Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1704

Last change on this file since 1704 was 1700, checked in by joachim, 17 years ago
students_catalog reindexing implemented.
Property svn:keywords set to `Id`
File size: 80.1 KB

Line
1	#-- mode: python; mode: fold --
2	# $Id: Students.py 1700 2007-04-23 21:16:34Z joachim $
3	from string import Template
4	from Globals import InitializeClass
5	from AccessControl import ClassSecurityInfo
6	from AccessControl.SecurityManagement import newSecurityManager
7	from zExceptions import BadRequest
8	from Products.ZCatalog.ZCatalog import ZCatalog
9	from Products.CMFCore.utils import UniqueObject, getToolByName
10	from Products.CMFCore.permissions import View
11	from Products.CMFCore.permissions import ModifyPortalContent
12	from Products.CPSCore.CPSBase import CPSBase_adder, CPSBaseFolder
13	#from Products.CPSCore.CPSBase import CPSBaseDocument as BaseDocument
14	from Products.CPSDocument.CPSDocument import CPSDocument
15	from Products.CPSCore.CPSBase import CPSBaseBTreeFolder as BaseBTreeFolder
16	from Products.CPSCore.CPSMembershipTool import CPSUnrestrictedUser
17	from Products.WAeUP_SRP.Academics import makeCertificateCode
18	from Products.AdvancedQuery import Eq, Between, Le,In
19	import 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,"createDEStudents")###(
97	def createDEStudents(self):
98	"""load Fulltime Studentdata from CSV values"""
99	import transaction
100	import random
101	#from pdb import set_trace
102	wftool = self.portal_workflow
103	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
104	csv_d = {'jamb_reg_no': "RegNumber",
105	'jamb_lastname': "Name",
106	'session': "Session",
107	'pume_tot_score': "PUDE SCORE",
108	##'jamb_score': "JambScore",
109	'entry_mode': "EntryMode",
110	'jamb_sex': "Sex",
111	'jamb_state': "State",
112	'jamb_first_cos': "AdminCourse",
113	'faculty': "AdminFaculty",
114	'course_code': "AdmitCoscode",
115	'stud_status':"AdmitStatus",
116	'department': "AdmitDept",
117	'jamb_lga': "LGA",
118	'app_email': "email",
119	'app_mobile': "PhoneNumbers",
120	}
121	csv_fields = [f[1] for f in csv_d.items()]
122	tr_count = 0
123	total = 0
124	#name = 'pume_results'
125	name = 'DE_Admitted'
126	no_import = []
127	s = ','.join(['"%s"' % fn for fn in csv_fields])
128	no_import.append('"Error",%s' % s)
129	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
130	no_certificate = "no certificate %s" % format
131	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
132	logger = logging.getLogger('Students.StudentsFolder.createDEStudents')
133	logger.info('Start loading from %s.csv' % name)
134	l = self.portal_catalog({'meta_type': "Certificate"})
135	certs = {}
136	cert_docs = {}
137	for f in l:
138	certs[f.getId] = f.getObject().getContent()
139	try:
140	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
141	except:
142	logger.error('Error reading %s.csv' % name)
143	return
144	for jamb in result:
145	jamb['Error'] = "Processing"
146	logger.info(format % jamb)
147	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
148	res = self.portal_catalog({'portal_type': "StudentApplication",
149	'SearchableText': jamb_reg_no })
150	if res:
151	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
152	logger.info(em)
153	jamb['Error'] = "Student exists"
154	no_import.append(format % jamb)
155	continue
156	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
157	if cert_id not in certs.keys():
158	em = 'No Certificate with ID %s \n' % cert_id
159	logger.info(em)
160	jamb['Error'] = "No Certificate %s" % cert_id
161	no_import.append( format % jamb)
162	continue
163	jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
164	cert_doc = certs[cert_id]
165	catalog_entry = {}
166	catalog_entry['jamb_reg_no'] = jamb_reg_no
167	jamb_name = jamb.get(csv_d['jamb_lastname'])
168	jamb_name.replace('>','')
169	jamb_name.replace('<','')
170	names = jamb_name.split()
171	letter = names[-1][0].upper()
172	sid = self.generateStudentId(letter)
173	not_created = True
174	while not_created:
175	try:
176	students_folder.invokeFactory('Student', sid)
177	not_created = False
178	except BadRequest:
179	sid = self.generateStudentId(letter)
180	catalog_entry['id'] = sid
181	tr_count += 1
182	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
183	student = getattr(self,sid)
184	student.manage_setLocalRoles(sid, ['Owner',])
185	student.invokeFactory('StudentPume','pume')
186	dp = {'Title': 'Pume Data'}
187	student.invokeFactory('StudentApplication','application')
188	da = {'Title': 'Application Data'}
189	da["jamb_lastname"] = jamb_name
190	da_fields = ('jamb_reg_no',
191	'jamb_sex',
192	'entry_mode',
193	#'jamb_score',
194	'jamb_first_cos',
195	'jamb_sex',
196	'jamb_state',
197	'jamb_lga',
198	'app_email',
199	'app_mobile',
200	)
201	for f in da_fields:
202	da[f] = jamb.get(csv_d[f])
203	catalog_entry['email'] = jamb.get(csv_d['app_email'])
204	app = student.application
205	app_doc = app.getContent()
206	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
207	#import pdb;pdb.set_trace()
208	if os.path.exists(picture):
209	file = open(picture)
210	if False:
211	img = PIL.Image.open(file)
212	img.thumbnail((150,200),
213	resample=PIL.Image.ANTIALIAS)
214	# We now need a buffer to write to. It can't be the same
215	# as the inbuffer as the PNG writer will write over itself.
216	outfile = StringIO()
217	img.save(outfile, format=img.format)
218	else:
219	outfile = file.read()
220	app_doc.manage_addFile('passport',
221	file=outfile,
222	title="%s.jpg" % jamb_reg_no)
223	app.getContent().edit(mapping=da)
224	app.manage_setLocalRoles(sid, ['Owner',])
225	#wftool.doActionFor(app,'close')
226	dp_fields = (
227	#'pume_eng_score',
228	#'pume_gen_score',
229	'pume_tot_score',
230	)
231	dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
232	pume = student.pume
233	pume.getContent().edit(mapping=dp)
234	#wftool.doActionFor(pume,'close')
235	pume.manage_setLocalRoles(sid, ['Owner',])
236	#student.getContent().createSubObjects()
237	dp = {}
238	if len(names) == 3:
239	dp['firstname'] = names[0].capitalize()
240	dp['middlename'] = names[1].capitalize()
241	dp['lastname'] = names[2].capitalize()
242	elif len(names) == 2:
243	dp['firstname'] = names[0].capitalize()
244	dp['middlename'] = ''
245	dp['lastname'] = names[1].capitalize()
246	else:
247	dp['firstname'] = ''
248	dp['middlename'] = ''
249	dp['lastname'] = jamb_name
250	dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
251	catalog_entry['sex'] = dp['sex']
252	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
253	student.invokeFactory('StudentPersonal','personal')
254	per = student.personal
255	per_doc = per.getContent()
256	per_doc.edit(mapping = dp)
257	per.manage_setLocalRoles(sid, ['Owner',])
258	if jamb.get(csv_d['stud_status']) == "Admitted":
259	wftool.doActionFor(student,'pume_pass')
260	wftool.doActionFor(student,'admit')
261	else:
262	wftool.doActionFor(student,'pume_fail')
263	wftool.doActionFor(student,'reject_admission')
264	continue
265	#
266	# Clearance
267	#
268	student.invokeFactory('StudentClearance','clearance')
269	#wftool.doActionFor(student.clearance,'open')
270	dp = {'Title': 'Clearance/Eligibility Record'}
271	student.clearance.manage_setLocalRoles(sid, ['Owner',])
272	#
273	# Study Course
274	#
275	student.invokeFactory('StudentStudyCourse','study_course')
276	study_course = student.study_course
277	dsc = {}
278	#from_certificate = ['title',
279	# 'max_elect',
280	# 'max_pass',
281	# 'n_core',
282	# 'nr_years',
283	# 'probation_credits',
284	# 'promotion_credits',
285	# 'start_level',
286	# ]
287	#for f in from_certificate:
288	# dsc[f] = getattr(cert_doc,f)
289	#dsc['faculty'] = jamb.get(csv_d['faculty'])
290	#dsc['department'] = jamb.get(csv_d['department'])
291	catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
292	catalog_entry['department'] = jamb.get(csv_d['department'])
293	catalog_entry['course'] = cert_id
294	#catalog_entry['level'] = getattr(cert_doc,'start_level')
295	catalog_entry['level'] = '200'
296	dsc['study_course'] = cert_id
297	dsc['current_level'] = '200'
298	#dsc['entry_session'] = jamb.get(csv_d['session'])
299	study_course.getContent().edit(mapping=dsc)
300	self.students_catalog.addRecord(**catalog_entry)
301	if tr_count > 10:
302	if len(no_import) > 1:
303	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
304	'\n'.join(no_import)+'\n')
305	no_import = []
306	em = '%d transactions commited\n' % tr_count
307	transaction.commit()
308	logger.info(em)
309	total += tr_count
310	tr_count = 0
311	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
312	'\n'.join(no_import))
313	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
314	###)
315
316	security.declareProtected(ModifyPortalContent,"createNewStudents")###(
317	def createNewStudents(self):
318	"""load Fulltime Studentdata from CSV values"""
319	import transaction
320	import random
321	#from pdb import set_trace
322	wftool = self.portal_workflow
323	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
324	csv_d = {'jamb_reg_no': "RegNumber",
325	'jamb_lastname': "Name",
326	'session': "Session",
327	'pume_tot_score': "PUME SCORE",
328	'jamb_score': "JambScore",
329	'jamb_sex': "Sex",
330	'jamb_state': "State",
331	## 'jamb_first_cos': "AdminCourse",
332	'faculty': "AdminFaculty",
333	'course_code': "AdmitCoscode",
334	'stud_status':"AdmitStatus",
335	'department': "AdmitDept",
336	'jamb_lga': "LGA",
337	'app_email': "email",
338	'app_mobile': "PhoneNumbers",
339	}
340	csv_fields = [f[1] for f in csv_d.items()]
341	tr_count = 0
342	total = 0
343	#name = 'pume_results'
344	name = 'Admitted'
345	no_import = []
346	s = ','.join(['"%s"' % fn for fn in csv_fields])
347	no_import.append('"Error",%s' % s)
348	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
349	no_certificate = "no certificate %s" % format
350	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
351	logger = logging.getLogger('Students.StudentsFolder.createNewStudents')
352	logger.info('Start loading from %s.csv' % name)
353	l = self.portal_catalog({'meta_type': "Certificate"})
354	certs = {}
355	cert_docs = {}
356	for f in l:
357	certs[f.getId] = f.getObject().getContent()
358	try:
359	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
360	except:
361	logger.error('Error reading %s.csv' % name)
362	return
363	for jamb in result:
364	jamb['Error'] = "Processing "
365	logger.info(format % jamb)
366	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
367	res = self.portal_catalog({'portal_type': "StudentApplication",
368	'SearchableText': jamb_reg_no })
369	if res:
370	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
371	logger.info(em)
372	jamb['Error'] = "Student exists"
373	no_import.append(format % jamb)
374	continue
375	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
376	if cert_id not in certs.keys():
377	em = 'No Certificate with ID %s \n' % cert_id
378	logger.info(em)
379	jamb['Error'] = "No Certificate %s" % cert_id
380	no_import.append( format % jamb)
381	continue
382	res = self.portal_pumeresults(jamb_reg_no = jamb_reg_no)
383	if len(res) == 1:
384	self.portal_pumeresults.modifyRecord(jamb_reg_no = jamb_reg_no,
385	status = jamb.get(csv_d['stud_status']),
386	)
387	jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
388	cert_doc = certs[cert_id]
389	catalog_entry = {}
390	catalog_entry['jamb_reg_no'] = jamb_reg_no
391	jamb_name = jamb.get(csv_d['jamb_lastname'])
392	jamb_name.replace('>','')
393	jamb_name.replace('<','')
394	names = jamb_name.split()
395	letter = names[-1][0].upper()
396	sid = self.generateStudentId(letter)
397	not_created = True
398	while not_created:
399	try:
400	students_folder.invokeFactory('Student', sid)
401	not_created = False
402	except BadRequest:
403	sid = self.generateStudentId(letter)
404	catalog_entry['id'] = sid
405	tr_count += 1
406	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
407	student = getattr(self,sid)
408	student.manage_setLocalRoles(sid, ['Owner',])
409	student.invokeFactory('StudentPume','pume')
410	dp = {'Title': 'Pume Data'}
411	student.invokeFactory('StudentApplication','application')
412	da = {'Title': 'Application Data'}
413	da["jamb_lastname"] = jamb_name
414	da_fields = ('jamb_reg_no',
415	'jamb_sex',
416	#'jamb_state',
417	'jamb_score',
418	## 'jamb_first_cos',
419	'jamb_sex',
420	'jamb_state',
421	'jamb_lga',
422	'app_email',
423	'app_mobile',
424	)
425	for f in da_fields:
426	da[f] = jamb.get(csv_d[f])
427	catalog_entry['email'] = jamb.get(csv_d['app_email'])
428	app = student.application
429	app_doc = app.getContent()
430	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
431	#import pdb;pdb.set_trace()
432	if os.path.exists(picture):
433	file = open(picture)
434	if False:
435	img = PIL.Image.open(file)
436	img.thumbnail((150,200),
437	resample=PIL.Image.ANTIALIAS)
438	# We now need a buffer to write to. It can't be the same
439	# as the inbuffer as the PNG writer will write over itself.
440	outfile = StringIO()
441	img.save(outfile, format=img.format)
442	else:
443	outfile = file.read()
444	app_doc.manage_addFile('passport',
445	file=outfile,
446	title="%s.jpg" % jamb_reg_no)
447	app.getContent().edit(mapping=da)
448	app.manage_setLocalRoles(sid, ['Owner',])
449	#wftool.doActionFor(app,'close')
450	dp_fields = (
451	#'pume_eng_score',
452	#'pume_gen_score',
453	'pume_tot_score',
454	)
455	dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
456	pume = student.pume
457	pume.getContent().edit(mapping=dp)
458	#wftool.doActionFor(pume,'close')
459	pume.manage_setLocalRoles(sid, ['Owner',])
460	#student.getContent().createSubObjects()
461	dp = {}
462	if len(names) == 3:
463	dp['firstname'] = names[0].capitalize()
464	dp['middlename'] = names[1].capitalize()
465	dp['lastname'] = names[2].capitalize()
466	elif len(names) == 2:
467	dp['firstname'] = names[0].capitalize()
468	dp['middlename'] = ''
469	dp['lastname'] = names[1].capitalize()
470	else:
471	dp['firstname'] = ''
472	dp['middlename'] = ''
473	dp['lastname'] = jamb_name
474	dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
475	catalog_entry['sex'] = dp['sex']
476	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
477	student.invokeFactory('StudentPersonal','personal')
478	per = student.personal
479	per_doc = per.getContent()
480	per_doc.edit(mapping = dp)
481	per.manage_setLocalRoles(sid, ['Owner',])
482	if jamb.get(csv_d['stud_status']) == "Admitted":
483	wftool.doActionFor(student,'pume_pass')
484	wftool.doActionFor(student,'admit')
485	else:
486	wftool.doActionFor(student,'pume_fail')
487	wftool.doActionFor(student,'reject_admission')
488	continue
489	#
490	# Clearance
491	#
492	student.invokeFactory('StudentClearance','clearance')
493	#wftool.doActionFor(student.clearance,'open')
494	dp = {'Title': 'Clearance/Eligibility Record'}
495	student.clearance.manage_setLocalRoles(sid, ['Owner',])
496	#
497	# Study Course
498	#
499	student.invokeFactory('StudentStudyCourse','study_course')
500	study_course = student.study_course
501	dsc = {}
502	#from_certificate = ['title',
503	# 'max_elect',
504	# 'max_pass',
505	# 'n_core',
506	# 'nr_years',
507	# 'probation_credits',
508	# 'promotion_credits',
509	# 'start_level',
510	# ]
511	#for f in from_certificate:
512	# dsc[f] = getattr(cert_doc,f)
513	#dsc['faculty'] = jamb.get(csv_d['faculty'])
514	#dsc['department'] = jamb.get(csv_d['department'])
515	catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
516	catalog_entry['department'] = jamb.get(csv_d['department'])
517	catalog_entry['course'] = cert_id
518	#catalog_entry['level'] = getattr(cert_doc,'start_level')
519	catalog_entry['level'] = '100'
520	dsc['study_course'] = cert_id
521	dsc['entry_level'] = '100'
522	#dsc['entry_session'] = jamb.get(csv_d['session'])
523	study_course.getContent().edit(mapping=dsc)
524	self.students_catalog.addRecord(**catalog_entry)
525	if tr_count > 10:
526	if len(no_import) > 0:
527	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
528	'\n'.join(no_import) + "\n")
529	no_import = []
530	em = '%d transactions commited\n' % tr_count
531	transaction.commit()
532	logger.info(em)
533	total += tr_count
534	tr_count = 0
535	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
536	'\n'.join(no_import))
537	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
538	###)
539
540	security.declareProtected(ModifyPortalContent,"createNewStudents")###(
541	def createParttimeStudents(self):
542	"""load Parttime Studentdata from CSV values"""
543	import transaction
544	import random
545	#from pdb import set_trace
546	wftool = self.portal_workflow
547	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
548	csv_d = {'jamb_reg_no': "Reg_No",
549	'jamb_firstname': "Firstname",
550	'jamb_middlename': "Middlename",
551	'jamb_lastname': "Lastname",
552	'jamb_sex': "Sex",
553	'entry_mode': 'Entry_mode',
554	'jamb_age': "Age",
555	'jamb_state': "State",
556	## 'jamb_first_cos': "AdminCourse",
557	'faculty': "AdminFaculty",
558	'course_code': "AdmitCoscode",
559	'stud_status':"AdmitStatus",
560	'department': "AdmitDept",
561	'jamb_lga': "LGA",
562	'app_email': "email",
563	'app_mobile': "PhoneNumbers",
564	}
565	csv_fields = [f[1] for f in csv_d.items()]
566	tr_count = 0
567	total = 0
568	#name = 'pume_results'
569	name = 'Admitted'
570	no_import = []
571	s = ','.join(['"%s"' % fn for fn in csv_fields])
572	no_import.append('"Error",%s' % s)
573	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
574	no_certificate = "no certificate %s" % format
575	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
576	logger = logging.getLogger('Students.StudentsFolder.createNewStudents')
577	logger.info('Start loading from %s.csv' % name)
578	l = self.portal_catalog({'meta_type': "Certificate"})
579	certs = {}
580	cert_docs = {}
581	for f in l:
582	certs[f.getId] = f.getObject().getContent()
583	try:
584	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
585	except:
586	logger.error('Error reading %s.csv' % name)
587	return
588	for jamb in result:
589	jamb['Error'] = "Processing "
590	logger.info(format % jamb)
591	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
592	res = self.portal_catalog({'portal_type': "StudentApplication",
593	'SearchableText': jamb_reg_no })
594	if res:
595	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
596	logger.info(em)
597	jamb['Error'] = "Student exists"
598	no_import.append(format % jamb)
599	continue
600	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
601	if cert_id not in certs.keys():
602	em = 'No Certificate with ID %s \n' % cert_id
603	logger.info(em)
604	jamb['Error'] = "No Certificate %s" % cert_id
605	no_import.append( format % jamb)
606	continue
607	res = self.portal_pumeresults(jamb_reg_no = jamb_reg_no)
608	if len(res) == 1:
609	self.portal_pumeresults.modifyRecord(jamb_reg_no = jamb_reg_no,
610	status = jamb.get(csv_d['stud_status']),
611	)
612	jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
613	cert_doc = certs[cert_id]
614	catalog_entry = {}
615	catalog_entry['jamb_reg_no'] = jamb_reg_no
616	jamb_name = jamb.get(csv_d['jamb_lastname'])
617	jamb_name.replace('>','')
618	jamb_name.replace('<','')
619	names = jamb_name.split()
620	letter = names[-1][0].upper()
621	sid = self.generateStudentId(letter)
622	not_created = True
623	while not_created:
624	try:
625	students_folder.invokeFactory('Student', sid)
626	not_created = False
627	except BadRequest:
628	sid = self.generateStudentId(letter)
629	catalog_entry['id'] = sid
630	tr_count += 1
631	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
632	student = getattr(self,sid)
633	student.manage_setLocalRoles(sid, ['Owner',])
634	student.invokeFactory('StudentPume','pume')
635	dp = {'Title': 'Pume Data'}
636	student.invokeFactory('StudentApplication','application')
637	da = {'Title': 'Application Data'}
638	da["jamb_lastname"] = jamb_name
639	da_fields = ('jamb_reg_no',
640	'jamb_sex',
641	#'jamb_state',
642	'jamb_score',
643	## 'jamb_first_cos',
644	'jamb_sex',
645	'jamb_state',
646	'jamb_lga',
647	'app_email',
648	'app_mobile',
649	)
650	for f in da_fields:
651	da[f] = jamb.get(csv_d[f])
652	catalog_entry['email'] = jamb.get(csv_d['app_email'])
653	app = student.application
654	app_doc = app.getContent()
655	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
656	#import pdb;pdb.set_trace()
657	if os.path.exists(picture):
658	file = open(picture)
659	if False:
660	img = PIL.Image.open(file)
661	img.thumbnail((150,200),
662	resample=PIL.Image.ANTIALIAS)
663	# We now need a buffer to write to. It can't be the same
664	# as the inbuffer as the PNG writer will write over itself.
665	outfile = StringIO()
666	img.save(outfile, format=img.format)
667	else:
668	outfile = file.read()
669	app_doc.manage_addFile('passport',
670	file=outfile,
671	title="%s.jpg" % jamb_reg_no)
672	app.getContent().edit(mapping=da)
673	app.manage_setLocalRoles(sid, ['Owner',])
674	#wftool.doActionFor(app,'close')
675	dp_fields = (
676	#'pume_eng_score',
677	#'pume_gen_score',
678	'pume_tot_score',
679	)
680	dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
681	pume = student.pume
682	pume.getContent().edit(mapping=dp)
683	#wftool.doActionFor(pume,'close')
684	pume.manage_setLocalRoles(sid, ['Owner',])
685	#student.getContent().createSubObjects()
686	dp = {}
687	if len(names) == 3:
688	dp['firstname'] = names[0].capitalize()
689	dp['middlename'] = names[1].capitalize()
690	dp['lastname'] = names[2].capitalize()
691	elif len(names) == 2:
692	dp['firstname'] = names[0].capitalize()
693	dp['middlename'] = ''
694	dp['lastname'] = names[1].capitalize()
695	else:
696	dp['firstname'] = ''
697	dp['middlename'] = ''
698	dp['lastname'] = jamb_name
699	dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
700	catalog_entry['sex'] = dp['sex']
701	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
702	student.invokeFactory('StudentPersonal','personal')
703	per = student.personal
704	per_doc = per.getContent()
705	per_doc.edit(mapping = dp)
706	per.manage_setLocalRoles(sid, ['Owner',])
707	if jamb.get(csv_d['stud_status']) == "Admitted":
708	wftool.doActionFor(student,'pume_pass')
709	wftool.doActionFor(student,'admit')
710	else:
711	wftool.doActionFor(student,'pume_fail')
712	wftool.doActionFor(student,'reject_admission')
713	continue
714	#
715	# Clearance
716	#
717	student.invokeFactory('StudentClearance','clearance')
718	#wftool.doActionFor(student.clearance,'open')
719	dp = {'Title': 'Clearance/Eligibility Record'}
720	student.clearance.manage_setLocalRoles(sid, ['Owner',])
721	#
722	# Study Course
723	#
724	student.invokeFactory('StudentStudyCourse','study_course')
725	study_course = student.study_course
726	dsc = {}
727	#from_certificate = ['title',
728	# 'max_elect',
729	# 'max_pass',
730	# 'n_core',
731	# 'nr_years',
732	# 'probation_credits',
733	# 'promotion_credits',
734	# 'start_level',
735	# ]
736	#for f in from_certificate:
737	# dsc[f] = getattr(cert_doc,f)
738	#dsc['faculty'] = jamb.get(csv_d['faculty'])
739	#dsc['department'] = jamb.get(csv_d['department'])
740	catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
741	catalog_entry['department'] = jamb.get(csv_d['department'])
742	catalog_entry['course'] = cert_id
743	#catalog_entry['level'] = getattr(cert_doc,'start_level')
744	catalog_entry['level'] = '100'
745	dsc['study_course'] = cert_id
746	dsc['entry_level'] = '100'
747	#dsc['entry_session'] = jamb.get(csv_d['session'])
748	study_course.getContent().edit(mapping=dsc)
749	self.students_catalog.addRecord(**catalog_entry)
750	if tr_count > 10:
751	if len(no_import) > 0:
752	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
753	'\n'.join(no_import) + "\n")
754	no_import = []
755	em = '%d transactions commited\n' % tr_count
756	transaction.commit()
757	logger.info(em)
758	total += tr_count
759	tr_count = 0
760	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
761	'\n'.join(no_import))
762	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
763	###)
764
765	security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
766	def importReturningStudents(self):
767	"""load Returning Studentdata from CSV values"""
768	import transaction
769	import random
770	#from pdb import set_trace
771	wftool = self.portal_workflow
772	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
773	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
774	#students_folder = self.portal_url().getPortalObject().campus.students
775	tr_count = 1
776	total = 0
777	#name = 'pume_results'
778	name = 'Returning'
779	table = self.returning_import
780	no_import = []
781	imported = []
782	logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
783	try:
784	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
785	except:
786	logger.error('Error reading %s.csv' % name)
787	return
788	l = self.portal_catalog({'meta_type': "Certificate"})
789	certs = {}
790	cert_docs = {}
791	for f in l:
792	certs[f.getId] = f.getObject().getContent()
793	start = True
794	res = table()
795	regs = []
796	if len(res) > 0:
797	regs = [s.matric_no for s in res]
798	#import pdb;pdb.set_trace()
799	for student in returning:
800	if start:
801	start = False
802	logger.info('Start loading from %s.csv' % name)
803	s = ','.join(['"%s"' % fn for fn in student.keys()])
804	imported.append(s)
805	no_import.append('%s,"Error"' % s)
806	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
807	format_error = format + ',"%(Error)s"'
808	no_certificate = "no certificate %s" % format
809	student['matric_no'] = matric_no = student.get('matric_no').upper()
810	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
811	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
812	if matric_no == '':
813	student['Error'] = "Empty matric_no"
814	no_import.append( format_error % student)
815	continue
816	if matric_no in regs or self.returning_import(matric_no = matric_no):
817	student['Error'] = "Duplicate"
818	no_import.append( format_error % student)
819	continue
820	cert_id = makeCertificateCode(student.get('Coursemajorcode'))
821	if cert_id not in certs.keys():
822	student['Error'] = "No Certificate %s" % cert_id
823	no_import.append( format_error % student)
824	continue
825	try:
826	table.addRecord(**student)
827	except ValueError:
828	student['Error'] = "Duplicate"
829	no_import.append( format_error % student)
830	continue
831	regs.append(student.get('matric_no'))
832	imported.append(format % student)
833	tr_count += 1
834	if tr_count > 1000:
835	if len(no_import) > 0:
836	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
837	'\n'.join(no_import) + '\n')
838	no_import = []
839	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
840	'\n'.join(no_import) + "\n")
841	imported = []
842	em = '%d transactions commited total %s\n' % (tr_count,total)
843	transaction.commit()
844	regs = []
845	logger.info(em)
846	total += tr_count
847	tr_count = 0
848	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
849	'\n'.join(imported))
850	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
851	'\n'.join(no_import))
852	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
853	###)
854
855	security.declareProtected(ModifyPortalContent,"fixVerdicts")###(
856	def fixVerdicts(self,csv_file=None):
857	"""fix wrong uploaded verdicts"""
858	import transaction
859	import random
860	wftool = self.portal_workflow
861	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
862	students_folder = self.portal_url.getPortalObject().campus.students
863	tr_count = 1
864	total = 0
865	if csv_file is None:
866	name = 'Verdicts'
867	else:
868	name = csv_file
869	st_cat = self.students_catalog
870	no_import = []
871	verdicts_voc = self.portal_vocabularies.verdicts
872	rverdicts = {}
873	for k,v in verdicts_voc.items():
874	rverdicts[v.upper()] = k
875	rverdicts['STUDENT ON PROBATION'] = 'C'
876	logger = logging.getLogger('Students.StudentsFolder.fixVerdicts')
877	try:
878	verdicts = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
879	except:
880	logger.error('Error reading %s.csv' % name)
881	return
882	start = True
883	#import pdb;pdb.set_trace()
884	for verdict in verdicts:
885	if start:
886	start = False
887	logger.info('Start loading from %s.csv' % name)
888	s = ','.join(['"%s"' % fn for fn in verdict.keys()])
889	no_import.append('%s,"Error"' % s)
890	format = ','.join(['"%%(%s)s"' % fn for fn in verdict.keys()])
891	format_error = format + ',"%(Error)s"'
892	matric_no = verdict.get('MAT NO')
893	if not matric_no:
894	continue
895	matric_no = matric_no.upper()
896	if matric_no == '':
897	continue
898	verdict_code = rverdicts.get(verdict.get('CATEGORY'),None)
899	if verdict_code is None:
900	continue
901	sres = st_cat(matric_no = matric_no)
902	if sres:
903	student_id = sres[0].id
904	student_obj = getattr(students_folder,student_id,None)
905	if student_obj:
906	study_course = getattr(student_obj,'study_course',None)
907	if study_course is None:
908	verdict['Error'] = "Student did not yet log in"
909	no_import.append( format_error % verdict)
910	continue
911	st_cat.modifyRecord(id = student_id,
912	verdict=verdict_code)
913
914	dsc = {}
915	dsc['current_verdict'] = verdict_code
916	study_course.getContent().edit(mapping=dsc)
917	else:
918	verdict['Error'] = "Not found in students_catalog"
919	no_import.append( format_error % verdict)
920	continue
921	tr_count += 1
922	if tr_count > 1000:
923	if len(no_import) > 0:
924	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
925	'\n'.join(no_import) + '\n')
926	no_import = []
927	em = '%d transactions commited total %s\n' % (tr_count,total)
928	transaction.commit()
929	regs = []
930	logger.info(em)
931	total += tr_count
932	tr_count = 0
933	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
934	'\n'.join(no_import))
935	total += tr_count
936	em = '%d total transactions commited' % (total)
937	logger.info(em)
938	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
939	###)
940
941	security.declareProtected(ModifyPortalContent,"fixAllNames")###(
942	def fixAllNames(self):
943	"fix all students names"
944	import transaction
945	response = self.REQUEST.RESPONSE
946	logger = logging.getLogger('fixAllNames')
947	logger.info('Start')
948	students = self.portal_catalog(portal_type='Student')
949	count = 0
950	total = 0
951	for student in students:
952	scat_res = self.students_catalog(id = student.getId)
953	if not scat_res:
954	self.students_catalog.addRecord(id = student.getId)
955	scat_res = self.students_catalog(id = student.getId)
956	student_entry = scat_res[0]
957	old_new = self.fixName(student,student_entry)
958	count += 1
959	response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
960	if count > 2000:
961	transaction.commit()
962	logger.info("%d transactions commited" % count)
963	total += count
964	count = 0
965	###)
966
967	security.declareProtected(ModifyPortalContent,"fixName")###(
968	def fixName(self,student_brain, student_entry):
969	"fix the name of a student"
970	fix = "first"
971	if student_entry.get('name_fixed',None) == fix:
972	return "Name already fixed"
973	student_id = student_entry.id
974	new_student = student_entry.jamb_reg_no.startswith('6')
975	student_obj = student_brain.getObject()
976	personal = getattr(student_obj,'personal',None)
977	invalid = ''
978	if personal is None:
979	return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
980	per_doc = personal.getContent()
981	old_first = per_doc.firstname
982	old_middle = per_doc.middlename
983	old_last = per_doc.lastname
984	new_first = ''
985	new_middle = ''
986	new_last = ''
987	if new_student:
988	if not old_first and not old_middle and old_last:
989	new_names = [n.capitalize() for n in old_last.split()]
990	if len(new_names) > 1:
991	old_first = new_names[0]
992	old_last = new_names[-1]
993	old_middle = ' '.join(new_names[1:-1])
994	else:
995	old_last = new_names[0]
996	old_first = ''
997	old_middle = ''
998	if old_first:
999	new_first = old_first
1000	if old_middle:
1001	new_middle = old_middle
1002	if old_last:
1003	new_last = old_last
1004	if old_first.find('<') != -1 or\
1005	old_first.find('>') != -1 or\
1006	old_middle.find('<') != -1 or\
1007	old_middle.find('>') != -1 or\
1008	old_last.find('<') != -1 or\
1009	old_last.find('>') != -1:
1010	invalid = "invalid characters"
1011	else:
1012	new_first = old_first
1013	if new_first.strip() == '-':
1014	new_first = ''
1015	new_middle = old_middle
1016	if new_middle.strip() == '-':
1017	new_middle = ''
1018	new_last = old_last
1019	if new_last.strip() == '-':
1020	new_last = ''
1021	name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
1022	if new_student:
1023	text = "New"
1024	else:
1025	text = "Returning"
1026	old_new = '"%s","%s","%s","%s"' % (invalid,text,
1027	student_entry.name,
1028	name)
1029	if not invalid:
1030	self.students_catalog.modifyRecord(id = student_id,
1031	name_fixed = fix,
1032	name = name)
1033	per_doc.edit(mapping = {'firstname' : new_first,
1034	'middlename' : new_middle,
1035	'lastname' : new_last,
1036	})
1037	return old_new
1038	###)
1039
1040	security.declareProtected(ModifyPortalContent,"fixAllEntryModeForReturning")###(
1041	def fixAllEntryModeForReturning(self):
1042	"read all Returning*.csv"
1043	ipath = "%s/import/" % i_home
1044	names = os.listdir(ipath)
1045	for name in names:
1046	head,tail = os.path.splitext(name)
1047	if head.startswith('Returning')\
1048	and tail == '.csv'\
1049	and name.find('imported') < 0:
1050	self.fixEntryModeForReturning(csv_file=head)
1051	###)
1052
1053	security.declareProtected(ModifyPortalContent,"fixEntryModeForReturning")###(
1054	def fixEntryModeForReturning(self,csv_file=None):
1055	"""load Returning Studentdata from CSV values"""
1056	import transaction
1057	import random
1058	wftool = self.portal_workflow
1059	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1060	students_folder = self.portal_url.getPortalObject().campus.students
1061	tr_count = 1
1062	total = 0
1063	if csv_file is None:
1064	name = 'Returning'
1065	else:
1066	name = csv_file
1067	table = self.returning_import
1068	st_cat = self.students_catalog
1069	no_import = []
1070	logger = logging.getLogger('Students.StudentsFolder.fixEntryModeForReturning')
1071	try:
1072	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1073	except:
1074	logger.error('Error reading %s.csv' % name)
1075	return
1076	start = True
1077	for student in returning:
1078	if start:
1079	start = False
1080	logger.info('Start loading from %s.csv' % name)
1081	s = ','.join(['"%s"' % fn for fn in student.keys()])
1082	no_import.append('%s,"Error"' % s)
1083	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
1084	format_error = format + ',"%(Error)s"'
1085	matric_no = student.get('matric_no')
1086	if not matric_no:
1087	continue
1088	matric_no = matric_no.upper()
1089	student['matric_no'] = matric_no
1090	if matric_no == '':
1091	continue
1092	if not table(matric_no = matric_no):
1093	student['Error'] = "Not imported yet"
1094	no_import.append( format_error % student)
1095	continue
1096	student_id = None
1097	app = None
1098	per = None
1099	if st_cat(matric_no = matric_no):
1100	student_id = st_cat(matric_no = matric_no)[0].id
1101	student_obj = getattr(students_folder,student_id,None)
1102	if student_obj:
1103	app = getattr(student_obj,'application',None)
1104	if app is not None:
1105	app_doc = app.getContent()
1106	per = getattr(student_obj,'personal',None)
1107	if per is not None:
1108	per_doc = per.getContent()
1109	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
1110	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
1111	#import pdb;pdb.set_trace()
1112	if not entry_mode:
1113	student['Error'] = "'Mode of Entry' empty"
1114	no_import.append( format_error % student)
1115	continue
1116	try:
1117	table.modifyRecord(matric_no = matric_no,
1118	Mode_of_Entry = entry_mode,
1119	Permanent_Address = perm_address)
1120	except KeyError:
1121	student['Error'] = "Not found in returning_import"
1122	no_import.append( format_error % student)
1123	continue
1124	if student_id is not None:
1125	try:
1126	st_cat.modifyRecord(id = student_id,
1127	entry_mode=entry_mode)
1128	except KeyError:
1129	student['Error'] = "Not found in students_catalog"
1130	no_import.append( format_error % student)
1131	continue
1132	if app is not None:
1133	da = {}
1134	da['entry_mode'] = entry_mode
1135	app_doc.edit(mapping=da)
1136	if per is not None:
1137	dp = {}
1138	dp['perm_address'] = perm_address
1139	per_doc.edit(mapping=dp)
1140	tr_count += 1
1141	if tr_count > 1000:
1142	if len(no_import) > 0:
1143	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1144	'\n'.join(no_import) + '\n')
1145	no_import = []
1146	em = '%d transactions commited total %s\n' % (tr_count,total)
1147	transaction.commit()
1148	regs = []
1149	logger.info(em)
1150	total += tr_count
1151	tr_count = 0
1152	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1153	'\n'.join(no_import))
1154	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1155	###)
1156
1157	security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
1158	def updateReturningStudents(self):
1159	"""load and overwrite Returning Student Data from CSV values"""
1160	import transaction
1161	import random
1162	#from pdb import set_trace
1163	wftool = self.portal_workflow
1164	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1165	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1166	tr_count = 1
1167	total = 0
1168	#name = 'pume_results'
1169	name = 'Returning_update'
1170	table = self.returning_import
1171	no_import = []
1172	imported = []
1173	logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
1174	try:
1175	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1176	except:
1177	logger.error('Error reading %s.csv' % name)
1178	return
1179	l = self.portal_catalog({'meta_type': "Certificate"})
1180	certs = {}
1181	cert_docs = {}
1182	for f in l:
1183	certs[f.getId] = f.getObject().getContent()
1184	start = True
1185	res = table()
1186	regs = []
1187	if len(res) > 0:
1188	regs = [s.matric_no for s in res]
1189	for student in returning:
1190	if start:
1191	start = False
1192	logger.info('Start loading from %s.csv' % name)
1193	s = ','.join(['"%s"' % fn for fn in student.keys()])
1194	imported.append(s)
1195	no_import.append('%s,"Error"' % s)
1196	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
1197	format_error = format + ',"%(Error)s"'
1198	no_certificate = "no certificate %s" % format
1199	matric_no = student.get('matric_no').upper()
1200	student['matric_no'] = matric_no
1201	if matric_no == '':
1202	student['Error'] = "Empty matric_no"
1203	no_import.append( format_error % student)
1204	continue
1205	# if matric_no in regs or self.returning_import(matric_no = matric_no):
1206	# student['Error'] = "Duplicate"
1207	# no_import.append( format_error % student)
1208	# continue
1209	# cert_id = makeCertificateCode(student.get('Coursemajorcode'))
1210	# if cert_id not in certs.keys():
1211	# student['Error'] = "No Certificate %s" % cert_id
1212	# no_import.append( format_error % student)
1213	# continue
1214	try:
1215	table.modifyRecord(**student)
1216	except KeyError:
1217	#import pdb;pdb.set_trace()
1218	student['Error'] = "no Student found to update"
1219	no_import.append( format_error % student)
1220	continue
1221	#s = self.students_catalog(matric_no=matric_no)
1222	#if s:
1223	# level = "%s" % (int(student.get('Level')) + 100)
1224	# self.students_catalog.modifyRecord(id = s[0].id,
1225	# level=level)
1226
1227	regs.append(student.get('matric_no'))
1228	imported.append(format % student)
1229	tr_count += 1
1230	if tr_count > 1000:
1231	if len(no_import) > 0:
1232	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1233	'\n'.join(no_import) + '\n')
1234	no_import = []
1235	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1236	'\n'.join(no_import) + "\n")
1237	imported = []
1238	em = '%d transactions commited total %s\n' % (tr_count,total)
1239	transaction.commit()
1240	regs = []
1241	logger.info(em)
1242	total += tr_count
1243	tr_count = 0
1244	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1245	'\n'.join(imported))
1246	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1247	'\n'.join(no_import))
1248	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1249	###)
1250
1251	security.declareProtected(ModifyPortalContent,"importResults")###(
1252	def importResults(self):
1253	"""load Returning Students Results from CSV"""
1254	import transaction
1255	import random
1256	#from pdb import set_trace
1257	wftool = self.portal_workflow
1258	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1259	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1260	tr_count = 1
1261	total = 0
1262	#name = 'pume_results'
1263	name = 'Results'
1264	table = self.results_import
1265	no_import = []
1266	imported = []
1267	logger = logging.getLogger('Students.StudentsFolder.importResults')
1268	try:
1269	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1270	except:
1271	logger.error('Error reading %s.csv' % name)
1272	return
1273	l = self.portal_catalog({'meta_type': "Course"})
1274	courses = [f.getId for f in l]
1275	start = True
1276	res = table()
1277	regs = []
1278	if len(res) > 0:
1279	regs = [s.key for s in res]
1280	no_course = []
1281	no_course_list = []
1282	course_count = 0
1283	for result in results:
1284	if start:
1285	start = False
1286	logger.info('Start loading from %s.csv' % name)
1287	s = ','.join(['"%s"' % fn for fn in result.keys()])
1288	imported.append(s)
1289	no_import.append('%s,"Error"' % s)
1290	format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
1291	format_error = format + ',"%(Error)s"'
1292	no_certificate = "no certificate %s" % format
1293	course_id = result.get('CosCode')
1294	if not course_id:
1295	course_id = 'N/A'
1296	result['CosCode'] = course_id
1297	matric_no = result.get('matric_no').upper()
1298	result['matric_no'] = matric_no
1299	key = matric_no+course_id
1300	if matric_no == '':
1301	result['Error'] = "Empty matric_no"
1302	no_import.append( format_error % result)
1303	continue
1304	if key in regs or self.results_import(key = key):
1305	result['Error'] = "Duplicate"
1306	no_import.append( format_error % result)
1307	continue
1308	if course_id not in courses:
1309	if course_id not in no_course:
1310	course_count +=1
1311	no_course.append(course_id)
1312	no_course_list.append('"%s"' % course_id)
1313	#result['Error'] = "No Course"
1314	#logger.info(format_error % result)
1315	regs.append(key)
1316	imported.append(format % result)
1317	tr_count += 1
1318	if tr_count > 1000:
1319	if len(no_import) > 0:
1320	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1321	'\n'.join(no_import)+'\n')
1322	no_import = []
1323	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1324	'\n'.join(imported) + '\n')
1325	imported = []
1326	if no_course_list:
1327	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1328	'\n'.join(no_course_list) + '\n')
1329	no_course_list = []
1330	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1331	transaction.commit()
1332	logger.info(em)
1333	regs = []
1334	total += tr_count
1335	tr_count = 0
1336	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1337	'\n'.join(imported))
1338	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1339	'\n'.join(no_import))
1340	if no_course_list:
1341	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1342	'\n'.join(no_course_list))
1343	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1344	logger.info(em)
1345	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1346	###)
1347
1348	security.declareProtected(ModifyPortalContent,"importPreviousSessionStudents")###(
1349	def importPreviousSessionStudents(self):
1350	"""load and create previous session students from CSV"""
1351	import transaction
1352	import random
1353	wftool = self.portal_workflow
1354	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1355	students_folder = self.portal_url.getPortalObject().campus.students
1356	tr_count = 1
1357	total = 0
1358	#name = 'pume_results'
1359	name = 'Previous'
1360	keys = self.portal_schemas.import_student.keys()
1361	keys += self.portal_schemas.import_student_level_data.keys()
1362	not_imported = []
1363	imported = []
1364	certificates = {}
1365	logger = logging.getLogger('Students.StudentsFolder.importPreviousSessionStudents')
1366	try:
1367	records = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1368	except:
1369	logger.error('Error reading %s.csv' % name)
1370	return
1371	start = True
1372	for record in records:
1373	if start:
1374	start = False
1375	logger.info('Start loading from %s.csv' % name)
1376	false_keys = [k for k in record.keys() if k not in keys]
1377	right_keys = [k for k in record.keys() if k in keys]
1378	if false_keys:
1379	logger.info('Fields %s not in schema' % false_keys)
1380	s = ','.join(['"%s"' % k for k in right_keys])
1381	imported.append(s)
1382	not_imported.append('%s,"error"' % s)
1383	format = ','.join(['"%%(%s)s"' % k for k in right_keys])
1384	format_error = format + ',"%(error)s"'
1385	study_course = record.get('study_course')
1386	matric_no = record.get('matric_no')
1387	student_res = self.students_catalog(matric_no = matric_no)
1388	if student_res:
1389	record['error'] = "Student exists"
1390	not_imported.append(format_error % record)
1391	continue
1392	if study_course not in certificates.keys():
1393	cert_res = self.portal_catalog(portal_type='Certificate',
1394	id = study_course)
1395	if not cert_res:
1396	record['error'] = "No such studycourse"
1397	not_imported.append(format_error % record)
1398	continue
1399	certificates[cert_res[0].id] = cert_res[0]
1400	sid = self.generateStudentId('x',students_folder)
1401	students_folder.invokeFactory('Student', sid)
1402	#from pdb import set_trace;set_trace()
1403	record['student_id'] = sid
1404	student = getattr(self,sid)
1405	student.manage_setLocalRoles(sid, ['Owner',])
1406	student.invokeFactory('StudentApplication','application')
1407	app = student.application
1408	app_doc = app.getContent()
1409	dict = {'Title': 'Application Data'}
1410	dict["jamb_lastname"] = "%(firstname)s %(lastname)s %(middlename)s" % record
1411	r2d = [
1412	('entry_mode','entry_mode'),
1413	('sex','jamb_sex'),
1414	('jamb_score','jamb_score'),
1415	('jamb_reg_no','jamb_reg_no'),
1416	]
1417	for r,d in r2d:
1418	dict[d] = record[r]
1419	app_doc.edit(mapping=dict)
1420	app.manage_setLocalRoles(sid, ['Owner',])
1421	wftool.doActionFor(app,'close')
1422	record['sex'] = record['sex'] == 'F'
1423	student.invokeFactory('StudentPersonal','personal')
1424	dict = {}
1425	r2d = [('firstname','firstname'),
1426	('middlename','middlename'),
1427	('lastname','lastname'),
1428	('sex','sex'),
1429	('email','email'),
1430	('phone','phone'),
1431	('address','perm_address'),
1432	]
1433	for r,d in r2d:
1434	dict[d] = record[r]
1435	per = student.personal
1436	per_doc = per.getContent()
1437	per_doc.edit(mapping = dict)
1438	per.manage_setLocalRoles(sid, ['Owner',])
1439	#
1440	# Clearance
1441	#
1442	student.invokeFactory('StudentClearance','clearance')
1443	#wftool.doActionFor(student.clearance,'open')
1444	clearance = getattr(student,'clearance')
1445	dict = {'Title': 'Clearance/Eligibility Record'}
1446	clearance.getContent().edit(mapping = dict)
1447	student.clearance.manage_setLocalRoles(sid, ['Owner',])
1448	#
1449	# Study Course
1450	#
1451	student.invokeFactory('StudentStudyCourse','study_course')
1452	study_course = student.study_course
1453	dict = {}
1454	r2d = [('session','current_session'),
1455	('level','current_level'),
1456	('verdict','current_verdict'),
1457	('study_course','study_course'),
1458	]
1459	for r,d in r2d:
1460	dict[d] = record[r]
1461	study_course.getContent().edit(mapping=dict)
1462	#
1463	# Study Level
1464	#
1465	level = record['level']
1466	study_course.invokeFactory('StudentStudyLevel',level)
1467	study_level = getattr(study_course,level)
1468	dict = {}
1469	r2d = [('session','session'),
1470	('level','code'),
1471	('verdict','verdict'),
1472	]
1473	for r,d in r2d:
1474	dict[d] = record[r]
1475	study_level.getContent().edit(mapping=dict)
1476	wftool.doActionFor(student,'return')
1477	imported.append(format % record)
1478	tr_count += 1
1479	record['tr_count'] = tr_count
1480	record['total'] = total
1481	logger.info('%(total)s+%(tr_count)s: Creating Student %(student_id)s %(matric_no)s %(jamb_reg_no)s' % record)
1482	if tr_count > 1000:
1483	if len(not_imported) > 0:
1484	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1485	'\n'.join(not_imported)+'\n')
1486	not_imported = []
1487	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1488	'\n'.join(imported) + '\n')
1489	imported = []
1490	em = '%d transactions commited total %s' % (tr_count,total)
1491	transaction.commit()
1492	logger.info(em)
1493	regs = []
1494	total += tr_count
1495	tr_count = 0
1496	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1497	'\n'.join(imported))
1498	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1499	'\n'.join(not_imported))
1500	em = '%d transactions commited total %d' % (tr_count,total)
1501	logger.info(em)
1502	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1503	###)
1504
1505	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
1506	def updateStudyCourse(self):
1507	"""update StudyCourse from CSV values"""
1508	import transaction
1509	import random
1510	from pdb import set_trace
1511	wftool = self.portal_workflow
1512	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1513	csv_d = {'jamb_reg_no': "RegNumber",
1514	'jamb_lastname': "Name",
1515	'session': "Session",
1516	'pume_tot_score': "PUME SCORE",
1517	'jamb_score': "JambScore",
1518	'jamb_sex': "Sex",
1519	'jamb_state': "State",
1520	## 'jamb_first_cos': "AdminCourse",
1521	'faculty': "AdminFaculty",
1522	'course_code': "AdmitCoscode",
1523	'stud_status':"AdmitStatus",
1524	'department': "AdmitDept",
1525	'jamb_lga': "LGA",
1526	'app_email': "email",
1527	'app_mobile': "PhoneNumbers",
1528	}
1529	csv_fields = [f[1] for f in csv_d.items()]
1530	tr_count = 0
1531	total = 0
1532	#name = 'pume_results'
1533	name = 'StudyCourseChange'
1534	no_import = []
1535	s = ','.join(['"%s"' % fn for fn in csv_fields])
1536	no_import.append('"Error",%s' % s)
1537	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1538	no_certificate = "no certificate %s" % format
1539	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1540	'\n'.join(no_import))
1541	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
1542	logger.info('Start loading from %s.csv' % name)
1543	l = self.portal_catalog({'meta_type': "Certificate"})
1544	try:
1545	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1546	except:
1547	logger.error('Error reading %s.csv' % name)
1548	return
1549	for jamb in result:
1550	jamb['Error'] = "Processing "
1551	logger.info(format % jamb)
1552	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1553	res = self.portal_catalog({'portal_type': "StudentApplication",
1554	'SearchableText': jamb_reg_no })
1555	if not res:
1556	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
1557	logger.info(em)
1558	jamb['Error'] = "Student does not exist"
1559	no_import.append(format % jamb)
1560	continue
1561	sid = res[0].getPath().split('/')[-2]
1562	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
1563	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
1564	if not res:
1565	em = 'No Certificate with ID %s \n' % cert_id
1566	logger.info(em)
1567	jamb['Error'] = "No Certificate %s" % cert_id
1568	no_import.append( format % jamb)
1569	continue
1570	cert_brain = res[0]
1571	catalog_entry = {}
1572	student = getattr(self,sid)
1573	#
1574	# Study Course
1575	#
1576	study_course = student.study_course
1577	dsc = {}
1578	cert_pl = cert_brain.getPath().split('/')
1579	catalog_entry['id'] = sid
1580	catalog_entry['faculty'] = cert_pl[-4]
1581	catalog_entry['department'] = cert_pl[-3]
1582	catalog_entry['course'] = cert_id
1583	dsc['study_course'] = cert_id
1584	study_course.getContent().edit(mapping=dsc)
1585	self.students_catalog.modifyRecord(**catalog_entry)
1586	if tr_count > 10:
1587	if len(no_import) > 1:
1588	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
1589	'\n'.join(no_import))
1590	no_import = []
1591	em = '%d transactions commited\n' % tr_count
1592	transaction.commit()
1593	logger.info(em)
1594	total += tr_count
1595	tr_count = 0
1596	tr_count += 1
1597	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1598	###)
1599
1600	security.declareProtected(View,"fixOwnership") ###(
1601	def fixOwnership(self):
1602	"""fix Ownership"""
1603	for s in self.portal_catalog(meta_type = 'Student'):
1604	student = s.getObject()
1605	sid = s.getId
1606	import pdb;pdb.set_trace()
1607	student.application.manage_setLocalRoles(sid, ['Owner',])
1608	student.personal.manage_setLocalRoles(sid, ['Owner',])
1609	###)
1610
1611	security.declareProtected(View,"Title") ###(
1612	def Title(self):
1613	"""compose title"""
1614	return "Student Section"
1615	###)
1616
1617	def generateStudentId(self,letter,students = None): ###(
1618	import random
1619	r = random
1620	if students is None:
1621	students = self.portal_url.getPortalObject().campus.students
1622	if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
1623	letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
1624	sid = "%c%d" % (letter,r.randint(99999,1000000))
1625	while hasattr(students, sid):
1626	sid = "%c%d" % (letter,r.randint(99999,1000000))
1627	return sid
1628	#return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
1629	###)
1630
1631	InitializeClass(StudentsFolder)
1632
1633	def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
1634	"""Add a Student."""
1635	ob = StudentsFolder(id, **kw)
1636	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1637	###)
1638
1639	###)
1640
1641	class Student(CPSDocument): ###(
1642	"""
1643	WAeUP Student container for the various student data
1644	"""
1645	meta_type = 'Student'
1646	portal_type = meta_type
1647	security = ClassSecurityInfo()
1648
1649	security.declareProtected(View,"Title")
1650	def Title(self):
1651	"""compose title"""
1652	reg_nr = self.getId()[1:]
1653	data = getattr(self,'personal',None)
1654	if data:
1655	content = data.getContent()
1656	return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
1657	data = getattr(self,'application',None)
1658	if data:
1659	content = data.getContent()
1660	return "%s" % (content.jamb_lastname)
1661	return self.title
1662
1663	security.declarePrivate('makeStudentMember') ###(
1664	def makeStudentMember(self,sid,password='uNsEt'):
1665	"""make the student a member"""
1666	membership = self.portal_membership
1667	membership.addMember(sid,
1668	password ,
1669	roles=('Member',
1670	'Student',
1671	),
1672	domains='',
1673	properties = {'memberareaCreationFlag': False,
1674	'homeless': True},)
1675	member = membership.getMemberById(sid)
1676	self.portal_registration.afterAdd(member, sid, password, None)
1677	self.manage_setLocalRoles(sid, ['Owner',])
1678
1679	###)
1680
1681	security.declareProtected(View,'createSubObjects') ###(
1682	def createSubObjects(self):
1683	"""make the student a member"""
1684	dp = {'Title': 'Personal Data'}
1685	app_doc = self.application.getContent()
1686	names = app_doc.jamb_lastname.split()
1687	if len(names) == 3:
1688	dp['firstname'] = names[0].capitalize()
1689	dp['middlename'] = names[1].capitalize()
1690	dp['lastname'] = names[2].capitalize()
1691	elif len(names) == 2:
1692	dp['firstname'] = names[0].capitalize()
1693	dp['lastname'] = names[1].capitalize()
1694	else:
1695	dp['lastname'] = app_doc.jamb_lastname
1696	dp['sex'] = app_doc.jamb_sex == 'F'
1697	dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1698	proxy = self.aq_parent
1699	proxy.invokeFactory('StudentPersonal','personal')
1700	per = proxy.personal
1701	per_doc = per.getContent()
1702	per_doc.edit(mapping = dp)
1703	per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1704	#self.portal_workflow.doActionFor(per,'open',dest_container=per)
1705
1706	###)
1707
1708	InitializeClass(Student)
1709
1710	def addStudent(container, id, REQUEST=None, **kw):
1711	"""Add a Student."""
1712	ob = Student(id, **kw)
1713	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1714
1715	###)
1716
1717	class StudentAccommodation(CPSDocument): ###(
1718	"""
1719	WAeUP Student container for the various student data
1720	"""
1721	meta_type = 'StudentAccommodation'
1722	portal_type = meta_type
1723	security = ClassSecurityInfo()
1724
1725	security.declareProtected(View,"Title")
1726	def Title(self):
1727	"""compose title"""
1728	content = self.getContent()
1729	#return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1730	return "Accommodation Data for Session %s" % content.session
1731
1732
1733	InitializeClass(StudentAccommodation)
1734
1735	def addStudentAccommodation(container, id, REQUEST=None, **kw):
1736	"""Add a Students personal data."""
1737	ob = StudentAccommodation(id, **kw)
1738	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1739
1740	###)
1741
1742	class StudentPersonal(CPSDocument): ###(
1743	"""
1744	WAeUP Student container for the various student data
1745	"""
1746	meta_type = 'StudentPersonal'
1747	portal_type = meta_type
1748	security = ClassSecurityInfo()
1749
1750	security.declareProtected(View,"Title")
1751	def Title(self):
1752	"""compose title"""
1753	content = self.getContent()
1754	#return "Personal Data for %s %s" % (content.firstname,content.lastname)
1755	return "Personal Data"
1756
1757
1758	InitializeClass(StudentPersonal)
1759
1760	def addStudentPersonal(container, id, REQUEST=None, **kw):
1761	"""Add a Students personal data."""
1762	ob = StudentPersonal(id, **kw)
1763	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1764
1765	###)
1766
1767	class StudentClearance(CPSDocument): ###(
1768	"""
1769	WAeUP Student container for the various student data
1770	"""
1771	meta_type = 'StudentClearance'
1772	portal_type = meta_type
1773	security = ClassSecurityInfo()
1774
1775	security.declareProtected(View,"Title")
1776	def Title(self):
1777	"""compose title"""
1778	content = self.getContent()
1779	#return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1780	return "Clearance/Eligibility Record"
1781
1782
1783	InitializeClass(StudentClearance)
1784
1785	def addStudentClearance(container, id, REQUEST=None, **kw):
1786	"""Add a Students personal data."""
1787	ob = StudentClearance(id, **kw)
1788	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1789
1790	###)
1791
1792	class StudentStudyLevel(CPSDocument): ###(
1793	"""
1794	WAeUP Student container for the various student data
1795	"""
1796	meta_type = 'StudentStudyLevel'
1797	portal_type = meta_type
1798	security = ClassSecurityInfo()
1799
1800	security.declareProtected(View,"Title")
1801	def Title(self):
1802	"""compose title"""
1803	return "Level %s" % self.aq_parent.getId()
1804
1805	def create_course_results(self,cert_id,current_level): ###(
1806	"create all courses in a level"
1807	aq_portal = self.portal_catalog.evalAdvancedQuery
1808	res = self.portal_catalog(portal_type="Certificate", id = cert_id)
1809	l = []
1810	import transaction
1811	if res:
1812	cert = res[0]
1813	path = cert.getPath()
1814	query = Eq("path","%s/%s" % (path,current_level)) &\
1815	Eq('portal_type','CertificateCourse')
1816	courses = aq_portal(query)
1817	#from pdb import set_trace;set_trace()
1818	self_proxy = self.aq_parent
1819	for c in courses:
1820	d = self.getCourseInfo(c.getId)
1821	cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
1822	course_result = getattr(self_proxy,cr_id)
1823	self.portal_workflow.doActionFor(course_result,'open')
1824	d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
1825	course_result.getContent().edit(mapping=d)
1826	transaction.commit()
1827	###)
1828
1829	InitializeClass(StudentStudyLevel)
1830
1831	def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1832	"""Add a Students personal data."""
1833	ob = StudentStudyLevel(id, **kw)
1834	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1835
1836	###)
1837
1838	class StudentStudyCourse(CPSDocument): ###(
1839	"""
1840	WAeUP Student container for the various student data
1841	"""
1842	meta_type = 'StudentStudyCourse'
1843	portal_type = meta_type
1844	security = ClassSecurityInfo()
1845
1846	security.declareProtected(View,"Title")
1847	def Title(self):
1848	"""compose title"""
1849	content = self.getContent()
1850	return "Study Course"
1851
1852
1853	InitializeClass(StudentStudyCourse)
1854
1855	def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1856	"""Add a Students personal data."""
1857	ob = StudentStudyCourse(id, **kw)
1858	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1859
1860	###)
1861
1862	class StudentApplication(CPSDocument): ###(
1863	"""
1864	WAeUP Student container for the various student data
1865	"""
1866	meta_type = 'StudentApplication'
1867	portal_type = meta_type
1868	security = ClassSecurityInfo()
1869
1870	security.declareProtected(View,"Title")
1871	def Title(self):
1872	"""compose title"""
1873	return "Application Data"
1874
1875
1876	InitializeClass(StudentApplication)
1877
1878	def addStudentApplication(container, id, REQUEST=None, **kw):
1879	"""Add a Students eligibility data."""
1880	ob = StudentApplication(id, **kw)
1881	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1882	###)
1883
1884	class StudentPume(CPSDocument): ###(
1885	"""
1886	WAeUP Student container for the various student data
1887	"""
1888	meta_type = 'StudentPume'
1889	portal_type = meta_type
1890	security = ClassSecurityInfo()
1891
1892	security.declareProtected(View,"Title")
1893	def Title(self):
1894	"""compose title"""
1895	return "PUME Results"
1896
1897
1898	InitializeClass(StudentPume)
1899
1900	def addStudentPume(container, id, REQUEST=None, **kw):
1901	"""Add a Students PUME data."""
1902	ob = StudentPume(id, **kw)
1903	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1904	###)
1905
1906	##class StudentSemester(CPSDocument): ###(
1907	## """
1908	## WAeUP StudentSemester containing the courses and students
1909	## """
1910	## meta_type = 'StudentSemester'
1911	## portal_type = meta_type
1912	## security = ClassSecurityInfo()
1913	##
1914	##InitializeClass(StudentSemester)
1915	##
1916	##def addStudentSemester(container, id, REQUEST=None, **kw):
1917	## """Add a StudentSemester."""
1918	## ob = StudentSemester(id, **kw)
1919	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1920	##
1921	#####)
1922
1923	##class Semester(CPSDocument): ###(
1924	## """
1925	## WAeUP Semester containing the courses and students
1926	## """
1927	## meta_type = 'Semester'
1928	## portal_type = meta_type
1929	## security = ClassSecurityInfo()
1930	##
1931	##InitializeClass(Semester)
1932	##
1933	##def addSemester(container, id, REQUEST=None, **kw):
1934	## """Add a Semester."""
1935	## ob = Semester(id, **kw)
1936	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1937	##
1938	#####)
1939
1940	class StudentCourseResult(CPSDocument): ###(
1941	"""
1942	WAeUP StudentCourseResult
1943	"""
1944	meta_type = 'StudentCourseResult'
1945	portal_type = meta_type
1946	security = ClassSecurityInfo()
1947
1948	def getCourseEntry(self,cid):
1949	res = self.portal_catalog({'meta_type': "Course",
1950	'id': cid})
1951	if res:
1952	return res[-1]
1953	else:
1954	return None
1955
1956	security.declareProtected(View,"Title")
1957	def Title(self):
1958	"""compose title"""
1959	cid = self.aq_parent.getId()
1960	ce = self.getCourseEntry(cid)
1961	if ce:
1962	return "%s" % ce.Title
1963	return "No course with id %s" % cid
1964
1965	InitializeClass(StudentCourseResult)
1966
1967	def addStudentCourseResult(container, id, REQUEST=None, **kw):
1968	"""Add a StudentCourseResult."""
1969	ob = StudentCourseResult(id, **kw)
1970	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1971	###)
1972
1973	# Backward Compatibility StudyLevel
1974
1975	from Products.WAeUP_SRP.Academics import StudyLevel
1976
1977	from Products.WAeUP_SRP.Academics import addStudyLevel
1978

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

Download in other formats: