sercom/model.py

   1 # vim: set et sw=4 sts=4 encoding=utf-8 :
   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
   9 from turbogears import identity
  10
  11 hub = PackageHub("sercom")
  12 __connection__ = hub
  13
  14 __all__ = ('Curso', 'Usuario', 'Docente', 'Alumno', 'Tarea', 'CasoDePrueba')
  15
  16 #{{{ Custom Columns
  17
  18 class TupleValidator(PickleValidator):
  19     """
  20     Validator for tuple types.  A tuple type is simply a pickle type
  21     that validates that the represented type is a tuple.
  22     """
  23
  24     def to_python(self, value, state):
  25         value = super(TupleValidator, self).to_python(value, state)
  26         if value is None:
  27             return None
  28         if isinstance(value, tuple):
  29             return value
  30         raise validators.Invalid("expected a tuple in the TupleCol '%s', got %s %r instead" % \
  31             (self.name, type(value), value), value, state)
  32
  33     def from_python(self, value, state):
  34         if value is None:
  35             return None
  36         if not isinstance(value, tuple):
  37             raise validators.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
  43     def __init__(self, **kw):
  44         super(SOTupleCol, self).__init__(**kw)
  45
  46     def createValidators(self):
  47         return [TupleValidator(name=self.name)] + \
  48             super(SOPickleCol, self).createValidators()
  49
  50 class TupleCol(PickleCol):
  51     baseClass = SOTupleCol
  52
  53 #}}}
  54
  55 #{{{ Tablas intermedias
  56
  57
  58 # BUG en SQLObject, SQLExpression no tiene cálculo de hash pero se usa como
  59 # key de un dict. Workarround hasta que lo arreglen.
  60 SQLExpression.__hash__ = lambda self: hash(str(self))
  61
  62 instancia_tarea_t = table.instancia_tarea
  63
  64 enunciado_tarea_t = table.enunciado_tarea
  65
  66 dependencia_t = table.dependencia
  67
  68 #}}}
  69
  70 #{{{ Clases
  71
  72 def srepr(obj): #{{{
  73     if obj is not None:
  74         return obj.shortrepr()
  75     return obj
  76 #}}}
  77
  78 class ByObject(object): #{{{
  79     @classmethod
  80     def by(cls, **kw):
  81         try:
  82             return cls.selectBy(**kw)[0]
  83         except IndexError:
  84             raise SQLObjectNotFound, "The object %s with columns %s does not exist" % (cls.__name__, kw)
  85 #}}}
  86
  87 class Curso(SQLObject, ByObject): #{{{
  88     # Clave
  89     anio            = IntCol(notNone=True)
  90     cuatrimestre    = IntCol(notNone=True)
  91     numero          = IntCol(notNone=True)
  92     pk              = DatabaseIndex(anio, cuatrimestre, numero, unique=True)
  93     # Campos
  94     descripcion     = UnicodeCol(length=255, default=None)
  95     # Joins
  96     docentes        = MultipleJoin('DocenteInscripto')
  97     alumnos         = MultipleJoin('AlumnoInscripto')
  98     grupos          = MultipleJoin('Grupo')
  99     ejercicios      = MultipleJoin('Ejercicio', orderBy='numero')
 100
 101     def add_docente(self, docente, **opts):
 102         return DocenteInscripto(cursoID=self.id, docenteID=docente.id, **opts)
 103
 104     def add_alumno(self, alumno, tutor=None, **opts):
 105         tutor_id = tutor and tutor.id
 106         return AlumnoInscripto(cursoID=self.id, alumnoID=alumno.id,
 107             tutorID=tutor_id, **opts)
 108
 109     def add_grupo(self, nombre, responsable=None, **opts):
 110         resp_id = responsable and responsable.id
 111         return Grupo(cursoID=self.id, nombre=unicode(nombre),
 112             responsableID=resp_id, **opts)
 113
 114     def add_ejercicio(self, numero, enunciado, **opts):
 115         return Ejercicio(cursoID=self.id, numero=numero,
 116             enunciadoID=enunciado.id, **opts)
 117
 118     def __repr__(self):
 119         return 'Curso(id=%s, anio=%s, cuatrimestre=%s, numero=%s, ' \
 120             'descripcion=%s)' \
 121                 % (self.id, self.anio, self.cuatrimestre, self.numero,
 122                     self.descripcion)
 123
 124     def shortrepr(self):
 125         return '%s.%s.%s' \
 126             % (self.anio, self.cuatrimestre, self.numero, self.descripcion)
 127 #}}}
 128
 129 class Usuario(InheritableSQLObject, ByObject): #{{{
 130     # Clave (para docentes puede ser un nombre de usuario arbitrario)
 131     usuario         = UnicodeCol(length=10, alternateID=True)
 132     # Campos
 133     contrasenia     = UnicodeCol(length=255, default=None)
 134     nombre          = UnicodeCol(length=255, notNone=True)
 135     email           = UnicodeCol(length=255, default=None)
 136     telefono        = UnicodeCol(length=255, default=None)
 137     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 138     observaciones   = UnicodeCol(default=None)
 139     activo          = BoolCol(notNone=True, default=True)
 140     # Joins
 141     grupos          = RelatedJoin('Grupo')
 142     roles           = RelatedJoin('Rol')
 143
 144     def _get_user_name(self): # para identity
 145         return self.usuario
 146
 147     @classmethod
 148     def by_user_name(cls, user_name): # para identity
 149         user = cls.byUsuario(user_name)
 150         if not user.activo:
 151             raise SQLObjectNotFound, "The object %s with user_name %s is " \
 152                 "not active" % (cls.__name__, user_name)
 153         return user
 154
 155     def _get_groups(self): # para identity
 156         return self.roles
 157
 158     def _get_permissions(self): # para identity
 159         perms = set()
 160         for g in self.groups:
 161             perms.update(g.permisos)
 162         return perms
 163
 164     def _set_password(self, cleartext_password): # para identity
 165         self.contrasenia = identity.encrypt_password(cleartext_password)
 166
 167     def _get_password(self): # para identity
 168         return self.contrasenia
 169
 170     def __repr__(self):
 171         raise NotImplementedError, 'Clase abstracta!'
 172
 173     def shortrepr(self):
 174         return '%s (%s)' % (self.usuario, self.nombre)
 175 #}}}
 176
 177 class Docente(Usuario): #{{{
 178     _inheritable = False
 179     # Campos
 180     nombrado        = BoolCol(notNone=True, default=True)
 181     # Joins
 182     enunciados      = MultipleJoin('Enunciado', joinColumn='autor_id')
 183     inscripciones   = MultipleJoin('DocenteInscripto')
 184
 185     def add_entrega(self, instancia, **opts):
 186         return Entrega(instanciaID=instancia.id, **opts)
 187
 188     def add_enunciado(self, nombre, **opts):
 189         return Enunciado(autorID=self.id, nombre=nombre, **opts)
 190
 191     def __repr__(self):
 192         return 'Docente(id=%s, usuario=%s, nombre=%s, password=%s, email=%s, ' \
 193             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
 194                 % (self.id, self.usuario, self.nombre, self.password,
 195                     self.email, self.telefono, self.activo, self.creado,
 196                     self.observaciones)
 197 #}}}
 198
 199 class Alumno(Usuario): #{{{
 200     _inheritable = False
 201     # Campos
 202     nota            = DecimalCol(size=3, precision=1, default=None)
 203     # Joins
 204     inscripciones   = MultipleJoin('AlumnoInscripto')
 205
 206     def _get_padron(self): # alias para poder referirse al alumno por padron
 207         return self.usuario
 208
 209     def _set_padron(self, padron):
 210         self.usuario = padron
 211
 212     def __repr__(self):
 213         return 'Alumno(id=%s, padron=%s, nombre=%s, password=%s, email=%s, ' \
 214             'telefono=%s, activo=%s, creado=%s, observaciones=%s)' \
 215                 % (self.id, self.padron, self.nombre, self.password, self.email,
 216                     self.telefono, self.activo, self.creado, self.observaciones)
 217 #}}}
 218
 219 class Tarea(InheritableSQLObject, ByObject): #{{{
 220     # Clave
 221     nombre          = UnicodeCol(length=30, alternateID=True)
 222     # Campos
 223     descripcion     = UnicodeCol(length=255, default=None)
 224     # Joins
 225
 226     def _get_dependencias(self):
 227         OtherTarea = Alias(Tarea, 'other_tarea')
 228         self.__dependencias = tuple(Tarea.select(
 229             AND(
 230                 Tarea.q.id == dependencia_t.hijo_id,
 231                 OtherTarea.q.id == dependencia_t.padre_id,
 232                 self.id == dependencia_t.padre_id,
 233             ),
 234             clauseTables=(dependencia_t,),
 235             orderBy=dependencia_t.orden,
 236         ))
 237         return self.__dependencias
 238
 239     def _set_dependencias(self, dependencias):
 240         orden = {}
 241         for i, t in enumerate(dependencias):
 242             orden[t.id] = i
 243         new = frozenset([t.id for t in dependencias])
 244         old = frozenset([t.id for t in self.dependencias])
 245         dependencias = dict([(t.id, t) for t in dependencias])
 246         for tid in old - new: # eliminadas
 247             self._connection.query(str(Delete(dependencia_t, where=AND(
 248                 dependencia_t.padre_id == self.id,
 249                 dependencia_t.hijo_id == tid))))
 250         for tid in new - old: # creadas
 251             self._connection.query(str(Insert(dependencia_t, values=dict(
 252                 padre_id=self.id, hijo_id=tid, orden=orden[tid]
 253             ))))
 254         for tid in new & old: # actualizados
 255             self._connection.query(str(Update(dependencia_t,
 256                 values=dict(orden=orden[tid]), where=AND(
 257                     dependencia_t.padre_id == self.id,
 258                     dependencia_t.hijo_id == tid,
 259                 ))))
 260
 261     def __repr__(self):
 262         return 'Tarea(id=%s, nombre=%s, descripcion=%s)' \
 263                 % (self.id, self.nombre, self.descripcion)
 264
 265     def shortrepr(self):
 266         return self.nombre
 267 #}}}
 268
 269 class Enunciado(SQLObject, ByObject): #{{{
 270     # Clave
 271     nombre          = UnicodeCol(length=60, alternateID=True)
 272     # Campos
 273     descripcion     = UnicodeCol(length=255, default=None)
 274     autor           = ForeignKey('Docente', default=None)
 275     creado          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 276     # Joins
 277     ejercicios      = MultipleJoin('Ejercicio')
 278     casos_de_prueba = MultipleJoin('CasoDePrueba')
 279
 280     def add_caso_de_prueba(self, nombre, **opts):
 281         return CasoDePrueba(enunciadoID=self.id, nombre=nombre, **opts)
 282
 283     def _get_tareas(self):
 284         self.__tareas = tuple(Tarea.select(
 285             AND(
 286                 Tarea.q.id == enunciado_tarea_t.tarea_id,
 287                 Enunciado.q.id == enunciado_tarea_t.enunciado_id,
 288                 Enunciado.q.id == self.id
 289             ),
 290             clauseTables=(enunciado_tarea_t, Enunciado.sqlmeta.table),
 291             orderBy=enunciado_tarea_t.orden,
 292         ))
 293         return self.__tareas
 294
 295     def _set_tareas(self, tareas):
 296         orden = {}
 297         for i, t in enumerate(tareas):
 298             orden[t.id] = i
 299         new = frozenset([t.id for t in tareas])
 300         old = frozenset([t.id for t in self.tareas])
 301         tareas = dict([(t.id, t) for t in tareas])
 302         for tid in old - new: # eliminadas
 303             self._connection.query(str(Delete(enunciado_tarea_t, where=AND(
 304                 enunciado_tarea_t.enunciado_id == self.id,
 305                 enunciado_tarea_t.tarea_id == tid))))
 306         for tid in new - old: # creadas
 307             self._connection.query(str(Insert(enunciado_tarea_t, values=dict(
 308                 enunciado_id=self.id, tarea_id=tid, orden=orden[tid]
 309             ))))
 310         for tid in new & old: # actualizados
 311             self._connection.query(str(Update(enunciado_tarea_t,
 312                 values=dict(orden=orden[tid]), where=AND(
 313                     enunciado_tarea_t.enunciado_id == self.id,
 314                     enunciado_tarea_t.tarea_id == tid,
 315                 ))))
 316
 317     def __repr__(self):
 318         return 'Enunciado(id=%s, autor=%s, nombre=%s, descripcion=%s, ' \
 319             'creado=%s)' \
 320                 % (self.id, srepr(self.autor), self.nombre, self.descripcion, \
 321                     self.creado)
 322
 323     def shortrepr(self):
 324         return self.nombre
 325 #}}}
 326
 327 class CasoDePrueba(SQLObject): #{{{
 328     # Clave
 329     enunciado       = ForeignKey('Enunciado')
 330     nombre          = UnicodeCol(length=40, notNone=True)
 331     pk              = DatabaseIndex(enunciado, nombre, unique=True)
 332     # Campos
 333 #    privado         = IntCol(default=None) TODO iria en instancia_de_entrega_caso_de_prueba
 334     parametros      = TupleCol(notNone=True, default=())
 335     retorno         = IntCol(default=None)
 336     tiempo_cpu      = FloatCol(default=None)
 337     descripcion     = UnicodeCol(length=255, default=None)
 338     # Joins
 339     pruebas         = MultipleJoin('Prueba')
 340
 341     def __repr__(self):
 342         return 'CasoDePrueba(enunciado=%s, nombre=%s, parametros=%s, ' \
 343             'retorno=%s, tiempo_cpu=%s, descripcion=%s)' \
 344                 % (self.enunciado.shortrepr(), self.nombre, self.parametros,
 345                     self.retorno, self.tiempo_cpu, self.descripcion)
 346
 347     def shortrepr(self):
 348         return '%s:%s' % (self.enunciado.shortrepr(), self.nombre)
 349 #}}}
 350
 351 class Ejercicio(SQLObject, ByObject): #{{{
 352     # Clave
 353     curso           = ForeignKey('Curso', notNone=True)
 354     numero          = IntCol(notNone=True)
 355     pk              = DatabaseIndex(curso, numero, unique=True)
 356     # Campos
 357     enunciado       = ForeignKey('Enunciado', notNone=True)
 358     grupal          = BoolCol(notNone=True, default=False)
 359     # Joins
 360     instancias      = MultipleJoin('InstanciaDeEntrega')
 361
 362     def add_instancia(self, numero, inicio, fin, **opts):
 363         return InstanciaDeEntrega(ejercicioID=self.id, numero=numero,
 364             inicio=inicio, fin=fin, **opts)
 365
 366     def __repr__(self):
 367         return 'Ejercicio(id=%s, curso=%s, numero=%s, enunciado=%s, ' \
 368             'grupal=%s)' \
 369                 % (self.id, self.curso.shortrepr(), self.numero,
 370                     self.enunciado.shortrepr(), self.grupal)
 371
 372     def shortrepr(self):
 373         return '(%s, %s, %s)' \
 374             % (self.curso.shortrepr(), self.nombre, \
 375                 self.enunciado.shortrepr())
 376 #}}}
 377
 378 class InstanciaDeEntrega(SQLObject, ByObject): #{{{
 379     # Clave
 380     ejercicio       = ForeignKey('Ejercicio', notNone=True)
 381     numero          = IntCol(notNone=True)
 382     # Campos
 383     inicio          = DateTimeCol(notNone=True)
 384     fin             = DateTimeCol(notNone=True)
 385     procesada       = BoolCol(notNone=True, default=False)
 386     observaciones   = UnicodeCol(default=None)
 387     activo          = BoolCol(notNone=True, default=True)
 388     # Joins
 389     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
 390     correcciones    = MultipleJoin('Correccion', joinColumn='instancia_id')
 391     casos_de_prueba = RelatedJoin('CasoDePrueba') # TODO CasoInstancia -> private
 392
 393     def _get_tareas(self):
 394         self.__tareas = tuple(Tarea.select(
 395             AND(
 396                 Tarea.q.id == instancia_tarea_t.tarea_id,
 397                 InstanciaDeEntrega.q.id == instancia_tarea_t.instancia_id,
 398                 InstanciaDeEntrega.q.id == self.id,
 399             ),
 400             clauseTables=(instancia_tarea_t, InstanciaDeEntrega.sqlmeta.table),
 401             orderBy=instancia_tarea_t.orden,
 402         ))
 403         return self.__tareas
 404
 405     def _set_tareas(self, tareas):
 406         orden = {}
 407         for i, t in enumerate(tareas):
 408             orden[t.id] = i
 409         new = frozenset([t.id for t in tareas])
 410         old = frozenset([t.id for t in self.tareas])
 411         tareas = dict([(t.id, t) for t in tareas])
 412         for tid in old - new: # eliminadas
 413             self._connection.query(str(Delete(instancia_tarea_t, where=AND(
 414                 instancia_tarea_t.instancia_id == self.id,
 415                 instancia_tarea_t.tarea_id == tid))))
 416         for tid in new - old: # creadas
 417             self._connection.query(str(Insert(instancia_tarea_t, values=dict(
 418                 instancia_id=self.id, tarea_id=tid, orden=orden[tid]
 419             ))))
 420         for tid in new & old: # actualizados
 421             self._connection.query(str(Update(instancia_tarea_t,
 422                 values=dict(orden=orden[tid]), where=AND(
 423                     instancia_tarea_t.instancia_id == self.id,
 424                     instancia_tarea_t.tarea_id == tid,
 425                 ))))
 426
 427     def __repr__(self):
 428         return 'InstanciaDeEntrega(id=%s, numero=%s, inicio=%s, fin=%s, ' \
 429             'procesada=%s, observaciones=%s, activo=%s)' \
 430                 % (self.id, self.numero, self.inicio, self.fin,
 431                     self.procesada, self.observaciones, self.activo)
 432
 433     def shortrepr(self):
 434         return self.numero
 435 #}}}
 436
 437 class DocenteInscripto(SQLObject, ByObject): #{{{
 438     # Clave
 439     curso           = ForeignKey('Curso', notNone=True)
 440     docente         = ForeignKey('Docente', notNone=True)
 441     pk              = DatabaseIndex(curso, docente, unique=True)
 442     # Campos
 443     corrige         = BoolCol(notNone=True, default=True)
 444     observaciones   = UnicodeCol(default=None)
 445     # Joins
 446     alumnos         = MultipleJoin('AlumnoInscripto', joinColumn='tutor_id')
 447     tutorias        = MultipleJoin('Tutor', joinColumn='docente_id')
 448     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
 449     correcciones    = MultipleJoin('Correccion', joinColumn='corrector_id')
 450
 451     def add_correccion(self, entrega, **opts):
 452         return Correccion(correctorID=self.id, instanciaID=entrega.instancia.id,
 453             entregadorID=entrega.entregador.id, entregaID=entrega.id, **opts)
 454
 455     def __repr__(self):
 456         return 'DocenteInscripto(id=%s, docente=%s, corrige=%s, ' \
 457             'observaciones=%s' \
 458                 % (self.id, self.docente.shortrepr(), self.corrige,
 459                     self.observaciones)
 460
 461     def shortrepr(self):
 462         return self.docente.shortrepr()
 463 #}}}
 464
 465 class Entregador(InheritableSQLObject, ByObject): #{{{
 466     # Campos
 467     nota            = DecimalCol(size=3, precision=1, default=None)
 468     nota_cursada    = DecimalCol(size=3, precision=1, default=None)
 469     observaciones   = UnicodeCol(default=None)
 470     activo          = BoolCol(notNone=True, default=True)
 471     # Joins
 472     entregas        = MultipleJoin('Entrega')
 473     correcciones    = MultipleJoin('Correccion')
 474
 475     def add_entrega(self, instancia, **opts):
 476         return Entrega(entregadorID=self.id, instanciaID=instancia.id, **opts)
 477
 478     def __repr__(self):
 479         raise NotImplementedError, 'Clase abstracta!'
 480 #}}}
 481
 482 class Grupo(Entregador): #{{{
 483     _inheritable = False
 484     # Clave
 485     curso           = ForeignKey('Curso', notNone=True)
 486     nombre          = UnicodeCol(length=20, notNone=True)
 487     # Campos
 488     responsable     = ForeignKey('AlumnoInscripto', default=None)
 489     # Joins
 490     miembros        = MultipleJoin('Miembro')
 491     tutores         = MultipleJoin('Tutor')
 492
 493     def add_alumno(self, alumno, **opts):
 494         return Miembro(grupoID=self.id, alumnoID=alumno.id, **opts)
 495
 496     def add_docente(self, docente, **opts):
 497         return Tutor(grupoID=self.id, docenteID=docente.id, **opts)
 498
 499     def __repr__(self):
 500         return 'Grupo(id=%s, nombre=%s, responsable=%s, nota=%s, ' \
 501             'nota_cursada=%s, observaciones=%s, activo=%s)' \
 502                 % (self.id, self.nombre, srepr(self.responsable), self.nota,
 503                     self.nota_cursada, self.observaciones, self.activo)
 504
 505     def shortrepr(self):
 506         return 'grupo:' + self.nombre
 507 #}}}
 508
 509 class AlumnoInscripto(Entregador): #{{{
 510     _inheritable = False
 511     # Clave
 512     curso               = ForeignKey('Curso', notNone=True)
 513     alumno              = ForeignKey('Alumno', notNone=True)
 514     pk                  = DatabaseIndex(curso, alumno, unique=True)
 515     # Campos
 516     condicional         = BoolCol(notNone=True, default=False)
 517     tutor               = ForeignKey('DocenteInscripto', default=None)
 518     # Joins
 519     responsabilidades   = MultipleJoin('Grupo', joinColumn='responsable_id')
 520     membresias          = MultipleJoin('Miembro', joinColumn='alumno_id')
 521     entregas            = MultipleJoin('Entrega', joinColumn='alumno_id')
 522     correcciones        = MultipleJoin('Correccion', joinColumn='alumno_id')
 523
 524     def __repr__(self):
 525         return 'AlumnoInscripto(id=%s, alumno=%s, condicional=%s, nota=%s, ' \
 526             'nota_cursada=%s, tutor=%s, observaciones=%s, activo=%s)' \
 527                 % (self.id, self.alumno.shortrepr(), self.condicional,
 528                     self.nota, self.nota_cursada, srepr(self.tutor),
 529                     self.observaciones, self.activo)
 530
 531     def shortrepr(self):
 532         return self.alumno.shortrepr()
 533 #}}}
 534
 535 class Tutor(SQLObject, ByObject): #{{{
 536     # Clave
 537     grupo           = ForeignKey('Grupo', notNone=True)
 538     docente         = ForeignKey('DocenteInscripto', notNone=True)
 539     pk              = DatabaseIndex(grupo, docente, unique=True)
 540     # Campos
 541     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 542     baja            = DateTimeCol(default=None)
 543
 544     def __repr__(self):
 545         return 'Tutor(docente=%s, grupo=%s, alta=%s, baja=%s)' \
 546                 % (self.docente.shortrepr(), self.grupo.shortrepr(),
 547                     self.alta, self.baja)
 548
 549     def shortrepr(self):
 550         return '%s-%s' % (self.docente.shortrepr(), self.grupo.shortrepr())
 551 #}}}
 552
 553 class Miembro(SQLObject, ByObject): #{{{
 554     # Clave
 555     grupo           = ForeignKey('Grupo', notNone=True)
 556     alumno          = ForeignKey('AlumnoInscripto', notNone=True)
 557     pk              = DatabaseIndex(grupo, alumno, unique=True)
 558     # Campos
 559     nota            = DecimalCol(size=3, precision=1, default=None)
 560     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 561     baja            = DateTimeCol(default=None)
 562
 563     def __repr__(self):
 564         return 'Miembro(alumno=%s, grupo=%s, nota=%s, alta=%s, baja=%s)' \
 565                 % (self.alumno.shortrepr(), self.grupo.shortrepr(),
 566                     self.nota, self.alta, self.baja)
 567
 568     def shortrepr(self):
 569         return '%s-%s' % (self.alumno.shortrepr(), self.grupo.shortrepr())
 570 #}}}
 571
 572 class Entrega(SQLObject, ByObject): #{{{
 573     # Clave
 574     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True)
 575     entregador      = ForeignKey('Entregador', default=None) # Si es None era un Docente
 576     fecha           = DateTimeCol(notNone=True, default=DateTimeCol.now)
 577     pk              = DatabaseIndex(instancia, entregador, fecha, unique=True)
 578     # Campos
 579     correcta        = BoolCol(notNone=True, default=False)
 580     observaciones   = UnicodeCol(default=None)
 581     # Joins
 582     tareas          = MultipleJoin('TareaEjecutada')
 583     # Para generar código
 584     codigo_dict     = r'0123456789abcdefghijklmnopqrstuvwxyz_.,*@#+'
 585     codigo_format   = r'%m%d%H%M%S'
 586
 587     def add_tarea_ejecutada(self, tarea, **opts):
 588         return TareaEjecutada(entregaID=self.id, tareaID=tarea.id, **opts)
 589
 590     def _get_codigo(self):
 591         if not hasattr(self, '_codigo'): # cache
 592             n = long(self.fecha.strftime(Entrega.codigo_format))
 593             d = Entrega.codigo_dict
 594             l = len(d)
 595             res = ''
 596             while n:
 597                     res += d[n % l]
 598                     n /= l
 599             self._codigo = res
 600         return self._codigo
 601
 602     def _set_fecha(self, fecha):
 603         self._SO_set_fecha(fecha)
 604         if hasattr(self, '_codigo'): del self._codigo # bye, bye cache!
 605
 606     def __repr__(self):
 607         return 'Entrega(instancia=%s, entregador=%s, codigo=%s, fecha=%s, ' \
 608             'correcta=%s, observaciones=%s)' \
 609                 % (self.instancia.shortrepr(), srepr(self.entregador),
 610                     self.codigo, self.fecha, self.correcta, self.observaciones)
 611
 612     def shortrepr(self):
 613         return '%s-%s-%s' % (self.instancia.shortrepr(), srepr(self.entregador),
 614             self.codigo)
 615 #}}}
 616
 617 class Correccion(SQLObject, ByObject): #{{{
 618     # Clave
 619     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True)
 620     entregador      = ForeignKey('Entregador', notNone=True) # Docente no tiene
 621     pk              = DatabaseIndex(instancia, entregador, unique=True)
 622     # Campos
 623     entrega         = ForeignKey('Entrega', notNone=True)
 624     corrector       = ForeignKey('DocenteInscripto', notNone=True)
 625     asignado        = DateTimeCol(notNone=True, default=DateTimeCol.now)
 626     corregido       = DateTimeCol(default=None)
 627     nota            = DecimalCol(size=3, precision=1, default=None)
 628     observaciones   = UnicodeCol(default=None)
 629
 630     def __repr__(self):
 631         return 'Correccion(instancia=%s, entregador=%s, entrega=%s, ' \
 632             'corrector=%s, asignado=%s, corregido=%s, nota=%s, ' \
 633             'observaciones=%s)' \
 634                 % (self.instancia.shortrepr(), self.entregador.shortrepr(),
 635                     self.entrega.shortrepr(), self.corrector, self.asignado,
 636                     self.corregido, self.nota, self.observaciones)
 637
 638     def shortrepr(self):
 639         return '%s,%s' % (self.entrega.shortrepr(), self.corrector.shortrepr())
 640 #}}}
 641
 642 class TareaEjecutada(InheritableSQLObject, ByObject): #{{{
 643     # Clave
 644     tarea           = ForeignKey('Tarea', notNone=True)
 645     entrega         = ForeignKey('Entrega', notNone=True)
 646     pk              = DatabaseIndex(tarea, entrega, unique=True)
 647     # Campos
 648     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 649     fin             = DateTimeCol(default=None)
 650     exito           = IntCol(default=None)
 651     observaciones   = UnicodeCol(default=None)
 652     # Joins
 653     pruebas         = MultipleJoin('Prueba')
 654
 655     def add_prueba(self, caso_de_prueba, **opts):
 656         return Prueba(tarea_ejecutadaID=self.id,
 657             caso_de_pruebaID=caso_de_prueba.id, **opts)
 658
 659     def __repr__(self):
 660         return 'TareaEjecutada(tarea=%s, entrega=%s, inicio=%s, fin=%s, ' \
 661             'exito=%s, observaciones=%s)' \
 662                 % (self.tarea.shortrepr(), self.entrega.shortrepr(),
 663                     self.inicio, self.fin, self.exito, self.observaciones)
 664
 665     def shortrepr(self):
 666         return '%s-%s' % (self.tarea.shortrepr(), self.entrega.shortrepr())
 667 #}}}
 668
 669 class Prueba(SQLObject): #{{{
 670     # Clave
 671     tarea_ejecutada = ForeignKey('TareaEjecutada', notNone=True)
 672     caso_de_prueba  = ForeignKey('CasoDePrueba', notNone=True)
 673     pk              = DatabaseIndex(tarea_ejecutada, caso_de_prueba, unique=True)
 674     # Campos
 675     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 676     fin             = DateTimeCol(default=None)
 677     pasada          = IntCol(default=None)
 678     observaciones   = UnicodeCol(default=None)
 679
 680     def __repr__(self):
 681         return 'Prueba(tarea_ejecutada=%s, caso_de_prueba=%s, inicio=%s, ' \
 682             'fin=%s, pasada=%s, observaciones=%s)' \
 683                 % (self.tarea_ejecutada.shortrepr(),
 684                     self.caso_de_prueba.shortrepr(), self.inicio, self.fin,
 685                     self.pasada, self.observaciones)
 686
 687     def shortrepr(self):
 688         return '%s:%s' % (self.tarea_ejecutada.shortrepr(),
 689             self.caso_de_prueba.shortrerp())
 690 #}}}
 691
 692 #{{{ Específico de Identity
 693
 694 class Visita(SQLObject): #{{{
 695     visit_key   = StringCol(length=40, alternateID=True,
 696                     alternateMethodName="by_visit_key")
 697     created     = DateTimeCol(notNone=True, default=datetime.now)
 698     expiry      = DateTimeCol()
 699
 700     @classmethod
 701     def lookup_visit(cls, visit_key):
 702         try:
 703             return cls.by_visit_key(visit_key)
 704         except SQLObjectNotFound:
 705             return None
 706 #}}}
 707
 708 class VisitaUsuario(SQLObject): #{{{
 709     # Clave
 710     visit_key   = StringCol(length=40, alternateID=True,
 711                           alternateMethodName="by_visit_key")
 712     # Campos
 713     user_id     = IntCol() # Negrada de identity
 714 #}}}
 715
 716
 717 class Rol(SQLObject): #{{{
 718     # Clave
 719     nombre      = UnicodeCol(length=255, alternateID=True,
 720                     alternateMethodName="by_group_name")
 721     # Campos
 722     descripcion = UnicodeCol(length=255, default=None)
 723     creado      = DateTimeCol(notNone=True, default=datetime.now)
 724     permisos    = TupleCol(notNone=True)
 725     # Joins
 726     usuarios    = RelatedJoin('Usuario')
 727 #}}}
 728
 729 # No es un SQLObject porque no tiene sentido agregar/sacar permisos, están
 730 # hardcodeados en el código
 731 class Permiso(object): #{{{
 732     def __init__(self, nombre, descripcion):
 733         self.nombre = nombre
 734         self.descripcion = descripcion
 735
 736     @classmethod
 737     def createTable(cls, ifNotExists): # para identity
 738         pass
 739
 740     @property
 741     def permission_name(self): # para identity
 742         return self.nombre
 743
 744     def __repr__(self):
 745         return self.nombre
 746 #}}}
 747
 748 # TODO ejemplos
 749 entregar_tp = Permiso(u'entregar', u'Permite entregar trabajos prácticos')
 750 admin = Permiso(u'admin', u'Permite hacer ABMs arbitrarios')
 751
 752 #}}} Identity
 753
 754 #}}} Clases
 755