sercom/subcontrollers/curso/__init__.py

   1 # vim: set et sw=4 sts=4 encoding=utf-8 foldmethod=marker :
   2
   3 #{{{ Imports
   4 import cherrypy
   5 from turbogears import controllers, expose, redirect
   6 from turbogears import validate, flash, error_handler
   7 from turbogears import validators as V
   8 from turbogears import widgets as W
   9 from turbogears import identity
  10 from turbogears import paginate
  11 from docutils.core import publish_parts
  12 from sercom.subcontrollers import validate as val
  13 from sercom.model import Curso, Correccion, Ejercicio, Alumno, Docente, Grupo, DocenteInscripto
  14 from curso_alumno import *
  15 from sqlobject import *
  16 from sqlobject.dberrors import *
  17 from sercom.widgets import *
  18 from alumno import AlumnoInscriptoController
  19 from grupo import GrupoController
  20 #}}}
  21
  22 #{{{ Configuración
  23 cls = Curso
  24 name = 'curso'
  25 namepl = name + 's'
  26 #}}}
  27
  28 ajax = u"""
  29     function alumnos_agregar_a_la_lista(texto, lista)
  30     {
  31         t = MochiKit.DOM.getElement(texto);
  32
  33         url = "/alumno/get_alumno?padron="+t.value;
  34         t.value = "";
  35         return url;
  36     }
  37
  38     function err (err)
  39     {
  40         alert("The metadata for MochiKit.Async could not be fetched :(");
  41     }
  42
  43     function procesar(result)
  44     {
  45         l = MochiKit.DOM.getElement('form_responsable_info');
  46         if (result.error)
  47             l.innerHTML = result.msg;
  48         else
  49             l.innerHTML = result.msg.value;
  50     }
  51
  52     function buscar_alumno()
  53     {
  54         /* Obtengo el curso */
  55         l = MochiKit.DOM.getElement('form_cursoID');
  56         cursoid = l.options[l.selectedIndex].value;
  57         if (cursoid <= 0) {
  58             alert('Debe seleccionar un curso');
  59             return;
  60         }
  61         /* Obtengo el padron ingresado */
  62         p = MochiKit.DOM.getElement('form_responsable');
  63         padron = p.value;
  64         if (padron == '') {
  65             alert('Debe ingresar el padrón del alumno responsable');
  66             return;
  67         }
  68         url = "/grupo/get_inscripto?cursoid="+cursoid+'&padron='+padron;
  69         var d = loadJSONDoc(url);
  70         d.addCallbacks(procesar, err);
  71     }
  72
  73     function doSubmit()
  74     {
  75         /* TODO : Validar datos y evitar el submit si no esta completo */
  76
  77         /* Selecciono todos los miembros si no, no llegan al controllere*/
  78         l = MochiKit.DOM.getElement('form_alumnos');
  79         for (i=0; i<l.options.length; i++) {
  80             l.options[i].selected = true;
  81         }
  82         /* Selecciono todos los miembros si no, no llegan al controllere*/
  83         l = MochiKit.DOM.getElement('form_docentes_to');
  84         for (i=0; i<l.options.length; i++) {
  85             l.options[i].selected = true;
  86         }
  87         return true; // Dejo hacer el submit
  88     }
  89 """
  90
  91
  92
  93 #{{{ Validación
  94 def validate_get(id):
  95     return val.validate_get(cls, name, id)
  96
  97 def validate_set(id, data):
  98     return val.validate_set(cls, name, id, data)
  99
 100 def validate_new(data):
 101     return val.validate_new(cls, name, data)
 102
 103 def validate_del(id):
 104     return val.validate_del(cls, name, id)
 105 #}}}
 106
 107 def get_ejercicios():
 108     return [(fk1.id, fk1.shortrepr()) for fk1 in Ejercicio.select()]
 109
 110 def get_docentes():
 111     return [(fk1.id, fk1.shortrepr()) for fk1 in Docente.select()]
 112
 113 def get_alumnos():
 114     return [(fk1.id, fk1.shortrepr()) for fk1 in Alumno.select()]
 115
 116 def get_grupos():
 117     return [(fk1.id, fk1.shortrepr()) for fk1 in Grupo.select()]
 118
 119
 120 #{{{ Formulario
 121 class CursoForm(W.TableForm):
 122     class Fields(W.WidgetsList):
 123         anio = W.TextField(label=_(u'Anio'),
 124             help_text=_(u'Requerido y único.'),
 125             validator=V.Number(min=4, max=4, strip=True))
 126         cuatrimestre = W.TextField(label=_(u'Cuatrimestre'),
 127             help_text=_(u'Requerido.'),
 128             validator=V.Number(min=1, max=1, strip=True))
 129         numero = W.TextField(label=_(u'Numero'),
 130             help_text=_(u'Requerido'),
 131             validator=V.Number(min=1, max=2, strip=True))
 132         descripcion = W.TextField(label=_(u'Descripción'),
 133             help_text=_(u'Descripción.'),
 134             validator=V.UnicodeString(not_empty=False, strip=True))
 135
 136         #docentes = W.MultipleSelectField(name="docentes",
 137         #    label=_(u'Docentes'),
 138         #    attrs=dict(style='width:300px'),
 139         #    options=get_docentes,
 140         #    validator=V.Int(not_empty=True))
 141         #addDocente = W.Button(default='Asignar', label='',
 142         #    attrs=dict( onclick='mover("form_docentes","form_docentes_curso")'))
 143         #remDocente = W.Button(default='Remover', label='',
 144         #    attrs=dict( onclick='remover("form_docentes_curso","form_docentes")'))
 145         #docentes_curso = W.MultipleSelectField(name="docentes_curso",
 146         #    label=_(u'Docentes del curso'),
 147         #    attrs=dict(style='width:300px'),
 148 #       #     options=get_docentes_curso,
 149         #    validator=V.Int(not_empty=True))
 150         docentes = AjaxDosListasSelect(label=_(u'Docentes'),
 151             title_from="Docentes",
 152             title_to="Docentes del Curso",
 153             options=get_docentes,
 154             validator=V.Int(not_empty=True))
 155
 156         alumnos = AjaxMultiSelect(label=_(u'Alumnos'),
 157                 validator=V.Int(),
 158                 attrs = dict(size='20'),
 159                 on_add="alumnos_agregar_a_la_lista")
 160
 161     fields = Fields()
 162     javascript = [W.JSSource("MochiKit.DOM.focusOnLoad('anio');"),
 163                   W.JSSource(ajax)]
 164     form_attrs = dict(onsubmit='return doSubmit();')
 165 form = CursoForm()
 166 #}}}
 167
 168 #{{{ Controlador
 169 class CursoController(controllers.Controller, identity.SecureResource):
 170     """Basic model admin interface"""
 171     require = identity.has_permission('admin')
 172     curso_alumno = CursoAlumnoController()
 173     alumno = AlumnoInscriptoController()
 174     grupo = GrupoController()
 175
 176     @expose()
 177     def default(self, tg_errors=None):
 178         """handle non exist urls"""
 179         raise redirect('list')
 180
 181     @expose()
 182     def index(self):
 183         raise redirect('list')
 184
 185     @expose(template='kid:%s.templates.list' % __name__)
 186     @paginate('records')
 187     def list(self):
 188         """List records in model"""
 189         r = cls.select()
 190         return dict(records=r, name=name, namepl=namepl)
 191
 192     @expose()
 193     def activate(self, id, activo):
 194         """Save or create record to model"""
 195         r = validate_get(id)
 196         try:
 197             r.activo = bool(int(activo))
 198         except ValueError:
 199             raise cherrypy.NotFound
 200         raise redirect('../../list')
 201
 202     @expose(template='kid:%s.templates.new' % __name__)
 203     def new(self, **kw):
 204         """Create new records in model"""
 205         params = dict([(k,v) for (k,v) in kw.iteritems() if k in Curso.sqlmeta.columns.keys()])
 206         return dict(name=name, namepl=namepl, form=form, values=params)
 207
 208     @validate(form=form)
 209     @error_handler(new)
 210     @expose()
 211     def create(self, **kw):
 212         """Save or create record to model"""
 213         print "--KW--"
 214         docentes = kw.get('docentes_to', [])
 215         alumnos = kw.get('alumnos', [])
 216         del(kw['docentes_to'])
 217         del(kw['alumnos'])
 218         r = validate_new(kw)
 219         """ Agrego la nueva seleccion de docentes """
 220         for d in docentes:
 221             r.add_docente(d)
 222         """ El curso es nuevo, por ende no hay alumnos inscriptos """
 223         for a in alumnos:
 224             r.add_alumno(a)
 225         flash(_(u'Se creó un nuevo %s.') % name)
 226         raise redirect('list')
 227
 228     @expose(template='kid:%s.templates.edit' % __name__)
 229     def edit(self, id, **kw):
 230         """Edit record in model"""
 231         r = validate_get(id)
 232         class EmptyClass:
 233             pass
 234         values = EmptyClass()
 235         values.id = r.id
 236         values.anio = r.anio
 237         values.numero = r.numero
 238         values.cuatrimestre = r.cuatrimestre
 239         values.cursoID = r.id
 240         values.descripcion = r.descripcion
 241         # cargo la lista con los docentes asignados al curso
 242         values.docentes_to = [{"id":d.docente.id, "label":d.docente.shortrepr()} for d in DocenteInscripto.selectBy(curso=r.id)]
 243         values.alumnos_inscriptos = [{"id":a.alumno.id, "label":a.alumno.shortrepr()} for a in AlumnoInscripto.selectBy(curso=r.id)]
 244
 245         return dict(name=name, namepl=namepl, record=values, form=form)
 246
 247     @validate(form=form)
 248     @error_handler(edit)
 249     @expose()
 250     def update(self, id, **kw):
 251         """Save or create record to model"""
 252         params = dict([(k,v) for (k,v) in kw.iteritems() if k in Curso.sqlmeta.columns.keys()])
 253         r = validate_set(id, params)
 254
 255         docentes = [a for a in kw.get('docentes_to', [])]
 256         alumnos = [a for a in kw.get('alumnos', [])]
 257         alumnos_inscriptos = AlumnoInscripto.selectBy(curso=id)
 258         """ levanto los doncentes del curso para ver cuales tengo que agregar """
 259         docentes_inscriptos = DocenteInscripto.selectBy(curso=id)
 260
 261         """ elimino a los docentes que no fueron seleccionados """
 262         for di in docentes_inscriptos:
 263             if di.id not in docentes:
 264                 r.remove_docente(di.docente)
 265
 266         """ Agrego la nueva seleccion """
 267         for d in docentes:
 268             try:
 269                 r.add_docente(d)
 270             except:
 271                 pass
 272
 273         """ Verifico que los alumnos no esten ya inscriptos """
 274         for a in alumnos_inscriptos:
 275             if (a.id not in alumnos):
 276                 try:
 277                     r.remove_alumno(a.alumno)
 278                 except:
 279                     pass
 280         for a in alumnos:
 281             try:
 282                 r.add_alumno(a)
 283             except:
 284                 pass
 285         flash(_(u'El %s fue actualizado.') % name)
 286         raise redirect('../list')
 287
 288     @expose(template='kid:%s.templates.show' % __name__)
 289     def show(self,id, **kw):
 290         """Show record in model"""
 291         r = validate_get(id)
 292         return dict(name=name, namepl=namepl, record=r)
 293
 294     @expose()
 295     def delete(self, id):
 296         """Destroy record in model"""
 297         validate_del(id)
 298         flash(_(u'El %s fue eliminado permanentemente.') % name)
 299         raise redirect('../list')
 300
 301     @expose(template='kid:%s.templates.from_file' % __name__)
 302     def from_file(self, id):
 303         return dict(cursoID=int(id))
 304
 305     @expose(template='kid:%s.templates.import_results' % __name__)
 306     def from_file_add(self, id, archivo):
 307         """ Se espera :
 308              padron,nombre,email,telefono
 309         """
 310         import csv
 311         lines = archivo.file.read().split('\n')
 312         ok = []
 313         fail = []
 314         curso = Curso.get(int(id))
 315         for line in lines:
 316             for row in csv.reader([line]):
 317                 if row == []:
 318                     continue
 319                 try:
 320                     u = Alumno(row[0], nombre=row[1])
 321                 except:
 322                     u = Alumno.byPadron(row[0])
 323                 try:
 324                     u.email = row[2]
 325                     u.telefono = row[3]
 326                     u.contrasenia = row[0]
 327                     u.activo = True
 328                     curso.add_alumno(u)
 329                     ok.append(row)
 330                 except Exception, e:
 331                     row.append(str(e))
 332                     fail.append(row)
 333         return dict(ok=ok, fail=fail)
 334
 335     @expose(template='kid:%s.templates.notas' % __name__)
 336     def notas(self, cursoid):
 337         r = validate_get(cursoid)
 338         # Armo las columnas del listado
 339         cols = ["Padron", "Nombre", "Grupo"]
 340         # Ejercicios
 341         for ej in r.ejercicios:
 342             for ins in ej.instancias:
 343                 print "E"+str(ej.numero)+str(ins.numero)
 344                 cols.append("E"+str(ej.numero)+str(ins.numero))
 345         cols.append("EA")
 346         cols.append("NP")
 347         cols.append("NF")
 348         cols.append("NL")
 349
 350         rows = []
 351         for i in r.alumnos:
 352             col = {}
 353             col["Padron"] = i.alumno.padron
 354             col["Nombre"] = i.alumno.nombre
 355             miembro = Grupo.selectByAlumno(i.alumno)
 356             if miembro.count() > 0:
 357                 col["Grupo"] = miembro[0].grupo.shortrepr()
 358             correctas = 0
 359             for ej in r.ejercicios:
 360                 for ins in ej.instancias:
 361                     if ej.grupal:
 362                         # Busco la correccion del grupo
 363                         g = Grupo.selectByAlumno(i.alumno).getOne()
 364                         c = Correccion.selectBy(instancia=ins, entregador=g.grupo)
 365                         print "  ", list(c)
 366                     else:
 367                         print "Alumno"
 368                         # Busco la correccion del alumno
 369                         c = Correccion.selectBy(instancia=ins, entregador=i)
 370                     if c.count() > 0:
 371                         col["E"+str(ej.numero)+str(ins.numero)] = c[0].nota
 372                         if c[0].nota > 7:
 373                             correctas += 1
 374                     else:
 375                         col["E"+str(ej.numero)+str(ins.numero)] = ""
 376             col["EA"] = correctas
 377             col["NP"] = i.nota_practica
 378             col["NF"] = i.nota_final
 379             col["NL"] = i.nota_libreta
 380             rows.append(col)
 381         return dict(curso=r, rows=rows, cols=cols)
 382
 383     @expose()
 384     def notascsv(self, cursoid):
 385         r = validate_get(cursoid)
 386         # Armo las columnas del listado
 387         cols = ["Padron", "Nombre", "Grupo"]
 388         # Ejercicios
 389         for ej in r.ejercicios:
 390             for ins in ej.instancias:
 391                 print "E"+str(ej.numero)+str(ins.numero)
 392                 cols.append("E"+str(ej.numero)+str(ins.numero))
 393         cols.append("EA")
 394         cols.append("NP")
 395         cols.append("NF")
 396         cols.append("NL")
 397
 398         rows = []
 399         for i in r.alumnos:
 400             col = []
 401             col.append(i.alumno.padron)
 402             col.append(i.alumno.nombre)
 403             miembro = Grupo.selectByAlumno(i.alumno)
 404             if miembro.count() > 0:
 405                 col.append(miembro[0].grupo.shortrepr())
 406             correctas = 0
 407             for ej in r.ejercicios:
 408                 for ins in ej.instancias:
 409                     if ej.grupal:
 410                         # Busco la correccion del grupo
 411                         g = Grupo.selectByAlumno(i.alumno).getOne()
 412                         c = Correccion.selectBy(instancia=ins, entregador=g.grupo)
 413                     else:
 414                         # Busco la correccion del alumno
 415                         c = Correccion.selectBy(instancia=ins, entregador=i)
 416                     if c.count() > 0:
 417                         col.append(str(c[0].nota))
 418                         if c[0].nota > 7:
 419                             correctas += 1
 420                     else:
 421                         col.append("")
 422             col.append(str(correctas))
 423             col.append(str(i.nota_practica))
 424             col.append(str(i.nota_final))
 425             col.append(str(i.nota_libreta))
 426             rows.append(col)
 427         s = ",".join(cols) + "\n"
 428         for i in rows:
 429             s = s + ",".join(i) + "\n"
 430
 431         return s
 432 #}}}
 433