Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1831

Last change on this file since 1831 was 1829, checked in by Henrik Bettermann, 17 years ago
fixed
Property svn:keywords set to `Id`
File size: 56.8 KB

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

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

Download in other formats: