Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1779

Last change on this file since 1779 was 1775, checked in by Henrik Bettermann, 18 years ago
create also payment object in importStudent unused methods removed from Students.py
Property svn:keywords set to `Id`
File size: 52.0 KB

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

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

Download in other formats: