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