Context navigation

source: WAeUP_SRP/trunk/Widgets.py @ 1907

Last change on this file since 1907 was 1907, checked in by joachim, 18 years ago
error messages with variables cause no modifications to zodb
Property svn:keywords set to `Id`
File size: 43.5 KB

Rev	Line
[47]	1	#-- mode: python; mode: fold --
[990]	2	# $Id: Widgets.py 1907 2007-06-16 14:09:52Z joachim $
[295]	3	from cgi import escape
[502]	4	from types import *
[22]	5	from Globals import InitializeClass
[199]	6	##from Products.CPSSchemas.Widget import CPSWidgetType
[295]	7	from Products.CMFCore.utils import getToolByName
[1772]	8	from Products.CPSSchemas.BasicWidgets import CPSBooleanWidget, CPSWidget, CPSStringWidget, CPSEmailWidget,CPSImageWidget
[295]	9	from Products.CPSSchemas.BasicWidgets import renderHtmlTag,CPSSelectWidget, CPSStringWidget
[22]	10	from Products.CPSSchemas.ExtendedWidgets import CPSDateTimeWidget
[199]	11	from Products.CPSSchemas.Widget import widgetRegistry
	12	##from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry
[22]	13	from DateTime.DateTime import DateTime
	14	from AccessControl import getSecurityManager
[502]	15	from Products.WAeUP_SRP.Students import getStudentByRegNo
[1747]	16	from Products.WAeUP_SRP.Academics import makeCertificateCode
[22]	17	from re import compile
[952]	18	import logging
[22]	19
[952]	20	#from zLOG import LOG, DEBUG
[22]	21
[295]	22	class CPSSelectWidgetForRecord(CPSSelectWidget): ###(
	23	"""Select widget. with record names"""
	24	meta_type = 'Select Widget for Records'
	25
	26	field_types = ('CPS String Field',)
	27	field_inits = ({'is_searchabletext': 1,},)
	28
	29	_properties = CPSSelectWidget._properties + (
	30	{'id': 'record_id', 'type': 'string', 'mode': 'w',
	31	'label': 'Record Id', 'is_required' : 1},
	32	)
	33
	34	def render(self, mode, datastructure, **kw):
	35	"""Render in mode from datastructure."""
	36	value = datastructure[self.getWidgetId()]
	37	vocabulary = self._getVocabulary(datastructure)
	38	portal = getToolByName(self, 'portal_url').getPortalObject()
	39	cpsmcat = portal.translation_service
	40	if mode == 'view':
	41	if self.translated:
	42	return escape(cpsmcat(vocabulary.getMsgid(value, value)).encode('ISO-8859-15', 'ignore'))
	43	else:
	44	return escape(vocabulary.get(value, value))
	45	elif mode == 'edit':
	46	html_widget_id = self.getHtmlWidgetId()
[444]	47	res = renderHtmlTag('select',
	48	name='%s.%s:records' % (self.record_id,html_widget_id),
[295]	49	id=html_widget_id)
	50	in_selection = 0
	51	for k, v in vocabulary.items():
	52	if self.translated:
	53	kw = {'value': k,
	54	'contents': cpsmcat(vocabulary.getMsgid(k, k)).encode('ISO-8859-15', 'ignore')
	55	}
	56	else:
	57	kw = {'value': k, 'contents': v}
	58	if value == k:
	59	kw['selected'] = 'selected'
	60	in_selection = 1
	61	res += renderHtmlTag('option', **kw)
	62	if value and not in_selection:
	63	kw = {'value': value, 'contents': 'invalid: '+ str(value),
	64	'selected': 'selected'}
	65	res += renderHtmlTag('option', **kw)
	66	res += '</select>'
	67	return res
	68	raise RuntimeError('unknown mode %s' % mode)
	69
	70	InitializeClass(CPSSelectWidgetForRecord)
	71
	72	widgetRegistry.register(CPSSelectWidgetForRecord)
	73
	74	###)
	75
[373]	76	class CPSStringWidgetForRecord(CPSStringWidget): ###(
[295]	77	"""String widget."""
	78	meta_type = 'String Widget For Record'
	79
	80	field_types = ('CPS String Field',)
	81	field_inits = ({'is_searchabletext': 1,},)
	82	_properties = CPSStringWidget._properties + (
	83	{'id': 'record_id', 'type': 'string', 'mode': 'w',
	84	'label': 'Record Id', 'is_required' : 1},
	85	)
	86
	87	def render(self, mode, datastructure, **kw):
	88	"""Render in mode from datastructure."""
	89	value = datastructure[self.getWidgetId()]
	90	if mode == 'view':
	91	return escape(value)
	92	elif mode == 'edit':
	93	# XXX TODO should use an other name than kw !
	94	# XXX change this everywhere
	95	html_widget_id = self.getHtmlWidgetId()
	96	kw = {'type': 'text',
	97	'id' : html_widget_id,
[444]	98	'name': '%s.%s:records' % (self.record_id,html_widget_id),
[295]	99	'value': escape(value),
	100	'size': self.display_width,
	101	}
	102	if self.size_max:
	103	kw['maxlength'] = self.size_max
	104	return renderHtmlTag('input', **kw)
	105	raise RuntimeError('unknown mode %s' % mode)
	106
	107	InitializeClass(CPSStringWidgetForRecord)
	108
	109	widgetRegistry.register(CPSStringWidgetForRecord)
	110
[373]	111	###)
	112
	113	class CertificateCourseIdWidget(CPSStringWidget): ###(
	114	""" CertificateCourseId Widget"""
	115	meta_type = "CertificateCourseId Widget"
[444]	116
[373]	117	def validate(self, datastructure, **kw):
	118	"""Validate datastructure and update datamodel."""
[444]	119
[373]	120	valid = CPSStringWidget.validate(self, datastructure, **kw)
	121	if not valid:
	122	return 0
	123	else:
	124	widget_id = self.getWidgetId()
	125	value = datastructure[widget_id].upper()
	126	err = 0
	127	c_ids = [c.id for c in self.portal_catalog({'meta_type': "Course"})]
[381]	128	if hasattr(self.aq_parent,value):
[1891]	129	err = 'Course already exists'
[381]	130	elif value not in c_ids:
[1891]	131	err = 'Course does not exist'
[373]	132	if err:
	133	datastructure.setError(widget_id, err)
	134	else:
	135	datamodel = datastructure.getDataModel()
	136	datamodel[self.fields[0]] = value
[444]	137
[373]	138	return not err
	139
	140	InitializeClass(CertificateCourseIdWidget)
	141
	142	widgetRegistry.register(CertificateCourseIdWidget)
[551]	143	###)
[373]	144
[551]	145	class CourseIdWidget(CPSStringWidget): ###(
	146	""" CourseId Widget"""
	147	meta_type = "CourseId Widget"
	148
	149	def validate(self, datastructure, **kw):
	150	"""Validate datastructure and update datamodel."""
	151
	152	valid = CPSStringWidget.validate(self, datastructure, **kw)
	153	if not valid:
	154	return 0
	155	else:
	156	widget_id = self.getWidgetId()
	157	value = datastructure[widget_id].upper()
	158	err = 0
	159	res = self.portal_catalog(meta_type= "Course",id = value)
	160	if len(res) > 0:
[1891]	161	err = 'Course already exists'
[551]	162	if err:
	163	datastructure.setError(widget_id, err)
	164	else:
	165	datamodel = datastructure.getDataModel()
	166	datamodel[self.fields[0]] = value
	167
	168	return not err
	169
	170	InitializeClass(CourseIdWidget)
	171
	172	widgetRegistry.register(CourseIdWidget)
	173
	174
[373]	175	###)
	176
[1820]	177	class WAeUPStudyModeWidget(CPSSelectWidget): ###(
	178	"""WAeUP StudyMode widget."""
	179	meta_type = 'WAeUP StudyMode Widget'
	180	vocabulary = 'entry_modes'
	181
	182	def _getStudyModes(self):
	183	voc = getattr(self.portal_vocabularies,self.vocabulary)
	184	d = {}
	185	for k,v in voc.items():
	186	d[k] = v
	187	return d
	188
	189	def validate(self, datastructure, **kw):
	190	"""Validate datastructure and update datamodel."""
	191	widget_id = self.getWidgetId()
	192	value = datastructure[widget_id]
	193	try:
	194	v = str(value)
	195	except ValueError:
	196	datastructure.setError(widget_id, "'%s' not a valid session key" % value)
	197	return 0
	198	studymodes = self._getStudyModes()
	199	if not value:
[1836]	200	v = value = 'ume_ft'
[1820]	201	#import pdb;pdb.set_trace()
	202	if not studymodes.has_key(value):
	203	datastructure.setError(widget_id, "'%s' not a valid session key" % v)
	204	return 0
	205	if self.is_required and not len(v):
	206	datastructure.setError(widget_id, "session key required")
	207	return 0
	208
	209	datamodel = datastructure.getDataModel()
	210	datamodel[self.fields[0]] = v
	211	return 1
	212
	213	def render(self, mode, datastructure, **kw):
	214	"""Render in mode from datastructure."""
	215	value = datastructure[self.getWidgetId()]
	216	studymodes = self._getStudyModes()
	217	if mode == 'view':
	218	return escape(studymodes.get(value, value))
	219	elif mode == 'edit':
	220	html_widget_id = self.getHtmlWidgetId()
	221	res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
	222	in_selection = 0
	223	vocabulary_items = studymodes.items()
	224	if self.sorted:
	225	vocabulary_items.sort(key=operator.itemgetter(1))
	226	for k, v in vocabulary_items:
	227	kw = {'value': k, 'contents': v}
	228	if value == k:
	229	kw['selected'] = 'selected'
	230	in_selection = 1
	231	res += renderHtmlTag('option', **kw)
	232	if value and not in_selection:
	233	kw = {'value': value, 'contents': 'invalid: '+ str(value),
	234	'selected': 'selected'}
	235	res += renderHtmlTag('option', **kw)
	236	res += '</select>'
	237	return res
	238	raise RuntimeError('unknown mode %s' % mode)
	239
	240	InitializeClass(WAeUPStudyModeWidget)
	241
	242	widgetRegistry.register(WAeUPStudyModeWidget)
	243
	244	###)
	245
[1804]	246	class WAeUPSessionWidget(CPSSelectWidget): ###(
	247	"""WAeUP Session widget."""
	248	meta_type = 'WAeUP Session Widget'
	249
	250	def _getSessions(self):
	251	current_year = DateTime().year()
	252	d = {'xx': 'unknown'}
	253	for y in range(current_year - 9,current_year + 1):
	254	d['%s' % str(y)[-2:]] = '%4d/%4d' % (y,y+1)
	255	return d
	256
	257	def validate(self, datastructure, **kw):
	258	"""Validate datastructure and update datamodel."""
	259	widget_id = self.getWidgetId()
	260	value = datastructure[widget_id]
	261	try:
	262	v = str(value)
	263	except ValueError:
	264	datastructure.setError(widget_id, "'%s' not a valid session key" % value)
	265	return 0
[1805]	266
[1804]	267	if len(v) == 1:
	268	v = value = '0%c' % v
	269	elif not value:
	270	v = value = self.getSessionId()[-2:]
	271	#import pdb;pdb.set_trace()
	272	sessions = self._getSessions()
	273	if not sessions.has_key(value):
	274	datastructure.setError(widget_id, "'%s' not a valid session key" % v)
	275	return 0
	276	if self.is_required and not len(v):
	277	datastructure.setError(widget_id, "session key required")
	278	return 0
	279
	280	datamodel = datastructure.getDataModel()
	281	datamodel[self.fields[0]] = v
	282	return 1
	283
	284	def render(self, mode, datastructure, **kw):
	285	"""Render in mode from datastructure."""
	286	value = datastructure[self.getWidgetId()]
	287	sessions = self._getSessions()
	288	if mode == 'view':
	289	return escape(sessions.get(value, value))
	290	elif mode == 'edit':
	291	html_widget_id = self.getHtmlWidgetId()
	292	res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
	293	in_selection = 0
	294	vocabulary_items = sessions.items()
	295	if self.sorted:
	296	vocabulary_items.sort(key=operator.itemgetter(1))
	297	for k, v in vocabulary_items:
	298	kw = {'value': k, 'contents': v}
	299	if value == k:
	300	kw['selected'] = 'selected'
	301	in_selection = 1
	302	res += renderHtmlTag('option', **kw)
	303	if value and not in_selection:
	304	kw = {'value': value, 'contents': 'invalid: '+ str(value),
	305	'selected': 'selected'}
	306	res += renderHtmlTag('option', **kw)
	307	res += '</select>'
	308	return res
	309	raise RuntimeError('unknown mode %s' % mode)
	310
	311	InitializeClass(WAeUPSessionWidget)
	312
	313	widgetRegistry.register(WAeUPSessionWidget)
	314
	315	###)
	316
	317	class WAeUPLevelWidget(CPSSelectWidget): ###(
	318	"""WAeUP Level Widget."""
	319	meta_type = 'WAeUP Level Widget'
	320
	321	def _getLevels(self):
	322	d = {'999':'unknown'}
	323	for y in range(100,800,100):
	324	d['%s' % str(y)] = 'Year %1d (%3d Level)' % (y/100,y)
	325	return d
	326
	327	def validate(self, datastructure, **kw):
	328	"""Validate datastructure and update datamodel."""
	329	widget_id = self.getWidgetId()
	330	value = datastructure[widget_id]
	331	try:
	332	v = str(value)
	333	except ValueError:
	334	datastructure.setError(widget_id, "'%s' not a valid level key" % value)
	335	return 0
[1805]	336
	337	if not value:
[1804]	338	v = value = '100'
	339	#import pdb;pdb.set_trace()
	340	levels = self._getLevels()
	341	if not levels.has_key(value):
	342	datastructure.setError(widget_id, "'%s' not a valid level" % v)
	343	return 0
	344	if self.is_required and not len(v):
	345	datastructure.setError(widget_id, "level key required")
	346	return 0
	347
	348	datamodel = datastructure.getDataModel()
	349	datamodel[self.fields[0]] = v
	350	return 1
	351
	352	def render(self, mode, datastructure, **kw):
	353	"""Render in mode from datastructure."""
	354	value = datastructure[self.getWidgetId()]
	355	levels = self._getLevels()
	356	if mode == 'view':
	357	return escape(levels.get(value, value))
	358	elif mode == 'edit':
	359	html_widget_id = self.getHtmlWidgetId()
	360	res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
	361	in_selection = 0
	362	vocabulary_items = levels.items()
	363	if self.sorted:
	364	vocabulary_items.sort(key=operator.itemgetter(1))
	365	for k, v in vocabulary_items:
	366	kw = {'value': k, 'contents': v}
	367	if value == k:
	368	kw['selected'] = 'selected'
	369	in_selection = 1
	370	res += renderHtmlTag('option', **kw)
	371	if value and not in_selection:
	372	kw = {'value': value, 'contents': 'invalid: '+ str(value),
	373	'selected': 'selected'}
	374	res += renderHtmlTag('option', **kw)
	375	res += '</select>'
	376	return res
	377	raise RuntimeError('unknown mode %s' % mode)
	378
	379	InitializeClass(WAeUPLevelWidget)
	380
	381	widgetRegistry.register(WAeUPLevelWidget)
	382
	383	###)
	384
	385	class WAeUPVerdictWidget(CPSSelectWidget): ###(
	386	"""WAeUP Verdict widget."""
	387	meta_type = 'WAeUP Verdict Widget'
	388
	389	# XXX make a menu for the vocabulary.
	390	vocabulary = 'verdicts'
	391
	392	# Associating the widget label with an input area to improve the widget
	393	# accessibility.
	394	has_input_area = True
	395
	396	def _getVerdicts(self,datastructure):
	397	voc = getattr(self.portal_vocabularies,self.vocabulary)
	398	d = {}
	399	for k,v in voc.items():
	400	d[k] = v
	401	return d
	402
	403	def validate(self, datastructure, **kw):
	404	"""Validate datastructure and update datamodel."""
	405	widget_id = self.getWidgetId()
	406	value = datastructure[widget_id]
	407	try:
	408	v = str(value)
	409	except ValueError:
	410	datastructure.setError(widget_id, "'%s' not a valid verdict key" % value)
	411	return 0
	412	#import pdb;pdb.set_trace()
	413	verdicts = self._getVerdicts(datastructure)
	414	if not value:
	415	v = value = verdicts['N/A']
	416	if not verdicts.has_key(value):
	417	datastructure.setError(widget_id, "'%s' not a valid verdict key" % v)
	418	return 0
	419	if self.is_required and not len(v):
	420	datastructure.setError(widget_id, "verdict required")
	421	return 0
	422
	423	datamodel = datastructure.getDataModel()
	424	datamodel[self.fields[0]] = v
	425	return 1
	426
	427	def render(self, mode, datastructure, **kw):
	428	"""Render in mode from datastructure."""
	429	value = datastructure[self.getWidgetId()]
	430	verdicts = self._getVerdicts(datastructure)
	431	if mode == 'view':
	432	return escape(verdicts.get(value, value))
	433	elif mode == 'edit':
	434	html_widget_id = self.getHtmlWidgetId()
	435	res = renderHtmlTag('select', name=html_widget_id, id=html_widget_id)
	436	in_selection = 0
	437	vocabulary_items = verdicts.items()
	438	if self.sorted:
	439	vocabulary_items.sort(key=operator.itemgetter(1))
	440	for k, v in vocabulary_items:
	441	kw = {'value': k, 'contents': v}
	442	if value == k:
	443	kw['selected'] = 'selected'
	444	in_selection = 1
	445	res += renderHtmlTag('option', **kw)
	446	if value and not in_selection:
	447	kw = {'value': value, 'contents': 'invalid: '+ str(value),
	448	'selected': 'selected'}
	449	res += renderHtmlTag('option', **kw)
	450	res += '</select>'
	451	return res
	452	raise RuntimeError('unknown mode %s' % mode)
	453
	454	InitializeClass(WAeUPVerdictWidget)
	455
	456	widgetRegistry.register(WAeUPVerdictWidget)
	457
	458	###)
	459
[714]	460	class WAeUPReservedRoomsWidget(CPSStringWidget): ###(
	461	""" WAeUPReservedRooms Widget"""
	462	meta_type = "WAeUPReservedRooms Widget"
	463
	464	def validate(self, datastructure, **kw):
	465	"""Validate datastructure and update datamodel."""
	466	import re
	467	valid = CPSStringWidget.validate(self, datastructure, **kw)
	468	if not valid:
	469	return 0
	470	else:
	471	widget_id = self.getWidgetId()
	472	value = datastructure[widget_id]
	473	err = 0
	474	try:
[926]	475	reserved = [(r.split('/')[0],int(r.split('/')[1])) for r in re.split(',\|\.\| ',value)
[714]	476	if r]
[1038]	477	except (ValueError,IndexError),msg:
[714]	478	err = str(msg)
	479	if err:
	480	datastructure.setError(widget_id, err)
	481	else:
	482	datamodel = datastructure.getDataModel()
	483	datamodel[self.fields[0]] = value
	484	return not err
	485
	486	InitializeClass(WAeUPReservedRoomsWidget)
	487
	488	widgetRegistry.register(WAeUPReservedRoomsWidget)
	489	###)
	490
[388]	491	class WAeUPIdWidget(CPSStringWidget): ###(
	492	""" WAeUPId Widget"""
	493	meta_type = "WAeUPId Widget"
[444]	494
[388]	495	def validate(self, datastructure, **kw):
	496	"""Validate datastructure and update datamodel."""
[444]	497
[388]	498	valid = CPSStringWidget.validate(self, datastructure, **kw)
[422]	499	id_pat_str = r"\S"
	500	inv_id_pat = compile(r"^%s$" % id_pat_str)
[388]	501	if not valid:
	502	return 0
	503	else:
[586]	504	portal_type_query = {'query':['Faculty',
	505	'Department',
	506	'Course',
	507	'Certificate',
	508	'CertificateCourse',]}
[388]	509	widget_id = self.getWidgetId()
	510	value = datastructure[widget_id].upper()
	511	err = 0
[1907]	512	mapping = {}
[440]	513	if len(value.split()) > 1:
[783]	514	err = 'Invalid Id, Id contains space(s).'
[586]	515	elif self.portal_catalog(portal_type=portal_type_query,id=value):
[1718]	516	brain = self.portal_catalog(portal_type=portal_type_query,id=value)[0]
[1907]	517	err = 'An ${portal_type} object with the Id ${id} already exists at ${path}.'
	518	mapping = {'portal_type': brain.portal_type,
	519	'id': value,
	520	'path': brain.getPath(),
	521	}
[388]	522	if err:
[1907]	523	datastructure.setError(widget_id, err, mapping)
[388]	524	else:
	525	datamodel = datastructure.getDataModel()
	526	datamodel[self.fields[0]] = value
[444]	527
[388]	528	return not err
	529
	530	InitializeClass(WAeUPIdWidget)
	531
	532	widgetRegistry.register(WAeUPIdWidget)
	533
	534
	535	###)
	536
[1025]	537	class StudyCourseWidget(CPSStringWidget): ###(
	538	""" StudyCourse Widget"""
	539	meta_type = "StudyCourse Widget"
	540
	541	def validate(self, datastructure, **kw):
	542	"""Validate datastructure and update datamodel."""
	543	#from Products.zdb import set_trace
	544	#set_trace()
[1747]	545	## valid = CPSStringWidget.validate(self, datastructure, **kw)
	546	## if not valid:
	547	## return 0
	548	widget_id = self.getWidgetId()
	549	value = makeCertificateCode(datastructure[widget_id]).upper()
[1025]	550	id_pat_str = r"\S"
	551	inv_id_pat = compile(r"^%s$" % id_pat_str)
[1747]	552	err = 0
	553	if len(value.split()) > 1:
	554	err = 'Invalid Id, Id contains space(s).'
	555	elif not self.portal_catalog(portal_type='Certificate',id=value):
	556	err = 'No such certificate'
	557	if err:
	558	datastructure.setError(widget_id, err)
[1025]	559	else:
[1747]	560	datamodel = datastructure.getDataModel()
	561	datamodel[self.fields[0]] = value
	562	return not err
[1025]	563
	564	InitializeClass(StudyCourseWidget)
	565
	566	widgetRegistry.register(StudyCourseWidget)
	567	###)
	568
[463]	569	class JambRegNoWidget(CPSStringWidget): ###(
	570	""" JambRegNo Widget"""
	571	meta_type = "JambRegNo Widget"
[1169]	572	_properties = CPSStringWidget._properties + (
	573	{'id': 'catalog', 'type': 'string', 'mode': 'w',
	574	'label': 'Catalog to search'},
	575	{'id': 'reference', 'type': 'string', 'mode': 'w',
	576	'label': 'Reference Field'},
	577	)
	578	catalog = "portal_pumeresults" #the catalog to search for jamb_reg_no
	579	reference = ""
[463]	580	digits = 8
	581	digits_str = "N"*digits
	582	letters = 2
	583	letters_str = "L"*letters
	584	def validate(self, datastructure, **kw):
	585	"""Validate datastructure and update datamodel."""
	586	valid = CPSStringWidget.validate(self, datastructure, **kw)
[1169]	587	jamb_nr_catalog = getattr(self,self.catalog)
	588	widget_id = self.getWidgetId()
	589	value = datastructure[widget_id].upper()
	590	err = 0
	591	if not valid: #or not (len(value) == self.digits + self.letters and value[:self.digits].isdigit() and value[self.digits:].isalpha()):
	592	#err = 'Invalid number, the expected format is: %s%s with N = Number, L = Letter' % (self.digits_str,self.letters_str)
[1793]	593	err = 'Invalid number'
[1169]	594	elif self.reference == '':
	595	#s = getStudentByRegNo(self,value)
	596	pume = jamb_nr_catalog(jamb_reg_no = value)
	597	if len(pume) < 1:
[1891]	598	err = 'No student record with this registration number.'
[1169]	599	else:
	600	datastructure['pume'] = pume[0]
[463]	601	else:
[1169]	602	#import pdb;pdb.set_trace()
	603	record = datastructure[self.reference]
	604	#jamb_reg_no = getattr(record,widget_id)
	605	jamb_reg_no = record.Entryregno
	606	if jamb_reg_no != value:
[1783]	607	err = 'Registration number does not match.'
[1169]	608	if err:
	609	datastructure.setError(widget_id, err)
	610	else:
	611	datamodel = datastructure.getDataModel()
	612	datamodel[self.fields[0]] = value
	613	return not err
[463]	614
	615	InitializeClass(JambRegNoWidget)
	616
	617	widgetRegistry.register(JambRegNoWidget)
[47]	618	###)
	619
[1175]	620	class SecretWidget(CPSStringWidget): ###(
	621	""" Secret Widget"""
	622	meta_type = "Secret Widget"
	623	_properties = CPSStringWidget._properties + (
	624	{'id': 'reference', 'type': 'string', 'mode': 'w',
	625	'label': 'Reference Record'},
	626	{'id': 'check_fields', 'type': 'tokens', 'mode': 'w',
	627	'label': 'Fields to check'},
	628	)
	629	reference = "student"
[1747]	630	matric_no_catalog = 'returning_import'
[1175]	631	check_fields = ("Firstname", "Middlename","Lastname")
	632	def validate(self, datastructure, **kw):
	633	"""Validate datastructure and update datamodel."""
[1571]	634	logger = logging.getLogger('Widgets.SecretWidget.validate')
[1175]	635	valid = CPSStringWidget.validate(self, datastructure, **kw)
	636	widget_id = self.getWidgetId()
	637	value = datastructure[widget_id].upper()
	638	err = 0
[1189]	639	record = datastructure.get(self.reference,None)
[1747]	640	#import pdb;pdb.set_trace()
[1379]	641	if not valid or len(value) < 2:
[1793]	642	err = 'Invalid string'
[1189]	643	elif not record or datastructure.errors:
[1177]	644	err = 0
[1175]	645	else:
	646	found = False
	647	cvs = []
	648	for field in self.check_fields:
	649	cv = getattr(record,field).upper()
[1243]	650	if len(cv.split()) > 1:
	651	for splited in cv.split():
[1747]	652	cvs.append(splited.strip())
[1243]	653	else:
	654	cvs.append(cv)
[1747]	655	for cv in cvs:
[1175]	656	if cv == value.upper():
	657	found = True
	658	break
	659	matric_no = record.matric_no
	660	name = " ".join(cvs)
	661	if not found:
[1573]	662	logger.info('%(matric_no)s did not find %(value)s in %(name)s' % vars())
	663	err = 'No name does match.'
[1175]	664	else:
[1571]	665	logger.info('%(matric_no)s found %(value)s in %(name)s' % vars())
[1175]	666	if err:
	667	datastructure.setError(widget_id, err)
	668	else:
	669	datamodel = datastructure.getDataModel()
	670	datamodel[self.fields[0]] = value
	671	return not err
	672
	673	InitializeClass(SecretWidget)
	674
	675	widgetRegistry.register(SecretWidget)
	676	###)
	677
[1804]	678	class WAeUPSexWidget(CPSBooleanWidget): ###(
[1772]	679	"""WAeUP sex widget."""
	680	meta_type = 'WAeUP Sex Widget'
	681
	682	def validate(self, datastructure, **kw):
	683	"""Validate datastructure and update datamodel."""
	684	value = datastructure[self.getWidgetId()]
	685
	686	if self.render_format not in self.render_formats:
	687	self.render_format = 'select'
	688
	689	female = value in ('F','f','Female','female',"True",True)
	690	male = value in ('M','m','Male','male','False',False)
	691	if not female and not male:
	692	datastructure.setError(self.getWidgetId(),
	693	"invalid sex %s" % value)
	694	return 0
	695	elif female:
	696	v = True
	697	else:
	698	v = False
	699	datamodel = datastructure.getDataModel()
	700	datamodel[self.fields[0]] = v
	701	return 1
	702
	703	InitializeClass(WAeUPSexWidget)
	704
	705	widgetRegistry.register(WAeUPSexWidget)
	706
[1804]	707	###)
	708
[1146]	709	class MatricNoWidget(CPSStringWidget): ###(
	710	""" MatricNo Widget"""
	711	meta_type = "MatricNo Widget"
[1747]	712
	713	_properties = CPSStringWidget._properties + (
	714	{'id': 'matric_no_catalog', 'type': 'string', 'mode': 'w',
	715	'label': 'Catalog to search for MatricNo'},
	716	{ 'id': 'results_catalog', 'type': 'string', 'mode': 'w',
	717	'label': 'Results Catalog'},
	718	)
	719	matric_no_catalog = "" #the catalog to search for matric_no
[1748]	720	results_catalog = "results_import" #results catalog
[1747]	721
[1146]	722	def validate(self, datastructure, **kw):
	723	"""Validate datastructure and update datamodel."""
[1747]	724	#import pdb;pdb.set_trace()
[1146]	725	valid = CPSStringWidget.validate(self, datastructure, **kw)
[1571]	726	logger = logging.getLogger('Widgets.MatricNoWidget.validate')
[1747]	727	returning = getattr(self,self.matric_no_catalog)
	728	results = getattr(self,self.results_catalog,None)
[1146]	729	err = 0
[1189]	730	widget_id = self.getWidgetId()
	731	value = datastructure[widget_id]
	732	if not valid or not value:
[1891]	733	err = 'Invalid string'
[1573]	734	logger.info('Invalid matric_no string %s' % value)
[1146]	735	else:
[1189]	736	value = value.upper()
[1177]	737	datastructure['student'] = None
[1146]	738	while not err:
[1151]	739	res = returning(matric_no = value)
[1146]	740	if len(res) < 1:
[1573]	741	logger.info('matric_no %s not found' % value)
[1891]	742	err = 'No student with this matriculation number.'
[1747]	743	break
[1146]	744	datastructure['student'] = res[0]
[1747]	745	if results is not None:
	746	res = results(matric_no = value)
	747	if len(res) < 1:
[1891]	748	err = 'No results for this matriculation number'
[1747]	749	continue
	750	datastructure['results'] = res
[1146]	751	break
[1189]	752	if err:
	753	datastructure.setError(widget_id, err)
	754	else:
	755	datamodel = datastructure.getDataModel()
	756	datamodel[self.fields[0]] = value
	757	return not err
[1146]	758
	759	InitializeClass(MatricNoWidget)
	760
	761	widgetRegistry.register(MatricNoWidget)
	762	###)
	763
[1393]	764	class StudentIdWidget(CPSStringWidget): ###(
	765	""" StudentId Widget"""
	766	meta_type = "StudentId Widget"
	767	def validate(self, datastructure, **kw):
	768	"""Validate datastructure and update datamodel."""
	769	valid = CPSStringWidget.validate(self, datastructure, **kw)
[1571]	770	logger = logging.getLogger('Widgets.StudentIdWidget.validate')
[1393]	771	#import pdb;pdb.set_trace()
	772	s_cat = self.students_catalog
	773	err = 0
	774	widget_id = self.getWidgetId()
	775	value = datastructure[widget_id]
	776	if not valid or not value:
[1891]	777	err = 'Invalid Id string'
[1573]	778	logger.info('Invalid id string %s' % value)
[1449]	779	datastructure['student'] = None
[1393]	780	else:
	781	value = value.upper()
	782	res = s_cat(id = value)
	783	if not res:
[1573]	784	logger.info('Student id %s not found' % value)
[1891]	785	err = 'No student with this Id'
[1393]	786	datastructure['student'] = None
	787	else:
	788	datastructure['student'] = res[0]
	789	if err:
	790	datastructure.setError(widget_id, err)
	791	else:
	792	datamodel = datastructure.getDataModel()
	793	datamodel[self.fields[0]] = value
	794	return not err
	795
	796	InitializeClass(StudentIdWidget)
	797
	798	widgetRegistry.register(StudentIdWidget)
	799	###)
	800
[1146]	801	class WAeUPMultilineResultsWidget(CPSStringWidget): ###(
	802	""" WAeUPMultilineResults Widget"""
	803	meta_type = "WAeUp Multiline Results Widget"
	804	_properties = CPSWidget._properties + (
	805	{'id': 'nr_of_lines', 'type': 'int', 'mode': 'w',
	806	'label': 'Nr of Lines'},
	807	)
	808	nr_of_lines = 5
	809	def prepare(self, datastructure, **kw): ###(
	810	"""Prepare datastructure from datamodel."""
	811	datamodel = datastructure.getDataModel()
	812	#import pdb;pdb.set_trace()
	813	widget_id = self.getWidgetId()
	814	v = datamodel[self.fields[0]]
	815	if type(v) is ListType and v:
	816	nr_results = len(v)
	817	else:
	818	v = []
	819	nr_results = 0
	820	count = 1
	821	for s,g in v:
	822	wid = "%s%02d"% (widget_id,count)
	823	datastructure[wid+'_s'] = s
	824	datastructure[wid+'_g'] = g
	825	count += 1
	826	if nr_results < self.nr_of_lines:
	827	for line in range(nr_results,self.nr_of_lines):
	828	v.append(('',''))
	829	wid = "%s%02d"% (widget_id,line)
	830	datastructure[wid+'_s'] = ''
	831	datastructure[wid+'_g'] = ''
	832	datastructure[widget_id] = v
	833	datastructure[widget_id+'_s'] = ''
	834	datastructure[widget_id+'_g'] = ''
	835	###)
	836
	837	def validate(self, datastructure, **kw): ###(
	838	"""Validate datastructure and update datamodel."""
	839	#import pdb;pdb.set_trace()
	840	widget_id = self.getWidgetId()
	841	err = 0
	842	lines = []
	843	for line in range(1,30):
	844	wid = "%s%02d"% (widget_id,line)
	845	if not datastructure.has_key(wid+'_s'):
	846	break
	847	lines.append((datastructure[wid+'_s'].strip(),
	848	datastructure[wid+'_g'].strip()))
[1155]	849
[1146]	850	s = datastructure[widget_id+'_s'].strip()
	851	g = datastructure[widget_id+'_g'].strip()
	852	if s and g:
	853	lines.append((s,g))
	854	active = []
	855	for s,g in lines:
	856	if g != "":
	857	active.append((s,g))
	858	if err:
	859	datastructure.setError(widget_id, err)
	860	else:
	861	datamodel = datastructure.getDataModel()
	862	datamodel[self.fields[0]] = active
	863	return not err
	864	###)
	865
	866	def render(self, mode, datastructure, **kw): ###(
	867	"""Render in mode from datastructure."""
	868	render_method = 'widget_waeup_multiline_result_render'
	869	meth = getattr(self, render_method, None)
	870	if meth is None:
	871	raise RuntimeError("Unknown Render Method %s for widget type %s"
	872	% (render_method, self.getId()))
	873	#import pdb;pdb.set_trace()
	874	datamodel = datastructure.getDataModel()
	875	widget_id = self.getWidgetId()
	876	lines = datamodel[self.fields[0]]
	877	if len(lines) < self.nr_of_lines:
	878	for line in range(len(lines),self.nr_of_lines + 1):
	879	lines.append(('',''))
	880	datastructure[widget_id] = lines
	881	datastructure[widget_id+'_s'] = ''
	882	datastructure[widget_id+'_g'] = ''
	883	## count = 1
	884	## for s,g in v:
	885	## wid = "%s%02d"% (widget_id,count)
	886	## count += 1
	887	return meth(mode=mode,
	888	datastructure=datastructure,
	889	)
	890	###)
	891
	892
	893	InitializeClass(WAeUPMultilineResultsWidget)
	894	widgetRegistry.register(WAeUPMultilineResultsWidget)
	895	###)
	896
[794]	897	class WAeUPResultsWidget(CPSStringWidget): ###(
	898	""" WAeUPResults Widget"""
	899	meta_type = "WAeUp Results Widget"
	900
	901	def prepare(self, datastructure, **kw): ###(
	902	"""Prepare datastructure from datamodel."""
	903	datamodel = datastructure.getDataModel()
	904	v = datamodel[self.fields[0]]
	905	#import pdb;pdb.set_trace()
	906	widget_id = self.getWidgetId()
[807]	907	datastructure[widget_id] = v
[794]	908	datastructure[widget_id+'_s'] = ''
	909	datastructure[widget_id+'_g'] = ''
	910	###)
	911
	912	def validate(self, datastructure, **kw): ###(
	913	"""Validate datastructure and update datamodel."""
[807]	914	#import pdb;pdb.set_trace()
[794]	915	widget_id = self.getWidgetId()
	916	v = datastructure[widget_id]
	917	err = 0
	918	s = datastructure[widget_id+'_s'].strip()
	919	g = datastructure[widget_id+'_g'].strip()
[807]	920	while 1:
	921	if not s and g:
[1891]	922	err = "No subject grade for subject"
[807]	923	break
	924	i = 0
	925	done = False
	926	for sv,gv in v:
	927	if sv == s:
	928	done = True
	929	if not g:
	930	v.pop(i)
	931	break
	932	v[i] = (s,g)
	933	break
	934	i += 1
	935	if done:
	936	break
	937	if s and g:
	938	v.append((s,g))
	939	break
[794]	940	if err:
	941	datastructure.setError(widget_id, err)
	942	else:
	943	datamodel = datastructure.getDataModel()
	944	datamodel[self.fields[0]] = v
	945	datastructure[widget_id+'_s'] = s
	946	datastructure[widget_id+'_g'] = g
	947	return not err
	948	###)
	949
	950	def render(self, mode, datastructure, **kw): ###(
	951	"""Render in mode from datastructure."""
	952	render_method = 'widget_waeup_result_render'
	953	meth = getattr(self, render_method, None)
	954	if meth is None:
	955	raise RuntimeError("Unknown Render Method %s for widget type %s"
	956	% (render_method, self.getId()))
	957	#import pdb;pdb.set_trace()
	958	datamodel = datastructure.getDataModel()
	959	widget_id = self.getWidgetId()
	960	datastructure[widget_id+'_s'] = ''
	961	datastructure[widget_id+'_g'] = ''
	962	return meth(mode=mode,
	963	datastructure=datastructure,
	964	)
	965	###)
	966
	967
	968	InitializeClass(WAeUPResultsWidget)
	969	widgetRegistry.register(WAeUPResultsWidget)
	970	###)
	971
[488]	972	class ScratchCardPin: ###(
	973	"""the ScratchCardPin"""
	974	def __init__(self,prefix,batch_no,number):
[990]	975	if not batch_no and not number:
	976	s = prefix
[996]	977	if len(s) > 3:
[990]	978	prefix,batch_no,number = s[:3],s[3:-10],s[-10:]
	979	else:
[996]	980	prefix,batch_no,number = s,'',''
[488]	981	self.p = prefix
	982	self.b = batch_no
	983	self.n = number
	984
	985	def __str__(self):
	986	return "%s-%s-%s" % (self.p,self.b,self.n)
[1146]	987
	988	def __repr__(self):
	989	return "%s%s%s" % (self.p,self.b,self.n)
[488]	990	###)
	991
[47]	992	class ScratchcardPinWidget(CPSStringWidget): ###(
[22]	993	""" ScratchcardPin Widget"""
[199]	994	meta_type = "Scratchcard Pin Widget"
[488]	995	_properties = CPSWidget._properties + (
	996	{'id': 'prefix', 'type': 'string', 'mode': 'w',
	997	'label': 'Prefix'},
	998	{'id': 'reference', 'type': 'string', 'mode': 'w',
	999	'label': 'Reference Field'},
	1000	)
	1001	prefix = ''
	1002	reference = ''
[502]	1003	def prepare(self, datastructure, **kw): ###(
[488]	1004	"""Prepare datastructure from datamodel."""
	1005	datamodel = datastructure.getDataModel()
	1006	v = datamodel[self.fields[0]]
	1007	widget_id = self.getWidgetId()
[742]	1008	#import pdb;pdb.set_trace()
[747]	1009	if v and type(v) is StringType:
[990]	1010	try:
	1011	p,b,n = v.split('-')
	1012	v = ScratchCardPin(p,b,n)
	1013	except ValueError:
	1014	v = ScratchCardPin(v,'','')
[488]	1015	if v:
[742]	1016	p = '%s' % v.p
[488]	1017	b = '%s' % v.b
	1018	n = '%s' % v.n
	1019	else:
[742]	1020	p = self.prefix
	1021	if p.startswith('@'):
	1022	p = getattr(self,self.prefix[1:])()
[488]	1023	b = n = ''
[742]	1024	v = ScratchCardPin(p,b,n)
[488]	1025	datastructure[widget_id] = v
[742]	1026	datastructure[widget_id+'_p'] = p
[488]	1027	datastructure[widget_id+'_b'] = b
	1028	datastructure[widget_id+'_n'] = n
[1376]	1029	###)
[758]	1030
[1169]	1031	def validate(self, datastructure, **kw): ###(
[22]	1032	"""Validate datastructure and update datamodel."""
[1571]	1033	s_logger = logging.getLogger('Widgets.ScratchcardPinWidget.validate')
[488]	1034	widget_id = self.getWidgetId()
	1035	v = datastructure[widget_id]
[996]	1036	#import pdb;pdb.set_trace()
[488]	1037	err = 0
[1907]	1038	mapping = {}
[742]	1039	prefix= self.prefix
	1040	if prefix.startswith('@'):
	1041	prefix= getattr(self,self.prefix[1:])()
[488]	1042	b = datastructure[widget_id+'_b'].strip()
	1043	n = datastructure[widget_id+'_n'].strip()
[502]	1044	pins = self.portal_pins
[742]	1045	pin = "%(prefix)s%(b)s%(n)s" % vars()
[1376]	1046	pin_str = "%(prefix)s-%(b)-s%(n)s" % vars()
[816]	1047	do = 1
[1025]	1048	s_id = str(self.portal_membership.getAuthenticatedMember())
[1326]	1049	#import pdb;pdb.set_trace()
[1343]	1050	if self.isStaff():
[1326]	1051	do = 0
	1052	err ='You are not a Student. PIN neither checked nor used.'
[1571]	1053	s_logger.info('%s tried to use scratch card %s' % (s_id,pin_str))
[1557]	1054	elif len(b) > 1 and b.find('-') > -1:
	1055	do = 0
[1573]	1056	err = 'PIN must not contain "-"'
	1057	s_logger.info('%s entered invalid PIN containing "-"' % (s_id))
[1557]	1058	elif n.find('-') > -1:
	1059	do = 0
[1573]	1060	err = 'PIN must not contain "-"'
	1061	s_logger.info('%s entered invalid PIN containing "-"' % (s_id))
[1376]	1062	elif len(n) != 10:
	1063	do = 0
[1891]	1064	err = 'Invalid PIN length'
[1573]	1065	s_logger.info('%s entered invalid PIN with length %d' % (s_id,len(n)))
[1326]	1066	elif self.reference == "":
[1030]	1067	ref = s_id
[635]	1068	else:
	1069	ref = datastructure[self.reference]
[843]	1070	if datastructure.errors:
[816]	1071	do = 0
[1805]	1072	datastructure.setError(widget_id, 'PIN neither checked nor used.')
[1571]	1073	s_logger.info('%s/%s entered wrong data together with PIN %s' % (s_id,ref,pin_str))
[816]	1074	while do:
	1075	ok = pins.searchAndSetRecord(pin,ref,prefix)
[1030]	1076	if ok < -2 or ok > 2:
	1077	err = 'Unknown error, please report!'
[1571]	1078	s_logger.info('%s/%s caused unknown error with PIN %s' % (s_id,ref,pin_str))
[1030]	1079	break
	1080	elif ok == -2:
[1783]	1081	err = 'Service already is activated but with a different PIN.'
[1571]	1082	s_logger.info('%s/%s repeatedly activated service but with different PIN %s' % (s_id,ref,pin_str))
[710]	1083	break
	1084	elif ok == -1:
[1793]	1085	err = 'Invalid PIN'
[1571]	1086	s_logger.info('%s/%s entered invalid PIN %s' % (s_id,ref,pin_str))
[502]	1087	break
	1088	if ok == 0:
[1571]	1089	err = 'PIN already used'
	1090	s_logger.info('%s/%s entered used PIN %s' % (s_id,ref,pin_str))
[502]	1091	break
	1092	if ok >= 1:
[710]	1093	#import pdb;pdb.set_trace()
[635]	1094	if self.isStudent():
[992]	1095	if self.reference == "jamb_reg_no":
[997]	1096	err = "You are already logged in."
[1573]	1097	s_logger.info('%s/%s checked admission with PIN %s though logged in' % (s_id,ref,pin_str))
[992]	1098	break
[1082]	1099	if ok == 1:
[1571]	1100	s_logger.info('%s/%s successfully used PIN %s' % (s_id,ref,pin_str))
[1032]	1101	else:
[1571]	1102	s_logger.info('%s/%s repeatedly used PIN %s' % (s_id,ref,pin_str))
[637]	1103	break
[635]	1104	else:
	1105	student = getStudentByRegNo(self,ref)
[1571]	1106	s_logger.info('%s/%s successfully used PIN %s' % (s_id,ref,pin_str))
[502]	1107	if student is None:
[1793]	1108	err = "Student not found"
[1571]	1109	s_logger.info('%s not found in admission list' % (ref))
[502]	1110	break
[648]	1111	s_id = student.getId()
[502]	1112	if ok == 2:
[990]	1113	if self.reference == "jamb_reg_no":
	1114	if hasattr(self.portal_directories.students,s_id):
[1907]	1115	err = "Please login with your Student Id ${id} and 10-digit PIN."
	1116	mapping = {'id': s_id}
[1571]	1117	s_logger.info('%s/%s repeatedly checked admission with PIN %s' % (s_id,ref,pin_str))
[990]	1118	break
	1119	else:
[1571]	1120	s_logger.info('%s/%s (non-member) repeatedly checked admission with PIN %s' % (s_id,ref,pin_str))
[990]	1121	else:
[1891]	1122	err = "Unknown error"
[1571]	1123	s_logger.info('%s/%s repeatedly activated service with PIN %s' % (s_id,ref,pin_str))
[986]	1124	break
	1125	try:
	1126	student.getContent().makeStudentMember(s_id,password=pin[4:])
[1571]	1127	s_logger.info('%s/%s has been created using PIN %s' % (s_id,ref,pin_str))
[986]	1128	except:
[1907]	1129	err = "Please login with your Student Id ${id} and 10-digit PIN."
	1130	mapping = {'id': s_id}
[1571]	1131	s_logger.info('%s/%s could not be made a member with PIN %s' % (s_id,ref,pin_str))
[986]	1132	break
[502]	1133	break
[488]	1134	if err:
[1907]	1135	datastructure.setError(widget_id, err,mapping)
[488]	1136	else:
	1137	datamodel = datastructure.getDataModel()
[742]	1138	datamodel[self.fields[0]] = ScratchCardPin(prefix,b,n)
	1139	datastructure[widget_id] = ScratchCardPin(prefix,b,n)
	1140	datastructure[widget_id+'_p'] = prefix
[488]	1141	datastructure[widget_id+'_b'] = b
	1142	datastructure[widget_id+'_n'] = n
[502]	1143	datastructure['s_id'] = s_id
[488]	1144	return not err
[444]	1145
[1169]	1146	###)
	1147
[502]	1148	def render(self, mode, datastructure, **kw): ###(
[488]	1149	"""Render in mode from datastructure."""
	1150	render_method = 'widget_scratch_card_pin_render'
	1151	meth = getattr(self, render_method, None)
	1152	if meth is None:
	1153	raise RuntimeError("Unknown Render Method %s for widget type %s"
	1154	% (render_method, self.getId()))
	1155
	1156	# XXX AT: datastructure has to be set again here, in case we're in edit
	1157	# or create mode, because a default value has to be provided.
	1158	#import pdb;pdb.set_trace()
	1159	datamodel = datastructure.getDataModel()
	1160	v = datamodel[self.fields[0]]
[502]	1161	if v and type(v) is StringType:
[990]	1162	try:
	1163	p,b,n = v.split('-')
	1164	v = ScratchCardPin(p,b,n)
	1165	except ValueError:
[996]	1166	v = ScratchCardPin(self.prefix,'1',v)
	1167	pass
[488]	1168	if v:
[742]	1169	prefix= '%s' % v.p
[488]	1170	b = '%s' % v.b
	1171	n = '%s' % v.n
[22]	1172	else:
[742]	1173	prefix= self.prefix
	1174	if prefix.startswith('@'):
	1175	prefix= getattr(self,self.prefix[1:])()
[488]	1176	b = n = ''
[742]	1177	v = ScratchCardPin(prefix,b,n)
	1178	widget_id = self.getWidgetId()
	1179	datastructure[widget_id] = v
	1180	datastructure[widget_id+'_p'] = prefix
	1181	datastructure[widget_id+'_b'] = b
	1182	datastructure[widget_id+'_n'] = n
[758]	1183	return meth(mode=mode,
	1184	datastructure=datastructure,
[488]	1185	)
[523]	1186	###)
[488]	1187
	1188
[22]	1189	InitializeClass(ScratchcardPinWidget)
[199]	1190	widgetRegistry.register(ScratchcardPinWidget)
[22]	1191
[47]	1192
	1193	###)
	1194
[1169]	1195	class WAeUPImageWidget(CPSImageWidget): ###(
[537]	1196	"""Photo widget."""
	1197	meta_type = 'WAeUP Image Widget'
	1198
	1199	def render(self, mode, datastructure, **kw):
	1200	render_method = 'widget_waeup_image_render'
	1201	meth = getattr(self, render_method, None)
	1202	if meth is None:
	1203	raise RuntimeError("Unknown Render Method %s for widget type %s"
	1204	% (render_method, self.getId()))
	1205	img_info = self.getImageInfo(datastructure)
	1206	return meth(mode=mode, datastructure=datastructure, **img_info)
	1207
	1208	InitializeClass(WAeUPImageWidget)
	1209
	1210	widgetRegistry.register(WAeUPImageWidget)
[1804]	1211	###)
[537]	1212
	1213
[22]	1214	###########
	1215

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

Download in other formats: