source: WAeUP_SRP/base/Widgets.py @ 2353

Last change on this file since 2353 was 2353, checked in by Henrik Bettermann, 17 years ago

ensure that always correct application form is used
  • Property svn:keywords set to Id
File size: 76.7 KB
Line 
1#-*- mode: python; mode: fold -*-
2# $Id: Widgets.py 2353 2007-10-12 10:47:41Z henrik $
3from cgi import escape
4from types import *
5import Globals
6from Globals import InitializeClass
7from ZPublisher.HTTPRequest import FileUpload
8##from Products.CPSSchemas.Widget import CPSWidgetType
9from Products.CMFCore.utils import getToolByName
10from Products.CPSSchemas.BasicWidgets import CPSBooleanWidget, CPSWidget, CPSStringWidget, CPSEmailWidget,CPSImageWidget
11from Products.CPSSchemas.BasicWidgets import CPSFileWidget
12from Products.CPSSchemas.BasicWidgets import renderHtmlTag,CPSSelectWidget, CPSStringWidget
13from Products.CPSSchemas.ExtendedWidgets import CPSDateTimeWidget
14from Products.CPSSchemas.Widget import widgetRegistry
15from Products.CPSUtil.file import PersistableFileUpload
16from Products.CPSUtil.id import generateFileName
17##from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry
18from DateTime.DateTime import DateTime
19from AccessControl import getSecurityManager
20from Products.WAeUP_SRP.Students import getStudentByRegNo
21from Products.WAeUP_SRP.Academics import makeCertificateCode
22#from Products.ExtFile.ExtFile import ExtFile
23import logging,os,re
24import operator
25p_home = Globals.package_home(globals())
26i_home = Globals.INSTANCE_HOME
27
28#from zLOG import LOG, DEBUG
29
30class CPSSelectWidgetForRecord(CPSSelectWidget): ###(
31    """Select widget. with record names"""
32    meta_type = 'Select Widget for Records'
33
34    field_types = ('CPS String Field',)
35    field_inits = ({'is_searchabletext': 1,},)
36
37    _properties = CPSSelectWidget._properties + (
38        {'id': 'record_id', 'type': 'string', 'mode': 'w',
39         'label': 'Record Id', 'is_required' : 1},
40        )
41
42    def render(self, mode, datastructure, **kw):
43        """Render in mode from datastructure."""
44        value = datastructure[self.getWidgetId()]
45        vocabulary = self._getVocabulary(datastructure)
46        portal = getToolByName(self, 'portal_url').getPortalObject()
47        cpsmcat = portal.translation_service
48        if mode == 'view':
49            if self.translated:
50                return escape(cpsmcat(vocabulary.getMsgid(value, value)).encode('ISO-8859-15', 'ignore'))
51            else:
52                return escape(vocabulary.get(value, value))
53        elif mode == 'edit':
54            html_widget_id = self.getHtmlWidgetId()
55            res = renderHtmlTag('select',
56                                name='%s.%s:records' % (self.record_id,html_widget_id),
57                                id=html_widget_id)
58            in_selection = 0
59            for k, v in vocabulary.items():
60                if self.translated:
61                    kw = {'value': k,
62                          'contents': cpsmcat(vocabulary.getMsgid(k, k)).encode('ISO-8859-15', 'ignore')
63                          }
64                else:
65                    kw = {'value': k, 'contents': v}
66                if value == k:
67                    kw['selected'] = 'selected'
68                    in_selection = 1
69                res += renderHtmlTag('option', **kw)
70            if value and not in_selection:
71                kw = {'value': value, 'contents': 'invalid: '+ str(value),
72                      'selected': 'selected'}
73                res += renderHtmlTag('option', **kw)
74            res += '</select>'
75            return res
76        raise RuntimeError('unknown mode %s' % mode)
77
78InitializeClass(CPSSelectWidgetForRecord)
79
80widgetRegistry.register(CPSSelectWidgetForRecord)
81
82###)
83
84class CPSStringWidgetForRecord(CPSStringWidget): ###(
85    """String widget."""
86    meta_type = 'String Widget For Record'
87
88    field_types = ('CPS String Field',)
89    field_inits = ({'is_searchabletext': 1,},)
90    _properties = CPSStringWidget._properties + (
91        {'id': 'record_id', 'type': 'string', 'mode': 'w',
92         'label': 'Record Id', 'is_required' : 1},
93        )
94
95    def render(self, mode, datastructure, **kw):
96        """Render in mode from datastructure."""
97        value = datastructure[self.getWidgetId()]
98        if mode == 'view':
99            return escape(value)
100        elif mode == 'edit':
101            # XXX TODO should use an other name than kw !
102            # XXX change this everywhere
103            html_widget_id = self.getHtmlWidgetId()
104            kw = {'type': 'text',
105                  'id'  : html_widget_id,
106                  'name': '%s.%s:records' % (self.record_id,html_widget_id),
107                  'value': escape(value),
108                  'size': self.display_width,
109                  }
110            if self.size_max:
111                kw['maxlength'] = self.size_max
112            return renderHtmlTag('input', **kw)
113        raise RuntimeError('unknown mode %s' % mode)
114
115InitializeClass(CPSStringWidgetForRecord)
116
117widgetRegistry.register(CPSStringWidgetForRecord)
118
119###)
120
121class CertificateCourseIdWidget(CPSStringWidget): ###(
122    """ CertificateCourseId Widget"""
123    meta_type = "CertificateCourseId Widget"
124
125    def validate(self, datastructure, **kw):
126        """Validate datastructure and update datamodel."""
127
128        valid = CPSStringWidget.validate(self, datastructure, **kw)
129        if not valid:
130            return 0
131        else:
132            widget_id = self.getWidgetId()
133            value = datastructure[widget_id].upper()
134            err = 0
135            c_ids = [c.id for c in self.portal_catalog({'meta_type': "Course"})]
136            if hasattr(self.aq_parent,value):
137                err = 'Course already exists'
138            elif value not in c_ids:
139                err = 'Course does not exist'
140            if err:
141                datastructure.setError(widget_id, err)
142            else:
143                datamodel = datastructure.getDataModel()
144                datamodel[self.fields[0]] = value
145
146            return not err
147
148InitializeClass(CertificateCourseIdWidget)
149
150widgetRegistry.register(CertificateCourseIdWidget)
151###)
152
153class CourseIdWidget(CPSStringWidget): ###(
154    """ CourseId Widget"""
155    meta_type = "CourseId Widget"
156
157    def validate(self, datastructure, **kw):
158        """Validate datastructure and update datamodel."""
159
160        valid = CPSStringWidget.validate(self, datastructure, **kw)
161        if not valid:
162            return 0
163        else:
164            widget_id = self.getWidgetId()
165            value = datastructure[widget_id].upper()
166            err = 0
167            res = self.courses_catalog(code = value)
168            if len(res) > 0:
169                err = 'Course already exists'
170            if err:
171                datastructure.setError(widget_id, err)
172            else:
173                datamodel = datastructure.getDataModel()
174                datamodel[self.fields[0]] = value
175
176            return not err
177
178InitializeClass(CourseIdWidget)
179
180widgetRegistry.register(CourseIdWidget)
181
182
183###)
184
185class WAeUPStudyModeWidget(CPSSelectWidget): ###(
186    """WAeUP StudyMode Widget."""
187    meta_type = 'WAeUP StudyMode Widget'
188    vocabulary = 'entry_modes'
189
190    def _getStudyModes(self):
191        voc = getattr(self.portal_vocabularies,self.vocabulary)
192        d = {}
193        for k,v in voc.items():
194            d[k] = v
195        return d
196
197    def validate(self, datastructure, **kw):
198        """Validate datastructure and update datamodel."""
199        widget_id = self.getWidgetId()
200        value = datastructure[widget_id]
201        try:
202            v = str(value)
203        except ValueError:
204            datastructure.setError(widget_id, "'%s' not a valid session key" % value)
205            return 0
206        studymodes = self._getStudyModes()
207        if not value:
208            v = value = 'ume_ft'
209        #import pdb;pdb.set_trace()
210        if not studymodes.has_key(value):
211            datastructure.setError(widget_id, "'%s' not a valid session key" % v)
212            return 0
213        if self.is_required and not len(v):
214            datastructure.setError(widget_id, "session key required")
215            return 0
216
217        datamodel = datastructure.getDataModel()
218        datamodel[self.fields[0]] = v
219        return 1
220
221    def render(self, mode, datastructure, **kw):
222        """Render in mode from datastructure."""
223        value = datastructure[self.getWidgetId()]
224        studymodes = self._getStudyModes()
225        if mode == 'view':
226            return escape(studymodes.get(value, value))
227        elif mode == 'edit':
228            html_widget_id = self.getHtmlWidgetId()
229            res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
230            in_selection = 0
231            vocabulary_items = studymodes.items()
232            if self.sorted:
233                vocabulary_items.sort(key=operator.itemgetter(1))
234            for k, v in vocabulary_items:
235                kw = {'value': k, 'contents': v}
236                if value == k:
237                    kw['selected'] = 'selected'
238                    in_selection = 1
239                res += renderHtmlTag('option', **kw)
240            if value and not in_selection:
241                kw = {'value': value, 'contents': 'invalid: '+ str(value),
242                      'selected': 'selected'}
243                res += renderHtmlTag('option', **kw)
244            res += '</select>'
245            return res
246        raise RuntimeError('unknown mode %s' % mode)
247
248InitializeClass(WAeUPStudyModeWidget)
249
250widgetRegistry.register(WAeUPStudyModeWidget)
251
252###)
253
254class WAeUPSessionWidget(CPSSelectWidget): ###(
255    """WAeUP Session Widget."""
256    meta_type = 'WAeUP Session Widget'
257
258    def _getSessions(self):
259        current_year = DateTime().year()
260        d = {'-1': 'N/A'}
261        for y in range(current_year - 9,current_year + 1):
262            d['%s' % str(y)[-2:]] = '%4d/%4d' % (y,y+1)
263        return d
264
265    def validate(self, datastructure, **kw):
266        """Validate datastructure and update datamodel."""
267        widget_id = self.getWidgetId()
268        value = datastructure[widget_id]
269        try:
270            v = str(value)
271        except ValueError:
272            datastructure.setError(widget_id, "'%s' not a valid session key" % value)
273            return 0
274
275        if len(v) == 1:
276            v = value = '0%c' % v
277        elif not value:
278            v = value = self.getSessionId()[-2:]
279        #import pdb;pdb.set_trace()
280        sessions = self._getSessions()
281        if not sessions.has_key(value):
282            datastructure.setError(widget_id, "'%s' not a valid session key" % v)
283            return 0
284        if self.is_required and not len(v):
285            datastructure.setError(widget_id, "session key required")
286            return 0
287
288        datamodel = datastructure.getDataModel()
289        datamodel[self.fields[0]] = v
290        return 1
291
292    def render(self, mode, datastructure, **kw):
293        """Render in mode from datastructure."""
294        value = datastructure[self.getWidgetId()]
295        sessions = self._getSessions()
296        if mode == 'view':
297            return escape(sessions.get(value, value))
298        elif mode == 'edit':
299            html_widget_id = self.getHtmlWidgetId()
300            res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
301            in_selection = 0
302            vocabulary_items = sessions.items()
303            if self.sorted:
304                vocabulary_items.sort(key=operator.itemgetter(0))
305            for k, v in vocabulary_items:
306                kw = {'value': k, 'contents': v}
307                if value == k:
308                    kw['selected'] = 'selected'
309                    in_selection = 1
310                res += renderHtmlTag('option', **kw)
311            if value and not in_selection:
312                kw = {'value': value, 'contents': 'invalid: '+ str(value),
313                      'selected': 'selected'}
314                res += renderHtmlTag('option', **kw)
315            res += '</select>'
316            return res
317        raise RuntimeError('unknown mode %s' % mode)
318
319InitializeClass(WAeUPSessionWidget)
320
321widgetRegistry.register(WAeUPSessionWidget)
322
323###)
324
325class WAeUPLevelWidget(CPSSelectWidget): ###(
326    """WAeUP Level Widget."""
327    meta_type = 'WAeUP Level Widget'
328
329    def _getLevels(self):
330        d = {'000':'N/A'}
331        for y in range(100,800,100):
332            d['%s' % str(y)] = 'Year %1d (%3d Level)' % (y/100,y)
333        return d
334
335    def validate(self, datastructure, **kw):
336        """Validate datastructure and update datamodel."""
337        widget_id = self.getWidgetId()
338        value = datastructure[widget_id]
339        try:
340            v = str(value)
341        except ValueError:
342            datastructure.setError(widget_id, "'%s' not a valid level key" % value)
343            return 0
344
345        if not value:
346            v = value = '100'
347        #import pdb;pdb.set_trace()
348        levels = self._getLevels()
349        if not levels.has_key(value):
350            datastructure.setError(widget_id, "'%s' not a valid level" % v)
351            return 0
352        if self.is_required and not len(v):
353            datastructure.setError(widget_id, "level key required")
354            return 0
355
356        datamodel = datastructure.getDataModel()
357        datamodel[self.fields[0]] = v
358        return 1
359
360    def render(self, mode, datastructure, **kw):
361        """Render in mode from datastructure."""
362        value = datastructure[self.getWidgetId()]
363        levels = self._getLevels()
364        if mode == 'view':
365            return escape(levels.get(value, value))
366        elif mode == 'edit':
367            html_widget_id = self.getHtmlWidgetId()
368            res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
369            in_selection = 0
370            vocabulary_items = levels.items()
371            if self.sorted:
372                vocabulary_items.sort(key=operator.itemgetter(0))
373            for k, v in vocabulary_items:
374                kw = {'value': k, 'contents': v}
375                if value == k:
376                    kw['selected'] = 'selected'
377                    in_selection = 1
378                res += renderHtmlTag('option', **kw)
379            if value and not in_selection:
380                kw = {'value': value, 'contents': 'invalid: '+ str(value),
381                      'selected': 'selected'}
382                res += renderHtmlTag('option', **kw)
383            res += '</select>'
384            return res
385        raise RuntimeError('unknown mode %s' % mode)
386
387InitializeClass(WAeUPLevelWidget)
388
389widgetRegistry.register(WAeUPLevelWidget)
390
391###)
392
393class WAeUPVerdictWidget(CPSSelectWidget): ###(
394    """WAeUP Verdict Widget."""
395    meta_type = 'WAeUP Verdict Widget'
396
397    # XXX make a menu for the vocabulary.
398    vocabulary = 'verdicts'
399
400    # Associating the widget label with an input area to improve the widget
401    # accessibility.
402    has_input_area = True
403
404    def _getVerdicts(self,datastructure):
405        voc = getattr(self.portal_vocabularies,self.vocabulary)
406        d = {}
407        for k,v in voc.items():
408            d[k] = v
409        return d
410
411    def validate(self, datastructure, **kw):
412        """Validate datastructure and update datamodel."""
413        widget_id = self.getWidgetId()
414        value = datastructure[widget_id]
415        try:
416            v = str(value)
417        except ValueError:
418            datastructure.setError(widget_id, "'%s' not a valid verdict key" % value)
419            return 0
420        #import pdb;pdb.set_trace()
421        verdicts = self._getVerdicts(datastructure)
422        if not value:
423            v = value = verdicts['N/A']
424        if not verdicts.has_key(value):
425            datastructure.setError(widget_id, "'%s' not a valid verdict key" % v)
426            return 0
427        if self.is_required and not len(v):
428            datastructure.setError(widget_id, "verdict required")
429            return 0
430
431        datamodel = datastructure.getDataModel()
432        datamodel[self.fields[0]] = v
433        return 1
434
435    def render(self, mode, datastructure, **kw):
436        """Render in mode from datastructure."""
437        value = datastructure[self.getWidgetId()]
438        verdicts = self._getVerdicts(datastructure)
439        if mode == 'view':
440            return escape(verdicts.get(value, value))
441        elif mode == 'edit':
442            html_widget_id = self.getHtmlWidgetId()
443            res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
444            in_selection = 0
445            vocabulary_items = verdicts.items()
446            if self.sorted:
447                vocabulary_items.sort(key=operator.itemgetter(1))
448            for k, v in vocabulary_items:
449                kw = {'value': k, 'contents': v}
450                if value == k:
451                    kw['selected'] = 'selected'
452                    in_selection = 1
453                res += renderHtmlTag('option', **kw)
454            if value and not in_selection:
455                kw = {'value': value, 'contents': 'invalid: '+ str(value),
456                      'selected': 'selected'}
457                res += renderHtmlTag('option', **kw)
458            res += '</select>'
459            return res
460        raise RuntimeError('unknown mode %s' % mode)
461
462InitializeClass(WAeUPVerdictWidget)
463
464widgetRegistry.register(WAeUPVerdictWidget)
465
466###)
467
468class WAeUPLGAWidget(CPSSelectWidget): ###(
469    """WAeUP LGA Widget."""
470    meta_type = 'WAeUP LGA Widget'
471    _properties = CPSSelectWidget._properties + (
472        {'id': 'state_field', 'type': 'string', 'mode': 'w',
473         'label': 'Name of the state field'},
474         {'id': 'lga_field', 'type': 'string', 'mode': 'w',
475         'label': 'Name of the LGA Field (without state)'},
476         )
477    state_field = "state"
478    lga_field = "lga"
479
480    # XXX make a menu for the vocabulary.
481    vocabulary = 'local_gov_areas'
482
483    # Associating the widget label with an input area to improve the widget
484    # accessibility.
485    has_input_area = True
486
487    def _getLGAs(self):
488        voc = getattr(self.portal_vocabularies,self.vocabulary)
489        states = []
490        lgas  = []
491        d = {}
492        for k,v in voc.items():
493            parts = v.split(' / ')
494            if len(parts) == 1:
495                state = parts[0].lower()
496                lga = ""
497            elif len(parts) == 2:
498                state = parts[0].lower()
499                lga = "_".join(re.split('\W+',parts[1].lower()))
500            else:
501                continue
502            if state not in states:
503                states.append(state)
504            if lga not in lgas:
505                lgas.append(lga)
506            d[k] = v
507
508        return (d,states,lgas)
509
510    def validate(self, datastructure, **kw):
511        """Validate datastructure and update datamodel."""
512        widget_id = self.getWidgetId()
513        value = datastructure[widget_id]
514        #import pdb;pdb.set_trace()
515        try:
516            v = str(value)
517        except ValueError:
518            datastructure.setError(widget_id, "'%s' not a valid lga key" % value)
519            return 0
520        v = v.lower()
521        combined,states,lgas = self._getLGAs()
522        one_field = False
523        if len(v) == 0:
524            pass
525        elif not self.state_field and not self.lga_field:
526            one_field = True
527            if v not in combined.keys():
528                datastructure.setError(widget_id, "'%s' not a valid lga key" % v)
529                return 0
530        else:
531            if widget_id == self.state_field:
532                if v not in states:
533                    datastructure.setError(widget_id, "'%s' not a valid state" % v)
534                    return 0
535            elif widget_id == self.lga_field:
536                if "_".join(re.split('\W+',v)) not in lgas:
537                    datastructure.setError(widget_id, "'%s' not a valid lga" % v)
538                    return 0
539                if datastructure[self.state_field]:
540                    v = datastructure[self.state_field] + '_' + v
541
542        if self.is_required and not len(v):
543            datastructure.setError(widget_id, "lga required")
544            return 0
545
546        datamodel = datastructure.getDataModel()
547        if one_field:
548            datamodel[self.fields[0]] = v
549        else:
550            state = datastructure[self.state_field].lower()
551            lga = "_".join(datastructure[self.lga_field].lower().split())
552            datamodel[self.fields[0]] =   state + "_" + lga
553        return 1
554
555    def render(self, mode, datastructure, **kw):
556        """Render in mode from datastructure."""
557        w_id = self
558        value = datastructure[self.getWidgetId()]
559        lgas,x,y = self._getLGAs(datastructure)
560        if mode == 'view':
561            return escape(lgas.get(value, value))
562        elif mode == 'edit':
563            html_widget_id = self.getHtmlWidgetId()
564            res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
565            in_selection = 0
566            vocabulary_items = lgas.items()
567            # if self.sorted:
568            #     vocabulary_items.sort(key=operator.itemgetter(1))
569            for k, v in vocabulary_items:
570                kw = {'value': k, 'contents': v}
571                if value == k:
572                    kw['selected'] = 'selected'
573                    in_selection = 1
574                res += renderHtmlTag('option', **kw)
575            if value and not in_selection:
576                kw = {'value': value, 'contents': 'invalid: '+ str(value),
577                      'selected': 'selected'}
578                res += renderHtmlTag('option', **kw)
579            res += '</select>'
580            return res
581        raise RuntimeError('unknown mode %s' % mode)
582
583InitializeClass(WAeUPLGAWidget)
584
585widgetRegistry.register(WAeUPLGAWidget)
586
587###)
588
589class WAeUPReservedRoomsWidget(CPSStringWidget): ###(
590    """ WAeUPReservedRooms Widget"""
591    meta_type = "WAeUPReservedRooms Widget"
592
593    def validate(self, datastructure, **kw):
594        """Validate datastructure and update datamodel."""
595        import re
596        valid = CPSStringWidget.validate(self, datastructure, **kw)
597        if not valid:
598            return 0
599        else:
600            widget_id = self.getWidgetId()
601            value = datastructure[widget_id]
602            err = 0
603            try:
604                reserved = [(r.split('/')[0],int(r.split('/')[1])) for r in re.split(',|\.| ',value)
605                                     if r]
606            except (ValueError,IndexError),msg:
607                err = str(msg)
608            if err:
609                datastructure.setError(widget_id, err)
610            else:
611                datamodel = datastructure.getDataModel()
612                datamodel[self.fields[0]] = value
613            return not err
614
615InitializeClass(WAeUPReservedRoomsWidget)
616
617widgetRegistry.register(WAeUPReservedRoomsWidget)
618###)
619
620class WAeUPIdWidget(CPSStringWidget): ###(
621    """ WAeUPId Widget"""
622    meta_type = "WAeUPId Widget"
623
624    def validate(self, datastructure, **kw):
625        """Validate datastructure and update datamodel."""
626        mode = kw.get('mode','create')
627        valid = CPSStringWidget.validate(self, datastructure, **kw)
628        id_pat_str = r"\S"
629        inv_id_pat = re.compile(r"^%s$" % id_pat_str)
630        if not valid:
631            return 0
632        else:
633            portal_type_query = {'query':['Faculty',
634                                          'Department',
635                                          'Course',
636                                          'Certificate',
637                                          'CertificateCourse',]}
638            widget_id = self.getWidgetId()
639            value = datastructure[widget_id]  #.upper()  is not necessary here because it's also done in waeup_document_create_do
640            err = 0
641            mapping = {}
642            if len(value.split()) > 1:
643                err = 'Invalid Id, Id contains space(s).'
644            elif mode == "create" and\
645                          self.portal_catalog(portal_type=portal_type_query,id=value):
646                brain = self.portal_catalog(portal_type=portal_type_query,id=value)[0]
647                err = 'An ${portal_type} object with the Id ${id} already exists at ${path}.'
648                mapping = {'portal_type': brain.portal_type,
649                           'id': value,
650                           'path': brain.getPath(),
651                           }
652            if err:
653                datastructure.setError(widget_id, err, mapping)
654            else:
655                datamodel = datastructure.getDataModel()
656                datamodel[self.fields[0]] = value
657
658            return not err
659
660InitializeClass(WAeUPIdWidget)
661
662widgetRegistry.register(WAeUPIdWidget)
663
664
665###)
666
667class StudyCourseWidget(CPSStringWidget): ###(
668    """ StudyCourse Widget"""
669    meta_type = "StudyCourse Widget"
670
671    def validate(self, datastructure, **kw):
672        """Validate datastructure and update datamodel."""
673        #from Products.zdb import set_trace
674        #set_trace()
675##        valid = CPSStringWidget.validate(self, datastructure, **kw)
676##        if not valid:
677##            return 0
678        widget_id = self.getWidgetId()
679        value = makeCertificateCode(datastructure[widget_id]).upper()
680        id_pat_str = r"\S"
681        inv_id_pat = re.compile(r"^%s$" % id_pat_str)
682        err = 0
683        if len(value.split()) > 1:
684            err = 'Invalid Id, Id contains space(s).'
685        elif not self.portal_catalog(portal_type='Certificate',id=value):
686            err = 'No such certificate'
687        if err:
688            datastructure.setError(widget_id, err)
689        else:
690            datamodel = datastructure.getDataModel()
691            datamodel[self.fields[0]] = value
692        return not err
693
694InitializeClass(StudyCourseWidget)
695
696widgetRegistry.register(StudyCourseWidget)
697###)
698
699class JambRegNoWidget(CPSStringWidget): ###(
700    """ JambRegNo Widget"""
701    meta_type = "JambRegNo Widget"
702    _properties = CPSStringWidget._properties + (
703        {'id': 'catalog', 'type': 'string', 'mode': 'w',
704         'label': 'Catalog to search'},
705         {'id': 'reference', 'type': 'string', 'mode': 'w',
706         'label': 'Reference Field'},
707         )
708    #catalog = "portal_pumeresults" #the catalog to search for jamb_reg_no
709    reference = ""
710    digits = 8
711    digits_str = "N"*digits
712    letters = 2
713    letters_str = "L"*letters
714    def validate(self, datastructure, **kw):
715        """Validate datastructure and update datamodel."""
716        valid = CPSStringWidget.validate(self, datastructure, **kw)
717        reg_no_catalog = getattr(self,self.catalog)
718        widget_id = self.getWidgetId()
719        value = datastructure[widget_id].upper()
720        err = 0
721        #import pdb;pdb.set_trace()
722        if kw.has_key('mode'):
723            mode = kw['mode']
724        else:
725            mode = "edit"
726        if not valid:
727            err = 'Invalid registration number'
728        elif self.reference == '':
729            #s = getStudentByRegNo(self,value)
730            pume = reg_no_catalog(jamb_reg_no = value)
731            if len(pume) < 1:
732                err = 'No student record with this registration number'
733            else:
734                datastructure['pume'] = pume[0]
735        elif mode == 'add':
736            pass
737        elif self.reference != '' and self.catalog == "applicants_catalog":
738            res = reg_no_catalog.searchResults({"%s" % self.reference: value})
739            if len(res) != 1:
740                err = 'No record with this registration number'
741            else:
742                datastructure['record'] = res[0]
743        else:
744            record = datastructure[self.reference]
745            #jamb_reg_no = getattr(record,widget_id)
746            jamb_reg_no = record.Entryregno
747            if jamb_reg_no != value:
748                err = 'Registration number does not match.'
749        if err:
750            datastructure.setError(widget_id, err)
751        else:
752            datamodel = datastructure.getDataModel()
753            datamodel[self.fields[0]] = value
754        return not err
755
756InitializeClass(JambRegNoWidget)
757
758widgetRegistry.register(JambRegNoWidget)
759###)
760
761class SecretWidget(CPSStringWidget): ###(
762    """ Secret Widget"""
763    meta_type = "Secret Widget"
764    _properties = CPSStringWidget._properties + (
765        {'id': 'reference', 'type': 'string', 'mode': 'w',
766         'label': 'Reference Record'},
767         {'id': 'check_fields', 'type': 'tokens', 'mode': 'w',
768         'label': 'Fields to check'},
769         )
770    reference = "student"
771    matric_no_catalog = 'returning_import'
772    check_fields = ("Firstname", "Middlename","Lastname")
773    def validate(self, datastructure, **kw):
774        """Validate datastructure and update datamodel."""
775        logger = logging.getLogger('Widgets.SecretWidget.validate')
776        valid = CPSStringWidget.validate(self, datastructure, **kw)
777        widget_id = self.getWidgetId()
778        value = datastructure[widget_id].upper()
779        err = 0
780        record = datastructure.get(self.reference,None)
781        #import pdb;pdb.set_trace()
782        if not valid or len(value) < 2:
783            err = 'Invalid string'
784        elif not record or datastructure.errors:
785            err = 0
786        else:
787            found = False
788            cvs = []
789            for field in self.check_fields:
790                cv = getattr(record,field).upper()
791                if len(cv.split()) > 1:
792                    for splited in cv.split():
793                        cvs.append(splited.strip())
794                else:
795                    cvs.append(cv)
796            for cv in cvs:
797                if cv  == value.upper():
798                    found = True
799                    break
800            matric_no = record.matric_no
801            name = " ".join(cvs)
802            if not found:
803                logger.info('%(matric_no)s did not find %(value)s in %(name)s' % vars())
804                err = 'No name does match.'
805            else:
806                logger.info('%(matric_no)s found %(value)s in %(name)s' % vars())
807        if err:
808            datastructure.setError(widget_id, err)
809        else:
810            datamodel = datastructure.getDataModel()
811            datamodel[self.fields[0]] = value
812        return not err
813
814InitializeClass(SecretWidget)
815
816widgetRegistry.register(SecretWidget)
817###)
818
819class WAeUPSexWidget(CPSBooleanWidget): ###(
820    """WAeUP sex widget."""
821    meta_type = 'WAeUP Sex Widget'
822
823    def validate(self, datastructure, **kw):
824        """Validate datastructure and update datamodel."""
825        value = datastructure[self.getWidgetId()]
826
827        if self.render_format not in self.render_formats:
828            self.render_format = 'select'
829
830        female = value in ('F','f','Female','female',"True",True)
831        male = value in ('M','m','Male','male','False',False)
832        if not female and not male:
833            datastructure.setError(self.getWidgetId(),
834                                   "invalid sex %s" % value)
835            return 0
836        elif female:
837            v = True
838        else:
839            v = False
840        datamodel = datastructure.getDataModel()
841        datamodel[self.fields[0]] = v
842        return 1
843
844InitializeClass(WAeUPSexWidget)
845
846widgetRegistry.register(WAeUPSexWidget)
847
848###)
849
850class MatricNoWidget(CPSStringWidget): ###(
851    """ MatricNo Widget"""
852    meta_type = "MatricNo Widget"
853
854    _properties = CPSStringWidget._properties + (
855        {'id': 'matric_no_catalog', 'type': 'string', 'mode': 'w',
856         'label': 'Catalog to search for MatricNo'},
857        { 'id': 'results_catalog', 'type': 'string', 'mode': 'w',
858         'label': 'Results Catalog'},
859         )
860    matric_no_catalog = "" #the catalog to search for matric_no
861    results_catalog = "results_import" #results catalog
862
863    def validate(self, datastructure, **kw):
864        """Validate datastructure and update datamodel."""
865        #import pdb;pdb.set_trace()
866        valid = CPSStringWidget.validate(self, datastructure, **kw)
867        logger = logging.getLogger('Widgets.MatricNoWidget.validate')
868        returning = getattr(self,self.matric_no_catalog)
869        results = getattr(self,self.results_catalog,None)
870        err = 0
871        widget_id = self.getWidgetId()
872        value = datastructure[widget_id]
873        if not valid or not value:
874            err = 'Invalid string'
875            logger.info('Invalid matric_no string %s' % value)
876        else:
877            value = value.upper()
878            datastructure['student'] = None
879            while not err:
880                res = returning(matric_no = value)
881                if len(res) < 1:
882                    logger.info('matric_no %s not found' % value)
883                    err = 'No student with this matriculation number.'
884                    break
885                datastructure['student'] = res[0]
886                if results is not None:
887                    res = results(matric_no = value)
888                    if len(res) < 1:
889                        err = 'No results for this matriculation number'
890                        continue
891                    datastructure['results'] = res
892                break
893        if err:
894            datastructure.setError(widget_id, err)
895        else:
896            datamodel = datastructure.getDataModel()
897            datamodel[self.fields[0]] = value
898        return not err
899
900InitializeClass(MatricNoWidget)
901
902widgetRegistry.register(MatricNoWidget)
903###)
904
905class StudentIdWidget(CPSStringWidget): ###(
906    """ StudentId Widget"""
907    meta_type = "StudentId Widget"
908    def validate(self, datastructure, **kw):
909        """Validate datastructure and update datamodel."""
910        valid = CPSStringWidget.validate(self, datastructure, **kw)
911        logger = logging.getLogger('Widgets.StudentIdWidget.validate')
912        #import pdb;pdb.set_trace()
913        s_cat = self.students_catalog
914        err = 0
915        widget_id = self.getWidgetId()
916        value = datastructure[widget_id]
917        if not valid or not value:
918            err = 'Invalid Id string'
919            logger.info('Invalid id string %s' % value)
920            datastructure['student'] = None
921        else:
922            value = value.upper()
923            res = s_cat(id = value)
924            if not res:
925                logger.info('Student id %s not found' % value)
926                err = 'No student with this Id'
927                datastructure['student'] = None
928            else:
929                datastructure['student'] = res[0]
930        if err:
931            datastructure.setError(widget_id, err)
932        else:
933            datamodel = datastructure.getDataModel()
934            datamodel[self.fields[0]] = value
935        return not err
936
937InitializeClass(StudentIdWidget)
938
939widgetRegistry.register(StudentIdWidget)
940###)
941
942class WAeUPMultilineResultsWidget(CPSStringWidget): ###(
943    """ WAeUPMultilineResults Widget"""
944    meta_type = "WAeUp Multiline Results Widget"
945    _properties = CPSWidget._properties + (
946        {'id': 'nr_of_lines', 'type': 'int', 'mode': 'w',
947         'label': 'Nr of Lines'},
948         )
949    nr_of_lines = 5
950    def prepare(self, datastructure, **kw): ###(
951        """Prepare datastructure from datamodel."""
952        datamodel = datastructure.getDataModel()
953        #import pdb;pdb.set_trace()
954        widget_id = self.getWidgetId()
955        v = datamodel[self.fields[0]]
956        if type(v) is ListType and v:
957            nr_results = len(v)
958        else:
959            v = []
960            nr_results = 0
961        count = 1
962        for s,g in v:
963            wid = "%s%02d"% (widget_id,count)
964            datastructure[wid+'_s'] = s
965            datastructure[wid+'_g'] = g
966            count += 1
967        if nr_results < self.nr_of_lines:
968            for line in range(nr_results,self.nr_of_lines):
969                v.append(('',''))
970                wid = "%s%02d"% (widget_id,line)
971                datastructure[wid+'_s'] = ''
972                datastructure[wid+'_g'] = ''
973        datastructure[widget_id] = v
974        datastructure[widget_id+'_s'] = ''
975        datastructure[widget_id+'_g'] = ''
976    ###)
977
978    def validate(self, datastructure, **kw): ###(
979        """Validate datastructure and update datamodel."""
980        #import pdb;pdb.set_trace()
981        widget_id = self.getWidgetId()
982        err = 0
983        lines = []
984        for line in range(1,30):
985            wid = "%s%02d"% (widget_id,line)
986            if not datastructure.has_key(wid+'_s'):
987                break
988            lines.append((datastructure[wid+'_s'].strip(),
989                         datastructure[wid+'_g'].strip()))
990
991        s = datastructure[widget_id+'_s'].strip()
992        g = datastructure[widget_id+'_g'].strip()
993        if s and g:
994            lines.append((s,g))
995        active = []
996        for s,g in lines:
997            if g != "":
998                active.append((s,g))
999        if err:
1000            datastructure.setError(widget_id, err)
1001        else:
1002            datamodel = datastructure.getDataModel()
1003            datamodel[self.fields[0]] = active
1004        return not err
1005    ###)
1006
1007    def render(self, mode, datastructure, **kw): ###(
1008        """Render in mode from datastructure."""
1009        render_method = 'widget_waeup_multiline_result_render'
1010        meth = getattr(self, render_method, None)
1011        if meth is None:
1012            raise RuntimeError("Unknown Render Method %s for widget type %s"
1013                               % (render_method, self.getId()))
1014        #import pdb;pdb.set_trace()
1015        datamodel = datastructure.getDataModel()
1016        widget_id = self.getWidgetId()
1017        lines = datamodel[self.fields[0]]
1018        if len(lines) < self.nr_of_lines:
1019            for line in range(len(lines),self.nr_of_lines + 1):
1020                lines.append(('',''))
1021        datastructure[widget_id] = lines
1022        datastructure[widget_id+'_s'] = ''
1023        datastructure[widget_id+'_g'] = ''
1024##        count = 1
1025##        for s,g in v:
1026##            wid = "%s%02d"% (widget_id,count)
1027##            count += 1
1028        return meth(mode=mode,
1029                    datastructure=datastructure,
1030                    )
1031    ###)
1032
1033
1034InitializeClass(WAeUPMultilineResultsWidget)
1035widgetRegistry.register(WAeUPMultilineResultsWidget)
1036###)
1037
1038class WAeUPResultsWidget(CPSStringWidget): ###(
1039    """ WAeUPResults Widget"""
1040    meta_type = "WAeUp Results Widget"
1041
1042    def prepare(self, datastructure, **kw): ###(
1043        """Prepare datastructure from datamodel."""
1044        datamodel = datastructure.getDataModel()
1045        v = datamodel[self.fields[0]]
1046        #import pdb;pdb.set_trace()
1047        widget_id = self.getWidgetId()
1048        datastructure[widget_id] = v
1049        datastructure[widget_id+'_s'] = ''
1050        datastructure[widget_id+'_g'] = ''
1051    ###)
1052
1053    def validate(self, datastructure, **kw): ###(
1054        """Validate datastructure and update datamodel."""
1055        #import pdb;pdb.set_trace()
1056        widget_id = self.getWidgetId()
1057        v = datastructure[widget_id]
1058        err = 0
1059        s = datastructure[widget_id+'_s'].strip()
1060        g = datastructure[widget_id+'_g'].strip()
1061        while 1:
1062            if not s and g:
1063                err = "No subject grade for subject"
1064                break
1065            i = 0
1066            done = False
1067            for sv,gv in v:
1068                if sv == s:
1069                    done = True
1070                    if not g:
1071                        v.pop(i)
1072                        break
1073                    v[i] = (s,g)
1074                    break
1075                i += 1
1076            if done:
1077                break
1078            if s and g:
1079                v.append((s,g))
1080            break
1081        if err:
1082            datastructure.setError(widget_id, err)
1083        else:
1084            datamodel = datastructure.getDataModel()
1085            datamodel[self.fields[0]] = v
1086            datastructure[widget_id+'_s'] = s
1087            datastructure[widget_id+'_g'] = g
1088        return not err
1089    ###)
1090
1091    def render(self, mode, datastructure, **kw): ###(
1092        """Render in mode from datastructure."""
1093        render_method = 'widget_waeup_result_render'
1094        meth = getattr(self, render_method, None)
1095        if meth is None:
1096            raise RuntimeError("Unknown Render Method %s for widget type %s"
1097                               % (render_method, self.getId()))
1098        #import pdb;pdb.set_trace()
1099        datamodel = datastructure.getDataModel()
1100        widget_id = self.getWidgetId()
1101        datastructure[widget_id+'_s'] = ''
1102        datastructure[widget_id+'_g'] = ''
1103        return meth(mode=mode,
1104                    datastructure=datastructure,
1105                    )
1106    ###)
1107
1108
1109InitializeClass(WAeUPResultsWidget)
1110widgetRegistry.register(WAeUPResultsWidget)
1111###)
1112
1113class ScratchCardPin: ###(
1114    """the ScratchCardPin"""
1115    def __init__(self,prefix,batch_no,number):
1116        if not batch_no and not number:
1117            s = prefix
1118            if len(s) > 3:
1119                prefix,batch_no,number = s[:3],s[3:-10],s[-10:]
1120            else:
1121                prefix,batch_no,number = s,'',''
1122        self.p = prefix
1123        self.b = batch_no
1124        self.n = number
1125
1126    def __str__(self):
1127        return "%s-%s-%s" % (self.p,self.b,self.n)
1128
1129    def __repr__(self):
1130        return "%s%s%s" % (self.p,self.b,self.n)
1131###)
1132
1133class ScratchcardPinWidget(CPSStringWidget): ###(
1134    """ ScratchcardPin Widget"""
1135    meta_type = "Scratchcard Pin Widget"
1136    _properties = CPSWidget._properties + (
1137        {'id': 'prefix', 'type': 'string', 'mode': 'w',
1138         'label': 'Prefix'},
1139         {'id': 'reference', 'type': 'string', 'mode': 'w',
1140         'label': 'Reference Field'},
1141        )
1142    prefix = ''
1143    reference = ''
1144    def prepare(self, datastructure, **kw): ###(
1145        """Prepare datastructure from datamodel."""
1146        datamodel = datastructure.getDataModel()
1147        v = datamodel[self.fields[0]]
1148        widget_id = self.getWidgetId()
1149        if v and type(v) is StringType:
1150            try:
1151                p,b,n = v.split('-')
1152                v = ScratchCardPin(p,b,n)
1153            except ValueError:
1154                v = ScratchCardPin(v,'','')
1155        if v:
1156            p = '%s' % v.p
1157            b = '%s' % v.b
1158            n = '%s' % v.n
1159        else:
1160            p = self.prefix
1161            if p.startswith('@'):
1162                p = getattr(self,self.prefix[1:])()
1163            b = n = ''
1164            v = ScratchCardPin(p,b,n)
1165        datastructure[widget_id] = v
1166        datastructure[widget_id+'_p'] = p
1167        datastructure[widget_id+'_b'] = b
1168        datastructure[widget_id+'_n'] = n
1169    ###)
1170
1171    def validate(self, datastructure, **kw): ###(
1172        """Validate datastructure and update datamodel."""
1173        s_logger = logging.getLogger('Widgets.ScratchcardPinWidget.validate')
1174        widget_id = self.getWidgetId()
1175        v = datastructure[widget_id]
1176        #import pdb;pdb.set_trace()
1177        err = 0
1178        mapping = {}
1179        prefix= self.prefix
1180        if prefix.startswith('@'):
1181            prefix= getattr(self,self.prefix[1:])()
1182        b = datastructure[widget_id+'_b'].strip()
1183        n = datastructure[widget_id+'_n'].strip()
1184        pins = self.portal_pins
1185        pin = "%(prefix)s%(b)s%(n)s" % vars()
1186        pin_str = "%(prefix)s-%(b)s-%(n)s" % vars()
1187        do = 1
1188        s_id = str(self.portal_membership.getAuthenticatedMember())
1189        if self.isStaff():
1190            do = 0
1191            err ='You are not a Student. PIN neither checked nor used.'
1192            s_logger.info('%s tried to use scratch card %s' % (s_id,pin_str))
1193        elif len(b) > 1 and b.find('-') > -1:
1194            do = 0
1195            err = 'PIN must not contain "-"'
1196            s_logger.info('%s entered invalid PIN  containing "-"' % (s_id))
1197        elif n.find('-') > -1:
1198            do = 0
1199            err = 'PIN must not contain "-"'
1200            s_logger.info('%s entered invalid PIN  containing "-"' % (s_id))
1201        elif len(n) != 10:
1202            do = 0
1203            err = 'Invalid PIN length'
1204            s_logger.info('%s entered invalid PIN with length %d' % (s_id,len(n)))
1205        elif self.reference == "":
1206            ref = s_id
1207        else:
1208            ref = datastructure[self.reference]
1209            if datastructure.errors:
1210                do = 0
1211                datastructure.setError(widget_id, 'PIN neither checked nor used.')
1212                s_logger.info('%s/%s entered wrong data together with PIN %s' % (s_id,ref,pin_str))
1213        while do:
1214            ok = pins.searchAndSetRecord(pin,ref,prefix)
1215            if ok < -2 or ok > 2:
1216                err = 'Unknown error, please report!'
1217                s_logger.info('%s/%s caused unknown error with PIN %s' % (s_id,ref,pin_str))
1218                break
1219            elif ok == -2:
1220                err = 'Service already is activated but with a different PIN.'
1221                s_logger.info('%s/%s repeatedly activated service but with different PIN %s' % (s_id,ref,pin_str))
1222                break
1223            elif ok == -1:
1224                err = 'Invalid PIN'
1225                s_logger.info('%s/%s entered invalid PIN %s' % (s_id,ref,pin_str))
1226                break
1227            if ok == 0:
1228                err = 'PIN already used'
1229                s_logger.info('%s/%s entered used PIN %s' % (s_id,ref,pin_str))
1230                break
1231            if ok >= 1:
1232                #import pdb;pdb.set_trace()
1233                if self.isStudent():
1234                    if self.reference == "jamb_reg_no":
1235                        err = "You are already logged in."
1236                        s_logger.info('%s/%s checked admission with PIN %s though logged in' % (s_id,ref,pin_str))
1237                        break
1238                    if ok == 1:
1239                        s_logger.info('%s/%s successfully used PIN %s' % (s_id,ref,pin_str))
1240                    else:
1241                        s_logger.info('%s/%s repeatedly used PIN %s' % (s_id,ref,pin_str))
1242                    break
1243                else:
1244                    student = getStudentByRegNo(self,ref)
1245                    s_logger.info('%s/%s successfully used PIN %s' % (s_id,ref,pin_str))
1246                if student is None:
1247                    err = "Student not found"
1248                    s_logger.info('%s not found in admission list' % (ref))
1249                    break
1250                s_id = student.getId()
1251                if ok == 2:
1252                    if self.reference == "jamb_reg_no":
1253                        if hasattr(self.portal_directories.students,s_id):
1254                            err = "Please login with your Student Id ${id} and 10-digit PIN."
1255                            mapping = {'id': s_id}
1256                            s_logger.info('%s/%s repeatedly checked admission with PIN %s' % (s_id,ref,pin_str))
1257                            break
1258                        else:
1259                            s_logger.info('%s/%s (non-member) repeatedly checked admission with PIN %s' % (s_id,ref,pin_str))
1260                    else:
1261                        err = "Unknown error"
1262                        s_logger.info('%s/%s repeatedly activated service with PIN %s' % (s_id,ref,pin_str))
1263                        break
1264                try:
1265                    student.getContent().makeStudentMember(s_id,password=pin[4:])
1266                    s_logger.info('%s/%s has been created using PIN %s' % (s_id,ref,pin_str))
1267                except:
1268                    err = "Please login with your Student Id ${id} and 10-digit PIN."
1269                    mapping = {'id': s_id}
1270                    s_logger.info('%s/%s could not be made a member with PIN %s' % (s_id,ref,pin_str))
1271                    break
1272            break
1273        if err:
1274            datastructure.setError(widget_id, err,mapping)
1275        else:
1276            datamodel = datastructure.getDataModel()
1277            datamodel[self.fields[0]] = ScratchCardPin(prefix,b,n)
1278            datastructure[widget_id] = ScratchCardPin(prefix,b,n)
1279            datastructure[widget_id+'_p'] = prefix
1280            datastructure[widget_id+'_b'] = b
1281            datastructure[widget_id+'_n'] = n
1282            datastructure['s_id'] = s_id
1283        return not err
1284
1285###)
1286
1287    def render(self, mode, datastructure, **kw): ###(
1288        """Render in mode from datastructure."""
1289        render_method = 'widget_scratch_card_pin_render'
1290        meth = getattr(self, render_method, None)
1291        if meth is None:
1292            raise RuntimeError("Unknown Render Method %s for widget type %s"
1293                               % (render_method, self.getId()))
1294
1295        # XXX AT: datastructure has to be set again here, in case we're in edit
1296        # or create mode, because a default value has to be provided.
1297        #import pdb;pdb.set_trace()
1298        datamodel = datastructure.getDataModel()
1299        v = datamodel[self.fields[0]]
1300        if v and type(v) is StringType:
1301            try:
1302                p,b,n = v.split('-')
1303                v = ScratchCardPin(p,b,n)
1304            except ValueError:
1305                v = ScratchCardPin(self.prefix,'XXX',v)
1306                pass
1307        if v:
1308            prefix= '%s' % v.p
1309            b = '%s' % v.b
1310            n = '%s' % v.n
1311        else:
1312            prefix= self.prefix
1313            if prefix.startswith('@'):
1314                prefix= getattr(self,self.prefix[1:])()
1315            b = n = ''
1316            v = ScratchCardPin(prefix,b,n)
1317        widget_id = self.getWidgetId()
1318        datastructure[widget_id] = v
1319        datastructure[widget_id+'_p'] = prefix
1320        datastructure[widget_id+'_b'] = b
1321        datastructure[widget_id+'_n'] = n
1322        return meth(mode=mode,
1323                    datastructure=datastructure,
1324                    )
1325    ###)
1326
1327InitializeClass(ScratchcardPinWidget)
1328widgetRegistry.register(ScratchcardPinWidget)
1329###)
1330
1331class PumePinWidget(ScratchcardPinWidget): ###(
1332    """ Pume Pin Widget"""
1333    meta_type = "Pume Pin Widget"
1334    catalog = "applicants_catalog"
1335    reference = ''
1336
1337    def prepare(self, datastructure, **kw): ###(
1338        """Prepare datastructure from datamodel."""
1339        datamodel = datastructure.getDataModel()
1340        #import pdb;pdb.set_trace()
1341        v = datamodel[self.fields[0]]
1342        widget_id = self.getWidgetId()
1343        if v and type(v) is StringType:
1344            try:
1345                p,b,n = v.split('-')
1346                v = ScratchCardPin(p,b,n)
1347            except ValueError:
1348                v = ScratchCardPin(v,'','')
1349        if v:
1350            p = '%s' % v.p
1351            b = '%s' % v.b
1352            n = '%s' % v.n
1353        else:
1354            p = self.prefix
1355            if p.startswith('@'):
1356                p = getattr(self,self.prefix[1:])()
1357            b = n = ''
1358            v = ScratchCardPin(p,b,n)
1359        datastructure[widget_id] = v
1360        datastructure[widget_id+'_p'] = p
1361        datastructure[widget_id+'_b'] = b
1362        datastructure[widget_id+'_n'] = n
1363    ###)
1364
1365    def validate(self, datastructure, **kw): ###(
1366        """Validate datastructure and update datamodel."""
1367        #import pdb;pdb.set_trace()
1368        s_logger = logging.getLogger('Widgets.ScratchcardPinWidget.validate')
1369        widget_id = self.getWidgetId()
1370        v = datastructure[widget_id]
1371        err = 0
1372        mapping = {}
1373        prefix= self.prefix
1374        if prefix.startswith('@'):
1375            prefix= getattr(self,self.prefix[1:])()
1376        b = datastructure[widget_id+'_b'].strip()
1377        n = datastructure[widget_id+'_n'].strip()
1378        pins = self.portal_pins
1379        pin = "%(prefix)s%(b)s%(n)s" % vars()
1380        pin_str = "%(prefix)s-%(b)s-%(n)s" % vars()
1381        member_id = str(self.portal_membership.getAuthenticatedMember())
1382        do = 1
1383        if self.isStaff():
1384            do = 0
1385            err ='You are not a Student. PIN neither checked nor used.'
1386            s_logger.info('%s tried to use scratch card %s' % (member_id,pin_str))
1387        elif len(b) > 1 and b.find('-') > -1:
1388            do = 0
1389            err = 'PIN must not contain "-"'
1390            s_logger.info('%s entered invalid PIN  containing "-"' % (member_id))
1391        elif n.find('-') > -1:
1392            do = 0
1393            err = 'PIN must not contain "-"'
1394            s_logger.info('%s entered invalid PIN  containing "-"' % (member_id))
1395        elif len(n) != 10:
1396            do = 0
1397            err = 'Invalid PIN length'
1398            s_logger.info('%s entered invalid PIN with length %d' % (member_id,len(n)))
1399        elif self.reference == "":
1400            ref = n
1401        else:
1402            ref = datastructure[self.reference]
1403            if datastructure.errors:
1404                do = 0
1405                datastructure.setError(widget_id, 'PIN neither checked nor used.')
1406                s_logger.info('%s/%s entered wrong data together with PIN %s' % (member_id,ref,pin_str))
1407        while do:
1408            ok = pins.searchAndSetRecord(pin,ref,prefix)
1409            if ok < -2 or ok > 2:
1410                err = 'Unknown error, please report!'
1411                s_logger.info('%s/%s caused unknown error with PIN %s' % (member_id,ref,pin_str))
1412                break
1413            elif ok == -2:
1414                err = 'Service is already activated but with a different PIN.'
1415                s_logger.info('%s/%s repeatedly activated service but with different PIN %s' % (member_id,ref,pin_str))
1416                break
1417            elif ok == -1:
1418                err = 'Invalid PIN'
1419                s_logger.info('%s/%s entered invalid PIN %s' % (member_id,ref,pin_str))
1420                break
1421            if ok == 0:
1422                err = 'PIN already used'
1423                s_logger.info('%s/%s entered used PIN %s' % (member_id,ref,pin_str))
1424                break
1425            if ok >= 1:
1426                #screening_type = self.REQUEST.form.get('screening_type','unknown')
1427                #screening_type = datastructure['screening_type']               
1428               
1429                if self.REQUEST.traverse_subpath:
1430                    screening_type_request = self.REQUEST.traverse_subpath[0]
1431                else:
1432                    screening_type_request = 'manage'
1433                if self.isStudent():
1434                    err = "You are a student!"
1435                    s_logger.info('%s/%s applied for screening test with PIN %s' % (member_id,ref,pin_str))
1436                    break
1437                elif datastructure.has_key('record'):
1438                    applicant = datastructure['record']
1439                   
1440                    if applicant.screening_type != screening_type_request and screening_type_request != 'manage':
1441                        err = "You used the wrong application form!"
1442                        s_logger.info('%s tried to use %s application form but has applied for %s' % (ref,
1443                                                                                           screening_type_request,
1444                                                                                           applicant.screening_type))
1445                        break
1446                    if not applicant.pin:
1447                        s_logger.info('%s successfully used PIN %s' % (ref,pin_str))
1448                        d = {}
1449                        d['reg_no'] = applicant.reg_no
1450                        d['pin'] = pin_str
1451                        #d['screening_type'] = screening_type
1452                        d['status'] = 'entered'
1453                        getattr(self,self.catalog).modifyRecord(**d)
1454                    elif applicant.pin != pin_str:
1455                        s_logger.info('%s/%s tried to enter application record with different PIN %s' % (member_id,ref,pin_str))
1456                    elif applicant.pin == pin_str:
1457                        s_logger.info('%s/%s repeatedly entered application record with PIN %s' % (member_id,ref,pin_str))
1458                else:
1459                    datastructure['reg_no'] = ref
1460                    res = self.applicants_catalog(reg_no = ref)
1461                    if not res:
1462                        s_logger.info('%s successfully used PIN %s' % (ref,pin_str))
1463                        d = {}
1464                        d['reg_no'] = ref
1465                        d['pin'] = pin_str
1466                        d['status'] = 'entered'
1467                        d['screening_type'] = screening_type_request
1468                        self.applicants_catalog.addRecord(**d)
1469                    else:
1470                        s_logger.info('%s/%s repeatedly entered application record with PIN %s' % (ref,ref,pin_str))
1471            break
1472        if err:
1473            datastructure.setError(widget_id, err,mapping)
1474        else:
1475            datamodel = datastructure.getDataModel()
1476            datamodel[self.fields[0]] = ScratchCardPin(prefix,b,n)
1477            datastructure[widget_id] = ScratchCardPin(prefix,b,n)
1478            datastructure[widget_id+'_p'] = prefix
1479            datastructure[widget_id+'_b'] = b
1480            datastructure[widget_id+'_n'] = n
1481        return not err
1482    ###)
1483
1484    def render(self, mode, datastructure, **kw): ###(
1485        """Render in mode from datastructure."""
1486        render_method = 'widget_scratch_card_pin_render'
1487        meth = getattr(self, render_method, None)
1488        if meth is None:
1489            raise RuntimeError("Unknown Render Method %s for widget type %s"
1490                               % (render_method, self.getId()))
1491
1492        # XXX AT: datastructure has to be set again here, in case we're in edit
1493        # or create mode, because a default value has to be provided.
1494        #import pdb;pdb.set_trace()
1495        datamodel = datastructure.getDataModel()
1496        v = datamodel[self.fields[0]]
1497        #import pdb;pdb.set_trace()
1498        if v and type(v) is StringType:
1499            try:
1500                p,b,n = v.split('-')
1501                v = ScratchCardPin(p,b,n)
1502            except ValueError:
1503                v = ScratchCardPin(self.prefix,'XXX',v)
1504                pass
1505        if v:
1506            prefix= '%s' % v.p
1507            b = '%s' % v.b
1508            n = '%s' % v.n
1509        else:
1510            prefix= self.prefix
1511            if prefix.startswith('@'):
1512                prefix= getattr(self,self.prefix[1:])()
1513            b = n = ''
1514            v = ScratchCardPin(prefix,b,n)
1515        widget_id = self.getWidgetId()
1516        datastructure[widget_id] = v
1517        datastructure[widget_id+'_p'] = prefix
1518        datastructure[widget_id+'_b'] = b
1519        datastructure[widget_id+'_n'] = n
1520        return meth(mode=mode,
1521                    datastructure=datastructure,
1522                    )
1523    ###)
1524
1525InitializeClass(PumePinWidget)
1526widgetRegistry.register(PumePinWidget)
1527###)
1528
1529class WAeUPImageWidget(CPSImageWidget): ###(
1530    """Photo widget."""
1531    meta_type = 'WAeUP Image Widget'
1532
1533    def render(self, mode, datastructure, **kw):
1534        render_method = 'widget_waeup_image_render'
1535        meth = getattr(self, render_method, None)
1536        if meth is None:
1537            raise RuntimeError("Unknown Render Method %s for widget type %s"
1538                               % (render_method, self.getId()))
1539        img_info = self.getImageInfo(datastructure)
1540        return meth(mode=mode, datastructure=datastructure, **img_info)
1541
1542InitializeClass(WAeUPImageWidget)
1543
1544widgetRegistry.register(WAeUPImageWidget)
1545###)
1546
1547class ApplicationImageWidget(CPSImageWidget): ###(
1548    """Image widget with filesystem storage."""
1549    meta_type = 'Application Image Widget'
1550    _properties = CPSImageWidget._properties +\
1551    (
1552     {'id': 'path', 'type': 'string', 'mode': 'w',
1553      'label': 'Relative Path'},
1554     {'id': 'id_field', 'type': 'string', 'mode': 'w',
1555      'label': 'Field to build the id'},
1556    )
1557    path = "images"
1558    storage_path = "%s/import/%s" % (i_home,path)
1559    id_field = "reg_no"
1560
1561    def getImageInfo(self, datastructure): ###(
1562        """Get the file info from the datastructure."""
1563        widget_id = self.getWidgetId()
1564        if  datastructure.has_key(widget_id):
1565            fileupload = datastructure[widget_id]
1566            dm = datastructure.getDataModel()
1567            field_id = self.fields[0]
1568            screening_type = datastructure.get('screening_type')
1569            current_filename = "%s_%s.jpg" % (datastructure[self.id_field],
1570                                            field_id,)
1571            base_path = os.path.join(screening_type,current_filename)
1572            content_url = os.path.join('viewimage',self.path,base_path)
1573            file_path = os.path.join(self.storage_path,base_path)
1574            #import pdb; pdb.set_trace()
1575        else:
1576            file_path = "XXX"
1577        # read the file from the filesystem
1578        if not os.path.exists(file_path):
1579            height = -1
1580            width = -1
1581            empty_file = True
1582            session_file = False
1583            current_filename = ''
1584            content_url = ''
1585            size = 0
1586            mimetype = ''
1587            last_modified = ''
1588            height = ''
1589            width = ''
1590
1591        else:
1592            image = open(file_path)
1593            from OFS.Image import getImageInfo as getImageInfoOFS
1594            image.seek(0)
1595            data = image.read(2000)
1596            size = len(data)
1597            empty_file = size == 0
1598            session_file = False
1599            last_modified = ''
1600            image.close()
1601            mimetype, width, height = getImageInfoOFS(data)
1602
1603            if width < 0:
1604                width = None
1605            if height < 0:
1606                height = None
1607
1608            if (self.allow_resize
1609                and height is not None
1610                and width  is not None):
1611                z_w = z_h = 1
1612                h = int(self.display_height)
1613                w = int(self.display_width)
1614                if w and h:
1615                    if w < width:
1616                        z_w = w / float(width)
1617                    if h < height:
1618                        z_h = h / float(height)
1619                    zoom = min(z_w, z_h)
1620                    width = int(zoom * width)
1621                    height = int(zoom * height)
1622                #import pdb;pdb.set_trace()
1623        image_info = {
1624            'empty_file': empty_file,
1625            'session_file': session_file,
1626            'current_filename': current_filename,
1627            'size': size,
1628            'last_modified': last_modified,
1629            'content_url': content_url,
1630            'mimetype': mimetype,
1631            }
1632        title = image_info['current_filename']
1633        alt = title or ''
1634        #height = int(self.display_height)
1635        #width = int(self.display_width)
1636        if height is None or width is None:
1637            tag = renderHtmlTag('img', src=image_info['content_url'],
1638                                alt=alt, title=title)
1639        else:
1640            tag = renderHtmlTag('img', src=image_info['content_url'],
1641                                width=str(width), height=str(height),
1642                                alt=alt, title=title)
1643
1644        image_info['height'] = height
1645        image_info['width'] = width
1646        image_info['image_tag'] = tag
1647        return image_info
1648    ###)
1649
1650    def checkFileName(self, filename, mimetype):
1651        return '', {}
1652        if mimetype and mimetype.startswith('image'):
1653            return '', {}
1654        return 'cpsschemas_err_image', {}
1655
1656    def prepare(self, datastructure, **kw): ###(
1657        """Prepare datastructure from datamodel."""
1658        datamodel = datastructure.getDataModel()
1659        widget_id = self.getWidgetId()
1660        file_name = datamodel[self.fields[0]]
1661        #import pdb; pdb.set_trace()
1662        if self.allow_resize:
1663            datastructure[self.getWidgetId() + '_resize'] = ''
1664        screening_type = datamodel.get('screening_type',None)
1665        if not screening_type:
1666            screening_type = self.REQUEST.form.get('screening_type','pume')
1667        datastructure["screening_type"] = screening_type
1668        datastructure[widget_id] = file_name
1669        datastructure[widget_id + '_choice'] = 'change'
1670        title = 'Passport Foto'
1671        datastructure[widget_id + '_filename'] = title
1672    ###)
1673
1674    def validate(self, datastructure, **kw): ###(
1675        """Update datamodel from user data in datastructure.
1676        """
1677        logger = logging.getLogger('Widgets.ApplicationImageWidget.validate')
1678        datamodel = datastructure.getDataModel()
1679        field_id = self.fields[0]
1680        widget_id = self.getWidgetId()
1681        store = False
1682        fileupload = None
1683        mimetype = None
1684        old_file = datamodel[field_id]
1685        # if old_file is not None:
1686        #     old_filename = old_file.title
1687        # else:
1688        #     old_filename = ''
1689        choice = datastructure[widget_id+'_choice']
1690        fileupload = datastructure[widget_id]
1691        is_upload = isinstance(fileupload, FileUpload)
1692        #import pdb; pdb.set_trace()
1693        if not is_upload and not datamodel[field_id]:
1694            if self.is_required:
1695                return self.validateError('Picture upload required', {},
1696                                          datastructure)
1697        if choice == 'delete':
1698            if self.is_required:
1699                return self.validateError('cpsschemas_err_required', {},
1700                                          datastructure)
1701            datamodel[field_id] = None
1702        elif choice == 'keep':
1703            fileupload = datastructure[widget_id]
1704            if isinstance(fileupload, PersistableFileUpload):
1705                # Keeping something from the session means we
1706                # actually want to store it.
1707                store = True
1708            # else:
1709            #     # Nothing to change, don't pollute datastructure
1710            #     # with something costly already stored, which therefore
1711            #     # doesn't need to be kept in the session.
1712            #     self.unprepare(datastructure)
1713        elif choice == 'change' and is_upload:
1714            if not fileupload:
1715                return self.validateError('cpsschemas_err_file_empty', {},
1716                                          datastructure)
1717            if not isinstance(fileupload, FileUpload):
1718                return self.validateError('cpsschemas_err_file', {},
1719                                          datastructure)
1720            fileupload.seek(0, 2) # end of file
1721            size = fileupload.tell()
1722            if not size:
1723                return self.validateError('cpsschemas_err_file_empty', {},
1724                                          datastructure)
1725            if self.size_max and size > self.size_max:
1726                max_size_str = self.getHumanReadableSize(self.size_max)
1727                err = 'This file is too big, the allowed max size is ${max_size}'
1728                logger.info('%s tried to upload picture with size %dk' %(datastructure['reg_no'],int(size)/1000) )
1729                err_mapping = {'max_size': max_size_str}
1730                return self.validateError(err, err_mapping, datastructure)
1731            store = True
1732
1733
1734        # Find filename
1735        if is_upload and store:
1736            ext ='jpg'
1737            screening_type = datastructure.get('screening_type')
1738            filename = "%s_%s.%s" % (datastructure[self.id_field],
1739                                     self.getWidgetId(),
1740                                     ext)
1741            datamodel[field_id] = filename
1742            registry = getToolByName(self, 'mimetypes_registry')
1743            mimetype = registry.lookupExtension(filename.lower())
1744            if mimetype is not None:
1745                mimetype = str(mimetype) # normalize
1746            file = self.makeFile(filename, fileupload, datastructure)
1747            # Fixup mimetype
1748            if mimetype and file.content_type != mimetype:
1749                file.content_type = mimetype
1750            # Store the file in the filesystem
1751            #import pdb;pdb.set_trace()
1752            base_path = os.path.join(self.storage_path, screening_type)
1753            if not os.path.exists(base_path):
1754                os.mkdir(base_path)
1755            full_path = os.path.join(base_path, filename)
1756            pict = open(full_path,"w")
1757            fileupload.seek(0)
1758            pict.write(fileupload.read())
1759            pict.close()
1760
1761
1762        return True
1763
1764###)
1765
1766    def render(self, mode, datastructure, **kw): ###(
1767        render_method = 'widget_passport_render'
1768        meth = getattr(self, render_method, None)
1769        if meth is None:
1770            raise RuntimeError("Unknown Render Method %s for widget type %s"
1771                               % (render_method, self.getId()))
1772        img_info = self.getImageInfo(datastructure)
1773        return meth(mode=mode, datastructure=datastructure, **img_info)
1774    ###)
1775
1776InitializeClass(ApplicationImageWidget)
1777
1778widgetRegistry.register(ApplicationImageWidget)
1779###)
1780
1781class FileImageWidget(CPSImageWidget): ###(
1782    """Image widget with filesystem storage."""
1783    meta_type = 'File Image Widget'
1784    _properties = CPSImageWidget._properties +\
1785    (
1786     {'id': 'path', 'type': 'string', 'mode': 'w',
1787      'label': 'Relative Path'},
1788     {'id': 'id_field', 'type': 'string', 'mode': 'w',
1789      'label': 'Field to build the id'},
1790     {'id': 'show_image', 'type': 'boolean', 'mode': 'w',
1791      'label': 'Show Image'},
1792    )
1793    path = "images"
1794    storage_path = "%s/%s" % (i_home,path)
1795    id_field = ""
1796    show_image = False
1797
1798    def getImageInfo(self, datastructure): ###(
1799        """Get the file info from the datastructure."""
1800        #import pdb; pdb.set_trace()
1801        widget_id = self.getWidgetId()
1802        if  datastructure.has_key(widget_id):
1803            fileupload = datastructure[widget_id]
1804            dm = datastructure.getDataModel()
1805            field_id = self.fields[0]
1806            if self.id_field == "":
1807                student_id = self.getStudentId()
1808            else:
1809                student_id = datastructure[self.id_field]
1810            content_url = os.path.join(self.portal_url(),
1811                                       "viewimage",
1812                                       self.path,
1813                                       student_id,
1814                                       "%s_%s.jpg" % (self.getWidgetId(),student_id),
1815                                       )
1816            image_title = "%s_%s.jpg" % (widget_id,student_id)
1817            current_filename = os.path.join(student_id,
1818                                            image_title)
1819            file_path = os.path.join(self.storage_path,
1820                                     current_filename)
1821        else:
1822            file_path = "XXX"
1823            image_title = ""
1824        # read the file from the filesystem
1825        if not os.path.exists(file_path):
1826            height = -1
1827            width = -1
1828            empty_file = True
1829            session_file = False
1830            current_filename = ''
1831            content_url = ''
1832            size = 0
1833            mimetype = ''
1834            last_modified = ''
1835            height = ''
1836            width = ''
1837        else:
1838            image = open(file_path)
1839            from OFS.Image import getImageInfo as getImageInfoOFS
1840            image.seek(0)
1841            data = image.read(2000)
1842            size = len(data)
1843            empty_file = size == 0
1844            session_file = False
1845            last_modified = ''
1846            image.close()
1847            mimetype, width, height = getImageInfoOFS(data)
1848            registry = getToolByName(self, 'mimetypes_registry')
1849            mimetype = (registry.lookupExtension(current_filename.lower()) or
1850                        registry.lookupExtension('file.bin'))
1851            if width < 0:
1852                width = None
1853            if height < 0:
1854                height = None
1855
1856            if (self.allow_resize
1857                and height is not None
1858                and width  is not None):
1859                z_w = z_h = 1
1860                h = int(self.display_height)
1861                w = int(self.display_width)
1862                if w and h:
1863                    if w < width:
1864                        z_w = w / float(width)
1865                    if h < height:
1866                        z_h = h / float(height)
1867                    zoom = min(z_w, z_h)
1868                    width = int(zoom * width)
1869                    height = int(zoom * height)
1870                #import pdb;pdb.set_trace()
1871        title = image_title
1872        image_info = {
1873            'empty_file': empty_file,
1874            'session_file': session_file,
1875            'current_filename': title,
1876            'size': size,
1877            'last_modified': last_modified,
1878            'content_url': content_url,
1879            'mimetype': mimetype,
1880            }
1881        alt = title or ''
1882        #height = int(self.display_height)
1883        #width = int(self.display_width)
1884        if height is None or width is None:
1885            tag = renderHtmlTag('img', src=image_info['content_url'],
1886                                alt=alt, title=title)
1887        else:
1888            tag = renderHtmlTag('img', src=image_info['content_url'],
1889                                width=str(width), height=str(height),
1890                                alt=alt, title=title)
1891
1892        image_info['height'] = height
1893        image_info['width'] = width
1894        image_info['image_tag'] = tag
1895        image_info['show_image'] = self.show_image
1896        return image_info
1897    ###)
1898
1899    def checkFileName(self, filename, mimetype):
1900        return '', {}
1901        if mimetype and mimetype.startswith('image'):
1902            return '', {}
1903        return 'cpsschemas_err_image', {}
1904
1905    def prepare(self, datastructure, **kw): ###(
1906        """Prepare datastructure from datamodel."""
1907        datamodel = datastructure.getDataModel()
1908        widget_id = self.getWidgetId()
1909        file_name = datamodel[self.fields[0]]
1910        if self.id_field == "":
1911            student_id = self.getStudentId()
1912        else:
1913            student_id = datastructure[self.id_field]
1914        if student_id is not None:
1915            student_path = os.path.join(self.storage_path,student_id)
1916            if not os.path.exists(student_path):
1917                self.waeup_tool.moveImagesToFS(student_id)
1918        if self.allow_resize:
1919            datastructure[self.getWidgetId() + '_resize'] = ''
1920        datastructure[widget_id] = file_name
1921        datastructure[widget_id + '_choice'] = 'change'
1922        title = 'Passport Foto'
1923        datastructure[widget_id + '_filename'] = title
1924    ###)
1925
1926    def validate(self, datastructure, **kw): ###(
1927        """Update datamodel from user data in datastructure.
1928        """
1929        logger = logging.getLogger('Widgets.FileImageWidget.validate')
1930        datamodel = datastructure.getDataModel()
1931        field_id = self.fields[0]
1932        widget_id = self.getWidgetId()
1933        store = False
1934        fileupload = None
1935        mimetype = None
1936        old_file = datamodel[field_id]
1937        # if old_file is not None:
1938        #     old_filename = old_file.title
1939        # else:
1940        #     old_filename = ''
1941        choice = datastructure[widget_id+'_choice']
1942        fileupload = datastructure[widget_id]
1943        is_upload = isinstance(fileupload, FileUpload)
1944        #import pdb; pdb.set_trace()
1945        if not is_upload and not datamodel[field_id]:
1946            if self.is_required:
1947                return self.validateError('Picture upload required', {},
1948                                          datastructure)
1949        if self.id_field == "":
1950            student_id = self.getStudentId()
1951        else:
1952            student_id = datastructure[self.id_field]
1953        if choice == 'delete':
1954            if self.is_required:
1955                return self.validateError('cpsschemas_err_required', {},
1956                                          datastructure)
1957            ext ='jpg'
1958            filename = "%s_%s.%s" % (self.getWidgetId(),
1959                                     student_id,
1960                                     ext)
1961            # Remove the file in the filesystem
1962            student_path = os.path.join(self.storage_path,student_id)
1963            full_path = os.path.join(student_path, filename)
1964            if os.path.exists(full_path):
1965                os.remove(full_path)
1966            datamodel[field_id] = None
1967        elif choice == 'keep':
1968            fileupload = datastructure[widget_id]
1969            if isinstance(fileupload, PersistableFileUpload):
1970                # Keeping something from the session means we
1971                # actually want to store it.
1972                store = True
1973            # else:
1974            #     # Nothing to change, don't pollute datastructure
1975            #     # with something costly already stored, which therefore
1976            #     # doesn't need to be kept in the session.
1977            #     self.unprepare(datastructure)
1978        elif choice == 'change' and is_upload:
1979            if not fileupload:
1980                return self.validateError('cpsschemas_err_file_empty', {},
1981                                          datastructure)
1982            if not isinstance(fileupload, FileUpload):
1983                return self.validateError('cpsschemas_err_file', {},
1984                                          datastructure)
1985            fileupload.seek(0, 2) # end of file
1986            size = fileupload.tell()
1987            if not size:
1988                return self.validateError('cpsschemas_err_file_empty', {},
1989                                          datastructure)
1990            if self.size_max and size > self.size_max:
1991                max_size_str = self.getHumanReadableSize(self.size_max)
1992                err = 'This file is too big, the allowed max size is ${max_size}'
1993                logger.info('%s tried to upload picture with size %dk' %(datastructure['reg_no'],int(size)/1000) )
1994                err_mapping = {'max_size': max_size_str}
1995                return self.validateError(err, err_mapping, datastructure)
1996            store = True
1997
1998
1999        # Find filename
2000        if is_upload and store:
2001            ext ='jpg'
2002            filename = "%s_%s.%s" % (self.getWidgetId(),
2003                                     student_id,
2004                                     ext)
2005            datamodel[field_id] = filename
2006            registry = getToolByName(self, 'mimetypes_registry')
2007            mimetype = registry.lookupExtension(filename.lower())
2008            if mimetype is not None:
2009                mimetype = str(mimetype) # normalize
2010            file = self.makeFile(filename, fileupload, datastructure)
2011            # Fixup mimetype
2012            if mimetype and file.content_type != mimetype:
2013                file.content_type = mimetype
2014            # Store the file in the filesystem
2015            student_path = os.path.join(self.storage_path,student_id)
2016            if not os.path.exists(student_path):
2017                os.mkdir(student_path)
2018            full_path = os.path.join(student_path, filename)
2019            #import pdb;pdb.set_trace()
2020            pict = open(full_path,"w")
2021            fileupload.seek(0)
2022            pict.write(fileupload.read())
2023            pict.close()
2024        return True
2025
2026###)
2027
2028    def render(self, mode, datastructure, **kw): ###(
2029        render_method = 'widget_image_render'
2030        meth = getattr(self, render_method, None)
2031        #import pdb;pdb.set_trace()
2032        if meth is None:
2033            raise RuntimeError("Unknown Render Method %s for widget type %s"
2034                               % (render_method, self.getId()))
2035        img_info = self.getImageInfo(datastructure)
2036        return meth(mode=mode, datastructure=datastructure, **img_info)
2037    ###)
2038
2039InitializeClass(FileImageWidget)
2040
2041widgetRegistry.register(FileImageWidget)
2042###)
2043
2044###########
2045
Note: See TracBrowser for help on using the repository browser.