Context navigation

source: WAeUP_SRP/trunk/Widgets.py @ 5505

Last change on this file since 5505 was 5505, checked in by Henrik Bettermann, 14 years ago
implement Phone Widget and apply to application, first_time_login and personal_edit student front end
Property svn:keywords set to `Id`
File size: 99.1 KB

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

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

Download in other formats: