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             ),
 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             ),
 398             clauseTables=(instancia_tarea_t, InstanciaDeEntrega.sqlmeta.table),
 399             orderBy=instancia_tarea_t.orden,
 400         ))
 401         return self.__tareas
 402
 403     def _set_tareas(self, tareas):
 404         orden = {}
 405         for i, t in enumerate(tareas):
 406             orden[t.id] = i
 407         new = frozenset([t.id for t in tareas])
 408         old = frozenset([t.id for t in self.tareas])
 409         tareas = dict([(t.id, t) for t in tareas])
 410         for tid in old - new: # eliminadas
 411             self._connection.query(str(Delete(instancia_tarea_t, where=AND(
 412                 instancia_tarea_t.instancia_id == self.id,
 413                 instancia_tarea_t.tarea_id == tid))))
 414         for tid in new - old: # creadas
 415             self._connection.query(str(Insert(instancia_tarea_t, values=dict(
 416                 instancia_id=self.id, tarea_id=tid, orden=orden[tid]
 417             ))))
 418         for tid in new & old: # actualizados
 419             self._connection.query(str(Update(instancia_tarea_t,
 420                 values=dict(orden=orden[tid]), where=AND(
 421                     instancia_tarea_t.instancia_id == self.id,
 422                     instancia_tarea_t.tarea_id == tid,
 423                 ))))
 424
 425     def __repr__(self):
 426         return 'InstanciaDeEntrega(id=%s, numero=%s, inicio=%s, fin=%s, ' \
 427             'procesada=%s, observaciones=%s, activo=%s)' \
 428                 % (self.id, self.numero, self.inicio, self.fin,
 429                     self.procesada, self.observaciones, self.activo)
 430
 431     def shortrepr(self):
 432         return self.numero
 433 #}}}
 434
 435 class DocenteInscripto(SQLObject, ByObject): #{{{
 436     # Clave
 437     curso           = ForeignKey('Curso', notNone=True)
 438     docente         = ForeignKey('Docente', notNone=True)
 439     pk              = DatabaseIndex(curso, docente, unique=True)
 440     # Campos
 441     corrige         = BoolCol(notNone=True, default=True)
 442     observaciones   = UnicodeCol(default=None)
 443     # Joins
 444     alumnos         = MultipleJoin('AlumnoInscripto', joinColumn='tutor_id')
 445     tutorias        = MultipleJoin('Tutor', joinColumn='docente_id')
 446     entregas        = MultipleJoin('Entrega', joinColumn='instancia_id')
 447     correcciones    = MultipleJoin('Correccion', joinColumn='corrector_id')
 448
 449     def add_correccion(self, entrega, **opts):
 450         return Correccion(correctorID=self.id, instanciaID=entrega.instancia.id,
 451             entregadorID=entrega.entregador.id, entregaID=entrega.id, **opts)
 452
 453     def __repr__(self):
 454         return 'DocenteInscripto(id=%s, docente=%s, corrige=%s, ' \
 455             'observaciones=%s' \
 456                 % (self.id, self.docente.shortrepr(), self.corrige,
 457                     self.observaciones)
 458
 459     def shortrepr(self):
 460         return self.docente.shortrepr()
 461 #}}}
 462
 463 class Entregador(InheritableSQLObject, ByObject): #{{{
 464     # Campos
 465     nota            = DecimalCol(size=3, precision=1, default=None)
 466     nota_cursada    = DecimalCol(size=3, precision=1, default=None)
 467     observaciones   = UnicodeCol(default=None)
 468     activo          = BoolCol(notNone=True, default=True)
 469     # Joins
 470     entregas        = MultipleJoin('Entrega')
 471     correcciones    = MultipleJoin('Correccion')
 472
 473     def add_entrega(self, instancia, **opts):
 474         return Entrega(entregadorID=self.id, instanciaID=instancia.id, **opts)
 475
 476     def __repr__(self):
 477         raise NotImplementedError, 'Clase abstracta!'
 478 #}}}
 479
 480 class Grupo(Entregador): #{{{
 481     _inheritable = False
 482     # Clave
 483     curso           = ForeignKey('Curso', notNone=True)
 484     nombre          = UnicodeCol(length=20, notNone=True)
 485     # Campos
 486     responsable     = ForeignKey('AlumnoInscripto', default=None)
 487     # Joins
 488     miembros        = MultipleJoin('Miembro')
 489     tutores         = MultipleJoin('Tutor')
 490
 491     def add_alumno(self, alumno, **opts):
 492         return Miembro(grupoID=self.id, alumnoID=alumno.id, **opts)
 493
 494     def add_docente(self, docente, **opts):
 495         return Tutor(grupoID=self.id, docenteID=docente.id, **opts)
 496
 497     def __repr__(self):
 498         return 'Grupo(id=%s, nombre=%s, responsable=%s, nota=%s, ' \
 499             'nota_cursada=%s, observaciones=%s, activo=%s)' \
 500                 % (self.id, self.nombre, srepr(self.responsable), self.nota,
 501                     self.nota_cursada, self.observaciones, self.activo)
 502
 503     def shortrepr(self):
 504         return 'grupo:' + self.nombre
 505 #}}}
 506
 507 class AlumnoInscripto(Entregador): #{{{
 508     _inheritable = False
 509     # Clave
 510     curso               = ForeignKey('Curso', notNone=True)
 511     alumno              = ForeignKey('Alumno', notNone=True)
 512     pk                  = DatabaseIndex(curso, alumno, unique=True)
 513     # Campos
 514     condicional         = BoolCol(notNone=True, default=False)
 515     tutor               = ForeignKey('DocenteInscripto', default=None)
 516     # Joins
 517     responsabilidades   = MultipleJoin('Grupo', joinColumn='responsable_id')
 518     membresias          = MultipleJoin('Miembro', joinColumn='alumno_id')
 519     entregas            = MultipleJoin('Entrega', joinColumn='alumno_id')
 520     correcciones        = MultipleJoin('Correccion', joinColumn='alumno_id')
 521
 522     def __repr__(self):
 523         return 'AlumnoInscripto(id=%s, alumno=%s, condicional=%s, nota=%s, ' \
 524             'nota_cursada=%s, tutor=%s, observaciones=%s, activo=%s)' \
 525                 % (self.id, self.alumno.shortrepr(), self.condicional,
 526                     self.nota, self.nota_cursada, srepr(self.tutor),
 527                     self.observaciones, self.activo)
 528
 529     def shortrepr(self):
 530         return self.alumno.shortrepr()
 531 #}}}
 532
 533 class Tutor(SQLObject, ByObject): #{{{
 534     # Clave
 535     grupo           = ForeignKey('Grupo', notNone=True)
 536     docente         = ForeignKey('DocenteInscripto', notNone=True)
 537     pk              = DatabaseIndex(grupo, docente, unique=True)
 538     # Campos
 539     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 540     baja            = DateTimeCol(default=None)
 541
 542     def __repr__(self):
 543         return 'Tutor(docente=%s, grupo=%s, alta=%s, baja=%s)' \
 544                 % (self.docente.shortrepr(), self.grupo.shortrepr(),
 545                     self.alta, self.baja)
 546
 547     def shortrepr(self):
 548         return '%s-%s' % (self.docente.shortrepr(), self.grupo.shortrepr())
 549 #}}}
 550
 551 class Miembro(SQLObject, ByObject): #{{{
 552     # Clave
 553     grupo           = ForeignKey('Grupo', notNone=True)
 554     alumno          = ForeignKey('AlumnoInscripto', notNone=True)
 555     pk              = DatabaseIndex(grupo, alumno, unique=True)
 556     # Campos
 557     nota            = DecimalCol(size=3, precision=1, default=None)
 558     alta            = DateTimeCol(notNone=True, default=DateTimeCol.now)
 559     baja            = DateTimeCol(default=None)
 560
 561     def __repr__(self):
 562         return 'Miembro(alumno=%s, grupo=%s, nota=%s, alta=%s, baja=%s)' \
 563                 % (self.alumno.shortrepr(), self.grupo.shortrepr(),
 564                     self.nota, self.alta, self.baja)
 565
 566     def shortrepr(self):
 567         return '%s-%s' % (self.alumno.shortrepr(), self.grupo.shortrepr())
 568 #}}}
 569
 570 class Entrega(SQLObject, ByObject): #{{{
 571     # Clave
 572     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True)
 573     entregador      = ForeignKey('Entregador', default=None) # Si es None era un Docente
 574     fecha           = DateTimeCol(notNone=True, default=DateTimeCol.now)
 575     pk              = DatabaseIndex(instancia, entregador, fecha, unique=True)
 576     # Campos
 577     correcta        = BoolCol(notNone=True, default=False)
 578     observaciones   = UnicodeCol(default=None)
 579     # Joins
 580     tareas          = MultipleJoin('TareaEjecutada')
 581     # Para generar código
 582     codigo_dict     = r'0123456789abcdefghijklmnopqrstuvwxyz_.,*@#+'
 583     codigo_format   = r'%m%d%H%M%S'
 584
 585     def add_tarea_ejecutada(self, tarea, **opts):
 586         return TareaEjecutada(entregaID=self.id, tareaID=tarea.id, **opts)
 587
 588     def _get_codigo(self):
 589         if not hasattr(self, '_codigo'): # cache
 590             n = long(self.fecha.strftime(Entrega.codigo_format))
 591             d = Entrega.codigo_dict
 592             l = len(d)
 593             res = ''
 594             while n:
 595                     res += d[n % l]
 596                     n /= l
 597             self._codigo = res
 598         return self._codigo
 599
 600     def _set_fecha(self, fecha):
 601         self._SO_set_fecha(fecha)
 602         if hasattr(self, '_codigo'): del self._codigo # bye, bye cache!
 603
 604     def __repr__(self):
 605         return 'Entrega(instancia=%s, entregador=%s, codigo=%s, fecha=%s, ' \
 606             'correcta=%s, observaciones=%s)' \
 607                 % (self.instancia.shortrepr(), srepr(self.entregador),
 608                     self.codigo, self.fecha, self.correcta, self.observaciones)
 609
 610     def shortrepr(self):
 611         return '%s-%s-%s' % (self.instancia.shortrepr(), srepr(self.entregador),
 612             self.codigo)
 613 #}}}
 614
 615 class Correccion(SQLObject, ByObject): #{{{
 616     # Clave
 617     instancia       = ForeignKey('InstanciaDeEntrega', notNone=True)
 618     entregador      = ForeignKey('Entregador', notNone=True) # Docente no tiene
 619     pk              = DatabaseIndex(instancia, entregador, unique=True)
 620     # Campos
 621     entrega         = ForeignKey('Entrega', notNone=True)
 622     corrector       = ForeignKey('DocenteInscripto', notNone=True)
 623     asignado        = DateTimeCol(notNone=True, default=DateTimeCol.now)
 624     corregido       = DateTimeCol(default=None)
 625     nota            = DecimalCol(size=3, precision=1, default=None)
 626     observaciones   = UnicodeCol(default=None)
 627
 628     def __repr__(self):
 629         return 'Correccion(instancia=%s, entregador=%s, entrega=%s, ' \
 630             'corrector=%s, asignado=%s, corregido=%s, nota=%s, ' \
 631             'observaciones=%s)' \
 632                 % (self.instancia.shortrepr(), self.entregador.shortrepr(),
 633                     self.entrega.shortrepr(), self.corrector, self.asignado,
 634                     self.corregido, self.nota, self.observaciones)
 635
 636     def shortrepr(self):
 637         return '%s,%s' % (self.entrega.shortrepr(), self.corrector.shortrepr())
 638 #}}}
 639
 640 class TareaEjecutada(InheritableSQLObject, ByObject): #{{{
 641     # Clave
 642     tarea           = ForeignKey('Tarea', notNone=True)
 643     entrega         = ForeignKey('Entrega', notNone=True)
 644     pk              = DatabaseIndex(tarea, entrega, unique=True)
 645     # Campos
 646     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 647     fin             = DateTimeCol(default=None)
 648     exito           = IntCol(default=None)
 649     observaciones   = UnicodeCol(default=None)
 650     # Joins
 651     pruebas         = MultipleJoin('Prueba')
 652
 653     def add_prueba(self, caso_de_prueba, **opts):
 654         return Prueba(tarea_ejecutadaID=self.id,
 655             caso_de_pruebaID=caso_de_prueba.id, **opts)
 656
 657     def __repr__(self):
 658         return 'TareaEjecutada(tarea=%s, entrega=%s, inicio=%s, fin=%s, ' \
 659             'exito=%s, observaciones=%s)' \
 660                 % (self.tarea.shortrepr(), self.entrega.shortrepr(),
 661                     self.inicio, self.fin, self.exito, self.observaciones)
 662
 663     def shortrepr(self):
 664         return '%s-%s' % (self.tarea.shortrepr(), self.entrega.shortrepr())
 665 #}}}
 666
 667 class Prueba(SQLObject): #{{{
 668     # Clave
 669     tarea_ejecutada = ForeignKey('TareaEjecutada', notNone=True)
 670     caso_de_prueba  = ForeignKey('CasoDePrueba', notNone=True)
 671     pk              = DatabaseIndex(tarea_ejecutada, caso_de_prueba, unique=True)
 672     # Campos
 673     inicio          = DateTimeCol(notNone=True, default=DateTimeCol.now)
 674     fin             = DateTimeCol(default=None)
 675     pasada          = IntCol(default=None)
 676     observaciones   = UnicodeCol(default=None)
 677
 678     def __repr__(self):
 679         return 'Prueba(tarea_ejecutada=%s, caso_de_prueba=%s, inicio=%s, ' \
 680             'fin=%s, pasada=%s, observaciones=%s)' \
 681                 % (self.tarea_ejecutada.shortrepr(),
 682                     self.caso_de_prueba.shortrepr(), self.inicio, self.fin,
 683                     self.pasada, self.observaciones)
 684
 685     def shortrepr(self):
 686         return '%s:%s' % (self.tarea_ejecutada.shortrepr(),
 687             self.caso_de_prueba.shortrerp())
 688 #}}}
 689
 690 #{{{ Específico de Identity
 691
 692 class Visita(SQLObject): #{{{
 693     visit_key   = StringCol(length=40, alternateID=True,
 694                     alternateMethodName="by_visit_key")
 695     created     = DateTimeCol(notNone=True, default=datetime.now)
 696     expiry      = DateTimeCol()
 697
 698     @classmethod
 699     def lookup_visit(cls, visit_key):
 700         try:
 701             return cls.by_visit_key(visit_key)
 702         except SQLObjectNotFound:
 703             return None
 704 #}}}
 705
 706 class VisitaUsuario(SQLObject): #{{{
 707     # Clave
 708     visit_key   = StringCol(length=40, alternateID=True,
 709                           alternateMethodName="by_visit_key")
 710     # Campos
 711     user_id     = IntCol() # Negrada de identity
 712 #}}}
 713
 714
 715 class Rol(SQLObject): #{{{
 716     # Clave
 717     nombre      = UnicodeCol(length=255, alternateID=True,
 718                     alternateMethodName="by_group_name")
 719     # Campos
 720     descripcion = UnicodeCol(length=255, default=None)
 721     creado      = DateTimeCol(notNone=True, default=datetime.now)
 722     permisos    = TupleCol(notNone=True)
 723     # Joins
 724     usuarios    = RelatedJoin('Usuario')
 725 #}}}
 726
 727 # No es un SQLObject porque no tiene sentido agregar/sacar permisos, están
 728 # hardcodeados en el código
 729 class Permiso(object): #{{{
 730     def __init__(self, nombre, descripcion):
 731         self.nombre = nombre
 732         self.descripcion = descripcion
 733
 734     @classmethod
 735     def createTable(cls, ifNotExists): # para identity
 736         pass
 737
 738     @property
 739     def permission_name(self): # para identity
 740         return self.nombre
 741
 742     def __repr__(self):
 743         return self.nombre
 744 #}}}
 745
 746 # TODO ejemplos
 747 entregar_tp = Permiso(u'entregar', u'Permite entregar trabajos prácticos')
 748 admin = Permiso(u'admin', u'Permite hacer ABMs arbitrarios')
 749
 750 #}}} Identity
 751
 752 #}}} Clases
 753