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