Context navigation

source: WAeUP_SRP/trunk/Students.py @ 1805

Last change on this file since 1805 was 1805, checked in by Henrik Bettermann, 18 years ago
preparations for viewing CEST results
Property svn:keywords set to `Id`
File size: 49.2 KB

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

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

Download in other formats: