Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1808

Last change on this file since 1808 was 1806, checked in by Henrik Bettermann, 18 years ago
some changes to enable import of admitted students (with createStudents)
Property svn:keywords set to `Id`
File size: 49.4 KB

Line
1	#-- mode: python; mode: fold --
2	# $Id: Students.py 1806 2007-05-22 21:09:28Z 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	#entry_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	#catalog_entry['entry_level'] = da["entry_level"] = entry_levels.get(da['entry_mode'],'100')
331	app = student.application
332	app_doc = app.getContent()
333	app.getContent().edit(mapping=da)
334	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
335	app.manage_setLocalRoles(sid, ['Owner',])
336
337	picture_id = da['jamb_reg_no'].replace('/','_')
338	file = None
339	for ext in ('jpg','JPG'):
340	picture ="%s/import/pictures_admitted_latest/%s.%s" % (i_home,picture_id,ext)
341	if os.path.exists(picture):
342	file = open(picture)
343	break
344	if file is not None:
345
346	## file conversion does not work
347	#img = PIL.Image.open(file)
348	#img.thumbnail((150,200),
349	# resample=PIL.Image.ANTIALIAS)
350	#outfile = StringIO()
351	#img.save(outfile, format=img.format)
352
353	outfile = file.read()
354	app_doc.manage_addFile('passport',
355	file=outfile,
356	title="%s.jpg" % jamb_reg_no)
357	#wftool.doActionFor(app,'close')
358	dp = {}
359	dp['firstname'] = firstname
360	dp['middlename'] = middlename
361	dp['lastname'] = lastname
362	dp['email'] = da['app_email']
363	dp['sex'] = sex
364	dp['perm_address'] = perm_address
365	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
366	student.invokeFactory('StudentPersonal','personal')
367	per = student.personal
368	per_doc = per.getContent()
369	per_doc.edit(mapping = dp)
370	per.manage_setLocalRoles(sid, ['Owner',])
371	wftool.doActionFor(student,'pume_pass')
372	wftool.doActionFor(student,'admit')
373	#
374	# Clearance
375	#
376	student.invokeFactory('StudentClearance','clearance')
377	#wftool.doActionFor(student.clearance,'open')
378	clearance = student.clearance
379	dc = {'Title': 'Clearance/Eligibility Record'}
380	clearance = student.clearance
381	date_str = result.get(csv_d['birthday'])
382	try:
383	date = DateTime.DateTime(date_str)
384	except:
385	#import pdb;pdb.set_trace()
386	date = None
387	dc['birthday'] = date
388	clearance.getContent().edit(mapping=dc)
389	clearance.manage_setLocalRoles(sid, ['Owner',])
390	#
391	# Study Course
392	#
393	student.invokeFactory('StudentStudyCourse','study_course')
394	study_course = student.study_course
395	dsc = {}
396	#catalog_entry['level'] = getattr(cert_doc,'start_level')
397	catalog_entry['session'] = dsc['current_session'] = da['entry_session']
398	#catalog_entry['level'] = dsc['current_level'] = entry_levels.get(da['entry_mode'],'100')
399	catalog_entry['mode'] = dsc['current_mode'] = da['entry_mode']
400	catalog_entry['level'] = dsc['current_level'] = '100' # Attention: not for DE students
401	catalog_entry['course'] = dsc['study_course'] = cert_id
402	catalog_entry['faculty'] = certificate['faculty']
403	catalog_entry['department'] = certificate['department']
404	catalog_entry['verdict'] = dsc['current_verdict'] = 'N/A'
405	catalog_entry['review_state'] = self.portal_workflow.getInfoFor(student,'review_state',None)
406	study_course.getContent().edit(mapping=dsc)
407	#import pdb;pdb.set_trace()
408	self.students_catalog.addRecord(**catalog_entry)
409	if tr_count > 1000:
410	if len(no_import) > 0:
411	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
412	'\n'.join(no_import) + "\n")
413	no_import = []
414	em = '%d transactions commited\n' % tr_count
415	transaction.commit()
416	logger.info(em)
417	total += tr_count
418	tr_count = 0
419	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
420	'\n'.join(no_import))
421	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
422	###)
423
424	security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
425	def importReturningStudents(self):
426	"""load Returning Studentdata from CSV values"""
427	import transaction
428	import random
429	#from pdb import set_trace
430	wftool = self.portal_workflow
431	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
432	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
433	students_folder = self.portal_url.getPortalObject().campus.students
434	tr_count = 1
435	total = 0
436	#name = 'pume_results'
437	name = 'Returning'
438	table = self.returning_import
439	no_import = []
440	imported = []
441	logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
442	try:
443	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
444	except:
445	logger.error('Error reading %s.csv' % name)
446	return
447	l = self.portal_catalog({'meta_type': "Certificate"})
448	certs = {}
449	cert_docs = {}
450	for f in l:
451	certs[f.getId] = f.getObject().getContent()
452	start = True
453	res = table()
454	regs = []
455	if len(res) > 0:
456	regs = [s.matric_no for s in res]
457	#import pdb;pdb.set_trace()
458	for student in returning:
459	if start:
460	start = False
461	logger.info('Start loading from %s.csv' % name)
462	s = ','.join(['"%s"' % fn for fn in student.keys()])
463	imported.append(s)
464	no_import.append('%s,"Error"' % s)
465	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
466	format_error = format + ',"%(Error)s"'
467	no_certificate = "no certificate %s" % format
468	student['matric_no'] = matric_no = student.get('matric_no').upper()
469	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
470	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
471	if matric_no == '':
472	student['Error'] = "Empty matric_no"
473	no_import.append( format_error % student)
474	continue
475	if matric_no in regs or self.returning_import(matric_no = matric_no):
476	student['Error'] = "Duplicate"
477	no_import.append( format_error % student)
478	continue
479	cert_id = makeCertificateCode(student.get('Coursemajorcode'))
480	if cert_id not in certs.keys():
481	student['Error'] = "No Certificate %s" % cert_id
482	no_import.append( format_error % student)
483	continue
484	try:
485	table.addRecord(**student)
486	except ValueError:
487	student['Error'] = "Duplicate"
488	no_import.append( format_error % student)
489	continue
490	regs.append(student.get('matric_no'))
491	imported.append(format % student)
492	tr_count += 1
493	if tr_count > 1000:
494	if len(no_import) > 0:
495	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
496	'\n'.join(no_import) + '\n')
497	no_import = []
498	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
499	'\n'.join(no_import) + "\n")
500	imported = []
501	em = '%d transactions commited total %s\n' % (tr_count,total)
502	transaction.commit()
503	regs = []
504	logger.info(em)
505	total += tr_count
506	tr_count = 0
507	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
508	'\n'.join(imported))
509	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
510	'\n'.join(no_import))
511	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
512	###)
513
514	security.declareProtected(ModifyPortalContent,"fixAllNames")###(
515	def fixAllNames(self):
516	"fix all students names"
517	import transaction
518	response = self.REQUEST.RESPONSE
519	logger = logging.getLogger('fixAllNames')
520	logger.info('Start')
521	students = self.portal_catalog(portal_type='Student')
522	count = 0
523	total = 0
524	for student in students:
525	scat_res = self.students_catalog(id = student.getId)
526	if not scat_res:
527	self.students_catalog.addRecord(id = student.getId)
528	scat_res = self.students_catalog(id = student.getId)
529	student_entry = scat_res[0]
530	old_new = self.fixName(student,student_entry)
531	count += 1
532	response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
533	if count > 2000:
534	transaction.commit()
535	logger.info("%d transactions commited" % count)
536	total += count
537	count = 0
538	###)
539
540	security.declareProtected(ModifyPortalContent,"fixName")###(
541	def fixName(self,student_brain, student_entry):
542	"fix the name of a student"
543	fix = "first"
544	if student_entry.get('name_fixed',None) == fix:
545	return "Name already fixed"
546	student_id = student_entry.id
547	new_student = student_entry.jamb_reg_no.startswith('6')
548	student_obj = student_brain.getObject()
549	personal = getattr(student_obj,'personal',None)
550	invalid = ''
551	if personal is None:
552	return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
553	per_doc = personal.getContent()
554	old_first = per_doc.firstname
555	old_middle = per_doc.middlename
556	old_last = per_doc.lastname
557	new_first = ''
558	new_middle = ''
559	new_last = ''
560	if new_student:
561	if not old_first and not old_middle and old_last:
562	new_names = [n.capitalize() for n in old_last.split()]
563	if len(new_names) > 1:
564	old_first = new_names[0]
565	old_last = new_names[-1]
566	old_middle = ' '.join(new_names[1:-1])
567	else:
568	old_last = new_names[0]
569	old_first = ''
570	old_middle = ''
571	if old_first:
572	new_first = old_first
573	if old_middle:
574	new_middle = old_middle
575	if old_last:
576	new_last = old_last
577	if old_first.find('<') != -1 or\
578	old_first.find('>') != -1 or\
579	old_middle.find('<') != -1 or\
580	old_middle.find('>') != -1 or\
581	old_last.find('<') != -1 or\
582	old_last.find('>') != -1:
583	invalid = "invalid characters"
584	else:
585	new_first = old_first
586	if new_first.strip() == '-':
587	new_first = ''
588	new_middle = old_middle
589	if new_middle.strip() == '-':
590	new_middle = ''
591	new_last = old_last
592	if new_last.strip() == '-':
593	new_last = ''
594	name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
595	if new_student:
596	text = "New"
597	else:
598	text = "Returning"
599	old_new = '"%s","%s","%s","%s"' % (invalid,text,
600	student_entry.name,
601	name)
602	if not invalid:
603	self.students_catalog.modifyRecord(id = student_id,
604	name_fixed = fix,
605	name = name)
606	per_doc.edit(mapping = {'firstname' : new_first,
607	'middlename' : new_middle,
608	'lastname' : new_last,
609	})
610	return old_new
611	###)
612
613	security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
614	def updateReturningStudents(self):
615	"""load and overwrite Returning Student Data from CSV values"""
616	import transaction
617	import random
618	#from pdb import set_trace
619	wftool = self.portal_workflow
620	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
621	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
622	students_folder = self.portal_url.getPortalObject().campus.students
623	tr_count = 1
624	total = 0
625	#name = 'pume_results'
626	name = 'Returning_update'
627	table = self.returning_import
628	no_import = []
629	imported = []
630	logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
631	try:
632	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
633	except:
634	logger.error('Error reading %s.csv' % name)
635	return
636	l = self.portal_catalog({'meta_type': "Certificate"})
637	certs = {}
638	cert_docs = {}
639	for f in l:
640	certs[f.getId] = f.getObject().getContent()
641	start = True
642	res = table()
643	regs = []
644	if len(res) > 0:
645	regs = [s.matric_no for s in res]
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	matric_no = student.get('matric_no').upper()
657	student['matric_no'] = matric_no
658	if matric_no == '':
659	student['Error'] = "Empty matric_no"
660	no_import.append( format_error % student)
661	continue
662	# if matric_no in regs or self.returning_import(matric_no = matric_no):
663	# student['Error'] = "Duplicate"
664	# no_import.append( format_error % student)
665	# continue
666	# cert_id = makeCertificateCode(student.get('Coursemajorcode'))
667	# if cert_id not in certs.keys():
668	# student['Error'] = "No Certificate %s" % cert_id
669	# no_import.append( format_error % student)
670	# continue
671	try:
672	table.modifyRecord(**student)
673	except KeyError:
674	#import pdb;pdb.set_trace()
675	student['Error'] = "no Student found to update"
676	no_import.append( format_error % student)
677	continue
678	#s = self.students_catalog(matric_no=matric_no)
679	#if s:
680	# level = "%s" % (int(student.get('Level')) + 100)
681	# self.students_catalog.modifyRecord(id = s[0].id,
682	# level=level)
683
684	regs.append(student.get('matric_no'))
685	imported.append(format % student)
686	tr_count += 1
687	if tr_count > 1000:
688	if len(no_import) > 0:
689	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
690	'\n'.join(no_import) + '\n')
691	no_import = []
692	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
693	'\n'.join(no_import) + "\n")
694	imported = []
695	em = '%d transactions commited total %s\n' % (tr_count,total)
696	transaction.commit()
697	regs = []
698	logger.info(em)
699	total += tr_count
700	tr_count = 0
701	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
702	'\n'.join(imported))
703	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
704	'\n'.join(no_import))
705	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
706	###)
707
708	security.declareProtected(ModifyPortalContent,"importResults")###(
709	def importResults(self):
710	"""load Returning Students Results from CSV"""
711	import transaction
712	import random
713	#from pdb import set_trace
714	wftool = self.portal_workflow
715	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
716	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
717	students_folder = self.portal_url.getPortalObject().campus.students
718	tr_count = 1
719	total = 0
720	#name = 'pume_results'
721	name = 'Results'
722	table = self.results_import
723	no_import = []
724	imported = []
725	logger = logging.getLogger('Students.StudentsFolder.importResults')
726	try:
727	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
728	except:
729	logger.error('Error reading %s.csv' % name)
730	return
731	l = self.portal_catalog({'meta_type': "Course"})
732	courses = [f.getId for f in l]
733	start = True
734	res = table()
735	regs = []
736	if len(res) > 0:
737	regs = [s.key for s in res]
738	no_course = []
739	no_course_list = []
740	course_count = 0
741	for result in results:
742	if start:
743	start = False
744	logger.info('Start loading from %s.csv' % name)
745	s = ','.join(['"%s"' % fn for fn in result.keys()])
746	imported.append(s)
747	no_import.append('%s,"Error"' % s)
748	format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
749	format_error = format + ',"%(Error)s"'
750	no_certificate = "no certificate %s" % format
751	course_id = result.get('CosCode')
752	if not course_id:
753	course_id = 'N/A'
754	result['CosCode'] = course_id
755	matric_no = result.get('matric_no').upper()
756	result['matric_no'] = matric_no
757	key = matric_no+course_id
758	if matric_no == '':
759	result['Error'] = "Empty matric_no"
760	no_import.append( format_error % result)
761	continue
762	if key in regs or self.results_import(key = key):
763	result['Error'] = "Duplicate"
764	no_import.append( format_error % result)
765	continue
766	if course_id not in courses:
767	if course_id not in no_course:
768	course_count +=1
769	no_course.append(course_id)
770	no_course_list.append('"%s"' % course_id)
771	#result['Error'] = "No Course"
772	#logger.info(format_error % result)
773	regs.append(key)
774	imported.append(format % result)
775	tr_count += 1
776	if tr_count > 1000:
777	if len(no_import) > 0:
778	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
779	'\n'.join(no_import)+'\n')
780	no_import = []
781	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
782	'\n'.join(imported) + '\n')
783	imported = []
784	if no_course_list:
785	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
786	'\n'.join(no_course_list) + '\n')
787	no_course_list = []
788	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
789	transaction.commit()
790	logger.info(em)
791	regs = []
792	total += tr_count
793	tr_count = 0
794	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
795	'\n'.join(imported))
796	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
797	'\n'.join(no_import))
798	if no_course_list:
799	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
800	'\n'.join(no_course_list))
801	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
802	logger.info(em)
803	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
804	###)
805
806	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
807	def updateStudyCourse(self):
808	"""update StudyCourse from CSV values"""
809	import transaction
810	import random
811	from pdb import set_trace
812	wftool = self.portal_workflow
813	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
814	students_folder = self.portal_url.getPortalObject().campus.students
815	csv_d = {'jamb_reg_no': "RegNumber",
816	'jamb_lastname': "Name",
817	'session': "Session",
818	'pume_tot_score': "PUME SCORE",
819	'jamb_score': "JambScore",
820	'jamb_sex': "Sex",
821	'jamb_state': "State",
822	## 'jamb_first_cos': "AdminCourse",
823	'faculty': "AdminFaculty",
824	'course_code': "AdmitCoscode",
825	'stud_status':"AdmitStatus",
826	'department': "AdmitDept",
827	'jamb_lga': "LGA",
828	'app_email': "email",
829	'app_mobile': "PhoneNumbers",
830	}
831	csv_fields = [f[1] for f in csv_d.items()]
832	tr_count = 0
833	total = 0
834	#name = 'pume_results'
835	name = 'StudyCourseChange'
836	no_import = []
837	s = ','.join(['"%s"' % fn for fn in csv_fields])
838	no_import.append('"Error",%s' % s)
839	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
840	no_certificate = "no certificate %s" % format
841	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
842	'\n'.join(no_import))
843	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
844	logger.info('Start loading from %s.csv' % name)
845	l = self.portal_catalog({'meta_type': "Certificate"})
846	try:
847	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
848	except:
849	logger.error('Error reading %s.csv' % name)
850	return
851	for jamb in result:
852	jamb['Error'] = "Processing "
853	logger.info(format % jamb)
854	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
855	res = self.portal_catalog({'portal_type': "StudentApplication",
856	'SearchableText': jamb_reg_no })
857	if not res:
858	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
859	logger.info(em)
860	jamb['Error'] = "Student does not exist"
861	no_import.append(format % jamb)
862	continue
863	sid = res[0].getPath().split('/')[-2]
864	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
865	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
866	if not res:
867	em = 'No Certificate with ID %s \n' % cert_id
868	logger.info(em)
869	jamb['Error'] = "No Certificate %s" % cert_id
870	no_import.append( format % jamb)
871	continue
872	cert_brain = res[0]
873	catalog_entry = {}
874	student = getattr(self,sid)
875	#
876	# Study Course
877	#
878	study_course = student.study_course
879	dsc = {}
880	cert_pl = cert_brain.getPath().split('/')
881	catalog_entry['id'] = sid
882	catalog_entry['faculty'] = cert_pl[-4]
883	catalog_entry['department'] = cert_pl[-3]
884	catalog_entry['course'] = cert_id
885	dsc['study_course'] = cert_id
886	study_course.getContent().edit(mapping=dsc)
887	self.students_catalog.modifyRecord(**catalog_entry)
888	if tr_count > 10:
889	if len(no_import) > 1:
890	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
891	'\n'.join(no_import))
892	no_import = []
893	em = '%d transactions commited\n' % tr_count
894	transaction.commit()
895	logger.info(em)
896	total += tr_count
897	tr_count = 0
898	tr_count += 1
899	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
900	###)
901
902	security.declareProtected(View,"fixOwnership") ###(
903	def fixOwnership(self):
904	"""fix Ownership"""
905	for s in self.portal_catalog(meta_type = 'Student'):
906	student = s.getObject()
907	sid = s.getId
908	import pdb;pdb.set_trace()
909	student.application.manage_setLocalRoles(sid, ['Owner',])
910	student.personal.manage_setLocalRoles(sid, ['Owner',])
911	###)
912
913	security.declareProtected(View,"Title") ###(
914	def Title(self):
915	"""compose title"""
916	return "Student Section"
917	###)
918
919	def generateStudentId(self,letter,students = None): ###(
920	import random
921	r = random
922	if students is None:
923	students = self.portal_url.getPortalObject().campus.students
924	if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
925	letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
926	sid = "%c%d" % (letter,r.randint(99999,1000000))
927	while hasattr(students, sid):
928	sid = "%c%d" % (letter,r.randint(99999,1000000))
929	return sid
930	#return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
931	###)
932
933	InitializeClass(StudentsFolder)
934
935	def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
936	"""Add a Student."""
937	ob = StudentsFolder(id, **kw)
938	return CPSBase_adder(container, ob, REQUEST=REQUEST)
939	###)
940
941	###)
942
943	class Student(CPSDocument): ###(
944	"""
945	WAeUP Student container for the various student data
946	"""
947	meta_type = 'Student'
948	portal_type = meta_type
949	security = ClassSecurityInfo()
950
951	security.declareProtected(View,"Title")
952	def Title(self):
953	"""compose title"""
954	reg_nr = self.getId()[1:]
955	data = getattr(self,'personal',None)
956	if data:
957	content = data.getContent()
958	return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
959	data = getattr(self,'application',None)
960	if data:
961	content = data.getContent()
962	return "%s" % (content.jamb_lastname)
963	return self.title
964
965	security.declarePrivate('makeStudentMember') ###(
966	def makeStudentMember(self,sid,password='uNsEt'):
967	"""make the student a member"""
968	membership = self.portal_membership
969	membership.addMember(sid,
970	password ,
971	roles=('Member',
972	'Student',
973	),
974	domains='',
975	properties = {'memberareaCreationFlag': False,
976	'homeless': True},)
977	member = membership.getMemberById(sid)
978	self.portal_registration.afterAdd(member, sid, password, None)
979	self.manage_setLocalRoles(sid, ['Owner',])
980
981	###)
982
983	security.declareProtected(View,'createSubObjects') ###(
984	def createSubObjects(self):
985	"""make the student a member"""
986	dp = {'Title': 'Personal Data'}
987	app_doc = self.application.getContent()
988	names = app_doc.jamb_lastname.split()
989	if len(names) == 3:
990	dp['firstname'] = names[0].capitalize()
991	dp['middlename'] = names[1].capitalize()
992	dp['lastname'] = names[2].capitalize()
993	elif len(names) == 2:
994	dp['firstname'] = names[0].capitalize()
995	dp['lastname'] = names[1].capitalize()
996	else:
997	dp['lastname'] = app_doc.jamb_lastname
998	dp['sex'] = app_doc.jamb_sex == 'F'
999	dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1000	proxy = self.aq_parent
1001	proxy.invokeFactory('StudentPersonal','personal')
1002	per = proxy.personal
1003	per_doc = per.getContent()
1004	per_doc.edit(mapping = dp)
1005	per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1006	#self.portal_workflow.doActionFor(per,'open',dest_container=per)
1007
1008	###)
1009
1010	InitializeClass(Student)
1011
1012	def addStudent(container, id, REQUEST=None, **kw):
1013	"""Add a Student."""
1014	ob = Student(id, **kw)
1015	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1016
1017	###)
1018
1019	class StudentAccommodation(CPSDocument): ###(
1020	"""
1021	WAeUP Student container for the various student data
1022	"""
1023	meta_type = 'StudentAccommodation'
1024	portal_type = meta_type
1025	security = ClassSecurityInfo()
1026
1027	security.declareProtected(View,"Title")
1028	def Title(self):
1029	"""compose title"""
1030	content = self.getContent()
1031	#return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1032	return "Accommodation Data for Session %s" % content.session
1033
1034
1035	InitializeClass(StudentAccommodation)
1036
1037	def addStudentAccommodation(container, id, REQUEST=None, **kw):
1038	"""Add a Students personal data."""
1039	ob = StudentAccommodation(id, **kw)
1040	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1041
1042	###)
1043
1044	class StudentPersonal(CPSDocument): ###(
1045	"""
1046	WAeUP Student container for the various student data
1047	"""
1048	meta_type = 'StudentPersonal'
1049	portal_type = meta_type
1050	security = ClassSecurityInfo()
1051
1052	security.declareProtected(View,"Title")
1053	def Title(self):
1054	"""compose title"""
1055	content = self.getContent()
1056	#return "Personal Data for %s %s" % (content.firstname,content.lastname)
1057	return "Personal Data"
1058
1059
1060	InitializeClass(StudentPersonal)
1061
1062	def addStudentPersonal(container, id, REQUEST=None, **kw):
1063	"""Add a Students personal data."""
1064	ob = StudentPersonal(id, **kw)
1065	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1066
1067	###)
1068
1069	class StudentClearance(CPSDocument): ###(
1070	"""
1071	WAeUP Student container for the various student data
1072	"""
1073	meta_type = 'StudentClearance'
1074	portal_type = meta_type
1075	security = ClassSecurityInfo()
1076
1077	security.declareProtected(View,"Title")
1078	def Title(self):
1079	"""compose title"""
1080	content = self.getContent()
1081	#return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1082	return "Clearance/Eligibility Record"
1083
1084
1085	InitializeClass(StudentClearance)
1086
1087	def addStudentClearance(container, id, REQUEST=None, **kw):
1088	"""Add a Students personal data."""
1089	ob = StudentClearance(id, **kw)
1090	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1091
1092	###)
1093
1094	class StudentStudyLevel(CPSDocument): ###(
1095	"""
1096	WAeUP Student container for the various student data
1097	"""
1098	meta_type = 'StudentStudyLevel'
1099	portal_type = meta_type
1100	security = ClassSecurityInfo()
1101
1102	security.declareProtected(View,"Title")
1103	def Title(self):
1104	"""compose title"""
1105	return "Level %s" % self.aq_parent.getId()
1106
1107	def create_course_results(self,cert_id,current_level): ###(
1108	"create all courses in a level"
1109	aq_portal = self.portal_catalog.evalAdvancedQuery
1110	res = self.portal_catalog(portal_type="Certificate", id = cert_id)
1111	l = []
1112	import transaction
1113	if res:
1114	cert = res[0]
1115	path = cert.getPath()
1116	query = Eq("path","%s/%s" % (path,current_level)) &\
1117	Eq('portal_type','CertificateCourse')
1118	courses = aq_portal(query)
1119	#from pdb import set_trace;set_trace()
1120	self_proxy = self.aq_parent
1121	for c in courses:
1122	d = self.getCourseInfo(c.getId)
1123	cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
1124	course_result = getattr(self_proxy,cr_id)
1125	self.portal_workflow.doActionFor(course_result,'open')
1126	d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
1127	course_result.getContent().edit(mapping=d)
1128	transaction.commit()
1129	###)
1130
1131	InitializeClass(StudentStudyLevel)
1132
1133	def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1134	"""Add a Students personal data."""
1135	ob = StudentStudyLevel(id, **kw)
1136	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1137
1138	###)
1139
1140	class StudentStudyCourse(CPSDocument): ###(
1141	"""
1142	WAeUP Student container for the various student data
1143	"""
1144	meta_type = 'StudentStudyCourse'
1145	portal_type = meta_type
1146	security = ClassSecurityInfo()
1147
1148	security.declareProtected(View,"Title")
1149	def Title(self):
1150	"""compose title"""
1151	content = self.getContent()
1152	return "Study Course"
1153
1154
1155	InitializeClass(StudentStudyCourse)
1156
1157	def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1158	"""Add a Students personal data."""
1159	ob = StudentStudyCourse(id, **kw)
1160	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1161
1162	###)
1163
1164	class StudentApplication(CPSDocument): ###(
1165	"""
1166	WAeUP Student container for the various student data
1167	"""
1168	meta_type = 'StudentApplication'
1169	portal_type = meta_type
1170	security = ClassSecurityInfo()
1171
1172	security.declareProtected(View,"Title")
1173	def Title(self):
1174	"""compose title"""
1175	return "Application Data"
1176
1177
1178	InitializeClass(StudentApplication)
1179
1180	def addStudentApplication(container, id, REQUEST=None, **kw):
1181	"""Add a Students eligibility data."""
1182	ob = StudentApplication(id, **kw)
1183	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1184	###)
1185
1186	class StudentPume(CPSDocument): ###(
1187	"""
1188	WAeUP Student container for the various student data
1189	"""
1190	meta_type = 'StudentPume'
1191	portal_type = meta_type
1192	security = ClassSecurityInfo()
1193
1194	security.declareProtected(View,"Title")
1195	def Title(self):
1196	"""compose title"""
1197	return "PUME Results"
1198
1199
1200	InitializeClass(StudentPume)
1201
1202	def addStudentPume(container, id, REQUEST=None, **kw):
1203	"""Add a Students PUME data."""
1204	ob = StudentPume(id, **kw)
1205	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1206	###)
1207
1208	##class StudentSemester(CPSDocument): ###(
1209	## """
1210	## WAeUP StudentSemester containing the courses and students
1211	## """
1212	## meta_type = 'StudentSemester'
1213	## portal_type = meta_type
1214	## security = ClassSecurityInfo()
1215	##
1216	##InitializeClass(StudentSemester)
1217	##
1218	##def addStudentSemester(container, id, REQUEST=None, **kw):
1219	## """Add a StudentSemester."""
1220	## ob = StudentSemester(id, **kw)
1221	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1222	##
1223	#####)
1224
1225	##class Semester(CPSDocument): ###(
1226	## """
1227	## WAeUP Semester containing the courses and students
1228	## """
1229	## meta_type = 'Semester'
1230	## portal_type = meta_type
1231	## security = ClassSecurityInfo()
1232	##
1233	##InitializeClass(Semester)
1234	##
1235	##def addSemester(container, id, REQUEST=None, **kw):
1236	## """Add a Semester."""
1237	## ob = Semester(id, **kw)
1238	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1239	##
1240	#####)
1241
1242	class StudentCourseResult(CPSDocument): ###(
1243	"""
1244	WAeUP StudentCourseResult
1245	"""
1246	meta_type = 'StudentCourseResult'
1247	portal_type = meta_type
1248	security = ClassSecurityInfo()
1249
1250	def getCourseEntry(self,cid):
1251	res = self.portal_catalog({'meta_type': "Course",
1252	'id': cid})
1253	if res:
1254	return res[-1]
1255	else:
1256	return None
1257
1258	security.declareProtected(View,"Title")
1259	def Title(self):
1260	"""compose title"""
1261	cid = self.aq_parent.getId()
1262	ce = self.getCourseEntry(cid)
1263	if ce:
1264	return "%s" % ce.Title
1265	return "No course with id %s" % cid
1266
1267	InitializeClass(StudentCourseResult)
1268
1269	def addStudentCourseResult(container, id, REQUEST=None, **kw):
1270	"""Add a StudentCourseResult."""
1271	ob = StudentCourseResult(id, **kw)
1272	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1273	###)
1274
1275	# Backward Compatibility StudyLevel
1276
1277	from Products.WAeUP_SRP.Academics import StudyLevel
1278
1279	from Products.WAeUP_SRP.Academics import addStudyLevel
1280

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

Download in other formats: