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