sercom/model.py

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