Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1883

Last change on this file since 1883 was 1880, checked in by Henrik Bettermann, 18 years ago
Rerunning transferStudents always transferred students, who were already transferred, if they had not level object. These students have upto 3 entries in matric_no_history in their clearance object.
Property svn:keywords set to `Id`
File size: 57.2 KB

Rev	Line
[57]	1	#-- mode: python; mode: fold --
[200]	2	# $Id: Students.py 1880 2007-06-12 05:14:45Z 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"""
[1848]	68	search = ZCatalog.searchResults(self.portal_catalog_real,{'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:
[1834]	476	em = 'Student with matric_no %s not found' % old_matric_no
[1820]	477	logger.info(em)
[1834]	478	result['Error'] = "Student does not exist"
[1820]	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:
[1834]	489	em = 'No certificate with ID %s \n' % cert_id
[1820]	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)
[1834]	514	new_study_course = result.get('study_course',None)
[1820]	515	try:
	516	icl = int(current_level)
	517	except:
	518	em = 'Invalid new level %s' % current_level
	519	logger.info(em)
	520	result['Error'] = em
	521	not_imported.append( format_error % result)
	522	total_not_imported += 1
	523	continue
[1880]	524	if icl == int(old_current_level) and old_study_course == new_study_course:
	525	em = 'Already transferred'
	526	logger.info(em)
	527	result['Error'] = em
	528	not_imported.append( format_error % result)
	529	total_not_imported += 1
	530	continue
	531	if study_course.objectIds():
[1834]	532	em = 'Already registered level %s for %s, but is supposed to study %s at level %s' % (old_current_level,old_study_course,new_study_course,current_level)
[1820]	533	logger.info(em)
	534	result['Error'] = em
	535	not_imported.append( format_error % result)
	536	total_not_imported += 1
	537	continue
	538	#from pdb import set_trace; set_trace()
	539	cd = {}
	540	matric_no_history = getattr(clearance_doc,'matric_no_history',[])
	541	if not matric_no_history:
	542	matric_no_history = []
	543	matric_no_history.append(old_matric_no)
	544	cd['matric_no_history'] = matric_no_history
	545	cd['matric_no'] = result.get('matric_no')
	546	clearance_doc.edit(mapping = cd)
	547	dsc = {}
	548	study_course_history = getattr(study_course_doc,'study_course_history',[])
	549	if not study_course_history:
	550	study_course_history = []
	551	study_course_history.append(old_study_course)
	552	dsc['study_course_history'] = study_course_history
[1834]	553	dsc['study_course'] = new_study_course
[1820]	554	dsc['current_level'] = current_level
	555	dsc['current_mode'] = result.get('current_mode')
	556	study_course_doc.edit(mapping=dsc)
	557	imported.append( format % result)
	558	tr_count += 1
	559	total_imported += 1
	560	if tr_count > 1000:
	561	if len(not_imported) > 0:
	562	open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(
	563	'\n'.join(not_imported) + '\n')
	564	not_imported = []
	565	if len(imported) > 0:
	566	open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(
	567	'\n'.join(imported) + '\n')
	568	imported = []
	569	em = '%d transactions committed\n' % (tr_count)
	570	transaction.commit()
	571	regs = []
	572	logger.info(em)
	573	tr_count = 0
	574	if len(imported) > 0:
	575	open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(
	576	'\n'.join(imported))
	577	if len(not_imported) > 0:
	578	open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(
	579	'\n'.join(not_imported))
	580	em = "Imported: %d, not imported: %d of total %d" % (total_imported,total_not_imported,total)
	581	logger.info(em)
	582	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	583	###)
	584
[1151]	585	security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
	586	def importReturningStudents(self):
	587	"""load Returning Studentdata from CSV values"""
[1146]	588	import transaction
	589	import random
	590	#from pdb import set_trace
	591	wftool = self.portal_workflow
	592	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
[1802]	593	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	594	students_folder = self.portal_url.getPortalObject().campus.students
[1146]	595	tr_count = 1
	596	total = 0
	597	#name = 'pume_results'
[1151]	598	name = 'Returning'
	599	table = self.returning_import
[1146]	600	no_import = []
	601	imported = []
[1571]	602	logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
[1146]	603	try:
[1151]	604	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
[1146]	605	except:
	606	logger.error('Error reading %s.csv' % name)
	607	return
	608	l = self.portal_catalog({'meta_type': "Certificate"})
	609	certs = {}
	610	cert_docs = {}
	611	for f in l:
	612	certs[f.getId] = f.getObject().getContent()
	613	start = True
	614	res = table()
	615	regs = []
	616	if len(res) > 0:
	617	regs = [s.matric_no for s in res]
[1319]	618	#import pdb;pdb.set_trace()
[1151]	619	for student in returning:
[1146]	620	if start:
	621	start = False
[1571]	622	logger.info('Start loading from %s.csv' % name)
[1319]	623	s = ','.join(['"%s"' % fn for fn in student.keys()])
[1146]	624	imported.append(s)
	625	no_import.append('%s,"Error"' % s)
	626	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
	627	format_error = format + ',"%(Error)s"'
	628	no_certificate = "no certificate %s" % format
[1319]	629	student['matric_no'] = matric_no = student.get('matric_no').upper()
	630	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
	631	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
[1168]	632	if matric_no == '':
[1252]	633	student['Error'] = "Empty matric_no"
[1146]	634	no_import.append( format_error % student)
	635	continue
[1168]	636	if matric_no in regs or self.returning_import(matric_no = matric_no):
[1252]	637	student['Error'] = "Duplicate"
[1146]	638	no_import.append( format_error % student)
	639	continue
	640	cert_id = makeCertificateCode(student.get('Coursemajorcode'))
	641	if cert_id not in certs.keys():
	642	student['Error'] = "No Certificate %s" % cert_id
	643	no_import.append( format_error % student)
	644	continue
	645	try:
	646	table.addRecord(**student)
	647	except ValueError:
[1252]	648	student['Error'] = "Duplicate"
[1146]	649	no_import.append( format_error % student)
	650	continue
	651	regs.append(student.get('matric_no'))
	652	imported.append(format % student)
	653	tr_count += 1
	654	if tr_count > 1000:
	655	if len(no_import) > 0:
	656	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
[1151]	657	'\n'.join(no_import) + '\n')
[1146]	658	no_import = []
	659	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
[1151]	660	'\n'.join(no_import) + "\n")
	661	imported = []
[1146]	662	em = '%d transactions commited total %s\n' % (tr_count,total)
	663	transaction.commit()
[1168]	664	regs = []
[1146]	665	logger.info(em)
	666	total += tr_count
	667	tr_count = 0
	668	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
[1252]	669	'\n'.join(imported))
[1146]	670	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	671	'\n'.join(no_import))
	672	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	673	###)
	674
[1599]	675	security.declareProtected(ModifyPortalContent,"fixAllNames")###(
[1601]	676	def fixAllNames(self):
[1599]	677	"fix all students names"
	678	import transaction
	679	response = self.REQUEST.RESPONSE
	680	logger = logging.getLogger('fixAllNames')
	681	logger.info('Start')
	682	students = self.portal_catalog(portal_type='Student')
	683	count = 0
	684	total = 0
	685	for student in students:
	686	scat_res = self.students_catalog(id = student.getId)
	687	if not scat_res:
	688	self.students_catalog.addRecord(id = student.getId)
	689	scat_res = self.students_catalog(id = student.getId)
	690	student_entry = scat_res[0]
	691	old_new = self.fixName(student,student_entry)
	692	count += 1
[1602]	693	response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
[1599]	694	if count > 2000:
	695	transaction.commit()
	696	logger.info("%d transactions commited" % count)
	697	total += count
	698	count = 0
	699	###)
	700
	701	security.declareProtected(ModifyPortalContent,"fixName")###(
[1601]	702	def fixName(self,student_brain, student_entry):
[1599]	703	"fix the name of a student"
	704	fix = "first"
	705	if student_entry.get('name_fixed',None) == fix:
	706	return "Name already fixed"
	707	student_id = student_entry.id
[1601]	708	new_student = student_entry.jamb_reg_no.startswith('6')
[1599]	709	student_obj = student_brain.getObject()
	710	personal = getattr(student_obj,'personal',None)
	711	invalid = ''
	712	if personal is None:
[1601]	713	return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
[1599]	714	per_doc = personal.getContent()
	715	old_first = per_doc.firstname
	716	old_middle = per_doc.middlename
	717	old_last = per_doc.lastname
	718	new_first = ''
	719	new_middle = ''
	720	new_last = ''
	721	if new_student:
	722	if not old_first and not old_middle and old_last:
	723	new_names = [n.capitalize() for n in old_last.split()]
[1611]	724	if len(new_names) > 1:
[1599]	725	old_first = new_names[0]
[1611]	726	old_last = new_names[-1]
	727	old_middle = ' '.join(new_names[1:-1])
	728	else:
[1599]	729	old_last = new_names[0]
	730	old_first = ''
	731	old_middle = ''
[1611]	732	if old_first:
	733	new_first = old_first
[1599]	734	if old_middle:
	735	new_middle = old_middle
[1611]	736	if old_last:
	737	new_last = old_last
[1599]	738	if old_first.find('<') != -1 or\
	739	old_first.find('>') != -1 or\
	740	old_middle.find('<') != -1 or\
	741	old_middle.find('>') != -1 or\
	742	old_last.find('<') != -1 or\
	743	old_last.find('>') != -1:
	744	invalid = "invalid characters"
	745	else:
[1611]	746	new_first = old_first
	747	if new_first.strip() == '-':
[1599]	748	new_first = ''
[1611]	749	new_middle = old_middle
	750	if new_middle.strip() == '-':
[1599]	751	new_middle = ''
[1611]	752	new_last = old_last
	753	if new_last.strip() == '-':
[1599]	754	new_last = ''
[1611]	755	name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
[1599]	756	if new_student:
	757	text = "New"
	758	else:
	759	text = "Returning"
[1601]	760	old_new = '"%s","%s","%s","%s"' % (invalid,text,
[1599]	761	student_entry.name,
	762	name)
	763	if not invalid:
	764	self.students_catalog.modifyRecord(id = student_id,
	765	name_fixed = fix,
	766	name = name)
	767	per_doc.edit(mapping = {'firstname' : new_first,
	768	'middlename' : new_middle,
	769	'lastname' : new_last,
	770	})
	771	return old_new
	772	###)
	773
[1289]	774	security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
	775	def updateReturningStudents(self):
	776	"""load and overwrite Returning Student Data from CSV values"""
	777	import transaction
	778	import random
	779	#from pdb import set_trace
	780	wftool = self.portal_workflow
	781	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
[1802]	782	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	783	students_folder = self.portal_url.getPortalObject().campus.students
[1289]	784	tr_count = 1
	785	total = 0
	786	#name = 'pume_results'
	787	name = 'Returning_update'
	788	table = self.returning_import
	789	no_import = []
	790	imported = []
[1571]	791	logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
[1289]	792	try:
	793	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	794	except:
	795	logger.error('Error reading %s.csv' % name)
	796	return
	797	l = self.portal_catalog({'meta_type': "Certificate"})
	798	certs = {}
	799	cert_docs = {}
	800	for f in l:
	801	certs[f.getId] = f.getObject().getContent()
	802	start = True
	803	res = table()
	804	regs = []
	805	if len(res) > 0:
	806	regs = [s.matric_no for s in res]
	807	for student in returning:
	808	if start:
	809	start = False
[1571]	810	logger.info('Start loading from %s.csv' % name)
[1321]	811	s = ','.join(['"%s"' % fn for fn in student.keys()])
[1289]	812	imported.append(s)
	813	no_import.append('%s,"Error"' % s)
	814	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
	815	format_error = format + ',"%(Error)s"'
	816	no_certificate = "no certificate %s" % format
	817	matric_no = student.get('matric_no').upper()
	818	student['matric_no'] = matric_no
	819	if matric_no == '':
	820	student['Error'] = "Empty matric_no"
	821	no_import.append( format_error % student)
	822	continue
	823	# if matric_no in regs or self.returning_import(matric_no = matric_no):
	824	# student['Error'] = "Duplicate"
	825	# no_import.append( format_error % student)
	826	# continue
	827	# cert_id = makeCertificateCode(student.get('Coursemajorcode'))
	828	# if cert_id not in certs.keys():
	829	# student['Error'] = "No Certificate %s" % cert_id
	830	# no_import.append( format_error % student)
	831	# continue
	832	try:
	833	table.modifyRecord(**student)
	834	except KeyError:
	835	#import pdb;pdb.set_trace()
	836	student['Error'] = "no Student found to update"
	837	no_import.append( format_error % student)
	838	continue
[1386]	839	#s = self.students_catalog(matric_no=matric_no)
	840	#if s:
	841	# level = "%s" % (int(student.get('Level')) + 100)
	842	# self.students_catalog.modifyRecord(id = s[0].id,
	843	# level=level)
[1289]	844
	845	regs.append(student.get('matric_no'))
	846	imported.append(format % student)
	847	tr_count += 1
	848	if tr_count > 1000:
	849	if len(no_import) > 0:
	850	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	851	'\n'.join(no_import) + '\n')
	852	no_import = []
	853	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	854	'\n'.join(no_import) + "\n")
	855	imported = []
	856	em = '%d transactions commited total %s\n' % (tr_count,total)
	857	transaction.commit()
	858	regs = []
	859	logger.info(em)
	860	total += tr_count
	861	tr_count = 0
	862	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	863	'\n'.join(imported))
	864	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	865	'\n'.join(no_import))
	866	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	867	###)
	868
[1146]	869	security.declareProtected(ModifyPortalContent,"importResults")###(
	870	def importResults(self):
[1151]	871	"""load Returning Students Results from CSV"""
[1146]	872	import transaction
	873	import random
	874	#from pdb import set_trace
	875	wftool = self.portal_workflow
	876	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
[1802]	877	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	878	students_folder = self.portal_url.getPortalObject().campus.students
[1146]	879	tr_count = 1
	880	total = 0
	881	#name = 'pume_results'
	882	name = 'Results'
	883	table = self.results_import
	884	no_import = []
	885	imported = []
[1571]	886	logger = logging.getLogger('Students.StudentsFolder.importResults')
[1146]	887	try:
	888	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	889	except:
	890	logger.error('Error reading %s.csv' % name)
	891	return
	892	l = self.portal_catalog({'meta_type': "Course"})
	893	courses = [f.getId for f in l]
	894	start = True
	895	res = table()
	896	regs = []
	897	if len(res) > 0:
	898	regs = [s.key for s in res]
	899	no_course = []
	900	no_course_list = []
	901	course_count = 0
	902	for result in results:
	903	if start:
	904	start = False
[1571]	905	logger.info('Start loading from %s.csv' % name)
[1321]	906	s = ','.join(['"%s"' % fn for fn in result.keys()])
[1146]	907	imported.append(s)
	908	no_import.append('%s,"Error"' % s)
	909	format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
	910	format_error = format + ',"%(Error)s"'
	911	no_certificate = "no certificate %s" % format
	912	course_id = result.get('CosCode')
[1448]	913	if not course_id:
	914	course_id = 'N/A'
	915	result['CosCode'] = course_id
[1168]	916	matric_no = result.get('matric_no').upper()
	917	result['matric_no'] = matric_no
	918	key = matric_no+course_id
	919	if matric_no == '':
[1252]	920	result['Error'] = "Empty matric_no"
[1146]	921	no_import.append( format_error % result)
	922	continue
[1168]	923	if key in regs or self.results_import(key = key):
[1252]	924	result['Error'] = "Duplicate"
[1146]	925	no_import.append( format_error % result)
	926	continue
	927	if course_id not in courses:
	928	if course_id not in no_course:
	929	course_count +=1
	930	no_course.append(course_id)
	931	no_course_list.append('"%s"' % course_id)
	932	#result['Error'] = "No Course"
	933	#logger.info(format_error % result)
[1829]	934
[1816]	935	result['key'] = key
	936	try:
	937	table.addRecord(**result)
	938	except ValueError:
	939	#import pdb;pdb.set_trace()
	940	result['Error'] = "Duplicate"
	941	no_import.append( format_error % result)
	942	continue
[1829]	943
[1146]	944	regs.append(key)
	945	imported.append(format % result)
	946	tr_count += 1
	947	if tr_count > 1000:
	948	if len(no_import) > 0:
	949	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
[1151]	950	'\n'.join(no_import)+'\n')
[1146]	951	no_import = []
	952	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
[1151]	953	'\n'.join(imported) + '\n')
[1146]	954	imported = []
	955	if no_course_list:
	956	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
[1151]	957	'\n'.join(no_course_list) + '\n')
[1146]	958	no_course_list = []
	959	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
	960	transaction.commit()
	961	logger.info(em)
[1168]	962	regs = []
[1146]	963	total += tr_count
	964	tr_count = 0
	965	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	966	'\n'.join(imported))
	967	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	968	'\n'.join(no_import))
	969	if no_course_list:
	970	open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
	971	'\n'.join(no_course_list))
[1393]	972	em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
	973	logger.info(em)
[1146]	974	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	975	###)
	976
[1065]	977	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
	978	def updateStudyCourse(self):
	979	"""update StudyCourse from CSV values"""
	980	import transaction
	981	import random
	982	from pdb import set_trace
	983	wftool = self.portal_workflow
[1802]	984	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	985	students_folder = self.portal_url.getPortalObject().campus.students
[1065]	986	csv_d = {'jamb_reg_no': "RegNumber",
	987	'jamb_lastname': "Name",
	988	'session': "Session",
	989	'pume_tot_score': "PUME SCORE",
	990	'jamb_score': "JambScore",
	991	'jamb_sex': "Sex",
	992	'jamb_state': "State",
	993	## 'jamb_first_cos': "AdminCourse",
	994	'faculty': "AdminFaculty",
	995	'course_code': "AdmitCoscode",
	996	'stud_status':"AdmitStatus",
	997	'department': "AdmitDept",
	998	'jamb_lga': "LGA",
	999	'app_email': "email",
	1000	'app_mobile': "PhoneNumbers",
	1001	}
	1002	csv_fields = [f[1] for f in csv_d.items()]
	1003	tr_count = 0
	1004	total = 0
	1005	#name = 'pume_results'
	1006	name = 'StudyCourseChange'
	1007	no_import = []
[1321]	1008	s = ','.join(['"%s"' % fn for fn in csv_fields])
[1065]	1009	no_import.append('"Error",%s' % s)
	1010	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	1011	no_certificate = "no certificate %s" % format
	1012	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
	1013	'\n'.join(no_import))
[1571]	1014	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
[1065]	1015	logger.info('Start loading from %s.csv' % name)
	1016	l = self.portal_catalog({'meta_type': "Certificate"})
	1017	try:
	1018	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1019	except:
	1020	logger.error('Error reading %s.csv' % name)
	1021	return
	1022	for jamb in result:
	1023	jamb['Error'] = "Processing "
	1024	logger.info(format % jamb)
	1025	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
	1026	res = self.portal_catalog({'portal_type': "StudentApplication",
	1027	'SearchableText': jamb_reg_no })
	1028	if not res:
[1571]	1029	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
[1065]	1030	logger.info(em)
[1571]	1031	jamb['Error'] = "Student does not exist"
[1065]	1032	no_import.append(format % jamb)
	1033	continue
	1034	sid = res[0].getPath().split('/')[-2]
	1035	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
	1036	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
	1037	if not res:
	1038	em = 'No Certificate with ID %s \n' % cert_id
	1039	logger.info(em)
	1040	jamb['Error'] = "No Certificate %s" % cert_id
	1041	no_import.append( format % jamb)
	1042	continue
	1043	cert_brain = res[0]
	1044	catalog_entry = {}
	1045	student = getattr(self,sid)
	1046	#
	1047	# Study Course
	1048	#
	1049	study_course = student.study_course
	1050	dsc = {}
	1051	cert_pl = cert_brain.getPath().split('/')
	1052	catalog_entry['id'] = sid
	1053	catalog_entry['faculty'] = cert_pl[-4]
	1054	catalog_entry['department'] = cert_pl[-3]
	1055	catalog_entry['course'] = cert_id
	1056	dsc['study_course'] = cert_id
	1057	study_course.getContent().edit(mapping=dsc)
	1058	self.students_catalog.modifyRecord(**catalog_entry)
	1059	if tr_count > 10:
	1060	if len(no_import) > 1:
	1061	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
	1062	'\n'.join(no_import))
	1063	no_import = []
	1064	em = '%d transactions commited\n' % tr_count
	1065	transaction.commit()
	1066	logger.info(em)
	1067	total += tr_count
	1068	tr_count = 0
	1069	tr_count += 1
	1070	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1071	###)
	1072
[1594]	1073	security.declareProtected(View,"fixOwnership") ###(
[511]	1074	def fixOwnership(self):
	1075	"""fix Ownership"""
	1076	for s in self.portal_catalog(meta_type = 'Student'):
	1077	student = s.getObject()
	1078	sid = s.getId
	1079	import pdb;pdb.set_trace()
	1080	student.application.manage_setLocalRoles(sid, ['Owner',])
	1081	student.personal.manage_setLocalRoles(sid, ['Owner',])
[1594]	1082	###)
[603]	1083
[1594]	1084	security.declareProtected(View,"Title") ###(
[364]	1085	def Title(self):
	1086	"""compose title"""
[382]	1087	return "Student Section"
[1594]	1088	###)
[361]	1089
[1700]	1090	def generateStudentId(self,letter,students = None): ###(
[714]	1091	import random
	1092	r = random
[1700]	1093	if students is None:
	1094	students = self.portal_url.getPortalObject().campus.students
[714]	1095	if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
	1096	letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
	1097	sid = "%c%d" % (letter,r.randint(99999,1000000))
	1098	while hasattr(students, sid):
	1099	sid = "%c%d" % (letter,r.randint(99999,1000000))
[758]	1100	return sid
[714]	1101	#return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
	1102	###)
	1103
[361]	1104	InitializeClass(StudentsFolder)
	1105
[1594]	1106	def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
[361]	1107	"""Add a Student."""
	1108	ob = StudentsFolder(id, **kw)
	1109	return CPSBase_adder(container, ob, REQUEST=REQUEST)
[1594]	1110	###)
	1111
[361]	1112	###)
	1113
[57]	1114	class Student(CPSDocument): ###(
	1115	"""
[154]	1116	WAeUP Student container for the various student data
[57]	1117	"""
	1118	meta_type = 'Student'
	1119	portal_type = meta_type
	1120	security = ClassSecurityInfo()
[154]	1121
[152]	1122	security.declareProtected(View,"Title")
	1123	def Title(self):
	1124	"""compose title"""
[153]	1125	reg_nr = self.getId()[1:]
[362]	1126	data = getattr(self,'personal',None)
[152]	1127	if data:
	1128	content = data.getContent()
[1143]	1129	return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
[472]	1130	data = getattr(self,'application',None)
[464]	1131	if data:
	1132	content = data.getContent()
	1133	return "%s" % (content.jamb_lastname)
[152]	1134	return self.title
[154]	1135
[511]	1136	security.declarePrivate('makeStudentMember') ###(
	1137	def makeStudentMember(self,sid,password='uNsEt'):
	1138	"""make the student a member"""
	1139	membership = self.portal_membership
[603]	1140	membership.addMember(sid,
[511]	1141	password ,
	1142	roles=('Member',
	1143	'Student',
[522]	1144	),
[511]	1145	domains='',
[904]	1146	properties = {'memberareaCreationFlag': False,
	1147	'homeless': True},)
[511]	1148	member = membership.getMemberById(sid)
	1149	self.portal_registration.afterAdd(member, sid, password, None)
	1150	self.manage_setLocalRoles(sid, ['Owner',])
	1151
	1152	###)
	1153
[764]	1154	security.declareProtected(View,'createSubObjects') ###(
	1155	def createSubObjects(self):
	1156	"""make the student a member"""
	1157	dp = {'Title': 'Personal Data'}
	1158	app_doc = self.application.getContent()
	1159	names = app_doc.jamb_lastname.split()
	1160	if len(names) == 3:
	1161	dp['firstname'] = names[0].capitalize()
	1162	dp['middlename'] = names[1].capitalize()
	1163	dp['lastname'] = names[2].capitalize()
	1164	elif len(names) == 2:
	1165	dp['firstname'] = names[0].capitalize()
	1166	dp['lastname'] = names[1].capitalize()
	1167	else:
	1168	dp['lastname'] = app_doc.jamb_lastname
	1169	dp['sex'] = app_doc.jamb_sex == 'F'
	1170	dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
	1171	proxy = self.aq_parent
	1172	proxy.invokeFactory('StudentPersonal','personal')
	1173	per = proxy.personal
	1174	per_doc = per.getContent()
	1175	per_doc.edit(mapping = dp)
[927]	1176	per.manage_setLocalRoles(proxy.getId(), ['Owner',])
[764]	1177	#self.portal_workflow.doActionFor(per,'open',dest_container=per)
[603]	1178
[511]	1179	###)
	1180
[57]	1181	InitializeClass(Student)
	1182
	1183	def addStudent(container, id, REQUEST=None, **kw):
	1184	"""Add a Student."""
	1185	ob = Student(id, **kw)
	1186	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1187
	1188	###)
[91]	1189
[639]	1190	class StudentAccommodation(CPSDocument): ###(
	1191	"""
	1192	WAeUP Student container for the various student data
	1193	"""
	1194	meta_type = 'StudentAccommodation'
	1195	portal_type = meta_type
	1196	security = ClassSecurityInfo()
	1197
	1198	security.declareProtected(View,"Title")
	1199	def Title(self):
	1200	"""compose title"""
	1201	content = self.getContent()
	1202	#return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
	1203	return "Accommodation Data for Session %s" % content.session
	1204
	1205
	1206	InitializeClass(StudentAccommodation)
	1207
	1208	def addStudentAccommodation(container, id, REQUEST=None, **kw):
	1209	"""Add a Students personal data."""
	1210	ob = StudentAccommodation(id, **kw)
	1211	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1212
	1213	###)
	1214
[89]	1215	class StudentPersonal(CPSDocument): ###(
	1216	"""
[154]	1217	WAeUP Student container for the various student data
[89]	1218	"""
	1219	meta_type = 'StudentPersonal'
	1220	portal_type = meta_type
	1221	security = ClassSecurityInfo()
[152]	1222
	1223	security.declareProtected(View,"Title")
	1224	def Title(self):
	1225	"""compose title"""
	1226	content = self.getContent()
[364]	1227	#return "Personal Data for %s %s" % (content.firstname,content.lastname)
	1228	return "Personal Data"
[152]	1229
[154]	1230
[89]	1231	InitializeClass(StudentPersonal)
	1232
	1233	def addStudentPersonal(container, id, REQUEST=None, **kw):
	1234	"""Add a Students personal data."""
	1235	ob = StudentPersonal(id, **kw)
	1236	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1237
	1238	###)
	1239
[423]	1240	class StudentClearance(CPSDocument): ###(
	1241	"""
	1242	WAeUP Student container for the various student data
	1243	"""
	1244	meta_type = 'StudentClearance'
	1245	portal_type = meta_type
	1246	security = ClassSecurityInfo()
	1247
	1248	security.declareProtected(View,"Title")
	1249	def Title(self):
	1250	"""compose title"""
	1251	content = self.getContent()
[840]	1252	#return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
	1253	return "Clearance/Eligibility Record"
[423]	1254
	1255
	1256	InitializeClass(StudentClearance)
	1257
	1258	def addStudentClearance(container, id, REQUEST=None, **kw):
	1259	"""Add a Students personal data."""
	1260	ob = StudentClearance(id, **kw)
	1261	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1262
	1263	###)
	1264
[454]	1265	class StudentStudyLevel(CPSDocument): ###(
	1266	"""
	1267	WAeUP Student container for the various student data
	1268	"""
	1269	meta_type = 'StudentStudyLevel'
	1270	portal_type = meta_type
	1271	security = ClassSecurityInfo()
	1272
	1273	security.declareProtected(View,"Title")
	1274	def Title(self):
	1275	"""compose title"""
	1276	return "Level %s" % self.aq_parent.getId()
	1277
[1700]	1278	def create_course_results(self,cert_id,current_level): ###(
[1649]	1279	"create all courses in a level"
	1280	aq_portal = self.portal_catalog.evalAdvancedQuery
	1281	res = self.portal_catalog(portal_type="Certificate", id = cert_id)
	1282	l = []
	1283	import transaction
	1284	if res:
	1285	cert = res[0]
	1286	path = cert.getPath()
	1287	query = Eq("path","%s/%s" % (path,current_level)) &\
	1288	Eq('portal_type','CertificateCourse')
	1289	courses = aq_portal(query)
	1290	#from pdb import set_trace;set_trace()
	1291	self_proxy = self.aq_parent
	1292	for c in courses:
	1293	d = self.getCourseInfo(c.getId)
	1294	cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
	1295	course_result = getattr(self_proxy,cr_id)
	1296	self.portal_workflow.doActionFor(course_result,'open')
	1297	d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
	1298	course_result.getContent().edit(mapping=d)
[1820]	1299	#transaction.commit()
[1700]	1300	###)
[472]	1301
[454]	1302	InitializeClass(StudentStudyLevel)
	1303
	1304	def addStudentStudyLevel(container, id, REQUEST=None, **kw):
	1305	"""Add a Students personal data."""
	1306	ob = StudentStudyLevel(id, **kw)
	1307	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1308
	1309	###)
	1310
[362]	1311	class StudentStudyCourse(CPSDocument): ###(
	1312	"""
	1313	WAeUP Student container for the various student data
	1314	"""
	1315	meta_type = 'StudentStudyCourse'
	1316	portal_type = meta_type
	1317	security = ClassSecurityInfo()
	1318
[364]	1319	security.declareProtected(View,"Title")
	1320	def Title(self):
	1321	"""compose title"""
	1322	content = self.getContent()
[453]	1323	return "Study Course"
[362]	1324
	1325
	1326	InitializeClass(StudentStudyCourse)
	1327
	1328	def addStudentStudyCourse(container, id, REQUEST=None, **kw):
	1329	"""Add a Students personal data."""
	1330	ob = StudentStudyCourse(id, **kw)
	1331	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1332
	1333	###)
	1334
[472]	1335	class StudentApplication(CPSDocument): ###(
[179]	1336	"""
	1337	WAeUP Student container for the various student data
	1338	"""
[472]	1339	meta_type = 'StudentApplication'
[179]	1340	portal_type = meta_type
	1341	security = ClassSecurityInfo()
	1342
[181]	1343	security.declareProtected(View,"Title")
	1344	def Title(self):
	1345	"""compose title"""
[472]	1346	return "Application Data"
[179]	1347
[181]	1348
[472]	1349	InitializeClass(StudentApplication)
[179]	1350
[472]	1351	def addStudentApplication(container, id, REQUEST=None, **kw):
[179]	1352	"""Add a Students eligibility data."""
[472]	1353	ob = StudentApplication(id, **kw)
[179]	1354	return CPSBase_adder(container, ob, REQUEST=REQUEST)
[763]	1355	###)
[179]	1356
[758]	1357	class StudentPume(CPSDocument): ###(
	1358	"""
	1359	WAeUP Student container for the various student data
	1360	"""
	1361	meta_type = 'StudentPume'
	1362	portal_type = meta_type
	1363	security = ClassSecurityInfo()
	1364
	1365	security.declareProtected(View,"Title")
	1366	def Title(self):
	1367	"""compose title"""
	1368	return "PUME Results"
	1369
	1370
	1371	InitializeClass(StudentPume)
	1372
	1373	def addStudentPume(container, id, REQUEST=None, **kw):
	1374	"""Add a Students PUME data."""
	1375	ob = StudentPume(id, **kw)
	1376	return CPSBase_adder(container, ob, REQUEST=REQUEST)
[179]	1377	###)
[181]	1378
[565]	1379	##class StudentSemester(CPSDocument): ###(
	1380	## """
	1381	## WAeUP StudentSemester containing the courses and students
	1382	## """
	1383	## meta_type = 'StudentSemester'
	1384	## portal_type = meta_type
	1385	## security = ClassSecurityInfo()
	1386	##
	1387	##InitializeClass(StudentSemester)
	1388	##
	1389	##def addStudentSemester(container, id, REQUEST=None, **kw):
	1390	## """Add a StudentSemester."""
	1391	## ob = StudentSemester(id, **kw)
	1392	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1393	##
	1394	#####)
[464]	1395
[758]	1396	##class Semester(CPSDocument): ###(
	1397	## """
	1398	## WAeUP Semester containing the courses and students
	1399	## """
	1400	## meta_type = 'Semester'
	1401	## portal_type = meta_type
	1402	## security = ClassSecurityInfo()
	1403	##
	1404	##InitializeClass(Semester)
	1405	##
	1406	##def addSemester(container, id, REQUEST=None, **kw):
	1407	## """Add a Semester."""
	1408	## ob = Semester(id, **kw)
	1409	## return CPSBase_adder(container, ob, REQUEST=REQUEST)
	1410	##
	1411	#####)
[464]	1412
	1413	class StudentCourseResult(CPSDocument): ###(
[89]	1414	"""
[464]	1415	WAeUP StudentCourseResult
[89]	1416	"""
[464]	1417	meta_type = 'StudentCourseResult'
[89]	1418	portal_type = meta_type
	1419	security = ClassSecurityInfo()
[472]	1420
[454]	1421	def getCourseEntry(self,cid):
[723]	1422	res = self.portal_catalog({'meta_type': "Course",
[454]	1423	'id': cid})
	1424	if res:
	1425	return res[-1]
	1426	else:
	1427	return None
[154]	1428
[454]	1429	security.declareProtected(View,"Title")
	1430	def Title(self):
	1431	"""compose title"""
[723]	1432	cid = self.aq_parent.getId()
[454]	1433	ce = self.getCourseEntry(cid)
	1434	if ce:
	1435	return "%s" % ce.Title
	1436	return "No course with id %s" % cid
[152]	1437
[464]	1438	InitializeClass(StudentCourseResult)
[454]	1439
[464]	1440	def addStudentCourseResult(container, id, REQUEST=None, **kw):
	1441	"""Add a StudentCourseResult."""
	1442	ob = StudentCourseResult(id, **kw)
[89]	1443	return CPSBase_adder(container, ob, REQUEST=REQUEST)
[139]	1444	###)
	1445
[579]	1446	# Backward Compatibility StudyLevel
	1447
	1448	from Products.WAeUP_SRP.Academics import StudyLevel
	1449
	1450	from Products.WAeUP_SRP.Academics import addStudyLevel
	1451

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

Download in other formats: