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', 'Tarea', '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             + super(SOPickleCol, self).createValidators()
  46
  47 class TupleCol(PickleCol):
  48     baseClass = SOTupleCol
  49
  50 class ParamsValidator(UnicodeStringValidator):
  51     def to_python(self, value, state):
  52         if isinstance(value, basestring) or value is None:
  53             value = super(ParamsValidator, self).to_python(value, state)
  54             try:
  55                 value = params_to_list(value)
  56             except ParseError, e:
  57                 raise Invalid("invalid parameters in the ParamsCol '%s', parse "
  58                     "error: %s" % (self.name, e), value, state)
  59         elif not isinstance(value, (list, tuple)):
  60             raise Invalid("expected a tuple, list or valid string in the "
  61                 "ParamsCol '%s', got %s %r instead"
  62                     % (self.name, type(value), value), value, state)
  63         return value
  64     def from_python(self, value, state):
  65         if isinstance(value, (list, tuple)):
  66             value = ' '.join([repr(p) for p in value])
  67         elif isinstance(value, basestring) or value is None:
  68             value = super(ParamsValidator, self).to_python(value, state)
  69             try:
  70                 params_to_list(value)
  71             except ParseError, e:
  72                 raise Invalid("invalid parameters in the ParamsCol '%s', parse "
  73                     "error: %s" % (self.name, e), value, state)
  74         else:
  75             raise Invalid("expected a tuple, list or valid string in the "
  76                 "ParamsCol '%s', got %s %r instead"
  77                     % (self.name, type(value), value), value, state)
  78         return value
  79
  80 class SOParamsCol(SOUnicodeCol):
  81     def createValidators(self):
  82         return [ParamsValidator(db_encoding=self.dbEncoding, name=self.name)] \
  83             + super(SOParamsCol, self).createValidators()
  84
  85 class ParamsCol(UnicodeCol):
  86     baseClass = SOParamsCol
  87
  88 #}}}
  89
  90 #{{{ Tablas intermedias
  91
  92 # BUG en SQLObject, SQLExpression no tiene cálculo de hash pero se usa como
  93 # key de un dict. Workarround hasta que lo arreglen.
  94 SQLExpression.__hash__ = lambda self: hash(str(self))
  95
  96 instancia_tarea_t = table.instancia_tarea
  97
  98 enunciado_tarea_t = table.enunciado_tarea
  99
 100 dependencia_t = table.dependencia
 101
 102 #}}}
 103
 104 #{{{ Clases
 105
 106 def srepr(obj): #{{{
 107     if obj is not None:
 108         return obj.shortrepr()
 109     return obj
 110 #}}}
 111
 112 class Curso(SQLObject): #{{{
 113     # Clave
 114     anio            = IntCol(notNone=True)
 115     cuatrimestre    = IntCol(notNone=True)
 116     numero          = IntCol(notNone=True)
 117     pk              = DatabaseIndex(anio, cuatrimestre, numero, unique=True)
 118     # Campos
 119     descripcion     = UnicodeCol(length=255, default=None)
 120     # Joins
 121     docentes        = MultipleJoin('DocenteInscripto')
 122     alumnos         = MultipleJoin('AlumnoInscripto')
 123     grupos          = MultipleJoin('Grupo')
 124     ejercicios      = MultipleJoin('Ejercicio', orderBy='numero')
 125
 126     def __init__(self, docentes=[], ejercicios=[], alumnos=[], **kw):
 127         super(Curso, self).__init__(**kw)
 128         for d in docentes:
 129             self.add_docente(d)
 130         for (n, e) in enumerate(ejercicios):
 131             self.add_ejercicio(n, e)
 132         for a in alumnos:
 133             self.add_alumno(a)
 134
 135     def set(self, docentes=None, ejercicios=None, alumnos=None, **kw):
 136         super(Curso, self).set(**kw)
 137         if docentes is not None:
 138             for d in DocenteInscripto.selectBy(curso=self):
 139                 d.destroySelf()
 140             for d in docentes:
 141                 self.add_docente(d)
 142         if ejercicios is not None:
 143             for e in Ejercicio.selectBy(curso=self):
 144                 e.destroySelf()
 145             for (n, e) in enumerate(ejercicios):
 146                 self.add_ejercicio(n, e)
 147         if alumnos is not None:
 148             for a in AlumnoInscripto.selectBy(curso=self):
 149                 a.destroySelf()
 150             for a in alumnos:
 151                 self.add_alumno(a)
 152
 153     def add_docente(self, docente, **kw):
 154         if isinstance(docente, Docente):
 155             kw['docente'] = docente
 156         else:
 157             kw['docenteID'] = docente
 158         return DocenteInscripto(curso=self, **kw)
 159
 160     def remove_docente(self, docente):
 161         if isinstance(docente, Docente):
 162             DocenteInscripto.selectBy(curso=self, docente=docente).getOne().destroySelf()
 163         else:
 164             DocenteInscripto.selectBy(curso=self, docenteID=docente).getOne().destroySelf()
 165
 166     def add_alumno(self, alumno, **kw):
 167         if isinstance(alumno, Alumno):
 168             kw['alumno'] = alumno
 169         else:
 170             kw['alumnoID'] = alumno
 171         return AlumnoInscripto(curso=self, **kw)
 172
 173     def remove_alumno(self, alumno):
 174         if isinstance(alumno, Alumno):
 175             AlumnoInscripto.selectBy(curso=self, alumno=alumno).getOne().destroySelf()
 176         else:
 177             AlumnoInscripto.selectBy(curso=self, alumnoID=alumno).getOne().destroySelf()
 178
 179     def add_grupo(self, nombre, **kw):
 180         return Grupo(curso=self, nombre=unicode(nombre), **kw)
 181
 182     def remove_grupo(self, nombre):
 183         Grupo.pk.get(curso=self, nombre=nombre).destroySelf()
 184
 185     def add_ejercicio(self, numero, enunciado, **kw):
 186         if isinstance(enunciado, Enunciado):
 187             kw['enunciado'] = enunciado
 188         else:
 189             kw['enunciadoID'] = enunciado
 190         return Ejercicio(curso=self, numero=numero, **kw)
 191
 192     def remove_ejercicio(self, numero):
 193         Ejercicio.pk.get(curso=self, numero=numero).destroySelf()
 194
 195     def __repr__(self):
 196         return 'Curso(id=%s, anio=%s, cuatrimestre=%s, numero=%s, ' \
 197             'descripcion=%s)' \
 198                 % (self.id, self.anio, self.cuatrimestre, self.numero,
 199                     self.descripcion)
 200
 201     def shortrepr(self):
 202         return '%s.%s.%s' \
 203             % (self.anio, self.cuatrimestre, self.numero)
 204 #}}}
 205
 206 class Usuario(InheritableSQLObject): #{{{
 207     # Clave (para docentes puede ser un nombre de usuario arbitrario)
 208     usuario         = UnicodeCol(length=10, alternateID=True)
 209     # Campos
 210     contrasenia     = UnicodeCol(length=255, default=None)
 211     nombre          = UnicodeCol(length=255, notNone=True)
 212     email           = UnicodeCol(length=255, default=None)
 213     telefono        = UnicodeCol(length=255, default=None)
 214     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 215     observaciones   = UnicodeCol(default=None)
 216     activo          = BoolCol(notNone=True, default=True)
 217     # Joins
 218     roles           = RelatedJoin('Rol', addRemoveName='_rol')
 219
 220     def __init__(self, password=None, roles=[], **kw):
 221         if password is not None:
 222             kw['contrasenia'] = encryptpw(password)
 223         super(Usuario, self).__init__(**kw)
 224         for r in roles:
 225             self.add_rol(r)
 226
 227     def set(self, password=None, roles=None, **kw):
 228         if password is not None:
 229             kw['contrasenia'] = encryptpw(password)
 230         super(Usuario, self).set(**kw)
 231         if roles is not None:
 232             for r in self.roles:
 233                 self.remove_rol(r)
 234             for r in roles:
 235                 self.add_rol(r)
 236
 237     def _get_user_name(self): # para identity
 238         return self.usuario
 239
 240     @classmethod
 241     def by_user_name(cls, user_name): # para identity
 242         user = cls.byUsuario(user_name)
 243         if not user.activo:
 244             raise SQLObjectNotFound, "The object %s with user_name %s is " \
 245                 "not active" % (cls.__name__, user_name)
 246         return user
 247
 248     def _get_groups(self): # para identity
 249         return self.roles
 250
 251     def _get_permissions(self): # para identity
 252         perms = set()
 253         for r in self.roles:
 254             perms.update(r.permisos)
 255         return perms
 256
 257     _get_permisos = _get_permissions
 258
 259     def _set_password(self, cleartext_password): # para identity
 260         self.contrasenia = encryptpw(cleartext_password)
 261
 262     def _get_password(self): # para identity
 263         return self.contrasenia
 264
 265     def __repr__(self):
 266         raise NotImplementedError, _('Clase abstracta!')
 267
 268     def shortrepr(self):
 269         return '%s (%s)' % (self.usuario, self.nombre)
 270 #}}}
 271
 272 class Docente(Usuario): #{{{
 273     _inheritable = False
 274     # Campos
 275     nombrado    = BoolCol(notNone=True, default=True)
 276     # Joins
 277     enunciados  = MultipleJoin('Enunciado', joinColumn='autor_id')
 278     cursos      = MultipleJoin('DocenteInscripto')
 279
 280     def add_entrega(self, instancia, **kw):
 281         return Entrega(instancia=instancia, **kw)
 282
 283     def add_enunciado(self, nombre, anio, cuatrimestre, **kw):
 284         return Enunciado(nombre=nombre, anio=anio, cuatrimestre=cuatrimestre,
 285             autor=self, **kw)
 286
 287     def remove_enunciado(self, nombre, anio, cuatrimestre):
 288         Enunciado.pk.get(nombre=nombre, anio=anio,
 289             cuatrimestre=cuatrimestre).destroySelf()
 290
 291     def __repr__(self):
 292         return 'Docente(id=%s, usuario=%s, nombre=%s, password=%s, email=%s, ' \
 293             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
 294                 % (self.id, self.usuario, self.nombre, self.password,
 295                     self.email, self.telefono, self.activo, self.creado,
 296                     self.observaciones)
 297 #}}}
 298
 299 class Alumno(Usuario): #{{{
 300     _inheritable = False
 301     # Campos
 302     nota            = DecimalCol(size=3, precision=1, default=None)
 303     # Joins
 304     inscripciones   = MultipleJoin('AlumnoInscripto')
 305
 306     def __init__(self, padron=None, **kw):
 307         if padron: kw['usuario'] = padron
 308         super(Alumno, self).__init__(**kw)
 309
 310     def set(self, padron=None, **kw):
 311         if padron: kw['usuario'] = padron
 312         super(Alumno, self).set(**kw)
 313
 314     def _get_padron(self): # alias para poder referirse al alumno por padron
 315         return self.usuario
 316
 317     def _set_padron(self, padron):
 318         self.usuario = padron
 319
 320     @classmethod
 321     def byPadron(cls, padron):
 322         return cls.byUsuario(unicode(padron))
 323
 324     def __repr__(self):
 325         return 'Alumno(id=%s, padron=%s, nombre=%s, password=%s, email=%s, ' \
 326             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
 327                 % (self.id, self.padron, self.nombre, self.password, self.email,
 328                     self.telefono, self.activo, self.creado, self.observaciones)
 329 #}}}
 330
 331 class Tarea(InheritableSQLObject): #{{{
 332     class sqlmeta:
 333         createSQL = dict(sqlite=r'''
 334 CREATE TABLE dependencia (
 335     padre_id INTEGER NOT NULL CONSTRAINT tarea_id_exists
 336         REFERENCES tarea(id) ON DELETE CASCADE,
 337     hijo_id INTEGER NOT NULL CONSTRAINT tarea_id_exists
 338         REFERENCES tarea(id) ON DELETE CASCADE,
 339     orden INT,
 340     PRIMARY KEY (padre_id, hijo_id)
 341 )''')
 342     # Clave
 343     nombre          = UnicodeCol(length=30, alternateID=True)
 344     # Campos
 345     descripcion     = UnicodeCol(length=255, default=None)
 346     # Joins
 347
 348     def __init__(self, dependencias=(), **kw):
 349         super(Tarea, self).__init__(**kw)
 350         if dependencias:
 351             self.dependencias = dependencias
 352
 353     def set(self, dependencias=None, **kw):
 354         super(Tarea, self).set(**kw)
 355         if dependencias is not None:
 356             self.dependencias = dependencias
 357
 358     def _get_dependencias(self):
 359         OtherTarea = Alias(Tarea, 'other_tarea')
 360         self.__dependencias = tuple(Tarea.select(
 361             AND(
 362                 Tarea.q.id == dependencia_t.hijo_id,
 363                 OtherTarea.q.id == dependencia_t.padre_id,
 364                 self.id == dependencia_t.padre_id,
 365             ),
 366             clauseTables=(dependencia_t,),
 367             orderBy=dependencia_t.orden,
 368         ))
 369         return self.__dependencias
 370
 371     def _set_dependencias(self, dependencias):
 372         orden = {}
 373         for i, t in enumerate(dependencias):
 374             orden[t.id] = i
 375         new = frozenset([t.id for t in dependencias])
 376         old = frozenset([t.id for t in self.dependencias])
 377         dependencias = dict([(t.id, t) for t in dependencias])
 378         for tid in old - new: # eliminadas
 379             self._connection.query(str(Delete(dependencia_t, where=AND(
 380                 dependencia_t.padre_id == self.id,
 381                 dependencia_t.hijo_id == tid))))
 382         for tid in new - old: # creadas
 383             self._connection.query(str(Insert(dependencia_t, values=dict(
 384                 padre_id=self.id, hijo_id=tid, orden=orden[tid]
 385             ))))
 386         for tid in new & old: # actualizados
 387             self._connection.query(str(Update(dependencia_t,
 388                 values=dict(orden=orden[tid]), where=AND(
 389                     dependencia_t.padre_id == self.id,
 390                     dependencia_t.hijo_id == tid,
 391                 ))))
 392
 393     def __repr__(self):
 394         return 'Tarea(id=%s, nombre=%s, descripcion=%s)' \
 395                 % (self.id, self.nombre, self.descripcion)
 396
 397     def shortrepr(self):
 398         return self.nombre
 399 #}}}
 400
 401 class Enunciado(SQLObject): #{{{
 402     class sqlmeta:
 403         createSQL = dict(sqlite=r'''
 404 CREATE TABLE enunciado_tarea (
 405     enunciado_id INTEGER NOT NULL CONSTRAINT enunciado_id_exists
 406         REFERENCES enunciado(id) ON DELETE CASCADE,
 407     tarea_id INTEGER NOT NULL CONSTRAINT tarea_id_exists
 408         REFERENCES tarea(id) ON DELETE CASCADE,
 409     orden INT,
 410     PRIMARY KEY (enunciado_id, tarea_id)
 411 )''')
 412     # Clave
 413     nombre          = UnicodeCol(length=60)
 414     anio            = IntCol(notNone=True)
 415     cuatrimestre    = IntCol(notNone=True)
 416     pk              = DatabaseIndex(nombre, anio, cuatrimestre, unique=True)
 417     # Campos
 418     autor           = ForeignKey('Docente', cascade='null')
 419     descripcion     = UnicodeCol(length=255, default=None)
 420     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 421     archivo         = BLOBCol(default=None)
 422     archivo_name    = UnicodeCol(length=255, default=None)
 423     archivo_type    = UnicodeCol(length=255, default=None)
 424     # Joins
 425     ejercicios      = MultipleJoin('Ejercicio')
 426     casos_de_prueba = MultipleJoin('CasoDePrueba')
 427
 428     def __init__(self, tareas=(), **kw):
 429         super(Enunciado, self).__init__(**kw)
 430         if tareas:
 431             self.tareas = tareas
 432
 433     def set(self, tareas=None, **kw):
 434         super(Enunciado, self).set(**kw)
 435         if tareas is not None:
 436             self.tareas = tareas
 437
 438     @classmethod
 439     def selectByCurso(self, curso):
 440         return Enunciado.selectBy(cuatrimestre=curso.cuatrimestre, anio=curso.anio)
 441
 442     def add_caso_de_prueba(self, nombre, **kw):
 443         return CasoDePrueba(enunciado=self, nombre=nombre, **kw)
 444
 445     def _get_tareas(self):
 446         self.__tareas = tuple(Tarea.select(
 447             AND(
 448                 Tarea.q.id == enunciado_tarea_t.tarea_id,
 449                 Enunciado.q.id == enunciado_tarea_t.enunciado_id,
 450                 Enunciado.q.id == self.id
 451             ),
 452             clauseTables=(enunciado_tarea_t, Enunciado.sqlmeta.table),
 453             orderBy=enunciado_tarea_t.orden,
 454         ))
 455         return self.__tareas
 456
 457     def _set_tareas(self, tareas):
 458         orden = {}
 459         for i, t in enumerate(tareas):
 460             orden[t.id] = i
 461         new = frozenset([t.id for t in tareas])
 462         old = frozenset([t.id for t in self.tareas])
 463         tareas = dict([(t.id, t) for t in tareas])
 464         for tid in old - new: # eliminadas
 465             self._connection.query(str(Delete(enunciado_tarea_t, where=AND(
 466                 enunciado_tarea_t.enunciado_id == self.id,
 467                 enunciado_tarea_t.tarea_id == tid))))
 468         for tid in new - old: # creadas
 469             self._connection.query(str(Insert(enunciado_tarea_t, values=dict(
 470                 enunciado_id=self.id, tarea_id=tid, orden=orden[tid]
 471             ))))
 472         for tid in new & old: # actualizados
 473             self._connection.query(str(Update(enunciado_tarea_t,
 474                 values=dict(orden=orden[tid]), where=AND(
 475                     enunciado_tarea_t.enunciado_id == self.id,
 476                     enunciado_tarea_t.tarea_id == tid,
 477                 ))))
 478
 479     def __repr__(self):
 480         return 'Enunciado(id=%s, autor=%s, nombre=%s, descripcion=%s, ' \
 481             'creado=%s)' \
 482                 % (self.id, srepr(self.autor), self.nombre, self.descripcion, \
 483                     self.creado)
 484
 485     def shortrepr(self):
 486         return self.nombre
 487 #}}}
 488
 489 class CasoDePrueba(SQLObject): #{{{
 490     # Clave
 491     enunciado       = ForeignKey('Enunciado', cascade=True)
 492     nombre          = UnicodeCol(length=40, notNone=True)
 493     pk              = DatabaseIndex(enunciado, nombre, unique=True)
 494     # Campos
 495     privado         = IntCol(default=None) # TODO iria en instancia_de_entrega_caso_de_prueba
 496     parametros      = ParamsCol(length=255, default=None)
 497     retorno         = IntCol(default=None)
 498     tiempo_cpu      = FloatCol(default=None)
 499     descripcion     = UnicodeCol(length=255, default=None)
 500     activo          = BoolCol(notNone=True, default=True)
 501     # Joins
 502     pruebas         = MultipleJoin('Prueba')
 503
 504     def __repr__(self):
 505         return 'CasoDePrueba(enunciado=%s, nombre=%s, parametros=%s, ' \
 506             'retorno=%s, tiempo_cpu=%s, descripcion=%s)' \
 507                 % (srepr(self.enunciado), self.nombre, self.parametros,
 508                     self.retorno, self.tiempo_cpu, self.descripcion)
 509
 510     def shortrepr(self):
 511         return '%s:%s' % (self.enunciado.shortrepr(), self.nombre)
 512 #}}}
 513
 514 class Ejercicio(SQLObject): #{{{
 515     # Clave
 516     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 517     numero          = IntCol(notNone=True)
 518     pk              = DatabaseIndex(curso, numero, unique=True)
 519     # Campos
 520     enunciado       = ForeignKey('Enunciado', notNone=True, cascade=False)
 521     grupal          = BoolCol(notNone=True, default=False)
 522     # Joins
 523     instancias      = MultipleJoin('InstanciaDeEntrega')
 524
 525     def add_instancia(self, numero, inicio, fin, **kw):
 526         return InstanciaDeEntrega(ejercicio=self, numero=numero, inicio=inicio,
 527             fin=fin, **kw)
 528
 529     def remove_instancia(self, numero):
 530         InstanciaDeEntrega.pk.get(ejercicio=self, numero=numero).destroySelf()
 531
 532     def __repr__(self):
 533         return 'Ejercicio(id=%s, curso=%s, numero=%s, enunciado=%s, ' \
 534             'grupal=%s)' \
 535                 % (self.id, self.curso.shortrepr(), self.numero,
 536                     self.enunciado.shortrepr(), self.grupal)
 537
 538     def shortrepr(self):
 539         return '(%s, %s, %s)' \
 540             % (self.curso.shortrepr(), str(self.numero), \
 541                 self.enunciado.shortrepr())
 542 #}}}
 543
 544 class InstanciaDeEntrega(SQLObject): #{{{
 545     class sqlmeta:
 546         createSQL = dict(sqlite=r'''
 547 CREATE TABLE instancia_tarea (
 548     instancia_id INTEGER NOT NULL CONSTRAINT instancia_id_exists
 549         REFERENCES instancia_de_entrega(id) ON DELETE CASCADE,
 550     tarea_id INTEGER NOT NULL CONSTRAINT tarea_id_exists
 551         REFERENCES tarea(id) ON DELETE CASCADE,
 552     orden INT,
 553     PRIMARY KEY (instancia_id, tarea_id)
 554 )''')
 555     # Clave
 556     ejercicio       = ForeignKey('Ejercicio', notNone=True, cascade=True)
 557     numero          = IntCol(notNone=True)
 558     pk              = DatabaseIndex(ejercicio, numero, unique=True)
 559     # Campos
 560     inicio          = DateTimeCol(notNone=True)
 561     fin             = DateTimeCol(notNone=True)
 562     procesada       = BoolCol(notNone=True, default=False)
 563     observaciones   = UnicodeCol(default=None)
 564     activo          = BoolCol(notNone=True, default=True)
 565     # Joins
 566     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
 567     correcciones    = MultipleJoin('Correccion', joinColumn='instancia_id')
 568
 569     def __init__(self, tareas=(), **kw):
 570         super(InstanciaDeEntrega, self).__init__(**kw)
 571         if tareas:
 572             self.tareas = tareas
 573
 574     def set(self, tareas=None, **kw):
 575         super(InstanciaDeEntrega, self).set(**kw)
 576         if tareas is not None:
 577             self.tareas = tareas
 578
 579     def _get_tareas(self):
 580         self.__tareas = tuple(Tarea.select(
 581             AND(
 582                 Tarea.q.id == instancia_tarea_t.tarea_id,
 583                 InstanciaDeEntrega.q.id == instancia_tarea_t.instancia_id,
 584                 InstanciaDeEntrega.q.id == self.id,
 585             ),
 586             clauseTables=(instancia_tarea_t, InstanciaDeEntrega.sqlmeta.table),
 587             orderBy=instancia_tarea_t.orden,
 588         ))
 589         return self.__tareas
 590
 591     def _set_tareas(self, tareas):
 592         orden = {}
 593         for i, t in enumerate(tareas):
 594             orden[t.id] = i
 595         new = frozenset([t.id for t in tareas])
 596         old = frozenset([t.id for t in self.tareas])
 597         tareas = dict([(t.id, t) for t in tareas])
 598         for tid in old - new: # eliminadas
 599             self._connection.query(str(Delete(instancia_tarea_t, where=AND(
 600                 instancia_tarea_t.instancia_id == self.id,
 601                 instancia_tarea_t.tarea_id == tid))))
 602         for tid in new - old: # creadas
 603             self._connection.query(str(Insert(instancia_tarea_t, values=dict(
 604                 instancia_id=self.id, tarea_id=tid, orden=orden[tid]
 605             ))))
 606         for tid in new & old: # actualizados
 607             self._connection.query(str(Update(instancia_tarea_t,
 608                 values=dict(orden=orden[tid]), where=AND(
 609                     instancia_tarea_t.instancia_id == self.id,
 610                     instancia_tarea_t.tarea_id == tid,
 611                 ))))
 612
 613     def __repr__(self):
 614         return 'InstanciaDeEntrega(id=%s, numero=%s, inicio=%s, fin=%s, ' \
 615             'procesada=%s, observaciones=%s, activo=%s)' \
 616                 % (self.id, self.numero, self.inicio, self.fin,
 617                     self.procesada, self.observaciones, self.activo)
 618
 619     def shortrepr(self):
 620         return self.numero
 621 #}}}
 622
 623 class DocenteInscripto(SQLObject): #{{{
 624     # Clave
 625     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 626     docente         = ForeignKey('Docente', notNone=True, cascade=True)
 627     pk              = DatabaseIndex(curso, docente, unique=True)
 628     # Campos
 629     corrige         = BoolCol(notNone=True, default=True)
 630     observaciones   = UnicodeCol(default=None)
 631     # Joins
 632     alumnos         = MultipleJoin('AlumnoInscripto', joinColumn='tutor_id')
 633     tutorias        = MultipleJoin('Tutor', joinColumn='docente_id')
 634     correcciones    = MultipleJoin('Correccion', joinColumn='corrector_id')
 635
 636     def add_correccion(self, entrega, **kw):
 637         return Correccion(instancia=entrega.instancia, entrega=entrega,
 638             entregador=entrega.entregador, corrector=self, **kw)
 639
 640     def remove_correccion(self, instancia, entregador):
 641         Correccion.pk.get(instancia=instancia,
 642             entregador=entregador).destroySelf()
 643
 644     def __repr__(self):
 645         return 'DocenteInscripto(id=%s, docente=%s, corrige=%s, ' \
 646             'observaciones=%s' \
 647                 % (self.id, self.docente.shortrepr(), self.corrige,
 648                     self.observaciones)
 649
 650     def shortrepr(self):
 651         return self.docente.shortrepr()
 652 #}}}
 653
 654 class Entregador(InheritableSQLObject): #{{{
 655     # Campos
 656     nota            = DecimalCol(size=3, precision=1, default=None)
 657     nota_cursada    = DecimalCol(size=3, precision=1, default=None)
 658     observaciones   = UnicodeCol(default=None)
 659     activo          = BoolCol(notNone=True, default=True)
 660     # Joins
 661     entregas        = MultipleJoin('Entrega')
 662     correcciones    = MultipleJoin('Correccion')
 663
 664     def add_entrega(self, instancia, **kw):
 665         return Entrega(instancia=instancia, entregador=self, **kw)
 666
 667     def __repr__(self):
 668         raise NotImplementedError, 'Clase abstracta!'
 669 #}}}
 670
 671 class Grupo(Entregador): #{{{
 672     _inheritable = False
 673     # Clave
 674     curso           = ForeignKey('Curso', notNone=True, cascade=True)
 675     nombre          = UnicodeCol(length=20, notNone=True)
 676     pk              = DatabaseIndex(curso, nombre, unique=True)
 677     # Campos
 678     responsable     = ForeignKey('AlumnoInscripto', default=None, cascade='null')
 679     # Joins
 680     miembros        = MultipleJoin('Miembro')
 681     tutores         = MultipleJoin('Tutor')
 682
 683     def __init__(self, miembros=[], tutores=[], **kw):
 684         super(Grupo, self).__init__(**kw)
 685         for a in miembros:
 686             self.add_miembro(a)
 687         for d in tutores:
 688             self.add_tutor(d)
 689
 690     def set(self, miembros=None, tutores=None, **kw):
 691         super(Grupo, self).set(**kw)
 692         if miembros is not None:
 693             for m in Miembro.selectBy(grupo=self):
 694                 m.destroySelf()
 695             for m in miembros:
 696                 self.add_miembro(m)
 697         if tutores is not None:
 698             for t in Tutor.selectBy(grupo=self):
 699                 t.destroySelf()
 700             for t in tutores:
 701                 self.add_tutor(t)
 702
 703     def add_miembro(self, alumno, **kw):
 704         if isinstance(alumno, AlumnoInscripto):
 705             kw['alumno'] = alumno
 706         else:
 707             kw['alumnoID'] = alumno
 708         return Miembro(grupo=self, **kw)
 709
 710     def remove_miembro(self, alumno):
 711         if isinstance(alumno, AlumnoInscripto):
 712             Miembro.pk.get(grupo=self, alumno=alumno).destroySelf()
 713         else:
 714             Miembro.pk.get(grupo=self, alumnoID=alumno).destroySelf()
 715
 716     def add_tutor(self, docente, **kw):
 717         if isinstance(docente, DocenteInscripto):
 718             kw['docente'] = docente
 719         else:
 720             kw['docenteID'] = docente
 721         return Tutor(grupo=self, **kw)
 722
 723     def remove_tutor(self, docente):
 724         if isinstance(docente, DocenteInscripto):
 725             Tutor.pk.get(grupo=self, docente=docente).destroySelf()
 726         else:
 727             Tutor.pk.get(grupo=self, docenteID=docente).destroySelf()
 728
 729     def __repr__(self):
 730         return 'Grupo(id=%s, nombre=%s, responsable=%s, nota=%s, ' \
 731             'nota_cursada=%s, observaciones=%s, activo=%s)' \
 732                 % (self.id, self.nombre, srepr(self.responsable), self.nota,
 733                     self.nota_cursada, self.observaciones, self.activo)
 734
 735     def shortrepr(self):
 736         return 'grupo:' + self.nombre
 737 #}}}
 738
 739 class AlumnoInscripto(Entregador): #{{{
 740     _inheritable = False
 741     # Clave
 742     curso               = ForeignKey('Curso', notNone=True, cascade=True)
 743     alumno              = ForeignKey('Alumno', notNone=True, cascade=True)
 744     pk                  = DatabaseIndex(curso, alumno, unique=True)
 745     # Campos
 746     condicional         = BoolCol(notNone=True, default=False)
 747     tutor               = ForeignKey('DocenteInscripto', default=None, cascade='null')
 748     # Joins
 749     responsabilidades   = MultipleJoin('Grupo', joinColumn='responsable_id')
 750     membresias          = MultipleJoin('Miembro', joinColumn='alumno_id')
 751     entregas            = MultipleJoin('Entrega', joinColumn='alumno_id')
 752     correcciones        = MultipleJoin('Correccion', joinColumn='alumno_id')
 753
 754     def __repr__(self):
 755         return 'AlumnoInscripto(id=%s, alumno=%s, condicional=%s, nota=%s, ' \
 756             'nota_cursada=%s, tutor=%s, observaciones=%s, activo=%s)' \
 757                 % (self.id, self.alumno.shortrepr(), self.condicional,
 758                     self.nota, self.nota_cursada, srepr(self.tutor),
 759                     self.observaciones, self.activo)
 760
 761     def shortrepr(self):
 762         return self.alumno.shortrepr()
 763 #}}}
 764
 765 class Tutor(SQLObject): #{{{
 766     # Clave
 767     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
 768     docente         = ForeignKey('DocenteInscripto', notNone=True, cascade=True)
 769     pk              = DatabaseIndex(grupo, docente, unique=True)
 770     # Campos
 771     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 772     baja            = DateTimeCol(default=None)
 773
 774     def __repr__(self):
 775         return 'Tutor(docente=%s, grupo=%s, alta=%s, baja=%s)' \
 776                 % (self.docente.shortrepr(), self.grupo.shortrepr(),
 777                     self.alta, self.baja)
 778
 779     def shortrepr(self):
 780         return '%s-%s' % (self.docente.shortrepr(), self.grupo.shortrepr())
 781 #}}}
 782
 783 class Miembro(SQLObject): #{{{
 784     # Clave
 785     grupo           = ForeignKey('Grupo', notNone=True, cascade=True)
 786     alumno          = ForeignKey('AlumnoInscripto', notNone=True, cascade=True)
 787     pk              = DatabaseIndex(grupo, alumno, unique=True)
 788     # Campos
 789     nota            = DecimalCol(size=3, precision=1, default=None)
 790     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 791     baja            = DateTimeCol(default=None)
 792
 793     def __repr__(self):
 794         return 'Miembro(alumno=%s, grupo=%s, nota=%s, alta=%s, baja=%s)' \
 795                 % (self.alumno.shortrepr(), self.grupo.shortrepr(),
 796                     self.nota, self.alta, self.baja)
 797
 798     def shortrepr(self):
 799         return '%s-%s' % (self.alumno.shortrepr(), self.grupo.shortrepr())
 800 #}}}
 801
 802 class Entrega(SQLObject): #{{{
 803     # Clave
 804     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
 805     entregador      = ForeignKey('Entregador', default=None, cascade=False) # Si es None era un Docente
 806     fecha           = DateTimeCol(notNone=True, default=DateTimeCol.now)
 807     pk              = DatabaseIndex(instancia, entregador, fecha, unique=True)
 808     # Campos
 809     correcta        = BoolCol(notNone=True, default=False)
 810     observaciones   = UnicodeCol(default=None)
 811     # Joins
 812     tareas          = MultipleJoin('TareaEjecutada')
 813     # Para generar código
 814     codigo_dict     = r'0123456789abcdefghijklmnopqrstuvwxyz_.,*@#+'
 815     codigo_format   = r'%m%d%H%M%S'
 816
 817     def add_tarea_ejecutada(self, tarea, **kw):
 818         return TareaEjecutada(tarea=tarea, entrega=self, **kw)
 819
 820     def _get_codigo(self):
 821         if not hasattr(self, '_codigo'): # cache
 822             n = long(self.fecha.strftime(Entrega.codigo_format))
 823             d = Entrega.codigo_dict
 824             l = len(d)
 825             res = ''
 826             while n:
 827                     res += d[n % l]
 828                     n /= l
 829             self._codigo = res
 830         return self._codigo
 831
 832     def _set_fecha(self, fecha):
 833         self._SO_set_fecha(fecha)
 834         if hasattr(self, '_codigo'): del self._codigo # bye, bye cache!
 835
 836     def __repr__(self):
 837         return 'Entrega(instancia=%s, entregador=%s, codigo=%s, fecha=%s, ' \
 838             'correcta=%s, observaciones=%s)' \
 839                 % (self.instancia.shortrepr(), srepr(self.entregador),
 840                     self.codigo, self.fecha, self.correcta, self.observaciones)
 841
 842     def shortrepr(self):
 843         return '%s-%s-%s' % (self.instancia.shortrepr(), srepr(self.entregador),
 844             self.codigo)
 845 #}}}
 846
 847 class Correccion(SQLObject): #{{{
 848     # Clave
 849     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True, cascade=False)
 850     entregador      = ForeignKey('Entregador', notNone=True, cascade=False) # Docente no tiene
 851     pk              = DatabaseIndex(instancia, entregador, unique=True)
 852     # Campos
 853     entrega         = ForeignKey('Entrega', notNone=True, cascade=False)
 854     corrector       = ForeignKey('DocenteInscripto', default=None, cascade='null')
 855     asignado        = DateTimeCol(notNone=True, default=DateTimeCol.now)
 856     corregido       = DateTimeCol(default=None)
 857     nota            = DecimalCol(size=3, precision=1, default=None)
 858     observaciones   = UnicodeCol(default=None)
 859
 860     def _get_entregas(self):
 861         return list(Entrega.selectBy(instancia=self.instancia, entregador=self.entregador))
 862
 863     def __repr__(self):
 864         return 'Correccion(instancia=%s, entregador=%s, entrega=%s, ' \
 865             'corrector=%s, asignado=%s, corregido=%s, nota=%s, ' \
 866             'observaciones=%s)' \
 867                 % (self.instancia.shortrepr(), self.entregador.shortrepr(),
 868                     self.entrega.shortrepr(), self.corrector, self.asignado,
 869                     self.corregido, self.nota, self.observaciones)
 870
 871     def shortrepr(self):
 872         if not self.corrector:
 873             return '%s' % self.entrega.shortrepr()
 874         return '%s,%s' % (self.entrega.shortrepr(), self.corrector.shortrepr())
 875 #}}}
 876
 877 class TareaEjecutada(InheritableSQLObject): #{{{
 878     # Clave
 879     tarea           = ForeignKey('Tarea', notNone=True, cascade=False)
 880     entrega         = ForeignKey('Entrega', notNone=True, cascade=False)
 881     pk              = DatabaseIndex(tarea, entrega, unique=True)
 882     # Campos
 883     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 884     fin             = DateTimeCol(default=None)
 885     exito           = IntCol(default=None)
 886     observaciones   = UnicodeCol(default=None)
 887     # Joins
 888     pruebas         = MultipleJoin('Prueba')
 889
 890     def add_prueba(self, caso_de_prueba, **kw):
 891         return Prueba(tarea_ejecutada=self, caso_de_prueba=caso_de_prueba,
 892             **kw)
 893
 894     def __repr__(self):
 895         return 'TareaEjecutada(tarea=%s, entrega=%s, inicio=%s, fin=%s, ' \
 896             'exito=%s, observaciones=%s)' \
 897                 % (self.tarea.shortrepr(), self.entrega.shortrepr(),
 898                     self.inicio, self.fin, self.exito, self.observaciones)
 899
 900     def shortrepr(self):
 901         return '%s-%s' % (self.tarea.shortrepr(), self.entrega.shortrepr())
 902 #}}}
 903
 904 class Prueba(SQLObject): #{{{
 905     # Clave
 906     tarea_ejecutada = ForeignKey('TareaEjecutada', notNone=True, cascade=False)
 907     caso_de_prueba  = ForeignKey('CasoDePrueba', notNone=True, cascade=False)
 908     pk              = DatabaseIndex(tarea_ejecutada, caso_de_prueba, unique=True)
 909     # Campos
 910     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 911     fin             = DateTimeCol(default=None)
 912     pasada          = IntCol(default=None)
 913     observaciones   = UnicodeCol(default=None)
 914
 915     def __repr__(self):
 916         return 'Prueba(tarea_ejecutada=%s, caso_de_prueba=%s, inicio=%s, ' \
 917             'fin=%s, pasada=%s, observaciones=%s)' \
 918                 % (self.tarea_ejecutada.shortrepr(),
 919                     self.caso_de_prueba.shortrepr(), self.inicio, self.fin,
 920                     self.pasada, self.observaciones)
 921
 922     def shortrepr(self):
 923         return '%s:%s' % (self.tarea_ejecutada.shortrepr(),
 924             self.caso_de_prueba.shortrerp())
 925 #}}}
 926
 927 #{{{ Específico de Identity
 928
 929 class Visita(SQLObject): #{{{
 930     visit_key   = StringCol(length=40, alternateID=True,
 931                     alternateMethodName="by_visit_key")
 932     created     = DateTimeCol(notNone=True, default=datetime.now)
 933     expiry      = DateTimeCol()
 934
 935     @classmethod
 936     def lookup_visit(cls, visit_key):
 937         try:
 938             return cls.by_visit_key(visit_key)
 939         except SQLObjectNotFound:
 940             return None
 941 #}}}
 942
 943 class VisitaUsuario(SQLObject): #{{{
 944     # Clave
 945     visit_key   = StringCol(length=40, alternateID=True,
 946                           alternateMethodName="by_visit_key")
 947     # Campos
 948     user_id     = IntCol() # Negrada de identity
 949 #}}}
 950
 951 class Rol(SQLObject): #{{{
 952     # Clave
 953     nombre      = UnicodeCol(length=255, alternateID=True,
 954                     alternateMethodName='by_nombre')
 955     # Campos
 956     descripcion = UnicodeCol(length=255, default=None)
 957     creado      = DateTimeCol(notNone=True, default=datetime.now)
 958     permisos    = TupleCol(notNone=True)
 959     # Joins
 960     usuarios    = RelatedJoin('Usuario', addRemoveName='_usuario')
 961
 962     def by_group_name(self, name): # para identity
 963         return self.by_nombre(name)
 964 #}}}
 965
 966 # No es un SQLObject porque no tiene sentido agregar/sacar permisos, están
 967 # hardcodeados en el código
 968 class Permiso(object): #{{{
 969     max_valor = 1
 970     def __init__(self, nombre, descripcion):
 971         self.valor = Permiso.max_valor
 972         Permiso.max_valor <<= 1
 973         self.nombre = nombre
 974         self.descripcion = descripcion
 975
 976     @classmethod
 977     def createTable(cls, ifNotExists): # para identity
 978         pass
 979
 980     @property
 981     def permission_name(self): # para identity
 982         return self.nombre
 983
 984     def __and__(self, other):
 985         return self.valor & other.valor
 986
 987     def __or__(self, other):
 988         return self.valor | other.valor
 989
 990     def __repr__(self):
 991         return self.nombre
 992 #}}}
 993
 994 # TODO ejemplos
 995 entregar_tp = Permiso(u'entregar', u'Permite entregar trabajos prácticos')
 996 admin = Permiso(u'admin', u'Permite hacer ABMs arbitrarios')
 997
 998 #}}} Identity
 999
1000 #}}} Clases
1001