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