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