Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1892

Last change on this file since 1892 was 1892, checked in by joachim, 17 years ago
mostly interswitch integration
Property svn:keywords set to `Id`
File size: 57.5 KB

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

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

Download in other formats: