Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1939

Last change on this file since 1939 was 1939, checked in by joachim, 18 years ago
add exportStudents
Property svn:keywords set to `Id`
File size: 61.7 KB

Line
1	#-- mode: python; mode: fold --
2	# $Id: Students.py 1939 2007-06-20 08:43:33Z joachim $
3	from string import Template
4	from Globals import InitializeClass
5	from AccessControl import ClassSecurityInfo
6	from AccessControl.SecurityManagement import newSecurityManager
7	from zExceptions import BadRequest
8	from Products.ZCatalog.ZCatalog import ZCatalog
9	from Products.CMFCore.utils import UniqueObject, getToolByName
10	from Products.CMFCore.permissions import View
11	from Products.CMFCore.permissions import ModifyPortalContent
12	from Products.CPSCore.CPSBase import CPSBase_adder, CPSBaseFolder
13	#from Products.CPSCore.CPSBase import CPSBaseDocument as BaseDocument
14	from Products.CPSDocument.CPSDocument import CPSDocument
15	from Products.CPSCore.CPSBase import CPSBaseBTreeFolder as BaseBTreeFolder
16	from Products.CPSCore.CPSMembershipTool import CPSUnrestrictedUser
17	from Products.WAeUP_SRP.Academics import makeCertificateCode
18	from Products.AdvancedQuery import Eq, Between, Le,In
19	import DateTime
20	import logging
21	import csv,re,os
22	import Globals
23	p_home = Globals.package_home(globals())
24	i_home = Globals.INSTANCE_HOME
25	MAX_TRANS = 1000
26	from urllib import urlencode
27
28	import DateTime
29	#import PIL.Image
30	from StringIO import StringIO
31
32	def makeCertificateCode(code): ###(
33	code = code.replace('.','')
34	code = code.replace('(','')
35	code = code.replace(')','')
36	code = code.replace('/','')
37	code = code.replace(' ','')
38	code = code.replace('_','')
39	return code
40
41	###)
42
43	def response_write(response,s): ###(
44	response.setHeader('Content-type','text/html; charset=ISO-8859-15')
45	while s.find('<') > -1:
46	s = s.replace('<','<')
47	while s.find('>') > -1:
48	#from pdb import set_trace;set_trace()
49	s = s.replace('>','>')
50	response.write("%s<br>\n" % s)
51
52	###)
53
54	def getInt(s): ###(
55	try:
56	return int(s)
57	except:
58	return 0
59
60	def getFloat(s):
61	try:
62	return float(s)
63	except:
64	return 0.0
65
66	###)
67
68	def getStudentByRegNo(self,reg_no): ###(
69	"""search student by JAMB Reg No and return StudentFolder"""
70	res = self.students_catalog(jamb_reg_no = reg_no)
71	if len(res) == 1:
72	return getattr(self.portal_url.getPortalObject().campus.students,res[0].id)
73	else:
74	return None
75	# don't search in portal_catalog
76	# search = ZCatalog.searchResults(self.portal_catalog_real,{'meta_type': 'StudentApplication',
77	# 'SearchableText': reg_no,
78	# })
79	# if len(search) < 1:
80	# return None
81	# return search[0].getObject().aq_parent
82
83	###)
84
85	def checkJambNo(jnr): ###(
86	try:
87	if len(jnr) != 10:
88	return False
89	except:
90	return False
91	try:
92	int(jnr[:8])
93	return True
94	except:
95	return False
96
97	###)
98
99	def formatLGA(lga):
100	if lga.find('_') > -1:
101	return "%s / %s" % (lga.split('_')[0].upper(),lga.split('_')[1].upper())
102	return lga
103
104	class StudentsFolder(CPSDocument): ###(
105	"""
106	WAeUP container for the various WAeUP containers data
107	"""
108	meta_type = 'StudentsFolder'
109	portal_type = meta_type
110	security = ClassSecurityInfo()
111
112	security.declareProtected(ModifyPortalContent,"loadPumeResultsFromCSV")###(
113	def loadPumeResultsFromCSV(self):
114	"""load Fulltime Studentdata from CSV values into pumeresults catalog"""
115	import transaction
116	import random
117	## csv_d = {'jamb_reg_no': "RegNumber", ###(
118	## 'status': "Admission Status",
119	## 'name': "Name",
120	## 'score': "Score",
121	## 'sex': "Sex",
122	## 'faculty': "Faculty",
123	## 'department': "Dept",
124	## 'course': "Course",
125	## 'course_code_org': "Course Code",
126	## }
127	###)
128	## csv_d = {'jamb_reg_no': "JAMBRegno",
129	## 'name': "Name",
130	## 'score': "Score",
131	## 'sex': "Sex",
132	## 'course': "Course",
133	## 'faculty': "Faculty",
134	## 'department': "Dept",
135	## 'course_code_org': "Course Code",
136	## 'status': "Admission Status",
137	## 'result_type': None,
138	## }
139
140	csv_d = {'jamb_reg_no': "reg_no",
141	'name': "fullname",
142	'score': "pume_score",
143	'sex': "sex",
144	'course': "study_course",
145	'course_code_org': "study_course",
146	'status': "admission_status",
147	'result_type': "entry_mode",
148	}
149
150	csv_fields = [f[1] for f in csv_d.items() if f[1]]
151	tr_count = 0
152	total = 0
153	#name = 'pup_new'
154	#name = 'pup_update'
155	name = 'Admitted_update'
156	update = name.endswith('update')
157	no_import = []
158	ok_import = []
159	ok_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_d.keys()]))
160	no_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_fields]))
161	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
162	ok_import_name = "%s/import/%s_imported_%s.csv" % (i_home,name,current)
163	#open(ok_import_name,"w").write('\n'.join(no_import))
164	no_import_name = "%s/import/%s_not_imported_%s.csv" % (i_home,name,current)
165	#open(no_import_name,"w").write('\n'.join(no_import))
166	logger = logging.getLogger('Students.loadPumeResultsFromCSV')
167	starttime = DateTime.now()
168	logger.info('Start loading from %s.csv' % name)
169	try:
170	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
171	except:
172	logger.error('Error reading %s.csv' % name)
173	return
174	pume = self.portal_pumeresults
175	format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
176	import_format = ','.join(['"%%(%s)s"' % fn for fn in csv_d.keys()])
177	eduplicate = '%s,"duplicate"' % format
178	eoriginal = '%s,"original"' % format
179	einvalidjamb = '%s,"invalid JambRegNo"' % format
180	added = 'added ,%s' % format
181	#from pdb import set_trace;set_trace()
182	for jamb in result:
183	dict = {}
184	for f,fn in csv_d.items():
185	dict[f] = jamb.get(csv_d[f])
186	dict['result_type'] = 'CEST'
187	jnr = jamb.get(csv_d['jamb_reg_no'])
188	#if not checkJambNo(jnr):
189	# logger.info(einvalidjamb % jamb)
190	# dd = {}
191	# for f,fn in csv_d.items():
192	# dd[fn] = getattr(data,f)
193	# no_import.append(eduplicate % dd)
194	# no_import.append(eduplicate % jamb)
195	# continue
196	res = pume(jamb_reg_no=jnr)
197	if len(res) > 0:
198	if update:
199	try:
200	pume.modifyRecord(**dict)
201	# Can not happen, but anyway...
202	except ValueError:
203	logger.info(eduplicate % jamb)
204	continue
205	# Can not happen, but anyway...
206	except KeyError:
207	pume.addRecord(**dict)
208	logger.info(added % jamb)
209	continue
210	else:
211	data = res[0]
212	if data.name != jamb.get(csv_d['name']):
213	#set_trace()
214	logger.info(eduplicate % jamb)
215	#em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
216	#logger.info(em)
217	dd = {}
218	for f,fn in csv_d.items():
219	dd[fn] = getattr(data,f)
220	no_import.append(eoriginal % dd)
221	no_import.append(eduplicate % jamb)
222	continue
223	else:
224	try:
225	pume.addRecord(**dict)
226	ok_import.append(import_format % dict)
227	except ValueError:
228	logger.info(eduplicate % jamb)
229	#em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
230	#logger.info(em)
231	no_import.append(eduplicate % jamb)
232	logger.info('End loading from %s.csv' % name)
233	if len(no_import) > 1:
234	open(no_import_name,"w+").write('\n'.join(no_import))
235	open(ok_import_name,"w+").write('\n'.join(ok_import))
236	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
237	###)
238
239	security.declareProtected(ModifyPortalContent,"createStudents")###(
240	def createStudents(self):
241	"""
242	load addmitted Studentdata from CSV values and create Studentobjects.
243	This is the current method to create new addmitted Students.
244	Before running the eventservice for the students_catalog must be disabled.
245	"""
246	import transaction
247	import random
248	#from pdb import set_trace
249	wftool = self.portal_workflow
250	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
251	students_folder = self.portal_url.getPortalObject().campus.students
252	levels = {'ume_ft':'100',
253	'de_ft': '200',
254	'ug_pt': '100',
255	'de_pt': '200',
256	'pg_ft': '700',
257	'pg_pt': '700',
258	'dp_pt': '100',
259	'dp_ft': '100',
260	}
261	csv_d = {'jamb_reg_no': "reg_no",
262	'entry_mode': 'entry_mode',
263	'jamb_firstname': "firstname",
264	'jamb_middlename': "middlename",
265	'jamb_lastname': "lastname",
266	'jamb_sex': "sex",
267	'jamb_state': "state",
268	'birthday': "date_of_birth",
269	'app_email': "email",
270	'study_course': "study_course",
271	'perm_address': "address",
272	'admission_status': "admission_status",
273	}
274	csv_fields = [f[1] for f in csv_d.items()]
275	tr_count = 0
276	total = 0
277	#name = 'pume_results'
278	name = 'Admitted'
279	no_import = []
280	s = ','.join(['"%s"' % fn for fn in csv_fields])
281	no_import.append('"Error",%s' % s)
282	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
283	no_certificate = "no certificate %s" % format
284	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
285	logger = logging.getLogger('Students.StudentsFolder.createStudents')
286	logger.info('Start loading from %s.csv' % name)
287	certs = {}
288	try:
289	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
290	except:
291	logger.error('Error reading %s.csv' % name)
292	return
293	for result in results:
294	if not result.get(csv_d['admission_status']).startswith('Admitted'):
295	continue
296	#result['Error'] = "Processing "
297	#logger.info(format % result)
298	jamb_reg_no = result.get(csv_d['jamb_reg_no'])
299	res = self.students_catalog(jamb_reg_no = jamb_reg_no)
300	if res:
301	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
302	logger.info(em)
303	result['Error'] = "Student exists"
304	no_import.append(format % result)
305	continue
306	cert_id = makeCertificateCode(result.get(csv_d['study_course']))
307	if cert_id not in certs.keys():
308	res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
309	if not res:
310	em = 'No Certificate with ID %s \n' % cert_id
311	logger.info(em)
312	result['Error'] = "No Certificate %s" % cert_id
313	no_import.append( format % result)
314	continue
315	cert = res[0]
316	cert_path = cert.getPath().split('/')
317	certificate = certs[cert_id] = {'faculty': cert_path[-4],
318	'department': cert_path[-3]}
319	cert_doc = certs[cert_id]
320	catalog_entry = {}
321	catalog_entry['jamb_reg_no'] = jamb_reg_no
322	firstname = result.get(csv_d['jamb_firstname'])
323	middlename = result.get(csv_d['jamb_middlename'])
324	lastname = result.get(csv_d['jamb_lastname'])
325	if len(firstname) < 3\
326	and len(middlename) < 3\
327	and len(lastname) < 3:
328	em = 'Student Names to short \n'
329	logger.info(em)
330	result['Error'] = "Names to short"
331	no_import.append( format % result)
332	continue
333	perm_address = result.get(csv_d['perm_address'])
334	sid = self.generateStudentId('x')
335	students_folder.invokeFactory('Student', sid)
336	catalog_entry['id'] = sid
337	tr_count += 1
338	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s reg_no %(jamb_reg_no)s ' % vars())
339	student = getattr(self,sid)
340	student.manage_setLocalRoles(sid, ['Owner',])
341	student.invokeFactory('StudentApplication','application')
342	da = {'Title': 'Application Data'}
343	da["jamb_firstname"] = firstname
344	da["jamb_middlename"] = middlename
345	da["jamb_lastname"] = lastname
346	catalog_entry['entry_session'] = da["entry_session"] = self.getSessionId()[-2:]
347	catalog_entry['sex'] = sex = result.get(csv_d['jamb_sex']).startswith('F')
348	da_fields = ('jamb_reg_no',
349	'jamb_sex',
350	'jamb_state',
351	'entry_mode',
352	'app_email',
353	)
354	for f in da_fields:
355	da[f] = result.get(csv_d[f])
356	catalog_entry['email'] = da['app_email']
357	catalog_entry['entry_mode'] = da['entry_mode']
358	app = student.application
359	app_doc = app.getContent()
360	app.getContent().edit(mapping=da)
361	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
362	app.manage_setLocalRoles(sid, ['Owner',])
363
364	picture_id = da['jamb_reg_no'].replace('/','_')
365	file = None
366	for ext in ('jpg','JPG'):
367	picture ="%s/import/pictures_admitted_latest/%s.%s" % (i_home,picture_id,ext)
368	if os.path.exists(picture):
369	file = open(picture)
370	break
371	if file is not None:
372
373	## file conversion does not work
374	#img = PIL.Image.open(file)
375	#img.thumbnail((150,200),
376	# resample=PIL.Image.ANTIALIAS)
377	#outfile = StringIO()
378	#img.save(outfile, format=img.format)
379
380	outfile = file.read()
381	app_doc.manage_addFile('passport',
382	file=outfile,
383	title="%s.jpg" % jamb_reg_no)
384	#wftool.doActionFor(app,'close')
385	dp = {}
386	dp['firstname'] = firstname
387	dp['middlename'] = middlename
388	dp['lastname'] = lastname
389	dp['email'] = da['app_email']
390	dp['sex'] = sex
391	dp['perm_address'] = perm_address
392	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
393	student.invokeFactory('StudentPersonal','personal')
394	per = student.personal
395	per_doc = per.getContent()
396	per_doc.edit(mapping = dp)
397	per.manage_setLocalRoles(sid, ['Owner',])
398	wftool.doActionFor(student,'pume_pass')
399	wftool.doActionFor(student,'admit')
400	#
401	# Clearance
402	#
403	student.invokeFactory('StudentClearance','clearance')
404	#wftool.doActionFor(student.clearance,'open')
405	clearance = student.clearance
406	dc = {'Title': 'Clearance/Eligibility Record'}
407	clearance = student.clearance
408	date_str = result.get(csv_d['birthday'])
409	try:
410	date = DateTime.DateTime(date_str)
411	except:
412	#import pdb;pdb.set_trace()
413	date = None
414	dc['birthday'] = date
415	clearance.getContent().edit(mapping=dc)
416	clearance.manage_setLocalRoles(sid, ['Owner',])
417	#
418	# Study Course
419	#
420	student.invokeFactory('StudentStudyCourse','study_course')
421	study_course = student.study_course
422	dsc = {}
423	catalog_entry['level'] = dsc['current_level'] = levels.get(da['entry_mode'],'100')
424	#catalog_entry['level'] = dsc['current_level'] = '100' # Attention: not for DE students
425	catalog_entry['session'] = dsc['current_session'] = da['entry_session']
426	catalog_entry['mode'] = dsc['current_mode'] = da['entry_mode']
427	catalog_entry['course'] = dsc['study_course'] = cert_id
428	catalog_entry['faculty'] = certificate['faculty']
429	catalog_entry['department'] = certificate['department']
430	catalog_entry['verdict'] = dsc['current_verdict'] = 'N/A'
431	catalog_entry['review_state'] = self.portal_workflow.getInfoFor(student,'review_state',None)
432	study_course.getContent().edit(mapping=dsc)
433	#import pdb;pdb.set_trace()
434	self.students_catalog.addRecord(**catalog_entry)
435	if tr_count > 100:
436	if len(no_import) > 0:
437	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
438	'\n'.join(no_import) + "\n")
439	no_import = []
440	em = '%d transactions commited\n' % tr_count
441	transaction.commit()
442	logger.info(em)
443	total += tr_count
444	tr_count = 0
445	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
446	'\n'.join(no_import))
447	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
448	###)
449
450	security.declareProtected(ModifyPortalContent,"transferStudents")###(
451	def transferStudents(self,filename):
452	"""
453	load Interfaculty transferStudents Studentdata from CSV values.
454	"""
455	import transaction
456	import random
457	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
458	pm = self.portal_membership
459	member = pm.getAuthenticatedMember()
460	logger = logging.getLogger('Students.StudentsFolder.transferStudents')
461	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
462	students_folder = self.portal_url.getPortalObject().campus.students
463	csv_fields = ('old_matric_no',
464	'matric_no',
465	'study_course',
466	'current_mode',
467	'current_level',
468	)
469	tr_count = 0
470	total = 0
471	total_imported = 0
472	total_not_imported = 0
473	imported = []
474	not_imported = []
475	certs = {}
476	try:
477	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,filename),"rb"))
478	except:
479	logger.error('Error reading %s.csv' % filename)
480	return
481	start = True
482	for result in results:
483	total += 1
484	if start:
485	start = False
486	logger.info('%s starts import from %s.csv' % (member,filename))
487	import_keys = [k for k in result.keys() if not k.startswith('ignore')]
488	diff2schema = set(import_keys).difference(set(csv_fields))
489	if diff2schema:
490	em = "not ignorable key(s) %s found in heading" % diff2schema
491	return em
492	s = ','.join(['"%s"' % fn for fn in import_keys])
493	open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(s + ',"Error"'+ '\n')
494	s = '"id",' + s
495	open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(s + '\n')
496	format = ','.join(['"%%(%s)s"' % fn for fn in import_keys])
497	format_error = format + ',"%(Error)s"'
498	format = '"%(id)s",'+ format
499	old_matric_no = result.get('old_matric_no')
500	res = self.students_catalog(matric_no = old_matric_no)
501	result['id'] = "None"
502	if not res:
503	em = 'Student with matric_no %s not found' % old_matric_no
504	logger.info(em)
505	result['Error'] = "Student does not exist"
506	not_imported.append(format_error % result)
507	total_not_imported += 1
508	continue
509	student_brain = res[0]
510	student_object = getattr(students_folder,student_brain.id)
511	result['id'] = student_brain.id
512	cert_id = makeCertificateCode(result.get('study_course'))
513	if cert_id not in certs.keys():
514	res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
515	if not res:
516	em = 'No certificate with ID %s \n' % cert_id
517	logger.info(em)
518	result['Error'] = "No Certificate %s" % cert_id
519	not_imported.append( format_error % result)
520	total_not_imported += 1
521	continue
522	cert = res[0]
523	cert_path = cert.getPath().split('/')
524	certificate = certs[cert_id] = {'faculty': cert_path[-4],
525	'department': cert_path[-3]}
526	cert_doc = certs[cert_id]
527	clearance = getattr(student_object,'clearance',None)
528	if clearance is None:
529	em = 'Student has no clearance object'
530	logger.info(em)
531	result['Error'] = em
532	not_imported.append( format_error % result)
533	total_not_imported += 1
534	continue
535	clearance_doc = clearance.getContent()
536	study_course = student_object.study_course
537	study_course_doc = study_course.getContent()
538	old_study_course = study_course_doc.study_course
539	old_current_level = study_course_doc.current_level
540	current_level = result.get('current_level',None)
541	new_study_course = result.get('study_course',None)
542	try:
543	icl = int(current_level)
544	except:
545	em = 'Invalid new level %s' % current_level
546	logger.info(em)
547	result['Error'] = em
548	not_imported.append( format_error % result)
549	total_not_imported += 1
550	continue
551	if icl == int(old_current_level) and old_study_course == new_study_course:
552	em = 'Already transferred'
553	logger.info(em)
554	result['Error'] = em
555	not_imported.append( format_error % result)
556	total_not_imported += 1
557	continue
558	if study_course.objectIds():
559	em = 'Already registered level %s for %s, but is supposed to study %s at level %s' % (old_current_level,old_study_course,new_study_course,current_level)
560	logger.info(em)
561	result['Error'] = em
562	not_imported.append( format_error % result)
563	total_not_imported += 1
564	continue
565	#from pdb import set_trace; set_trace()
566	cd = {}
567	matric_no_history = getattr(clearance_doc,'matric_no_history',[])
568	if not matric_no_history:
569	matric_no_history = []
570	matric_no_history.append(old_matric_no)
571	cd['matric_no_history'] = matric_no_history
572	cd['matric_no'] = result.get('matric_no')
573	clearance_doc.edit(mapping = cd)
574	dsc = {}
575	study_course_history = getattr(study_course_doc,'study_course_history',[])
576	if not study_course_history:
577	study_course_history = []
578	study_course_history.append(old_study_course)
579	dsc['study_course_history'] = study_course_history
580	dsc['study_course'] = new_study_course
581	dsc['current_level'] = current_level
582	dsc['current_mode'] = result.get('current_mode')
583	study_course_doc.edit(mapping=dsc)
584	imported.append( format % result)
585	tr_count += 1
586	total_imported += 1
587	if tr_count > 1000:
588	if len(not_imported) > 0:
589	open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(
590	'\n'.join(not_imported) + '\n')
591	not_imported = []
592	if len(imported) > 0:
593	open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(
594	'\n'.join(imported) + '\n')
595	imported = []
596	em = '%d transactions committed\n' % (tr_count)
597	transaction.commit()
598	regs = []
599	logger.info(em)
600	tr_count = 0
601	if len(imported) > 0:
602	open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(
603	'\n'.join(imported))
604	if len(not_imported) > 0:
605	open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(
606	'\n'.join(not_imported))
607	em = "Imported: %d, not imported: %d of total %d" % (total_imported,total_not_imported,total)
608	logger.info(em)
609	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
610	###)
611
612	security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
613	def importReturningStudents(self):
614	"""load Returning Studentdata from CSV values"""
615	import transaction
616	import random
617	#from pdb import set_trace
618	wftool = self.portal_workflow
619	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
620	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
621	students_folder = self.portal_url.getPortalObject().campus.students
622	tr_count = 1
623	total = 0
624	#name = 'pume_results'
625	name = 'Returning'
626	table = self.returning_import
627	no_import = []
628	imported = []
629	logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
630	try:
631	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
632	except:
633	logger.error('Error reading %s.csv' % name)
634	return
635	l = self.portal_catalog({'meta_type': "Certificate"})
636	certs = {}
637	cert_docs = {}
638	for f in l:
639	certs[f.getId] = f.getObject().getContent()
640	start = True
641	res = table()
642	regs = []
643	if len(res) > 0:
644	regs = [s.matric_no for s in res]
645	#import pdb;pdb.set_trace()
646	for student in returning:
647	if start:
648	start = False
649	logger.info('Start loading from %s.csv' % name)
650	s = ','.join(['"%s"' % fn for fn in student.keys()])
651	imported.append(s)
652	no_import.append('%s,"Error"' % s)
653	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
654	format_error = format + ',"%(Error)s"'
655	no_certificate = "no certificate %s" % format
656	student['matric_no'] = matric_no = student.get('matric_no').upper()
657	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
658	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
659	if matric_no == '':
660	student['Error'] = "Empty matric_no"
661	no_import.append( format_error % student)
662	continue
663	if matric_no in regs or self.returning_import(matric_no = matric_no):
664	student['Error'] = "Duplicate"
665	no_import.append( format_error % student)
666	continue
667	cert_id = makeCertificateCode(student.get('Coursemajorcode'))
668	if cert_id not in certs.keys():
669	student['Error'] = "No Certificate %s" % cert_id
670	no_import.append( format_error % student)
671	continue
672	try:
673	table.addRecord(**student)
674	except ValueError:
675	student['Error'] = "Duplicate"
676	no_import.append( format_error % student)
677	continue
678	regs.append(student.get('matric_no'))
679	imported.append(format % student)
680	tr_count += 1
681	if tr_count > 1000:
682	if len(no_import) > 0:
683	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
684	'\n'.join(no_import) + '\n')
685	no_import = []
686	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
687	'\n'.join(no_import) + "\n")
688	imported = []
689	em = '%d transactions commited total %s\n' % (tr_count,total)
690	transaction.commit()
691	regs = []
692	logger.info(em)
693	total += tr_count
694	tr_count = 0
695	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
696	'\n'.join(imported))
697	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
698	'\n'.join(no_import))
699	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
700	###)
701
702	security.declareProtected(ModifyPortalContent,"fixAllNames")###(
703	def fixAllNames(self):
704	"fix all students names"
705	import transaction
706	response = self.REQUEST.RESPONSE
707	logger = logging.getLogger('fixAllNames')
708	logger.info('Start')
709	students = self.portal_catalog(portal_type='Student')
710	count = 0
711	total = 0
712	for student in students:
713	scat_res = self.students_catalog(id = student.getId)
714	if not scat_res:
715	self.students_catalog.addRecord(id = student.getId)
716	scat_res = self.students_catalog(id = student.getId)
717	student_entry = scat_res[0]
718	old_new = self.fixName(student,student_entry)
719	count += 1
720	response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
721	if count > 2000:
722	transaction.commit()
723	logger.info("%d transactions commited" % count)
724	total += count
725	count = 0
726	###)
727
728	security.declareProtected(ModifyPortalContent,"fixName")###(
729	def fixName(self,student_brain, student_entry):
730	"fix the name of a student"
731	fix = "first"
732	if student_entry.get('name_fixed',None) == fix:
733	return "Name already fixed"
734	student_id = student_entry.id
735	new_student = student_entry.jamb_reg_no.startswith('6')
736	student_obj = student_brain.getObject()
737	personal = getattr(student_obj,'personal',None)
738	invalid = ''
739	if personal is None:
740	return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
741	per_doc = personal.getContent()
742	old_first = per_doc.firstname
743	old_middle = per_doc.middlename
744	old_last = per_doc.lastname
745	new_first = ''
746	new_middle = ''
747	new_last = ''
748	if new_student:
749	if not old_first and not old_middle and old_last:
750	new_names = [n.capitalize() for n in old_last.split()]
751	if len(new_names) > 1:
752	old_first = new_names[0]
753	old_last = new_names[-1]
754	old_middle = ' '.join(new_names[1:-1])
755	else:
756	old_last = new_names[0]
757	old_first = ''
758	old_middle = ''
759	if old_first:
760	new_first = old_first
761	if old_middle:
762	new_middle = old_middle
763	if old_last:
764	new_last = old_last
765	if old_first.find('<') != -1 or\
766	old_first.find('>') != -1 or\
767	old_middle.find('<') != -1 or\
768	old_middle.find('>') != -1 or\
769	old_last.find('<') != -1 or\
770	old_last.find('>') != -1:
771	invalid = "invalid characters"
772	else:
773	new_first = old_first
774	if new_first.strip() == '-':
775	new_first = ''
776	new_middle = old_middle
777	if new_middle.strip() == '-':
778	new_middle = ''
779	new_last = old_last
780	if new_last.strip() == '-':
781	new_last = ''
782	name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
783	if new_student:
784	text = "New"
785	else:
786	text = "Returning"
787	old_new = '"%s","%s","%s","%s"' % (invalid,text,
788	student_entry.name,
789	name)
790	if not invalid:
791	self.students_catalog.modifyRecord(id = student_id,
792	name_fixed = fix,
793	name = name)
794	per_doc.edit(mapping = {'firstname' : new_first,
795	'middlename' : new_middle,
796	'lastname' : new_last,
797	})
798	return old_new
799	###)
800
801	security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
802	def updateReturningStudents(self):
803	"""load and overwrite Returning Student Data from CSV values"""
804	import transaction
805	import random
806	#from pdb import set_trace
807	wftool = self.portal_workflow
808	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
809	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
810	students_folder = self.portal_url.getPortalObject().campus.students
811	tr_count = 1
812	total = 0
813	#name = 'pume_results'
814	name = 'Returning_update'
815	table = self.returning_import
816	no_import = []
817	imported = []
818	logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
819	try:
820	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
821	except:
822	logger.error('Error reading %s.csv' % name)
823	return
824	l = self.portal_catalog({'meta_type': "Certificate"})
825	certs = {}
826	cert_docs = {}
827	for f in l:
828	certs[f.getId] = f.getObject().getContent()
829	start = True
830	res = table()
831	regs = []
832	if len(res) > 0:
833	regs = [s.matric_no for s in res]
834	for student in returning:
835	if start:
836	start = False
837	logger.info('Start loading from %s.csv' % name)
838	s = ','.join(['"%s"' % fn for fn in student.keys()])
839	imported.append(s)
840	no_import.append('%s,"Error"' % s)
841	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
842	format_error = format + ',"%(Error)s"'
843	no_certificate = "no certificate %s" % format
844	matric_no = student.get('matric_no').upper()
845	student['matric_no'] = matric_no
846	if matric_no == '':
847	student['Error'] = "Empty matric_no"
848	no_import.append( format_error % student)
849	continue
850	# if matric_no in regs or self.returning_import(matric_no = matric_no):
851	# student['Error'] = "Duplicate"
852	# no_import.append( format_error % student)
853	# continue
854	# cert_id = makeCertificateCode(student.get('Coursemajorcode'))
855	# if cert_id not in certs.keys():
856	# student['Error'] = "No Certificate %s" % cert_id
857	# no_import.append( format_error % student)
858	# continue
859	try:
860	table.modifyRecord(**student)
861	except KeyError:
862	#import pdb;pdb.set_trace()
863	student['Error'] = "no Student found to update"
864	no_import.append( format_error % student)
865	continue
866	#s = self.students_catalog(matric_no=matric_no)
867	#if s:
868	# level = "%s" % (int(student.get('Level')) + 100)
869	# self.students_catalog.modifyRecord(id = s[0].id,
870	# level=level)
871
872	regs.append(student.get('matric_no'))
873	imported.append(format % student)
874	tr_count += 1
875	if tr_count > 1000:
876	if len(no_import) > 0:
877	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
878	'\n'.join(no_import) + '\n')
879	no_import = []
880	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
881	'\n'.join(no_import) + "\n")
882	imported = []
883	em = '%d transactions commited total %s\n' % (tr_count,total)
884	transaction.commit()
885	regs = []
886	logger.info(em)
887	total += tr_count
888	tr_count = 0
889	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
890	'\n'.join(imported))
891	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
892	'\n'.join(no_import))
893	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
894	###)
895
896	security.declareProtected(ModifyPortalContent,"exportStudents")###(
897	def exportStudents(self):
898	"""export Studentsdata to a file"""
899	logger = logging.getLogger('Students.exportStudents')
900	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
901	students_folder = self.portal_url.getPortalObject().campus.students
902	export_file = "%s/export/students_%s.csv" % (i_home,current)
903	from Products.AdvancedQuery import Eq, Between, Le,In,MatchRegexp
904	aq_students = self.students_catalog.evalAdvancedQuery
905	toexport = {'students_catalog': ("id",
906	"matric_no",
907	"jamb_reg_no",
908	"review_state",
909	"sex",
910	"email",
911	"faculty",
912	"department",
913	"course",
914	"level",
915	),
916	'personal': ('firstname',
917	'middlename',
918	'lastname',
919	'perm_address',
920	),
921	'clearance': ('state',
922	'lga',
923	)
924	}
925	res_list = []
926	lines = []
927	fields = []
928	with_lga = False
929	for k in toexport.keys():
930	for f in toexport[k]:
931	if f == 'lga' :
932	with_lga = True
933	fields.append(f)
934	headline = ','.join(fields)
935	open(export_file,"a").write(headline +'\n')
936	format = '"%(' + ')s","%('.join(fields) + ')s"'
937	query = In('review_state',('cleared_and_validated',
938	'school_fee_paid',
939	'courses_registered',
940	'courses_validated'))
941	students = aq_students(query)
942	chunk = 100
943	total = 0
944	for student in students:
945	not_all = False
946	d = self.getFormattedStudentEntry(student)
947	for k in toexport.keys()[1:]:
948	try:
949	object = getattr(getattr(students_folder,student.id),k)
950	object_doc = object.getContent()
951	except:
952	logger.info('%s %s record not found' % (student.id,k))
953	not_all = True
954	continue
955	for f in toexport[k]:
956	d[f] = getattr(object_doc,f,'')
957	if not_all:
958	continue
959	if with_lga:
960	d['lga'] = formatLGA(d['lga'])
961	lines.append(format % d)
962	total += 1
963	if total and not total % chunk or total == len(students):
964	open(export_file,"a").write('\n'.join(lines) +'\n')
965	anz = len(lines)
966	logger.info("wrote %(anz)d to %(export_file)s" % vars())
967	lines = []
968	filename, extension = os.path.splitext(export_file)
969	os.system('zip %s %s' % (filename,export_file))
970	os.system('rm %s' % (export_file))
971	msg = "finished wrote %(total)d records to %(filename)s.zip" % vars()
972	logger.info(msg)
973	args = {'portal_status_message': msg}
974	#url = self.REQUEST.get('URL1') + '?' + urlencode(args)
975	url = self.REQUEST.get('URL1')
976	return self.REQUEST.RESPONSE.redirect(url)
977	###)
978
979	security.declareProtected(ModifyPortalContent,"importResults")###(
980	def importResults(self):
981	"""load Returning Students Results from CSV"""
982	import transaction
983	import random
984	#from pdb import set_trace
985	wftool = self.portal_workflow
986	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
987	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
988	students_folder = self.portal_url.getPortalObject().campus.students
989	tr_count = 1
990	total = 0
991	#name = 'pume_results'
992	name = 'Results'
993	table = self.results_import
994	no_import = []
995	imported = []
996	logger = logging.getLogger('Students.StudentsFolder.importResults')
997	try:
998	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
999	except:
1000	logger.error('Error reading %s.csv' % name)
1001	return
1002	l = self.portal_catalog({'meta_type': "Course"})
1003	courses = [f.getId for f in l]
1004	start = True
1005	res = table()
1006	regs = []
1007	if len(res) > 0:
1008	regs = [s.key for s in res]
1009	no_course = []
1010	no_course_list = []
1011	course_count = 0
1012	for result in results:
1013	if start:
1014	start = False
1015	logger.info('Start loading from %s.csv' % name)
1016	s = ','.join(['"%s"' % fn for fn in result.keys()])
1017	imported.append(s)
1018	no_import.append('%s,"Error"' % s)
1019	format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
1020	format_error = format + ',"%(Error)s"'
1021	no_certificate = "no certificate %s" % format
1022	course_id = result.get('CosCode')
1023	if not course_id:
1024	course_id = 'N/A'
1025	result['CosCode'] = course_id
1026	matric_no = result.get('matric_no').upper()
1027	result['matric_no'] = matric_no
1028	key = matric_no+course_id
1029	if matric_no == '':
1030	result['Error'] = "Empty matric_no"
1031	no_import.append( format_error % result)
1032	continue
1033	if key in regs or self.results_import(key = key):
1034	result['Error'] = "Duplicate"
1035	no_import.append( format_error % result)
1036	continue
1037	if course_id not in courses:
1038	if course_id not in no_course:
1039	course_count +=1
1040	no_course.append(course_id)
1041	no_course_list.append('"%s"' % course_id)
1042	#result['Error'] = "No Course"
1043	#logger.info(format_error % result)
1044
1045	result['key'] = key
1046	try:
1047	table.addRecord(**result)
1048	except ValueError:
1049	#import pdb;pdb.set_trace()
1050	result['Error'] = "Duplicate"
1051	no_import.append( format_error % result)
1052	continue
1053
1054	regs.append(key)
1055	imported.append(format % result)
1056	tr_count += 1
1057	if tr_count > 1000:
1058	if len(no_import) > 0:
1059	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1060	'\n'.join(no_import)+'\n')
1061	no_import = []
1062	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1063	'\n'.join(imported) + '\n')
1064	imported = []
1065	if no_course_list:
1066	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1067	'\n'.join(no_course_list) + '\n')
1068	no_course_list = []
1069	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1070	transaction.commit()
1071	logger.info(em)
1072	regs = []
1073	total += tr_count
1074	tr_count = 0
1075	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1076	'\n'.join(imported))
1077	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1078	'\n'.join(no_import))
1079	if no_course_list:
1080	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1081	'\n'.join(no_course_list))
1082	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1083	logger.info(em)
1084	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1085	###)
1086
1087	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
1088	def updateStudyCourse(self):
1089	"""update StudyCourse from CSV values"""
1090	import transaction
1091	import random
1092	from pdb import set_trace
1093	wftool = self.portal_workflow
1094	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1095	students_folder = self.portal_url.getPortalObject().campus.students
1096	csv_d = {'jamb_reg_no': "RegNumber",
1097	'jamb_lastname': "Name",
1098	'session': "Session",
1099	'pume_tot_score': "PUME SCORE",
1100	'jamb_score': "JambScore",
1101	'jamb_sex': "Sex",
1102	'jamb_state': "State",
1103	## 'jamb_first_cos': "AdminCourse",
1104	'faculty': "AdminFaculty",
1105	'course_code': "AdmitCoscode",
1106	'stud_status':"AdmitStatus",
1107	'department': "AdmitDept",
1108	'jamb_lga': "LGA",
1109	'app_email': "email",
1110	'app_mobile': "PhoneNumbers",
1111	}
1112	csv_fields = [f[1] for f in csv_d.items()]
1113	tr_count = 0
1114	total = 0
1115	#name = 'pume_results'
1116	name = 'StudyCourseChange'
1117	no_import = []
1118	s = ','.join(['"%s"' % fn for fn in csv_fields])
1119	no_import.append('"Error",%s' % s)
1120	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1121	no_certificate = "no certificate %s" % format
1122	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1123	'\n'.join(no_import))
1124	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
1125	logger.info('Start loading from %s.csv' % name)
1126	l = self.portal_catalog({'meta_type': "Certificate"})
1127	try:
1128	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1129	except:
1130	logger.error('Error reading %s.csv' % name)
1131	return
1132	for jamb in result:
1133	jamb['Error'] = "Processing "
1134	logger.info(format % jamb)
1135	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1136	res = self.portal_catalog({'portal_type': "StudentApplication",
1137	'SearchableText': jamb_reg_no })
1138	if not res:
1139	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
1140	logger.info(em)
1141	jamb['Error'] = "Student does not exist"
1142	no_import.append(format % jamb)
1143	continue
1144	sid = res[0].getPath().split('/')[-2]
1145	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
1146	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
1147	if not res:
1148	em = 'No Certificate with ID %s \n' % cert_id
1149	logger.info(em)
1150	jamb['Error'] = "No Certificate %s" % cert_id
1151	no_import.append( format % jamb)
1152	continue
1153	cert_brain = res[0]
1154	catalog_entry = {}
1155	student = getattr(self,sid)
1156	#
1157	# Study Course
1158	#
1159	study_course = student.study_course
1160	dsc = {}
1161	cert_pl = cert_brain.getPath().split('/')
1162	catalog_entry['id'] = sid
1163	catalog_entry['faculty'] = cert_pl[-4]
1164	catalog_entry['department'] = cert_pl[-3]
1165	catalog_entry['course'] = cert_id
1166	dsc['study_course'] = cert_id
1167	study_course.getContent().edit(mapping=dsc)
1168	self.students_catalog.modifyRecord(**catalog_entry)
1169	if tr_count > 10:
1170	if len(no_import) > 1:
1171	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
1172	'\n'.join(no_import))
1173	no_import = []
1174	em = '%d transactions commited\n' % tr_count
1175	transaction.commit()
1176	logger.info(em)
1177	total += tr_count
1178	tr_count = 0
1179	tr_count += 1
1180	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1181	###)
1182
1183	security.declareProtected(View,"fixOwnership") ###(
1184	def fixOwnership(self):
1185	"""fix Ownership"""
1186	for s in self.portal_catalog(meta_type = 'Student'):
1187	student = s.getObject()
1188	sid = s.getId
1189	import pdb;pdb.set_trace()
1190	student.application.manage_setLocalRoles(sid, ['Owner',])
1191	student.personal.manage_setLocalRoles(sid, ['Owner',])
1192	###)
1193
1194	security.declareProtected(View,"Title") ###(
1195	def Title(self):
1196	"""compose title"""
1197	return "Student Section"
1198	###)
1199
1200	def generateStudentId(self,letter,students = None): ###(
1201	import random
1202	r = random
1203	if students is None:
1204	students = self.portal_url.getPortalObject().campus.students
1205	if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
1206	letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
1207	sid = "%c%d" % (letter,r.randint(99999,1000000))
1208	while hasattr(students, sid):
1209	sid = "%c%d" % (letter,r.randint(99999,1000000))
1210	return sid
1211	#return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
1212	###)
1213
1214	InitializeClass(StudentsFolder)
1215
1216	def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
1217	"""Add a Student."""
1218	ob = StudentsFolder(id, **kw)
1219	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1220	###)
1221
1222	###)
1223
1224	class Student(CPSDocument): ###(
1225	"""
1226	WAeUP Student container for the various student data
1227	"""
1228	meta_type = 'Student'
1229	portal_type = meta_type
1230	security = ClassSecurityInfo()
1231
1232	security.declareProtected(View,"Title")
1233	def Title(self):
1234	"""compose title"""
1235	reg_nr = self.getId()[1:]
1236	data = getattr(self,'personal',None)
1237	if data:
1238	content = data.getContent()
1239	return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
1240	data = getattr(self,'application',None)
1241	if data:
1242	content = data.getContent()
1243	return "%s" % (content.jamb_lastname)
1244	return self.title
1245
1246	security.declarePrivate('makeStudentMember') ###(
1247	def makeStudentMember(self,sid,password='uNsEt'):
1248	"""make the student a member"""
1249	membership = self.portal_membership
1250	membership.addMember(sid,
1251	password ,
1252	roles=('Member',
1253	'Student',
1254	),
1255	domains='',
1256	properties = {'memberareaCreationFlag': False,
1257	'homeless': True},)
1258	member = membership.getMemberById(sid)
1259	self.portal_registration.afterAdd(member, sid, password, None)
1260	self.manage_setLocalRoles(sid, ['Owner',])
1261
1262	###)
1263
1264	security.declareProtected(View,'createSubObjects') ###(
1265	def createSubObjects(self):
1266	"""make the student a member"""
1267	dp = {'Title': 'Personal Data'}
1268	app_doc = self.application.getContent()
1269	names = app_doc.jamb_lastname.split()
1270	if len(names) == 3:
1271	dp['firstname'] = names[0].capitalize()
1272	dp['middlename'] = names[1].capitalize()
1273	dp['lastname'] = names[2].capitalize()
1274	elif len(names) == 2:
1275	dp['firstname'] = names[0].capitalize()
1276	dp['lastname'] = names[1].capitalize()
1277	else:
1278	dp['lastname'] = app_doc.jamb_lastname
1279	dp['sex'] = app_doc.jamb_sex == 'F'
1280	dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1281	proxy = self.aq_parent
1282	proxy.invokeFactory('StudentPersonal','personal')
1283	per = proxy.personal
1284	per_doc = per.getContent()
1285	per_doc.edit(mapping = dp)
1286	per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1287	#self.portal_workflow.doActionFor(per,'open',dest_container=per)
1288
1289	###)
1290
1291	InitializeClass(Student)
1292
1293	def addStudent(container, id, REQUEST=None, **kw):
1294	"""Add a Student."""
1295	ob = Student(id, **kw)
1296	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1297
1298	###)
1299
1300	class StudentAccommodation(CPSDocument): ###(
1301	"""
1302	WAeUP Student container for the various student data
1303	"""
1304	meta_type = 'StudentAccommodation'
1305	portal_type = meta_type
1306	security = ClassSecurityInfo()
1307
1308	security.declareProtected(View,"Title")
1309	def Title(self):
1310	"""compose title"""
1311	content = self.getContent()
1312	#return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1313	return "Accommodation Data for Session %s" % content.session
1314
1315
1316	InitializeClass(StudentAccommodation)
1317
1318	def addStudentAccommodation(container, id, REQUEST=None, **kw):
1319	"""Add a Students personal data."""
1320	ob = StudentAccommodation(id, **kw)
1321	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1322
1323	###)
1324
1325	class StudentPersonal(CPSDocument): ###(
1326	"""
1327	WAeUP Student container for the various student data
1328	"""
1329	meta_type = 'StudentPersonal'
1330	portal_type = meta_type
1331	security = ClassSecurityInfo()
1332
1333	security.declareProtected(View,"Title")
1334	def Title(self):
1335	"""compose title"""
1336	content = self.getContent()
1337	#return "Personal Data for %s %s" % (content.firstname,content.lastname)
1338	return "Personal Data"
1339
1340
1341	InitializeClass(StudentPersonal)
1342
1343	def addStudentPersonal(container, id, REQUEST=None, **kw):
1344	"""Add a Students personal data."""
1345	ob = StudentPersonal(id, **kw)
1346	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1347
1348	###)
1349
1350	class StudentClearance(CPSDocument): ###(
1351	"""
1352	WAeUP Student container for the various student data
1353	"""
1354	meta_type = 'StudentClearance'
1355	portal_type = meta_type
1356	security = ClassSecurityInfo()
1357
1358	security.declareProtected(View,"Title")
1359	def Title(self):
1360	"""compose title"""
1361	content = self.getContent()
1362	#return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1363	return "Clearance/Eligibility Record"
1364
1365
1366	InitializeClass(StudentClearance)
1367
1368	def addStudentClearance(container, id, REQUEST=None, **kw):
1369	"""Add a Students personal data."""
1370	ob = StudentClearance(id, **kw)
1371	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1372
1373	###)
1374
1375	class StudentStudyLevel(CPSDocument): ###(
1376	"""
1377	WAeUP Student container for the various student data
1378	"""
1379	meta_type = 'StudentStudyLevel'
1380	portal_type = meta_type
1381	security = ClassSecurityInfo()
1382
1383	security.declareProtected(View,"Title")
1384	def Title(self):
1385	"""compose title"""
1386	return "Level %s" % self.aq_parent.getId()
1387
1388	def create_course_results(self,cert_id,current_level): ###(
1389	"create all courses in a level"
1390	aq_portal = self.portal_catalog.evalAdvancedQuery
1391	res = self.portal_catalog(portal_type="Certificate", id = cert_id)
1392	l = []
1393	import transaction
1394	if res:
1395	cert = res[0]
1396	path = cert.getPath()
1397	query = Eq("path","%s/%s" % (path,current_level)) &\
1398	Eq('portal_type','CertificateCourse')
1399	courses = aq_portal(query)
1400	#from pdb import set_trace;set_trace()
1401	self_proxy = self.aq_parent
1402	for c in courses:
1403	d = self.getCourseInfo(c.getId)
1404	cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
1405	course_result = getattr(self_proxy,cr_id)
1406	self.portal_workflow.doActionFor(course_result,'open')
1407	d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
1408	course_result.getContent().edit(mapping=d)
1409	#transaction.commit()
1410	###)
1411
1412	InitializeClass(StudentStudyLevel)
1413
1414	def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1415	"""Add a Students personal data."""
1416	ob = StudentStudyLevel(id, **kw)
1417	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1418
1419	###)
1420
1421	class StudentStudyCourse(CPSDocument): ###(
1422	"""
1423	WAeUP Student container for the various student data
1424	"""
1425	meta_type = 'StudentStudyCourse'
1426	portal_type = meta_type
1427	security = ClassSecurityInfo()
1428
1429	security.declareProtected(View,"Title")
1430	def Title(self):
1431	"""compose title"""
1432	content = self.getContent()
1433	return "Study Course"
1434
1435
1436	InitializeClass(StudentStudyCourse)
1437
1438	def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1439	"""Add a Students personal data."""
1440	ob = StudentStudyCourse(id, **kw)
1441	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1442
1443	###)
1444
1445	class StudentApplication(CPSDocument): ###(
1446	"""
1447	WAeUP Student container for the various student data
1448	"""
1449	meta_type = 'StudentApplication'
1450	portal_type = meta_type
1451	security = ClassSecurityInfo()
1452
1453	security.declareProtected(View,"Title")
1454	def Title(self):
1455	"""compose title"""
1456	return "Application Data"
1457
1458
1459	InitializeClass(StudentApplication)
1460
1461	def addStudentApplication(container, id, REQUEST=None, **kw):
1462	"""Add a Students eligibility data."""
1463	ob = StudentApplication(id, **kw)
1464	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1465	###)
1466
1467	class StudentPume(CPSDocument): ###(
1468	"""
1469	WAeUP Student container for the various student data
1470	"""
1471	meta_type = 'StudentPume'
1472	portal_type = meta_type
1473	security = ClassSecurityInfo()
1474
1475	security.declareProtected(View,"Title")
1476	def Title(self):
1477	"""compose title"""
1478	return "PUME Results"
1479
1480
1481	InitializeClass(StudentPume)
1482
1483	def addStudentPume(container, id, REQUEST=None, **kw):
1484	"""Add a Students PUME data."""
1485	ob = StudentPume(id, **kw)
1486	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1487	###)
1488
1489	##class StudentSemester(CPSDocument): ###(
1490	## """
1491	## WAeUP StudentSemester containing the courses and students
1492	## """
1493	## meta_type = 'StudentSemester'
1494	## portal_type = meta_type
1495	## security = ClassSecurityInfo()
1496	##
1497	##InitializeClass(StudentSemester)
1498	##
1499	##def addStudentSemester(container, id, REQUEST=None, **kw):
1500	## """Add a StudentSemester."""
1501	## ob = StudentSemester(id, **kw)
1502	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1503	##
1504	#####)
1505
1506	##class Semester(CPSDocument): ###(
1507	## """
1508	## WAeUP Semester containing the courses and students
1509	## """
1510	## meta_type = 'Semester'
1511	## portal_type = meta_type
1512	## security = ClassSecurityInfo()
1513	##
1514	##InitializeClass(Semester)
1515	##
1516	##def addSemester(container, id, REQUEST=None, **kw):
1517	## """Add a Semester."""
1518	## ob = Semester(id, **kw)
1519	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1520	##
1521	#####)
1522
1523	class StudentCourseResult(CPSDocument): ###(
1524	"""
1525	WAeUP StudentCourseResult
1526	"""
1527	meta_type = 'StudentCourseResult'
1528	portal_type = meta_type
1529	security = ClassSecurityInfo()
1530
1531	def getCourseEntry(self,cid):
1532	res = self.portal_catalog({'meta_type': "Course",
1533	'id': cid})
1534	if res:
1535	return res[-1]
1536	else:
1537	return None
1538
1539	security.declareProtected(View,"Title")
1540	def Title(self):
1541	"""compose title"""
1542	cid = self.aq_parent.getId()
1543	ce = self.getCourseEntry(cid)
1544	if ce:
1545	return "%s" % ce.Title
1546	return "No course with id %s" % cid
1547
1548	InitializeClass(StudentCourseResult)
1549
1550	def addStudentCourseResult(container, id, REQUEST=None, **kw):
1551	"""Add a StudentCourseResult."""
1552	ob = StudentCourseResult(id, **kw)
1553	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1554	###)
1555
1556	# Backward Compatibility StudyLevel
1557
1558	from Products.WAeUP_SRP.Academics import StudyLevel
1559
1560	from Products.WAeUP_SRP.Academics import addStudyLevel
1561

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

Download in other formats: