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