]> git.llucax.com Git - z.facultad/75.52/sercom.git/blob - sercom/model.py
dbf342fe8635f8937b090c5169c6515011c4a5e8
[z.facultad/75.52/sercom.git] / sercom / model.py
1 # vim: set et sw=4 sts=4 encoding=utf-8 foldmethod=marker :
2
3 from datetime import datetime
4 from turbogears.database import PackageHub
5 from sqlobject import *
6 from sqlobject.sqlbuilder import *
7 from sqlobject.inheritance import InheritableSQLObject
8 from sqlobject.col import PickleValidator, UnicodeStringValidator
9 from turbogears import identity
10 from turbogears.identity import encrypt_password as encryptpw
11 from sercom.validators import params_to_list, ParseError
12 from formencode import Invalid
13
14 hub = PackageHub("sercom")
15 __connection__ = hub
16
17 __all__ = ('Curso', 'Usuario', 'Docente', 'Alumno', 'CasoDePrueba')
18
19 #{{{ Custom Columns
20
21 class TupleValidator(PickleValidator):
22     """
23     Validator for tuple types.  A tuple type is simply a pickle type
24     that validates that the represented type is a tuple.
25     """
26     def to_python(self, value, state):
27         value = super(TupleValidator, self).to_python(value, state)
28         if value is None:
29             return None
30         if isinstance(value, tuple):
31             return value
32         raise Invalid("expected a tuple in the TupleCol '%s', got %s %r instead" % \
33             (self.name, type(value), value), value, state)
34     def from_python(self, value, state):
35         if value is None:
36             return None
37         if not isinstance(value, tuple):
38             raise Invalid("expected a tuple in the TupleCol '%s', got %s %r instead" % \
39                 (self.name, type(value), value), value, state)
40         return super(TupleValidator, self).from_python(value, state)
41
42 class SOTupleCol(SOPickleCol):
43     def createValidators(self):
44         return [TupleValidator(name=self.name)]
45
46 class TupleCol(PickleCol):
47     baseClass = SOTupleCol
48
49 class ParamsValidator(UnicodeStringValidator):
50     def to_python(self, value, state):
51         if isinstance(value, basestring) or value is None:
52             value = super(ParamsValidator, self).to_python(value, state)
53             try:
54                 value = params_to_list(value)
55             except ParseError, e:
56                 raise Invalid("invalid parameters in the ParamsCol '%s', parse "
57                     "error: %s" % (self.name, e), value, state)
58         elif not isinstance(value, (list, tuple)):
59             raise Invalid("expected a tuple, list or valid string in the "
60                 "ParamsCol '%s', got %s %r instead"
61                     % (self.name, type(value), value), value, state)
62         return value
63     def from_python(self, value, state):
64         if isinstance(value, (list, tuple)):
65             value = ' '.join([repr(p) for p in value])
66         elif isinstance(value, basestring) or value is None:
67             value = super(ParamsValidator, self).to_python(value, state)
68             try:
69                 params_to_list(value)
70             except ParseError, e:
71                 raise Invalid("invalid parameters in the ParamsCol '%s', parse "
72                     "error: %s" % (self.name, e), value, state)
73         else:
74             raise Invalid("expected a tuple, list or valid string in the "
75                 "ParamsCol '%s', got %s %r instead"
76                     % (self.name, type(value), value), value, state)
77         return value
78
79 class SOParamsCol(SOUnicodeCol):
80     def createValidators(self):
81         return [ParamsValidator(db_encoding=self.dbEncoding, name=self.name)]
82
83 class ParamsCol(UnicodeCol):
84     baseClass = SOParamsCol
85
86 #}}}
87
88 #{{{ Clases
89
90 def srepr(obj): #{{{
91     if obj is not None:
92         return obj.shortrepr()
93     return obj
94 #}}}
95
96 class Curso(SQLObject): #{{{
97     # Clave
98     anio            = IntCol(notNone=True)
99     cuatrimestre    = IntCol(notNone=True)
100     numero          = IntCol(notNone=True)
101     pk              = DatabaseIndex(anio, cuatrimestre, numero, unique=True)
102     # Campos
103     descripcion     = UnicodeCol(length=255, default=None)
104     # Joins
105     docentes        = MultipleJoin('DocenteInscripto')
106     alumnos         = MultipleJoin('AlumnoInscripto')
107     grupos          = MultipleJoin('Grupo')
108     ejercicios      = MultipleJoin('Ejercicio', orderBy='numero')
109
110     def __init__(self, docentes=[], ejercicios=[], alumnos=[], **kw):
111         super(Curso, self).__init__(**kw)
112         for d in docentes:
113             self.add_docente(d)
114         for (n, e) in enumerate(ejercicios):
115             self.add_ejercicio(n, e)
116         for a in alumnos:
117             self.add_alumno(a)
118
119     def set(self, docentes=None, ejercicios=None, alumnos=None, **kw):
120         super(Curso, self).set(**kw)
121         if docentes is not None:
122             for d in DocenteInscripto.selectBy(curso=self):
123                 d.destroySelf()
124             for d in docentes:
125                 self.add_docente(d)
126         if ejercicios is not None:
127             for e in Ejercicio.selectBy(curso=self):
128                 e.destroySelf()
129             for (n, e) in enumerate(ejercicios):
130                 self.add_ejercicio(n+1, e)
131         if alumnos is not None:
132             for a in AlumnoInscripto.selectBy(curso=self):
133                 a.destroySelf()
134             for a in alumnos:
135                 self.add_alumno(a)
136
137     def add_docente(self, docente, **kw):
138         if isinstance(docente, Docente):
139             kw['docente'] = docente
140         else:
141             kw['docenteID'] = docente
142         return DocenteInscripto(curso=self, **kw)
143
144     def remove_docente(self, docente):
145         if isinstance(docente, Docente):
146             docente = docente.id
147         # FIXME esto deberian arreglarlo en SQLObject y debería ser
148         # DocenteInscripto.pk.get(self, docente).destroySelf()
149         DocenteInscripto.pk.get(self.id, docente).destroySelf()
150
151     def add_alumno(self, alumno, **kw):
152         if isinstance(alumno, Alumno):
153             kw['alumno'] = alumno
154         else:
155             kw['alumnoID'] = alumno
156         return AlumnoInscripto(curso=self, **kw)
157
158     def remove_alumno(self, alumno):
159         if isinstance(alumno, Alumno):
160             alumno = alumno.id
161         # FIXME esto deberian arreglarlo en SQLObject
162         AlumnoInscripto.pk.get(self.id, alumno).destroySelf()
163
164     def add_grupo(self, nombre, **kw):
165         return Grupo(curso=self, nombre=unicode(nombre), **kw)
166
167     def remove_grupo(self, nombre):
168         # FIXME esto deberian arreglarlo en SQLObject
169         Grupo.pk.get(self.id, nombre).destroySelf()
170
171     def add_ejercicio(self, numero, enunciado, **kw):
172         if isinstance(enunciado, Enunciado):
173             kw['enunciado'] = enunciado
174         else:
175             kw['enunciadoID'] = enunciado
176         return Ejercicio(curso=self, numero=numero, **kw)
177
178     def remove_ejercicio(self, numero):
179         # FIXME esto deberian arreglarlo en SQLObject
180         Ejercicio.pk.get(self.id, numero).destroySelf()
181
182     def __repr__(self):
183         return 'Curso(id=%s, anio=%s, cuatrimestre=%s, numero=%s, ' \
184             'descripcion=%s)' \
185                 % (self.id, self.anio, self.cuatrimestre, self.numero,
186                     self.descripcion)
187
188     def shortrepr(self):
189         return '%s.%s.%s' \
190             % (self.anio, self.cuatrimestre, self.numero)
191 #}}}
192
193 class Usuario(InheritableSQLObject): #{{{
194     # Clave (para docentes puede ser un nombre de usuario arbitrario)
195     usuario         = UnicodeCol(length=10, alternateID=True)
196     # Campos
197     contrasenia     = UnicodeCol(length=255, default=None)
198     nombre          = UnicodeCol(length=255, notNone=True)
199     email           = UnicodeCol(length=255, default=None)
200     telefono        = UnicodeCol(length=255, default=None)
201     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
202     observaciones   = UnicodeCol(default=None)
203     activo          = BoolCol(notNone=True, default=True)
204     # Joins
205     roles           = RelatedJoin('Rol', addRemoveName='_rol')
206
207     def __init__(self, password=None, roles=[], **kw):
208         if password is not None:
209             kw['contrasenia'] = encryptpw(password)
210         super(Usuario, self).__init__(**kw)
211         for r in roles:
212             self.add_rol(r)
213
214     def set(self, password=None, roles=None, **kw):
215         if password is not None:
216             kw['contrasenia'] = encryptpw(password)
217         super(Usuario, self).set(**kw)
218         if roles is not None:
219             for r in self.roles:
220                 self.remove_rol(r)
221             for r in roles:
222                 self.add_rol(r)
223
224     def _get_user_name(self): # para identity
225         return self.usuario
226
227     @classmethod
228     def by_user_name(cls, user_name): # para identity
229         user = cls.byUsuario(user_name)
230         if not user.activo:
231             raise SQLObjectNotFound(_(u'El %s está inactivo' % cls.__name__))
232         return user
233
234     def _get_groups(self): # para identity
235         return self.roles
236
237     def _get_permissions(self): # para identity
238         perms = set()
239         for r in self.roles:
240             perms.update(r.permisos)
241         return perms
242
243     _get_permisos = _get_permissions
244
245     def _set_password(self, cleartext_password): # para identity
246         self.contrasenia = encryptpw(cleartext_password)
247
248     def _get_password(self): # para identity
249         return self.contrasenia
250
251     def __repr__(self):
252         raise NotImplementedError(_(u'Clase abstracta!'))
253
254     def shortrepr(self):
255         return '%s (%s)' % (self.usuario, self.nombre)
256 #}}}
257
258 class Docente(Usuario): #{{{
259     _inheritable = False
260     # Campos
261     nombrado    = BoolCol(notNone=True, default=True)
262     # Joins
263     enunciados  = MultipleJoin('Enunciado', joinColumn='autor_id')
264     cursos      = MultipleJoin('DocenteInscripto')
265
266     def add_entrega(self, instancia, **kw):
267         return Entrega(instancia=instancia, **kw)
268
269     def add_enunciado(self, nombre, anio, cuatrimestre, **kw):
270         return Enunciado(nombre=nombre, anio=anio, cuatrimestre=cuatrimestre,
271             autor=self, **kw)
272
273     def remove_enunciado(self, nombre, anio, cuatrimestre):
274         Enunciado.pk.get(nombre, anio, cuatrimestre).destroySelf()
275
276     def __repr__(self):
277         return 'Docente(id=%s, usuario=%s, nombre=%s, password=%s, email=%s, ' \
278             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
279                 % (self.id, self.usuario, self.nombre, self.password,
280                     self.email, self.telefono, self.activo, self.creado,
281                     self.observaciones)
282 #}}}
283
284 class Alumno(Usuario): #{{{
285     _inheritable = False
286     # Campos
287     nota            = DecimalCol(size=3, precision=1, default=None)
288     # Joins
289     inscripciones   = MultipleJoin('AlumnoInscripto')
290
291     def __init__(self, padron=None, **kw):
292         if padron: kw['usuario'] = padron
293         super(Alumno, self).__init__(**kw)
294
295     def set(self, padron=None, **kw):
296         if padron: kw['usuario'] = padron
297         super(Alumno, self).set(**kw)
298
299     def _get_padron(self): # alias para poder referirse al alumno por padron
300         return self.usuario
301
302     def _set_padron(self, padron):
303         self.usuario = padron
304
305     @classmethod
306     def byPadron(cls, padron):
307         return cls.byUsuario(unicode(padron))
308
309     def __repr__(self):
310         return 'Alumno(id=%s, padron=%s, nombre=%s, password=%s, email=%s, ' \
311             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
312                 % (self.id, self.padron, self.nombre, self.password, self.email,
313                     self.telefono, self.activo, self.creado, self.observaciones)
314 #}}}
315
316 class Tarea(InheritableSQLObject): #{{{
317     # Clave
318     nombre              = UnicodeCol(length=30, alternateID=True)
319     # Campos
320     descripcion         = UnicodeCol(length=255, default=None)
321     terminar_si_falla   = BoolCol(notNone=True, default=True)
322     rechazar_si_falla   = BoolCol(notNone=True, default=True)
323     # Joins
324     enunciados          = RelatedJoin('Enunciado', addRemoveName='_enunciado')
325
326     def __repr__(self):
327         raise NotImplementedError('Tarea es una clase abstracta')
328
329     def shortrepr(self):
330         return self.nombre
331 #}}}
332
333 class TareaFuente(Tarea): #{{{
334     # Joins
335     comandos    = MultipleJoin('ComandoFuente', joinColumn='tarea_id')
336
337     def add_comando(self, orden, comando, **kw):
338         return ComandoFuente(tarea=self, orden=orden, comando=comando, **kw)
339
340     def remove_comando(self, orden):
341         ComandoFuente.pk.get(self.id, orden).destroySelf()
342
343     def __repr__(self):
344         return 'TareaFuente(id=%s, nombre=%s, descripcion=%s)' \
345                 % (self.id, self.nombre, self.descripcion)
346 #}}}
347
348 class TareaPrueba(Tarea): #{{{
349     # Joins
350     comandos    = MultipleJoin('ComandoPrueba', joinColumn='tarea_id')
351
352     def add_comando(self, orden, comando, **kw):
353         return ComandoPrueba(tarea=self, orden=orden, comando=comando, **kw)
354
355     def remove_comando(self, orden):
356         ComandoPrueba.pk.get(self.id, orden).destroySelf()
357
358     def __repr__(self):
359         return 'TareaPrueba(id=%s, nombre=%s, descripcion=%s)' \
360                 % (self.id, self.nombre, self.descripcion)
361 #}}}
362
363 class Comando(InheritableSQLObject): #{{{
364     RET_ANY = None
365     RET_FAIL = -1
366     # Campos
367     comando             = ParamsCol(length=255, notNone=True)
368     descripcion         = UnicodeCol(length=255, default=None)
369     retorno             = IntCol(default=None) # None es que no importa
370     max_tiempo_cpu      = IntCol(default=None) # En segundos
371     max_memoria         = IntCol(default=None) # En MB
372     max_tam_archivo     = IntCol(default=None) # En MB
373     max_cant_archivos   = IntCol(default=None)
374     max_cant_procesos   = IntCol(default=None)
375     max_locks_memoria   = IntCol(default=None)
376     terminar_si_falla   = BoolCol(notNone=True, default=True)
377     rechazar_si_falla   = BoolCol(notNone=True, default=True)
378     archivos_entrada    = BLOBCol(default=None) # ZIP con archivos de entrada
379                                                 # stdin es caso especial
380     archivos_salida     = BLOBCol(default=None) # ZIP con archivos de salida
381                                                 # stdout y stderr son especiales
382     activo              = BoolCol(notNone=True, default=True)
383
384     def __repr__(self, clave='', mas=''):
385         return ('%s(%s comando=%s, descripcion=%s, retorno=%s, '
386             'max_tiempo_cpu=%s, max_memoria=%s, max_tam_archivo=%s, '
387             'max_cant_archivos=%s, max_cant_procesos=%s, max_locks_memoria=%s, '
388             'terminar_si_falla=%s, rechazar_si_falla=%s%s)'
389                 % (self.__class__.__name__, clave, self.comando,
390                     self.descripcion, self.retorno, self.max_tiempo_cpu,
391                     self.max_memoria, self.max_tam_archivo,
392                     self.max_cant_archivos, self.max_cant_procesos,
393                     self.max_locks_memoria, self.terminar_si_falla,
394                     self.rechazar_si_falla))
395
396     def shortrepr(self):
397         return '%s (%s)' % (self.comando, self.descripcion)
398 #}}}
399
400 class ComandoFuente(Comando): #{{{
401     # Clave
402     tarea       = ForeignKey('TareaFuente', notNone=True, cascade=True)
403     orden       = IntCol(notNone=True)
404     pk          = DatabaseIndex(tarea, orden, unique=True)
405
406     def __repr__(self):
407         return super(ComandoFuente, self).__repr__('tarea=%s, orden=%s'
408             % (self.tarea.shortrepr(), self.orden))
409
410     def shortrepr(self):
411         return '%s:%s (%s)' % (self.tarea.shortrepr(), self.orden, self.comando)
412 #}}}
413
414 class ComandoPrueba(Comando): #{{{
415     RET_PRUEBA = -2 # Espera el mismo retorno que el de la prueba.
416     # XXX todos los campos de limitación en este caso son multiplicadores para
417     # los valores del caso de prueba.
418     # Clave
419     tarea               = ForeignKey('TareaPrueba', notNone=True, cascade=True)
420     orden               = IntCol(notNone=True)
421     pk                  = DatabaseIndex(tarea, orden, unique=True)
422
423     def __repr__(self):
424         return super(ComandoFuente, self).__repr__('tarea=%s, orden=%s'
425             % (self.tarea.shortrepr(), self.orden))
426
427     def shortrepr(self):
428         return '%s:%s (%s)' % (self.tarea.shortrepr(), self.orden, self.comando)
429 #}}}
430
431 class Enunciado(SQLObject): #{{{
432     # Clave
433     nombre          = UnicodeCol(length=60)
434     anio            = IntCol(notNone=True)
435     cuatrimestre    = IntCol(notNone=True)
436     pk              = DatabaseIndex(nombre, anio, cuatrimestre, unique=True)
437     # Campos
438     descripcion     = UnicodeCol(length=255, default=None)
439     autor           = ForeignKey('Docente', cascade='null')
440     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
441     archivo         = BLOBCol(default=None)
442     archivo_name    = UnicodeCol(length=255, default=None)
443     archivo_type    = UnicodeCol(length=255, default=None)
444     # Joins
445     ejercicios      = MultipleJoin('Ejercicio')
446     casos_de_prueba = MultipleJoin('CasoDePrueba')
447     tareas          = RelatedJoin('Tarea', addRemoveName='_tarea')
448
449     def __init__(self, tareas=[], **kw):
450         super(Enunciado, self).__init__(**kw)
451         for tarea in tareas:
452             self.add_tarea(tarea)
453
454     def set(self, tareas=None, **kw):
455         super(Enunciado, self).set(**kw)
456         if tareas is not None:
457             for tarea in self.tareas:
458                 self.remove_tarea(tarea)
459             for tarea in tareas:
460                 self.add_tarea(tarea)
461
462     @classmethod
463     def selectByCurso(self, curso):
464         return Enunciado.selectBy(cuatrimestre=curso.cuatrimestre, anio=curso.anio)
465
466     def add_caso_de_prueba(self, nombre, **kw):
467         return CasoDePrueba(enunciado=self, nombre=nombre, **kw)
468
469     def __repr__(self):
470         return 'Enunciado(id=%s, autor=%s, nombre=%s, descripcion=%s, ' \
471             'creado=%s)' \
472                 % (self.id, srepr(self.autor), self.nombre, self.descripcion, \
473                     self.creado)
474
475     def shortrepr(self):
476         return self.nombre
477 #}}}
478
479 class CasoDePrueba(Comando): #{{{
480     # Clave
481     enunciado           = ForeignKey('Enunciado', cascade=True)
482     nombre              = UnicodeCol(length=40, notNone=True)
483     pk                  = DatabaseIndex(enunciado, nombre, unique=True)
484     # Joins
485     pruebas             = MultipleJoin('Prueba')
486
487     def __repr__(self):
488         return super(ComandoFuente, self).__repr__('enunciado=%s, nombre=%s'
489             % (srepr(self.enunciado), self.nombre))
490
491     def shortrepr(self):
492         return '%s:%s' % (self.enunciado.shortrepr(), self.nombre)
493 #}}}
494
495 class Ejercicio(SQLObject): #{{{
496     # Clave
497     curso           = ForeignKey('Curso', notNone=True, cascade=True)
498     numero          = IntCol(notNone=True)
499     pk              = DatabaseIndex(curso, numero, unique=True)
500     # Campos
501     enunciado       = ForeignKey('Enunciado', notNone=True, cascade=False)
502     grupal          = BoolCol(default=False) # None es grupal o individual
503     # Joins
504     instancias      = MultipleJoin('InstanciaDeEntrega')
505
506     def add_instancia(self, numero, inicio, fin, **kw):
507         return InstanciaDeEntrega(ejercicio=self, numero=numero, inicio=inicio,
508             fin=fin, **kw)
509
510     def remove_instancia(self, numero):
511         # FIXME self.id
512         InstanciaDeEntrega.pk.get(self.id, numero).destroySelf()
513
514     def __repr__(self):
515         return 'Ejercicio(id=%s, curso=%s, numero=%s, enunciado=%s, ' \
516             'grupal=%s)' \
517                 % (self.id, self.curso.shortrepr(), self.numero,
518                     self.enunciado.shortrepr(), self.grupal)
519
520     def shortrepr(self):
521         return '(%s, %s, %s)' \
522             % (self.curso.shortrepr(), str(self.numero), \
523                 self.enunciado.shortrepr())
524 #}}}
525
526 class InstanciaDeEntrega(SQLObject): #{{{
527     # Clave
528     ejercicio       = ForeignKey('Ejercicio', notNone=True, cascade=True)
529     numero          = IntCol(notNone=True)
530     pk              = DatabaseIndex(ejercicio, numero, unique=True)
531     # Campos
532     inicio          = DateTimeCol(notNone=True)
533     fin             = DateTimeCol(notNone=True)
534     procesada       = BoolCol(notNone=True, default=False)
535     observaciones   = UnicodeCol(default=None)
536     activo          = BoolCol(notNone=True, default=True)
537     # Joins
538     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
539     correcciones    = MultipleJoin('Correccion', joinColumn='instancia_id')
540
541     def __repr__(self):
542         return 'InstanciaDeEntrega(id=%s, numero=%s, inicio=%s, fin=%s, ' \
543             'procesada=%s, observaciones=%s, activo=%s)' \
544                 % (self.id, self.numero, self.inicio, self.fin,
545                     self.procesada, self.observaciones, self.activo)
546
547     def shortrepr(self):
548         return self.numero
549 #}}}
550
551 class DocenteInscripto(SQLObject): #{{{
552     # Clave
553     curso           = ForeignKey('Curso', notNone=True, cascade=True)
554     docente         = ForeignKey('Docente', notNone=True, cascade=True)
555     pk              = DatabaseIndex(curso, docente, unique=True)
556     # Campos
557     corrige         = BoolCol(notNone=True, default=True)
558     observaciones   = UnicodeCol(default=None)
559     # Joins
560     alumnos         = MultipleJoin('AlumnoInscripto', joinColumn='tutor_id')
561     tutorias        = MultipleJoin('Tutor', joinColumn='docente_id')
562     correcciones    = MultipleJoin('Correccion', joinColumn='corrector_id')
563
564     def add_correccion(self, entrega, **kw):
565         return Correccion(instancia=entrega.instancia, entrega=entrega,
566             entregador=entrega.entregador, corrector=self, **kw)
567
568     def remove_correccion(self, instancia, entregador):
569         # FIXME instancia.id, entregador.id
570         Correccion.pk.get(instancia.id, entregador.id).destroySelf()
571
572     def __repr__(self):
573         return 'DocenteInscripto(id=%s, docente=%s, corrige=%s, ' \
574             'observaciones=%s' \
575                 % (self.id, self.docente.shortrepr(), self.corrige,
576                     self.observaciones)
577
578     def shortrepr(self):
579         return self.docente.shortrepr()
580 #}}}
581
582 class Entregador(InheritableSQLObject): #{{{
583     # Campos
584     nota            = DecimalCol(size=3, precision=1, default=None)
585     nota_cursada    = DecimalCol(size=3, precision=1, default=None)
586     observaciones   = UnicodeCol(notNone=True, default=u'')
587     activo          = BoolCol(notNone=True, default=True)
588     # Joins
589     entregas        = MultipleJoin('Entrega')
590     correcciones    = MultipleJoin('Correccion')
591
592     def add_entrega(self, instancia, **kw):
593         return Entrega(instancia=instancia, entregador=self, **kw)
594
595     def __repr__(self):
596         raise NotImplementedError, 'Clase abstracta!'
597 #}}}
598
599 class Grupo(Entregador): #{{{
600     _inheritable = False
601     # Clave
602     curso           = ForeignKey('Curso', notNone=True, cascade=True)
603     nombre          = UnicodeCol(length=20, notNone=True)
604     pk              = DatabaseIndex(curso, nombre, unique=True)
605     # Campos
606     responsable     = ForeignKey('AlumnoInscripto', default=None, cascade='null')
607     # Joins
608     miembros        = MultipleJoin('Miembro')
609     tutores         = MultipleJoin('Tutor')
610
611     def __init__(self, miembros=[], tutores=[], **kw):
612         super(Grupo, self).__init__(**kw)
613         for a in miembros:
614             self.add_miembro(a)
615         for d in tutores:
616             self.add_tutor(d)
617
618     def set(self, miembros=None, tutores=None, **kw):
619         super(Grupo, self).set(**kw)
620         if miembros is not None:
621             for m in Miembro.selectBy(grupo=self):
622                 m.destroySelf()
623             for m in miembros:
624                 self.add_miembro(m)
625         if tutores is not None:
626             for t in Tutor.selectBy(grupo=self):
627                 t.destroySelf()
628             for t in tutores:
629                 self.add_tutor(t)
630
631     _doc_alumnos = 'Devuelve una lista de AlumnoInscriptos **activos**.'
632     def _get_alumnos(self):
633         return list([m.alumno for m in Miembro.selectBy(grupo=self, baja=None)])
634
635     _doc_docentes = 'Devuelve una lista de DocenteInscriptos **activos**.'
636     def _get_docentes(self):
637         return list([t.docente for t in Tutor.selectBy(grupo=self, baja=None)])
638
639     def add_miembro(self, alumno, **kw):
640         if isinstance(alumno, AlumnoInscripto):
641             alumno = alumno.id
642         return Miembro(grupo=self, alumnoID=alumno, **kw)
643
644     def remove_miembro(self, alumno):
645         if isinstance(alumno, AlumnoInscripto):
646             alumno = alumno.id
647         m = Miembro.selectBy(grupo=self, alumnoID=alumno, baja=None).getOne()
648         m.baja = DateTimeCol.now()
649
650     def add_tutor(self, docente, **kw):
651         if isinstance(docente, DocenteInscripto):
652             docente = docente.id
653         return Tutor(grupo=self, docenteID=docente, **kw)
654
655     def remove_tutor(self, docente):
656         if isinstance(docente, DocenteInscripto):
657             docente = docente.id
658         t = Tutor.selectBy(grupo=self, docenteID=docente, baja=None)
659         t.baja = DateTimeCol.now()
660
661     def __repr__(self):
662         return 'Grupo(id=%s, nombre=%s, responsable=%s, nota=%s, ' \
663             'nota_cursada=%s, observaciones=%s, activo=%s)' \
664                 % (self.id, self.nombre, srepr(self.responsable), self.nota,
665                     self.nota_cursada, self.observaciones, self.activo)
666
667     def shortrepr(self):
668         return 'grupo:' + self.nombre
669 #}}}
670
671 class AlumnoInscripto(Entregador): #{{{
672     _inheritable = False
673     # Clave
674     curso               = ForeignKey('Curso', notNone=True, cascade=True)
675     alumno              = ForeignKey('Alumno', notNone=True, cascade=True)
676     pk                  = DatabaseIndex(curso, alumno, unique=True)
677     # Campos
678     condicional         = BoolCol(notNone=True, default=False)
679     tutor               = ForeignKey('DocenteInscripto', default=None, cascade='null')
680     # Joins
681     responsabilidades   = MultipleJoin('Grupo', joinColumn='responsable_id')
682     membresias          = MultipleJoin('Miembro', joinColumn='alumno_id')
683     entregas            = MultipleJoin('Entrega', joinColumn='alumno_id')
684     correcciones        = MultipleJoin('Correccion', joinColumn='alumno_id')
685
686     def _get_nombre(self):
687         return self.alumno.padron
688
689     def __repr__(self):
690         return 'AlumnoInscripto(id=%s, alumno=%s, condicional=%s, nota=%s, ' \
691             'nota_cursada=%s, tutor=%s, observaciones=%s, activo=%s)' \
692                 % (self.id, self.alumno.shortrepr(), self.condicional,
693                     self.nota, self.nota_cursada, srepr(self.tutor),
694                     self.observaciones, self.activo)
695
696     def shortrepr(self):
697         return self.alumno.shortrepr()
698 #}}}
699
700 class Tutor(SQLObject): #{{{
701     # Clave
702     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
703     docente         = ForeignKey('DocenteInscripto', notNone=True, cascade=True)
704     pk              = DatabaseIndex(grupo, docente, unique=True)
705     # Campos
706     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
707     baja            = DateTimeCol(default=None)
708
709     def __repr__(self):
710         return 'Tutor(docente=%s, grupo=%s, alta=%s, baja=%s)' \
711                 % (self.docente.shortrepr(), self.grupo.shortrepr(),
712                     self.alta, self.baja)
713
714     def shortrepr(self):
715         return '%s-%s' % (self.docente.shortrepr(), self.grupo.shortrepr())
716 #}}}
717
718 class Miembro(SQLObject): #{{{
719     # Clave
720     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
721     alumno          = ForeignKey('AlumnoInscripto', notNone=True, cascade=True)
722     pk              = DatabaseIndex(grupo, alumno, unique=True)
723     # Campos
724     nota            = DecimalCol(size=3, precision=1, default=None)
725     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
726     baja            = DateTimeCol(default=None)
727
728     def __repr__(self):
729         return 'Miembro(alumno=%s, grupo=%s, nota=%s, alta=%s, baja=%s)' \
730                 % (self.alumno.shortrepr(), self.grupo.shortrepr(),
731                     self.nota, self.alta, self.baja)
732
733     def shortrepr(self):
734         return '%s-%s' % (self.alumno.shortrepr(), self.grupo.shortrepr())
735 #}}}
736
737 class Entrega(SQLObject): #{{{
738     # Clave
739     instancia           = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
740     entregador          = ForeignKey('Entregador', default=None, cascade=False) # Si es None era un Docente
741     fecha               = DateTimeCol(notNone=True, default=DateTimeCol.now)
742     pk                  = DatabaseIndex(instancia, entregador, fecha, unique=True)
743     # Campos
744     archivos            = BLOBCol(notNone=True) # ZIP con fuentes de la entrega
745     correcta            = BoolCol(default=None) # None es que no se sabe qué pasó
746     inicio_tareas       = DateTimeCol(default=None) # Si es None no se procesó
747     fin_tareas          = DateTimeCol(default=None) # Si es None pero inicio no, se está procesando
748     observaciones       = UnicodeCol(notNone=True, default=u'')
749     # Joins
750     comandos_ejecutados = MultipleJoin('ComandoFuenteEjecutado')
751     pruebas             = MultipleJoin('Prueba')
752
753     def add_comando_ejecutado(self, comando, **kw):
754         return ComandoFuenteEjecutado(entrega=self, comando=comando, **kw)
755
756     def remove_comando_ejecutado(self, comando):
757         if isinstance(comando, ComandoFuente):
758             comando = comando.id
759         # FIXME self.id
760         ComandoFuenteEjecutado.pk.get(self.id, comando).destroySelf()
761
762     def add_prueba(self, caso_de_prueba, **kw):
763         return Prueba(entrega=self, caso_de_prueba=caso_de_prueba, **kw)
764
765     def remove_prueba(self, caso_de_prueba):
766         if isinstance(caso_de_prueba, CasoDePrueba):
767             caso_de_prueba = caso_de_prueba.id
768         # FIXME self.id, caso_de_prueba
769         Prueba.pk.get(self.id, caso_de_prueba).destroySelf()
770
771     def __repr__(self):
772         return 'Entrega(id=%s, instancia=%s, entregador=%s, fecha=%s, ' \
773             'correcta=%s, inicio_tareas=%s, fin_tareas=%s, observaciones=%s)' \
774                 % (self.id, self.instancia.shortrepr(), srepr(self.entregador),
775                     self.fecha, self.inicio_tareas, self.fin_tareas,
776                     self.correcta, self.observaciones)
777
778     def shortrepr(self):
779         return '%s-%s-%s' % (self.instancia.shortrepr(),
780             srepr(self.entregador), self.fecha)
781 #}}}
782
783 class Correccion(SQLObject): #{{{
784     # Clave
785     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
786     entregador      = ForeignKey('Entregador', notNone=True, cascade=False) # Docente no tiene
787     pk              = DatabaseIndex(instancia, entregador, unique=True)
788     # Campos
789     entrega         = ForeignKey('Entrega', notNone=True, cascade=False)
790     corrector       = ForeignKey('DocenteInscripto', default=None, cascade='null')
791     asignado        = DateTimeCol(notNone=True, default=DateTimeCol.now)
792     corregido       = DateTimeCol(default=None)
793     nota            = DecimalCol(size=3, precision=1, default=None)
794     observaciones   = UnicodeCol(default=None)
795
796     def _get_entregas(self):
797         return list(Entrega.selectBy(instancia=self.instancia, entregador=self.entregador))
798
799     def __repr__(self):
800         return 'Correccion(instancia=%s, entregador=%s, entrega=%s, ' \
801             'corrector=%s, asignado=%s, corregido=%s, nota=%s, ' \
802             'observaciones=%s)' \
803                 % (self.instancia.shortrepr(), self.entregador.shortrepr(),
804                     self.entrega.shortrepr(), self.corrector, self.asignado,
805                     self.corregido, self.nota, self.observaciones)
806
807     def shortrepr(self):
808         if not self.corrector:
809             return '%s' % self.entrega.shortrepr()
810         return '%s,%s' % (self.entrega.shortrepr(), self.corrector.shortrepr())
811 #}}}
812
813 class ComandoEjecutado(InheritableSQLObject): #{{{
814     # Campos
815     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
816     fin             = DateTimeCol(default=None)
817     exito           = IntCol(default=None)
818     observaciones   = UnicodeCol(notNone=True, default=u'')
819
820     def __repr__(self):
821         raise NotImplementedError('ComandoEjecutado es una clase abstracta')
822 #}}}
823
824 class ComandoFuenteEjecutado(ComandoEjecutado): #{{{
825     # Clave
826     comando = ForeignKey('ComandoFuente', notNone=True, cascade=False)
827     entrega = ForeignKey('Entrega', notNone=True, cascade=False)
828     pk      = DatabaseIndex(comando, entrega, unique=True)
829
830     def __repr__(self):
831         return 'ComandoFuenteEjecutado(comando=%s, entrega=%s, inicio=%s, ' \
832             'fin=%s, exito=%s, observaciones=%s)' \
833                 % (self.comando.shortrepr(), self.entrega.shortrepr(),
834                     self.inicio, self.fin, self.exito, self.observaciones)
835
836     def shortrepr(self):
837         return '%s-%s' % (self.tarea.shortrepr(), self.entrega.shortrepr())
838 #}}}
839
840 class ComandoPruebaEjecutado(ComandoEjecutado): #{{{
841     # Clave
842     comando = ForeignKey('ComandoPrueba', notNone=True, cascade=False)
843     prueba  = ForeignKey('Prueba', notNone=True, cascade=False)
844     pk      = DatabaseIndex(comando, prueba, unique=True)
845
846     def __repr__(self):
847         return 'ComandoPruebaEjecutado(comando=%s, prueba=%s, inicio=%s, ' \
848             'fin=%s, exito=%s, observaciones=%s)' \
849                 % (self.comando.shortrepr(), self.prueba.shortrepr(),
850                     self.inicio, self.fin, self.exito, self.observaciones)
851
852     def shortrepr(self):
853         return '%s:%s:%s' % (self.tarea.shortrepr(), self.entrega.shortrepr(),
854             self.caso_de_prueba.shortrepr())
855 #}}}
856
857 class Prueba(SQLObject): #{{{
858     # Clave
859     entrega             = ForeignKey('Entrega', notNone=True, cascade=False)
860     caso_de_prueba      = ForeignKey('CasoDePrueba', notNone=True, cascade=False)
861     pk                  = DatabaseIndex(entrega, caso_de_prueba, unique=True)
862     # Campos
863     inicio              = DateTimeCol(notNone=True, default=DateTimeCol.now)
864     fin                 = DateTimeCol(default=None)
865     pasada              = IntCol(default=None)
866     observaciones       = UnicodeCol(notNone=True, default=u'')
867     # Joins
868     comandos_ejecutados = MultipleJoin('ComandoPruebaEjecutado')
869
870     def add_comando_ejecutado(self, comando, **kw):
871         if isinstance(comando, ComandoPrueba):
872             comando = comando.id
873         return ComandoPruebaEjecutado(prueba=self, comandoID=comando, **kw)
874
875     def remove_comando_ejecutado(self, comando):
876         if isinstance(comando, ComandoPrueba):
877             comando = comando.id
878         # FIXME self.id, comando.id
879         ComandoPruebaEjecutado.pk.get(self.id, comando).destroySelf()
880
881     def __repr__(self):
882         return 'Prueba(entrega=%s, caso_de_prueba=%s, inicio=%s, fin=%s, ' \
883             'pasada=%s, observaciones=%s)' \
884                 % (self.entrega.shortrepr(), self.caso_de_prueba.shortrepr(),
885                 self.inicio, self.fin, self.pasada, self.observaciones)
886
887     def shortrepr(self):
888         return '%s:%s' % (self.entrega.shortrepr(),
889             self.caso_de_prueba.shortrepr())
890 #}}}
891
892 #{{{ Específico de Identity
893
894 class Visita(SQLObject): #{{{
895     visit_key   = StringCol(length=40, alternateID=True,
896                     alternateMethodName="by_visit_key")
897     created     = DateTimeCol(notNone=True, default=datetime.now)
898     expiry      = DateTimeCol()
899
900     @classmethod
901     def lookup_visit(cls, visit_key):
902         try:
903             return cls.by_visit_key(visit_key)
904         except SQLObjectNotFound:
905             return None
906 #}}}
907
908 class VisitaUsuario(SQLObject): #{{{
909     # Clave
910     visit_key   = StringCol(length=40, alternateID=True,
911                           alternateMethodName="by_visit_key")
912     # Campos
913     user_id     = IntCol() # Negrada de identity
914 #}}}
915
916 class Rol(SQLObject): #{{{
917     # Clave
918     nombre      = UnicodeCol(length=255, alternateID=True,
919                     alternateMethodName='by_nombre')
920     # Campos
921     descripcion = UnicodeCol(length=255, default=None)
922     creado      = DateTimeCol(notNone=True, default=datetime.now)
923     permisos    = TupleCol(notNone=True)
924     # Joins
925     usuarios    = RelatedJoin('Usuario', addRemoveName='_usuario')
926
927     def by_group_name(self, name): # para identity
928         return self.by_nombre(name)
929 #}}}
930
931 # No es un SQLObject porque no tiene sentido agregar/sacar permisos, están
932 # hardcodeados en el código
933 class Permiso(object): #{{{
934     max_valor = 1
935     def __init__(self, nombre, descripcion):
936         self.valor = Permiso.max_valor
937         Permiso.max_valor <<= 1
938         self.nombre = nombre
939         self.descripcion = descripcion
940
941     @classmethod
942     def createTable(cls, ifNotExists): # para identity
943         pass
944
945     @property
946     def permission_name(self): # para identity
947         return self.nombre
948
949     def __and__(self, other):
950         return self.valor & other.valor
951
952     def __or__(self, other):
953         return self.valor | other.valor
954
955     def __repr__(self):
956         return self.nombre
957 #}}}
958
959 # TODO ejemplos
960 entregar_tp = Permiso(u'entregar', u'Permite entregar trabajos prácticos')
961 admin = Permiso(u'admin', u'Permite hacer ABMs arbitrarios')
962
963 #}}} Identity
964
965 #}}} Clases
966