Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1812

Last change on this file since 1812 was 1809, checked in by Henrik Bettermann, 18 years ago
set current_level correctly
Property svn:keywords set to `Id`
File size: 49.3 KB

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

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

Download in other formats: