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         MochiKit.DOM.getElement('form_tutoresA').disabled = true;
 181         MochiKit.DOM.getElement('form_tutoresB').disabled = true;
 182         MochiKit.DOM.getElement('form_responsableA').disabled = true;
 183         MochiKit.DOM.getElement('form_responsableB').disabled = true;
 184     }
 185
 186     function onListaAChange() {
 187         lista = MochiKit.DOM.getElement('form_listaGrupoA');
 188         if ( lista.selectedIndex != '0' ) {
 189             initWidgets(false);
 190         } else {
 191             initWidgets(true);
 192             return;
 193         }
 194         // carga el grupo en el multiple select
 195         grupoA = MochiKit.DOM.getElement('form_grupos_from');
 196         id = lista.options[lista.selectedIndex].value
 197         cargarGrupo(id, grupoA);
 198     }
 199
 200     function onListaBChange() {
 201         lista = MochiKit.DOM.getElement('form_listaGrupoB');
 202         listaA =  MochiKit.DOM.getElement('form_listaGrupoA');
 203         MochiKit.DOM.getElement('form_grupos_to').options.length = 0;
 204         if ( lista.selectedIndex == 0 ) {
 205             return;
 206         }
 207         if ( lista.selectedIndex != '0' ) {
 208             if ( lista.selectedIndex == listaA.selectedIndex ) {
 209                 window.alert('Debe seleccionar 2 grupos distintos');
 210                 MochiKit.DOM.getElement('form_grupos_to').options.length = 0;
 211                 return;
 212             }
 213             grupoB = MochiKit.DOM.getElement('form_grupos_to');
 214             id = lista.options[lista.selectedIndex].value
 215             cargarGrupo(id, grupoB);
 216         }
 217     }
 218
 219     function makeOption(option) {
 220         return OPTION({"value": option.value}, option.text);
 221     }
 222
 223     function cargarGrupo(grupoid, lista) {
 224         var result = loadJSONDoc('/curso/grupo/get_alumnos?grupoid='+id);
 225         result.addCallbacks(partial(cargarLista, lista), err)
 226     }
 227
 228     function err (err)
 229     {
 230         alert("The metadata for MochiKit.Async could not be fetched :(");
 231     }
 232
 233     function cargarLista(lista, result) {
 234         var alumnos = result.msg;
 235         if (result.error) {
 236             window.alert(result.msg);
 237             return;
 238         }
 239         for (i in alumnos) {
 240             id = alumnos[i].id;
 241             label = alumnos[i].label;
 242             MochiKit.DOM.appendChildNodes(lista, OPTION({"value":id}, label))
 243         }
 244         ActualizarResponsables();
 245     }
 246
 247     function ActualizarResponsables()
 248     {
 249         replaceChildNodes('form_responsableA', '');
 250         replaceChildNodes('form_responsableB', '');
 251         appendChildNodes('form_responsableA', map(makeOption, $('form_grupos_from').options));
 252         appendChildNodes('form_responsableB', map(makeOption, $('form_grupos_to').options));
 253
 254         if (getElement('form_grupos_from').options.length == 0) {
 255             getElement('form_tutoresA').disabled = true;
 256             getElement('form_responsableA').disabled = true;
 257         } else {
 258             getElement('form_tutoresA').disabled = false;
 259             getElement('form_responsableA').disabled = false;
 260         }
 261         if (getElement('form_grupos_to').options.length == 0) {
 262             getElement('form_tutoresB').disabled = true;
 263             getElement('form_responsableB').disabled = true;
 264         } else {
 265             getElement('form_tutoresB').disabled = false;
 266             getElement('form_responsableB').disabled = false;
 267         }
 268     }
 269 """
 270
 271 class GrupoAdminForm(W.TableForm):
 272     class Fields(W.WidgetsList):
 273         cursoID = W.HiddenField()
 274         listaGrupoA = W.SingleSelectField(label=_(u'Grupo A'), attrs = dict(onChange='onListaAChange()'), validator = V.Int(not_empty=True))
 275         listaGrupoB = W.SingleSelectField(label=_(u'Grupo B'), attrs = dict(onChange='onListaBChange()'), validator = V.Int(not_empty=True))
 276         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))
 277         responsableA = W.SingleSelectField(label=_(u'Responsable A'), validator = V.Int())
 278         responsableB = W.SingleSelectField(label=_(u'Responsable B'), validator = V.Int())
 279         tutoresA = W.MultipleSelectField(label=_(u'Tutores A'), validator = V.Int(not_empty=True))
 280         tutoresB = W.MultipleSelectField(label=_(u'Tutores B'), validator = V.Int(not_empty=True))
 281
 282     fields = Fields()
 283     javascript = [W.JSSource("MochiKit.DOM.focusOnLoad('listaGrupoA');"), W.JSSource(ajaxadmin)]
 284     form_attrs = dict(onsubmit='return doSubmit();')
 285
 286 formadmin = GrupoAdminForm()
 287
 288 #}}}
 289
 290 #{{{ Controlador
 291 class GrupoController(controllers.Controller, identity.SecureResource):
 292     """Basic model admin interface"""
 293     require = identity.has_permission('admin')
 294
 295     @expose()
 296     def default(self, tg_errors=None):
 297         """handle non exist urls"""
 298         raise redirect(tg.url('/curso/list'))
 299
 300     @expose()
 301     def index(self):
 302         raise redirect(tg.url('/curso/list'))
 303
 304     @expose(template='kid:%s.templates.list' % __name__)
 305     @paginate('records')
 306     def list(self, cursoID):
 307         """List records in model"""
 308         r = cls.select(cls.q.cursoID == cursoID)
 309         return dict(records=r, name=name, namepl=namepl, cursoID=int(cursoID))
 310
 311     @expose(template='kid:%s.templates.new' % __name__)
 312     def new(self, cursoID, **kw):
 313         """Create new records in model"""
 314         form.fields[0].attrs['value'] = cursoID
 315         options = dict(tutores=get_docentes_inscriptos(cursoID))
 316         return dict(name=name, namepl=namepl, cursoID=int(cursoID), form=form, options=options, values=kw)
 317
 318     @validate(form=form)
 319     @error_handler(new)
 320     @expose()
 321     def create(self, **kw):
 322         """Save or create record to model"""
 323         resp = kw['responsable']
 324         try:
 325             # Busco el alumno inscripto
 326             resp = AlumnoInscripto.selectBy(cursoID=kw['cursoID'],
 327                 alumno=Alumno.byPadron(kw['responsable'])).getOne()
 328         except SQLObjectNotFound:
 329             resp = None
 330         kw['responsable'] = resp
 331
 332         r = validate_new(kw)
 333         flash(_(u'Se creó un nuevo %s.') % name)
 334         raise redirect('list/%d' % int(kw['cursoID']))
 335
 336     @expose(template='kid:%s.templates.edit' % __name__)
 337     def edit(self, id, **kw):
 338         """Edit record in model"""
 339         r = validate_get(id)
 340         # TODO : No encontre mejor forma de pasar cosas al form
 341         # de manera comoda y facil de formatear segun lo que espera la UI (que
 342         # en este caso es super particular). Ese EmptyClass no se si hay algo estandar
 343         # en python que usar, puse {} y [] pero cuando quiero hacer values.id = XX explota.
 344         options = dict(tutores=get_docentes_inscriptos(r.curso.id))
 345         class EmptyClass:
 346             pass
 347         values = EmptyClass()
 348         values.id = r.id
 349         values.cursoID = r.cursoID
 350         values.nombre = r.nombre
 351         # TODO : Ver como llenar la lista primero :S
 352         if r.responsable:
 353             values.responsable = r.responsable.alumno.padron
 354         values.miembros = [{"id":i.alumno.id, "label":i.alumno.alumno.nombre} for i in filter(lambda x: x.baja is None, r.miembros)]
 355         values.tutores = [a.docenteID for a in r.tutores]
 356         return dict(name=name, namepl=namepl, record=values, options=options, form=form)
 357
 358     @validate(form=form)
 359     @error_handler(edit)
 360     @expose()
 361     def update(self, id, **kw):
 362         """Save or create record to model"""
 363         responsable = kw['responsable']
 364         curso = kw['cursoID']
 365         resp = kw['responsable']
 366         try:
 367             # Busco el alumno inscripto
 368             resp = AlumnoInscripto.selectBy(cursoID=kw['cursoID'],
 369                 alumno=Alumno.byPadron(kw['responsable'])).getOne()
 370         except SQLObjectNotFound:
 371             resp = None
 372         kw['responsable'] = resp
 373         r = validate_set(id, kw)
 374         flash(_(u'El %s fue actualizado.') % name)
 375         raise redirect('../list/%d' % r.curso.id)
 376
 377     @expose(template='kid:%s.templates.show' % __name__)
 378     def show(self,id, **kw):
 379         """Show record in model"""
 380         r = validate_get(id)
 381         return dict(name=name, namepl=namepl, record=r)
 382
 383     @expose()
 384     def delete(self, cursoID, id):
 385         """Destroy record in model"""
 386         validate_del(id)
 387         flash(_(u'El %s fue eliminado permanentemente.') % name)
 388         raise redirect('../../list/%d' % int(cursoID))
 389
 390     @expose('json')
 391     def get_inscripto(self, cursoid, padron):
 392         msg = u''
 393         error=False
 394         try:
 395             # Busco el alumno inscripto
 396             alumno = AlumnoInscripto.selectBy(curso=cursoid, alumno=Alumno.byUsuario(padron)).getOne()
 397             msg = {}
 398             msg['id'] = alumno.id
 399             msg['value'] = alumno.alumno.nombre
 400         except SQLObjectNotFound:
 401             msg = 'No existe el alumno %s en el curso seleccionado.' % padron
 402             error=True
 403         except Exception, (inst):
 404             msg = u"""Se ha producido un error inesperado al buscar el registro:\n      %s""" % str(inst)
 405             error = True
 406         return dict(msg=msg, error=error)
 407
 408     @expose('json')
 409     def get_alumnos(self, grupoid):
 410         msg = u''
 411         error=False
 412         try:
 413             # Busco los alumnos del grupo
 414             grupo = Grupo.get(int(grupoid))
 415             miembros = Miembro.selectBy(baja=None, grupo=grupo)
 416             print miembros
 417             integrantes = []
 418             for m in miembros:
 419                 msg = {}
 420                 alumnoInscripto = AlumnoInscripto.get(m.alumno.id)
 421                 msg['id'] = alumnoInscripto.id
 422                 msg['label'] = alumnoInscripto.shortrepr()
 423                 integrantes.append(msg)
 424         except Exception, (inst):
 425             msg = u"""Se ha producido un error inesperado al buscar el registro:\n      %s""" % str(inst)
 426             error = True
 427             integrantes = []
 428             integrantes.append(msg)
 429         return dict(msg=integrantes, error=error)
 430
 431     @expose(template='kid:%s.templates.admin' % __name__)
 432     def admin(self, cursoID, **kw):
 433         """Create new records in model"""
 434         options = dict(
 435             listaGrupoA=get_gruposA(cursoID),
 436             listaGrupoB=get_gruposB(cursoID),
 437             tutoresA=get_docentes_inscriptos(cursoID),
 438             tutoresB=get_docentes_inscriptos(cursoID),
 439         )
 440         kw['cursoID'] = cursoID
 441         return dict(name=name, namepl=namepl, options=options, form=formadmin, values=kw, cursoID=int(cursoID))
 442
 443     @validate(form=formadmin)
 444     @error_handler(admin)
 445     @expose()
 446     def adminupdate(self, **kw):
 447         """Save or create record to model"""
 448         cursoID = int(kw['cursoID'])
 449         log.debug(kw)
 450         grupoAId = kw['listaGrupoA']
 451         grupoBId = kw['listaGrupoB']
 452         miembrosA = kw.get('grupos_from', [])
 453         miembrosB = kw.get('grupos_to', [])
 454         responsableA = kw['responsableA']
 455         responsableB = kw['responsableB']
 456         tutoresA = kw.get('tutoresA', [])
 457         tutoresB = kw.get('tutoresB', [])
 458
 459         # por las dudas de que no sea una lista
 460         if not isinstance(miembrosA, list):
 461             miembrosA = [miembrosA]
 462         if not isinstance(miembrosB, list):
 463             miembrosB = [miembrosB]
 464         if not isinstance(tutoresA, list):
 465             tutoresA = [tutoresA]
 466         if not isinstance(tutoresB, list):
 467             tutoresB = [tutoresB]
 468
 469
 470         """ levanto los grupos originales """
 471         grupoAorig = validate_get(int(grupoAId))
 472         log.debug(miembrosA)
 473         log.debug(Miembro.selectBy(grupo=grupoAorig, baja=None))
 474         """ Si el grupo A quedo vacio deberia eliminarlo (primero
 475             genero los otros para que no elimine los alumnos)"""
 476         for mA in Miembro.selectBy(grupo=grupoAorig, baja=None):
 477             if str(mA.alumno.id) not in miembrosA:
 478                 grupoAorig.remove_miembro(mA.alumno.id)
 479
 480         try:
 481             grupoA = validate_get(grupoAId)
 482             for a in miembrosA:
 483                 try:
 484                     grupoA.add_miembro(a, baja=None)
 485                 except DuplicateEntryError:
 486                     continue
 487         except Exception, e:
 488             log.debug(e)
 489             flash(_(u'Error A %s.' % e))
 490             raise redirect(url('/curso/grupo/list' % int(cursoID)))
 491         # seteo el reponsable del grupo
 492         if responsableA and int(responsableA) != 0:
 493             grupoA.responsable = AlumnoInscripto.get(int(responsableA))
 494
 495         for t in tutoresA:
 496             try:
 497                 grupoA.add_tutor(int(t))
 498             except:
 499                 #TODO ver por que no anda el duplicate error, por ahora cacheo silencioso
 500                 pass
 501
 502
 503         #Elimino el grupo si quedo vacio
 504         if len(miembrosA) == 0:
 505             try:
 506                 validate_del(grupoAId)
 507             except:
 508                 pass
 509
 510         # si se selecciono un grupo nuevo
 511         if int(grupoBId) == 0:
 512             # creo un grupo nuevo
 513             nuevosMiembros = []
 514             for m in miembrosB:
 515                 nuevosMiembros.append(AlumnoInscripto.get(int(m)))
 516             nuevosTutores = []
 517             for t in tutoresB:
 518                 nuevosTutores.append(DocenteInscripto.get(t))
 519             #Creo el nuevo grupo
 520             Grupo(miembros = nuevosMiembros, tutores = nuevosTutores, cursoID=cursoID, nombre='NuevoGrupo'+str(cursoID))
 521         else:
 522             grupoBorig = validate_get(int(grupoBId))
 523             log.debug(miembrosB)
 524             b = list(Miembro.selectBy(grupo=grupoBorig, baja=None))
 525             log.debug(b)
 526             #borro todos y los vuelvo a agregar
 527             for mB in Miembro.selectBy(grupo=grupoBorig, baja=None):
 528                 if str(mB.alumno.id) not in miembrosB:
 529                     grupoBorig.remove_miembro(mB.alumno.id)
 530             try:
 531                 grupoB = validate_get(grupoBId)
 532                 for b in miembrosB:
 533                     try:
 534                         grupoB.add_miembro(b, baja=None)
 535                     except DuplicateEntryError:
 536                         continue
 537             except Exception, e:
 538                 log.debug(e)
 539                 flash(_(u'Error B %s.' % e))
 540                 raise redirect(url('/curso/grupo/list/%d' % int(cursoID)))
 541             # seteo el reponsable del grupo
 542             if responsableB and int(responsableB) != 0:
 543                 grupoB.responsable = AlumnoInscripto.get(int(responsableB))
 544
 545             #Elimino el grupo si quedo vacio
 546             if len(miembrosB) == 0:
 547                 try:
 548                     validate_del(grupoBId)
 549                 except:
 550                     pass
 551
 552             for t in tutoresB:
 553                 try:
 554                     grupoB.add_tutor(int(t))
 555                 except:
 556                     #TODO ver por que no anda el duplicate error, por ahora cahceo silencioso
 557                     pass
 558         flash(_(u'Los grupos fueron actualizado.'))
 559         raise redirect(url('/curso/grupo/list/%d' % int(cursoID)))
 560 #}}}
 561