sercom/model.py

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