sercom/subcontrollers/curso/grupo/__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, AlumnoInscripto, Docente, DocenteInscripto, Grupo, Alumno, Miembro
  14 from sqlobject import *
  15
  16 from sercom.widgets import *
  17
  18 #}}}
  19
  20 #{{{ Configuración
  21 cls = Grupo
  22 name = 'grupo'
  23 namepl = 'grupos'
  24 #}}}
  25
  26 #{{{ Validación
  27 def validate_get(id):
  28     return val.validate_get(cls, name, id)
  29
  30 def validate_set(id, data):
  31     return val.validate_set(cls, name, id, data)
  32
  33 def validate_new(data):
  34     return val.validate_new(cls, name, data)
  35
  36 def validate_del(id):
  37     return val.validate_del(cls, name, id)
  38 #}}}
  39
  40 #{{{ Formulario
  41 def get_docentes():
  42     return [(fk1.id, fk1.shortrepr()) for fk1 in Docente.select()]
  43
  44 def get_docentes_inscriptos(id):
  45     return [(fk1.id, fk1.shortrepr()) for fk1 in DocenteInscripto.select(DocenteInscripto.q.cursoID==id)]
  46
  47 ajax = u"""
  48     function alumnos_agregar_a_la_lista(texto, lista)
  49     {
  50         t = MochiKit.DOM.getElement(texto);
  51
  52         curso = MochiKit.DOM.getElement('form_cursoID');
  53         if (!curso) {
  54             alert("No deberias ver esto, y quiere decir que tu form esta roto.\\nTe falta un combo de curso");
  55             return;
  56         }
  57         if (curso.value <= 0) {
  58             alert('Debes seleccionar un curso primero');
  59             return;
  60         }
  61         url = "/curso/grupo/get_inscripto?cursoid="+curso.value+"&padron="+t.value;
  62         t.value = "";
  63         return url;
  64     }
  65
  66     function err (err)
  67     {
  68         alert("The metadata for MochiKit.Async could not be fetched :(");
  69     }
  70
  71     function procesar(result)
  72     {
  73         l = MochiKit.DOM.getElement('form_responsable_info');
  74         if (result.error)
  75             l.innerHTML = result.msg;
  76         else
  77             l.innerHTML = result.msg.value;
  78     }
  79
  80     function buscar_alumno()
  81     {
  82         /* Obtengo el padron ingresado */
  83         p = MochiKit.DOM.getElement('form_responsable');
  84         padron = p.value;
  85         if (padron == '') {
  86             return;
  87         }
  88         /* Obtengo el curso */
  89         l = MochiKit.DOM.getElement('form_cursoID');
  90         cursoid = l.value;
  91         if (cursoid <= 0) {
  92             alert('Debe seleccionar un curso');
  93             return;
  94         }
  95         url = "/curso/grupo/get_inscripto?cursoid="+cursoid+'&padron='+padron;
  96         var d = loadJSONDoc(url);
  97         d.addCallbacks(procesar, err);
  98     }
  99
 100     function prepare()
 101     {
 102         connect('form_responsable', 'onblur', buscar_alumno);
 103     }
 104
 105     function doSubmit()
 106     {
 107         /* TODO : Validar datos y evitar el submit si no esta completo */
 108
 109         /* Selecciono todos los miembros si no, no llegan al controllere*/
 110         l = MochiKit.DOM.getElement('form_miembros');
 111         for (i=0; i<l.options.length; i++) {
 112             l.options[i].selected = true;
 113         }
 114         return true; // Dejo hacer el submit
 115     }
 116
 117     MochiKit.DOM.addLoadEvent(prepare)
 118
 119 """
 120
 121 class GrupoForm(W.TableForm):
 122     class Fields(W.WidgetsList):
 123         cursoID = W.HiddenField()
 124         nombre = W.TextField(label=_(u'Nombre'), validator=V.UnicodeString(not_empty=True,strip=True))
 125         responsable = CustomTextField(label=_(u'Responsable'), validator=V.UnicodeString(), attrs=dict(size='8'))
 126         miembros = AjaxMultiSelect(label=_(u'Miembros'), validator=V.Int(), on_add="alumnos_agregar_a_la_lista")
 127         tutores = W.MultipleSelectField(label=_(u'Tutores'), validator=V.Int())
 128
 129     fields = Fields()
 130     javascript = [W.JSSource("MochiKit.DOM.focusOnLoad('form_nombre');"), W.JSSource(ajax)]
 131     form_attrs = dict(onsubmit='return doSubmit()')
 132
 133 form = GrupoForm()
 134
 135 #}}}
 136
 137 #{{{ Controlador
 138 class GrupoController(controllers.Controller, identity.SecureResource):
 139     """Basic model admin interface"""
 140     require = identity.has_permission('admin')
 141
 142     @expose()
 143     def default(self, tg_errors=None):
 144         """handle non exist urls"""
 145         raise redirect(tg.url('/curso/list'))
 146
 147     @expose()
 148     def index(self):
 149         raise redirect(tg.url('/curso/list'))
 150
 151     @expose(template='kid:%s.templates.list' % __name__)
 152     @paginate('records')
 153     def list(self, cursoID):
 154         """List records in model"""
 155         r = cls.select(cls.q.cursoID == cursoID)
 156         return dict(records=r, name=name, namepl=namepl, cursoID=int(cursoID))
 157
 158     @expose(template='kid:%s.templates.new' % __name__)
 159     def new(self, cursoID, **kw):
 160         """Create new records in model"""
 161         form.fields[0].attrs['value'] = cursoID
 162         options = dict(tutores=get_docentes_inscriptos(cursoID))
 163         return dict(name=name, namepl=namepl, cursoID=int(cursoID), form=form, options=options, values=kw)
 164
 165     @validate(form=form)
 166     @error_handler(new)
 167     @expose()
 168     def create(self, **kw):
 169         """Save or create record to model"""
 170         resp = kw['responsable']
 171         try:
 172             # Busco el alumno inscripto
 173             resp = AlumnoInscripto.selectBy(cursoID=kw['cursoID'],
 174                 alumno=Alumno.byPadron(kw['responsable'])).getOne()
 175         except SQLObjectNotFound:
 176             resp = None
 177         kw['responsable'] = resp
 178
 179         r = validate_new(kw)
 180         flash(_(u'Se creó un nuevo %s.') % name)
 181         raise redirect('list/%d' % int(kw['cursoID']))
 182
 183     @expose(template='kid:%s.templates.edit' % __name__)
 184     def edit(self, id, **kw):
 185         """Edit record in model"""
 186         r = validate_get(id)
 187         # TODO : No encontre mejor forma de pasar cosas al form
 188         # de manera comoda y facil de formatear segun lo que espera la UI (que
 189         # en este caso es super particular). Ese EmptyClass no se si hay algo estandar
 190         # en python que usar, puse {} y [] pero cuando quiero hacer values.id = XX explota.
 191         options = dict(tutores=get_docentes_inscriptos(r.curso.id))
 192         class EmptyClass:
 193             pass
 194         values = EmptyClass()
 195         values.id = r.id
 196         values.cursoID = r.cursoID
 197         values.nombre = r.nombre
 198         # TODO : Ver como llenar la lista primero :S
 199         if r.responsable:
 200             values.responsable = r.responsable.alumno.padron
 201         values.miembros = [{"id":i.alumno.id, "label":i.alumno.alumno.nombre} for i in filter(lambda x: x.baja is None, r.miembros)]
 202         values.tutores = [a.docenteID for a in r.tutores]
 203         return dict(name=name, namepl=namepl, record=values, options=options, form=form)
 204
 205     @validate(form=form)
 206     @error_handler(edit)
 207     @expose()
 208     def update(self, id, **kw):
 209         """Save or create record to model"""
 210         responsable = kw['responsable']
 211         curso = kw['cursoID']
 212         resp = kw['responsable']
 213         try:
 214             # Busco el alumno inscripto
 215             resp = AlumnoInscripto.selectBy(cursoID=kw['cursoID'],
 216                 alumno=Alumno.byPadron(kw['responsable'])).getOne()
 217         except SQLObjectNotFound:
 218             resp = None
 219         kw['responsable'] = resp
 220         r = validate_set(id, kw)
 221         flash(_(u'El %s fue actualizado.') % name)
 222         raise redirect('../list/%d' % r.curso.id)
 223
 224     @expose(template='kid:%s.templates.show' % __name__)
 225     def show(self,id, **kw):
 226         """Show record in model"""
 227         r = validate_get(id)
 228         return dict(name=name, namepl=namepl, record=r)
 229
 230     @expose()
 231     def delete(self, cursoID, id):
 232         """Destroy record in model"""
 233         validate_del(id)
 234         flash(_(u'El %s fue eliminado permanentemente.') % name)
 235         raise redirect('../../list/%d' % int(cursoID))
 236
 237     @expose('json')
 238     def get_inscripto(self, cursoid, padron):
 239         msg = u''
 240         error=False
 241         try:
 242             # Busco el alumno inscripto
 243             alumno = AlumnoInscripto.selectBy(curso=cursoid, alumno=Alumno.byUsuario(padron)).getOne()
 244             msg = {}
 245             msg['id'] = alumno.id
 246             msg['value'] = alumno.alumno.nombre
 247         except SQLObjectNotFound:
 248             msg = 'No existe el alumno %s en el curso seleccionado.' % padron
 249             error=True
 250         except Exception, (inst):
 251             msg = u"""Se ha producido un error inesperado al buscar el registro:\n      %s""" % str(inst)
 252             error = True
 253         return dict(msg=msg, error=error)
 254
 255     @expose('json')
 256     def get_alumnos(self, grupoid):
 257         msg = u''
 258         error=False
 259         try:
 260             # Busco los alumnos del grupo
 261             grupo = Grupo.get(int(grupoid))
 262             miembros = Miembro.selectBy(baja=None, grupo=grupo)
 263             print miembros
 264             integrantes = []
 265             for m in miembros:
 266                 msg = {}
 267                 alumnoInscripto = AlumnoInscripto.get(m.alumno.id)
 268                 msg['id'] = alumnoInscripto.id
 269                 msg['label'] = alumnoInscripto.shortrepr()
 270                 integrantes.append(msg)
 271         except Exception, (inst):
 272             msg = u"""Se ha producido un error inesperado al buscar el registro:\n      %s""" % str(inst)
 273             error = True
 274             integrantes = []
 275             integrantes.append(msg)
 276         return dict(msg=integrantes, error=error)
 277 #}}}
 278