Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1940

Last change on this file since 1940 was 1940, checked in by Henrik Bettermann, 17 years ago

some more logging messages

current_level instead of level

Property svn:keywords set to Id

File size: 61.9 KB

Line
1	#-- mode: python; mode: fold --
2	# $Id: Students.py 1940 2007-06-20 13:43:45Z henrik $
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	member = self.portal_membership.getAuthenticatedMember()
900	logger = logging.getLogger('Students.exportStudents')
901	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
902	students_folder = self.portal_url.getPortalObject().campus.students
903	export_file = "%s/export/students_%s.csv" % (i_home,current)
904
905	from Products.AdvancedQuery import Eq, Between, Le,In,MatchRegexp
906	aq_students = self.students_catalog.evalAdvancedQuery
907	toexport = {'students_catalog': ("id",
908	"matric_no",
909	"jamb_reg_no",
910	"review_state",
911	"sex",
912	"email",
913	"faculty",
914	"department",
915	"course",
916	"level",
917	),
918	'personal': ('firstname',
919	'middlename',
920	'lastname',
921	'perm_address',
922	),
923	'clearance': ('state',
924	'lga',
925	)
926	}
927	res_list = []
928	lines = []
929	fields = []
930	with_lga = False
931	for k in toexport.keys():
932	for f in toexport[k]:
933	if f == 'lga' :
934	with_lga = True
935	fields.append(f)
936	headline = ','.join(fields).replace('level','current_level')
937	open(export_file,"a").write(headline +'\n')
938	format = '"%(' + ')s","%('.join(fields) + ')s"'
939	query = In('review_state',('cleared_and_validated',
940	'school_fee_paid',
941	'courses_registered',
942	'courses_validated'))
943	students = aq_students(query)
944	logger.info('%s starts exportStudents, %s student records to export' % (member,len(students)))
945	chunk = 100
946	total = 0
947	for student in students:
948	not_all = False
949	d = self.getFormattedStudentEntry(student)
950	for k in toexport.keys()[1:]:
951	try:
952	object = getattr(getattr(students_folder,student.id),k)
953	object_doc = object.getContent()
954	except:
955	logger.info('%s %s record not found' % (student.id,k))
956	not_all = True
957	continue
958	for f in toexport[k]:
959	d[f] = getattr(object_doc,f,'')
960	if not_all:
961	continue
962	if with_lga:
963	d['lga'] = formatLGA(d['lga'])
964	lines.append(format % d)
965	total += 1
966	if total and not total % chunk or total == len(students):
967	open(export_file,"a").write('\n'.join(lines) +'\n')
968	anz = len(lines)
969	logger.info("wrote %(anz)d to %(export_file)s" % vars())
970	lines = []
971	filename, extension = os.path.splitext(export_file)
972	os.system('zip %s %s' % (filename,export_file))
973	os.system('rm %s' % (export_file))
974	msg = "finished wrote %(total)d records to %(filename)s.zip" % vars()
975	logger.info(msg)
976	args = {'portal_status_message': msg}
977	#url = self.REQUEST.get('URL1') + '?' + urlencode(args)
978	url = self.REQUEST.get('URL1')
979	return self.REQUEST.RESPONSE.redirect(url)
980	###)
981
982	security.declareProtected(ModifyPortalContent,"importResults")###(
983	def importResults(self):
984	"""load Returning Students Results from CSV"""
985	import transaction
986	import random
987	#from pdb import set_trace
988	wftool = self.portal_workflow
989	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
990	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
991	students_folder = self.portal_url.getPortalObject().campus.students
992	tr_count = 1
993	total = 0
994	#name = 'pume_results'
995	name = 'Results'
996	table = self.results_import
997	no_import = []
998	imported = []
999	logger = logging.getLogger('Students.StudentsFolder.importResults')
1000	try:
1001	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1002	except:
1003	logger.error('Error reading %s.csv' % name)
1004	return
1005	l = self.portal_catalog({'meta_type': "Course"})
1006	courses = [f.getId for f in l]
1007	start = True
1008	res = table()
1009	regs = []
1010	if len(res) > 0:
1011	regs = [s.key for s in res]
1012	no_course = []
1013	no_course_list = []
1014	course_count = 0
1015	for result in results:
1016	if start:
1017	start = False
1018	logger.info('Start loading from %s.csv' % name)
1019	s = ','.join(['"%s"' % fn for fn in result.keys()])
1020	imported.append(s)
1021	no_import.append('%s,"Error"' % s)
1022	format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
1023	format_error = format + ',"%(Error)s"'
1024	no_certificate = "no certificate %s" % format
1025	course_id = result.get('CosCode')
1026	if not course_id:
1027	course_id = 'N/A'
1028	result['CosCode'] = course_id
1029	matric_no = result.get('matric_no').upper()
1030	result['matric_no'] = matric_no
1031	key = matric_no+course_id
1032	if matric_no == '':
1033	result['Error'] = "Empty matric_no"
1034	no_import.append( format_error % result)
1035	continue
1036	if key in regs or self.results_import(key = key):
1037	result['Error'] = "Duplicate"
1038	no_import.append( format_error % result)
1039	continue
1040	if course_id not in courses:
1041	if course_id not in no_course:
1042	course_count +=1
1043	no_course.append(course_id)
1044	no_course_list.append('"%s"' % course_id)
1045	#result['Error'] = "No Course"
1046	#logger.info(format_error % result)
1047
1048	result['key'] = key
1049	try:
1050	table.addRecord(**result)
1051	except ValueError:
1052	#import pdb;pdb.set_trace()
1053	result['Error'] = "Duplicate"
1054	no_import.append( format_error % result)
1055	continue
1056
1057	regs.append(key)
1058	imported.append(format % result)
1059	tr_count += 1
1060	if tr_count > 1000:
1061	if len(no_import) > 0:
1062	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1063	'\n'.join(no_import)+'\n')
1064	no_import = []
1065	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1066	'\n'.join(imported) + '\n')
1067	imported = []
1068	if no_course_list:
1069	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1070	'\n'.join(no_course_list) + '\n')
1071	no_course_list = []
1072	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1073	transaction.commit()
1074	logger.info(em)
1075	regs = []
1076	total += tr_count
1077	tr_count = 0
1078	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1079	'\n'.join(imported))
1080	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1081	'\n'.join(no_import))
1082	if no_course_list:
1083	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1084	'\n'.join(no_course_list))
1085	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1086	logger.info(em)
1087	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1088	###)
1089
1090	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
1091	def updateStudyCourse(self):
1092	"""update StudyCourse from CSV values"""
1093	import transaction
1094	import random
1095	from pdb import set_trace
1096	wftool = self.portal_workflow
1097	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1098	students_folder = self.portal_url.getPortalObject().campus.students
1099	csv_d = {'jamb_reg_no': "RegNumber",
1100	'jamb_lastname': "Name",
1101	'session': "Session",
1102	'pume_tot_score': "PUME SCORE",
1103	'jamb_score': "JambScore",
1104	'jamb_sex': "Sex",
1105	'jamb_state': "State",
1106	## 'jamb_first_cos': "AdminCourse",
1107	'faculty': "AdminFaculty",
1108	'course_code': "AdmitCoscode",
1109	'stud_status':"AdmitStatus",
1110	'department': "AdmitDept",
1111	'jamb_lga': "LGA",
1112	'app_email': "email",
1113	'app_mobile': "PhoneNumbers",
1114	}
1115	csv_fields = [f[1] for f in csv_d.items()]
1116	tr_count = 0
1117	total = 0
1118	#name = 'pume_results'
1119	name = 'StudyCourseChange'
1120	no_import = []
1121	s = ','.join(['"%s"' % fn for fn in csv_fields])
1122	no_import.append('"Error",%s' % s)
1123	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1124	no_certificate = "no certificate %s" % format
1125	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1126	'\n'.join(no_import))
1127	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
1128	logger.info('Start loading from %s.csv' % name)
1129	l = self.portal_catalog({'meta_type': "Certificate"})
1130	try:
1131	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1132	except:
1133	logger.error('Error reading %s.csv' % name)
1134	return
1135	for jamb in result:
1136	jamb['Error'] = "Processing "
1137	logger.info(format % jamb)
1138	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1139	res = self.portal_catalog({'portal_type': "StudentApplication",
1140	'SearchableText': jamb_reg_no })
1141	if not res:
1142	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
1143	logger.info(em)
1144	jamb['Error'] = "Student does not exist"
1145	no_import.append(format % jamb)
1146	continue
1147	sid = res[0].getPath().split('/')[-2]
1148	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
1149	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
1150	if not res:
1151	em = 'No Certificate with ID %s \n' % cert_id
1152	logger.info(em)
1153	jamb['Error'] = "No Certificate %s" % cert_id
1154	no_import.append( format % jamb)
1155	continue
1156	cert_brain = res[0]
1157	catalog_entry = {}
1158	student = getattr(self,sid)
1159	#
1160	# Study Course
1161	#
1162	study_course = student.study_course
1163	dsc = {}
1164	cert_pl = cert_brain.getPath().split('/')
1165	catalog_entry['id'] = sid
1166	catalog_entry['faculty'] = cert_pl[-4]
1167	catalog_entry['department'] = cert_pl[-3]
1168	catalog_entry['course'] = cert_id
1169	dsc['study_course'] = cert_id
1170	study_course.getContent().edit(mapping=dsc)
1171	self.students_catalog.modifyRecord(**catalog_entry)
1172	if tr_count > 10:
1173	if len(no_import) > 1:
1174	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
1175	'\n'.join(no_import))
1176	no_import = []
1177	em = '%d transactions commited\n' % tr_count
1178	transaction.commit()
1179	logger.info(em)
1180	total += tr_count
1181	tr_count = 0
1182	tr_count += 1
1183	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1184	###)
1185
1186	security.declareProtected(View,"fixOwnership") ###(
1187	def fixOwnership(self):
1188	"""fix Ownership"""
1189	for s in self.portal_catalog(meta_type = 'Student'):
1190	student = s.getObject()
1191	sid = s.getId
1192	import pdb;pdb.set_trace()
1193	student.application.manage_setLocalRoles(sid, ['Owner',])
1194	student.personal.manage_setLocalRoles(sid, ['Owner',])
1195	###)
1196
1197	security.declareProtected(View,"Title") ###(
1198	def Title(self):
1199	"""compose title"""
1200	return "Student Section"
1201	###)
1202
1203	def generateStudentId(self,letter,students = None): ###(
1204	import random
1205	r = random
1206	if students is None:
1207	students = self.portal_url.getPortalObject().campus.students
1208	if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
1209	letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
1210	sid = "%c%d" % (letter,r.randint(99999,1000000))
1211	while hasattr(students, sid):
1212	sid = "%c%d" % (letter,r.randint(99999,1000000))
1213	return sid
1214	#return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
1215	###)
1216
1217	InitializeClass(StudentsFolder)
1218
1219	def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
1220	"""Add a Student."""
1221	ob = StudentsFolder(id, **kw)
1222	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1223	###)
1224
1225	###)
1226
1227	class Student(CPSDocument): ###(
1228	"""
1229	WAeUP Student container for the various student data
1230	"""
1231	meta_type = 'Student'
1232	portal_type = meta_type
1233	security = ClassSecurityInfo()
1234
1235	security.declareProtected(View,"Title")
1236	def Title(self):
1237	"""compose title"""
1238	reg_nr = self.getId()[1:]
1239	data = getattr(self,'personal',None)
1240	if data:
1241	content = data.getContent()
1242	return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
1243	data = getattr(self,'application',None)
1244	if data:
1245	content = data.getContent()
1246	return "%s" % (content.jamb_lastname)
1247	return self.title
1248
1249	security.declarePrivate('makeStudentMember') ###(
1250	def makeStudentMember(self,sid,password='uNsEt'):
1251	"""make the student a member"""
1252	membership = self.portal_membership
1253	membership.addMember(sid,
1254	password ,
1255	roles=('Member',
1256	'Student',
1257	),
1258	domains='',
1259	properties = {'memberareaCreationFlag': False,
1260	'homeless': True},)
1261	member = membership.getMemberById(sid)
1262	self.portal_registration.afterAdd(member, sid, password, None)
1263	self.manage_setLocalRoles(sid, ['Owner',])
1264
1265	###)
1266
1267	security.declareProtected(View,'createSubObjects') ###(
1268	def createSubObjects(self):
1269	"""make the student a member"""
1270	dp = {'Title': 'Personal Data'}
1271	app_doc = self.application.getContent()
1272	names = app_doc.jamb_lastname.split()
1273	if len(names) == 3:
1274	dp['firstname'] = names[0].capitalize()
1275	dp['middlename'] = names[1].capitalize()
1276	dp['lastname'] = names[2].capitalize()
1277	elif len(names) == 2:
1278	dp['firstname'] = names[0].capitalize()
1279	dp['lastname'] = names[1].capitalize()
1280	else:
1281	dp['lastname'] = app_doc.jamb_lastname
1282	dp['sex'] = app_doc.jamb_sex == 'F'
1283	dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1284	proxy = self.aq_parent
1285	proxy.invokeFactory('StudentPersonal','personal')
1286	per = proxy.personal
1287	per_doc = per.getContent()
1288	per_doc.edit(mapping = dp)
1289	per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1290	#self.portal_workflow.doActionFor(per,'open',dest_container=per)
1291
1292	###)
1293
1294	InitializeClass(Student)
1295
1296	def addStudent(container, id, REQUEST=None, **kw):
1297	"""Add a Student."""
1298	ob = Student(id, **kw)
1299	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1300
1301	###)
1302
1303	class StudentAccommodation(CPSDocument): ###(
1304	"""
1305	WAeUP Student container for the various student data
1306	"""
1307	meta_type = 'StudentAccommodation'
1308	portal_type = meta_type
1309	security = ClassSecurityInfo()
1310
1311	security.declareProtected(View,"Title")
1312	def Title(self):
1313	"""compose title"""
1314	content = self.getContent()
1315	#return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1316	return "Accommodation Data for Session %s" % content.session
1317
1318
1319	InitializeClass(StudentAccommodation)
1320
1321	def addStudentAccommodation(container, id, REQUEST=None, **kw):
1322	"""Add a Students personal data."""
1323	ob = StudentAccommodation(id, **kw)
1324	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1325
1326	###)
1327
1328	class StudentPersonal(CPSDocument): ###(
1329	"""
1330	WAeUP Student container for the various student data
1331	"""
1332	meta_type = 'StudentPersonal'
1333	portal_type = meta_type
1334	security = ClassSecurityInfo()
1335
1336	security.declareProtected(View,"Title")
1337	def Title(self):
1338	"""compose title"""
1339	content = self.getContent()
1340	#return "Personal Data for %s %s" % (content.firstname,content.lastname)
1341	return "Personal Data"
1342
1343
1344	InitializeClass(StudentPersonal)
1345
1346	def addStudentPersonal(container, id, REQUEST=None, **kw):
1347	"""Add a Students personal data."""
1348	ob = StudentPersonal(id, **kw)
1349	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1350
1351	###)
1352
1353	class StudentClearance(CPSDocument): ###(
1354	"""
1355	WAeUP Student container for the various student data
1356	"""
1357	meta_type = 'StudentClearance'
1358	portal_type = meta_type
1359	security = ClassSecurityInfo()
1360
1361	security.declareProtected(View,"Title")
1362	def Title(self):
1363	"""compose title"""
1364	content = self.getContent()
1365	#return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1366	return "Clearance/Eligibility Record"
1367
1368
1369	InitializeClass(StudentClearance)
1370
1371	def addStudentClearance(container, id, REQUEST=None, **kw):
1372	"""Add a Students personal data."""
1373	ob = StudentClearance(id, **kw)
1374	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1375
1376	###)
1377
1378	class StudentStudyLevel(CPSDocument): ###(
1379	"""
1380	WAeUP Student container for the various student data
1381	"""
1382	meta_type = 'StudentStudyLevel'
1383	portal_type = meta_type
1384	security = ClassSecurityInfo()
1385
1386	security.declareProtected(View,"Title")
1387	def Title(self):
1388	"""compose title"""
1389	return "Level %s" % self.aq_parent.getId()
1390
1391	def create_course_results(self,cert_id,current_level): ###(
1392	"create all courses in a level"
1393	aq_portal = self.portal_catalog.evalAdvancedQuery
1394	res = self.portal_catalog(portal_type="Certificate", id = cert_id)
1395	l = []
1396	import transaction
1397	if res:
1398	cert = res[0]
1399	path = cert.getPath()
1400	query = Eq("path","%s/%s" % (path,current_level)) &\
1401	Eq('portal_type','CertificateCourse')
1402	courses = aq_portal(query)
1403	#from pdb import set_trace;set_trace()
1404	self_proxy = self.aq_parent
1405	for c in courses:
1406	d = self.getCourseInfo(c.getId)
1407	cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
1408	course_result = getattr(self_proxy,cr_id)
1409	self.portal_workflow.doActionFor(course_result,'open')
1410	d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
1411	course_result.getContent().edit(mapping=d)
1412	#transaction.commit()
1413	###)
1414
1415	InitializeClass(StudentStudyLevel)
1416
1417	def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1418	"""Add a Students personal data."""
1419	ob = StudentStudyLevel(id, **kw)
1420	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1421
1422	###)
1423
1424	class StudentStudyCourse(CPSDocument): ###(
1425	"""
1426	WAeUP Student container for the various student data
1427	"""
1428	meta_type = 'StudentStudyCourse'
1429	portal_type = meta_type
1430	security = ClassSecurityInfo()
1431
1432	security.declareProtected(View,"Title")
1433	def Title(self):
1434	"""compose title"""
1435	content = self.getContent()
1436	return "Study Course"
1437
1438
1439	InitializeClass(StudentStudyCourse)
1440
1441	def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1442	"""Add a Students personal data."""
1443	ob = StudentStudyCourse(id, **kw)
1444	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1445
1446	###)
1447
1448	class StudentApplication(CPSDocument): ###(
1449	"""
1450	WAeUP Student container for the various student data
1451	"""
1452	meta_type = 'StudentApplication'
1453	portal_type = meta_type
1454	security = ClassSecurityInfo()
1455
1456	security.declareProtected(View,"Title")
1457	def Title(self):
1458	"""compose title"""
1459	return "Application Data"
1460
1461
1462	InitializeClass(StudentApplication)
1463
1464	def addStudentApplication(container, id, REQUEST=None, **kw):
1465	"""Add a Students eligibility data."""
1466	ob = StudentApplication(id, **kw)
1467	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1468	###)
1469
1470	class StudentPume(CPSDocument): ###(
1471	"""
1472	WAeUP Student container for the various student data
1473	"""
1474	meta_type = 'StudentPume'
1475	portal_type = meta_type
1476	security = ClassSecurityInfo()
1477
1478	security.declareProtected(View,"Title")
1479	def Title(self):
1480	"""compose title"""
1481	return "PUME Results"
1482
1483
1484	InitializeClass(StudentPume)
1485
1486	def addStudentPume(container, id, REQUEST=None, **kw):
1487	"""Add a Students PUME data."""
1488	ob = StudentPume(id, **kw)
1489	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1490	###)
1491
1492	##class StudentSemester(CPSDocument): ###(
1493	## """
1494	## WAeUP StudentSemester containing the courses and students
1495	## """
1496	## meta_type = 'StudentSemester'
1497	## portal_type = meta_type
1498	## security = ClassSecurityInfo()
1499	##
1500	##InitializeClass(StudentSemester)
1501	##
1502	##def addStudentSemester(container, id, REQUEST=None, **kw):
1503	## """Add a StudentSemester."""
1504	## ob = StudentSemester(id, **kw)
1505	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1506	##
1507	#####)
1508
1509	##class Semester(CPSDocument): ###(
1510	## """
1511	## WAeUP Semester containing the courses and students
1512	## """
1513	## meta_type = 'Semester'
1514	## portal_type = meta_type
1515	## security = ClassSecurityInfo()
1516	##
1517	##InitializeClass(Semester)
1518	##
1519	##def addSemester(container, id, REQUEST=None, **kw):
1520	## """Add a Semester."""
1521	## ob = Semester(id, **kw)
1522	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1523	##
1524	#####)
1525
1526	class StudentCourseResult(CPSDocument): ###(
1527	"""
1528	WAeUP StudentCourseResult
1529	"""
1530	meta_type = 'StudentCourseResult'
1531	portal_type = meta_type
1532	security = ClassSecurityInfo()
1533
1534	def getCourseEntry(self,cid):
1535	res = self.portal_catalog({'meta_type': "Course",
1536	'id': cid})
1537	if res:
1538	return res[-1]
1539	else:
1540	return None
1541
1542	security.declareProtected(View,"Title")
1543	def Title(self):
1544	"""compose title"""
1545	cid = self.aq_parent.getId()
1546	ce = self.getCourseEntry(cid)
1547	if ce:
1548	return "%s" % ce.Title
1549	return "No course with id %s" % cid
1550
1551	InitializeClass(StudentCourseResult)
1552
1553	def addStudentCourseResult(container, id, REQUEST=None, **kw):
1554	"""Add a StudentCourseResult."""
1555	ob = StudentCourseResult(id, **kw)
1556	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1557	###)
1558
1559	# Backward Compatibility StudyLevel
1560
1561	from Products.WAeUP_SRP.Academics import StudyLevel
1562
1563	from Products.WAeUP_SRP.Academics import addStudyLevel
1564

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

Download in other formats: