Context navigation

source: WAeUP_SRP/base/Students.unused_methods.txt @ 2666

Last change on this file since 2666 was 2654, checked in by Henrik Bettermann, 17 years ago
move unused methods from Students.py
File size: 107.6 KB

Rev	Line
[1571]	1	security.declareProtected(ModifyPortalContent,"loadFullTimeStudentsFromCSV")###(
	2	def loadFullTimeStudentsFromCSV(self):
	3	"""load Fulltime Studentdata from CSV values"""
	4	import transaction
	5	import random
	6	tr_count = 0
	7	name = 'short_full_time'
	8	no_import = False
	9	if not no_import:
	10	no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
	11	no_import.write('"MatricNo","EntryRegNo","CurrentSession","StudentLevel","fullname","FirstName","MiddleName","Lastname","FormerSurname","Sex","Nationality","State","LGA","PermanentAddress","PermanentAddressCity","CampusAddress","PhoneNumber","Emailaddress","Mode","CourseMajor","Faculty","Dept"\n')
	12	logger = logging.getLogger('Import.%s' % name)
	13	logger.info('Start loading from %s.csv' % name)
	14	pwlist = []
	15	pwlist.append('"student_id","firstname","middlename","lastname","matric_no","jamb_reg_no","access_code"')
	16	pwl_template = Template('"$student_id","$firstname","$middlename","$lastname","$matric_no","$jamb_reg_no","$access_code"')
	17	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	18	try:
	19	students = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	20	except:
	21	logger.error('Error reading %s.csv' % name)
	22	return
	23	l = self.portal_catalog({'meta_type': "StudentClearance",})
	24	matrics = []
	25	for s in l:
	26	matrics.append(s.getObject().getContent().matric_no)
	27	print matrics
	28	l = self.portal_catalog({'meta_type': "Certificate"})
	29	certs = {}
	30	for c in l:
	31	ca,ac,fa,dep_id,co,certcode = c.relative_path.split('/')
	32	cid = "%(dep_id)s_%(certcode)s" % vars()
	33	certs[cid] = c.getObject()
	34	for student in students:
	35	logger.info('processing "%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
	36	sid = student.get('MatricNo')
	37	if sid == "":
	38	em = 'Empty MatricNo\n'
	39	logger.info(em)
	40	no_import.write(em)
	41	no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
	42	continue
	43	certcode = makeCertificateCode(student.get('CourseMajor'))
	44	dep_id = student.get('Dept')
	45	fac_id = student.get('Faculty')
	46	cid = "%(dep_id)s_%(certcode)s" % vars()
	47	if cid not in certs.keys():
	48	em = 'Certificate with ID %s %s not found\n' % (certcode, student.get('CourseMajor'))
	49	logger.info(em)
	50	no_import.write(em)
	51	no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
	52	continue
	53	certificate_doc = certs[cid].getContent()
	54	level = student.get('StudentLevel')
	55	try:
	56	int(level)
	57	except:
	58	em = 'Student with ID %(MatricNo)s StudentLevel is empty\n' % student
	59	logger.info(em)
	60	no_import.write(em)
	61	no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
	62	continue
	63	matric_no = student.get('MatricNo')
	64	if matric_no not in matrics:
	65	matrics.append(matric_no)
	66	sid = self.generateStudentId(student.get('Lastname')[0])
	67	#self.log('Creating Faculty %(id)s = %(Title)s' % faculty)
	68	students_folder.invokeFactory('Student', sid)
	69	logger.info('%(tr_count)s: Creating Student with ID %(sid)s Matric_no %(matric_no)s ' % vars())
	70	student_obj = getattr(self,sid)
	71	access_code = "%d" % random.randint(1000000000,9999999999)
	72	student_obj.getContent().makeStudentMember(sid,access_code,)
	73	pwl_dict = {'student_id': sid,'access_code':access_code}
	74	student_obj.invokeFactory('StudentApplication','application')
	75	application = student_obj.application
	76	da = {'Title': 'Application Data'}
	77	student_obj.invokeFactory('StudentPersonal','personal')
	78	da['jamb_reg_no'] = student.get('EntryRegNo')
	79	personal = student_obj.personal
	80	dp = {'Title': 'Personal Data'}
	81	student_obj.invokeFactory('StudentClearance','clearance')
	82	clearance = student_obj.clearance
	83	dc = {'Title': 'Clearance/Eligibility Record'}
	84	dc['matric_no'] = matric_no
	85	state = student.get('State')
	86	lga = student.get('LGA')
	87	if state and lga:
	88	lga = state + ' / ' + lga
	89	else:
	90	lga = "None"
	91	dc['lga'] = lga
	92	dc['nationality'] = student.get('Nationality')
	93	dc['email'] = student.get('Emailaddress')
	94	dp['firstname'] = student.get('FirstName')
	95	dp['middlename'] = student.get('MiddleName')
	96	dp['lastname'] = student.get('Lastname')
	97	dp['former_surname'] = student.get('FormerSurname')
	98	dp['sex'] = student.get('Sex') == 'F'
	99	dp['perm_address'] = student.get('PermanentAddress')
	100	dp['perm_city'] = student.get('PermanentAddressCity')
	101	dp['campus_address'] = student.get('CampusAddress')
	102	dp['phone'] = student.get('PhoneNumber')
	103	application.getContent().edit(mapping=da)
	104	personal.getContent().edit(mapping=dp)
	105	clearance.getContent().edit(mapping=dc)
	106	#
	107	# Study Course
	108	#
	109	student_obj.invokeFactory('StudentStudyCourse','study_course')
	110	studycourse = student_obj.study_course
	111	dsc = {}
	112	from_certificate = ['title',
	113	'max_elect',
	114	'max_pass',
	115	'n_core',
	116	'nr_years',
	117	'probation_credits',
	118	'promotion_credits',
	119	'start_level',
	120	]
	121	for f in from_certificate:
	122	dsc[f] = getattr(certificate_doc,f)
	123	dsc['faculty'] = fac_id
	124	dsc['department'] = dep_id
	125	dsc['study_course'] = certcode
	126	css = student.get('CurrentSession') or '2004-2005'
	127	cs = int(css.split('-')[0]) - 2000
	128	cl = int(student.get('StudentLevel') or '100')/100
	129	dsc['entry_session'] = "200%s" % (cs - cl)
	130	dsc['clr_ac_pin'] = access_code
	131	studycourse.getContent().edit(mapping=dsc)
	132	#
	133	# Level
	134	#
	135	## l = getattr(studycourse,level,None)
	136	## if 0 and l is None:
	137	## #self.log('Creating Department %(DeptCode)s = %(Description)s' % dep)
	138	## logger.info('Creating Level %(StudentLevel)s for %(fullname)s' % student)
	139	## studycourse.invokeFactory('StudentStudyLevel', level)
	140	## l = getattr(studycourse, level)
	141	## certificate = certs[certcode]
	142	## cert_level = getattr(certificate,level,None)
	143	## if cert_level is None:
	144	## logger.info('Level %(level)s not in %(certcode)s' % vars())
	145	## l.getContent().edit(mapping={'Title': "Level %s" % level})
	146	else:
	147	em = 'Student with ID %(MatricNo)s %(fullname)s already exists\n' % student
	148	logger.info(em)
	149	no_import.write(em)
	150	no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
	151	continue
	152	if tr_count > MAX_TRANS:
	153	transaction.commit()
	154	em = 'Transaction commited\n' % student
	155	logger.info(em)
	156	tr_count = 0
	157	tr_count += 1
	158	pwl_dict.update(dc)
	159	pwl_dict.update(da)
	160	pwl_dict.update(dp)
	161	wftool = self.portal_workflow
	162	pwlist.append(pwl_template.substitute(pwl_dict))
	163	wftool.doActionFor(student_obj,'clear_and_validate')
	164	student_obj.manage_setLocalRoles(sid, ['Owner',])
	165	wftool.doActionFor(application,'close')
	166	application.manage_setLocalRoles(sid, ['Owner',])
	167	wftool.doActionFor(clearance,'close')
	168	clearance.manage_setLocalRoles(sid, ['Owner',])
	169	wftool.doActionFor(personal,'close')
	170	personal.manage_setLocalRoles(sid, ['Owner',])
	171	wftool.doActionFor(studycourse,'close_for_edit')
	172	studycourse.manage_setLocalRoles(sid, ['Owner',])
	173	open("%s/import/pwlist-%s.csv" % (i_home,name),"w+").write('\n'.join(pwlist))
	174	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	175	###)
	176
	177	security.declareProtected(ModifyPortalContent,"loadPumeResultsFromCSV")###(
	178	def loadPumeResultsFromCSV(self):
	179	"""load Fulltime Studentdata from CSV values into pumeresults catalog"""
	180	import transaction
	181	import random
	182	## csv_d = {'jamb_reg_no': "RegNumber", ###(
	183	## 'status': "Admission Status",
	184	## 'name': "Name",
	185	## 'score': "Score",
	186	## 'sex': "Sex",
	187	## 'faculty': "Faculty",
	188	## 'department': "Dept",
	189	## 'course': "Course",
	190	## 'course_code_org': "Course Code",
	191	## }
	192	###)
	193	csv_d = {'jamb_reg_no': "JAMBRegno",
	194	'name': "Name",
	195	'score': "Score",
	196	'sex': "Sex",
	197	'course': "Course",
	198	'faculty': "Faculty",
	199	'department': "Dept",
	200	'course_code_org': "Course Code",
	201	'status': "Admission Status",
	202	'result_type': None,
	203	}
	204	csv_fields = [f[1] for f in csv_d.items() if f[1]]
	205	tr_count = 0
	206	total = 0
	207	#name = 'pup_new'
	208	name = 'pup_update'
	209	update = name.endswith('update')
	210	no_import = []
	211	ok_import = []
	212	ok_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_d.keys()]))
	213	no_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_fields]))
	214	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	215	ok_import_name = "%s/import/%s_imported_%s.csv" % (i_home,name,current)
	216	#open(ok_import_name,"w").write('\n'.join(no_import))
	217	no_import_name = "%s/import/%s_not_imported_%s.csv" % (i_home,name,current)
	218	#open(no_import_name,"w").write('\n'.join(no_import))
	219	logger = logging.getLogger('Import.%s' % name)
	220	starttime = DateTime.now()
	221	logger.info('Start loading from %s.csv' % name)
	222	try:
	223	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	224	except:
	225	logger.error('Error reading %s.csv' % name)
	226	return
	227	pume = self.portal_pumeresults
	228	format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	229	import_format = ','.join(['"%%(%s)s"' % fn for fn in csv_d.keys()])
	230	eduplicate = '%s,"duplicate"' % format
	231	einvalidjamb = '%s,"invalid JambRegNo"' % format
	232	added = 'added ,%s' % format
	233	#from pdb import set_trace;set_trace()
	234	for jamb in result:
	235	dict = {}
	236	for f,fn in csv_d.items():
	237	dict[f] = jamb.get(csv_d[f])
	238	dict['result_type'] = 'DE'
	239	jnr = jamb.get(csv_d['jamb_reg_no'])
	240	if not checkJambNo(jnr):
	241	logger.info(einvalidjamb % jamb)
	242	dd = {}
	243	for f,fn in csv_d.items():
	244	dd[fn] = getattr(data,f)
	245	no_import.append(eduplicate % dd)
	246	no_import.append(eduplicate % jamb)
	247	continue
	248	res = pume(jamb_reg_no=jnr)
	249	if len(res) > 0:
	250	if update:
	251	try:
	252	pume.modifyRecord(**dict)
	253	except ValueError:
	254	logger.info(eduplicate % jamb)
	255	continue
	256	except KeyError:
	257	pume.addRecord(**dict)
	258	logger.info(added % jamb)
	259	continue
	260	else:
	261	data = res[0]
	262	if data.name != jamb.get(csv_d['name']):
	263	#set_trace()
	264	logger.info(eduplicate % jamb)
	265	#em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
	266	#logger.info(em)
	267	dd = {}
	268	for f,fn in csv_d.items():
	269	dd[fn] = getattr(data,f)
	270	no_import.append(eduplicate % dd)
	271	no_import.append(eduplicate % jamb)
	272	continue
	273	try:
	274	pume.addRecord(**dict)
	275	ok_import.append(import_format % dict)
	276	except ValueError:
	277	logger.info(eduplicate % jamb)
	278	#em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
	279	#logger.info(em)
	280	no_import.append(eduplicate % jamb)
	281	logger.info('End loading from %s.csv' % name)
	282	if len(no_import) > 1:
	283	open(no_import_name,"w+").write('\n'.join(no_import))
	284	open(ok_import_name,"w+").write('\n'.join(ok_import))
	285	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	286	###)
	287
	288
	289	security.declareProtected(ModifyPortalContent,"OLDloadPumeResultsFromCSV")###(
	290	def OLDloadPumeResultsFromCSV(self):
	291	"""load Fulltime Studentdata from CSV values"""
	292	import transaction
	293	import random
	294	wftool = self.portal_workflow
	295	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	296	csv_d = {'jamb_reg_no': "JAMBRegno",
	297	'jamb_lastname': "Name",
	298	'pume_options': "Options",
	299	'session': "Session",
	300	'days': "Days",
	301	'response': "Responce",
	302	'wrong': "Wrong",
	303	'pume_eng_score': "EngScore",
	304	'pume_gen_score': "GenScore",
	305	'pume_tot_score': "Score",
	306	'batch': "Batch",
	307	'serial': "SerialNo",
	308	'jamb_score': "JambScore",
	309	'omitted':"Omitted",
	310	'search_key': "SearchKey",
	311	'jamb_sex': "Sex",
	312	'fac1': "Fac1",
	313	'fac2': "Fac2",
	314	'jamb_first_cos': "CourseofStudy",
	315	'stud_status':"StudStatus",
	316	'registered': "Registered",
	317	'jamb_state': "State",
	318	'eng_fail': "EngFail",
	319	'gen_fail': "GenFail",
	320	'un_ans_eng': "UnAnsEng",
	321	'un_ans_eng': "UnAnsGen",
	322	'total_ans': "TotalUnAns",
	323	'dept': "Dept",
	324	'jamb_second_cos': "Course2",
	325	'jamb_third_cos': "course3",
	326	}
	327	csv_fields = [f[1] for f in csv_d.items()]
	328	tr_count = 0
	329	name = 'pume_results'
	330	no_import = []
	331	s = ','.join(['"%s"' % fn for fn in csv_fields])
	332	no_import.append('%s\n' % s)
	333	logger = logging.getLogger('Import.%s' % name)
	334	logger.info('Start loading from %s.csv' % name)
	335	try:
	336	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	337	except:
	338	logger.error('Error reading %s.csv' % name)
	339	return
	340	for jamb in result:
	341	format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	342	processing = "processing %s" % format
	343	logger.info(processing % jamb)
	344	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
	345	#import pdb;pdb.set_trace()
	346	res = self.portal_catalog({'portal_type': "StudentApplication",
	347	'jamb_reg_no': jamb_reg_no })
	348	if res:
	349	em = 'Student with REG-NO %s already exists\n' % jamb_reg_no
	350	logger.info(em)
	351	no_import.append(em)
	352	no_import.append(format % jamb)
	353	continue
	354	cert_id = jamb.get(csv_d['jamb_first_cos']).upper()
	355	res = self.portal_catalog({'portal_type': "Certificate",
	356	'id': cert_id })
	357	if len(res) < 1:
	358	em = 'No Certificate with ID %s \n' % cert_id
	359	logger.info(em)
	360	no_import.append(em)
	361	no_import.append(format % jamb)
	362	continue
	363	cert = res[0].getObject()
	364	cert_path = res[0].getPath()
	365	cert_doc = cert.getContent()
	366	jamb_name = jamb.get(csv_d['jamb_lastname'])
	367	jamb_name.replace('>','')
	368	names = jamb_name.split()
	369	letter = names[-1][0].upper()
	370	sid = self.generateStudentId(letter)
	371	not_created = True
	372	while not_created:
	373	try:
	374	students_folder.invokeFactory('Student', sid)
	375	not_created = False
	376	except BadRequest:
	377	sid = self.generateStudentId(letter)
	378	logger.info('%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
	379	student = getattr(self,sid)
	380	student.manage_setLocalRoles(sid, ['Owner',])
	381	student.invokeFactory('StudentClearance','clearance')
	382	#wftool.doActionFor(student.clearance,'open')
	383	dp = {'Title': 'Clearance/Eligibility Record'}
	384	student.clearance.manage_setLocalRoles(sid, ['Owner',])
	385	student.invokeFactory('StudentPume','pume')
	386	dp = {'Title': 'Pume Data'}
	387	student.invokeFactory('StudentApplication','application')
	388	da = {'Title': 'Application Data'}
	389	da["jamb_lastname"] = jamb_name
	390	da_fields = ('jamb_reg_no',
	391	'jamb_sex',
	392	'jamb_state',
	393	'jamb_score',
	394	'jamb_first_cos',
	395	'jamb_sex',
	396	'jamb_state',
	397	'jamb_first_cos',
	398	'jamb_second_cos',
	399	)
	400	for f in da_fields:
	401	da[f] = jamb.get(csv_d[f])
	402	app = student.application
	403	app.getContent().edit(mapping=da)
	404	app.manage_setLocalRoles(sid, ['Owner',])
	405	#wftool.doActionFor(app,'close')
	406	dp_fields = (
	407	'pume_eng_score',
	408	'pume_gen_score',
	409	'pume_tot_score',
	410	)
	411	for f in dp_fields:
	412	dp[f] = float(jamb.get(csv_d[f]))
	413	pume = student.pume
	414	pume.getContent().edit(mapping=dp)
	415	#wftool.doActionFor(pume,'close')
	416	pume.manage_setLocalRoles(sid, ['Owner',])
	417	#
	418	# Study Course
	419	#
	420	student.invokeFactory('StudentStudyCourse','study_course')
	421	study_course = student.study_course
	422	dsc = {}
	423	from_certificate = ['title',
	424	'max_elect',
	425	'max_pass',
	426	'n_core',
	427	'nr_years',
	428	'probation_credits',
	429	'promotion_credits',
	430	'start_level',
	431	]
	432	for f in from_certificate:
	433	dsc[f] = getattr(cert_doc,f)
	434	cpl = cert_path.split('/')
	435	dsc['faculty'] = cpl[-4]
	436	dsc['department'] = cpl[-3]
	437	dsc['study_course'] = cert_id
	438	dsc['entry_session'] = jamb.get(csv_d['session'])
	439	study_course.getContent().edit(mapping=dsc)
	440	student.getContent().createSubObjects()
	441	if dp['pume_tot_score']>49:
	442	wftool.doActionFor(student,'pume_pass')
	443	wftool.doActionFor(student,'admit')
	444	else:
	445	wftool.doActionFor(student,'pume_fail')
	446	wftool.doActionFor(student,'reject_admission')
	447	if len(no_import) > 1:
	448	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
	449	'\n'.join(no_import))
	450	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	451	###)
	452
	453	security.declareProtected(ModifyPortalContent,"loadFullTimeStudentsResultsFromCSV") ###(
	454	def loadFullTimeStudentsResultsFromCSV(self):
	455	"""load Fulltime Studentdata from CSV values"""
	456	#return
	457	level_wf_actions = {}
	458	level_wf_actions["SUCCESSFUL STUDENT"] = "pass_A"
	459	level_wf_actions["STUDENT WITH CARRYOVER COURSES"] = "pass_B"
	460	level_wf_actions["STUDENT FOR PROBATION"] = "probate_C"
	461	level_wf_actions["STUDENT ON PROBATION/TRANSFER"] = "reject_D"
	462	import transaction
	463	wftool = self.portal_workflow
	464	tr_count = 0
	465	name = 'short_full_time_results_2004_2005'
	466	no_import = False
	467	if not no_import:
	468	no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
	469	no_import.write('"Matnumber","CosCode","Ansbook","CosStuatus","Session","Mat_Cos","Score","CarryLevel","Grade","Weight","Semster","Verdict","Level","id","GPA"\n')
	470	logger = logging.getLogger('import.%s' % name)
	471	logger.info('Start loading from %s.csv' % name)
	472	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	473	try:
	474	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	475	except:
	476	logger.error('Error reading %s.csv' % name)
	477	return
	478	l = self.portal_catalog({'meta_type': "Course"})
	479	courses = {}
	480	for c in l:
	481	courses[c.id] = c.getObject()
	482	level_changed = False
	483	student_changed = False
	484	sid = ''
	485	#import pdb;pdb.set_trace()
	486	for result in results:
	487	temp_sid = result.get('Matnumber')
	488	if temp_sid != sid:
	489	student_changed = True
	490	res = self.portal_catalog({'meta_type': "StudentClearance",
	491	'SearchableText': temp_sid })
	492	if not res:
	493	em = 'Student with ID %(Matnumber)s not found\n' % result
	494	logger.info(em)
	495	no_import.write(em)
	496	no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
	497	continue
	498	elif len(res) > 1:
	499	em = 'More than one Student with ID %(Matnumber)s found\n' % result
	500	logger.info(em)
	501	no_import.write(em)
	502	no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
	503	continue
	504	sid = temp_sid
	505	sf = res[0].getObject().aq_parent
	506	sc = getattr(sf,'study_course')
	507	level = ''
	508	else:
	509	student_changed = False
	510	course = result.get('CosCode')
	511	if course not in courses.keys():
	512	em = 'Course with ID %(CosCode)s not found\n' % result
	513	logger.info(em)
	514	no_import.write(em)
	515	no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
	516	continue
	517	course_doc = courses[course].getContent()
	518	temp_level = result.get('Level')
	519	student_id = sf.getId()
	520	result['StudentId'] = student_id
	521	if temp_level != level:
	522	try:
	523	int(temp_level)
	524	except:
	525	em = 'Result with ID %(Matnumber)s Course %(CosCode)s Level is empty\n' % result
	526	logger.info(em)
	527	no_import.write(em)
	528	no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
	529	continue
	530	level_changed = True
	531	if 'dlev' in vars().keys():
	532	wftool.doActionFor(l,level_wf_actions[dlev['verdict']])
	533	level = temp_level
	534	l = getattr(sc,level,None)
	535	if l is None:
	536	logger.info('Creating Level %(Level)s for %(StudentId)s %(Matnumber)s' % result)
	537	sc.invokeFactory('StudentStudyLevel', level)
	538	l = getattr(sc, level)
	539	l.manage_setLocalRoles(student_id, ['Owner',])
	540	else:
	541	level_changed = False
	542	cr = getattr(l,course,None)
	543	if cr is None:
	544	logger.info('Creating Course %(CosCode)s for %(StudentId)s %(Matnumber)s in Level %(Level)s' % result)
	545	l.invokeFactory('StudentCourseResult',course)
	546	cr = getattr(l,course)
	547	dcr = {}
	548	from_course = ['title',
	549	'credits',
	550	'passmark',
	551	]
	552	for f in from_course:
	553	dcr[f] = getattr(course_doc,f)
	554	dlev = {}
	555	dcr['ansbook'] = result.get('Ansbook')
	556	dcr['semester'] = getInt(result.get('Semster'))
	557	dcr['status'] = result.get('CosStuatus')
	558	dcr['score'] = getInt(result.get('Score'))
	559	dlev['session'] = result.get('Session')
	560	dcr['carry_level'] = result.get('CarryLevel')
	561	dcr['grade'] = result.get('Grade')
	562	dcr['weight'] = result.get('Weight')
	563	dlev['verdict'] = result.get('Verdict')
	564	dcr['import_id'] = result.get('id')
	565	gpa = result.get('GPA').replace(',','.')
	566	dlev['imported_gpa'] = getFloat(gpa)
	567	cr.getContent().edit(mapping = dcr)
	568	cr.manage_setLocalRoles(student_id, ['Owner',])
	569	l.getContent().edit(mapping = dlev)
	570	if tr_count > MAX_TRANS:
	571	transaction.commit()
	572	tr_count = 0
	573	tr_count += 1
	574	wftool.doActionFor(cr,'close')
	575	wftool.doActionFor(l,level_wf_actions[dlev['verdict']])
	576	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	577
	578	###)
	579
	580	security.declareProtected(ModifyPortalContent,"loadJAMBFromCSV")###(
	581	def loadJAMBFromCSV(self):
	582	"""load JAMB data from CSV values"""
	583	#return
	584	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	585	import transaction
	586	tr_count = 0
	587	name = 'SampleJAMBDataII'
	588	wftool = self.portal_workflow
	589	no_import = False
	590	if not no_import:
	591	no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
	592	no_import.write('REG-NO,NAME,SEX,STATE,LGA,ENG-SCORE,SUBJ1,SUBJ1-SCORE,SUBJ2,SUBJ2-SCORE,SUBJ3,SUBJ3-SCORE,AGGREGATE,UNIV1,FACULTY1,COURSE1,UNIV2,FACULTY2,COURSE2')
	593	logger = logging.getLogger('Import.%s' % name)
	594	logger.info('Start loading from %s.csv' % name)
	595	try:
	596	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	597	except:
	598	logger.error('Error reading %s.csv' % name)
	599	return
	600	for jamb in result:
	601	logger.info('processing %(REG-NO)s,%(NAME)s,%(SEX)s,%(STATE)s,%(LGA)s,%(ENG-SCORE)s,%(SUBJ1)s,%(SUBJ1-SCORE)s,%(SUBJ2)s,%(SUBJ2-SCORE)s,%(SUBJ3)s,%(SUBJ3-SCORE)s,%(AGGREGATE)s,%(UNIV1)s,%(FACULTY1)s,%(COURSE1)s,%(UNIV2)s,%(FACULTY2)s,%(COURSE2)s\n' % jamb)
	602	jamb_reg_no = jamb.get('REG-NO')
	603	res = self.portal_catalog({'meta_type': "StudentApplication",
	604	'jamb_reg_no': jamb_reg_no })
	605	if res:
	606	em = 'Student with REG-NO %(REG-NO)s already exists\n' % jamb
	607	logger.info(em)
	608	no_import.write(em)
	609	no_import.write('%(REG-NO)s,%(NAME)s,%(SEX)s,%(STATE)s,%(LGA)s,%(ENG-SCORE)s,%(SUBJ1)s,%(SUBJ1-SCORE)s,%(SUBJ2)s,%(SUBJ2-SCORE)s,%(SUBJ3)s,%(SUBJ3-SCORE)s,%(AGGREGATE)s,%(UNIV1)s,%(FACULTY1)s,%(COURSE1)s,%(UNIV2)s,%(FACULTY2)s,%(COURSE2)s\n' % jamb)
	610	continue
	611	jamb_name = jamb.get("NAME")
	612	jamb_name.replace('>','')
	613	names = jamb_name.split()
	614	letter = names[-1][0].upper()
	615	sid = self.generateStudentId(letter)
	616	not_created = True
	617	while not_created:
	618	try:
	619	students_folder.invokeFactory('Student', sid)
	620	not_created = False
	621	except BadRequest:
	622	sid = self.generateStudentId(letter)
	623	logger.info('%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
	624	student = getattr(self,sid)
	625	student.manage_setLocalRoles(sid, ['Owner',])
	626	student.invokeFactory('StudentApplication','application')
	627	da = {'Title': 'Application Data'}
	628	da["jamb_reg_no"] = jamb.get("REG-NO")
	629	da["jamb_lastname"] = jamb_name
	630	da["jamb_sex"] = jamb.get("SEX")
	631	da["jamb_state"] = jamb.get("STATE")
	632	da["jamb_lga"] = jamb.get("LGA")
	633	da["jamb_score"] = jamb.get("AGGREGATE")
	634	da["jamb_first_cos"] = jamb.get("COURSE1")
	635	da["jamb_second_cos"] = jamb.get("COURSE2")
	636	da["jamb_first_uni"] = jamb.get("UNIV1")
	637	da["jamb_second_uni"] = jamb.get("UNIV2")
	638	app = student.application
	639	app_doc = app.getContent()
	640	app_doc.edit(mapping=da)
	641	#wftool.doActionFor(app,'open',dest_container=app)
	642	app.manage_setLocalRoles(sid, ['Owner',])
	643	student.getContent().createSubObjects()
	644	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	645	###)
[1775]	646
	647
	648	security.declareProtected(ModifyPortalContent,"importPreviousSessionStudents")###(
	649	def importPreviousSessionStudents(self):
	650	"""load and create previous session students from CSV"""
	651	import transaction
	652	import random
	653	wftool = self.portal_workflow
	654	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	655	students_folder = self.portal_url.getPortalObject().campus.students
	656	tr_count = 1
	657	total = 0
	658	#name = 'pume_results'
	659	name = 'Previous'
	660	keys = self.portal_schemas.import_student.keys()
	661	keys += self.portal_schemas.import_student_level_data.keys()
	662	not_imported = []
	663	imported = []
	664	certificates = {}
	665	logger = logging.getLogger('Students.StudentsFolder.importPreviousSessionStudents')
	666	try:
	667	records = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	668	except:
	669	logger.error('Error reading %s.csv' % name)
	670	return
	671	start = True
	672	for record in records:
	673	if start:
	674	start = False
	675	logger.info('Start loading from %s.csv' % name)
	676	false_keys = [k for k in record.keys() if k not in keys]
	677	right_keys = [k for k in record.keys() if k in keys]
	678	if false_keys:
	679	logger.info('Fields %s not in schema' % false_keys)
	680	s = ','.join(['"%s"' % k for k in right_keys])
	681	imported.append(s)
	682	not_imported.append('%s,"error"' % s)
	683	format = ','.join(['"%%(%s)s"' % k for k in right_keys])
	684	format_error = format + ',"%(error)s"'
	685	study_course = makeCertificateCode(record.get('study_course'))
	686	matric_no = record.get('matric_no')
	687	student_res = self.students_catalog(matric_no = matric_no)
	688	if student_res:
	689	record['error'] = "Student exists"
	690	not_imported.append(format_error % record)
	691	continue
	692	if study_course not in certificates.keys():
	693	cert_res = self.portal_catalog(portal_type='Certificate',
	694	id = study_course)
	695	if not cert_res:
	696	record['error'] = "No such studycourse"
	697	not_imported.append(format_error % record)
	698	continue
	699	certificates[cert_res[0].id] = cert_res[0]
	700	sid = self.generateStudentId('x',students_folder)
	701	students_folder.invokeFactory('Student', sid)
	702	#from pdb import set_trace;set_trace()
	703	record['student_id'] = sid
	704	student = getattr(self,sid)
	705	student.manage_setLocalRoles(sid, ['Owner',])
	706	student.invokeFactory('StudentApplication','application')
	707	app = student.application
	708	app_doc = app.getContent()
	709	dict = {'Title': 'Application Data'}
	710	dict["jamb_lastname"] = "%(firstname)s %(lastname)s %(middlename)s" % record
	711	r2d = [
	712	('entry_mode','entry_mode'),
	713	('sex','jamb_sex'),
	714	('jamb_score','jamb_score'),
	715	('jamb_reg_no','jamb_reg_no'),
	716	]
	717	for r,d in r2d:
	718	dict[d] = record[r]
	719	app_doc.edit(mapping=dict)
	720	app.manage_setLocalRoles(sid, ['Owner',])
	721	wftool.doActionFor(app,'close')
	722	record['sex'] = record['sex'] == 'F'
	723	student.invokeFactory('StudentPersonal','personal')
	724	dict = {}
	725	r2d = [('firstname','firstname'),
	726	('middlename','middlename'),
	727	('lastname','lastname'),
	728	('sex','sex'),
	729	('email','email'),
	730	('phone','phone'),
	731	('address','perm_address'),
	732	]
	733	for r,d in r2d:
	734	dict[d] = record[r]
	735	per = student.personal
	736	per_doc = per.getContent()
	737	per_doc.edit(mapping = dict)
	738	per.manage_setLocalRoles(sid, ['Owner',])
	739	#
	740	# Clearance
	741	#
	742	student.invokeFactory('StudentClearance','clearance')
	743	#wftool.doActionFor(student.clearance,'open')
	744	clearance = getattr(student,'clearance')
	745	dict = {'Title': 'Clearance/Eligibility Record'}
	746	clearance.getContent().edit(mapping = dict)
	747	student.clearance.manage_setLocalRoles(sid, ['Owner',])
	748	#
	749	# Study Course
	750	#
	751	student.invokeFactory('StudentStudyCourse','study_course')
	752	study_course = student.study_course
	753	dict = {}
	754	r2d = [('session','current_session'),
	755	('level','current_level'),
	756	('verdict','current_verdict'),
	757	('study_course','study_course'),
	758	]
	759	for r,d in r2d:
	760	dict[d] = record[r]
	761	study_course.getContent().edit(mapping=dict)
	762	#
	763	# Study Level
	764	#
	765	level = record['level']
	766	study_course.invokeFactory('StudentStudyLevel',level)
	767	study_level = getattr(study_course,level)
	768	dict = {}
	769	r2d = [('session','session'),
	770	('level','code'),
	771	('verdict','verdict'),
	772	]
	773	for r,d in r2d:
	774	dict[d] = record[r]
	775	study_level.getContent().edit(mapping=dict)
	776	wftool.doActionFor(student,'return')
	777	imported.append(format % record)
	778	tr_count += 1
	779	record['tr_count'] = tr_count
	780	record['total'] = total
	781	logger.info('%(total)s+%(tr_count)s: Creating Student %(student_id)s %(matric_no)s %(jamb_reg_no)s' % record)
	782	if tr_count > 1000:
	783	if len(not_imported) > 0:
	784	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	785	'\n'.join(not_imported)+'\n')
	786	not_imported = []
	787	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	788	'\n'.join(imported) + '\n')
	789	imported = []
	790	em = '%d transactions commited total %s' % (tr_count,total)
	791	transaction.commit()
	792	logger.info(em)
	793	regs = []
	794	total += tr_count
	795	tr_count = 0
	796	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	797	'\n'.join(imported))
	798	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	799	'\n'.join(not_imported))
	800	em = '%d transactions commited total %d' % (tr_count,total)
	801	logger.info(em)
	802	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	803	###)
	804
	805
	806	security.declareProtected(ModifyPortalContent,"createDEStudents")###(
	807	def createDEStudents(self):
	808	"""load Fulltime Studentdata from CSV values"""
	809	import transaction
	810	import random
	811	#from pdb import set_trace
	812	wftool = self.portal_workflow
	813	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	814	csv_d = {'jamb_reg_no': "RegNumber",
	815	'jamb_lastname': "Name",
	816	'session': "Session",
	817	'pume_tot_score': "PUDE SCORE",
	818	##'jamb_score': "JambScore",
	819	'entry_mode': "EntryMode",
	820	'jamb_sex': "Sex",
	821	'jamb_state': "State",
	822	'jamb_first_cos': "AdminCourse",
	823	'faculty': "AdminFaculty",
	824	'course_code': "AdmitCoscode",
	825	'stud_status':"AdmitStatus",
	826	'department': "AdmitDept",
	827	'jamb_lga': "LGA",
	828	'app_email': "email",
	829	'app_mobile': "PhoneNumbers",
	830	}
	831	csv_fields = [f[1] for f in csv_d.items()]
	832	tr_count = 0
	833	total = 0
	834	#name = 'pume_results'
	835	name = 'DE_Admitted'
	836	no_import = []
	837	s = ','.join(['"%s"' % fn for fn in csv_fields])
	838	no_import.append('"Error",%s' % s)
	839	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	840	no_certificate = "no certificate %s" % format
	841	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
	842	logger = logging.getLogger('Students.StudentsFolder.createDEStudents')
	843	logger.info('Start loading from %s.csv' % name)
	844	l = self.portal_catalog({'meta_type': "Certificate"})
	845	certs = {}
	846	cert_docs = {}
	847	for f in l:
	848	certs[f.getId] = f.getObject().getContent()
	849	try:
	850	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	851	except:
	852	logger.error('Error reading %s.csv' % name)
	853	return
	854	for jamb in result:
	855	jamb['Error'] = "Processing"
	856	logger.info(format % jamb)
	857	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
	858	res = self.portal_catalog({'portal_type': "StudentApplication",
	859	'SearchableText': jamb_reg_no })
	860	if res:
	861	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
	862	logger.info(em)
	863	jamb['Error'] = "Student exists"
	864	no_import.append(format % jamb)
	865	continue
	866	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
	867	if cert_id not in certs.keys():
	868	em = 'No Certificate with ID %s \n' % cert_id
	869	logger.info(em)
	870	jamb['Error'] = "No Certificate %s" % cert_id
	871	no_import.append( format % jamb)
	872	continue
	873	jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
	874	cert_doc = certs[cert_id]
	875	catalog_entry = {}
	876	catalog_entry['jamb_reg_no'] = jamb_reg_no
	877	jamb_name = jamb.get(csv_d['jamb_lastname'])
	878	jamb_name.replace('>','')
	879	jamb_name.replace('<','')
	880	names = jamb_name.split()
	881	letter = names[-1][0].upper()
	882	sid = self.generateStudentId(letter)
	883	not_created = True
	884	while not_created:
	885	try:
	886	students_folder.invokeFactory('Student', sid)
	887	not_created = False
	888	except BadRequest:
	889	sid = self.generateStudentId(letter)
	890	catalog_entry['id'] = sid
	891	tr_count += 1
	892	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
	893	student = getattr(self,sid)
	894	student.manage_setLocalRoles(sid, ['Owner',])
	895	student.invokeFactory('StudentPume','pume')
	896	dp = {'Title': 'Pume Data'}
	897	student.invokeFactory('StudentApplication','application')
	898	da = {'Title': 'Application Data'}
	899	da["jamb_lastname"] = jamb_name
	900	da_fields = ('jamb_reg_no',
	901	'jamb_sex',
	902	'entry_mode',
	903	#'jamb_score',
	904	'jamb_first_cos',
	905	'jamb_sex',
	906	'jamb_state',
	907	'jamb_lga',
	908	'app_email',
	909	'app_mobile',
	910	)
	911	for f in da_fields:
	912	da[f] = jamb.get(csv_d[f])
	913	catalog_entry['email'] = jamb.get(csv_d['app_email'])
	914	app = student.application
	915	app_doc = app.getContent()
	916	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
	917	#import pdb;pdb.set_trace()
	918	if os.path.exists(picture):
	919	file = open(picture)
	920	if False:
	921	img = PIL.Image.open(file)
	922	img.thumbnail((150,200),
	923	resample=PIL.Image.ANTIALIAS)
	924	# We now need a buffer to write to. It can't be the same
	925	# as the inbuffer as the PNG writer will write over itself.
	926	outfile = StringIO()
	927	img.save(outfile, format=img.format)
	928	else:
	929	outfile = file.read()
	930	app_doc.manage_addFile('passport',
	931	file=outfile,
	932	title="%s.jpg" % jamb_reg_no)
	933	app.getContent().edit(mapping=da)
	934	app.manage_setLocalRoles(sid, ['Owner',])
	935	#wftool.doActionFor(app,'close')
	936	dp_fields = (
	937	#'pume_eng_score',
	938	#'pume_gen_score',
	939	'pume_tot_score',
	940	)
	941	dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
	942	pume = student.pume
	943	pume.getContent().edit(mapping=dp)
	944	#wftool.doActionFor(pume,'close')
	945	pume.manage_setLocalRoles(sid, ['Owner',])
	946	#student.getContent().createSubObjects()
	947	dp = {}
	948	if len(names) == 3:
	949	dp['firstname'] = names[0].capitalize()
	950	dp['middlename'] = names[1].capitalize()
	951	dp['lastname'] = names[2].capitalize()
	952	elif len(names) == 2:
	953	dp['firstname'] = names[0].capitalize()
	954	dp['middlename'] = ''
	955	dp['lastname'] = names[1].capitalize()
	956	else:
	957	dp['firstname'] = ''
	958	dp['middlename'] = ''
	959	dp['lastname'] = jamb_name
	960	dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
	961	catalog_entry['sex'] = dp['sex']
	962	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
	963	student.invokeFactory('StudentPersonal','personal')
	964	per = student.personal
	965	per_doc = per.getContent()
	966	per_doc.edit(mapping = dp)
	967	per.manage_setLocalRoles(sid, ['Owner',])
	968	if jamb.get(csv_d['stud_status']) == "Admitted":
	969	wftool.doActionFor(student,'pume_pass')
	970	wftool.doActionFor(student,'admit')
	971	else:
	972	wftool.doActionFor(student,'pume_fail')
	973	wftool.doActionFor(student,'reject_admission')
	974	continue
	975	#
	976	# Clearance
	977	#
	978	student.invokeFactory('StudentClearance','clearance')
	979	#wftool.doActionFor(student.clearance,'open')
	980	dp = {'Title': 'Clearance/Eligibility Record'}
	981	student.clearance.manage_setLocalRoles(sid, ['Owner',])
	982	#
	983	# Study Course
	984	#
	985	student.invokeFactory('StudentStudyCourse','study_course')
	986	study_course = student.study_course
	987	dsc = {}
	988	#from_certificate = ['title',
	989	# 'max_elect',
	990	# 'max_pass',
	991	# 'n_core',
	992	# 'nr_years',
	993	# 'probation_credits',
	994	# 'promotion_credits',
	995	# 'start_level',
	996	# ]
	997	#for f in from_certificate:
	998	# dsc[f] = getattr(cert_doc,f)
	999	#dsc['faculty'] = jamb.get(csv_d['faculty'])
	1000	#dsc['department'] = jamb.get(csv_d['department'])
	1001	catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
	1002	catalog_entry['department'] = jamb.get(csv_d['department'])
	1003	catalog_entry['course'] = cert_id
	1004	#catalog_entry['level'] = getattr(cert_doc,'start_level')
	1005	catalog_entry['level'] = '200'
	1006	dsc['study_course'] = cert_id
	1007	dsc['current_level'] = '200'
	1008	#dsc['entry_session'] = jamb.get(csv_d['session'])
	1009	study_course.getContent().edit(mapping=dsc)
	1010	self.students_catalog.addRecord(**catalog_entry)
	1011	if tr_count > 10:
	1012	if len(no_import) > 1:
	1013	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
	1014	'\n'.join(no_import)+'\n')
	1015	no_import = []
	1016	em = '%d transactions commited\n' % tr_count
	1017	transaction.commit()
	1018	logger.info(em)
	1019	total += tr_count
	1020	tr_count = 0
	1021	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
	1022	'\n'.join(no_import))
	1023	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1024	###)
	1025
	1026	security.declareProtected(ModifyPortalContent,"createNewStudents")###(
	1027	def createNewStudents(self):
	1028	"""load Fulltime Studentdata from CSV values"""
	1029	import transaction
	1030	import random
	1031	#from pdb import set_trace
	1032	wftool = self.portal_workflow
	1033	students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	1034	csv_d = {'jamb_reg_no': "RegNumber",
	1035	'jamb_lastname': "Name",
	1036	'session': "Session",
	1037	'pume_tot_score': "PUME SCORE",
	1038	'jamb_score': "JambScore",
	1039	'jamb_sex': "Sex",
	1040	'jamb_state': "State",
	1041	## 'jamb_first_cos': "AdminCourse",
	1042	'faculty': "AdminFaculty",
	1043	'course_code': "AdmitCoscode",
	1044	'stud_status':"AdmitStatus",
	1045	'department': "AdmitDept",
	1046	'jamb_lga': "LGA",
	1047	'app_email': "email",
	1048	'app_mobile': "PhoneNumbers",
	1049	}
	1050	csv_fields = [f[1] for f in csv_d.items()]
	1051	tr_count = 0
	1052	total = 0
	1053	#name = 'pume_results'
	1054	name = 'Admitted'
	1055	no_import = []
	1056	s = ','.join(['"%s"' % fn for fn in csv_fields])
	1057	no_import.append('"Error",%s' % s)
	1058	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	1059	no_certificate = "no certificate %s" % format
	1060	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
	1061	logger = logging.getLogger('Students.StudentsFolder.createNewStudents')
	1062	logger.info('Start loading from %s.csv' % name)
	1063	l = self.portal_catalog({'meta_type': "Certificate"})
	1064	certs = {}
	1065	cert_docs = {}
	1066	for f in l:
	1067	certs[f.getId] = f.getObject().getContent()
	1068	try:
	1069	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1070	except:
	1071	logger.error('Error reading %s.csv' % name)
	1072	return
	1073	for jamb in result:
	1074	jamb['Error'] = "Processing "
	1075	logger.info(format % jamb)
	1076	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
	1077	res = self.portal_catalog({'portal_type': "StudentApplication",
	1078	'SearchableText': jamb_reg_no })
	1079	if res:
	1080	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
	1081	logger.info(em)
	1082	jamb['Error'] = "Student exists"
	1083	no_import.append(format % jamb)
	1084	continue
	1085	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
	1086	if cert_id not in certs.keys():
	1087	em = 'No Certificate with ID %s \n' % cert_id
	1088	logger.info(em)
	1089	jamb['Error'] = "No Certificate %s" % cert_id
	1090	no_import.append( format % jamb)
	1091	continue
	1092	res = self.portal_pumeresults(jamb_reg_no = jamb_reg_no)
	1093	if len(res) == 1:
	1094	self.portal_pumeresults.modifyRecord(jamb_reg_no = jamb_reg_no,
	1095	status = jamb.get(csv_d['stud_status']),
	1096	)
	1097	jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
	1098	cert_doc = certs[cert_id]
	1099	catalog_entry = {}
	1100	catalog_entry['jamb_reg_no'] = jamb_reg_no
	1101	jamb_name = jamb.get(csv_d['jamb_lastname'])
	1102	jamb_name.replace('>','')
	1103	jamb_name.replace('<','')
	1104	names = jamb_name.split()
	1105	letter = names[-1][0].upper()
	1106	sid = self.generateStudentId(letter)
	1107	not_created = True
	1108	while not_created:
	1109	try:
	1110	students_folder.invokeFactory('Student', sid)
	1111	not_created = False
	1112	except BadRequest:
	1113	sid = self.generateStudentId(letter)
	1114	catalog_entry['id'] = sid
	1115	tr_count += 1
	1116	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s reg_no %(jamb_reg_no)s ' % vars())
	1117	student = getattr(self,sid)
	1118	student.manage_setLocalRoles(sid, ['Owner',])
	1119	student.invokeFactory('StudentPume','pume')
	1120	dp = {'Title': 'Pume Data'}
	1121	student.invokeFactory('StudentApplication','application')
	1122	da = {'Title': 'Application Data'}
	1123	da["jamb_lastname"] = jamb_name
	1124	da_fields = ('jamb_reg_no',
	1125	'jamb_sex',
	1126	#'jamb_state',
	1127	'jamb_score',
	1128	## 'jamb_first_cos',
	1129	'jamb_sex',
	1130	'jamb_state',
	1131	'jamb_lga',
	1132	'app_email',
	1133	'app_mobile',
	1134	)
	1135	for f in da_fields:
	1136	da[f] = jamb.get(csv_d[f])
	1137	catalog_entry['email'] = jamb.get(csv_d['app_email'])
	1138	app = student.application
	1139	app_doc = app.getContent()
	1140	#import pdb;pdb.set_trace()
	1141	picture ="%s/import/pictures/%s.jpg" % (i_home,picture_id)
	1142	if os.path.exists(picture):
	1143	file = open(picture)
	1144	if False:
	1145	img = PIL.Image.open(file)
	1146	img.thumbnail((150,200),
	1147	resample=PIL.Image.ANTIALIAS)
	1148	# We now need a buffer to write to. It can't be the same
	1149	# as the inbuffer as the PNG writer will write over itself.
	1150	outfile = StringIO()
	1151	img.save(outfile, format=img.format)
	1152	else:
	1153	outfile = file.read()
	1154	app_doc.manage_addFile('passport',
	1155	file=outfile,
	1156	title="%s.jpg" % jamb_reg_no)
	1157	app.getContent().edit(mapping=da)
	1158	app.manage_setLocalRoles(sid, ['Owner',])
	1159	#wftool.doActionFor(app,'close')
	1160	dp_fields = (
	1161	#'pume_eng_score',
	1162	#'pume_gen_score',
	1163	'pume_tot_score',
	1164	)
	1165	dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
	1166	pume = student.pume
	1167	pume.getContent().edit(mapping=dp)
	1168	#wftool.doActionFor(pume,'close')
	1169	pume.manage_setLocalRoles(sid, ['Owner',])
	1170	#student.getContent().createSubObjects()
	1171	dp = {}
	1172	if len(names) == 3:
	1173	dp['firstname'] = names[0].capitalize()
	1174	dp['middlename'] = names[1].capitalize()
	1175	dp['lastname'] = names[2].capitalize()
	1176	elif len(names) == 2:
	1177	dp['firstname'] = names[0].capitalize()
	1178	dp['middlename'] = ''
	1179	dp['lastname'] = names[1].capitalize()
	1180	else:
	1181	dp['firstname'] = ''
	1182	dp['middlename'] = ''
	1183	dp['lastname'] = jamb_name
	1184	dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
	1185	catalog_entry['sex'] = dp['sex']
	1186	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
	1187	student.invokeFactory('StudentPersonal','personal')
	1188	per = student.personal
	1189	per_doc = per.getContent()
	1190	per_doc.edit(mapping = dp)
	1191	per.manage_setLocalRoles(sid, ['Owner',])
	1192	if jamb.get(csv_d['stud_status']) == "Admitted":
	1193	wftool.doActionFor(student,'pume_pass')
	1194	wftool.doActionFor(student,'admit')
	1195	else:
	1196	wftool.doActionFor(student,'pume_fail')
	1197	wftool.doActionFor(student,'reject_admission')
	1198	continue
	1199	#
	1200	# Clearance
	1201	#
	1202	student.invokeFactory('StudentClearance','clearance')
	1203	#wftool.doActionFor(student.clearance,'open')
	1204	dp = {'Title': 'Clearance/Eligibility Record'}
	1205	student.clearance.manage_setLocalRoles(sid, ['Owner',])
	1206	#
	1207	# Study Course
	1208	#
	1209	student.invokeFactory('StudentStudyCourse','study_course')
	1210	study_course = student.study_course
	1211	dsc = {}
	1212	#from_certificate = ['title',
	1213	# 'max_elect',
	1214	# 'max_pass',
	1215	# 'n_core',
	1216	# 'nr_years',
	1217	# 'probation_credits',
	1218	# 'promotion_credits',
	1219	# 'start_level',
	1220	# ]
	1221	#for f in from_certificate:
	1222	# dsc[f] = getattr(cert_doc,f)
	1223	#dsc['faculty'] = jamb.get(csv_d['faculty'])
	1224	#dsc['department'] = jamb.get(csv_d['department'])
	1225	catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
	1226	catalog_entry['department'] = jamb.get(csv_d['department'])
	1227	catalog_entry['course'] = cert_id
	1228	#catalog_entry['level'] = getattr(cert_doc,'start_level')
	1229	catalog_entry['level'] = '100'
	1230	dsc['study_course'] = cert_id
	1231	#dsc['entry_level'] = '100'
	1232	#dsc['entry_session'] = jamb.get(csv_d['session'])
	1233	study_course.getContent().edit(mapping=dsc)
	1234	self.students_catalog.addRecord(**catalog_entry)
	1235	if tr_count > 10:
	1236	if len(no_import) > 0:
	1237	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
	1238	'\n'.join(no_import) + "\n")
	1239	no_import = []
	1240	em = '%d transactions commited\n' % tr_count
	1241	transaction.commit()
	1242	logger.info(em)
	1243	total += tr_count
	1244	tr_count = 0
	1245	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
	1246	'\n'.join(no_import))
	1247	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1248	###)
[1783]	1249
	1250
	1251	security.declareProtected(ModifyPortalContent,"fixVerdicts")###(
	1252	def fixVerdicts(self,csv_file=None):
	1253	"""fix wrong uploaded verdicts"""
	1254	import transaction
	1255	import random
	1256	wftool = self.portal_workflow
	1257	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	1258	students_folder = self.portal_url.getPortalObject().campus.students
	1259	tr_count = 1
	1260	total = 0
	1261	if csv_file is None:
	1262	name = 'Verdicts'
	1263	else:
	1264	name = csv_file
	1265	st_cat = self.students_catalog
	1266	no_import = []
	1267	verdicts_voc = self.portal_vocabularies.verdicts
	1268	rverdicts = {}
	1269	for k,v in verdicts_voc.items():
	1270	rverdicts[v.upper()] = k
	1271	rverdicts['STUDENT ON PROBATION'] = 'C'
	1272	logger = logging.getLogger('Students.StudentsFolder.fixVerdicts')
	1273	try:
	1274	verdicts = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1275	except:
	1276	logger.error('Error reading %s.csv' % name)
	1277	return
	1278	start = True
	1279	#import pdb;pdb.set_trace()
	1280	for verdict in verdicts:
	1281	if start:
	1282	start = False
	1283	logger.info('Start loading from %s.csv' % name)
	1284	s = ','.join(['"%s"' % fn for fn in verdict.keys()])
	1285	no_import.append('%s,"Error"' % s)
	1286	format = ','.join(['"%%(%s)s"' % fn for fn in verdict.keys()])
	1287	format_error = format + ',"%(Error)s"'
	1288	matric_no = verdict.get('MAT NO')
	1289	if not matric_no:
	1290	continue
	1291	matric_no = matric_no.upper()
	1292	if matric_no == '':
	1293	continue
	1294	verdict_code = rverdicts.get(verdict.get('CATEGORY'),None)
	1295	if verdict_code is None:
	1296	continue
	1297	sres = st_cat(matric_no = matric_no)
	1298	if sres:
	1299	student_id = sres[0].id
	1300	student_obj = getattr(students_folder,student_id,None)
	1301	if student_obj:
	1302	study_course = getattr(student_obj,'study_course',None)
	1303	if study_course is None:
	1304	verdict['Error'] = "Student did not yet log in"
	1305	no_import.append( format_error % verdict)
	1306	continue
	1307	st_cat.modifyRecord(id = student_id,
	1308	verdict=verdict_code)
	1309
	1310	dsc = {}
	1311	dsc['current_verdict'] = verdict_code
	1312	study_course.getContent().edit(mapping=dsc)
	1313	else:
	1314	verdict['Error'] = "Not found in students_catalog"
	1315	no_import.append( format_error % verdict)
	1316	continue
	1317	tr_count += 1
	1318	if tr_count > 1000:
	1319	if len(no_import) > 0:
	1320	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	1321	'\n'.join(no_import) + '\n')
	1322	no_import = []
	1323	em = '%d transactions commited total %s\n' % (tr_count,total)
	1324	transaction.commit()
	1325	regs = []
	1326	logger.info(em)
	1327	total += tr_count
	1328	tr_count = 0
	1329	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	1330	'\n'.join(no_import))
	1331	total += tr_count
	1332	em = '%d total transactions commited' % (total)
	1333	logger.info(em)
	1334	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1335	###)
	1336
	1337
	1338	security.declareProtected(ModifyPortalContent,"fixAllEntryModeForReturning")###(
	1339	def fixAllEntryModeForReturning(self):
	1340	"read all Returning*.csv"
	1341	ipath = "%s/import/" % i_home
	1342	names = os.listdir(ipath)
	1343	for name in names:
	1344	head,tail = os.path.splitext(name)
	1345	if head.startswith('Returning')\
	1346	and tail == '.csv'\
	1347	and name.find('imported') < 0:
	1348	self.fixEntryModeForReturning(csv_file=head)
	1349	###)
	1350
	1351	security.declareProtected(ModifyPortalContent,"fixEntryModeForReturning")###(
	1352	def fixEntryModeForReturning(self,csv_file=None):
	1353	"""load Returning Studentdata from CSV values"""
	1354	import transaction
	1355	import random
	1356	wftool = self.portal_workflow
	1357	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	1358	students_folder = self.portal_url.getPortalObject().campus.students
	1359	tr_count = 1
	1360	total = 0
	1361	if csv_file is None:
	1362	name = 'Returning'
	1363	else:
	1364	name = csv_file
	1365	table = self.returning_import
	1366	st_cat = self.students_catalog
	1367	no_import = []
	1368	logger = logging.getLogger('Students.StudentsFolder.fixEntryModeForReturning')
	1369	try:
	1370	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1371	except:
	1372	logger.error('Error reading %s.csv' % name)
	1373	return
	1374	start = True
	1375	for student in returning:
	1376	if start:
	1377	start = False
	1378	logger.info('Start loading from %s.csv' % name)
	1379	s = ','.join(['"%s"' % fn for fn in student.keys()])
	1380	no_import.append('%s,"Error"' % s)
	1381	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
	1382	format_error = format + ',"%(Error)s"'
	1383	matric_no = student.get('matric_no')
	1384	if not matric_no:
	1385	continue
	1386	matric_no = matric_no.upper()
	1387	student['matric_no'] = matric_no
	1388	if matric_no == '':
	1389	continue
	1390	if not table(matric_no = matric_no):
	1391	student['Error'] = "Not imported yet"
	1392	no_import.append( format_error % student)
	1393	continue
	1394	student_id = None
	1395	app = None
	1396	per = None
	1397	if st_cat(matric_no = matric_no):
	1398	student_id = st_cat(matric_no = matric_no)[0].id
	1399	student_obj = getattr(students_folder,student_id,None)
	1400	if student_obj:
	1401	app = getattr(student_obj,'application',None)
	1402	if app is not None:
	1403	app_doc = app.getContent()
	1404	per = getattr(student_obj,'personal',None)
	1405	if per is not None:
	1406	per_doc = per.getContent()
	1407	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
	1408	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
	1409	#import pdb;pdb.set_trace()
	1410	if not entry_mode:
	1411	student['Error'] = "'Mode of Entry' empty"
	1412	no_import.append( format_error % student)
	1413	continue
	1414	try:
	1415	table.modifyRecord(matric_no = matric_no,
	1416	Mode_of_Entry = entry_mode,
	1417	Permanent_Address = perm_address)
	1418	except KeyError:
	1419	student['Error'] = "Not found in returning_import"
	1420	no_import.append( format_error % student)
	1421	continue
	1422	if student_id is not None:
	1423	try:
	1424	st_cat.modifyRecord(id = student_id,
	1425	entry_mode=entry_mode)
	1426	except KeyError:
	1427	student['Error'] = "Not found in students_catalog"
	1428	no_import.append( format_error % student)
	1429	continue
	1430	if app is not None:
	1431	da = {}
	1432	da['entry_mode'] = entry_mode
	1433	app_doc.edit(mapping=da)
	1434	if per is not None:
	1435	dp = {}
	1436	dp['perm_address'] = perm_address
	1437	per_doc.edit(mapping=dp)
	1438	tr_count += 1
	1439	if tr_count > 1000:
	1440	if len(no_import) > 0:
	1441	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	1442	'\n'.join(no_import) + '\n')
	1443	no_import = []
	1444	em = '%d transactions commited total %s\n' % (tr_count,total)
	1445	transaction.commit()
	1446	regs = []
	1447	logger.info(em)
	1448	total += tr_count
	1449	tr_count = 0
	1450	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	1451	'\n'.join(no_import))
	1452	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[2654]	1453	###)
	1454
	1455	security.declareProtected(ModifyPortalContent,"loadPumeResultsFromCSV")###(
	1456	def loadPumeResultsFromCSV(self):
	1457	"""load Fulltime Studentdata from CSV values into pumeresults catalog"""
	1458	import transaction
	1459	import random
	1460	## csv_d = {'jamb_reg_no': "RegNumber", ###(
	1461	## 'status': "Admission Status",
	1462	## 'name': "Name",
	1463	## 'score': "Score",
	1464	## 'sex': "Sex",
	1465	## 'faculty': "Faculty",
	1466	## 'department': "Dept",
	1467	## 'course': "Course",
	1468	## 'course_code_org': "Course Code",
	1469	## }
	1470	###)
	1471	## csv_d = {'jamb_reg_no': "JAMBRegno",
	1472	## 'name': "Name",
	1473	## 'score': "Score",
	1474	## 'sex': "Sex",
	1475	## 'course': "Course",
	1476	## 'faculty': "Faculty",
	1477	## 'department': "Dept",
	1478	## 'course_code_org': "Course Code",
	1479	## 'status': "Admission Status",
	1480	## 'result_type': None,
	1481	## }
	1482
	1483	csv_d = {'jamb_reg_no': "reg_no",
	1484	'name': "fullname",
	1485	'score': "pume_score",
	1486	'sex': "sex",
	1487	'course': "study_course",
	1488	'course_code_org': "study_course",
	1489	'status': "admission_status",
	1490	'result_type': "entry_mode",
	1491	}
	1492
	1493	csv_fields = [f[1] for f in csv_d.items() if f[1]]
	1494	tr_count = 0
	1495	total = 0
	1496	#name = 'pup_new'
	1497	#name = 'pup_update'
	1498	name = 'Admitted_update'
	1499	update = name.endswith('update')
	1500	no_import = []
	1501	ok_import = []
	1502	ok_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_d.keys()]))
	1503	no_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_fields]))
	1504	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	1505	ok_import_name = "%s/import/%s_imported_%s.csv" % (i_home,name,current)
	1506	#open(ok_import_name,"w").write('\n'.join(no_import))
	1507	no_import_name = "%s/import/%s_not_imported_%s.csv" % (i_home,name,current)
	1508	#open(no_import_name,"w").write('\n'.join(no_import))
	1509	logger = logging.getLogger('Students.loadPumeResultsFromCSV')
	1510	starttime = DateTime.now()
	1511	logger.info('Start loading from %s.csv' % name)
	1512	try:
	1513	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1514	except:
	1515	logger.error('Error reading %s.csv' % name)
	1516	return
	1517	pume = self.portal_pumeresults
	1518	format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	1519	import_format = ','.join(['"%%(%s)s"' % fn for fn in csv_d.keys()])
	1520	eduplicate = '%s,"duplicate"' % format
	1521	eoriginal = '%s,"original"' % format
	1522	einvalidjamb = '%s,"invalid JambRegNo"' % format
	1523	added = 'added ,%s' % format
	1524	#from pdb import set_trace;set_trace()
	1525	for jamb in result:
	1526	if not jamb.get(csv_d['score']):
	1527	logger.info('Student %s has no pume_score' % jamb.get(csv_d['jamb_reg_no']))
	1528	continue
	1529	dict = {}
	1530	for f,fn in csv_d.items():
	1531	dict[f] = jamb.get(csv_d[f])
	1532	dict['result_type'] = 'CEST'
	1533	jnr = jamb.get(csv_d['jamb_reg_no'])
	1534	#if not checkJambNo(jnr):
	1535	# logger.info(einvalidjamb % jamb)
	1536	# dd = {}
	1537	# for f,fn in csv_d.items():
	1538	# dd[fn] = getattr(data,f)
	1539	# no_import.append(eduplicate % dd)
	1540	# no_import.append(eduplicate % jamb)
	1541	# continue
	1542	res = pume(jamb_reg_no=jnr)
	1543	if len(res) > 0:
	1544	if update:
	1545	try:
	1546	pume.modifyRecord(**dict)
	1547	# Can not happen, but anyway...
	1548	except ValueError:
	1549	logger.info(eduplicate % jamb)
	1550	continue
	1551	# Can not happen, but anyway...
	1552	except KeyError:
	1553	pume.addRecord(**dict)
	1554	logger.info(added % jamb)
	1555	continue
	1556	else:
	1557	data = res[0]
	1558	if data.name != jamb.get(csv_d['name']):
	1559	#set_trace()
	1560	logger.info(eduplicate % jamb)
	1561	#em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
	1562	#logger.info(em)
	1563	dd = {}
	1564	for f,fn in csv_d.items():
	1565	dd[fn] = getattr(data,f)
	1566	no_import.append(eoriginal % dd)
	1567	no_import.append(eduplicate % jamb)
	1568	continue
	1569	else:
	1570	try:
	1571	pume.addRecord(**dict)
	1572	ok_import.append(import_format % dict)
	1573	except ValueError:
	1574	logger.info(eduplicate % jamb)
	1575	#em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
	1576	#logger.info(em)
	1577	no_import.append(eduplicate % jamb)
	1578	logger.info('End loading from %s.csv' % name)
	1579	if len(no_import) > 1:
	1580	open(no_import_name,"w+").write('\n'.join(no_import))
	1581	open(ok_import_name,"w+").write('\n'.join(ok_import))
	1582	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1583	###)
	1584
	1585	security.declareProtected(ModifyPortalContent,"createStudents")###(
	1586	def createStudents(self):
	1587	"""
	1588	load addmitted Studentdata from CSV values and create Studentobjects.
	1589	This is the current method to create new addmitted Students.
	1590	Before running the eventservice for the students_catalog must be disabled.
	1591	"""
	1592	import transaction
	1593	import random
	1594	#from pdb import set_trace
	1595	wftool = self.portal_workflow
	1596	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	1597	students_folder = self.portal_url.getPortalObject().campus.students
	1598	levels = {'ume_ft':'100',
	1599	'de_ft': '200',
	1600	'ug_pt': '100',
	1601	'de_pt': '200',
	1602	'pg_ft': '700',
	1603	'pg_pt': '700',
	1604	'dp_pt': '100',
	1605	'dp_ft': '100',
	1606	}
	1607	csv_d = {'jamb_reg_no': "reg_no",
	1608	'entry_mode': 'entry_mode',
	1609	'jamb_firstname': "firstname",
	1610	'jamb_middlename': "middlename",
	1611	'jamb_lastname': "lastname",
	1612	'jamb_sex': "sex",
	1613	'jamb_state': "state",
	1614	'birthday': "date_of_birth",
	1615	'app_email': "email",
	1616	'study_course': "study_course",
	1617	'perm_address': "address",
	1618	'admission_status': "admission_status",
	1619	}
	1620	csv_fields = [f[1] for f in csv_d.items()]
	1621	tr_count = 0
	1622	total = 0
	1623	#name = 'pume_results'
	1624	name = 'Admitted_update'
	1625	no_import = []
	1626	s = ','.join(['"%s"' % fn for fn in csv_fields])
	1627	no_import.append('"Error",%s' % s)
	1628	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	1629	no_certificate = "no certificate %s" % format
	1630	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
	1631	logger = logging.getLogger('Students.StudentsFolder.createStudents')
	1632	logger.info('Start loading from %s.csv' % name)
	1633	certs = {}
	1634	try:
	1635	results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1636	except:
	1637	logger.error('Error reading %s.csv' % name)
	1638	return
	1639	for result in results:
	1640	if not result.get(csv_d['admission_status']).startswith('Admitted'):
	1641	continue
	1642	#result['Error'] = "Processing "
	1643	#logger.info(format % result)
	1644	jamb_reg_no = result.get(csv_d['jamb_reg_no'])
	1645	res = self.students_catalog(jamb_reg_no = jamb_reg_no)
	1646	if res:
	1647	em = 'Student with RegNo %s already exists\n' % jamb_reg_no
	1648	logger.info(em)
	1649	result['Error'] = "Student exists"
	1650	no_import.append(format % result)
	1651	continue
	1652	cert_id = makeCertificateCode(result.get(csv_d['study_course']))
	1653	if cert_id not in certs.keys():
	1654	res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
	1655	if not res:
	1656	em = 'No Certificate with ID %s \n' % cert_id
	1657	logger.info(em)
	1658	result['Error'] = "No Certificate %s" % cert_id
	1659	no_import.append( format % result)
	1660	continue
	1661	cert = res[0]
	1662	cert_path = cert.getPath().split('/')
	1663	certificate = certs[cert_id] = {'faculty': cert_path[-4],
	1664	'department': cert_path[-3]}
	1665	cert_doc = certs[cert_id]
	1666	catalog_entry = {}
	1667	catalog_entry['jamb_reg_no'] = jamb_reg_no
	1668	firstname = result.get(csv_d['jamb_firstname'])
	1669	middlename = result.get(csv_d['jamb_middlename'])
	1670	lastname = result.get(csv_d['jamb_lastname'])
	1671	if len(firstname) < 3\
	1672	and len(middlename) < 3\
	1673	and len(lastname) < 3:
	1674	em = 'Student Names to short \n'
	1675	logger.info(em)
	1676	result['Error'] = "Names to short"
	1677	no_import.append( format % result)
	1678	continue
	1679	perm_address = result.get(csv_d['perm_address'])
	1680	sid = self.generateStudentId('x')
	1681	students_folder.invokeFactory('Student', sid)
	1682	catalog_entry['id'] = sid
	1683	tr_count += 1
	1684	logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s reg_no %(jamb_reg_no)s ' % vars())
	1685	student = getattr(self,sid)
	1686	student.manage_setLocalRoles(sid, ['Owner',])
	1687	student.invokeFactory('StudentApplication','application')
	1688	da = {'Title': 'Application Data'}
	1689	da["jamb_firstname"] = firstname
	1690	da["jamb_middlename"] = middlename
	1691	da["jamb_lastname"] = lastname
	1692	catalog_entry['entry_session'] = da["entry_session"] = self.getSessionId()[0]
	1693	catalog_entry['sex'] = sex = result.get(csv_d['jamb_sex']).startswith('F')
	1694	da_fields = ('jamb_reg_no',
	1695	'jamb_sex',
	1696	'jamb_state',
	1697	'entry_mode',
	1698	'app_email',
	1699	)
	1700	for f in da_fields:
	1701	da[f] = result.get(csv_d[f])
	1702	catalog_entry['email'] = da['app_email']
	1703	catalog_entry['entry_mode'] = da['entry_mode']
	1704	app = student.application
	1705	app_doc = app.getContent()
	1706	app.getContent().edit(mapping=da)
	1707	picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
	1708	app.manage_setLocalRoles(sid, ['Owner',])
	1709
	1710	picture_id = da['jamb_reg_no'].replace('/','_')
	1711	file = None
	1712	for ext in ('jpg','JPG'):
	1713	picture ="%s/import/pictures_admitted_latest/%s.%s" % (i_home,picture_id,ext)
	1714	if os.path.exists(picture):
	1715	file = open(picture)
	1716	break
	1717	if file is not None:
	1718
	1719	## file conversion does not work
	1720	#img = PIL.Image.open(file)
	1721	#img.thumbnail((150,200),
	1722	# resample=PIL.Image.ANTIALIAS)
	1723	#outfile = StringIO()
	1724	#img.save(outfile, format=img.format)
	1725
	1726	outfile = file.read()
	1727	app_doc.manage_addFile('passport',
	1728	file=outfile,
	1729	title="%s.jpg" % jamb_reg_no)
	1730	#wftool.doActionFor(app,'close')
	1731	dp = {}
	1732	dp['firstname'] = firstname
	1733	dp['middlename'] = middlename
	1734	dp['lastname'] = lastname
	1735	dp['email'] = da['app_email']
	1736	dp['sex'] = sex
	1737	dp['perm_address'] = perm_address
	1738	catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
	1739	student.invokeFactory('StudentPersonal','personal')
	1740	per = student.personal
	1741	per_doc = per.getContent()
	1742	per_doc.edit(mapping = dp)
	1743	per.manage_setLocalRoles(sid, ['Owner',])
	1744	wftool.doActionFor(student,'pume_pass')
	1745	wftool.doActionFor(student,'admit')
	1746	#
	1747	# Clearance
	1748	#
	1749	student.invokeFactory('StudentClearance','clearance')
	1750	#wftool.doActionFor(student.clearance,'open')
	1751	clearance = student.clearance
	1752	dc = {'Title': 'Clearance/Eligibility Record'}
	1753	clearance = student.clearance
	1754	date_str = result.get(csv_d['birthday'])
	1755	try:
	1756	date = DateTime.DateTime(date_str)
	1757	except:
	1758	#import pdb;pdb.set_trace()
	1759	date = None
	1760	dc['birthday'] = date
	1761	clearance.getContent().edit(mapping=dc)
	1762	clearance.manage_setLocalRoles(sid, ['Owner',])
	1763	#
	1764	# Study Course
	1765	#
	1766	student.invokeFactory('StudentStudyCourse','study_course')
	1767	study_course = student.study_course
	1768	dsc = {}
	1769	catalog_entry['level'] = dsc['current_level'] = levels.get(da['entry_mode'],'100')
	1770	#catalog_entry['level'] = dsc['current_level'] = '100' # Attention: not for DE students
	1771	catalog_entry['session'] = dsc['current_session'] = da['entry_session']
	1772	catalog_entry['mode'] = dsc['current_mode'] = da['entry_mode']
	1773	catalog_entry['course'] = dsc['study_course'] = cert_id
	1774	catalog_entry['faculty'] = certificate['faculty']
	1775	catalog_entry['department'] = certificate['department']
	1776	catalog_entry['verdict'] = dsc['current_verdict'] = 'N/A'
	1777	catalog_entry['review_state'] = self.portal_workflow.getInfoFor(student,'review_state',None)
	1778	study_course.getContent().edit(mapping=dsc)
	1779	#import pdb;pdb.set_trace()
	1780	self.students_catalog.addRecord(**catalog_entry)
	1781	if tr_count > 100:
	1782	if len(no_import) > 0:
	1783	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
	1784	'\n'.join(no_import) + "\n")
	1785	no_import = []
	1786	em = '%d transactions commited\n' % tr_count
	1787	transaction.commit()
	1788	logger.info(em)
	1789	total += tr_count
	1790	tr_count = 0
	1791	open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
	1792	'\n'.join(no_import))
	1793	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1794	###)
	1795
	1796
	1797	security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
	1798	def importReturningStudents(self):
	1799	"""load Returning Studentdata from CSV values"""
	1800	import transaction
	1801	import random
	1802	#from pdb import set_trace
	1803	wftool = self.portal_workflow
	1804	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	1805	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	1806	students_folder = self.portal_url.getPortalObject().campus.students
	1807	tr_count = 1
	1808	total = 0
	1809	#name = 'pume_results'
	1810	name = 'Returning'
	1811	table = self.returning_import
	1812	no_import = []
	1813	imported = []
	1814	logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
	1815	try:
	1816	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	1817	except:
	1818	logger.error('Error reading %s.csv' % name)
	1819	return
	1820	l = self.portal_catalog({'meta_type': "Certificate"})
	1821	certs = {}
	1822	cert_docs = {}
	1823	for f in l:
	1824	certs[f.getId] = f.getObject().getContent()
	1825	start = True
	1826	res = table()
	1827	regs = []
	1828	if len(res) > 0:
	1829	regs = [s.matric_no for s in res]
	1830	#import pdb;pdb.set_trace()
	1831	for student in returning:
	1832	if start:
	1833	start = False
	1834	logger.info('Start loading from %s.csv' % name)
	1835	s = ','.join(['"%s"' % fn for fn in student.keys()])
	1836	imported.append(s)
	1837	no_import.append('%s,"Error"' % s)
	1838	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
	1839	format_error = format + ',"%(Error)s"'
	1840	no_certificate = "no certificate %s" % format
	1841	student['matric_no'] = matric_no = student.get('matric_no').upper()
	1842	student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
	1843	student['Permanent_Address'] = perm_address = student.get('Permanent Address')
	1844	if matric_no == '':
	1845	student['Error'] = "Empty matric_no"
	1846	no_import.append( format_error % student)
	1847	continue
	1848	if matric_no in regs or self.returning_import(matric_no = matric_no):
	1849	student['Error'] = "Duplicate"
	1850	no_import.append( format_error % student)
	1851	continue
	1852	cert_id = makeCertificateCode(student.get('Coursemajorcode'))
	1853	if cert_id not in certs.keys():
	1854	student['Error'] = "No Certificate %s" % cert_id
	1855	no_import.append( format_error % student)
	1856	continue
	1857	try:
	1858	table.addRecord(**student)
	1859	except ValueError:
	1860	student['Error'] = "Duplicate"
	1861	no_import.append( format_error % student)
	1862	continue
	1863	regs.append(student.get('matric_no'))
	1864	imported.append(format % student)
	1865	tr_count += 1
	1866	if tr_count > 1000:
	1867	if len(no_import) > 0:
	1868	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	1869	'\n'.join(no_import) + '\n')
	1870	no_import = []
	1871	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	1872	'\n'.join(no_import) + "\n")
	1873	imported = []
	1874	em = '%d transactions commited total %s\n' % (tr_count,total)
	1875	transaction.commit()
	1876	regs = []
	1877	logger.info(em)
	1878	total += tr_count
	1879	tr_count = 0
	1880	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	1881	'\n'.join(imported))
	1882	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	1883	'\n'.join(no_import))
	1884	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	1885	###)
	1886
	1887	security.declareProtected(ModifyPortalContent,"fixAllNames")###(
	1888	def fixAllNames(self):
	1889	"fix all students names"
	1890	import transaction
	1891	response = self.REQUEST.RESPONSE
	1892	logger = logging.getLogger('fixAllNames')
	1893	logger.info('Start')
	1894	students = self.portal_catalog(portal_type='Student')
	1895	count = 0
	1896	total = 0
	1897	for student in students:
	1898	scat_res = self.students_catalog(id = student.getId)
	1899	if not scat_res:
	1900	self.students_catalog.addRecord(id = student.getId)
	1901	scat_res = self.students_catalog(id = student.getId)
	1902	student_entry = scat_res[0]
	1903	old_new = self.fixName(student,student_entry)
	1904	count += 1
	1905	response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
	1906	if count > 2000:
	1907	transaction.commit()
	1908	logger.info("%d transactions commited" % count)
	1909	total += count
	1910	count = 0
	1911	###)
	1912
	1913	security.declareProtected(ModifyPortalContent,"fixName")###(
	1914	def fixName(self,student_brain, student_entry):
	1915	"fix the name of a student"
	1916	fix = "first"
	1917	if student_entry.get('name_fixed',None) == fix:
	1918	return "Name already fixed"
	1919	student_id = student_entry.id
	1920	new_student = student_entry.jamb_reg_no.startswith('6')
	1921	student_obj = student_brain.getObject()
	1922	personal = getattr(student_obj,'personal',None)
	1923	invalid = ''
	1924	if personal is None:
	1925	return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
	1926	per_doc = personal.getContent()
	1927	old_first = per_doc.firstname
	1928	old_middle = per_doc.middlename
	1929	old_last = per_doc.lastname
	1930	new_first = ''
	1931	new_middle = ''
	1932	new_last = ''
	1933	if new_student:
	1934	if not old_first and not old_middle and old_last:
	1935	new_names = [n.capitalize() for n in old_last.split()]
	1936	if len(new_names) > 1:
	1937	old_first = new_names[0]
	1938	old_last = new_names[-1]
	1939	old_middle = ' '.join(new_names[1:-1])
	1940	else:
	1941	old_last = new_names[0]
	1942	old_first = ''
	1943	old_middle = ''
	1944	if old_first:
	1945	new_first = old_first
	1946	if old_middle:
	1947	new_middle = old_middle
	1948	if old_last:
	1949	new_last = old_last
	1950	if old_first.find('<') != -1 or\
	1951	old_first.find('>') != -1 or\
	1952	old_middle.find('<') != -1 or\
	1953	old_middle.find('>') != -1 or\
	1954	old_last.find('<') != -1 or\
	1955	old_last.find('>') != -1:
	1956	invalid = "invalid characters"
	1957	else:
	1958	new_first = old_first
	1959	if new_first.strip() == '-':
	1960	new_first = ''
	1961	new_middle = old_middle
	1962	if new_middle.strip() == '-':
	1963	new_middle = ''
	1964	new_last = old_last
	1965	if new_last.strip() == '-':
	1966	new_last = ''
	1967	name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
	1968	if new_student:
	1969	text = "New"
	1970	else:
	1971	text = "Returning"
	1972	old_new = '"%s","%s","%s","%s"' % (invalid,text,
	1973	student_entry.name,
	1974	name)
	1975	if not invalid:
	1976	self.students_catalog.modifyRecord(id = student_id,
	1977	name_fixed = fix,
	1978	name = name)
	1979	per_doc.edit(mapping = {'firstname' : new_first,
	1980	'middlename' : new_middle,
	1981	'lastname' : new_last,
	1982	})
	1983	return old_new
	1984	###)
	1985
	1986	security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
	1987	def updateReturningStudents(self):
	1988	"""load and overwrite Returning Student Data from CSV values"""
	1989	import transaction
	1990	import random
	1991	#from pdb import set_trace
	1992	wftool = self.portal_workflow
	1993	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	1994	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	1995	students_folder = self.portal_url.getPortalObject().campus.students
	1996	tr_count = 1
	1997	total = 0
	1998	#name = 'pume_results'
	1999	name = 'Returning_update'
	2000	table = self.returning_import
	2001	no_import = []
	2002	imported = []
	2003	logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
	2004	try:
	2005	returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	2006	except:
	2007	logger.error('Error reading %s.csv' % name)
	2008	return
	2009	l = self.portal_catalog({'meta_type': "Certificate"})
	2010	certs = {}
	2011	cert_docs = {}
	2012	for f in l:
	2013	certs[f.getId] = f.getObject().getContent()
	2014	start = True
	2015	res = table()
	2016	regs = []
	2017	if len(res) > 0:
	2018	regs = [s.matric_no for s in res]
	2019	for student in returning:
	2020	if start:
	2021	start = False
	2022	logger.info('Start loading from %s.csv' % name)
	2023	s = ','.join(['"%s"' % fn for fn in student.keys()])
	2024	imported.append(s)
	2025	no_import.append('%s,"Error"' % s)
	2026	format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
	2027	format_error = format + ',"%(Error)s"'
	2028	no_certificate = "no certificate %s" % format
	2029	matric_no = student.get('matric_no').upper()
	2030	student['matric_no'] = matric_no
	2031	if matric_no == '':
	2032	student['Error'] = "Empty matric_no"
	2033	no_import.append( format_error % student)
	2034	continue
	2035	# if matric_no in regs or self.returning_import(matric_no = matric_no):
	2036	# student['Error'] = "Duplicate"
	2037	# no_import.append( format_error % student)
	2038	# continue
	2039	# cert_id = makeCertificateCode(student.get('Coursemajorcode'))
	2040	# if cert_id not in certs.keys():
	2041	# student['Error'] = "No Certificate %s" % cert_id
	2042	# no_import.append( format_error % student)
	2043	# continue
	2044	try:
	2045	table.modifyRecord(**student)
	2046	except KeyError:
	2047	#import pdb;pdb.set_trace()
	2048	student['Error'] = "no Student found to update"
	2049	no_import.append( format_error % student)
	2050	continue
	2051	#s = self.students_catalog(matric_no=matric_no)
	2052	#if s:
	2053	# level = "%s" % (int(student.get('Level')) + 100)
	2054	# self.students_catalog.modifyRecord(id = s[0].id,
	2055	# level=level)
	2056
	2057	regs.append(student.get('matric_no'))
	2058	imported.append(format % student)
	2059	tr_count += 1
	2060	if tr_count > 1000:
	2061	if len(no_import) > 0:
	2062	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	2063	'\n'.join(no_import) + '\n')
	2064	no_import = []
	2065	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	2066	'\n'.join(no_import) + "\n")
	2067	imported = []
	2068	em = '%d transactions commited total %s\n' % (tr_count,total)
	2069	transaction.commit()
	2070	regs = []
	2071	logger.info(em)
	2072	total += tr_count
	2073	tr_count = 0
	2074	open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
	2075	'\n'.join(imported))
	2076	open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
	2077	'\n'.join(no_import))
	2078	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	2079	###)
	2080
	2081	security.declareProtected(ModifyPortalContent,"exportStudents")###(
	2082	def exportStudents(self):
	2083	"""export Studentsdata to a file"""
	2084	member = self.portal_membership.getAuthenticatedMember()
	2085	logger = logging.getLogger('Students.exportStudents')
	2086	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	2087	students_folder = self.portal_url.getPortalObject().campus.students
	2088	export_file = "%s/export/students_%s.csv" % (i_home,current)
	2089
	2090	from Products.AdvancedQuery import Eq, Between, Le,In,MatchRegexp
	2091	aq_students = self.students_catalog.evalAdvancedQuery
	2092	toexport = {'students_catalog': ("id",
	2093	"matric_no",
	2094	"jamb_reg_no",
	2095	"name",
	2096	"review_state",
	2097	"entry_session",
	2098	"session",
	2099	"entry_mode",
	2100	"mode",
	2101	"verdict",
	2102	"sex",
	2103	"email",
	2104	"phone",
	2105	"faculty",
	2106	"department",
	2107	"course",
	2108	"level",
	2109	),
	2110	'personal': ('firstname',
	2111	'middlename',
	2112	'lastname',
	2113	'perm_address',
	2114	),
	2115	'clearance': ('state', # is not an attribute of clearance but is needed for splitting lga
	2116	'lga',
	2117	)
	2118	}
	2119	res_list = []
	2120	lines = []
	2121	fields = []
	2122	with_lga = False
	2123	for k in toexport.keys():
	2124	for f in toexport[k]:
	2125	if f == 'lga' :
	2126	with_lga = True
	2127	fields.append(f)
	2128	headline = ','.join(fields).replace('level','current_level')
	2129	open(export_file,"a").write(headline +'\n')
	2130	format = '"%(' + ')s","%('.join(fields) + ')s"'
	2131	query = In('review_state',('cleared_and_validated',
	2132	'clearance_requested',
	2133	'school_fee_paid',
	2134	'courses_registered',
	2135	'courses_validated'))
	2136	#query = In('review_state',('clearance_requested'))
	2137	students = aq_students(query)
	2138	nr2export = len(students)
	2139	logger.info('%s starts exportStudents, %s student records to export' % (member,nr2export))
	2140	chunk = 1000
	2141	total = 0
	2142	start = DateTime.DateTime().timeTime()
	2143	start_chunk = DateTime.DateTime().timeTime()
	2144	## alternative method slightly slower
	2145	# student_recs = {}
	2146	# for s in students:
	2147	# student_recs[s.id] = s
	2148	# catalog_recs = {}
	2149	# brains = self.portal_catalog(portal_type = 'Student')
	2150	# for cat_rec in brains:
	2151	# sid = cat_rec.getId
	2152	# catalog_recs[sid] = cat_rec
	2153	# #import pdb;pdb.set_trace()
	2154	# start = DateTime.DateTime().timeTime()
	2155	# start_chunk = DateTime.DateTime().timeTime()
	2156	# for student in students:
	2157	# if student.id not in student_recs.keys():
	2158	# continue
	2159	# not_all = False
	2160	# d = self.getFormattedStudentEntry(student_recs[student.id])
	2161	# student_obj = catalog_recs[student.id].getObject()
	2162	for student in students:
	2163	not_all = False
	2164	d = self.getFormattedStudentEntry(student)
	2165	student_obj = getattr(students_folder,student.id)
	2166	for k in toexport.keys()[1:]:
	2167	try:
	2168	object = getattr(student_obj,k)
	2169	object_doc = object.getContent()
	2170	except:
	2171	logger.info('%s %s record not found' % (student.id,k))
	2172	not_all = True
	2173	continue
	2174	for f in toexport[k]:
	2175	d[f] = getattr(object_doc,f,'')
	2176	if not_all:
	2177	continue
	2178	if with_lga:
	2179	d['state'],d['lga'] = formatLGA(d['lga'],voc = self.portal_vocabularies.local_gov_areas)
	2180	lines.append(format % d)
	2181	total += 1
	2182	if total and not total % chunk or total == len(students):
	2183	open(export_file,"a").write('\n'.join(lines) +'\n')
	2184	anz = len(lines)
	2185	logger.info("wrote %(anz)d total written %(total)d" % vars())
	2186	end_chunk = DateTime.DateTime().timeTime()
	2187	duration = end_chunk-start_chunk
	2188	per_record = duration/anz
	2189	till_now = end_chunk - start
	2190	avarage_per_record = till_now/total
	2191	estimated_end = DateTime.DateTime(start + avarage_per_record * nr2export)
	2192	estimated_end = estimated_end.strftime("%H:%M:%S")
	2193	logger.info('%(duration)4.1f, %(per_record)4.3f,end %(estimated_end)s' % vars())
	2194	start_chunk = DateTime.DateTime().timeTime()
	2195	lines = []
	2196	end = DateTime.DateTime().timeTime()
	2197	logger.info('total time %6.2f m' % ((end-start)/60))
	2198	filename, extension = os.path.splitext(export_file)
	2199	from subprocess import call
	2200	msg = "wrote %(total)d records to %(export_file)s" % vars()
	2201	try:
	2202	retcode = call('gzip %s' % (export_file),shell=True)
	2203	if retcode == 0:
	2204	msg = "wrote %(total)d records to %(export_file)s.gz" % vars()
	2205	except OSError, e:
	2206	retcode = -99
	2207	logger.info("zip failed with %s" % e)
	2208	logger.info(msg)
	2209	args = {'portal_status_message': msg}
	2210	#url = self.REQUEST.get('URL1') + '?' + urlencode(args)
	2211	url = self.REQUEST.get('URL2')
	2212	return self.REQUEST.RESPONSE.redirect(url)
	2213	###)
	2214
	2215	security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
	2216	def updateStudyCourse(self):
	2217	"""update StudyCourse from CSV values"""
	2218	import transaction
	2219	import random
	2220	from pdb import set_trace
	2221	wftool = self.portal_workflow
	2222	#students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
	2223	students_folder = self.portal_url.getPortalObject().campus.students
	2224	csv_d = {'jamb_reg_no': "RegNumber",
	2225	'jamb_lastname': "Name",
	2226	'session': "Session",
	2227	'pume_tot_score': "PUME SCORE",
	2228	'jamb_score': "JambScore",
	2229	'jamb_sex': "Sex",
	2230	'jamb_state': "State",
	2231	## 'jamb_first_cos': "AdminCourse",
	2232	'faculty': "AdminFaculty",
	2233	'course_code': "AdmitCoscode",
	2234	'stud_status':"AdmitStatus",
	2235	'department': "AdmitDept",
	2236	'jamb_lga': "LGA",
	2237	'app_email': "email",
	2238	'app_mobile': "PhoneNumbers",
	2239	}
	2240	csv_fields = [f[1] for f in csv_d.items()]
	2241	tr_count = 0
	2242	total = 0
	2243	#name = 'pume_results'
	2244	name = 'StudyCourseChange'
	2245	no_import = []
	2246	s = ','.join(['"%s"' % fn for fn in csv_fields])
	2247	no_import.append('"Error",%s' % s)
	2248	format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
	2249	no_certificate = "no certificate %s" % format
	2250	open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
	2251	'\n'.join(no_import))
	2252	logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
	2253	logger.info('Start loading from %s.csv' % name)
	2254	l = self.portal_catalog({'meta_type': "Certificate"})
	2255	try:
	2256	result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
	2257	except:
	2258	logger.error('Error reading %s.csv' % name)
	2259	return
	2260	for jamb in result:
	2261	jamb['Error'] = "Processing "
	2262	logger.info(format % jamb)
	2263	jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
	2264	res = self.portal_catalog({'portal_type': "StudentApplication",
	2265	'SearchableText': jamb_reg_no })
	2266	if not res:
	2267	em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
	2268	logger.info(em)
	2269	jamb['Error'] = "Student does not exist"
	2270	no_import.append(format % jamb)
	2271	continue
	2272	sid = res[0].getPath().split('/')[-2]
	2273	cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
	2274	res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
	2275	if not res:
	2276	em = 'No Certificate with ID %s \n' % cert_id
	2277	logger.info(em)
	2278	jamb['Error'] = "No Certificate %s" % cert_id
	2279	no_import.append( format % jamb)
	2280	continue
	2281	cert_brain = res[0]
	2282	catalog_entry = {}
	2283	student = getattr(self,sid)
	2284	#
	2285	# Study Course
	2286	#
	2287	study_course = student.study_course
	2288	dsc = {}
	2289	cert_pl = cert_brain.getPath().split('/')
	2290	catalog_entry['id'] = sid
	2291	catalog_entry['faculty'] = cert_pl[-4]
	2292	catalog_entry['department'] = cert_pl[-3]
	2293	catalog_entry['course'] = cert_id
	2294	dsc['study_course'] = cert_id
	2295	study_course.getContent().edit(mapping=dsc)
	2296	self.students_catalog.modifyRecord(**catalog_entry)
	2297	if tr_count > 10:
	2298	if len(no_import) > 1:
	2299	open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
	2300	'\n'.join(no_import))
	2301	no_import = []
	2302	em = '%d transactions commited\n' % tr_count
	2303	transaction.commit()
	2304	logger.info(em)
	2305	total += tr_count
	2306	tr_count = 0
	2307	tr_count += 1
	2308	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[1783]	2309	###)

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

Download in other formats: