source: WAeUP_SRP/base/Widgets.py @ 2709

Last change on this file since 2709 was 2709, checked in by joachim, 17 years ago

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