Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1818

Last change on this file since 1818 was 1816, checked in by Henrik Bettermann, 18 years ago
importResults fixed: line readded which had been removed in revion 1700 (don't know why!!) also the link 'Previous Sessions' now works for withdrawn students
Property svn:keywords set to `Id`
File size: 49.6 KB

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

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

Download in other formats: