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, comando='', **kw):
 316         return ComandoPrueba(tarea=self, orden=orden, comando=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     publico             = BoolCol(notNone=True, default=True)
 349     archivos_entrada    = BLOBCol(default=None) # ZIP con archivos de entrada
 350                                                 # __stdin__ es caso especial
 351                                                 # Si un caso de prueba tiene
 352                                                 # comandos que tiene algún
 353                                                 # archivo de entrada (incluyendo
 354                                                 # stdin) con los propios, se usa
 355                                                 # el archivo del caso de prueba,
 356                                                 # no del comando.
 357     archivos_a_comparar = BLOBCol(default=None) # ZIP con archivos de salida
 358                                                 # __stdout__, __stderr__ y
 359                                                 # __stdouterr__ (ambos juntos)
 360                                                 # son casos especiales
 361                                                 # Si un caso de prueba tiene
 362                                                 # comandos que tiene algún
 363                                                 # archivo a comparar (incluyendo
 364                                                 # stdout/err) con los propios,
 365                                                 # se compara contra el archivo
 366                                                 # del caso de prueba, no del
 367                                                 # comando.
 368     archivos_a_guardar  = TupleCol(notNone=True, default=()) # TODO FrozenSetCol
 369                                                 # __stdout__, __stderr__ y
 370                                                 # __stdouterr__ (ambos juntos)
 371                                                 # son casos especiales
 372     activo              = BoolCol(notNone=True, default=True)
 373
 374     def __repr__(self, clave='', mas=''):
 375         return ('%s(%s comando=%s, descripcion=%s, retorno=%s, '
 376             'max_tiempo_cpu=%s, max_memoria=%s, max_tam_archivo=%s, '
 377             'max_cant_archivos=%s, max_cant_procesos=%s, max_locks_memoria=%s, '
 378             'terminar_si_falla=%s, rechazar_si_falla=%s%s)'
 379                 % (self.__class__.__name__, clave, self.comando,
 380                     self.descripcion, self.retorno, self.max_tiempo_cpu,
 381                     self.max_memoria, self.max_tam_archivo,
 382                     self.max_cant_archivos, self.max_cant_procesos,
 383                     self.max_locks_memoria, self.terminar_si_falla,
 384                     self.rechazar_si_falla, mas))
 385
 386     def shortrepr(self):
 387         return '%s (%s)' % (self.comando, self.descripcion)
 388 #}}}
 389
 390 class ComandoFuente(Comando): #{{{
 391     _inheritable = False
 392     # Clave
 393     tarea       = ForeignKey('TareaFuente', notNone=True, cascade=True)
 394     orden       = IntCol(notNone=True)
 395     pk          = DatabaseIndex(tarea, orden, unique=True)
 396
 397     def __repr__(self):
 398         return super(ComandoFuente, self).__repr__('tarea=%s, orden=%s'
 399             % (self.tarea.shortrepr(), self.orden))
 400
 401     def shortrepr(self):
 402         return '%s:%s (%s)' % (self.tarea.shortrepr(), self.orden, self.comando)
 403 #}}}
 404
 405 class ComandoPrueba(Comando): #{{{
 406     _inheritable = False
 407     RET_PRUEBA = -257 # Espera el mismo retorno que el de la prueba.
 408     # XXX todos los campos de limitación en este caso son multiplicadores para
 409     # los valores del caso de prueba.
 410     # Clave
 411     tarea               = ForeignKey('TareaPrueba', notNone=True, cascade=True)
 412     orden               = IntCol(notNone=True)
 413     pk                  = DatabaseIndex(tarea, orden, unique=True)
 414
 415     def __repr__(self):
 416         return super(ComandoPrueba, self).__repr__('tarea=%s, orden=%s'
 417             % (self.tarea.shortrepr(), self.orden))
 418
 419     def shortrepr(self):
 420         return '%s:%s (%s)' % (self.tarea.shortrepr(), self.orden, self.comando)
 421 #}}}
 422
 423 class Enunciado(SQLObject): #{{{
 424     # Clave
 425     nombre          = UnicodeCol(length=60)
 426     anio            = IntCol(notNone=True)
 427     cuatrimestre    = IntCol(notNone=True)
 428     pk              = DatabaseIndex(nombre, anio, cuatrimestre, unique=True)
 429     # Campos
 430     descripcion     = UnicodeCol(length=255, default=None)
 431     autor           = ForeignKey('Docente', cascade='null')
 432     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 433     archivo         = BLOBCol(default=None)
 434     archivo_name    = UnicodeCol(length=255, default=None)
 435     archivo_type    = UnicodeCol(length=255, default=None)
 436     # Joins
 437     ejercicios      = MultipleJoin('Ejercicio')
 438     casos_de_prueba = MultipleJoin('CasoDePrueba')
 439     tareas          = RelatedJoin('Tarea', addRemoveName='_tarea')
 440
 441     def __init__(self, tareas=[], **kw):
 442         super(Enunciado, self).__init__(**kw)
 443         for tarea in tareas:
 444             self.add_tarea(tarea)
 445
 446     def set(self, tareas=None, **kw):
 447         super(Enunciado, self).set(**kw)
 448         if tareas is not None:
 449             for tarea in self.tareas:
 450                 self.remove_tarea(tarea)
 451             for tarea in tareas:
 452                 self.add_tarea(tarea)
 453
 454     @classmethod
 455     def selectByCurso(self, curso):
 456         return Enunciado.selectBy(cuatrimestre=curso.cuatrimestre, anio=curso.anio)
 457
 458     def add_caso_de_prueba(self, nombre, **kw):
 459         return CasoDePrueba(enunciado=self, nombre=nombre, **kw)
 460
 461     def __repr__(self):
 462         return 'Enunciado(id=%s, autor=%s, nombre=%s, descripcion=%s, ' \
 463             'creado=%s)' \
 464                 % (self.id, srepr(self.autor), self.nombre, self.descripcion, \
 465                     self.creado)
 466
 467     def shortrepr(self):
 468         return self.nombre
 469 #}}}
 470
 471 class CasoDePrueba(Comando): #{{{
 472     _inheritable = False
 473     # Clave
 474     enunciado           = ForeignKey('Enunciado', cascade=True)
 475     nombre              = UnicodeCol(length=40, notNone=True)
 476     pk                  = DatabaseIndex(enunciado, nombre, unique=True)
 477     # Joins
 478     pruebas             = MultipleJoin('Prueba')
 479
 480     def __repr__(self):
 481         return super(CasoDePrueba, self).__repr__('enunciado=%s, nombre=%s'
 482             % (srepr(self.enunciado), self.nombre))
 483
 484     def shortrepr(self):
 485         return '%s:%s' % (self.enunciado.shortrepr(), self.nombre)
 486 #}}}
 487
 488 class Ejercicio(SQLObject): #{{{
 489     # Clave
 490     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 491     numero          = IntCol(notNone=True)
 492     pk              = DatabaseIndex(curso, numero, unique=True)
 493     # Campos
 494     enunciado       = ForeignKey('Enunciado', notNone=True, cascade=False)
 495     grupal          = BoolCol(default=False) # None es grupal o individual
 496     # Joins
 497     instancias      = MultipleJoin('InstanciaDeEntrega')
 498
 499     def add_instancia(self, numero, inicio, fin, **kw):
 500         return InstanciaDeEntrega(ejercicio=self, numero=numero, inicio=inicio,
 501             fin=fin, **kw)
 502
 503     def remove_instancia(self, numero):
 504         # FIXME self.id
 505         InstanciaDeEntrega.pk.get(self.id, numero).destroySelf()
 506
 507     def __repr__(self):
 508         return 'Ejercicio(id=%s, curso=%s, numero=%s, enunciado=%s, ' \
 509             'grupal=%s)' \
 510                 % (self.id, self.curso.shortrepr(), self.numero,
 511                     self.enunciado.shortrepr(), self.grupal)
 512
 513     def shortrepr(self):
 514         return '(%s, %s, %s)' \
 515             % (self.curso.shortrepr(), str(self.numero), \
 516                 self.enunciado.shortrepr())
 517 #}}}
 518
 519 class InstanciaDeEntrega(SQLObject): #{{{
 520     # Clave
 521     ejercicio       = ForeignKey('Ejercicio', notNone=True, cascade=True)
 522     numero          = IntCol(notNone=True)
 523     pk              = DatabaseIndex(ejercicio, numero, unique=True)
 524     # Campos
 525     inicio          = DateTimeCol(notNone=True)
 526     fin             = DateTimeCol(notNone=True)
 527     inicio_proceso  = DateTimeCol(default=None)
 528     fin_proceso     = DateTimeCol(default=None)
 529     observaciones   = UnicodeCol(default=None)
 530     activo          = BoolCol(notNone=True, default=True)
 531     # Joins
 532     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
 533     correcciones    = MultipleJoin('Correccion', joinColumn='instancia_id')
 534
 535     def __repr__(self):
 536         return 'InstanciaDeEntrega(id=%s, numero=%s, inicio=%s, fin=%s, ' \
 537             'inicio_proceso=%s, fin_proceso=%s, observaciones=%s, activo=%s)' \
 538                 % (self.id, self.numero, self.inicio, self.fin,
 539                     self.inicio_proceso, self.fin_proceso, self.observaciones,
 540                     self.activo)
 541
 542     def shortrepr(self):
 543         return self.numero
 544 #}}}
 545
 546 class DocenteInscripto(SQLObject): #{{{
 547     # Clave
 548     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 549     docente         = ForeignKey('Docente', notNone=True, cascade=True)
 550     pk              = DatabaseIndex(curso, docente, unique=True)
 551     # Campos
 552     corrige         = BoolCol(notNone=True, default=True)
 553     observaciones   = UnicodeCol(default=None)
 554     # Joins
 555     alumnos         = MultipleJoin('AlumnoInscripto', joinColumn='tutor_id')
 556     tutorias        = MultipleJoin('Tutor', joinColumn='docente_id')
 557     correcciones    = MultipleJoin('Correccion', joinColumn='corrector_id')
 558
 559     def add_correccion(self, entrega, **kw):
 560         return Correccion(instancia=entrega.instancia, entrega=entrega,
 561             entregador=entrega.entregador, corrector=self, **kw)
 562
 563     def remove_correccion(self, instancia, entregador):
 564         # FIXME instancia.id, entregador.id
 565         Correccion.pk.get(instancia.id, entregador.id).destroySelf()
 566
 567     def __repr__(self):
 568         return 'DocenteInscripto(id=%s, docente=%s, corrige=%s, ' \
 569             'observaciones=%s' \
 570                 % (self.id, self.docente.shortrepr(), self.corrige,
 571                     self.observaciones)
 572
 573     def shortrepr(self):
 574         return self.docente.shortrepr()
 575 #}}}
 576
 577 class Entregador(InheritableSQLObject): #{{{
 578     # Campos
 579     nota            = DecimalCol(size=3, precision=1, default=None)
 580     nota_cursada    = DecimalCol(size=3, precision=1, default=None)
 581     observaciones   = UnicodeCol(notNone=True, default=u'')
 582     activo          = BoolCol(notNone=True, default=True)
 583     # Joins
 584     entregas        = MultipleJoin('Entrega')
 585     correcciones    = MultipleJoin('Correccion')
 586
 587     def add_entrega(self, instancia, **kw):
 588         return Entrega(instancia=instancia, entregador=self, **kw)
 589
 590     def __repr__(self):
 591         raise NotImplementedError, 'Clase abstracta!'
 592 #}}}
 593
 594 class Grupo(Entregador): #{{{
 595     _inheritable = False
 596     # Clave
 597     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 598     nombre          = UnicodeCol(length=20, notNone=True)
 599     pk              = DatabaseIndex(curso, nombre, unique=True)
 600     # Campos
 601     responsable     = ForeignKey('AlumnoInscripto', default=None, cascade='null')
 602     # Joins
 603     miembros        = MultipleJoin('Miembro')
 604     tutores         = MultipleJoin('Tutor')
 605
 606     def __init__(self, miembros=[], tutores=[], **kw):
 607         super(Grupo, self).__init__(**kw)
 608         for a in miembros:
 609             self.add_miembro(a)
 610         for d in tutores:
 611             self.add_tutor(d)
 612
 613     def set(self, miembros=None, tutores=None, **kw):
 614         super(Grupo, self).set(**kw)
 615         if miembros is not None:
 616             for m in Miembro.selectBy(grupo=self):
 617                 m.destroySelf()
 618             for m in miembros:
 619                 self.add_miembro(m)
 620         if tutores is not None:
 621             for t in Tutor.selectBy(grupo=self):
 622                 t.destroySelf()
 623             for t in tutores:
 624                 self.add_tutor(t)
 625
 626     _doc_alumnos = 'Devuelve una lista de AlumnoInscriptos **activos**.'
 627     def _get_alumnos(self):
 628         return list([m.alumno for m in Miembro.selectBy(grupo=self, baja=None)])
 629
 630     _doc_docentes = 'Devuelve una lista de DocenteInscriptos **activos**.'
 631     def _get_docentes(self):
 632         return list([t.docente for t in Tutor.selectBy(grupo=self, baja=None)])
 633
 634     def add_miembro(self, alumno, **kw):
 635         if isinstance(alumno, AlumnoInscripto):
 636             alumno = alumno.id
 637         # FIXME acá habría que sacarle la unicidad a Miembro.pk para que
 638         # un alumno pueda ser miembro varias veces del mismo grupo, de
 639         # manera de tener la historia completa, pero hay que tener cuidad
 640         # y arreglar todos los lugares donde se asume esa unicidad
 641         try:
 642             m = Miembro.selectBy(grupo=self, alumnoID=alumno).getOne()
 643             m.baja = None # si ya existía, le sacamos la fecha de baja
 644             return m
 645         except SQLObjectNotFound: # creo uno nuevo
 646             return Miembro(grupo=self, alumnoID=alumno, **kw)
 647
 648     def remove_miembro(self, alumno):
 649         if isinstance(alumno, AlumnoInscripto):
 650             alumno = alumno.id
 651         m = Miembro.selectBy(grupo=self, alumnoID=alumno, baja=None).getOne()
 652         m.baja = DateTimeCol.now()
 653
 654     def add_tutor(self, docente, **kw):
 655         if isinstance(docente, DocenteInscripto):
 656             docente = docente.id
 657         # FIXME ídem add_miembro()
 658         try:
 659             t = Tutor.selectBy(grupo=self, docenteID=alumno).getOne()
 660             t.baja = None # si ya existía, le sacamos la fecha de baja
 661             return t
 662         except SQLObjectNotFound: # creo uno nuevo
 663             return Tutor(grupo=self, docenteID=docente, **kw)
 664
 665     def remove_tutor(self, docente):
 666         if isinstance(docente, DocenteInscripto):
 667             docente = docente.id
 668         t = Tutor.selectBy(grupo=self, docenteID=docente, baja=None)
 669         t.baja = DateTimeCol.now()
 670
 671     def __repr__(self):
 672         return 'Grupo(id=%s, nombre=%s, responsable=%s, nota=%s, ' \
 673             'nota_cursada=%s, observaciones=%s, activo=%s)' \
 674                 % (self.id, self.nombre, srepr(self.responsable), self.nota,
 675                     self.nota_cursada, self.observaciones, self.activo)
 676
 677     @classmethod
 678     def selectByAlumno(self, alumno):
 679         return Miembro.select(AND(Miembro.q.alumnoID == AlumnoInscripto.q.id,
 680                 AlumnoInscripto.q.alumnoID == alumno.id, Miembro.q.baja == None))
 681
 682     def shortrepr(self):
 683         return 'grupo:' + self.nombre
 684 #}}}
 685
 686 class AlumnoInscripto(Entregador): #{{{
 687     _inheritable = False
 688     # Clave
 689     curso               = ForeignKey('Curso', notNone=True, cascade=True)
 690     alumno              = ForeignKey('Alumno', notNone=True, cascade=True)
 691     pk                  = DatabaseIndex(curso, alumno, unique=True)
 692     # Campos
 693     condicional         = BoolCol(notNone=True, default=False)
 694     tutor               = ForeignKey('DocenteInscripto', default=None, cascade='null')
 695     # Joins
 696     responsabilidades   = MultipleJoin('Grupo', joinColumn='responsable_id')
 697     membresias          = MultipleJoin('Miembro', joinColumn='alumno_id')
 698     entregas            = MultipleJoin('Entrega', joinColumn='alumno_id')
 699     correcciones        = MultipleJoin('Correccion', joinColumn='alumno_id')
 700     # Notas de la cursada
 701     nota_practica       = DecimalCol(size=3, precision=1, default=None)
 702     nota_final          = DecimalCol(size=3, precision=1, default=None)
 703     nota_libreta        = DecimalCol(size=3, precision=1, default=None)
 704
 705     def _get_nombre(self):
 706         return self.alumno.padron
 707
 708     @classmethod
 709     def selectByAlumno(self, alumno):
 710         return AlumnoInscripto.select(AlumnoInscripto.q.alumnoID == alumno.id).getOne()
 711
 712     def __repr__(self):
 713         return 'AlumnoInscripto(id=%s, alumno=%s, condicional=%s, nota=%s, ' \
 714             'nota_cursada=%s, tutor=%s, observaciones=%s, activo=%s)' \
 715                 % (self.id, self.alumno.shortrepr(), self.condicional,
 716                     self.nota, self.nota_cursada, srepr(self.tutor),
 717                     self.observaciones, self.activo)
 718
 719     def shortrepr(self):
 720         return self.alumno.shortrepr()
 721 #}}}
 722
 723 class Tutor(SQLObject): #{{{
 724     # Clave
 725     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
 726     docente         = ForeignKey('DocenteInscripto', notNone=True, cascade=True)
 727     pk              = DatabaseIndex(grupo, docente, unique=True)
 728     # Campos
 729     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 730     baja            = DateTimeCol(default=None)
 731
 732     def __repr__(self):
 733         return 'Tutor(docente=%s, grupo=%s, alta=%s, baja=%s)' \
 734                 % (self.docente.shortrepr(), self.grupo.shortrepr(),
 735                     self.alta, self.baja)
 736
 737     def shortrepr(self):
 738         return '%s-%s' % (self.docente.shortrepr(), self.grupo.shortrepr())
 739 #}}}
 740
 741 class Miembro(SQLObject): #{{{
 742     # Clave
 743     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
 744     alumno          = ForeignKey('AlumnoInscripto', notNone=True, cascade=True)
 745     pk              = DatabaseIndex(grupo, alumno, unique=True)
 746     # Campos
 747     nota            = DecimalCol(size=3, precision=1, default=None)
 748     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 749     baja            = DateTimeCol(default=None)
 750
 751     def __repr__(self):
 752         return 'Miembro(alumno=%s, grupo=%s, nota=%s, alta=%s, baja=%s)' \
 753                 % (self.alumno.shortrepr(), self.grupo.shortrepr(),
 754                     self.nota, self.alta, self.baja)
 755
 756     def shortrepr(self):
 757         return '%s-%s' % (self.alumno.shortrepr(), self.grupo.shortrepr())
 758 #}}}
 759
 760 class Ejecucion(InheritableSQLObject): #{{{
 761     # Campos
 762     inicio          = DateTimeCol(default=None)
 763     fin             = DateTimeCol(default=None)
 764     exito           = IntCol(default=None)
 765     observaciones   = UnicodeCol(notNone=True, default=u'')
 766     archivos        = BLOBCol(default=None) # ZIP con archivos
 767
 768     def __repr__(self, clave='', mas=''):
 769         return ('%s(%s inicio=%s, fin=%s, exito=%s, observaciones=%s%s)'
 770             % (self.__class__.__name__, clave, self.inicio, self.fin,
 771             self.exito, self.observaciones, mas))
 772 #}}}
 773
 774 class Entrega(Ejecucion): #{{{
 775     _inheritable = False
 776     # Clave
 777     instancia           = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
 778     entregador          = ForeignKey('Entregador', default=None, cascade=False) # Si es None era un Docente
 779     fecha               = DateTimeCol(notNone=True, default=DateTimeCol.now)
 780     pk                  = DatabaseIndex(instancia, entregador, fecha, unique=True)
 781     # Joins
 782     comandos_ejecutados = MultipleJoin('ComandoFuenteEjecutado')
 783     pruebas             = MultipleJoin('Prueba')
 784
 785     def add_comando_ejecutado(self, comando, **kw):
 786         return ComandoFuenteEjecutado(entrega=self, comando=comando, **kw)
 787
 788     def remove_comando_ejecutado(self, comando):
 789         if isinstance(comando, ComandoFuente):
 790             comando = comando.id
 791         # FIXME self.id
 792         ComandoFuenteEjecutado.pk.get(self.id, comando).destroySelf()
 793
 794     def add_prueba(self, caso_de_prueba, **kw):
 795         return Prueba(entrega=self, caso_de_prueba=caso_de_prueba, **kw)
 796
 797     def remove_prueba(self, caso_de_prueba):
 798         if isinstance(caso_de_prueba, CasoDePrueba):
 799             caso_de_prueba = caso_de_prueba.id
 800         # FIXME self.id, caso_de_prueba
 801         Prueba.pk.get(self.id, caso_de_prueba).destroySelf()
 802
 803     def make_correccion(self, corrector, **kw):
 804         return Correccion(instancia=self.instancia, entregador=self.entregador,
 805             entrega=self, corrector=corrector, **kw)
 806
 807     def __repr__(self):
 808         return super(Entrega, self).__repr__('instancia=%s, entregador=%s, '
 809             'fecha=%s' % (self.instancia.shortrepr(), srepr(self.entregador),
 810                 self.fecha))
 811
 812     def shortrepr(self):
 813         return '%s-%s-%s' % (self.instancia.shortrepr(),
 814             srepr(self.entregador), self.fecha)
 815 #}}}
 816
 817 class Correccion(SQLObject): #{{{
 818     # Clave
 819     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
 820     entregador      = ForeignKey('Entregador', notNone=True, cascade=False) # Docente no tiene
 821     pk              = DatabaseIndex(instancia, entregador, unique=True)
 822     # Campos
 823     entrega         = ForeignKey('Entrega', notNone=True, cascade=False)
 824     corrector       = ForeignKey('DocenteInscripto', notNone=True, cascade=False)
 825     asignado        = DateTimeCol(notNone=True, default=DateTimeCol.now)
 826     corregido       = DateTimeCol(default=None)
 827     nota            = DecimalCol(size=3, precision=1, default=None)
 828     observaciones   = UnicodeCol(default=None)
 829
 830     def _get_entregas(self):
 831         return list(Entrega.selectBy(instancia=self.instancia, entregador=self.entregador))
 832
 833     def __repr__(self):
 834         return 'Correccion(instancia=%s, entregador=%s, entrega=%s, ' \
 835             'corrector=%s, asignado=%s, corregido=%s, nota=%s, ' \
 836             'observaciones=%s)' \
 837                 % (self.instancia.shortrepr(), self.entregador.shortrepr(),
 838                     self.entrega.shortrepr(), self.corrector, self.asignado,
 839                     self.corregido, self.nota, self.observaciones)
 840
 841     def shortrepr(self):
 842         if not self.corrector:
 843             return '%s' % self.entrega.shortrepr()
 844         return '%s,%s' % (self.entrega.shortrepr(), self.corrector.shortrepr())
 845 #}}}
 846
 847 class ComandoEjecutado(Ejecucion): #{{{
 848     # Campos
 849     diferencias = BLOBCol(default=None) # ZIP con archivos guardados
 850
 851     def __repr__(self, clave='', mas=''):
 852         return super(ComandoEjecutado, self).__repr__(clave, mas)
 853 #}}}
 854
 855 class ComandoFuenteEjecutado(ComandoEjecutado): #{{{
 856     _inheritable = False
 857     # Clave
 858     comando = ForeignKey('ComandoFuente', notNone=True, cascade=False)
 859     entrega = ForeignKey('Entrega', notNone=True, cascade=False)
 860     pk      = DatabaseIndex(comando, entrega, unique=True)
 861
 862     def __repr__(self):
 863         return super(ComandoFuenteEjecutado, self).__repr__(
 864             'comando=%s, entrega=%s' % (self.comando.shortrepr(),
 865                 self.entrega.shortrepr()))
 866
 867     def shortrepr(self):
 868         return '%s-%s' % (self.comando.shortrepr(), self.entrega.shortrepr())
 869 #}}}
 870
 871 class ComandoPruebaEjecutado(ComandoEjecutado): #{{{
 872     _inheritable = False
 873     # Clave
 874     comando = ForeignKey('ComandoPrueba', notNone=True, cascade=False)
 875     prueba  = ForeignKey('Prueba', notNone=True, cascade=False)
 876     pk      = DatabaseIndex(comando, prueba, unique=True)
 877
 878     def __repr__(self):
 879         return super(ComandoPruebaEjecutado, self).__repr__(
 880             'comando=%s, entrega=%s' % (self.comando.shortrepr(),
 881                 self.entrega.shortrepr()))
 882
 883     def shortrepr(self):
 884         return '%s:%s:%s' % (self.tarea.shortrepr(), self.entrega.shortrepr(),
 885             self.caso_de_prueba.shortrepr())
 886 #}}}
 887
 888 class Prueba(ComandoEjecutado): #{{{
 889     _inheritable = False
 890     # Clave
 891     entrega             = ForeignKey('Entrega', notNone=True, cascade=False)
 892     caso_de_prueba      = ForeignKey('CasoDePrueba', notNone=True, cascade=False)
 893     pk                  = DatabaseIndex(entrega, caso_de_prueba, unique=True)
 894     # Joins
 895     comandos_ejecutados = MultipleJoin('ComandoPruebaEjecutado')
 896
 897     def add_comando_ejecutado(self, comando, **kw):
 898         if isinstance(comando, ComandoPrueba):
 899             comando = comando.id
 900         return ComandoPruebaEjecutado(prueba=self, comandoID=comando, **kw)
 901
 902     def remove_comando_ejecutado(self, comando):
 903         if isinstance(comando, ComandoPrueba):
 904             comando = comando.id
 905         # FIXME self.id, comando.id
 906         ComandoPruebaEjecutado.pk.get(self.id, comando).destroySelf()
 907
 908     def __repr__(self):
 909         return super(Prueba, self).__repr__('entrega=%s, caso_de_prueba=%s'
 910             % (self.entrega.shortrepr(), self.caso_de_prueba.shortrepr()))
 911
 912     def shortrepr(self):
 913         return '%s:%s' % (self.entrega.shortrepr(),
 914             self.caso_de_prueba.shortrepr())
 915 #}}}
 916
 917 #{{{ Específico de Identity
 918
 919 class Visita(SQLObject): #{{{
 920     visit_key   = StringCol(length=40, alternateID=True,
 921                     alternateMethodName="by_visit_key")
 922     created     = DateTimeCol(notNone=True, default=datetime.now)
 923     expiry      = DateTimeCol()
 924
 925     @classmethod
 926     def lookup_visit(cls, visit_key):
 927         try:
 928             return cls.by_visit_key(visit_key)
 929         except SQLObjectNotFound:
 930             return None
 931 #}}}
 932
 933 class VisitaUsuario(SQLObject): #{{{
 934     # Clave
 935     visit_key   = StringCol(length=40, alternateID=True,
 936                           alternateMethodName="by_visit_key")
 937     # Campos
 938     user_id     = IntCol() # Negrada de identity
 939 #}}}
 940
 941 class Rol(SQLObject): #{{{
 942     # Clave
 943     nombre      = UnicodeCol(length=255, alternateID=True,
 944                     alternateMethodName='by_nombre')
 945     # Campos
 946     descripcion = UnicodeCol(length=255, default=None)
 947     creado      = DateTimeCol(notNone=True, default=datetime.now)
 948     permisos    = TupleCol(notNone=True)
 949     # Joins
 950     usuarios    = RelatedJoin('Usuario', addRemoveName='_usuario')
 951
 952     def by_group_name(self, name): # para identity
 953         return self.by_nombre(name)
 954 #}}}
 955
 956 # No es un SQLObject porque no tiene sentido agregar/sacar permisos, están
 957 # hardcodeados en el código
 958 class Permiso(object): #{{{
 959     max_valor = 1
 960     def __init__(self, nombre, descripcion):
 961         self.valor = Permiso.max_valor
 962         Permiso.max_valor <<= 1
 963         self.nombre = nombre
 964         self.descripcion = descripcion
 965
 966     @classmethod
 967     def createTable(cls, ifNotExists): # para identity
 968         pass
 969
 970     @property
 971     def permission_name(self): # para identity
 972         return self.nombre
 973
 974     def __and__(self, other):
 975         return self.valor & other.valor
 976
 977     def __or__(self, other):
 978         return self.valor | other.valor
 979
 980     def __repr__(self):
 981         return self.nombre
 982 #}}}
 983
 984 # TODO ejemplos
 985 entregar_tp = Permiso(u'entregar', u'Permite entregar trabajos prácticos')
 986 admin = Permiso(u'admin', u'Permite hacer ABMs arbitrarios')
 987
 988 #}}} Identity
 989
 990 #}}} Clases
 991