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, url
  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 from sqlobject.dberrors import *
  16
  17 from sercom.widgets import *
  18
  19 import logging
  20
  21 log = logging.getLogger('sercom.curso.grupo.admin')
  22
  23 #}}}
  24
  25 #{{{ Configuración
  26 cls = Grupo
  27 name = 'grupo'
  28 namepl = 'grupos'
  29 #}}}
  30
  31 #{{{ Validación
  32 def validate_get(id):
  33     return val.validate_get(cls, name, id)
  34
  35 def validate_set(id, data):
  36     return val.validate_set(cls, name, id, data)
  37
  38 def validate_new(data):
  39     return val.validate_new(cls, name, data)
  40
  41 def validate_del(id):
  42     return val.validate_del(cls, name, id)
  43 #}}}
  44
  45 #{{{ Formulario
  46 def get_docentes():
  47     return [(fk1.id, fk1.shortrepr()) for fk1 in Docente.select()]
  48
  49 def get_docentes_inscriptos(id):
  50     return [(fk1.id, fk1.shortrepr()) for fk1 in DocenteInscripto.select(DocenteInscripto.q.cursoID==id)]
  51
  52 ajax = u"""
  53     function alumnos_agregar_a_la_lista(texto, lista)
  54     {
  55         t = MochiKit.DOM.getElement(texto);
  56
  57         curso = MochiKit.DOM.getElement('form_cursoID');
  58         if (!curso) {
  59             alert("No deberias ver esto, y quiere decir que tu form esta roto.\\nTe falta un combo de curso");
  60             return;
  61         }
  62         if (curso.value <= 0) {
  63             alert('Debes seleccionar un curso primero');
  64             return;
  65         }
  66         url = "/curso/grupo/get_inscripto?cursoid="+curso.value+"&padron="+t.value;
  67         t.value = "";
  68         return url;
  69     }
  70
  71     function err (err)
  72     {
  73         alert("The metadata for MochiKit.Async could not be fetched :(");
  74     }
  75
  76     function procesar(result)
  77     {
  78         l = MochiKit.DOM.getElement('form_responsable_info');
  79         if (result.error)
  80             l.innerHTML = result.msg;
  81         else
  82             l.innerHTML = result.msg.value;
  83     }
  84
  85     function buscar_alumno()
  86     {
  87         /* Obtengo el padron ingresado */
  88         p = MochiKit.DOM.getElement('form_responsable');
  89         padron = p.value;
  90         if (padron == '') {
  91             return;
  92         }
  93         /* Obtengo el curso */
  94         l = MochiKit.DOM.getElement('form_cursoID');
  95         cursoid = l.value;
  96         if (cursoid <= 0) {
  97             alert('Debe seleccionar un curso');
  98             return;
  99         }
 100         url = "/curso/grupo/get_inscripto?cursoid="+cursoid+'&padron='+padron;
 101         var d = loadJSONDoc(url);
 102         d.addCallbacks(procesar, err);
 103     }
 104
 105     function prepare()
 106     {
 107         connect('form_responsable', 'onblur', buscar_alumno);
 108     }
 109
 110     function doSubmit()
 111     {
 112         /* TODO : Validar datos y evitar el submit si no esta completo */
 113
 114         /* Selecciono todos los miembros si no, no llegan al controllere*/
 115         l = MochiKit.DOM.getElement('form_miembros');
 116         for (i=0; i<l.options.length; i++) {
 117             l.options[i].selected = true;
 118         }
 119         return true; // Dejo hacer el submit
 120     }
 121
 122     MochiKit.DOM.addLoadEvent(prepare)
 123
 124 """
 125
 126 class GrupoForm(W.TableForm):
 127     class Fields(W.WidgetsList):
 128         cursoID = W.HiddenField()
 129         nombre = W.TextField(label=_(u'Nombre'), validator=V.UnicodeString(not_empty=True,strip=True))
 130         responsable = CustomTextField(label=_(u'Responsable'), validator=V.UnicodeString(), attrs=dict(size='8'))
 131         miembros = AjaxMultiSelect(label=_(u'Miembros'), validator=V.Int(), on_add="alumnos_agregar_a_la_lista")
 132         tutores = W.MultipleSelectField(label=_(u'Tutores'), validator=V.Int())
 133
 134     fields = Fields()
 135     javascript = [W.JSSource("MochiKit.DOM.focusOnLoad('form_nombre');"), W.JSSource(ajax)]
 136     form_attrs = dict(onsubmit='return doSubmit()')
 137
 138 form = GrupoForm()
 139
 140 def get_gruposA(cursoID):
 141     return [(0, u'---')] + [(g.id, g.shortrepr()) for g in Grupo.select(Grupo.q.cursoID==cursoID)]
 142
 143 def get_gruposB(cursoID):
 144     return [(0, u'Nuevo Grupo')] + [(g.id, g.shortrepr()) for g in Grupo.select(Grupo.q.cursoID==cursoID)]
 145
 146 ajaxadmin = u"""
 147     function err (err)
 148     {
 149         alert("The metadata for MochiKit.Async could not be fetched :(");
 150     }
 151
 152     function doSubmit()
 153     {
 154         /* TODO : Validar datos y evitar el submit si no esta completo */
 155
 156         /* Selecciono todos los miembros si no, no llegan al controllere*/
 157         l = MochiKit.DOM.getElement('form_grupos_to');
 158         for (i=0; i<l.options.length; i++) {
 159             l.options[i].selected = true;
 160         }
 161         /* Selecciono todos los miembros si no, no llegan al controllere*/
 162         l = MochiKit.DOM.getElement('form_grupos_from');
 163         for (i=0; i<l.options.length; i++) {
 164             l.options[i].selected = true;
 165         }
 166
 167         return true; // Dejo hacer el submit
 168     }
 169
 170     function initWidgets(disabled) {
 171         if ( disabled ) {
 172             MochiKit.DOM.getElement('form_listaGrupoA').selectedIndex = 0;
 173         }
 174         MochiKit.DOM.getElement('form_listaGrupoB').selectedIndex = 0;
 175         MochiKit.DOM.getElement('form_grupos_to').options.length = 0;
 176         MochiKit.DOM.getElement('form_grupos_from').options.length = 0;
 177         MochiKit.DOM.getElement('form_listaGrupoB').disabled = disabled;
 178         MochiKit.DOM.getElement('form_grupos_to').disabled = disabled;
 179         MochiKit.DOM.getElement('form_grupos_from').disabled = disabled;
 180     }
 181
 182     function onListaAChange() {
 183         lista = MochiKit.DOM.getElement('form_listaGrupoA');
 184         if ( lista.selectedIndex != '0' ) {
 185             initWidgets(false);
 186         } else {
 187             initWidgets(true);
 188             return;
 189         }
 190         // carga el grupo en el multiple select
 191         grupoA = MochiKit.DOM.getElement('form_grupos_from');
 192         id = lista.options[lista.selectedIndex].value
 193         cargarGrupo(id, grupoA);
 194     }
 195
 196     function onListaBChange() {
 197         lista = MochiKit.DOM.getElement('form_listaGrupoB');
 198         listaA =  MochiKit.DOM.getElement('form_listaGrupoA');
 199         MochiKit.DOM.getElement('form_grupos_to').options.length = 0;
 200         if ( lista.selectedIndex == 0 ) {
 201             return;
 202         }
 203         if ( lista.selectedIndex != '0' ) {
 204             if ( lista.selectedIndex == listaA.selectedIndex ) {
 205                 window.alert('Debe seleccionar 2 grupos distintos');
 206                 MochiKit.DOM.getElement('form_grupos_to').options.length = 0;
 207                 return;
 208             }
 209             grupoB = MochiKit.DOM.getElement('form_grupos_to');
 210             id = lista.options[lista.selectedIndex].value
 211             cargarGrupo(id, grupoB);
 212         }
 213     }
 214
 215     function makeOption(option) {
 216         return OPTION({"value": option.value}, option.text);
 217     }
 218
 219     function cargarGrupo(grupoid, lista) {
 220         var result = loadJSONDoc('/curso/grupo/get_alumnos?grupoid='+id);
 221         result.addCallbacks(partial(cargarLista, lista), err)
 222     }
 223
 224     function err (err)
 225     {
 226         alert("The metadata for MochiKit.Async could not be fetched :(");
 227     }
 228
 229     function cargarLista(lista, result) {
 230         var alumnos = result.msg;
 231         if (result.error) {
 232             window.alert(result.msg);
 233             return;
 234         }
 235         for (i in alumnos) {
 236             id = alumnos[i].id;
 237             label = alumnos[i].label;
 238             MochiKit.DOM.appendChildNodes(lista, OPTION({"value":id}, label))
 239         }
 240         ActualizarResponsables();
 241     }
 242
 243     function ActualizarResponsables()
 244     {
 245         replaceChildNodes('form_responsableA', '');
 246         replaceChildNodes('form_responsableB', '');
 247         appendChildNodes('form_responsableA', map(makeOption, $('form_grupos_from').options));
 248         appendChildNodes('form_responsableB', map(makeOption, $('form_grupos_to').options));
 249     }
 250 """
 251
 252 class GrupoAdminForm(W.TableForm):
 253     class Fields(W.WidgetsList):
 254         cursoID = W.HiddenField()
 255         listaGrupoA = W.SingleSelectField(label=_(u'Grupo A'), attrs = dict(onChange='onListaAChange()'), validator = V.Int(not_empty=True))
 256         listaGrupoB = W.SingleSelectField(label=_(u'Grupo B'), attrs = dict(onChange='onListaBChange()'), validator = V.Int(not_empty=True))
 257         grupos = AjaxDosListasSelect(label=_(u'Grupos'),title_from=u"Grupo A", size=8, move_signal="ActualizarResponsables();", title_to=u"Grupo B", validator=V.Int(not_empty=True))
 258         responsableA = W.SingleSelectField(label=_(u'Responsable A'), validator = V.Int())
 259         responsableB = W.SingleSelectField(label=_(u'Responsable B'), validator = V.Int())
 260         tutoresA = W.MultipleSelectField(label=_(u'Tutores A'), validator = V.Int(not_empty=True))
 261         tutoresB = W.MultipleSelectField(label=_(u'Tutores B'), validator = V.Int(not_empty=True))
 262
 263     fields = Fields()
 264     javascript = [W.JSSource("MochiKit.DOM.focusOnLoad('listaGrupoA');"), W.JSSource(ajaxadmin)]
 265     form_attrs = dict(onsubmit='return doSubmit();')
 266
 267 formadmin = GrupoAdminForm()
 268
 269 #}}}
 270
 271 #{{{ Controlador
 272 class GrupoController(controllers.Controller, identity.SecureResource):
 273     """Basic model admin interface"""
 274     require = identity.has_permission('admin')
 275
 276     @expose()
 277     def default(self, tg_errors=None):
 278         """handle non exist urls"""
 279         raise redirect(tg.url('/curso/list'))
 280
 281     @expose()
 282     def index(self):
 283         raise redirect(tg.url('/curso/list'))
 284
 285     @expose(template='kid:%s.templates.list' % __name__)
 286     @paginate('records')
 287     def list(self, cursoID):
 288         """List records in model"""
 289         r = cls.select(cls.q.cursoID == cursoID)
 290         return dict(records=r, name=name, namepl=namepl, cursoID=int(cursoID))
 291
 292     @expose(template='kid:%s.templates.new' % __name__)
 293     def new(self, cursoID, **kw):
 294         """Create new records in model"""
 295         form.fields[0].attrs['value'] = cursoID
 296         options = dict(tutores=get_docentes_inscriptos(cursoID))
 297         return dict(name=name, namepl=namepl, cursoID=int(cursoID), form=form, options=options, values=kw)
 298
 299     @validate(form=form)
 300     @error_handler(new)
 301     @expose()
 302     def create(self, **kw):
 303         """Save or create record to model"""
 304         resp = kw['responsable']
 305         try:
 306             # Busco el alumno inscripto
 307             resp = AlumnoInscripto.selectBy(cursoID=kw['cursoID'],
 308                 alumno=Alumno.byPadron(kw['responsable'])).getOne()
 309         except SQLObjectNotFound:
 310             resp = None
 311         kw['responsable'] = resp
 312
 313         r = validate_new(kw)
 314         flash(_(u'Se creó un nuevo %s.') % name)
 315         raise redirect('list/%d' % int(kw['cursoID']))
 316
 317     @expose(template='kid:%s.templates.edit' % __name__)
 318     def edit(self, id, **kw):
 319         """Edit record in model"""
 320         r = validate_get(id)
 321         # TODO : No encontre mejor forma de pasar cosas al form
 322         # de manera comoda y facil de formatear segun lo que espera la UI (que
 323         # en este caso es super particular). Ese EmptyClass no se si hay algo estandar
 324         # en python que usar, puse {} y [] pero cuando quiero hacer values.id = XX explota.
 325         options = dict(tutores=get_docentes_inscriptos(r.curso.id))
 326         class EmptyClass:
 327             pass
 328         values = EmptyClass()
 329         values.id = r.id
 330         values.cursoID = r.cursoID
 331         values.nombre = r.nombre
 332         # TODO : Ver como llenar la lista primero :S
 333         if r.responsable:
 334             values.responsable = r.responsable.alumno.padron
 335         values.miembros = [{"id":i.alumno.id, "label":i.alumno.alumno.nombre} for i in filter(lambda x: x.baja is None, r.miembros)]
 336         values.tutores = [a.docenteID for a in r.tutores]
 337         return dict(name=name, namepl=namepl, record=values, options=options, form=form)
 338
 339     @validate(form=form)
 340     @error_handler(edit)
 341     @expose()
 342     def update(self, id, **kw):
 343         """Save or create record to model"""
 344         responsable = kw['responsable']
 345         curso = kw['cursoID']
 346         resp = kw['responsable']
 347         try:
 348             # Busco el alumno inscripto
 349             resp = AlumnoInscripto.selectBy(cursoID=kw['cursoID'],
 350                 alumno=Alumno.byPadron(kw['responsable'])).getOne()
 351         except SQLObjectNotFound:
 352             resp = None
 353         kw['responsable'] = resp
 354         r = validate_set(id, kw)
 355         flash(_(u'El %s fue actualizado.') % name)
 356         raise redirect('../list/%d' % r.curso.id)
 357
 358     @expose(template='kid:%s.templates.show' % __name__)
 359     def show(self,id, **kw):
 360         """Show record in model"""
 361         r = validate_get(id)
 362         return dict(name=name, namepl=namepl, record=r)
 363
 364     @expose()
 365     def delete(self, cursoID, id):
 366         """Destroy record in model"""
 367         validate_del(id)
 368         flash(_(u'El %s fue eliminado permanentemente.') % name)
 369         raise redirect('../../list/%d' % int(cursoID))
 370
 371     @expose('json')
 372     def get_inscripto(self, cursoid, padron):
 373         msg = u''
 374         error=False
 375         try:
 376             # Busco el alumno inscripto
 377             alumno = AlumnoInscripto.selectBy(curso=cursoid, alumno=Alumno.byUsuario(padron)).getOne()
 378             msg = {}
 379             msg['id'] = alumno.id
 380             msg['value'] = alumno.alumno.nombre
 381         except SQLObjectNotFound:
 382             msg = 'No existe el alumno %s en el curso seleccionado.' % padron
 383             error=True
 384         except Exception, (inst):
 385             msg = u"""Se ha producido un error inesperado al buscar el registro:\n      %s""" % str(inst)
 386             error = True
 387         return dict(msg=msg, error=error)
 388
 389     @expose('json')
 390     def get_alumnos(self, grupoid):
 391         msg = u''
 392         error=False
 393         try:
 394             # Busco los alumnos del grupo
 395             grupo = Grupo.get(int(grupoid))
 396             miembros = Miembro.selectBy(baja=None, grupo=grupo)
 397             print miembros
 398             integrantes = []
 399             for m in miembros:
 400                 msg = {}
 401                 alumnoInscripto = AlumnoInscripto.get(m.alumno.id)
 402                 msg['id'] = alumnoInscripto.id
 403                 msg['label'] = alumnoInscripto.shortrepr()
 404                 integrantes.append(msg)
 405         except Exception, (inst):
 406             msg = u"""Se ha producido un error inesperado al buscar el registro:\n      %s""" % str(inst)
 407             error = True
 408             integrantes = []
 409             integrantes.append(msg)
 410         return dict(msg=integrantes, error=error)
 411
 412     @expose(template='kid:%s.templates.admin' % __name__)
 413     def admin(self, cursoID, **kw):
 414         """Create new records in model"""
 415         options = dict(
 416             listaGrupoA=get_gruposA(cursoID),
 417             listaGrupoB=get_gruposB(cursoID),
 418             tutoresA=get_docentes_inscriptos(cursoID),
 419             tutoresB=get_docentes_inscriptos(cursoID),
 420         )
 421         kw['cursoID'] = cursoID
 422         return dict(name=name, namepl=namepl, options=options, form=formadmin, values=kw, cursoID=int(cursoID))
 423
 424     @validate(form=formadmin)
 425     @error_handler(admin)
 426     @expose()
 427     def adminupdate(self, **kw):
 428         """Save or create record to model"""
 429         cursoID = int(kw['cursoID'])
 430         log.debug(kw)
 431         grupoAId = kw['listaGrupoA']
 432         grupoBId = kw['listaGrupoB']
 433         miembrosA = kw.get('grupos_from', [])
 434         miembrosB = kw.get('grupos_to', [])
 435         responsableA = kw['responsableA']
 436         responsableB = kw['responsableB']
 437         tutoresA = kw.get('tutoresA', [])
 438         tutoresB = kw.get('tutoresB', [])
 439
 440         # por las dudas de que no sea una lista
 441         if not isinstance(miembrosA, list):
 442             miembrosA = [miembrosA]
 443         if not isinstance(miembrosB, list):
 444             miembrosB = [miembrosB]
 445         if not isinstance(tutoresA, list):
 446             tutoresA = [tutoresA]
 447         if not isinstance(tutoresB, list):
 448             tutoresB = [tutoresB]
 449
 450
 451         """ levanto los grupos originales """
 452         grupoAorig = validate_get(int(grupoAId))
 453         log.debug(miembrosA)
 454         log.debug(Miembro.selectBy(grupo=grupoAorig, baja=None))
 455         """ Si el grupo A quedo vacio deberia eliminarlo (primero
 456             genero los otros para que no elimine los alumnos)"""
 457         for mA in Miembro.selectBy(grupo=grupoAorig, baja=None):
 458             if str(mA.alumno.id) not in miembrosA:
 459                 grupoAorig.remove_miembro(mA.alumno.id)
 460
 461         try:
 462             grupoA = validate_get(grupoAId)
 463             for a in miembrosA:
 464                 try:
 465                     grupoA.add_miembro(a, baja=None)
 466                 except DuplicateEntryError:
 467                     continue
 468         except Exception, e:
 469             log.debug(e)
 470             flash(_(u'Error A %s.' % e))
 471             raise redirect(url('/curso/grupo/list' % int(cursoID)))
 472         # seteo el reponsable del grupo
 473         if int(responsableA) != 0:
 474             grupoA.responsable = AlumnoInscripto.get(int(responsableA))
 475
 476         for t in tutoresA:
 477             try:
 478                 grupoA.add_tutor(int(t))
 479             except:
 480                 #TODO ver por que no anda el duplicate error, por ahora cacheo silencioso
 481                 pass
 482
 483
 484         #Elimino el grupo si quedo vacio
 485         if len(miembrosA) == 0:
 486             try:
 487                 validate_del(grupoAId)
 488             except:
 489                 pass
 490
 491         # si se selecciono un grupo nuevo
 492         if int(grupoBId) == 0:
 493             # creo un grupo nuevo
 494             nuevosMiembros = []
 495             for m in miembrosB:
 496                 nuevosMiembros.append(AlumnoInscripto.get(int(m)))
 497             nuevosTutores = []
 498             for t in tutoresB:
 499                 nuevosTutores.append(Docente.get(t))
 500             #Creo el nuevo grupo
 501             Grupo(miembros = nuevosMiembros, tutores = nuevosTutores, cursoID=cursoID, nombre='NuevoGrupo'+str(cursoID))
 502         else:
 503             grupoBorig = validate_get(int(grupoBId))
 504             log.debug(miembrosB)
 505             b = list(Miembro.selectBy(grupo=grupoBorig, baja=None))
 506             log.debug(b)
 507             #borro todos y los vuelvo a agregar
 508             for mB in Miembro.selectBy(grupo=grupoBorig, baja=None):
 509                 if str(mB.alumno.id) not in miembrosB:
 510                     grupoBorig.remove_miembro(mB.alumno.id)
 511             try:
 512                 grupoB = validate_get(grupoBId)
 513                 for b in miembrosB:
 514                     try:
 515                         grupoB.add_miembro(b, baja=None)
 516                     except DuplicateEntryError:
 517                         continue
 518             except Exception, e:
 519                 log.debug(e)
 520                 flash(_(u'Error B %s.' % e))
 521                 raise redirect(url('/curso/grupo/list/%d' % int(cursoID)))
 522             # seteo el reponsable del grupo
 523             if int(responsableB) != 0:
 524                 grupoB.responsable = AlumnoInscripto.get(int(responsableB))
 525
 526             #Elimino el grupo si quedo vacio
 527             if len(miembrosB) == 0:
 528                 try:
 529                     validate_del(grupoBId)
 530                 except:
 531                     pass
 532
 533             for t in tutoresB:
 534                 try:
 535                     grupoB.add_tutor(int(t))
 536                 except:
 537                     #TODO ver por que no anda el duplicate error, por ahora cahceo silencioso
 538                     pass
 539         flash(_(u'Los grupos fueron actualizado.'))
 540         raise redirect(url('/curso/grupo/list/%d' % int(cursoID)))
 541 #}}}
 542