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