Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1890

Last change on this file since 1890 was 1889, checked in by Henrik Bettermann, 18 years ago
commit 100
Property svn:keywords set to `Id`
File size: 57.2 KB

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

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

Download in other formats: