Context navigation

source: WAeUP_SRP/trunk/Widgets.py @ 1783

Last change on this file since 1783 was 1783, checked in by Henrik Bettermann, 17 years ago
assertViewable removed and page templates adjusted, so that no traceback occurs. 'Previous Session' action added waeup_content_master.pt removed and more
Property svn:keywords set to `Id`
File size: 33.5 KB

Rev	Line
[47]	1	#-- mode: python; mode: fold --
[990]	2	# $Id: Widgets.py 1783 2007-05-15 07:49:50Z henrik $
[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):
[1783]	129	err = 'course %s already exists' % (value)
[381]	130	elif value not in c_ids:
[1783]	131	err = 'course %s does not exist' % (value)
[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:
[1783]	161	err = 'course %s already exists' % (value)
[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
[714]	177	class WAeUPReservedRoomsWidget(CPSStringWidget): ###(
	178	""" WAeUPReservedRooms Widget"""
	179	meta_type = "WAeUPReservedRooms Widget"
	180
	181	def validate(self, datastructure, **kw):
	182	"""Validate datastructure and update datamodel."""
	183	import re
	184	valid = CPSStringWidget.validate(self, datastructure, **kw)
	185	if not valid:
	186	return 0
	187	else:
	188	widget_id = self.getWidgetId()
	189	value = datastructure[widget_id]
	190	err = 0
	191	try:
[926]	192	reserved = [(r.split('/')[0],int(r.split('/')[1])) for r in re.split(',\|\.\| ',value)
[714]	193	if r]
[1038]	194	except (ValueError,IndexError),msg:
[714]	195	err = str(msg)
	196	if err:
	197	datastructure.setError(widget_id, err)
	198	else:
	199	datamodel = datastructure.getDataModel()
	200	datamodel[self.fields[0]] = value
	201	return not err
	202
	203	InitializeClass(WAeUPReservedRoomsWidget)
	204
	205	widgetRegistry.register(WAeUPReservedRoomsWidget)
	206	###)
	207
[388]	208	class WAeUPIdWidget(CPSStringWidget): ###(
	209	""" WAeUPId Widget"""
	210	meta_type = "WAeUPId Widget"
[444]	211
[388]	212	def validate(self, datastructure, **kw):
	213	"""Validate datastructure and update datamodel."""
[444]	214
[388]	215	valid = CPSStringWidget.validate(self, datastructure, **kw)
[422]	216	id_pat_str = r"\S"
	217	inv_id_pat = compile(r"^%s$" % id_pat_str)
[388]	218	if not valid:
	219	return 0
	220	else:
[586]	221	portal_type_query = {'query':['Faculty',
	222	'Department',
	223	'Course',
	224	'Certificate',
	225	'CertificateCourse',]}
[388]	226	widget_id = self.getWidgetId()
	227	value = datastructure[widget_id].upper()
	228	err = 0
[440]	229	if len(value.split()) > 1:
[783]	230	err = 'Invalid Id, Id contains space(s).'
[586]	231	elif self.portal_catalog(portal_type=portal_type_query,id=value):
[1718]	232	brain = self.portal_catalog(portal_type=portal_type_query,id=value)[0]
[1783]	233	err = 'An %s object with the Id %s already exists at %s.'\
[1718]	234	% (brain.portal_type,value,brain.getPath())
[388]	235	if err:
	236	datastructure.setError(widget_id, err)
	237	else:
	238	datamodel = datastructure.getDataModel()
	239	datamodel[self.fields[0]] = value
[444]	240
[388]	241	return not err
	242
	243	InitializeClass(WAeUPIdWidget)
	244
	245	widgetRegistry.register(WAeUPIdWidget)
	246
	247
	248	###)
	249
[1025]	250	class StudyCourseWidget(CPSStringWidget): ###(
	251	""" StudyCourse Widget"""
	252	meta_type = "StudyCourse Widget"
	253
	254	def validate(self, datastructure, **kw):
	255	"""Validate datastructure and update datamodel."""
	256	#from Products.zdb import set_trace
	257	#set_trace()
[1747]	258	## valid = CPSStringWidget.validate(self, datastructure, **kw)
	259	## if not valid:
	260	## return 0
	261	widget_id = self.getWidgetId()
	262	value = makeCertificateCode(datastructure[widget_id]).upper()
[1025]	263	id_pat_str = r"\S"
	264	inv_id_pat = compile(r"^%s$" % id_pat_str)
[1747]	265	err = 0
	266	if len(value.split()) > 1:
	267	err = 'Invalid Id, Id contains space(s).'
	268	elif not self.portal_catalog(portal_type='Certificate',id=value):
	269	err = 'No such certificate'
	270	if err:
	271	datastructure.setError(widget_id, err)
[1025]	272	else:
[1747]	273	datamodel = datastructure.getDataModel()
	274	datamodel[self.fields[0]] = value
	275	return not err
[1025]	276
	277	InitializeClass(StudyCourseWidget)
	278
	279	widgetRegistry.register(StudyCourseWidget)
	280	###)
	281
[463]	282	class JambRegNoWidget(CPSStringWidget): ###(
	283	""" JambRegNo Widget"""
	284	meta_type = "JambRegNo Widget"
[1169]	285	_properties = CPSStringWidget._properties + (
	286	{'id': 'catalog', 'type': 'string', 'mode': 'w',
	287	'label': 'Catalog to search'},
	288	{'id': 'reference', 'type': 'string', 'mode': 'w',
	289	'label': 'Reference Field'},
	290	)
	291	catalog = "portal_pumeresults" #the catalog to search for jamb_reg_no
	292	reference = ""
[463]	293	digits = 8
	294	digits_str = "N"*digits
	295	letters = 2
	296	letters_str = "L"*letters
	297	def validate(self, datastructure, **kw):
	298	"""Validate datastructure and update datamodel."""
	299	valid = CPSStringWidget.validate(self, datastructure, **kw)
[816]	300	#import pdb;pdb.set_trace()
[1169]	301	jamb_nr_catalog = getattr(self,self.catalog)
	302	widget_id = self.getWidgetId()
	303	value = datastructure[widget_id].upper()
	304	err = 0
	305	if not valid: #or not (len(value) == self.digits + self.letters and value[:self.digits].isdigit() and value[self.digits:].isalpha()):
	306	#err = 'Invalid number, the expected format is: %s%s with N = Number, L = Letter' % (self.digits_str,self.letters_str)
[1783]	307	err = 'invalid number'
[1169]	308	elif self.reference == '':
	309	#s = getStudentByRegNo(self,value)
	310	pume = jamb_nr_catalog(jamb_reg_no = value)
	311	if len(pume) < 1:
[1783]	312	err = 'no Student with JAMB RegNo %s' % (value)
[1169]	313	else:
	314	datastructure['pume'] = pume[0]
[463]	315	else:
[1169]	316	#import pdb;pdb.set_trace()
	317	record = datastructure[self.reference]
	318	#jamb_reg_no = getattr(record,widget_id)
	319	jamb_reg_no = record.Entryregno
	320	if jamb_reg_no != value:
[1783]	321	err = 'Registration number does not match.'
[1169]	322	if err:
	323	datastructure.setError(widget_id, err)
	324	else:
	325	datamodel = datastructure.getDataModel()
	326	datamodel[self.fields[0]] = value
	327	return not err
[463]	328
	329	InitializeClass(JambRegNoWidget)
	330
	331	widgetRegistry.register(JambRegNoWidget)
[47]	332	###)
	333
[1175]	334	class SecretWidget(CPSStringWidget): ###(
	335	""" Secret Widget"""
	336	meta_type = "Secret Widget"
	337	_properties = CPSStringWidget._properties + (
	338	{'id': 'reference', 'type': 'string', 'mode': 'w',
	339	'label': 'Reference Record'},
	340	{'id': 'check_fields', 'type': 'tokens', 'mode': 'w',
	341	'label': 'Fields to check'},
	342	)
	343	reference = "student"
[1747]	344	matric_no_catalog = 'returning_import'
[1175]	345	check_fields = ("Firstname", "Middlename","Lastname")
	346	def validate(self, datastructure, **kw):
	347	"""Validate datastructure and update datamodel."""
[1571]	348	logger = logging.getLogger('Widgets.SecretWidget.validate')
[1175]	349	valid = CPSStringWidget.validate(self, datastructure, **kw)
	350	widget_id = self.getWidgetId()
	351	value = datastructure[widget_id].upper()
	352	err = 0
[1189]	353	record = datastructure.get(self.reference,None)
[1747]	354	#import pdb;pdb.set_trace()
[1379]	355	if not valid or len(value) < 2:
[1783]	356	err = 'invalid string'
[1189]	357	elif not record or datastructure.errors:
[1177]	358	err = 0
[1175]	359	else:
	360	found = False
	361	cvs = []
	362	for field in self.check_fields:
	363	cv = getattr(record,field).upper()
[1243]	364	if len(cv.split()) > 1:
	365	for splited in cv.split():
[1747]	366	cvs.append(splited.strip())
[1243]	367	else:
	368	cvs.append(cv)
[1747]	369	for cv in cvs:
[1175]	370	if cv == value.upper():
	371	found = True
	372	break
	373	matric_no = record.matric_no
	374	name = " ".join(cvs)
	375	if not found:
[1573]	376	logger.info('%(matric_no)s did not find %(value)s in %(name)s' % vars())
	377	err = 'No name does match.'
[1175]	378	else:
[1571]	379	logger.info('%(matric_no)s found %(value)s in %(name)s' % vars())
[1175]	380	if err:
	381	datastructure.setError(widget_id, err)
	382	else:
	383	datamodel = datastructure.getDataModel()
	384	datamodel[self.fields[0]] = value
	385	return not err
	386
	387	InitializeClass(SecretWidget)
	388
	389	widgetRegistry.register(SecretWidget)
	390	###)
	391
[1772]	392	class WAeUPSexWidget(CPSBooleanWidget):
	393	"""WAeUP sex widget."""
	394	meta_type = 'WAeUP Sex Widget'
	395
	396	def validate(self, datastructure, **kw):
	397	"""Validate datastructure and update datamodel."""
	398	value = datastructure[self.getWidgetId()]
	399
	400	if self.render_format not in self.render_formats:
	401	self.render_format = 'select'
	402
	403	female = value in ('F','f','Female','female',"True",True)
	404	male = value in ('M','m','Male','male','False',False)
	405	if not female and not male:
	406	datastructure.setError(self.getWidgetId(),
	407	"invalid sex %s" % value)
	408	return 0
	409	elif female:
	410	v = True
	411	else:
	412	v = False
	413	datamodel = datastructure.getDataModel()
	414	datamodel[self.fields[0]] = v
	415	return 1
	416
	417	InitializeClass(WAeUPSexWidget)
	418
	419	widgetRegistry.register(WAeUPSexWidget)
	420
[1146]	421	class MatricNoWidget(CPSStringWidget): ###(
	422	""" MatricNo Widget"""
	423	meta_type = "MatricNo Widget"
[1747]	424
	425	_properties = CPSStringWidget._properties + (
	426	{'id': 'matric_no_catalog', 'type': 'string', 'mode': 'w',
	427	'label': 'Catalog to search for MatricNo'},
	428	{ 'id': 'results_catalog', 'type': 'string', 'mode': 'w',
	429	'label': 'Results Catalog'},
	430	)
	431	matric_no_catalog = "" #the catalog to search for matric_no
[1748]	432	results_catalog = "results_import" #results catalog
[1747]	433
[1146]	434	def validate(self, datastructure, **kw):
	435	"""Validate datastructure and update datamodel."""
[1747]	436	#import pdb;pdb.set_trace()
[1146]	437	valid = CPSStringWidget.validate(self, datastructure, **kw)
[1571]	438	logger = logging.getLogger('Widgets.MatricNoWidget.validate')
[1747]	439	returning = getattr(self,self.matric_no_catalog)
	440	results = getattr(self,self.results_catalog,None)
[1146]	441	err = 0
[1189]	442	widget_id = self.getWidgetId()
	443	value = datastructure[widget_id]
	444	if not valid or not value:
[1783]	445	err = 'invalid string %s' % value
[1573]	446	logger.info('Invalid matric_no string %s' % value)
[1146]	447	else:
[1189]	448	value = value.upper()
[1177]	449	datastructure['student'] = None
[1146]	450	while not err:
[1151]	451	res = returning(matric_no = value)
[1146]	452	if len(res) < 1:
[1573]	453	logger.info('matric_no %s not found' % value)
[1783]	454	err = 'no student with matric_no %s' % (value)
[1747]	455	break
[1146]	456	datastructure['student'] = res[0]
[1747]	457	if results is not None:
	458	res = results(matric_no = value)
	459	if len(res) < 1:
[1783]	460	err = 'no results with matric_no %s' % (value)
[1747]	461	continue
	462	datastructure['results'] = res
[1146]	463	break
[1189]	464	if err:
	465	datastructure.setError(widget_id, err)
	466	else:
	467	datamodel = datastructure.getDataModel()
	468	datamodel[self.fields[0]] = value
	469	return not err
[1146]	470
	471	InitializeClass(MatricNoWidget)
	472
	473	widgetRegistry.register(MatricNoWidget)
	474	###)
	475
[1393]	476	class StudentIdWidget(CPSStringWidget): ###(
	477	""" StudentId Widget"""
	478	meta_type = "StudentId Widget"
	479	def validate(self, datastructure, **kw):
	480	"""Validate datastructure and update datamodel."""
	481	valid = CPSStringWidget.validate(self, datastructure, **kw)
[1571]	482	logger = logging.getLogger('Widgets.StudentIdWidget.validate')
[1393]	483	#import pdb;pdb.set_trace()
	484	s_cat = self.students_catalog
	485	err = 0
	486	widget_id = self.getWidgetId()
	487	value = datastructure[widget_id]
	488	if not valid or not value:
[1783]	489	err = 'invalid Id string %s' % value
[1573]	490	logger.info('Invalid id string %s' % value)
[1449]	491	datastructure['student'] = None
[1393]	492	else:
	493	value = value.upper()
	494	res = s_cat(id = value)
	495	if not res:
[1573]	496	logger.info('Student id %s not found' % value)
[1783]	497	err = 'no student with Id %s' % (value)
[1393]	498	datastructure['student'] = None
	499	else:
	500	datastructure['student'] = res[0]
	501	if err:
	502	datastructure.setError(widget_id, err)
	503	else:
	504	datamodel = datastructure.getDataModel()
	505	datamodel[self.fields[0]] = value
	506	return not err
	507
	508	InitializeClass(StudentIdWidget)
	509
	510	widgetRegistry.register(StudentIdWidget)
	511	###)
	512
[1146]	513	class WAeUPMultilineResultsWidget(CPSStringWidget): ###(
	514	""" WAeUPMultilineResults Widget"""
	515	meta_type = "WAeUp Multiline Results Widget"
	516	_properties = CPSWidget._properties + (
	517	{'id': 'nr_of_lines', 'type': 'int', 'mode': 'w',
	518	'label': 'Nr of Lines'},
	519	)
	520	nr_of_lines = 5
	521	def prepare(self, datastructure, **kw): ###(
	522	"""Prepare datastructure from datamodel."""
	523	datamodel = datastructure.getDataModel()
	524	#import pdb;pdb.set_trace()
	525	widget_id = self.getWidgetId()
	526	v = datamodel[self.fields[0]]
	527	if type(v) is ListType and v:
	528	nr_results = len(v)
	529	else:
	530	v = []
	531	nr_results = 0
	532	count = 1
	533	for s,g in v:
	534	wid = "%s%02d"% (widget_id,count)
	535	datastructure[wid+'_s'] = s
	536	datastructure[wid+'_g'] = g
	537	count += 1
	538	if nr_results < self.nr_of_lines:
	539	for line in range(nr_results,self.nr_of_lines):
	540	v.append(('',''))
	541	wid = "%s%02d"% (widget_id,line)
	542	datastructure[wid+'_s'] = ''
	543	datastructure[wid+'_g'] = ''
	544	datastructure[widget_id] = v
	545	datastructure[widget_id+'_s'] = ''
	546	datastructure[widget_id+'_g'] = ''
	547	###)
	548
	549	def validate(self, datastructure, **kw): ###(
	550	"""Validate datastructure and update datamodel."""
	551	#import pdb;pdb.set_trace()
	552	widget_id = self.getWidgetId()
	553	err = 0
	554	lines = []
	555	for line in range(1,30):
	556	wid = "%s%02d"% (widget_id,line)
	557	if not datastructure.has_key(wid+'_s'):
	558	break
	559	lines.append((datastructure[wid+'_s'].strip(),
	560	datastructure[wid+'_g'].strip()))
[1155]	561
[1146]	562	s = datastructure[widget_id+'_s'].strip()
	563	g = datastructure[widget_id+'_g'].strip()
	564	if s and g:
	565	lines.append((s,g))
	566	active = []
	567	for s,g in lines:
	568	if g != "":
	569	active.append((s,g))
	570	if err:
	571	datastructure.setError(widget_id, err)
	572	else:
	573	datamodel = datastructure.getDataModel()
	574	datamodel[self.fields[0]] = active
	575	return not err
	576	###)
	577
	578	def render(self, mode, datastructure, **kw): ###(
	579	"""Render in mode from datastructure."""
	580	render_method = 'widget_waeup_multiline_result_render'
	581	meth = getattr(self, render_method, None)
	582	if meth is None:
	583	raise RuntimeError("Unknown Render Method %s for widget type %s"
	584	% (render_method, self.getId()))
	585	#import pdb;pdb.set_trace()
	586	datamodel = datastructure.getDataModel()
	587	widget_id = self.getWidgetId()
	588	lines = datamodel[self.fields[0]]
	589	if len(lines) < self.nr_of_lines:
	590	for line in range(len(lines),self.nr_of_lines + 1):
	591	lines.append(('',''))
	592	datastructure[widget_id] = lines
	593	datastructure[widget_id+'_s'] = ''
	594	datastructure[widget_id+'_g'] = ''
	595	## count = 1
	596	## for s,g in v:
	597	## wid = "%s%02d"% (widget_id,count)
	598	## count += 1
	599	return meth(mode=mode,
	600	datastructure=datastructure,
	601	)
	602	###)
	603
	604
	605	InitializeClass(WAeUPMultilineResultsWidget)
	606	widgetRegistry.register(WAeUPMultilineResultsWidget)
	607	###)
	608
[794]	609	class WAeUPResultsWidget(CPSStringWidget): ###(
	610	""" WAeUPResults Widget"""
	611	meta_type = "WAeUp Results Widget"
	612
	613	def prepare(self, datastructure, **kw): ###(
	614	"""Prepare datastructure from datamodel."""
	615	datamodel = datastructure.getDataModel()
	616	v = datamodel[self.fields[0]]
	617	#import pdb;pdb.set_trace()
	618	widget_id = self.getWidgetId()
[807]	619	datastructure[widget_id] = v
[794]	620	datastructure[widget_id+'_s'] = ''
	621	datastructure[widget_id+'_g'] = ''
	622	###)
	623
	624	def validate(self, datastructure, **kw): ###(
	625	"""Validate datastructure and update datamodel."""
[807]	626	#import pdb;pdb.set_trace()
[794]	627	widget_id = self.getWidgetId()
	628	v = datastructure[widget_id]
	629	err = 0
	630	s = datastructure[widget_id+'_s'].strip()
	631	g = datastructure[widget_id+'_g'].strip()
[807]	632	while 1:
	633	if not s and g:
[1783]	634	err = "no subject grade for subject %s " % s
[807]	635	break
	636	i = 0
	637	done = False
	638	for sv,gv in v:
	639	if sv == s:
	640	done = True
	641	if not g:
	642	v.pop(i)
	643	break
	644	v[i] = (s,g)
	645	break
	646	i += 1
	647	if done:
	648	break
	649	if s and g:
	650	v.append((s,g))
	651	break
[794]	652	if err:
	653	datastructure.setError(widget_id, err)
	654	else:
	655	datamodel = datastructure.getDataModel()
	656	datamodel[self.fields[0]] = v
	657	datastructure[widget_id+'_s'] = s
	658	datastructure[widget_id+'_g'] = g
	659	return not err
	660	###)
	661
	662	def render(self, mode, datastructure, **kw): ###(
	663	"""Render in mode from datastructure."""
	664	render_method = 'widget_waeup_result_render'
	665	meth = getattr(self, render_method, None)
	666	if meth is None:
	667	raise RuntimeError("Unknown Render Method %s for widget type %s"
	668	% (render_method, self.getId()))
	669	#import pdb;pdb.set_trace()
	670	datamodel = datastructure.getDataModel()
	671	widget_id = self.getWidgetId()
	672	datastructure[widget_id+'_s'] = ''
	673	datastructure[widget_id+'_g'] = ''
	674	return meth(mode=mode,
	675	datastructure=datastructure,
	676	)
	677	###)
	678
	679
	680	InitializeClass(WAeUPResultsWidget)
	681	widgetRegistry.register(WAeUPResultsWidget)
	682	###)
	683
[488]	684	class ScratchCardPin: ###(
	685	"""the ScratchCardPin"""
	686	def __init__(self,prefix,batch_no,number):
[990]	687	if not batch_no and not number:
	688	s = prefix
[996]	689	if len(s) > 3:
[990]	690	prefix,batch_no,number = s[:3],s[3:-10],s[-10:]
	691	else:
[996]	692	prefix,batch_no,number = s,'',''
[488]	693	self.p = prefix
	694	self.b = batch_no
	695	self.n = number
	696
	697	def __str__(self):
	698	return "%s-%s-%s" % (self.p,self.b,self.n)
[1146]	699
	700	def __repr__(self):
	701	return "%s%s%s" % (self.p,self.b,self.n)
[488]	702	###)
	703
[47]	704	class ScratchcardPinWidget(CPSStringWidget): ###(
[22]	705	""" ScratchcardPin Widget"""
[199]	706	meta_type = "Scratchcard Pin Widget"
[488]	707	_properties = CPSWidget._properties + (
	708	{'id': 'prefix', 'type': 'string', 'mode': 'w',
	709	'label': 'Prefix'},
	710	{'id': 'reference', 'type': 'string', 'mode': 'w',
	711	'label': 'Reference Field'},
	712	)
	713	prefix = ''
	714	reference = ''
[502]	715	def prepare(self, datastructure, **kw): ###(
[488]	716	"""Prepare datastructure from datamodel."""
	717	datamodel = datastructure.getDataModel()
	718	v = datamodel[self.fields[0]]
	719	widget_id = self.getWidgetId()
[742]	720	#import pdb;pdb.set_trace()
[747]	721	if v and type(v) is StringType:
[990]	722	try:
	723	p,b,n = v.split('-')
	724	v = ScratchCardPin(p,b,n)
	725	except ValueError:
	726	v = ScratchCardPin(v,'','')
[488]	727	if v:
[742]	728	p = '%s' % v.p
[488]	729	b = '%s' % v.b
	730	n = '%s' % v.n
	731	else:
[742]	732	p = self.prefix
	733	if p.startswith('@'):
	734	p = getattr(self,self.prefix[1:])()
[488]	735	b = n = ''
[742]	736	v = ScratchCardPin(p,b,n)
[488]	737	datastructure[widget_id] = v
[742]	738	datastructure[widget_id+'_p'] = p
[488]	739	datastructure[widget_id+'_b'] = b
	740	datastructure[widget_id+'_n'] = n
[1376]	741	###)
[758]	742
[1169]	743	def validate(self, datastructure, **kw): ###(
[22]	744	"""Validate datastructure and update datamodel."""
[1571]	745	s_logger = logging.getLogger('Widgets.ScratchcardPinWidget.validate')
[488]	746	widget_id = self.getWidgetId()
	747	v = datastructure[widget_id]
[996]	748	#import pdb;pdb.set_trace()
[488]	749	err = 0
[742]	750	prefix= self.prefix
	751	if prefix.startswith('@'):
	752	prefix= getattr(self,self.prefix[1:])()
[488]	753	b = datastructure[widget_id+'_b'].strip()
	754	n = datastructure[widget_id+'_n'].strip()
[502]	755	pins = self.portal_pins
[742]	756	pin = "%(prefix)s%(b)s%(n)s" % vars()
[1376]	757	pin_str = "%(prefix)s-%(b)-s%(n)s" % vars()
[816]	758	do = 1
[1025]	759	s_id = str(self.portal_membership.getAuthenticatedMember())
[1326]	760	#import pdb;pdb.set_trace()
[1343]	761	if self.isStaff():
[1326]	762	do = 0
	763	err ='You are not a Student. PIN neither checked nor used.'
[1571]	764	s_logger.info('%s tried to use scratch card %s' % (s_id,pin_str))
[1557]	765	elif len(b) > 1 and b.find('-') > -1:
	766	do = 0
[1573]	767	err = 'PIN must not contain "-"'
	768	s_logger.info('%s entered invalid PIN containing "-"' % (s_id))
[1557]	769	elif n.find('-') > -1:
	770	do = 0
[1573]	771	err = 'PIN must not contain "-"'
	772	s_logger.info('%s entered invalid PIN containing "-"' % (s_id))
[1376]	773	elif len(n) != 10:
	774	do = 0
[1783]	775	err = 'invalid PIN length %d' % len(n)
[1573]	776	s_logger.info('%s entered invalid PIN with length %d' % (s_id,len(n)))
[1326]	777	elif self.reference == "":
[1030]	778	ref = s_id
[635]	779	else:
	780	ref = datastructure[self.reference]
[843]	781	if datastructure.errors:
[816]	782	do = 0
[1571]	783	datastructure.setError(widget_id, 'errors in other data, PIN neither checked nor used')
	784	s_logger.info('%s/%s entered wrong data together with PIN %s' % (s_id,ref,pin_str))
[816]	785	while do:
	786	ok = pins.searchAndSetRecord(pin,ref,prefix)
[1030]	787	if ok < -2 or ok > 2:
	788	err = 'Unknown error, please report!'
[1571]	789	s_logger.info('%s/%s caused unknown error with PIN %s' % (s_id,ref,pin_str))
[1030]	790	break
	791	elif ok == -2:
[1783]	792	err = 'Service already is activated but with a different PIN.'
[1571]	793	s_logger.info('%s/%s repeatedly activated service but with different PIN %s' % (s_id,ref,pin_str))
[710]	794	break
	795	elif ok == -1:
[1783]	796	err = 'invalid PIN'
[1571]	797	s_logger.info('%s/%s entered invalid PIN %s' % (s_id,ref,pin_str))
[502]	798	break
	799	if ok == 0:
[1571]	800	err = 'PIN already used'
	801	s_logger.info('%s/%s entered used PIN %s' % (s_id,ref,pin_str))
[502]	802	break
	803	if ok >= 1:
[710]	804	#import pdb;pdb.set_trace()
[635]	805	if self.isStudent():
[992]	806	if self.reference == "jamb_reg_no":
[997]	807	err = "You are already logged in."
[1573]	808	s_logger.info('%s/%s checked admission with PIN %s though logged in' % (s_id,ref,pin_str))
[992]	809	break
[1082]	810	if ok == 1:
[1571]	811	s_logger.info('%s/%s successfully used PIN %s' % (s_id,ref,pin_str))
[1032]	812	else:
[1571]	813	s_logger.info('%s/%s repeatedly used PIN %s' % (s_id,ref,pin_str))
[637]	814	break
[635]	815	else:
	816	student = getStudentByRegNo(self,ref)
[1571]	817	s_logger.info('%s/%s successfully used PIN %s' % (s_id,ref,pin_str))
[502]	818	if student is None:
[1783]	819	err = "student not found"
[1571]	820	s_logger.info('%s not found in admission list' % (ref))
[502]	821	break
[648]	822	s_id = student.getId()
[502]	823	if ok == 2:
[990]	824	if self.reference == "jamb_reg_no":
	825	if hasattr(self.portal_directories.students,s_id):
	826	err = "Please login with your Student Id %s and 10-digit PIN." % s_id
[1571]	827	s_logger.info('%s/%s repeatedly checked admission with PIN %s' % (s_id,ref,pin_str))
[990]	828	break
	829	else:
[1571]	830	s_logger.info('%s/%s (non-member) repeatedly checked admission with PIN %s' % (s_id,ref,pin_str))
[990]	831	else:
[1783]	832	err = "unknown error" % s_id
[1571]	833	s_logger.info('%s/%s repeatedly activated service with PIN %s' % (s_id,ref,pin_str))
[986]	834	break
	835	try:
	836	student.getContent().makeStudentMember(s_id,password=pin[4:])
[1571]	837	s_logger.info('%s/%s has been created using PIN %s' % (s_id,ref,pin_str))
[986]	838	except:
[989]	839	err = "Please login with your Student Id %s and 10-digit PIN." % s_id
[1571]	840	s_logger.info('%s/%s could not be made a member with PIN %s' % (s_id,ref,pin_str))
[986]	841	break
[502]	842	break
[488]	843	if err:
	844	datastructure.setError(widget_id, err)
	845	else:
	846	datamodel = datastructure.getDataModel()
[742]	847	datamodel[self.fields[0]] = ScratchCardPin(prefix,b,n)
	848	datastructure[widget_id] = ScratchCardPin(prefix,b,n)
	849	datastructure[widget_id+'_p'] = prefix
[488]	850	datastructure[widget_id+'_b'] = b
	851	datastructure[widget_id+'_n'] = n
[502]	852	datastructure['s_id'] = s_id
[488]	853	return not err
[444]	854
[1169]	855	###)
	856
[502]	857	def render(self, mode, datastructure, **kw): ###(
[488]	858	"""Render in mode from datastructure."""
	859	render_method = 'widget_scratch_card_pin_render'
	860	meth = getattr(self, render_method, None)
	861	if meth is None:
	862	raise RuntimeError("Unknown Render Method %s for widget type %s"
	863	% (render_method, self.getId()))
	864
	865	# XXX AT: datastructure has to be set again here, in case we're in edit
	866	# or create mode, because a default value has to be provided.
	867	#import pdb;pdb.set_trace()
	868	datamodel = datastructure.getDataModel()
	869	v = datamodel[self.fields[0]]
[502]	870	if v and type(v) is StringType:
[990]	871	try:
	872	p,b,n = v.split('-')
	873	v = ScratchCardPin(p,b,n)
	874	except ValueError:
[996]	875	v = ScratchCardPin(self.prefix,'1',v)
	876	pass
[488]	877	if v:
[742]	878	prefix= '%s' % v.p
[488]	879	b = '%s' % v.b
	880	n = '%s' % v.n
[22]	881	else:
[742]	882	prefix= self.prefix
	883	if prefix.startswith('@'):
	884	prefix= getattr(self,self.prefix[1:])()
[488]	885	b = n = ''
[742]	886	v = ScratchCardPin(prefix,b,n)
	887	widget_id = self.getWidgetId()
	888	datastructure[widget_id] = v
	889	datastructure[widget_id+'_p'] = prefix
	890	datastructure[widget_id+'_b'] = b
	891	datastructure[widget_id+'_n'] = n
[758]	892	return meth(mode=mode,
	893	datastructure=datastructure,
[488]	894	)
[523]	895	###)
[488]	896
	897
[22]	898	InitializeClass(ScratchcardPinWidget)
[199]	899	widgetRegistry.register(ScratchcardPinWidget)
[22]	900
[47]	901
	902	###)
	903
[1169]	904	class WAeUPImageWidget(CPSImageWidget): ###(
[537]	905	"""Photo widget."""
	906	meta_type = 'WAeUP Image Widget'
	907
	908	def render(self, mode, datastructure, **kw):
	909	render_method = 'widget_waeup_image_render'
	910	meth = getattr(self, render_method, None)
	911	if meth is None:
	912	raise RuntimeError("Unknown Render Method %s for widget type %s"
	913	% (render_method, self.getId()))
	914	img_info = self.getImageInfo(datastructure)
	915	return meth(mode=mode, datastructure=datastructure, **img_info)
	916
[1169]	917	###)
[537]	918
	919
[1169]	920
[537]	921	InitializeClass(WAeUPImageWidget)
	922
	923	widgetRegistry.register(WAeUPImageWidget)
	924
	925
[22]	926	###########
	927

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

Download in other formats: