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