1 | #-*- mode: python; mode: fold -*- |
---|
2 | # $Id: Widgets.py 1243 2007-01-08 17:39:17Z joachim $ |
---|
3 | from cgi import escape |
---|
4 | from types import * |
---|
5 | from Globals import InitializeClass |
---|
6 | ##from Products.CPSSchemas.Widget import CPSWidgetType |
---|
7 | from Products.CMFCore.utils import getToolByName |
---|
8 | from Products.CPSSchemas.BasicWidgets import CPSWidget, CPSStringWidget, CPSEmailWidget,CPSImageWidget |
---|
9 | from Products.CPSSchemas.BasicWidgets import renderHtmlTag,CPSSelectWidget, CPSStringWidget |
---|
10 | from Products.CPSSchemas.ExtendedWidgets import CPSDateTimeWidget |
---|
11 | from Products.CPSSchemas.Widget import widgetRegistry |
---|
12 | ##from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry |
---|
13 | from DateTime.DateTime import DateTime |
---|
14 | from AccessControl import getSecurityManager |
---|
15 | from Products.WAeUP_SRP.Students import getStudentByRegNo |
---|
16 | from re import compile |
---|
17 | import logging |
---|
18 | |
---|
19 | #from zLOG import LOG, DEBUG |
---|
20 | |
---|
21 | class CPSSelectWidgetForRecord(CPSSelectWidget): ###( |
---|
22 | """Select widget. with record names""" |
---|
23 | meta_type = 'Select Widget for Records' |
---|
24 | |
---|
25 | field_types = ('CPS String Field',) |
---|
26 | field_inits = ({'is_searchabletext': 1,},) |
---|
27 | |
---|
28 | _properties = CPSSelectWidget._properties + ( |
---|
29 | {'id': 'record_id', 'type': 'string', 'mode': 'w', |
---|
30 | 'label': 'Record Id', 'is_required' : 1}, |
---|
31 | ) |
---|
32 | |
---|
33 | def render(self, mode, datastructure, **kw): |
---|
34 | """Render in mode from datastructure.""" |
---|
35 | value = datastructure[self.getWidgetId()] |
---|
36 | vocabulary = self._getVocabulary(datastructure) |
---|
37 | portal = getToolByName(self, 'portal_url').getPortalObject() |
---|
38 | cpsmcat = portal.translation_service |
---|
39 | if mode == 'view': |
---|
40 | if self.translated: |
---|
41 | return escape(cpsmcat(vocabulary.getMsgid(value, value)).encode('ISO-8859-15', 'ignore')) |
---|
42 | else: |
---|
43 | return escape(vocabulary.get(value, value)) |
---|
44 | elif mode == 'edit': |
---|
45 | html_widget_id = self.getHtmlWidgetId() |
---|
46 | res = renderHtmlTag('select', |
---|
47 | name='%s.%s:records' % (self.record_id,html_widget_id), |
---|
48 | id=html_widget_id) |
---|
49 | in_selection = 0 |
---|
50 | for k, v in vocabulary.items(): |
---|
51 | if self.translated: |
---|
52 | kw = {'value': k, |
---|
53 | 'contents': cpsmcat(vocabulary.getMsgid(k, k)).encode('ISO-8859-15', 'ignore') |
---|
54 | } |
---|
55 | else: |
---|
56 | kw = {'value': k, 'contents': v} |
---|
57 | if value == k: |
---|
58 | kw['selected'] = 'selected' |
---|
59 | in_selection = 1 |
---|
60 | res += renderHtmlTag('option', **kw) |
---|
61 | if value and not in_selection: |
---|
62 | kw = {'value': value, 'contents': 'invalid: '+ str(value), |
---|
63 | 'selected': 'selected'} |
---|
64 | res += renderHtmlTag('option', **kw) |
---|
65 | res += '</select>' |
---|
66 | return res |
---|
67 | raise RuntimeError('unknown mode %s' % mode) |
---|
68 | |
---|
69 | InitializeClass(CPSSelectWidgetForRecord) |
---|
70 | |
---|
71 | widgetRegistry.register(CPSSelectWidgetForRecord) |
---|
72 | |
---|
73 | ###) |
---|
74 | |
---|
75 | class CPSStringWidgetForRecord(CPSStringWidget): ###( |
---|
76 | """String widget.""" |
---|
77 | meta_type = 'String Widget For Record' |
---|
78 | |
---|
79 | field_types = ('CPS String Field',) |
---|
80 | field_inits = ({'is_searchabletext': 1,},) |
---|
81 | _properties = CPSStringWidget._properties + ( |
---|
82 | {'id': 'record_id', 'type': 'string', 'mode': 'w', |
---|
83 | 'label': 'Record Id', 'is_required' : 1}, |
---|
84 | ) |
---|
85 | |
---|
86 | def render(self, mode, datastructure, **kw): |
---|
87 | """Render in mode from datastructure.""" |
---|
88 | value = datastructure[self.getWidgetId()] |
---|
89 | if mode == 'view': |
---|
90 | return escape(value) |
---|
91 | elif mode == 'edit': |
---|
92 | # XXX TODO should use an other name than kw ! |
---|
93 | # XXX change this everywhere |
---|
94 | html_widget_id = self.getHtmlWidgetId() |
---|
95 | kw = {'type': 'text', |
---|
96 | 'id' : html_widget_id, |
---|
97 | 'name': '%s.%s:records' % (self.record_id,html_widget_id), |
---|
98 | 'value': escape(value), |
---|
99 | 'size': self.display_width, |
---|
100 | } |
---|
101 | if self.size_max: |
---|
102 | kw['maxlength'] = self.size_max |
---|
103 | return renderHtmlTag('input', **kw) |
---|
104 | raise RuntimeError('unknown mode %s' % mode) |
---|
105 | |
---|
106 | InitializeClass(CPSStringWidgetForRecord) |
---|
107 | |
---|
108 | widgetRegistry.register(CPSStringWidgetForRecord) |
---|
109 | |
---|
110 | ###) |
---|
111 | |
---|
112 | class CertificateCourseIdWidget(CPSStringWidget): ###( |
---|
113 | """ CertificateCourseId Widget""" |
---|
114 | meta_type = "CertificateCourseId Widget" |
---|
115 | |
---|
116 | def validate(self, datastructure, **kw): |
---|
117 | """Validate datastructure and update datamodel.""" |
---|
118 | |
---|
119 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
120 | if not valid: |
---|
121 | return 0 |
---|
122 | else: |
---|
123 | widget_id = self.getWidgetId() |
---|
124 | value = datastructure[widget_id].upper() |
---|
125 | err = 0 |
---|
126 | c_ids = [c.id for c in self.portal_catalog({'meta_type': "Course"})] |
---|
127 | if hasattr(self.aq_parent,value): |
---|
128 | err = 'Course %s already exists' % (value) |
---|
129 | elif value not in c_ids: |
---|
130 | err = 'Course %s does not exist' % (value) |
---|
131 | if err: |
---|
132 | datastructure.setError(widget_id, err) |
---|
133 | else: |
---|
134 | datamodel = datastructure.getDataModel() |
---|
135 | datamodel[self.fields[0]] = value |
---|
136 | |
---|
137 | return not err |
---|
138 | |
---|
139 | InitializeClass(CertificateCourseIdWidget) |
---|
140 | |
---|
141 | widgetRegistry.register(CertificateCourseIdWidget) |
---|
142 | ###) |
---|
143 | |
---|
144 | class CourseIdWidget(CPSStringWidget): ###( |
---|
145 | """ CourseId Widget""" |
---|
146 | meta_type = "CourseId Widget" |
---|
147 | |
---|
148 | def validate(self, datastructure, **kw): |
---|
149 | """Validate datastructure and update datamodel.""" |
---|
150 | |
---|
151 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
152 | if not valid: |
---|
153 | return 0 |
---|
154 | else: |
---|
155 | widget_id = self.getWidgetId() |
---|
156 | value = datastructure[widget_id].upper() |
---|
157 | err = 0 |
---|
158 | res = self.portal_catalog(meta_type= "Course",id = value) |
---|
159 | if len(res) > 0: |
---|
160 | err = 'Course %s already exists' % (value) |
---|
161 | if err: |
---|
162 | datastructure.setError(widget_id, err) |
---|
163 | else: |
---|
164 | datamodel = datastructure.getDataModel() |
---|
165 | datamodel[self.fields[0]] = value |
---|
166 | |
---|
167 | return not err |
---|
168 | |
---|
169 | InitializeClass(CourseIdWidget) |
---|
170 | |
---|
171 | widgetRegistry.register(CourseIdWidget) |
---|
172 | |
---|
173 | |
---|
174 | ###) |
---|
175 | |
---|
176 | class WAeUPReservedRoomsWidget(CPSStringWidget): ###( |
---|
177 | """ WAeUPReservedRooms Widget""" |
---|
178 | meta_type = "WAeUPReservedRooms Widget" |
---|
179 | |
---|
180 | def validate(self, datastructure, **kw): |
---|
181 | """Validate datastructure and update datamodel.""" |
---|
182 | import re |
---|
183 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
184 | if not valid: |
---|
185 | return 0 |
---|
186 | else: |
---|
187 | widget_id = self.getWidgetId() |
---|
188 | value = datastructure[widget_id] |
---|
189 | err = 0 |
---|
190 | try: |
---|
191 | reserved = [(r.split('/')[0],int(r.split('/')[1])) for r in re.split(',|\.| ',value) |
---|
192 | if r] |
---|
193 | except (ValueError,IndexError),msg: |
---|
194 | err = str(msg) |
---|
195 | if err: |
---|
196 | datastructure.setError(widget_id, err) |
---|
197 | else: |
---|
198 | datamodel = datastructure.getDataModel() |
---|
199 | datamodel[self.fields[0]] = value |
---|
200 | return not err |
---|
201 | |
---|
202 | InitializeClass(WAeUPReservedRoomsWidget) |
---|
203 | |
---|
204 | widgetRegistry.register(WAeUPReservedRoomsWidget) |
---|
205 | |
---|
206 | |
---|
207 | ###) |
---|
208 | |
---|
209 | class WAeUPIdWidget(CPSStringWidget): ###( |
---|
210 | """ WAeUPId Widget""" |
---|
211 | meta_type = "WAeUPId Widget" |
---|
212 | |
---|
213 | def validate(self, datastructure, **kw): |
---|
214 | """Validate datastructure and update datamodel.""" |
---|
215 | |
---|
216 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
217 | id_pat_str = r"\S" |
---|
218 | inv_id_pat = compile(r"^%s$" % id_pat_str) |
---|
219 | if not valid: |
---|
220 | return 0 |
---|
221 | else: |
---|
222 | portal_type_query = {'query':['Faculty', |
---|
223 | 'Department', |
---|
224 | 'Course', |
---|
225 | 'Certificate', |
---|
226 | 'CertificateCourse',]} |
---|
227 | widget_id = self.getWidgetId() |
---|
228 | value = datastructure[widget_id].upper() |
---|
229 | err = 0 |
---|
230 | if len(value.split()) > 1: |
---|
231 | err = 'Invalid Id, Id contains space(s).' |
---|
232 | elif self.portal_catalog(portal_type=portal_type_query,id=value): |
---|
233 | err = 'An object with the Id %s already exists in the Academic Section.' % (value) |
---|
234 | if err: |
---|
235 | datastructure.setError(widget_id, err) |
---|
236 | else: |
---|
237 | datamodel = datastructure.getDataModel() |
---|
238 | datamodel[self.fields[0]] = value |
---|
239 | |
---|
240 | return not err |
---|
241 | |
---|
242 | InitializeClass(WAeUPIdWidget) |
---|
243 | |
---|
244 | widgetRegistry.register(WAeUPIdWidget) |
---|
245 | |
---|
246 | |
---|
247 | ###) |
---|
248 | |
---|
249 | class StudyCourseWidget(CPSStringWidget): ###( |
---|
250 | """ StudyCourse Widget""" |
---|
251 | meta_type = "StudyCourse Widget" |
---|
252 | |
---|
253 | def validate(self, datastructure, **kw): |
---|
254 | """Validate datastructure and update datamodel.""" |
---|
255 | #from Products.zdb import set_trace |
---|
256 | #set_trace() |
---|
257 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
258 | id_pat_str = r"\S" |
---|
259 | inv_id_pat = compile(r"^%s$" % id_pat_str) |
---|
260 | if not valid: |
---|
261 | return 0 |
---|
262 | else: |
---|
263 | widget_id = self.getWidgetId() |
---|
264 | value = datastructure[widget_id].upper() |
---|
265 | err = 0 |
---|
266 | if len(value.split()) > 1: |
---|
267 | err = 'Invalid Id, Id contains space(s).' |
---|
268 | elif not self.portal_catalog(portal_type='Certificate',id=value): |
---|
269 | err = 'No such certificate' |
---|
270 | if err: |
---|
271 | datastructure.setError(widget_id, err) |
---|
272 | else: |
---|
273 | datamodel = datastructure.getDataModel() |
---|
274 | datamodel[self.fields[0]] = value |
---|
275 | return not err |
---|
276 | |
---|
277 | InitializeClass(StudyCourseWidget) |
---|
278 | |
---|
279 | widgetRegistry.register(StudyCourseWidget) |
---|
280 | ###) |
---|
281 | |
---|
282 | ##class StudentIdWidget(CPSStringWidget): ###( |
---|
283 | ## """ StudentId Widget""" |
---|
284 | ## meta_type = "StudentId Widget" |
---|
285 | ## digits = 8 |
---|
286 | ## digits_str = "N"*digits |
---|
287 | ## letters = 2 |
---|
288 | ## letters_str = "L"*letters |
---|
289 | ## |
---|
290 | ## def validate(self, datastructure, **kw): |
---|
291 | ## """Validate datastructure and update datamodel.""" |
---|
292 | ## |
---|
293 | ## valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
294 | ## if not valid: |
---|
295 | ## return 0 |
---|
296 | ## else: |
---|
297 | ## widget_id = self.getWidgetId() |
---|
298 | ## value = datastructure[widget_id] |
---|
299 | ## err = 0 |
---|
300 | ## if not (len(value) == self.digits + self.letters and value[:self.digits].isdigit() and value[self.digits:].isalpha()): |
---|
301 | ## err = 'Invalid Registration Number in the format: %s%s with N = Number, L = Letter' % (self.digits_str,self.letters_str) |
---|
302 | ## if err: |
---|
303 | ## datastructure.setError(widget_id, err) |
---|
304 | ## else: |
---|
305 | ## datamodel = datastructure.getDataModel() |
---|
306 | ## datamodel[self.fields[0]] = value |
---|
307 | ## |
---|
308 | ## return not err |
---|
309 | ## |
---|
310 | ##InitializeClass(StudentIdWidget) |
---|
311 | ##widgetRegistry.register(StudentIdWidget) |
---|
312 | ## |
---|
313 | #####) |
---|
314 | |
---|
315 | class JambRegNoWidget(CPSStringWidget): ###( |
---|
316 | """ JambRegNo Widget""" |
---|
317 | meta_type = "JambRegNo Widget" |
---|
318 | _properties = CPSStringWidget._properties + ( |
---|
319 | {'id': 'catalog', 'type': 'string', 'mode': 'w', |
---|
320 | 'label': 'Catalog to search'}, |
---|
321 | {'id': 'reference', 'type': 'string', 'mode': 'w', |
---|
322 | 'label': 'Reference Field'}, |
---|
323 | ) |
---|
324 | catalog = "portal_pumeresults" #the catalog to search for jamb_reg_no |
---|
325 | reference = "" |
---|
326 | digits = 8 |
---|
327 | digits_str = "N"*digits |
---|
328 | letters = 2 |
---|
329 | letters_str = "L"*letters |
---|
330 | def validate(self, datastructure, **kw): |
---|
331 | """Validate datastructure and update datamodel.""" |
---|
332 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
333 | #import pdb;pdb.set_trace() |
---|
334 | jamb_nr_catalog = getattr(self,self.catalog) |
---|
335 | widget_id = self.getWidgetId() |
---|
336 | value = datastructure[widget_id].upper() |
---|
337 | err = 0 |
---|
338 | if not valid: #or not (len(value) == self.digits + self.letters and value[:self.digits].isdigit() and value[self.digits:].isalpha()): |
---|
339 | #err = 'Invalid number, the expected format is: %s%s with N = Number, L = Letter' % (self.digits_str,self.letters_str) |
---|
340 | err = 'Invalid number' |
---|
341 | elif self.reference == '': |
---|
342 | #s = getStudentByRegNo(self,value) |
---|
343 | pume = jamb_nr_catalog(jamb_reg_no = value) |
---|
344 | if len(pume) < 1: |
---|
345 | err = 'No Student with JAMB RegNo %s.' % (value) |
---|
346 | else: |
---|
347 | datastructure['pume'] = pume[0] |
---|
348 | else: |
---|
349 | #import pdb;pdb.set_trace() |
---|
350 | record = datastructure[self.reference] |
---|
351 | #jamb_reg_no = getattr(record,widget_id) |
---|
352 | jamb_reg_no = record.Entryregno |
---|
353 | if jamb_reg_no != value: |
---|
354 | err = 'Entry Registration Nr does not match.' |
---|
355 | if err: |
---|
356 | datastructure.setError(widget_id, err) |
---|
357 | else: |
---|
358 | datamodel = datastructure.getDataModel() |
---|
359 | datamodel[self.fields[0]] = value |
---|
360 | return not err |
---|
361 | |
---|
362 | InitializeClass(JambRegNoWidget) |
---|
363 | |
---|
364 | widgetRegistry.register(JambRegNoWidget) |
---|
365 | ###) |
---|
366 | |
---|
367 | class SecretWidget(CPSStringWidget): ###( |
---|
368 | """ Secret Widget""" |
---|
369 | meta_type = "Secret Widget" |
---|
370 | _properties = CPSStringWidget._properties + ( |
---|
371 | {'id': 'reference', 'type': 'string', 'mode': 'w', |
---|
372 | 'label': 'Reference Record'}, |
---|
373 | {'id': 'check_fields', 'type': 'tokens', 'mode': 'w', |
---|
374 | 'label': 'Fields to check'}, |
---|
375 | ) |
---|
376 | reference = "student" |
---|
377 | check_fields = ("Firstname", "Middlename","Lastname") |
---|
378 | def validate(self, datastructure, **kw): |
---|
379 | """Validate datastructure and update datamodel.""" |
---|
380 | logger = logging.getLogger('Secret.Validate') |
---|
381 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
382 | #import pdb;pdb.set_trace() |
---|
383 | widget_id = self.getWidgetId() |
---|
384 | value = datastructure[widget_id].upper() |
---|
385 | err = 0 |
---|
386 | record = datastructure.get(self.reference,None) |
---|
387 | if not valid: |
---|
388 | err = 'Invalid String' |
---|
389 | elif not record or datastructure.errors: |
---|
390 | err = 0 |
---|
391 | else: |
---|
392 | found = False |
---|
393 | cvs = [] |
---|
394 | for field in self.check_fields: |
---|
395 | cv = getattr(record,field).upper() |
---|
396 | if len(cv.split()) > 1: |
---|
397 | for splited in cv.split(): |
---|
398 | cvs.append(splited) |
---|
399 | else: |
---|
400 | cvs.append(cv) |
---|
401 | if cv == value.upper(): |
---|
402 | found = True |
---|
403 | break |
---|
404 | matric_no = record.matric_no |
---|
405 | name = " ".join(cvs) |
---|
406 | if not found: |
---|
407 | logger.info('"%(matric_no)s","mismatch", "%(value)s", "not in","%(name)s"' % vars()) |
---|
408 | err = 'No Name does match.' |
---|
409 | else: |
---|
410 | logger.info('"%(matric_no)s","found", "%(value)s", "in","%(name)s"' % vars()) |
---|
411 | if err: |
---|
412 | datastructure.setError(widget_id, err) |
---|
413 | else: |
---|
414 | datamodel = datastructure.getDataModel() |
---|
415 | datamodel[self.fields[0]] = value |
---|
416 | return not err |
---|
417 | |
---|
418 | InitializeClass(SecretWidget) |
---|
419 | |
---|
420 | widgetRegistry.register(SecretWidget) |
---|
421 | ###) |
---|
422 | |
---|
423 | class MatricNoWidget(CPSStringWidget): ###( |
---|
424 | """ MatricNo Widget""" |
---|
425 | meta_type = "MatricNo Widget" |
---|
426 | def validate(self, datastructure, **kw): |
---|
427 | """Validate datastructure and update datamodel.""" |
---|
428 | valid = CPSStringWidget.validate(self, datastructure, **kw) |
---|
429 | logger = logging.getLogger('MatricNo.Validate') |
---|
430 | #import pdb;pdb.set_trace() |
---|
431 | returning = self.returning_import |
---|
432 | results = self.results_import |
---|
433 | err = 0 |
---|
434 | widget_id = self.getWidgetId() |
---|
435 | value = datastructure[widget_id] |
---|
436 | if not valid or not value: |
---|
437 | err = 'Invalid MatricNo String %s.' % value |
---|
438 | logger.info('"%s","invalid MatricNo String"' % value) |
---|
439 | else: |
---|
440 | value = value.upper() |
---|
441 | datastructure['student'] = None |
---|
442 | while not err: |
---|
443 | res = returning(matric_no = value) |
---|
444 | if len(res) < 1: |
---|
445 | logger.info('"%s","MatricNo not found."' % value) |
---|
446 | err = 'No Student with MatricNo %s.' % (value) |
---|
447 | continue |
---|
448 | datastructure['student'] = res[0] |
---|
449 | res = results(matric_no = value) |
---|
450 | if len(res) < 1: |
---|
451 | err = 'No Results with MatricNo %s.' % (value) |
---|
452 | continue |
---|
453 | datastructure['results'] = res |
---|
454 | break |
---|
455 | if err: |
---|
456 | datastructure.setError(widget_id, err) |
---|
457 | else: |
---|
458 | datamodel = datastructure.getDataModel() |
---|
459 | datamodel[self.fields[0]] = value |
---|
460 | return not err |
---|
461 | |
---|
462 | InitializeClass(MatricNoWidget) |
---|
463 | |
---|
464 | widgetRegistry.register(MatricNoWidget) |
---|
465 | ###) |
---|
466 | |
---|
467 | class WAeUPMultilineResultsWidget(CPSStringWidget): ###( |
---|
468 | """ WAeUPMultilineResults Widget""" |
---|
469 | meta_type = "WAeUp Multiline Results Widget" |
---|
470 | _properties = CPSWidget._properties + ( |
---|
471 | {'id': 'nr_of_lines', 'type': 'int', 'mode': 'w', |
---|
472 | 'label': 'Nr of Lines'}, |
---|
473 | ) |
---|
474 | nr_of_lines = 5 |
---|
475 | def prepare(self, datastructure, **kw): ###( |
---|
476 | """Prepare datastructure from datamodel.""" |
---|
477 | datamodel = datastructure.getDataModel() |
---|
478 | #import pdb;pdb.set_trace() |
---|
479 | widget_id = self.getWidgetId() |
---|
480 | v = datamodel[self.fields[0]] |
---|
481 | if type(v) is ListType and v: |
---|
482 | nr_results = len(v) |
---|
483 | else: |
---|
484 | v = [] |
---|
485 | nr_results = 0 |
---|
486 | count = 1 |
---|
487 | for s,g in v: |
---|
488 | wid = "%s%02d"% (widget_id,count) |
---|
489 | datastructure[wid+'_s'] = s |
---|
490 | datastructure[wid+'_g'] = g |
---|
491 | count += 1 |
---|
492 | if nr_results < self.nr_of_lines: |
---|
493 | for line in range(nr_results,self.nr_of_lines): |
---|
494 | v.append(('','')) |
---|
495 | wid = "%s%02d"% (widget_id,line) |
---|
496 | datastructure[wid+'_s'] = '' |
---|
497 | datastructure[wid+'_g'] = '' |
---|
498 | datastructure[widget_id] = v |
---|
499 | datastructure[widget_id+'_s'] = '' |
---|
500 | datastructure[widget_id+'_g'] = '' |
---|
501 | ###) |
---|
502 | |
---|
503 | def validate(self, datastructure, **kw): ###( |
---|
504 | """Validate datastructure and update datamodel.""" |
---|
505 | #import pdb;pdb.set_trace() |
---|
506 | widget_id = self.getWidgetId() |
---|
507 | err = 0 |
---|
508 | lines = [] |
---|
509 | for line in range(1,30): |
---|
510 | wid = "%s%02d"% (widget_id,line) |
---|
511 | if not datastructure.has_key(wid+'_s'): |
---|
512 | break |
---|
513 | lines.append((datastructure[wid+'_s'].strip(), |
---|
514 | datastructure[wid+'_g'].strip())) |
---|
515 | |
---|
516 | s = datastructure[widget_id+'_s'].strip() |
---|
517 | g = datastructure[widget_id+'_g'].strip() |
---|
518 | if s and g: |
---|
519 | lines.append((s,g)) |
---|
520 | active = [] |
---|
521 | for s,g in lines: |
---|
522 | if g != "": |
---|
523 | active.append((s,g)) |
---|
524 | if err: |
---|
525 | datastructure.setError(widget_id, err) |
---|
526 | else: |
---|
527 | datamodel = datastructure.getDataModel() |
---|
528 | datamodel[self.fields[0]] = active |
---|
529 | return not err |
---|
530 | ###) |
---|
531 | |
---|
532 | def render(self, mode, datastructure, **kw): ###( |
---|
533 | """Render in mode from datastructure.""" |
---|
534 | render_method = 'widget_waeup_multiline_result_render' |
---|
535 | meth = getattr(self, render_method, None) |
---|
536 | if meth is None: |
---|
537 | raise RuntimeError("Unknown Render Method %s for widget type %s" |
---|
538 | % (render_method, self.getId())) |
---|
539 | #import pdb;pdb.set_trace() |
---|
540 | datamodel = datastructure.getDataModel() |
---|
541 | widget_id = self.getWidgetId() |
---|
542 | lines = datamodel[self.fields[0]] |
---|
543 | if len(lines) < self.nr_of_lines: |
---|
544 | for line in range(len(lines),self.nr_of_lines + 1): |
---|
545 | lines.append(('','')) |
---|
546 | datastructure[widget_id] = lines |
---|
547 | datastructure[widget_id+'_s'] = '' |
---|
548 | datastructure[widget_id+'_g'] = '' |
---|
549 | ## count = 1 |
---|
550 | ## for s,g in v: |
---|
551 | ## wid = "%s%02d"% (widget_id,count) |
---|
552 | ## count += 1 |
---|
553 | return meth(mode=mode, |
---|
554 | datastructure=datastructure, |
---|
555 | ) |
---|
556 | ###) |
---|
557 | |
---|
558 | |
---|
559 | InitializeClass(WAeUPMultilineResultsWidget) |
---|
560 | widgetRegistry.register(WAeUPMultilineResultsWidget) |
---|
561 | ###) |
---|
562 | |
---|
563 | class WAeUPResultsWidget(CPSStringWidget): ###( |
---|
564 | """ WAeUPResults Widget""" |
---|
565 | meta_type = "WAeUp Results Widget" |
---|
566 | |
---|
567 | def prepare(self, datastructure, **kw): ###( |
---|
568 | """Prepare datastructure from datamodel.""" |
---|
569 | datamodel = datastructure.getDataModel() |
---|
570 | v = datamodel[self.fields[0]] |
---|
571 | #import pdb;pdb.set_trace() |
---|
572 | widget_id = self.getWidgetId() |
---|
573 | datastructure[widget_id] = v |
---|
574 | datastructure[widget_id+'_s'] = '' |
---|
575 | datastructure[widget_id+'_g'] = '' |
---|
576 | ###) |
---|
577 | |
---|
578 | def validate(self, datastructure, **kw): ###( |
---|
579 | """Validate datastructure and update datamodel.""" |
---|
580 | #import pdb;pdb.set_trace() |
---|
581 | widget_id = self.getWidgetId() |
---|
582 | v = datastructure[widget_id] |
---|
583 | err = 0 |
---|
584 | s = datastructure[widget_id+'_s'].strip() |
---|
585 | g = datastructure[widget_id+'_g'].strip() |
---|
586 | while 1: |
---|
587 | if not s and g: |
---|
588 | err = "no subject grad for subject %s " % s |
---|
589 | break |
---|
590 | i = 0 |
---|
591 | done = False |
---|
592 | for sv,gv in v: |
---|
593 | if sv == s: |
---|
594 | done = True |
---|
595 | if not g: |
---|
596 | v.pop(i) |
---|
597 | break |
---|
598 | v[i] = (s,g) |
---|
599 | break |
---|
600 | i += 1 |
---|
601 | if done: |
---|
602 | break |
---|
603 | if s and g: |
---|
604 | v.append((s,g)) |
---|
605 | break |
---|
606 | if err: |
---|
607 | datastructure.setError(widget_id, err) |
---|
608 | else: |
---|
609 | datamodel = datastructure.getDataModel() |
---|
610 | datamodel[self.fields[0]] = v |
---|
611 | datastructure[widget_id+'_s'] = s |
---|
612 | datastructure[widget_id+'_g'] = g |
---|
613 | return not err |
---|
614 | ###) |
---|
615 | |
---|
616 | def render(self, mode, datastructure, **kw): ###( |
---|
617 | """Render in mode from datastructure.""" |
---|
618 | render_method = 'widget_waeup_result_render' |
---|
619 | meth = getattr(self, render_method, None) |
---|
620 | if meth is None: |
---|
621 | raise RuntimeError("Unknown Render Method %s for widget type %s" |
---|
622 | % (render_method, self.getId())) |
---|
623 | #import pdb;pdb.set_trace() |
---|
624 | datamodel = datastructure.getDataModel() |
---|
625 | widget_id = self.getWidgetId() |
---|
626 | datastructure[widget_id+'_s'] = '' |
---|
627 | datastructure[widget_id+'_g'] = '' |
---|
628 | return meth(mode=mode, |
---|
629 | datastructure=datastructure, |
---|
630 | ) |
---|
631 | ###) |
---|
632 | |
---|
633 | |
---|
634 | InitializeClass(WAeUPResultsWidget) |
---|
635 | widgetRegistry.register(WAeUPResultsWidget) |
---|
636 | ###) |
---|
637 | |
---|
638 | class ScratchCardPin: ###( |
---|
639 | """the ScratchCardPin""" |
---|
640 | def __init__(self,prefix,batch_no,number): |
---|
641 | if not batch_no and not number: |
---|
642 | s = prefix |
---|
643 | if len(s) > 3: |
---|
644 | prefix,batch_no,number = s[:3],s[3:-10],s[-10:] |
---|
645 | else: |
---|
646 | prefix,batch_no,number = s,'','' |
---|
647 | self.p = prefix |
---|
648 | self.b = batch_no |
---|
649 | self.n = number |
---|
650 | |
---|
651 | def __str__(self): |
---|
652 | return "%s-%s-%s" % (self.p,self.b,self.n) |
---|
653 | |
---|
654 | def __repr__(self): |
---|
655 | return "%s%s%s" % (self.p,self.b,self.n) |
---|
656 | ###) |
---|
657 | |
---|
658 | class ScratchcardPinWidget(CPSStringWidget): ###( |
---|
659 | """ ScratchcardPin Widget""" |
---|
660 | meta_type = "Scratchcard Pin Widget" |
---|
661 | _properties = CPSWidget._properties + ( |
---|
662 | {'id': 'prefix', 'type': 'string', 'mode': 'w', |
---|
663 | 'label': 'Prefix'}, |
---|
664 | {'id': 'reference', 'type': 'string', 'mode': 'w', |
---|
665 | 'label': 'Reference Field'}, |
---|
666 | ) |
---|
667 | prefix = '' |
---|
668 | reference = '' |
---|
669 | def prepare(self, datastructure, **kw): ###( |
---|
670 | """Prepare datastructure from datamodel.""" |
---|
671 | datamodel = datastructure.getDataModel() |
---|
672 | v = datamodel[self.fields[0]] |
---|
673 | widget_id = self.getWidgetId() |
---|
674 | #import pdb;pdb.set_trace() |
---|
675 | if v and type(v) is StringType: |
---|
676 | try: |
---|
677 | p,b,n = v.split('-') |
---|
678 | v = ScratchCardPin(p,b,n) |
---|
679 | except ValueError: |
---|
680 | v = ScratchCardPin(v,'','') |
---|
681 | if v: |
---|
682 | p = '%s' % v.p |
---|
683 | b = '%s' % v.b |
---|
684 | n = '%s' % v.n |
---|
685 | else: |
---|
686 | p = self.prefix |
---|
687 | if p.startswith('@'): |
---|
688 | p = getattr(self,self.prefix[1:])() |
---|
689 | b = n = '' |
---|
690 | v = ScratchCardPin(p,b,n) |
---|
691 | datastructure[widget_id] = v |
---|
692 | datastructure[widget_id+'_p'] = p |
---|
693 | datastructure[widget_id+'_b'] = b |
---|
694 | datastructure[widget_id+'_n'] = n |
---|
695 | |
---|
696 | ###) |
---|
697 | |
---|
698 | def validate(self, datastructure, **kw): ###( |
---|
699 | """Validate datastructure and update datamodel.""" |
---|
700 | s_logger = logging.getLogger('Pin.Validate') |
---|
701 | widget_id = self.getWidgetId() |
---|
702 | v = datastructure[widget_id] |
---|
703 | #import pdb;pdb.set_trace() |
---|
704 | err = 0 |
---|
705 | prefix= self.prefix |
---|
706 | if prefix.startswith('@'): |
---|
707 | prefix= getattr(self,self.prefix[1:])() |
---|
708 | b = datastructure[widget_id+'_b'].strip() |
---|
709 | n = datastructure[widget_id+'_n'].strip() |
---|
710 | pins = self.portal_pins |
---|
711 | pin = "%(prefix)s%(b)s%(n)s" % vars() |
---|
712 | do = 1 |
---|
713 | s_id = str(self.portal_membership.getAuthenticatedMember()) |
---|
714 | if self.reference == "": |
---|
715 | ref = s_id |
---|
716 | else: |
---|
717 | ref = datastructure[self.reference] |
---|
718 | if datastructure.errors: |
---|
719 | do = 0 |
---|
720 | datastructure.setError(widget_id, 'Errors in other data, PIN neither checked nor used.') |
---|
721 | s_logger.info('"%s", "%s","entered wrong data together with pin", "%s"' % (s_id,ref,pin)) |
---|
722 | while do: |
---|
723 | ok = pins.searchAndSetRecord(pin,ref,prefix) |
---|
724 | if ok < -2 or ok > 2: |
---|
725 | err = 'Unknown error, please report!' |
---|
726 | s_logger.info('"%s","%s", "caused unknown error with pin", "%s"' % (s_id,ref,pin)) |
---|
727 | break |
---|
728 | elif ok == -2: |
---|
729 | err = 'Service already activated but with a different PIN.' |
---|
730 | s_logger.info('"%s","%s", "repeatedly activated service but with different pin", "%s"' % (s_id,ref,pin)) |
---|
731 | break |
---|
732 | elif ok == -1: |
---|
733 | err = 'Invalid PIN' |
---|
734 | s_logger.info('"%s","%s", "entered invalid pin", "%s"' % (s_id,ref,pin)) |
---|
735 | break |
---|
736 | if ok == 0: |
---|
737 | err = 'PIN already used.' |
---|
738 | s_logger.info('"%s","%s", "entered used pin", "%s"' % (s_id,ref,pin)) |
---|
739 | break |
---|
740 | if ok >= 1: |
---|
741 | #import pdb;pdb.set_trace() |
---|
742 | if self.isStudent(): |
---|
743 | if self.reference == "jamb_reg_no": |
---|
744 | err = "You are already logged in." |
---|
745 | s_logger.info('"%s","%s", "checked admission though logged in", "%s"' % (s_id,ref,pin)) |
---|
746 | break |
---|
747 | if ok == 1: |
---|
748 | s_logger.info('"%s","%s", "successfully used pin", "%s"' % (s_id,ref,pin)) |
---|
749 | else: |
---|
750 | s_logger.info('"%s","%s", "repeatedly used pin", "%s"' % (s_id,ref,pin)) |
---|
751 | break |
---|
752 | else: |
---|
753 | student = getStudentByRegNo(self,ref) |
---|
754 | s_logger.info('"%s","%s","successfully used pin","%s"' % (s_id,ref,pin)) |
---|
755 | if student is None: |
---|
756 | err = "Student not found." |
---|
757 | s_logger.info('"%s","not found in admission list"' % (ref)) |
---|
758 | break |
---|
759 | s_id = student.getId() |
---|
760 | if ok == 2: |
---|
761 | if self.reference == "jamb_reg_no": |
---|
762 | if hasattr(self.portal_directories.students,s_id): |
---|
763 | err = "Please login with your Student Id %s and 10-digit PIN." % s_id |
---|
764 | s_logger.info('"%s","%s", "repeatedly checked admission with pin", "%s"' % (s_id,ref,pin)) |
---|
765 | break |
---|
766 | else: |
---|
767 | s_logger.info('"%s","%s","(non-member) repeatedly checked admission with pin", "%s"' % (s_id,ref,pin)) |
---|
768 | else: |
---|
769 | err = "Unknown error" % s_id |
---|
770 | s_logger.info('"%s","%s", "repeatedly activated service with pin", "%s"' % (s_id,ref,pin)) |
---|
771 | break |
---|
772 | try: |
---|
773 | student.getContent().makeStudentMember(s_id,password=pin[4:]) |
---|
774 | s_logger.info('"%s","%s", "has been created using pin", "%s"' % (s_id,ref,pin)) |
---|
775 | except: |
---|
776 | err = "Please login with your Student Id %s and 10-digit PIN." % s_id |
---|
777 | s_logger.info('"%s","%s", "could not be made a member with pin", "%s"' % (s_id,ref,pin)) |
---|
778 | break |
---|
779 | break |
---|
780 | if err: |
---|
781 | datastructure.setError(widget_id, err) |
---|
782 | else: |
---|
783 | datamodel = datastructure.getDataModel() |
---|
784 | datamodel[self.fields[0]] = ScratchCardPin(prefix,b,n) |
---|
785 | datastructure[widget_id] = ScratchCardPin(prefix,b,n) |
---|
786 | datastructure[widget_id+'_p'] = prefix |
---|
787 | datastructure[widget_id+'_b'] = b |
---|
788 | datastructure[widget_id+'_n'] = n |
---|
789 | datastructure['s_id'] = s_id |
---|
790 | return not err |
---|
791 | |
---|
792 | ###) |
---|
793 | |
---|
794 | def render(self, mode, datastructure, **kw): ###( |
---|
795 | """Render in mode from datastructure.""" |
---|
796 | render_method = 'widget_scratch_card_pin_render' |
---|
797 | meth = getattr(self, render_method, None) |
---|
798 | if meth is None: |
---|
799 | raise RuntimeError("Unknown Render Method %s for widget type %s" |
---|
800 | % (render_method, self.getId())) |
---|
801 | |
---|
802 | # XXX AT: datastructure has to be set again here, in case we're in edit |
---|
803 | # or create mode, because a default value has to be provided. |
---|
804 | #import pdb;pdb.set_trace() |
---|
805 | datamodel = datastructure.getDataModel() |
---|
806 | v = datamodel[self.fields[0]] |
---|
807 | if v and type(v) is StringType: |
---|
808 | try: |
---|
809 | p,b,n = v.split('-') |
---|
810 | v = ScratchCardPin(p,b,n) |
---|
811 | except ValueError: |
---|
812 | v = ScratchCardPin(self.prefix,'1',v) |
---|
813 | pass |
---|
814 | if v: |
---|
815 | prefix= '%s' % v.p |
---|
816 | b = '%s' % v.b |
---|
817 | n = '%s' % v.n |
---|
818 | else: |
---|
819 | prefix= self.prefix |
---|
820 | if prefix.startswith('@'): |
---|
821 | prefix= getattr(self,self.prefix[1:])() |
---|
822 | b = n = '' |
---|
823 | v = ScratchCardPin(prefix,b,n) |
---|
824 | widget_id = self.getWidgetId() |
---|
825 | datastructure[widget_id] = v |
---|
826 | datastructure[widget_id+'_p'] = prefix |
---|
827 | datastructure[widget_id+'_b'] = b |
---|
828 | datastructure[widget_id+'_n'] = n |
---|
829 | return meth(mode=mode, |
---|
830 | datastructure=datastructure, |
---|
831 | ) |
---|
832 | ###) |
---|
833 | |
---|
834 | |
---|
835 | InitializeClass(ScratchcardPinWidget) |
---|
836 | widgetRegistry.register(ScratchcardPinWidget) |
---|
837 | |
---|
838 | |
---|
839 | ###) |
---|
840 | |
---|
841 | class WAeUPImageWidget(CPSImageWidget): ###( |
---|
842 | """Photo widget.""" |
---|
843 | meta_type = 'WAeUP Image Widget' |
---|
844 | |
---|
845 | def render(self, mode, datastructure, **kw): |
---|
846 | render_method = 'widget_waeup_image_render' |
---|
847 | meth = getattr(self, render_method, None) |
---|
848 | if meth is None: |
---|
849 | raise RuntimeError("Unknown Render Method %s for widget type %s" |
---|
850 | % (render_method, self.getId())) |
---|
851 | img_info = self.getImageInfo(datastructure) |
---|
852 | return meth(mode=mode, datastructure=datastructure, **img_info) |
---|
853 | |
---|
854 | ###) |
---|
855 | |
---|
856 | |
---|
857 | |
---|
858 | InitializeClass(WAeUPImageWidget) |
---|
859 | |
---|
860 | widgetRegistry.register(WAeUPImageWidget) |
---|
861 | |
---|
862 | |
---|
863 | ########### |
---|
864 | |
---|