Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1711

Last change on this file since 1711 was 1711, checked in by Henrik Bettermann, 18 years ago
using PIL for passport conversion
Property svn:keywords set to `Id`
File size: 78.9 KB

Line
1	#-- mode: python; mode: fold --
2	# $Id: Students.py 1711 2007-04-25 19:22:21Z 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,"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	#import pdb;pdb.set_trace()
431	picture ="%s/import/pictures/%s.jpg" % (i_home,picture_id)
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,"createStudents")###(
541	def createStudents(self):
542	"""load 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	entry_levels = {'ume_ft':'100',
549	'de_ft': '200',
550	'ug_pt': '100',
551	'de_pt': '200',
552	'pg_ft': '700',
553	'pg_pt': '700',
554	'dp_pt': '100',
555	'dp_ft': '100',
556	}
557	csv_d = {'jamb_reg_no': "reg_no",
558	'entry_mode': 'entry_mode',
559	'jamb_firstname': "firstname",
560	'jamb_middlename': "middlename",
561	'jamb_lastname': "lastname",
562	'jamb_sex': "sex",
563	'jamb_state': "state",
564	'birthday': "date_of_birth",
565	'app_email': "email",
566	'study_course': "study_course",
567	'perm_address': "address",
568	}
569	csv_fields = [f[1] for f in csv_d.items()]
570	tr_count = 0
571	total = 0
572	#name = 'pume_results'
573	name = 'Admitted'
574	no_import = []
575	s = ','.join(['"%s"' % fn for fn in csv_fields])
576	no_import.append('"Error",%s' % s)
577	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
578	no_certificate = "no certificate %s" % format
579	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
580	logger = logging.getLogger('Students.StudentsFolder.createNewStudents')
581	logger.info('Start loading from %s.csv' % name)
582	certs = {}
583	try:
584	results = 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 result in results:
589	#result['Error'] = "Processing "
590	#logger.info(format % result)
591	jamb_reg_no = result.get(csv_d['jamb_reg_no'])
592	res = self.students_catalog(jamb_reg_no = jamb_reg_no)
593	if res:
594	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
595	logger.info(em)
596	result['Error'] = "Student exists"
597	no_import.append(format % result)
598	continue
599	cert_id = makeCertificateCode(result.get(csv_d['study_course']))
600	if cert_id not in certs.keys():
601	res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
602	if not res:
603	em = 'No Certificate with ID %s \n' % cert_id
604	logger.info(em)
605	result['Error'] = "No Certificate %s" % cert_id
606	no_import.append( format % result)
607	continue
608	cert = res[0]
609	cert_path = cert.getPath().split('/')
610	certificate = certs[cert_id] = {'faculty': cert_path[-4],
611	'department': cert_path[-3]}
612	cert_doc = certs[cert_id]
613	catalog_entry = {}
614	catalog_entry['jamb_reg_no'] = jamb_reg_no
615	firstname = result.get(csv_d['jamb_firstname'])
616	middlename = result.get(csv_d['jamb_middlename'])
617	lastname = result.get(csv_d['jamb_lastname'])
618	sid = self.generateStudentId('x')
619	students_folder.invokeFactory('Student', sid)
620	catalog_entry['id'] = sid
621	tr_count += 1
622	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
623	student = getattr(self,sid)
624	student.manage_setLocalRoles(sid, ['Owner',])
625	student.invokeFactory('StudentApplication','application')
626	da = {'Title': 'Application Data'}
627	da["jamb_firstname"] = firstname
628	da["jamb_middlename"] = middlename
629	da["jamb_lastname"] = lastname
630	catalog_entry['entry_session'] = da["entry_session"] = self.getSessionId()[-2:]
631	catalog_entry['sex'] = sex = result.get(csv_d['jamb_sex']).startswith('F')
632	da_fields = ('jamb_reg_no',
633	'jamb_sex',
634	'jamb_state',
635	'entry_mode',
636	'app_email',
637	)
638	for f in da_fields:
639	da[f] = result.get(csv_d[f])
640	catalog_entry['email'] = da['app_email']
641	catalog_entry['entry_mode'] = da['entry_mode']
642	catalog_entry['entry_level'] = da["entry_level"] = entry_levels.get(da['entry_mode'],'100')
643	app = student.application
644	app_doc = app.getContent()
645	app.getContent().edit(mapping=da)
646	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
647	app.manage_setLocalRoles(sid, ['Owner',])
648
649	picture_id = da['jamb_reg_no'].replace('/','_')
650	file = None
651	for ext in ('jpg','JPG'):
652	picture ="%s/import/pictures_admitted_latest/%s.%s" % (i_home,picture_id,ext)
653	if os.path.exists(picture):
654	file = open(picture)
655	break
656	if file is not None:
657	img = PIL.Image.open(file)
658	img.thumbnail((150,200),
659	resample=PIL.Image.ANTIALIAS)
660	# We now need a buffer to write to. It can't be the same
661	# as the inbuffer as the PNG writer will write over itself.
662	outfile = StringIO()
663	img.save(outfile, format=img.format)
664	#outfile = file.read()
665	app_doc.manage_addFile('passport',
666	file=outfile,
667	title="%s.jpg" % jamb_reg_no)
668	#wftool.doActionFor(app,'close')
669	dp = {}
670	dp['firstname'] = firstname
671	dp['middlename'] = middlename
672	dp['lastname'] = lastname
673	dp['email'] = da['app_email']
674	dp['sex'] = sex
675	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
676	student.invokeFactory('StudentPersonal','personal')
677	per = student.personal
678	per_doc = per.getContent()
679	per_doc.edit(mapping = dp)
680	per.manage_setLocalRoles(sid, ['Owner',])
681	wftool.doActionFor(student,'pume_pass')
682	wftool.doActionFor(student,'admit')
683	#
684	# Clearance
685	#
686	student.invokeFactory('StudentClearance','clearance')
687	#wftool.doActionFor(student.clearance,'open')
688	clearance = student.clearance
689	dc = {'Title': 'Clearance/Eligibility Record'}
690	clearance = student.clearance
691	date_str = result.get(csv_d['birthday'])
692	try:
693	date = DateTime.DateTime(date_str)
694	except:
695	#import pdb;pdb.set_trace()
696	date = None
697	dc['birthday'] = date
698	clearance.getContent().edit(mapping=dc)
699	clearance.manage_setLocalRoles(sid, ['Owner',])
700	#
701	# Study Course
702	#
703	student.invokeFactory('StudentStudyCourse','study_course')
704	study_course = student.study_course
705	dsc = {}
706	#catalog_entry['level'] = getattr(cert_doc,'start_level')
707	catalog_entry['session'] = dsc['current_session'] = da['entry_session']
708	catalog_entry['level'] = dsc['current_level'] = entry_levels.get(da['entry_mode'],'100')
709	catalog_entry['mode'] = dsc['current_mode'] = da['entry_mode']
710	catalog_entry['course'] = dsc['study_course'] = cert_id
711	catalog_entry['faculty'] = certificate['faculty']
712	catalog_entry['department'] = certificate['department']
713	catalog_entry['verdict'] = dsc['current_verdict'] = 'N/A'
714	catalog_entry['review_state'] = self.portal_workflow.getInfoFor(student,'review_state',None)
715	study_course.getContent().edit(mapping=dsc)
716	#import pdb;pdb.set_trace()
717	self.students_catalog.addRecord(**catalog_entry)
718	if tr_count > 10:
719	if len(no_import) > 0:
720	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
721	'\n'.join(no_import) + "\n")
722	no_import = []
723	em = '%d transactions commited\n' % tr_count
724	transaction.commit()
725	logger.info(em)
726	total += tr_count
727	tr_count = 0
728	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
729	'\n'.join(no_import))
730	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
731	###)
732
733	security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
734	def importReturningStudents(self):
735	"""load Returning Studentdata from CSV values"""
736	import transaction
737	import random
738	#from pdb import set_trace
739	wftool = self.portal_workflow
740	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
741	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
742	#students_folder = self.portal_url().getPortalObject().campus.students
743	tr_count = 1
744	total = 0
745	#name = 'pume_results'
746	name = 'Returning'
747	table = self.returning_import
748	no_import = []
749	imported = []
750	logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
751	try:
752	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
753	except:
754	logger.error('Error reading %s.csv' % name)
755	return
756	l = self.portal_catalog({'meta_type': "Certificate"})
757	certs = {}
758	cert_docs = {}
759	for f in l:
760	certs[f.getId] = f.getObject().getContent()
761	start = True
762	res = table()
763	regs = []
764	if len(res) > 0:
765	regs = [s.matric_no for s in res]
766	#import pdb;pdb.set_trace()
767	for student in returning:
768	if start:
769	start = False
770	logger.info('Start loading from %s.csv' % name)
771	s = ','.join(['"%s"' % fn for fn in student.keys()])
772	imported.append(s)
773	no_import.append('%s,"Error"' % s)
774	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
775	format_error = format + ',"%(Error)s"'
776	no_certificate = "no certificate %s" % format
777	student['matric_no'] = matric_no = student.get('matric_no').upper()
778	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
779	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
780	if matric_no == '':
781	student['Error'] = "Empty matric_no"
782	no_import.append( format_error % student)
783	continue
784	if matric_no in regs or self.returning_import(matric_no = matric_no):
785	student['Error'] = "Duplicate"
786	no_import.append( format_error % student)
787	continue
788	cert_id = makeCertificateCode(student.get('Coursemajorcode'))
789	if cert_id not in certs.keys():
790	student['Error'] = "No Certificate %s" % cert_id
791	no_import.append( format_error % student)
792	continue
793	try:
794	table.addRecord(**student)
795	except ValueError:
796	student['Error'] = "Duplicate"
797	no_import.append( format_error % student)
798	continue
799	regs.append(student.get('matric_no'))
800	imported.append(format % student)
801	tr_count += 1
802	if tr_count > 1000:
803	if len(no_import) > 0:
804	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
805	'\n'.join(no_import) + '\n')
806	no_import = []
807	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
808	'\n'.join(no_import) + "\n")
809	imported = []
810	em = '%d transactions commited total %s\n' % (tr_count,total)
811	transaction.commit()
812	regs = []
813	logger.info(em)
814	total += tr_count
815	tr_count = 0
816	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
817	'\n'.join(imported))
818	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
819	'\n'.join(no_import))
820	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
821	###)
822
823	security.declareProtected(ModifyPortalContent,"fixVerdicts")###(
824	def fixVerdicts(self,csv_file=None):
825	"""fix wrong uploaded verdicts"""
826	import transaction
827	import random
828	wftool = self.portal_workflow
829	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
830	students_folder = self.portal_url.getPortalObject().campus.students
831	tr_count = 1
832	total = 0
833	if csv_file is None:
834	name = 'Verdicts'
835	else:
836	name = csv_file
837	st_cat = self.students_catalog
838	no_import = []
839	verdicts_voc = self.portal_vocabularies.verdicts
840	rverdicts = {}
841	for k,v in verdicts_voc.items():
842	rverdicts[v.upper()] = k
843	rverdicts['STUDENT ON PROBATION'] = 'C'
844	logger = logging.getLogger('Students.StudentsFolder.fixVerdicts')
845	try:
846	verdicts = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
847	except:
848	logger.error('Error reading %s.csv' % name)
849	return
850	start = True
851	#import pdb;pdb.set_trace()
852	for verdict in verdicts:
853	if start:
854	start = False
855	logger.info('Start loading from %s.csv' % name)
856	s = ','.join(['"%s"' % fn for fn in verdict.keys()])
857	no_import.append('%s,"Error"' % s)
858	format = ','.join(['"%%(%s)s"' % fn for fn in verdict.keys()])
859	format_error = format + ',"%(Error)s"'
860	matric_no = verdict.get('MAT NO')
861	if not matric_no:
862	continue
863	matric_no = matric_no.upper()
864	if matric_no == '':
865	continue
866	verdict_code = rverdicts.get(verdict.get('CATEGORY'),None)
867	if verdict_code is None:
868	continue
869	sres = st_cat(matric_no = matric_no)
870	if sres:
871	student_id = sres[0].id
872	student_obj = getattr(students_folder,student_id,None)
873	if student_obj:
874	study_course = getattr(student_obj,'study_course',None)
875	if study_course is None:
876	verdict['Error'] = "Student did not yet log in"
877	no_import.append( format_error % verdict)
878	continue
879	st_cat.modifyRecord(id = student_id,
880	verdict=verdict_code)
881
882	dsc = {}
883	dsc['current_verdict'] = verdict_code
884	study_course.getContent().edit(mapping=dsc)
885	else:
886	verdict['Error'] = "Not found in students_catalog"
887	no_import.append( format_error % verdict)
888	continue
889	tr_count += 1
890	if tr_count > 1000:
891	if len(no_import) > 0:
892	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
893	'\n'.join(no_import) + '\n')
894	no_import = []
895	em = '%d transactions commited total %s\n' % (tr_count,total)
896	transaction.commit()
897	regs = []
898	logger.info(em)
899	total += tr_count
900	tr_count = 0
901	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
902	'\n'.join(no_import))
903	total += tr_count
904	em = '%d total transactions commited' % (total)
905	logger.info(em)
906	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
907	###)
908
909	security.declareProtected(ModifyPortalContent,"fixAllNames")###(
910	def fixAllNames(self):
911	"fix all students names"
912	import transaction
913	response = self.REQUEST.RESPONSE
914	logger = logging.getLogger('fixAllNames')
915	logger.info('Start')
916	students = self.portal_catalog(portal_type='Student')
917	count = 0
918	total = 0
919	for student in students:
920	scat_res = self.students_catalog(id = student.getId)
921	if not scat_res:
922	self.students_catalog.addRecord(id = student.getId)
923	scat_res = self.students_catalog(id = student.getId)
924	student_entry = scat_res[0]
925	old_new = self.fixName(student,student_entry)
926	count += 1
927	response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
928	if count > 2000:
929	transaction.commit()
930	logger.info("%d transactions commited" % count)
931	total += count
932	count = 0
933	###)
934
935	security.declareProtected(ModifyPortalContent,"fixName")###(
936	def fixName(self,student_brain, student_entry):
937	"fix the name of a student"
938	fix = "first"
939	if student_entry.get('name_fixed',None) == fix:
940	return "Name already fixed"
941	student_id = student_entry.id
942	new_student = student_entry.jamb_reg_no.startswith('6')
943	student_obj = student_brain.getObject()
944	personal = getattr(student_obj,'personal',None)
945	invalid = ''
946	if personal is None:
947	return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
948	per_doc = personal.getContent()
949	old_first = per_doc.firstname
950	old_middle = per_doc.middlename
951	old_last = per_doc.lastname
952	new_first = ''
953	new_middle = ''
954	new_last = ''
955	if new_student:
956	if not old_first and not old_middle and old_last:
957	new_names = [n.capitalize() for n in old_last.split()]
958	if len(new_names) > 1:
959	old_first = new_names[0]
960	old_last = new_names[-1]
961	old_middle = ' '.join(new_names[1:-1])
962	else:
963	old_last = new_names[0]
964	old_first = ''
965	old_middle = ''
966	if old_first:
967	new_first = old_first
968	if old_middle:
969	new_middle = old_middle
970	if old_last:
971	new_last = old_last
972	if old_first.find('<') != -1 or\
973	old_first.find('>') != -1 or\
974	old_middle.find('<') != -1 or\
975	old_middle.find('>') != -1 or\
976	old_last.find('<') != -1 or\
977	old_last.find('>') != -1:
978	invalid = "invalid characters"
979	else:
980	new_first = old_first
981	if new_first.strip() == '-':
982	new_first = ''
983	new_middle = old_middle
984	if new_middle.strip() == '-':
985	new_middle = ''
986	new_last = old_last
987	if new_last.strip() == '-':
988	new_last = ''
989	name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
990	if new_student:
991	text = "New"
992	else:
993	text = "Returning"
994	old_new = '"%s","%s","%s","%s"' % (invalid,text,
995	student_entry.name,
996	name)
997	if not invalid:
998	self.students_catalog.modifyRecord(id = student_id,
999	name_fixed = fix,
1000	name = name)
1001	per_doc.edit(mapping = {'firstname' : new_first,
1002	'middlename' : new_middle,
1003	'lastname' : new_last,
1004	})
1005	return old_new
1006	###)
1007
1008	security.declareProtected(ModifyPortalContent,"fixAllEntryModeForReturning")###(
1009	def fixAllEntryModeForReturning(self):
1010	"read all Returning*.csv"
1011	ipath = "%s/import/" % i_home
1012	names = os.listdir(ipath)
1013	for name in names:
1014	head,tail = os.path.splitext(name)
1015	if head.startswith('Returning')\
1016	and tail == '.csv'\
1017	and name.find('imported') < 0:
1018	self.fixEntryModeForReturning(csv_file=head)
1019	###)
1020
1021	security.declareProtected(ModifyPortalContent,"fixEntryModeForReturning")###(
1022	def fixEntryModeForReturning(self,csv_file=None):
1023	"""load Returning Studentdata from CSV values"""
1024	import transaction
1025	import random
1026	wftool = self.portal_workflow
1027	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1028	students_folder = self.portal_url.getPortalObject().campus.students
1029	tr_count = 1
1030	total = 0
1031	if csv_file is None:
1032	name = 'Returning'
1033	else:
1034	name = csv_file
1035	table = self.returning_import
1036	st_cat = self.students_catalog
1037	no_import = []
1038	logger = logging.getLogger('Students.StudentsFolder.fixEntryModeForReturning')
1039	try:
1040	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1041	except:
1042	logger.error('Error reading %s.csv' % name)
1043	return
1044	start = True
1045	for student in returning:
1046	if start:
1047	start = False
1048	logger.info('Start loading from %s.csv' % name)
1049	s = ','.join(['"%s"' % fn for fn in student.keys()])
1050	no_import.append('%s,"Error"' % s)
1051	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
1052	format_error = format + ',"%(Error)s"'
1053	matric_no = student.get('matric_no')
1054	if not matric_no:
1055	continue
1056	matric_no = matric_no.upper()
1057	student['matric_no'] = matric_no
1058	if matric_no == '':
1059	continue
1060	if not table(matric_no = matric_no):
1061	student['Error'] = "Not imported yet"
1062	no_import.append( format_error % student)
1063	continue
1064	student_id = None
1065	app = None
1066	per = None
1067	if st_cat(matric_no = matric_no):
1068	student_id = st_cat(matric_no = matric_no)[0].id
1069	student_obj = getattr(students_folder,student_id,None)
1070	if student_obj:
1071	app = getattr(student_obj,'application',None)
1072	if app is not None:
1073	app_doc = app.getContent()
1074	per = getattr(student_obj,'personal',None)
1075	if per is not None:
1076	per_doc = per.getContent()
1077	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
1078	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
1079	#import pdb;pdb.set_trace()
1080	if not entry_mode:
1081	student['Error'] = "'Mode of Entry' empty"
1082	no_import.append( format_error % student)
1083	continue
1084	try:
1085	table.modifyRecord(matric_no = matric_no,
1086	Mode_of_Entry = entry_mode,
1087	Permanent_Address = perm_address)
1088	except KeyError:
1089	student['Error'] = "Not found in returning_import"
1090	no_import.append( format_error % student)
1091	continue
1092	if student_id is not None:
1093	try:
1094	st_cat.modifyRecord(id = student_id,
1095	entry_mode=entry_mode)
1096	except KeyError:
1097	student['Error'] = "Not found in students_catalog"
1098	no_import.append( format_error % student)
1099	continue
1100	if app is not None:
1101	da = {}
1102	da['entry_mode'] = entry_mode
1103	app_doc.edit(mapping=da)
1104	if per is not None:
1105	dp = {}
1106	dp['perm_address'] = perm_address
1107	per_doc.edit(mapping=dp)
1108	tr_count += 1
1109	if tr_count > 1000:
1110	if len(no_import) > 0:
1111	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1112	'\n'.join(no_import) + '\n')
1113	no_import = []
1114	em = '%d transactions commited total %s\n' % (tr_count,total)
1115	transaction.commit()
1116	regs = []
1117	logger.info(em)
1118	total += tr_count
1119	tr_count = 0
1120	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1121	'\n'.join(no_import))
1122	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1123	###)
1124
1125	security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
1126	def updateReturningStudents(self):
1127	"""load and overwrite Returning Student Data from CSV values"""
1128	import transaction
1129	import random
1130	#from pdb import set_trace
1131	wftool = self.portal_workflow
1132	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1133	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1134	tr_count = 1
1135	total = 0
1136	#name = 'pume_results'
1137	name = 'Returning_update'
1138	table = self.returning_import
1139	no_import = []
1140	imported = []
1141	logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
1142	try:
1143	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1144	except:
1145	logger.error('Error reading %s.csv' % name)
1146	return
1147	l = self.portal_catalog({'meta_type': "Certificate"})
1148	certs = {}
1149	cert_docs = {}
1150	for f in l:
1151	certs[f.getId] = f.getObject().getContent()
1152	start = True
1153	res = table()
1154	regs = []
1155	if len(res) > 0:
1156	regs = [s.matric_no for s in res]
1157	for student in returning:
1158	if start:
1159	start = False
1160	logger.info('Start loading from %s.csv' % name)
1161	s = ','.join(['"%s"' % fn for fn in student.keys()])
1162	imported.append(s)
1163	no_import.append('%s,"Error"' % s)
1164	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
1165	format_error = format + ',"%(Error)s"'
1166	no_certificate = "no certificate %s" % format
1167	matric_no = student.get('matric_no').upper()
1168	student['matric_no'] = matric_no
1169	if matric_no == '':
1170	student['Error'] = "Empty matric_no"
1171	no_import.append( format_error % student)
1172	continue
1173	# if matric_no in regs or self.returning_import(matric_no = matric_no):
1174	# student['Error'] = "Duplicate"
1175	# no_import.append( format_error % student)
1176	# continue
1177	# cert_id = makeCertificateCode(student.get('Coursemajorcode'))
1178	# if cert_id not in certs.keys():
1179	# student['Error'] = "No Certificate %s" % cert_id
1180	# no_import.append( format_error % student)
1181	# continue
1182	try:
1183	table.modifyRecord(**student)
1184	except KeyError:
1185	#import pdb;pdb.set_trace()
1186	student['Error'] = "no Student found to update"
1187	no_import.append( format_error % student)
1188	continue
1189	#s = self.students_catalog(matric_no=matric_no)
1190	#if s:
1191	# level = "%s" % (int(student.get('Level')) + 100)
1192	# self.students_catalog.modifyRecord(id = s[0].id,
1193	# level=level)
1194
1195	regs.append(student.get('matric_no'))
1196	imported.append(format % student)
1197	tr_count += 1
1198	if tr_count > 1000:
1199	if len(no_import) > 0:
1200	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1201	'\n'.join(no_import) + '\n')
1202	no_import = []
1203	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1204	'\n'.join(no_import) + "\n")
1205	imported = []
1206	em = '%d transactions commited total %s\n' % (tr_count,total)
1207	transaction.commit()
1208	regs = []
1209	logger.info(em)
1210	total += tr_count
1211	tr_count = 0
1212	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1213	'\n'.join(imported))
1214	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1215	'\n'.join(no_import))
1216	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1217	###)
1218
1219	security.declareProtected(ModifyPortalContent,"importResults")###(
1220	def importResults(self):
1221	"""load Returning Students Results from CSV"""
1222	import transaction
1223	import random
1224	#from pdb import set_trace
1225	wftool = self.portal_workflow
1226	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1227	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1228	tr_count = 1
1229	total = 0
1230	#name = 'pume_results'
1231	name = 'Results'
1232	table = self.results_import
1233	no_import = []
1234	imported = []
1235	logger = logging.getLogger('Students.StudentsFolder.importResults')
1236	try:
1237	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1238	except:
1239	logger.error('Error reading %s.csv' % name)
1240	return
1241	l = self.portal_catalog({'meta_type': "Course"})
1242	courses = [f.getId for f in l]
1243	start = True
1244	res = table()
1245	regs = []
1246	if len(res) > 0:
1247	regs = [s.key for s in res]
1248	no_course = []
1249	no_course_list = []
1250	course_count = 0
1251	for result in results:
1252	if start:
1253	start = False
1254	logger.info('Start loading from %s.csv' % name)
1255	s = ','.join(['"%s"' % fn for fn in result.keys()])
1256	imported.append(s)
1257	no_import.append('%s,"Error"' % s)
1258	format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
1259	format_error = format + ',"%(Error)s"'
1260	no_certificate = "no certificate %s" % format
1261	course_id = result.get('CosCode')
1262	if not course_id:
1263	course_id = 'N/A'
1264	result['CosCode'] = course_id
1265	matric_no = result.get('matric_no').upper()
1266	result['matric_no'] = matric_no
1267	key = matric_no+course_id
1268	if matric_no == '':
1269	result['Error'] = "Empty matric_no"
1270	no_import.append( format_error % result)
1271	continue
1272	if key in regs or self.results_import(key = key):
1273	result['Error'] = "Duplicate"
1274	no_import.append( format_error % result)
1275	continue
1276	if course_id not in courses:
1277	if course_id not in no_course:
1278	course_count +=1
1279	no_course.append(course_id)
1280	no_course_list.append('"%s"' % course_id)
1281	#result['Error'] = "No Course"
1282	#logger.info(format_error % result)
1283	regs.append(key)
1284	imported.append(format % result)
1285	tr_count += 1
1286	if tr_count > 1000:
1287	if len(no_import) > 0:
1288	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1289	'\n'.join(no_import)+'\n')
1290	no_import = []
1291	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1292	'\n'.join(imported) + '\n')
1293	imported = []
1294	if no_course_list:
1295	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1296	'\n'.join(no_course_list) + '\n')
1297	no_course_list = []
1298	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1299	transaction.commit()
1300	logger.info(em)
1301	regs = []
1302	total += tr_count
1303	tr_count = 0
1304	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1305	'\n'.join(imported))
1306	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1307	'\n'.join(no_import))
1308	if no_course_list:
1309	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
1310	'\n'.join(no_course_list))
1311	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
1312	logger.info(em)
1313	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1314	###)
1315
1316	security.declareProtected(ModifyPortalContent,"importPreviousSessionStudents")###(
1317	def importPreviousSessionStudents(self):
1318	"""load and create previous session students from CSV"""
1319	import transaction
1320	import random
1321	wftool = self.portal_workflow
1322	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
1323	students_folder = self.portal_url.getPortalObject().campus.students
1324	tr_count = 1
1325	total = 0
1326	#name = 'pume_results'
1327	name = 'Previous'
1328	keys = self.portal_schemas.import_student.keys()
1329	keys += self.portal_schemas.import_student_level_data.keys()
1330	not_imported = []
1331	imported = []
1332	certificates = {}
1333	logger = logging.getLogger('Students.StudentsFolder.importPreviousSessionStudents')
1334	try:
1335	records = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1336	except:
1337	logger.error('Error reading %s.csv' % name)
1338	return
1339	start = True
1340	for record in records:
1341	if start:
1342	start = False
1343	logger.info('Start loading from %s.csv' % name)
1344	false_keys = [k for k in record.keys() if k not in keys]
1345	right_keys = [k for k in record.keys() if k in keys]
1346	if false_keys:
1347	logger.info('Fields %s not in schema' % false_keys)
1348	s = ','.join(['"%s"' % k for k in right_keys])
1349	imported.append(s)
1350	not_imported.append('%s,"error"' % s)
1351	format = ','.join(['"%%(%s)s"' % k for k in right_keys])
1352	format_error = format + ',"%(error)s"'
1353	study_course = record.get('study_course')
1354	matric_no = record.get('matric_no')
1355	student_res = self.students_catalog(matric_no = matric_no)
1356	if student_res:
1357	record['error'] = "Student exists"
1358	not_imported.append(format_error % record)
1359	continue
1360	if study_course not in certificates.keys():
1361	cert_res = self.portal_catalog(portal_type='Certificate',
1362	id = study_course)
1363	if not cert_res:
1364	record['error'] = "No such studycourse"
1365	not_imported.append(format_error % record)
1366	continue
1367	certificates[cert_res[0].id] = cert_res[0]
1368	sid = self.generateStudentId('x',students_folder)
1369	students_folder.invokeFactory('Student', sid)
1370	#from pdb import set_trace;set_trace()
1371	record['student_id'] = sid
1372	student = getattr(self,sid)
1373	student.manage_setLocalRoles(sid, ['Owner',])
1374	student.invokeFactory('StudentApplication','application')
1375	app = student.application
1376	app_doc = app.getContent()
1377	dict = {'Title': 'Application Data'}
1378	dict["jamb_lastname"] = "%(firstname)s %(lastname)s %(middlename)s" % record
1379	r2d = [
1380	('entry_mode','entry_mode'),
1381	('sex','jamb_sex'),
1382	('jamb_score','jamb_score'),
1383	('jamb_reg_no','jamb_reg_no'),
1384	]
1385	for r,d in r2d:
1386	dict[d] = record[r]
1387	app_doc.edit(mapping=dict)
1388	app.manage_setLocalRoles(sid, ['Owner',])
1389	wftool.doActionFor(app,'close')
1390	record['sex'] = record['sex'] == 'F'
1391	student.invokeFactory('StudentPersonal','personal')
1392	dict = {}
1393	r2d = [('firstname','firstname'),
1394	('middlename','middlename'),
1395	('lastname','lastname'),
1396	('sex','sex'),
1397	('email','email'),
1398	('phone','phone'),
1399	('address','perm_address'),
1400	]
1401	for r,d in r2d:
1402	dict[d] = record[r]
1403	per = student.personal
1404	per_doc = per.getContent()
1405	per_doc.edit(mapping = dict)
1406	per.manage_setLocalRoles(sid, ['Owner',])
1407	#
1408	# Clearance
1409	#
1410	student.invokeFactory('StudentClearance','clearance')
1411	#wftool.doActionFor(student.clearance,'open')
1412	clearance = getattr(student,'clearance')
1413	dict = {'Title': 'Clearance/Eligibility Record'}
1414	clearance.getContent().edit(mapping = dict)
1415	student.clearance.manage_setLocalRoles(sid, ['Owner',])
1416	#
1417	# Study Course
1418	#
1419	student.invokeFactory('StudentStudyCourse','study_course')
1420	study_course = student.study_course
1421	dict = {}
1422	r2d = [('session','current_session'),
1423	('level','current_level'),
1424	('verdict','current_verdict'),
1425	('study_course','study_course'),
1426	]
1427	for r,d in r2d:
1428	dict[d] = record[r]
1429	study_course.getContent().edit(mapping=dict)
1430	#
1431	# Study Level
1432	#
1433	level = record['level']
1434	study_course.invokeFactory('StudentStudyLevel',level)
1435	study_level = getattr(study_course,level)
1436	dict = {}
1437	r2d = [('session','session'),
1438	('level','code'),
1439	('verdict','verdict'),
1440	]
1441	for r,d in r2d:
1442	dict[d] = record[r]
1443	study_level.getContent().edit(mapping=dict)
1444	wftool.doActionFor(student,'return')
1445	imported.append(format % record)
1446	tr_count += 1
1447	record['tr_count'] = tr_count
1448	record['total'] = total
1449	logger.info('%(total)s+%(tr_count)s: Creating Student %(student_id)s %(matric_no)s %(jamb_reg_no)s' % record)
1450	if tr_count > 1000:
1451	if len(not_imported) > 0:
1452	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1453	'\n'.join(not_imported)+'\n')
1454	not_imported = []
1455	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1456	'\n'.join(imported) + '\n')
1457	imported = []
1458	em = '%d transactions commited total %s' % (tr_count,total)
1459	transaction.commit()
1460	logger.info(em)
1461	regs = []
1462	total += tr_count
1463	tr_count = 0
1464	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
1465	'\n'.join(imported))
1466	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
1467	'\n'.join(not_imported))
1468	em = '%d transactions commited total %d' % (tr_count,total)
1469	logger.info(em)
1470	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1471	###)
1472
1473	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
1474	def updateStudyCourse(self):
1475	"""update StudyCourse from CSV values"""
1476	import transaction
1477	import random
1478	from pdb import set_trace
1479	wftool = self.portal_workflow
1480	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1481	csv_d = {'jamb_reg_no': "RegNumber",
1482	'jamb_lastname': "Name",
1483	'session': "Session",
1484	'pume_tot_score': "PUME SCORE",
1485	'jamb_score': "JambScore",
1486	'jamb_sex': "Sex",
1487	'jamb_state': "State",
1488	## 'jamb_first_cos': "AdminCourse",
1489	'faculty': "AdminFaculty",
1490	'course_code': "AdmitCoscode",
1491	'stud_status':"AdmitStatus",
1492	'department': "AdmitDept",
1493	'jamb_lga': "LGA",
1494	'app_email': "email",
1495	'app_mobile': "PhoneNumbers",
1496	}
1497	csv_fields = [f[1] for f in csv_d.items()]
1498	tr_count = 0
1499	total = 0
1500	#name = 'pume_results'
1501	name = 'StudyCourseChange'
1502	no_import = []
1503	s = ','.join(['"%s"' % fn for fn in csv_fields])
1504	no_import.append('"Error",%s' % s)
1505	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1506	no_certificate = "no certificate %s" % format
1507	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1508	'\n'.join(no_import))
1509	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
1510	logger.info('Start loading from %s.csv' % name)
1511	l = self.portal_catalog({'meta_type': "Certificate"})
1512	try:
1513	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1514	except:
1515	logger.error('Error reading %s.csv' % name)
1516	return
1517	for jamb in result:
1518	jamb['Error'] = "Processing "
1519	logger.info(format % jamb)
1520	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1521	res = self.portal_catalog({'portal_type': "StudentApplication",
1522	'SearchableText': jamb_reg_no })
1523	if not res:
1524	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
1525	logger.info(em)
1526	jamb['Error'] = "Student does not exist"
1527	no_import.append(format % jamb)
1528	continue
1529	sid = res[0].getPath().split('/')[-2]
1530	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
1531	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
1532	if not res:
1533	em = 'No Certificate with ID %s \n' % cert_id
1534	logger.info(em)
1535	jamb['Error'] = "No Certificate %s" % cert_id
1536	no_import.append( format % jamb)
1537	continue
1538	cert_brain = res[0]
1539	catalog_entry = {}
1540	student = getattr(self,sid)
1541	#
1542	# Study Course
1543	#
1544	study_course = student.study_course
1545	dsc = {}
1546	cert_pl = cert_brain.getPath().split('/')
1547	catalog_entry['id'] = sid
1548	catalog_entry['faculty'] = cert_pl[-4]
1549	catalog_entry['department'] = cert_pl[-3]
1550	catalog_entry['course'] = cert_id
1551	dsc['study_course'] = cert_id
1552	study_course.getContent().edit(mapping=dsc)
1553	self.students_catalog.modifyRecord(**catalog_entry)
1554	if tr_count > 10:
1555	if len(no_import) > 1:
1556	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
1557	'\n'.join(no_import))
1558	no_import = []
1559	em = '%d transactions commited\n' % tr_count
1560	transaction.commit()
1561	logger.info(em)
1562	total += tr_count
1563	tr_count = 0
1564	tr_count += 1
1565	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1566	###)
1567
1568	security.declareProtected(View,"fixOwnership") ###(
1569	def fixOwnership(self):
1570	"""fix Ownership"""
1571	for s in self.portal_catalog(meta_type = 'Student'):
1572	student = s.getObject()
1573	sid = s.getId
1574	import pdb;pdb.set_trace()
1575	student.application.manage_setLocalRoles(sid, ['Owner',])
1576	student.personal.manage_setLocalRoles(sid, ['Owner',])
1577	###)
1578
1579	security.declareProtected(View,"Title") ###(
1580	def Title(self):
1581	"""compose title"""
1582	return "Student Section"
1583	###)
1584
1585	def generateStudentId(self,letter,students = None): ###(
1586	import random
1587	r = random
1588	if students is None:
1589	students = self.portal_url.getPortalObject().campus.students
1590	if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
1591	letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
1592	sid = "%c%d" % (letter,r.randint(99999,1000000))
1593	while hasattr(students, sid):
1594	sid = "%c%d" % (letter,r.randint(99999,1000000))
1595	return sid
1596	#return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
1597	###)
1598
1599	InitializeClass(StudentsFolder)
1600
1601	def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
1602	"""Add a Student."""
1603	ob = StudentsFolder(id, **kw)
1604	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1605	###)
1606
1607	###)
1608
1609	class Student(CPSDocument): ###(
1610	"""
1611	WAeUP Student container for the various student data
1612	"""
1613	meta_type = 'Student'
1614	portal_type = meta_type
1615	security = ClassSecurityInfo()
1616
1617	security.declareProtected(View,"Title")
1618	def Title(self):
1619	"""compose title"""
1620	reg_nr = self.getId()[1:]
1621	data = getattr(self,'personal',None)
1622	if data:
1623	content = data.getContent()
1624	return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
1625	data = getattr(self,'application',None)
1626	if data:
1627	content = data.getContent()
1628	return "%s" % (content.jamb_lastname)
1629	return self.title
1630
1631	security.declarePrivate('makeStudentMember') ###(
1632	def makeStudentMember(self,sid,password='uNsEt'):
1633	"""make the student a member"""
1634	membership = self.portal_membership
1635	membership.addMember(sid,
1636	password ,
1637	roles=('Member',
1638	'Student',
1639	),
1640	domains='',
1641	properties = {'memberareaCreationFlag': False,
1642	'homeless': True},)
1643	member = membership.getMemberById(sid)
1644	self.portal_registration.afterAdd(member, sid, password, None)
1645	self.manage_setLocalRoles(sid, ['Owner',])
1646
1647	###)
1648
1649	security.declareProtected(View,'createSubObjects') ###(
1650	def createSubObjects(self):
1651	"""make the student a member"""
1652	dp = {'Title': 'Personal Data'}
1653	app_doc = self.application.getContent()
1654	names = app_doc.jamb_lastname.split()
1655	if len(names) == 3:
1656	dp['firstname'] = names[0].capitalize()
1657	dp['middlename'] = names[1].capitalize()
1658	dp['lastname'] = names[2].capitalize()
1659	elif len(names) == 2:
1660	dp['firstname'] = names[0].capitalize()
1661	dp['lastname'] = names[1].capitalize()
1662	else:
1663	dp['lastname'] = app_doc.jamb_lastname
1664	dp['sex'] = app_doc.jamb_sex == 'F'
1665	dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1666	proxy = self.aq_parent
1667	proxy.invokeFactory('StudentPersonal','personal')
1668	per = proxy.personal
1669	per_doc = per.getContent()
1670	per_doc.edit(mapping = dp)
1671	per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1672	#self.portal_workflow.doActionFor(per,'open',dest_container=per)
1673
1674	###)
1675
1676	InitializeClass(Student)
1677
1678	def addStudent(container, id, REQUEST=None, **kw):
1679	"""Add a Student."""
1680	ob = Student(id, **kw)
1681	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1682
1683	###)
1684
1685	class StudentAccommodation(CPSDocument): ###(
1686	"""
1687	WAeUP Student container for the various student data
1688	"""
1689	meta_type = 'StudentAccommodation'
1690	portal_type = meta_type
1691	security = ClassSecurityInfo()
1692
1693	security.declareProtected(View,"Title")
1694	def Title(self):
1695	"""compose title"""
1696	content = self.getContent()
1697	#return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1698	return "Accommodation Data for Session %s" % content.session
1699
1700
1701	InitializeClass(StudentAccommodation)
1702
1703	def addStudentAccommodation(container, id, REQUEST=None, **kw):
1704	"""Add a Students personal data."""
1705	ob = StudentAccommodation(id, **kw)
1706	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1707
1708	###)
1709
1710	class StudentPersonal(CPSDocument): ###(
1711	"""
1712	WAeUP Student container for the various student data
1713	"""
1714	meta_type = 'StudentPersonal'
1715	portal_type = meta_type
1716	security = ClassSecurityInfo()
1717
1718	security.declareProtected(View,"Title")
1719	def Title(self):
1720	"""compose title"""
1721	content = self.getContent()
1722	#return "Personal Data for %s %s" % (content.firstname,content.lastname)
1723	return "Personal Data"
1724
1725
1726	InitializeClass(StudentPersonal)
1727
1728	def addStudentPersonal(container, id, REQUEST=None, **kw):
1729	"""Add a Students personal data."""
1730	ob = StudentPersonal(id, **kw)
1731	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1732
1733	###)
1734
1735	class StudentClearance(CPSDocument): ###(
1736	"""
1737	WAeUP Student container for the various student data
1738	"""
1739	meta_type = 'StudentClearance'
1740	portal_type = meta_type
1741	security = ClassSecurityInfo()
1742
1743	security.declareProtected(View,"Title")
1744	def Title(self):
1745	"""compose title"""
1746	content = self.getContent()
1747	#return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1748	return "Clearance/Eligibility Record"
1749
1750
1751	InitializeClass(StudentClearance)
1752
1753	def addStudentClearance(container, id, REQUEST=None, **kw):
1754	"""Add a Students personal data."""
1755	ob = StudentClearance(id, **kw)
1756	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1757
1758	###)
1759
1760	class StudentStudyLevel(CPSDocument): ###(
1761	"""
1762	WAeUP Student container for the various student data
1763	"""
1764	meta_type = 'StudentStudyLevel'
1765	portal_type = meta_type
1766	security = ClassSecurityInfo()
1767
1768	security.declareProtected(View,"Title")
1769	def Title(self):
1770	"""compose title"""
1771	return "Level %s" % self.aq_parent.getId()
1772
1773	def create_course_results(self,cert_id,current_level): ###(
1774	"create all courses in a level"
1775	aq_portal = self.portal_catalog.evalAdvancedQuery
1776	res = self.portal_catalog(portal_type="Certificate", id = cert_id)
1777	l = []
1778	import transaction
1779	if res:
1780	cert = res[0]
1781	path = cert.getPath()
1782	query = Eq("path","%s/%s" % (path,current_level)) &\
1783	Eq('portal_type','CertificateCourse')
1784	courses = aq_portal(query)
1785	#from pdb import set_trace;set_trace()
1786	self_proxy = self.aq_parent
1787	for c in courses:
1788	d = self.getCourseInfo(c.getId)
1789	cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
1790	course_result = getattr(self_proxy,cr_id)
1791	self.portal_workflow.doActionFor(course_result,'open')
1792	d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
1793	course_result.getContent().edit(mapping=d)
1794	transaction.commit()
1795	###)
1796
1797	InitializeClass(StudentStudyLevel)
1798
1799	def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1800	"""Add a Students personal data."""
1801	ob = StudentStudyLevel(id, **kw)
1802	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1803
1804	###)
1805
1806	class StudentStudyCourse(CPSDocument): ###(
1807	"""
1808	WAeUP Student container for the various student data
1809	"""
1810	meta_type = 'StudentStudyCourse'
1811	portal_type = meta_type
1812	security = ClassSecurityInfo()
1813
1814	security.declareProtected(View,"Title")
1815	def Title(self):
1816	"""compose title"""
1817	content = self.getContent()
1818	return "Study Course"
1819
1820
1821	InitializeClass(StudentStudyCourse)
1822
1823	def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1824	"""Add a Students personal data."""
1825	ob = StudentStudyCourse(id, **kw)
1826	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1827
1828	###)
1829
1830	class StudentApplication(CPSDocument): ###(
1831	"""
1832	WAeUP Student container for the various student data
1833	"""
1834	meta_type = 'StudentApplication'
1835	portal_type = meta_type
1836	security = ClassSecurityInfo()
1837
1838	security.declareProtected(View,"Title")
1839	def Title(self):
1840	"""compose title"""
1841	return "Application Data"
1842
1843
1844	InitializeClass(StudentApplication)
1845
1846	def addStudentApplication(container, id, REQUEST=None, **kw):
1847	"""Add a Students eligibility data."""
1848	ob = StudentApplication(id, **kw)
1849	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1850	###)
1851
1852	class StudentPume(CPSDocument): ###(
1853	"""
1854	WAeUP Student container for the various student data
1855	"""
1856	meta_type = 'StudentPume'
1857	portal_type = meta_type
1858	security = ClassSecurityInfo()
1859
1860	security.declareProtected(View,"Title")
1861	def Title(self):
1862	"""compose title"""
1863	return "PUME Results"
1864
1865
1866	InitializeClass(StudentPume)
1867
1868	def addStudentPume(container, id, REQUEST=None, **kw):
1869	"""Add a Students PUME data."""
1870	ob = StudentPume(id, **kw)
1871	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1872	###)
1873
1874	##class StudentSemester(CPSDocument): ###(
1875	## """
1876	## WAeUP StudentSemester containing the courses and students
1877	## """
1878	## meta_type = 'StudentSemester'
1879	## portal_type = meta_type
1880	## security = ClassSecurityInfo()
1881	##
1882	##InitializeClass(StudentSemester)
1883	##
1884	##def addStudentSemester(container, id, REQUEST=None, **kw):
1885	## """Add a StudentSemester."""
1886	## ob = StudentSemester(id, **kw)
1887	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1888	##
1889	#####)
1890
1891	##class Semester(CPSDocument): ###(
1892	## """
1893	## WAeUP Semester containing the courses and students
1894	## """
1895	## meta_type = 'Semester'
1896	## portal_type = meta_type
1897	## security = ClassSecurityInfo()
1898	##
1899	##InitializeClass(Semester)
1900	##
1901	##def addSemester(container, id, REQUEST=None, **kw):
1902	## """Add a Semester."""
1903	## ob = Semester(id, **kw)
1904	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
1905	##
1906	#####)
1907
1908	class StudentCourseResult(CPSDocument): ###(
1909	"""
1910	WAeUP StudentCourseResult
1911	"""
1912	meta_type = 'StudentCourseResult'
1913	portal_type = meta_type
1914	security = ClassSecurityInfo()
1915
1916	def getCourseEntry(self,cid):
1917	res = self.portal_catalog({'meta_type': "Course",
1918	'id': cid})
1919	if res:
1920	return res[-1]
1921	else:
1922	return None
1923
1924	security.declareProtected(View,"Title")
1925	def Title(self):
1926	"""compose title"""
1927	cid = self.aq_parent.getId()
1928	ce = self.getCourseEntry(cid)
1929	if ce:
1930	return "%s" % ce.Title
1931	return "No course with id %s" % cid
1932
1933	InitializeClass(StudentCourseResult)
1934
1935	def addStudentCourseResult(container, id, REQUEST=None, **kw):
1936	"""Add a StudentCourseResult."""
1937	ob = StudentCourseResult(id, **kw)
1938	return CPSBase_adder(container, ob, REQUEST=REQUEST)
1939	###)
1940
1941	# Backward Compatibility StudyLevel
1942
1943	from Products.WAeUP_SRP.Academics import StudyLevel
1944
1945	from Products.WAeUP_SRP.Academics import addStudyLevel
1946

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

Download in other formats: