source: WAeUP_SRP/trunk/Widgets.py @ 1234

Last change on this file since 1234 was 1189, checked in by joachim, 18 years ago

fix empty matric_no entry

  • Property svn:keywords set to Id
File size: 30.8 KB
RevLine 
[47]1#-*- mode: python; mode: fold -*-
[990]2# $Id: Widgets.py 1189 2007-01-03 18:50:45Z joachim $
[295]3from cgi import escape
[502]4from types import *
[22]5from Globals import InitializeClass
[199]6##from Products.CPSSchemas.Widget import CPSWidgetType
[295]7from Products.CMFCore.utils import getToolByName
[537]8from Products.CPSSchemas.BasicWidgets import CPSWidget, CPSStringWidget, CPSEmailWidget,CPSImageWidget
[295]9from Products.CPSSchemas.BasicWidgets import renderHtmlTag,CPSSelectWidget, CPSStringWidget
[22]10from Products.CPSSchemas.ExtendedWidgets import CPSDateTimeWidget
[199]11from Products.CPSSchemas.Widget import widgetRegistry
12##from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry
[22]13from DateTime.DateTime import DateTime
14from AccessControl import getSecurityManager
[502]15from Products.WAeUP_SRP.Students import getStudentByRegNo
[22]16from re import compile
[952]17import logging
[22]18
[952]19#from zLOG import LOG, DEBUG
[22]20
[295]21class 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()
[444]46            res = renderHtmlTag('select',
47                                name='%s.%s:records' % (self.record_id,html_widget_id),
[295]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
69InitializeClass(CPSSelectWidgetForRecord)
70
71widgetRegistry.register(CPSSelectWidgetForRecord)
72
73###)
74
[373]75class CPSStringWidgetForRecord(CPSStringWidget): ###(
[295]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,
[444]97                  'name': '%s.%s:records' % (self.record_id,html_widget_id),
[295]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
106InitializeClass(CPSStringWidgetForRecord)
107
108widgetRegistry.register(CPSStringWidgetForRecord)
109
[373]110###)
111
112class CertificateCourseIdWidget(CPSStringWidget): ###(
113    """ CertificateCourseId Widget"""
114    meta_type = "CertificateCourseId Widget"
[444]115
[373]116    def validate(self, datastructure, **kw):
117        """Validate datastructure and update datamodel."""
[444]118
[373]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"})]
[381]127            if hasattr(self.aq_parent,value):
[444]128                err = 'Course %s already exists' % (value)
[381]129            elif value not in c_ids:
[444]130                err = 'Course %s does not exist' % (value)
[373]131            if err:
132                datastructure.setError(widget_id, err)
133            else:
134                datamodel = datastructure.getDataModel()
135                datamodel[self.fields[0]] = value
[444]136
[373]137            return not err
138
139InitializeClass(CertificateCourseIdWidget)
140
141widgetRegistry.register(CertificateCourseIdWidget)
[551]142###)
[373]143
[551]144class 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
169InitializeClass(CourseIdWidget)
170
171widgetRegistry.register(CourseIdWidget)
172
173
[373]174###)
175
[714]176class 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:
[926]191                reserved = [(r.split('/')[0],int(r.split('/')[1])) for r in re.split(',|\.| ',value)
[714]192                                     if r]
[1038]193            except (ValueError,IndexError),msg:
[714]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
202InitializeClass(WAeUPReservedRoomsWidget)
203
204widgetRegistry.register(WAeUPReservedRoomsWidget)
205
206
207###)
208
[388]209class WAeUPIdWidget(CPSStringWidget): ###(
210    """ WAeUPId Widget"""
211    meta_type = "WAeUPId Widget"
[444]212
[388]213    def validate(self, datastructure, **kw):
214        """Validate datastructure and update datamodel."""
[444]215
[388]216        valid = CPSStringWidget.validate(self, datastructure, **kw)
[422]217        id_pat_str = r"\S"
218        inv_id_pat = compile(r"^%s$" % id_pat_str)
[388]219        if not valid:
220            return 0
221        else:
[586]222            portal_type_query = {'query':['Faculty',
223                                          'Department',
224                                          'Course',
225                                          'Certificate',
226                                          'CertificateCourse',]}
[388]227            widget_id = self.getWidgetId()
228            value = datastructure[widget_id].upper()
229            err = 0
[440]230            if len(value.split()) > 1:
[783]231                err = 'Invalid Id, Id contains space(s).'
[586]232            elif self.portal_catalog(portal_type=portal_type_query,id=value):
[783]233                err = 'An object with the Id %s already exists in the Academic Section.' % (value)
[388]234            if err:
235                datastructure.setError(widget_id, err)
236            else:
237                datamodel = datastructure.getDataModel()
238                datamodel[self.fields[0]] = value
[444]239
[388]240            return not err
241
242InitializeClass(WAeUPIdWidget)
243
244widgetRegistry.register(WAeUPIdWidget)
245
246
247###)
248
[1025]249class 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
277InitializeClass(StudyCourseWidget)
278
279widgetRegistry.register(StudyCourseWidget)
280###)
281
[710]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#####)
[444]314
[463]315class JambRegNoWidget(CPSStringWidget): ###(
316    """ JambRegNo Widget"""
317    meta_type = "JambRegNo Widget"
[1169]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 = ""
[463]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)
[816]333        #import pdb;pdb.set_trace()
[1169]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]
[463]348        else:
[1169]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
[463]361
362InitializeClass(JambRegNoWidget)
363
364widgetRegistry.register(JambRegNoWidget)
[47]365###)
366
[1175]367class 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
[1189]386        record = datastructure.get(self.reference,None)
[1175]387        if not valid:
388            err = 'Invalid String'
[1189]389        elif not record or datastructure.errors:
[1177]390            err = 0
[1175]391        else:
392            found = False
393            cvs = []
394            for field in self.check_fields:
395                cv = getattr(record,field).upper()
396                cvs.append(cv)
397                if cv  == value.upper():
398                    found = True
399                    break
400            matric_no = record.matric_no
401            name = " ".join(cvs)
402            if not found:
403                logger.info('"%(matric_no)s","mismatch", "%(value)s", "not in","%(name)s"' % vars())
404                err = 'No Name does match.'
405            else:
406                logger.info('"%(matric_no)s","found", "%(value)s", "in","%(name)s"' % vars())
407        if err:
408            datastructure.setError(widget_id, err)
409        else:
410            datamodel = datastructure.getDataModel()
411            datamodel[self.fields[0]] = value
412        return not err
413
414InitializeClass(SecretWidget)
415
416widgetRegistry.register(SecretWidget)
417###)
418
[1146]419class MatricNoWidget(CPSStringWidget): ###(
420    """ MatricNo Widget"""
421    meta_type = "MatricNo Widget"
422    def validate(self, datastructure, **kw):
423        """Validate datastructure and update datamodel."""
424        valid = CPSStringWidget.validate(self, datastructure, **kw)
[1175]425        logger = logging.getLogger('MatricNo.Validate')
[1146]426        #import pdb;pdb.set_trace()
[1151]427        returning = self.returning_import
[1146]428        results = self.results_import
429        err = 0
[1189]430        widget_id = self.getWidgetId()
431        value = datastructure[widget_id]
432        if not valid or not value:
[1188]433            err = 'Invalid MatricNo String %s.' % value
[1189]434            logger.info('"%s","invalid MatricNo String"' % value)
[1146]435        else:
[1189]436            value = value.upper()
[1177]437            datastructure['student'] = None
[1146]438            while not err:
[1151]439                res = returning(matric_no = value)
[1146]440                if len(res) < 1:
[1177]441                    logger.info('"%s","MatricNo not found."' % value)
[1146]442                    err = 'No Student with MatricNo %s.' % (value)
443                    continue
444                datastructure['student'] = res[0]
445                res = results(matric_no = value)
446                if len(res) < 1:
447                    err = 'No Results with MatricNo %s.' % (value)
448                    continue
449                datastructure['results'] = res
450                break
[1189]451        if err:
452            datastructure.setError(widget_id, err)
453        else:
454            datamodel = datastructure.getDataModel()
455            datamodel[self.fields[0]] = value
456        return not err
[1146]457
458InitializeClass(MatricNoWidget)
459
460widgetRegistry.register(MatricNoWidget)
461###)
462
463class WAeUPMultilineResultsWidget(CPSStringWidget): ###(
464    """ WAeUPMultilineResults Widget"""
465    meta_type = "WAeUp Multiline Results Widget"
466    _properties = CPSWidget._properties + (
467        {'id': 'nr_of_lines', 'type': 'int', 'mode': 'w',
468         'label': 'Nr of Lines'},
469         )
470    nr_of_lines = 5
471    def prepare(self, datastructure, **kw): ###(
472        """Prepare datastructure from datamodel."""
473        datamodel = datastructure.getDataModel()
474        #import pdb;pdb.set_trace()
475        widget_id = self.getWidgetId()
476        v = datamodel[self.fields[0]]
477        if type(v) is ListType and v:
478            nr_results = len(v)
479        else:
480            v = []
481            nr_results = 0
482        count = 1
483        for s,g in v:
484            wid = "%s%02d"% (widget_id,count)
485            datastructure[wid+'_s'] = s
486            datastructure[wid+'_g'] = g
487            count += 1
488        if nr_results < self.nr_of_lines:
489            for line in range(nr_results,self.nr_of_lines):
490                v.append(('',''))
491                wid = "%s%02d"% (widget_id,line)
492                datastructure[wid+'_s'] = ''
493                datastructure[wid+'_g'] = ''
494        datastructure[widget_id] = v
495        datastructure[widget_id+'_s'] = ''
496        datastructure[widget_id+'_g'] = ''
497    ###)
498
499    def validate(self, datastructure, **kw): ###(
500        """Validate datastructure and update datamodel."""
501        #import pdb;pdb.set_trace()
502        widget_id = self.getWidgetId()
503        err = 0
504        lines = []
505        for line in range(1,30):
506            wid = "%s%02d"% (widget_id,line)
507            if not datastructure.has_key(wid+'_s'):
508                break
509            lines.append((datastructure[wid+'_s'].strip(),
510                         datastructure[wid+'_g'].strip()))
[1155]511
[1146]512        s = datastructure[widget_id+'_s'].strip()
513        g = datastructure[widget_id+'_g'].strip()
514        if s and g:
515            lines.append((s,g))
516        active = []
517        for s,g in lines:
518            if g != "":
519                active.append((s,g))
520        if err:
521            datastructure.setError(widget_id, err)
522        else:
523            datamodel = datastructure.getDataModel()
524            datamodel[self.fields[0]] = active
525        return not err
526    ###)
527
528    def render(self, mode, datastructure, **kw): ###(
529        """Render in mode from datastructure."""
530        render_method = 'widget_waeup_multiline_result_render'
531        meth = getattr(self, render_method, None)
532        if meth is None:
533            raise RuntimeError("Unknown Render Method %s for widget type %s"
534                               % (render_method, self.getId()))
535        #import pdb;pdb.set_trace()
536        datamodel = datastructure.getDataModel()
537        widget_id = self.getWidgetId()
538        lines = datamodel[self.fields[0]]
539        if len(lines) < self.nr_of_lines:
540            for line in range(len(lines),self.nr_of_lines + 1):
541                lines.append(('',''))
542        datastructure[widget_id] = lines
543        datastructure[widget_id+'_s'] = ''
544        datastructure[widget_id+'_g'] = ''
545##        count = 1
546##        for s,g in v:
547##            wid = "%s%02d"% (widget_id,count)
548##            count += 1
549        return meth(mode=mode,
550                    datastructure=datastructure,
551                    )
552    ###)
553
554
555InitializeClass(WAeUPMultilineResultsWidget)
556widgetRegistry.register(WAeUPMultilineResultsWidget)
557###)
558
[794]559class WAeUPResultsWidget(CPSStringWidget): ###(
560    """ WAeUPResults Widget"""
561    meta_type = "WAeUp Results Widget"
562
563    def prepare(self, datastructure, **kw): ###(
564        """Prepare datastructure from datamodel."""
565        datamodel = datastructure.getDataModel()
566        v = datamodel[self.fields[0]]
567        #import pdb;pdb.set_trace()
568        widget_id = self.getWidgetId()
[807]569        datastructure[widget_id] = v
[794]570        datastructure[widget_id+'_s'] = ''
571        datastructure[widget_id+'_g'] = ''
572    ###)
573
574    def validate(self, datastructure, **kw): ###(
575        """Validate datastructure and update datamodel."""
[807]576        #import pdb;pdb.set_trace()
[794]577        widget_id = self.getWidgetId()
578        v = datastructure[widget_id]
579        err = 0
580        s = datastructure[widget_id+'_s'].strip()
581        g = datastructure[widget_id+'_g'].strip()
[807]582        while 1:
583            if not s and g:
584                err = "no subject grad for subject %s " % s
585                break
586            i = 0
587            done = False
588            for sv,gv in v:
589                if sv == s:
590                    done = True
591                    if not g:
592                        v.pop(i)
593                        break
594                    v[i] = (s,g)
595                    break
596                i += 1
597            if done:
598                break
599            if s and g:
600                v.append((s,g))
601            break
[794]602        if err:
603            datastructure.setError(widget_id, err)
604        else:
605            datamodel = datastructure.getDataModel()
606            datamodel[self.fields[0]] = v
607            datastructure[widget_id+'_s'] = s
608            datastructure[widget_id+'_g'] = g
609        return not err
610    ###)
611
612    def render(self, mode, datastructure, **kw): ###(
613        """Render in mode from datastructure."""
614        render_method = 'widget_waeup_result_render'
615        meth = getattr(self, render_method, None)
616        if meth is None:
617            raise RuntimeError("Unknown Render Method %s for widget type %s"
618                               % (render_method, self.getId()))
619        #import pdb;pdb.set_trace()
620        datamodel = datastructure.getDataModel()
621        widget_id = self.getWidgetId()
622        datastructure[widget_id+'_s'] = ''
623        datastructure[widget_id+'_g'] = ''
624        return meth(mode=mode,
625                    datastructure=datastructure,
626                    )
627    ###)
628
629
630InitializeClass(WAeUPResultsWidget)
631widgetRegistry.register(WAeUPResultsWidget)
632###)
633
[488]634class ScratchCardPin: ###(
635    """the ScratchCardPin"""
636    def __init__(self,prefix,batch_no,number):
[990]637        if not batch_no and not number:
638            s = prefix
[996]639            if len(s) > 3:
[990]640                prefix,batch_no,number = s[:3],s[3:-10],s[-10:]
641            else:
[996]642                prefix,batch_no,number = s,'',''
[488]643        self.p = prefix
644        self.b = batch_no
645        self.n = number
646
647    def __str__(self):
648        return "%s-%s-%s" % (self.p,self.b,self.n)
[1146]649
650    def __repr__(self):
651        return "%s%s%s" % (self.p,self.b,self.n)
[488]652###)
653
[47]654class ScratchcardPinWidget(CPSStringWidget): ###(
[22]655    """ ScratchcardPin Widget"""
[199]656    meta_type = "Scratchcard Pin Widget"
[488]657    _properties = CPSWidget._properties + (
658        {'id': 'prefix', 'type': 'string', 'mode': 'w',
659         'label': 'Prefix'},
660         {'id': 'reference', 'type': 'string', 'mode': 'w',
661         'label': 'Reference Field'},
662        )
663    prefix = ''
664    reference = ''
[502]665    def prepare(self, datastructure, **kw): ###(
[488]666        """Prepare datastructure from datamodel."""
667        datamodel = datastructure.getDataModel()
668        v = datamodel[self.fields[0]]
669        widget_id = self.getWidgetId()
[742]670        #import pdb;pdb.set_trace()
[747]671        if v and type(v) is StringType:
[990]672            try:
673                p,b,n = v.split('-')
674                v = ScratchCardPin(p,b,n)
675            except ValueError:
676                v = ScratchCardPin(v,'','')
[488]677        if v:
[742]678            p = '%s' % v.p
[488]679            b = '%s' % v.b
680            n = '%s' % v.n
681        else:
[742]682            p = self.prefix
683            if p.startswith('@'):
684                p = getattr(self,self.prefix[1:])()
[488]685            b = n = ''
[742]686            v = ScratchCardPin(p,b,n)
[488]687        datastructure[widget_id] = v
[742]688        datastructure[widget_id+'_p'] = p
[488]689        datastructure[widget_id+'_b'] = b
690        datastructure[widget_id+'_n'] = n
[758]691
[502]692###)
693
[1169]694    def validate(self, datastructure, **kw): ###(
[22]695        """Validate datastructure and update datamodel."""
[1082]696        s_logger = logging.getLogger('Pin.Validate')
[488]697        widget_id = self.getWidgetId()
698        v = datastructure[widget_id]
[996]699        #import pdb;pdb.set_trace()
[488]700        err = 0
[742]701        prefix= self.prefix
702        if prefix.startswith('@'):
703            prefix= getattr(self,self.prefix[1:])()
[488]704        b = datastructure[widget_id+'_b'].strip()
705        n = datastructure[widget_id+'_n'].strip()
[502]706        pins = self.portal_pins
[742]707        pin = "%(prefix)s%(b)s%(n)s" % vars()
[816]708        do = 1
[1025]709        s_id = str(self.portal_membership.getAuthenticatedMember())
[635]710        if self.reference == "":
[1030]711            ref = s_id
[635]712        else:
713            ref = datastructure[self.reference]
[843]714            if datastructure.errors:
[816]715                do = 0
[977]716                datastructure.setError(widget_id, 'Errors in other data, PIN neither checked nor used.')
[1030]717                s_logger.info('"%s", "%s","entered wrong data together with pin", "%s"' % (s_id,ref,pin))
[816]718        while do:
719            ok = pins.searchAndSetRecord(pin,ref,prefix)
[1030]720            if ok < -2 or ok > 2:
721                err = 'Unknown error, please report!'
722                s_logger.info('"%s","%s", "caused unknown error with pin", "%s"' % (s_id,ref,pin))
723                break
724            elif ok == -2:
[819]725                err = 'Service already activated but with a different PIN.'
[1030]726                s_logger.info('"%s","%s", "repeatedly activated service but with different pin", "%s"' % (s_id,ref,pin))
[710]727                break
728            elif ok == -1:
[783]729                err = 'Invalid PIN'
[1030]730                s_logger.info('"%s","%s", "entered invalid pin", "%s"' % (s_id,ref,pin))
[502]731                break
732            if ok == 0:
[796]733                err = 'PIN already used.'
[1030]734                s_logger.info('"%s","%s", "entered used pin", "%s"' % (s_id,ref,pin))
[502]735                break
736            if ok >= 1:
[710]737                #import pdb;pdb.set_trace()
[635]738                if self.isStudent():
[992]739                    if self.reference == "jamb_reg_no":
[997]740                        err = "You are already logged in."
[1030]741                        s_logger.info('"%s","%s", "checked admission though logged in", "%s"' % (s_id,ref,pin))
[992]742                        break
[1082]743                    if ok == 1:
[1032]744                        s_logger.info('"%s","%s", "successfully used pin", "%s"' % (s_id,ref,pin))
745                    else:
746                        s_logger.info('"%s","%s", "repeatedly used pin", "%s"' % (s_id,ref,pin))
[637]747                    break
[635]748                else:
749                    student = getStudentByRegNo(self,ref)
[1030]750                    s_logger.info('"%s","%s","successfully used pin","%s"' % (s_id,ref,pin))
[502]751                if student is None:
[796]752                    err = "Student not found."
[1032]753                    s_logger.info('"%s","not found in admission list"' % (ref))
[502]754                    break
[648]755                s_id = student.getId()
[502]756                if ok == 2:
[990]757                    if self.reference == "jamb_reg_no":
758                        if hasattr(self.portal_directories.students,s_id):
759                            err = "Please login with your Student Id %s and 10-digit PIN." % s_id
[1032]760                            s_logger.info('"%s","%s", "repeatedly checked admission with pin", "%s"' % (s_id,ref,pin))
[990]761                            break
762                        else:
[1032]763                            s_logger.info('"%s","%s","(non-member) repeatedly checked admission with pin", "%s"' % (s_id,ref,pin))
[990]764                    else:
[1030]765                        err = "Unknown error" % s_id
[1032]766                        s_logger.info('"%s","%s", "repeatedly activated service with pin", "%s"' % (s_id,ref,pin))
[986]767                        break
768                try:
769                    student.getContent().makeStudentMember(s_id,password=pin[4:])
[1030]770                    s_logger.info('"%s","%s", "has been created using pin", "%s"' % (s_id,ref,pin))
[986]771                except:
[989]772                    err = "Please login with your Student Id %s and 10-digit PIN." % s_id
[1032]773                    s_logger.info('"%s","%s", "could not be made a member with pin", "%s"' % (s_id,ref,pin))
[986]774                    break
[502]775            break
[488]776        if err:
777            datastructure.setError(widget_id, err)
778        else:
779            datamodel = datastructure.getDataModel()
[742]780            datamodel[self.fields[0]] = ScratchCardPin(prefix,b,n)
781            datastructure[widget_id] = ScratchCardPin(prefix,b,n)
782            datastructure[widget_id+'_p'] = prefix
[488]783            datastructure[widget_id+'_b'] = b
784            datastructure[widget_id+'_n'] = n
[502]785            datastructure['s_id'] = s_id
[488]786        return not err
[444]787
[1169]788###)
789
[502]790    def render(self, mode, datastructure, **kw): ###(
[488]791        """Render in mode from datastructure."""
792        render_method = 'widget_scratch_card_pin_render'
793        meth = getattr(self, render_method, None)
794        if meth is None:
795            raise RuntimeError("Unknown Render Method %s for widget type %s"
796                               % (render_method, self.getId()))
797
798        # XXX AT: datastructure has to be set again here, in case we're in edit
799        # or create mode, because a default value has to be provided.
800        #import pdb;pdb.set_trace()
801        datamodel = datastructure.getDataModel()
802        v = datamodel[self.fields[0]]
[502]803        if v and type(v) is StringType:
[990]804            try:
805                p,b,n = v.split('-')
806                v = ScratchCardPin(p,b,n)
807            except ValueError:
[996]808                v = ScratchCardPin(self.prefix,'1',v)
809                pass
[488]810        if v:
[742]811            prefix= '%s' % v.p
[488]812            b = '%s' % v.b
813            n = '%s' % v.n
[22]814        else:
[742]815            prefix= self.prefix
816            if prefix.startswith('@'):
817                prefix= getattr(self,self.prefix[1:])()
[488]818            b = n = ''
[742]819            v = ScratchCardPin(prefix,b,n)
820        widget_id = self.getWidgetId()
821        datastructure[widget_id] = v
822        datastructure[widget_id+'_p'] = prefix
823        datastructure[widget_id+'_b'] = b
824        datastructure[widget_id+'_n'] = n
[758]825        return meth(mode=mode,
826                    datastructure=datastructure,
[488]827                    )
[523]828    ###)
[488]829
830
[22]831InitializeClass(ScratchcardPinWidget)
[199]832widgetRegistry.register(ScratchcardPinWidget)
[22]833
[47]834
835###)
836
[1169]837class WAeUPImageWidget(CPSImageWidget): ###(
[537]838    """Photo widget."""
839    meta_type = 'WAeUP Image Widget'
840
841    def render(self, mode, datastructure, **kw):
842        render_method = 'widget_waeup_image_render'
843        meth = getattr(self, render_method, None)
844        if meth is None:
845            raise RuntimeError("Unknown Render Method %s for widget type %s"
846                               % (render_method, self.getId()))
847        img_info = self.getImageInfo(datastructure)
848        return meth(mode=mode, datastructure=datastructure, **img_info)
849
[1169]850###)
[537]851
852
[1169]853
[537]854InitializeClass(WAeUPImageWidget)
855
856widgetRegistry.register(WAeUPImageWidget)
857
858
[22]859###########
860
Note: See TracBrowser for help on using the repository browser.