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