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