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