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                         alternateMethodName='by_usuario')
 160     # Campos
 161     contrasenia     = UnicodeCol(length=255, default=None)
 162     nombre          = UnicodeCol(length=255, notNone=True)
 163     email           = UnicodeCol(length=255, default=None)
 164     telefono        = UnicodeCol(length=255, default=None)
 165     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 166     observaciones   = UnicodeCol(default=None)
 167     activo          = BoolCol(notNone=True, default=True)
 168     # Joins
 169     roles           = RelatedJoin('Rol', addRemoveName='_rol')
 170
 171     def __init__(self, password=None, roles=[], **kw):
 172         if password is not None:
 173             kw['contrasenia'] = encryptpw(password)
 174         super(Usuario, self).__init__(**kw)
 175         for r in roles:
 176             self.add_rol(r)
 177
 178     def set(self, password=None, roles=None, **kw):
 179         if password is not None:
 180             kw['contrasenia'] = encryptpw(password)
 181         super(Usuario, self).set(**kw)
 182         if roles is not None:
 183             for r in self.roles:
 184                 self.remove_rol(r)
 185             for r in roles:
 186                 self.add_rol(r)
 187
 188     def _get_user_name(self): # para identity
 189         return self.usuario
 190
 191     @classmethod
 192     def byUsuario(cls, usuario): # TODO eliminar, backward compat
 193         return cls.by_usuario(usuario)
 194
 195     @classmethod
 196     def by_user_name(cls, user_name): # para identity
 197         user = cls.byUsuario(user_name)
 198         if not user.activo:
 199             raise SQLObjectNotFound(_(u'El %s está inactivo' % cls.__name__))
 200         return user
 201
 202     def _get_groups(self): # para identity
 203         return self.roles
 204
 205     def _get_permissions(self): # para identity
 206         perms = set()
 207         for r in self.roles:
 208             perms.update(r.permisos)
 209         return perms
 210
 211     _get_permisos = _get_permissions
 212
 213     def _set_password(self, cleartext_password): # para identity
 214         self.contrasenia = encryptpw(cleartext_password)
 215
 216     def _get_password(self): # para identity
 217         return self.contrasenia
 218
 219     def __repr__(self):
 220         raise NotImplementedError(_(u'Clase abstracta!'))
 221
 222     def shortrepr(self):
 223         return '%s (%s)' % (self.usuario, self.nombre)
 224 #}}}
 225
 226 class Docente(Usuario): #{{{
 227     _inheritable = False
 228     # Campos
 229     nombrado    = BoolCol(notNone=True, default=True)
 230     # Joins
 231     enunciados  = MultipleJoin('Enunciado', joinColumn='autor_id')
 232     cursos      = MultipleJoin('DocenteInscripto')
 233
 234     def add_entrega(self, instancia, **kw):
 235         return Entrega(instancia=instancia, **kw)
 236
 237     def add_enunciado(self, nombre, anio, cuatrimestre, **kw):
 238         return Enunciado(nombre=nombre, anio=anio, cuatrimestre=cuatrimestre,
 239             autor=self, **kw)
 240
 241     def remove_enunciado(self, nombre, anio, cuatrimestre):
 242         Enunciado.pk.get(nombre, anio, cuatrimestre).destroySelf()
 243
 244     def __repr__(self):
 245         return 'Docente(id=%s, usuario=%s, nombre=%s, password=%s, email=%s, ' \
 246             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
 247                 % (self.id, self.usuario, self.nombre, self.password,
 248                     self.email, self.telefono, self.activo, self.creado,
 249                     self.observaciones)
 250 #}}}
 251
 252 class Alumno(Usuario): #{{{
 253     _inheritable = False
 254     # Campos
 255     nota            = DecimalCol(size=3, precision=1, default=None)
 256     # Joins
 257     inscripciones   = MultipleJoin('AlumnoInscripto')
 258
 259     def __init__(self, padron=None, **kw):
 260         if padron: kw['usuario'] = padron
 261         super(Alumno, self).__init__(**kw)
 262
 263     def set(self, padron=None, **kw):
 264         if padron: kw['usuario'] = padron
 265         super(Alumno, self).set(**kw)
 266
 267     def _get_padron(self): # alias para poder referirse al alumno por padron
 268         return self.usuario
 269
 270     def _set_padron(self, padron):
 271         self.usuario = padron
 272
 273     @classmethod
 274     def byPadron(cls, padron): # TODO eliminar, backward compat
 275         return cls.byUsuario(unicode(padron))
 276
 277     @classmethod
 278     def by_padron(cls, padron):
 279         return cls.by_usuario(unicode(padron))
 280
 281     def __repr__(self):
 282         return 'Alumno(id=%s, padron=%s, nombre=%s, password=%s, email=%s, ' \
 283             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
 284                 % (self.id, self.padron, self.nombre, self.password, self.email,
 285                     self.telefono, self.activo, self.creado, self.observaciones)
 286 #}}}
 287
 288 class Tarea(InheritableSQLObject): #{{{
 289     # Clave
 290     nombre              = UnicodeCol(length=30, alternateID=True)
 291     # Campos
 292     descripcion         = UnicodeCol(length=255, default=None)
 293     # Joins
 294     enunciados          = RelatedJoin('Enunciado', addRemoveName='_enunciado')
 295
 296     def __repr__(self):
 297         raise NotImplementedError('Tarea es una clase abstracta')
 298
 299     def shortrepr(self):
 300         return self.nombre
 301 #}}}
 302
 303 class TareaFuente(Tarea): #{{{
 304     _inheritable = False
 305     # Joins
 306     comandos    = MultipleJoin('ComandoFuente', joinColumn='tarea_id')
 307
 308     def add_comando(self, orden, comando, **kw):
 309         return ComandoFuente(tarea=self, orden=orden, comando=comando, **kw)
 310
 311     def remove_comando(self, orden):
 312         ComandoFuente.pk.get(self.id, orden).destroySelf()
 313
 314     def __repr__(self):
 315         return 'TareaFuente(id=%s, nombre=%s, descripcion=%s)' \
 316                 % (self.id, self.nombre, self.descripcion)
 317 #}}}
 318
 319 class TareaPrueba(Tarea): #{{{
 320     _inheritable = False
 321     # Joins
 322     comandos    = MultipleJoin('ComandoPrueba', joinColumn='tarea_id')
 323
 324     def add_comando(self, orden, comando='', **kw):
 325         return ComandoPrueba(tarea=self, orden=orden, comando=comando, **kw)
 326
 327     def remove_comando(self, orden):
 328         ComandoPrueba.pk.get(self.id, orden).destroySelf()
 329
 330     def __repr__(self):
 331         return 'TareaPrueba(id=%s, nombre=%s, descripcion=%s)' \
 332                 % (self.id, self.nombre, self.descripcion)
 333 #}}}
 334
 335 class Comando(InheritableSQLObject): #{{{
 336     # Tipos de retorno especiales
 337     RET_ANY = None
 338     RET_FAIL = -256
 339     # Archivos especiales
 340     STDIN = '__stdin__'
 341     STDOUT = '__stdout__'
 342     STDERR = '__stderr__'
 343     STDOUTERR = '__stdouterr__'
 344     # Campos
 345     comando             = UnicodeCol(length=255, notNone=True)
 346     descripcion         = UnicodeCol(length=255, default=None)
 347     retorno             = IntCol(default=None) # Ver RET_XXX y si es negativo
 348                                                # se espera una señal
 349     max_tiempo_cpu      = IntCol(default=None) # En segundos
 350     max_memoria         = IntCol(default=None) # En MB
 351     max_tam_archivo     = IntCol(default=None) # En MB
 352     max_cant_archivos   = IntCol(default=None)
 353     max_cant_procesos   = IntCol(default=None)
 354     max_locks_memoria   = IntCol(default=None)
 355     terminar_si_falla   = BoolCol(notNone=True, default=True)
 356     rechazar_si_falla   = BoolCol(notNone=True, default=True)
 357     publico             = BoolCol(notNone=True, default=True)
 358     archivos_entrada    = BLOBCol(default=None) # ZIP con archivos de entrada
 359                                                 # __stdin__ es caso especial
 360                                                 # Si un caso de prueba tiene
 361                                                 # comandos que tiene algún
 362                                                 # archivo de entrada (incluyendo
 363                                                 # stdin) con los propios, se usa
 364                                                 # el archivo del caso de prueba,
 365                                                 # no del comando.
 366     archivos_a_comparar = BLOBCol(default=None) # ZIP con archivos de salida
 367                                                 # __stdout__, __stderr__ y
 368                                                 # __stdouterr__ (ambos juntos)
 369                                                 # son casos especiales
 370                                                 # Si un caso de prueba tiene
 371                                                 # comandos que tiene algún
 372                                                 # archivo a comparar (incluyendo
 373                                                 # stdout/err) con los propios,
 374                                                 # se compara contra el archivo
 375                                                 # del caso de prueba, no del
 376                                                 # comando.
 377     archivos_a_guardar  = TupleCol(notNone=True, default=()) # TODO FrozenSetCol
 378                                                 # __stdout__, __stderr__ y
 379                                                 # __stdouterr__ (ambos juntos)
 380                                                 # son casos especiales
 381     activo              = BoolCol(notNone=True, default=True)
 382
 383     def __repr__(self, clave='', mas=''):
 384         return ('%s(%s comando=%s, descripcion=%s, retorno=%s, '
 385             'max_tiempo_cpu=%s, max_memoria=%s, max_tam_archivo=%s, '
 386             'max_cant_archivos=%s, max_cant_procesos=%s, max_locks_memoria=%s, '
 387             'terminar_si_falla=%s, rechazar_si_falla=%s%s)'
 388                 % (self.__class__.__name__, clave, self.comando,
 389                     self.descripcion, self.retorno, self.max_tiempo_cpu,
 390                     self.max_memoria, self.max_tam_archivo,
 391                     self.max_cant_archivos, self.max_cant_procesos,
 392                     self.max_locks_memoria, self.terminar_si_falla,
 393                     self.rechazar_si_falla, mas))
 394
 395     def shortrepr(self):
 396         return '%s (%s)' % (self.comando, self.descripcion)
 397 #}}}
 398
 399 class ComandoFuente(Comando): #{{{
 400     _inheritable = False
 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     _inheritable = False
 416     RET_PRUEBA = -257 # Espera el mismo retorno que el de la prueba.
 417     # XXX todos los campos de limitación en este caso son multiplicadores para
 418     # los valores del caso de prueba.
 419     # Clave
 420     tarea               = ForeignKey('TareaPrueba', notNone=True, cascade=True)
 421     orden               = IntCol(notNone=True)
 422     pk                  = DatabaseIndex(tarea, orden, unique=True)
 423
 424     def __repr__(self):
 425         return super(ComandoPrueba, self).__repr__('tarea=%s, orden=%s'
 426             % (self.tarea.shortrepr(), self.orden))
 427
 428     def shortrepr(self):
 429         return '%s:%s (%s)' % (self.tarea.shortrepr(), self.orden, self.comando)
 430 #}}}
 431
 432 class Enunciado(SQLObject): #{{{
 433     # Clave
 434     nombre          = UnicodeCol(length=60)
 435     anio            = IntCol(notNone=True)
 436     cuatrimestre    = IntCol(notNone=True)
 437     pk              = DatabaseIndex(nombre, anio, cuatrimestre, unique=True)
 438     # Campos
 439     descripcion     = UnicodeCol(length=255, default=None)
 440     autor           = ForeignKey('Docente', cascade='null')
 441     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 442     archivos        = BLOBCol(default=None)
 443     # Joins
 444     ejercicios      = MultipleJoin('Ejercicio')
 445     casos_de_prueba = MultipleJoin('CasoDePrueba')
 446     tareas          = RelatedJoin('Tarea', addRemoveName='_tarea')
 447
 448     def __init__(self, tareas=[], **kw):
 449         super(Enunciado, self).__init__(**kw)
 450         for tarea in tareas:
 451             self.add_tarea(tarea)
 452
 453     def set(self, tareas=None, **kw):
 454         super(Enunciado, self).set(**kw)
 455         if tareas is not None:
 456             for tarea in self.tareas:
 457                 self.remove_tarea(tarea)
 458             for tarea in tareas:
 459                 self.add_tarea(tarea)
 460
 461     @classmethod
 462     def selectByCurso(self, curso):
 463         return Enunciado.selectBy(cuatrimestre=curso.cuatrimestre, anio=curso.anio)
 464
 465     def add_caso_de_prueba(self, nombre, **kw):
 466         return CasoDePrueba(enunciado=self, nombre=nombre, **kw)
 467
 468     def __repr__(self):
 469         return 'Enunciado(id=%s, autor=%s, nombre=%s, descripcion=%s, ' \
 470             'creado=%s)' \
 471                 % (self.id, srepr(self.autor), self.nombre, self.descripcion, \
 472                     self.creado)
 473
 474     def shortrepr(self):
 475         return self.nombre
 476 #}}}
 477
 478 class CasoDePrueba(Comando): #{{{
 479     _inheritable = False
 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(CasoDePrueba, 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     inicio_proceso  = DateTimeCol(default=None)
 535     fin_proceso     = DateTimeCol(default=None)
 536     observaciones   = UnicodeCol(notNone=True, default=u'')
 537     activo          = BoolCol(notNone=True, default=True)
 538     # Joins
 539     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
 540     correcciones    = MultipleJoin('Correccion', joinColumn='instancia_id')
 541
 542     def __repr__(self):
 543         return 'InstanciaDeEntrega(id=%s, numero=%s, inicio=%s, fin=%s, ' \
 544             'inicio_proceso=%s, fin_proceso=%s, observaciones=%s, activo=%s)' \
 545                 % (self.id, self.numero, self.inicio, self.fin,
 546                     self.inicio_proceso, self.fin_proceso, self.observaciones,
 547                     self.activo)
 548
 549     def shortrepr(self):
 550         return self.numero
 551 #}}}
 552
 553 class DocenteInscripto(SQLObject): #{{{
 554     # Clave
 555     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 556     docente         = ForeignKey('Docente', notNone=True, cascade=True)
 557     pk              = DatabaseIndex(curso, docente, unique=True)
 558     # Campos
 559     corrige         = BoolCol(notNone=True, default=True)
 560     observaciones   = UnicodeCol(default=None)
 561     # Joins
 562     alumnos         = MultipleJoin('AlumnoInscripto', joinColumn='tutor_id')
 563     tutorias        = MultipleJoin('Tutor', joinColumn='docente_id')
 564     correcciones    = MultipleJoin('Correccion', joinColumn='corrector_id')
 565
 566     def add_correccion(self, entrega, **kw):
 567         return Correccion(instancia=entrega.instancia, entrega=entrega,
 568             entregador=entrega.entregador, corrector=self, **kw)
 569
 570     def remove_correccion(self, instancia, entregador):
 571         # FIXME instancia.id, entregador.id
 572         Correccion.pk.get(instancia.id, entregador.id).destroySelf()
 573
 574     def __repr__(self):
 575         return 'DocenteInscripto(id=%s, docente=%s, corrige=%s, ' \
 576             'observaciones=%s' \
 577                 % (self.id, self.docente.shortrepr(), self.corrige,
 578                     self.observaciones)
 579
 580     def shortrepr(self):
 581         return self.docente.shortrepr()
 582 #}}}
 583
 584 class Entregador(InheritableSQLObject): #{{{
 585     # Campos
 586     nota            = DecimalCol(size=3, precision=1, default=None)
 587     nota_cursada    = DecimalCol(size=3, precision=1, default=None)
 588     observaciones   = UnicodeCol(notNone=True, default=u'')
 589     activo          = BoolCol(notNone=True, default=True)
 590     # Joins
 591     entregas        = MultipleJoin('Entrega')
 592     correcciones    = MultipleJoin('Correccion')
 593
 594     def add_entrega(self, instancia, **kw):
 595         return Entrega(instancia=instancia, entregador=self, **kw)
 596
 597     def __repr__(self):
 598         raise NotImplementedError, 'Clase abstracta!'
 599 #}}}
 600
 601 class Grupo(Entregador): #{{{
 602     _inheritable = False
 603     # Clave
 604     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 605     nombre          = UnicodeCol(length=20, notNone=True)
 606     pk              = DatabaseIndex(curso, nombre, unique=True)
 607     # Campos
 608     responsable     = ForeignKey('AlumnoInscripto', default=None, cascade='null')
 609     # Joins
 610     miembros        = MultipleJoin('Miembro')
 611     tutores         = MultipleJoin('Tutor')
 612
 613     def __init__(self, miembros=[], tutores=[], **kw):
 614         super(Grupo, self).__init__(**kw)
 615         for a in miembros:
 616             self.add_miembro(a)
 617         for d in tutores:
 618             self.add_tutor(d)
 619
 620     def set(self, miembros=None, tutores=None, **kw):
 621         super(Grupo, self).set(**kw)
 622         if miembros is not None:
 623             for m in Miembro.selectBy(grupo=self):
 624                 m.destroySelf()
 625             for m in miembros:
 626                 self.add_miembro(m)
 627         if tutores is not None:
 628             for t in Tutor.selectBy(grupo=self):
 629                 t.destroySelf()
 630             for t in tutores:
 631                 self.add_tutor(t)
 632
 633     _doc_alumnos = 'Devuelve una lista de AlumnoInscriptos **activos**.'
 634     def _get_alumnos(self):
 635         return list([m.alumno for m in Miembro.selectBy(grupo=self, baja=None)])
 636
 637     _doc_docentes = 'Devuelve una lista de DocenteInscriptos **activos**.'
 638     def _get_docentes(self):
 639         return list([t.docente for t in Tutor.selectBy(grupo=self, baja=None)])
 640
 641     def add_miembro(self, alumno, **kw):
 642         if isinstance(alumno, AlumnoInscripto):
 643             alumno = alumno.id
 644         # FIXME acá habría que sacarle la unicidad a Miembro.pk para que
 645         # un alumno pueda ser miembro varias veces del mismo grupo, de
 646         # manera de tener la historia completa, pero hay que tener cuidad
 647         # y arreglar todos los lugares donde se asume esa unicidad
 648         try:
 649             m = Miembro.selectBy(grupo=self, alumnoID=alumno).getOne()
 650             m.baja = None # si ya existía, le sacamos la fecha de baja
 651             return m
 652         except SQLObjectNotFound: # creo uno nuevo
 653             return Miembro(grupo=self, alumnoID=alumno, **kw)
 654
 655     def remove_miembro(self, alumno):
 656         if isinstance(alumno, AlumnoInscripto):
 657             alumno = alumno.id
 658         m = Miembro.selectBy(grupo=self, alumnoID=alumno, baja=None).getOne()
 659         m.baja = DateTimeCol.now()
 660
 661     def add_tutor(self, docente, **kw):
 662         if isinstance(docente, DocenteInscripto):
 663             docente = docente.id
 664         # FIXME ídem add_miembro()
 665         try:
 666             t = Tutor.selectBy(grupo=self, docenteID=docente).getOne()
 667             t.baja = None # si ya existía, le sacamos la fecha de baja
 668             return t
 669         except SQLObjectNotFound: # creo uno nuevo
 670             return Tutor(grupo=self, docenteID=docente, **kw)
 671
 672     def remove_tutor(self, docente):
 673         if isinstance(docente, DocenteInscripto):
 674             docente = docente.id
 675         t = Tutor.selectBy(grupo=self, docenteID=docente, baja=None)
 676         t.baja = DateTimeCol.now()
 677
 678     def __repr__(self):
 679         return 'Grupo(id=%s, nombre=%s, responsable=%s, nota=%s, ' \
 680             'nota_cursada=%s, observaciones=%s, activo=%s)' \
 681                 % (self.id, self.nombre, srepr(self.responsable), self.nota,
 682                     self.nota_cursada, self.observaciones, self.activo)
 683
 684     @classmethod
 685     def selectByAlumno(self, alumno):
 686         return Miembro.select(AND(Miembro.q.alumnoID == AlumnoInscripto.q.id,
 687                 AlumnoInscripto.q.alumnoID == alumno.id, Miembro.q.baja == None))
 688
 689     def shortrepr(self):
 690         return 'grupo:' + self.nombre
 691 #}}}
 692
 693 class AlumnoInscripto(Entregador): #{{{
 694     _inheritable = False
 695     # Clave
 696     curso               = ForeignKey('Curso', notNone=True, cascade=True)
 697     alumno              = ForeignKey('Alumno', notNone=True, cascade=True)
 698     pk                  = DatabaseIndex(curso, alumno, unique=True)
 699     # Campos
 700     condicional         = BoolCol(notNone=True, default=False)
 701     tutor               = ForeignKey('DocenteInscripto', default=None, cascade='null')
 702     # Joins
 703     responsabilidades   = MultipleJoin('Grupo', joinColumn='responsable_id')
 704     membresias          = MultipleJoin('Miembro', joinColumn='alumno_id')
 705     entregas            = MultipleJoin('Entrega', joinColumn='alumno_id')
 706     correcciones        = MultipleJoin('Correccion', joinColumn='alumno_id')
 707     # Notas de la cursada
 708     nota_practica       = DecimalCol(size=3, precision=1, default=None)
 709     nota_final          = DecimalCol(size=3, precision=1, default=None)
 710     nota_libreta        = DecimalCol(size=3, precision=1, default=None)
 711
 712     def _get_nombre(self):
 713         return self.alumno.padron
 714
 715     @classmethod
 716     def selectByAlumno(self, alumno):
 717         return AlumnoInscripto.select(AlumnoInscripto.q.alumnoID == alumno.id).getOne()
 718
 719     def __repr__(self):
 720         return 'AlumnoInscripto(id=%s, alumno=%s, condicional=%s, nota=%s, ' \
 721             'nota_cursada=%s, tutor=%s, observaciones=%s, activo=%s)' \
 722                 % (self.id, self.alumno.shortrepr(), self.condicional,
 723                     self.nota, self.nota_cursada, srepr(self.tutor),
 724                     self.observaciones, self.activo)
 725
 726     def shortrepr(self):
 727         return self.alumno.shortrepr()
 728 #}}}
 729
 730 class Tutor(SQLObject): #{{{
 731     # Clave
 732     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
 733     docente         = ForeignKey('DocenteInscripto', notNone=True, cascade=True)
 734     pk              = DatabaseIndex(grupo, docente, unique=True)
 735     # Campos
 736     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 737     baja            = DateTimeCol(default=None)
 738
 739     def __repr__(self):
 740         return 'Tutor(docente=%s, grupo=%s, alta=%s, baja=%s)' \
 741                 % (self.docente.shortrepr(), self.grupo.shortrepr(),
 742                     self.alta, self.baja)
 743
 744     def shortrepr(self):
 745         return '%s-%s' % (self.docente.shortrepr(), self.grupo.shortrepr())
 746 #}}}
 747
 748 class Miembro(SQLObject): #{{{
 749     # Clave
 750     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
 751     alumno          = ForeignKey('AlumnoInscripto', notNone=True, cascade=True)
 752     pk              = DatabaseIndex(grupo, alumno, unique=True)
 753     # Campos
 754     nota            = DecimalCol(size=3, precision=1, default=None)
 755     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 756     baja            = DateTimeCol(default=None)
 757
 758     def __repr__(self):
 759         return 'Miembro(alumno=%s, grupo=%s, nota=%s, alta=%s, baja=%s)' \
 760                 % (self.alumno.shortrepr(), self.grupo.shortrepr(),
 761                     self.nota, self.alta, self.baja)
 762
 763     def shortrepr(self):
 764         return '%s-%s' % (self.alumno.shortrepr(), self.grupo.shortrepr())
 765 #}}}
 766
 767 class Ejecucion(InheritableSQLObject): #{{{
 768     # Campos
 769     inicio          = DateTimeCol(default=None)
 770     fin             = DateTimeCol(default=None)
 771     exito           = IntCol(default=None)
 772     observaciones   = UnicodeCol(notNone=True, default=u'')
 773     archivos        = BLOBCol(default=None) # ZIP con archivos
 774
 775     def __repr__(self, clave='', mas=''):
 776         return ('%s(%s inicio=%s, fin=%s, exito=%s, observaciones=%s%s)'
 777             % (self.__class__.__name__, clave, self.inicio, self.fin,
 778             self.exito, self.observaciones, mas))
 779 #}}}
 780
 781 class Entrega(Ejecucion): #{{{
 782     _inheritable = False
 783     # Clave
 784     instancia           = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
 785     entregador          = ForeignKey('Entregador', default=None, cascade=False) # Si es None era un Docente
 786     fecha               = DateTimeCol(notNone=True, default=DateTimeCol.now)
 787     pk                  = DatabaseIndex(instancia, entregador, fecha, unique=True)
 788     # Joins
 789     comandos_ejecutados = MultipleJoin('ComandoFuenteEjecutado')
 790     pruebas             = MultipleJoin('Prueba')
 791
 792     def add_comando_ejecutado(self, comando, **kw):
 793         return ComandoFuenteEjecutado(entrega=self, comando=comando, **kw)
 794
 795     def remove_comando_ejecutado(self, comando):
 796         if isinstance(comando, ComandoFuente):
 797             comando = comando.id
 798         # FIXME self.id
 799         ComandoFuenteEjecutado.pk.get(self.id, comando).destroySelf()
 800
 801     def add_prueba(self, caso_de_prueba, **kw):
 802         return Prueba(entrega=self, caso_de_prueba=caso_de_prueba, **kw)
 803
 804     def remove_prueba(self, caso_de_prueba):
 805         if isinstance(caso_de_prueba, CasoDePrueba):
 806             caso_de_prueba = caso_de_prueba.id
 807         # FIXME self.id, caso_de_prueba
 808         Prueba.pk.get(self.id, caso_de_prueba).destroySelf()
 809
 810     def make_correccion(self, corrector, **kw):
 811         return Correccion(instancia=self.instancia, entregador=self.entregador,
 812             entrega=self, corrector=corrector, **kw)
 813
 814     def __repr__(self):
 815         return super(Entrega, self).__repr__('instancia=%s, entregador=%s, '
 816             'fecha=%s' % (self.instancia.shortrepr(), srepr(self.entregador),
 817                 self.fecha))
 818
 819     def shortrepr(self):
 820         return '%s-%s-%s' % (self.instancia.shortrepr(),
 821             srepr(self.entregador), self.fecha)
 822 #}}}
 823
 824 class Correccion(SQLObject): #{{{
 825     # Clave
 826     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
 827     entregador      = ForeignKey('Entregador', notNone=True, cascade=False) # Docente no tiene
 828     pk              = DatabaseIndex(instancia, entregador, unique=True)
 829     # Campos
 830     entrega         = ForeignKey('Entrega', notNone=True, cascade=False)
 831     corrector       = ForeignKey('DocenteInscripto', notNone=True, cascade=False)
 832     asignado        = DateTimeCol(notNone=True, default=DateTimeCol.now)
 833     corregido       = DateTimeCol(default=None)
 834     nota            = DecimalCol(size=3, precision=1, default=None)
 835     observaciones   = UnicodeCol(default=None)
 836
 837     def _get_entregas(self):
 838         return list(Entrega.selectBy(instancia=self.instancia, entregador=self.entregador))
 839
 840     def __repr__(self):
 841         return 'Correccion(instancia=%s, entregador=%s, entrega=%s, ' \
 842             'corrector=%s, asignado=%s, corregido=%s, nota=%s, ' \
 843             'observaciones=%s)' \
 844                 % (self.instancia.shortrepr(), self.entregador.shortrepr(),
 845                     self.entrega.shortrepr(), self.corrector, self.asignado,
 846                     self.corregido, self.nota, self.observaciones)
 847
 848     def shortrepr(self):
 849         if not self.corrector:
 850             return '%s' % self.entrega.shortrepr()
 851         return '%s,%s' % (self.entrega.shortrepr(), self.corrector.shortrepr())
 852 #}}}
 853
 854 class ComandoEjecutado(Ejecucion): #{{{
 855     # Campos
 856     diferencias = BLOBCol(default=None) # ZIP con archivos guardados
 857
 858     def __repr__(self, clave='', mas=''):
 859         return super(ComandoEjecutado, self).__repr__(clave, mas)
 860 #}}}
 861
 862 class ComandoFuenteEjecutado(ComandoEjecutado): #{{{
 863     _inheritable = False
 864     # Clave
 865     comando = ForeignKey('ComandoFuente', notNone=True, cascade=False)
 866     entrega = ForeignKey('Entrega', notNone=True, cascade=False)
 867     pk      = DatabaseIndex(comando, entrega, unique=True)
 868
 869     def __repr__(self):
 870         return super(ComandoFuenteEjecutado, self).__repr__(
 871             'comando=%s, entrega=%s' % (self.comando.shortrepr(),
 872                 self.entrega.shortrepr()))
 873
 874     def shortrepr(self):
 875         return '%s-%s' % (self.comando.shortrepr(), self.entrega.shortrepr())
 876 #}}}
 877
 878 class ComandoPruebaEjecutado(ComandoEjecutado): #{{{
 879     _inheritable = False
 880     # Clave
 881     comando = ForeignKey('ComandoPrueba', notNone=True, cascade=False)
 882     prueba  = ForeignKey('Prueba', notNone=True, cascade=False)
 883     pk      = DatabaseIndex(comando, prueba, unique=True)
 884
 885     def __repr__(self):
 886         return super(ComandoPruebaEjecutado, self).__repr__(
 887             'comando=%s, prueba=%s' % (self.comando.shortrepr(),
 888                 self.prueba.shortrepr()))
 889
 890     def shortrepr(self):
 891         return '%s:%s:%s' % (self.tarea.shortrepr(), self.prueba.shortrepr(),
 892             self.caso_de_prueba.shortrepr())
 893 #}}}
 894
 895 class Prueba(ComandoEjecutado): #{{{
 896     _inheritable = False
 897     # Clave
 898     entrega             = ForeignKey('Entrega', notNone=True, cascade=False)
 899     caso_de_prueba      = ForeignKey('CasoDePrueba', notNone=True, cascade=False)
 900     pk                  = DatabaseIndex(entrega, caso_de_prueba, unique=True)
 901     # Joins
 902     comandos_ejecutados = MultipleJoin('ComandoPruebaEjecutado')
 903
 904     def add_comando_ejecutado(self, comando, **kw):
 905         if isinstance(comando, ComandoPrueba):
 906             comando = comando.id
 907         return ComandoPruebaEjecutado(prueba=self, comandoID=comando, **kw)
 908
 909     def remove_comando_ejecutado(self, comando):
 910         if isinstance(comando, ComandoPrueba):
 911             comando = comando.id
 912         # FIXME self.id, comando.id
 913         ComandoPruebaEjecutado.pk.get(self.id, comando).destroySelf()
 914
 915     def __repr__(self):
 916         return super(Prueba, self).__repr__('entrega=%s, caso_de_prueba=%s'
 917             % (self.entrega.shortrepr(), self.caso_de_prueba.shortrepr()))
 918
 919     def shortrepr(self):
 920         return '%s:%s' % (self.entrega.shortrepr(),
 921             self.caso_de_prueba.shortrepr())
 922 #}}}
 923
 924 #{{{ Específico de Identity
 925
 926 class Visita(SQLObject): #{{{
 927     visit_key   = StringCol(length=40, alternateID=True,
 928                     alternateMethodName="by_visit_key")
 929     created     = DateTimeCol(notNone=True, default=datetime.now)
 930     expiry      = DateTimeCol()
 931
 932     @classmethod
 933     def lookup_visit(cls, visit_key):
 934         try:
 935             return cls.by_visit_key(visit_key)
 936         except SQLObjectNotFound:
 937             return None
 938 #}}}
 939
 940 class VisitaUsuario(SQLObject): #{{{
 941     # Clave
 942     visit_key   = StringCol(length=40, alternateID=True,
 943                           alternateMethodName="by_visit_key")
 944     # Campos
 945     user_id     = IntCol() # Negrada de identity
 946 #}}}
 947
 948 class Rol(SQLObject): #{{{
 949     # Clave
 950     nombre      = UnicodeCol(length=255, alternateID=True,
 951                     alternateMethodName='by_nombre')
 952     # Campos
 953     descripcion = UnicodeCol(length=255, default=None)
 954     creado      = DateTimeCol(notNone=True, default=datetime.now)
 955     permisos    = TupleCol(notNone=True)
 956     # Joins
 957     usuarios    = RelatedJoin('Usuario', addRemoveName='_usuario')
 958
 959     def by_group_name(self, name): # para identity
 960         return self.by_nombre(name)
 961 #}}}
 962
 963 # No es un SQLObject porque no tiene sentido agregar/sacar permisos, están
 964 # hardcodeados en el código
 965 class Permiso(object): #{{{
 966     max_valor = 1
 967     def __init__(self, nombre, descripcion):
 968         self.valor = Permiso.max_valor
 969         Permiso.max_valor <<= 1
 970         self.nombre = nombre
 971         self.descripcion = descripcion
 972
 973     @classmethod
 974     def createTable(cls, ifNotExists): # para identity
 975         pass
 976
 977     @property
 978     def permission_name(self): # para identity
 979         return self.nombre
 980
 981     def __and__(self, other):
 982         return self.valor & other.valor
 983
 984     def __or__(self, other):
 985         return self.valor | other.valor
 986
 987     def __repr__(self):
 988         return self.nombre
 989 #}}}
 990
 991 # TODO ejemplos
 992 entregar_tp = Permiso(u'entregar', u'Permite entregar trabajos prácticos')
 993 admin = Permiso(u'admin', u'Permite hacer ABMs arbitrarios')
 994
 995 #}}} Identity
 996
 997 #}}} Clases
 998