Context navigation

source: WAeUP_SRP/base/Widgets.py @ 3203

Last change on this file since 3203 was 3200, checked in by Henrik Bettermann, 17 years ago
resolve #486
Property svn:keywords set to `Id`
File size: 81.1 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: