Context navigation

WAeUPTables.py @ 7657

Last change on this file since 7657 was 5614, checked in by Henrik Bettermann, 14 years ago
Implement first part of new accommodation allocation module. This part contains the new student accommodation catalog which replaces the accommodation objects.
Property svn:keywords set to `Id`
File size: 74.4 KB

Rev	Line
[966]	1	#-- mode: python; mode: fold --
[363]	2	# (C) Copyright 2005 AixtraWare <http://aixtraware.de>
	3	# Author: Joachim Schmitz <js@aixtraware.de>
	4	#
	5	# This program is free software; you can redistribute it and/or modify
	6	# it under the terms of the GNU General Public License version 2 as published
	7	# by the Free Software Foundation.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	17	# 02111-1307, USA.
	18	#
	19	# $Id: WAeUPTables.py 5614 2010-12-27 07:25:11Z henrik $
	20
	21	from zope.interface import implements
	22	from Globals import InitializeClass
	23	from Products.ZCatalog.ZCatalog import ZCatalog
[1620]	24	from Products.ZCatalog.ProgressHandler import ZLogHandler
[780]	25	from AccessControl import ClassSecurityInfo
	26	from Products.CMFCore.permissions import ModifyPortalContent
[2094]	27	from Products.CMFCore.utils import getToolByName
	28	from Products.CMFCore.CatalogTool import CatalogTool
	29	from Products.CPSSchemas.StorageAdapter import MappingStorageAdapter
	30	from Products.CPSSchemas.DataStructure import DataStructure
	31	from Products.CPSSchemas.DataModel import DataModel
	32	from Products.AdvancedQuery import Eq, Between, Le,In
[1700]	33	import urllib
[1620]	34	import DateTime,time
[3989]	35	import csv,re,os
[780]	36	import logging
	37	import Globals
	38	p_home = Globals.package_home(globals())
	39	i_home = Globals.INSTANCE_HOME
	40
[2084]	41	ADDING_SHEDULED = "adding_sheduled"
	42	OBJECT_CREATED = "object_created"
[2845]	43	NOT_OCCUPIED = 'not_occupied'
[2084]	44
[363]	45	from interfaces import IWAeUPTable
	46
	47	class AttributeHolder(object):
	48	pass
	49
	50	def dict2ob(dict):
	51	ob = AttributeHolder()
	52	for key, value in dict.items():
	53	setattr(ob, key, value)
	54	return ob
	55
[1146]	56	class WAeUPTable(ZCatalog): ###(
[834]	57
[363]	58	implements(IWAeUPTable)
[780]	59	security = ClassSecurityInfo()
[2094]	60	meta_type = None
[2099]	61
[2094]	62	def __init__(self,name=None):
	63	if name == None:
	64	name = self.name
	65	ZCatalog.__init__(self,name)
[2099]	66
[2094]	67	def refreshCatalog(self, clear=0, pghandler=None): ###(
[1620]	68	""" don't refresh for a normal table """
	69
	70	if self.REQUEST and self.REQUEST.RESPONSE:
	71	self.REQUEST.RESPONSE.redirect(
	72	URL1 +
	73	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20refresh%20not%20implemented')
	74
[2094]	75	###)
	76
	77	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None): ###(
[1620]	78	""" clears the whole enchilada """
[1986]	79
[1916]	80	#if REQUEST and RESPONSE:
	81	# RESPONSE.redirect(
	82	# URL1 +
	83	# '/manage_catalogAdvanced?manage_tabs_message=Catalog%20Clearing%20disabled')
[1620]	84
[1916]	85	self._catalog.clear()
[1620]	86	if REQUEST and RESPONSE:
	87	RESPONSE.redirect(
	88	URL1 +
[1916]	89	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20cleared')
[1620]	90
[2094]	91	###)
	92
[4244]	93	def record2dict(self,fields,record,index): ###(
[2189]	94	d = {}
	95	for key in fields:
	96	v = getattr(record, key, None)
[3018]	97	v_dump = v
[2192]	98	if key == 'sex':
[3017]	99	if v == True:
	100	v_dump = 'F'
[3018]	101	elif v == False:
[3017]	102	v_dump = 'M'
	103	d[key] = v_dump
[2192]	104	elif v:
[4244]	105	if index == 'translate':
	106	if key == 'lga':
	107	v_dump = self.portal_vocabularies.local_gov_areas.get(v)
	108	if not v_dump:
	109	v_dump = v
	110	elif key == 'aos':
	111	v_dump = self.portal_vocabularies.aos.get(v)
[3017]	112	d[key] = v_dump
[2189]	113	else:
	114	d[key] = ''
	115	return d
[2191]	116
[2632]	117	###)
	118
[2094]	119	def addRecord(self, **data): ###(
[502]	120	# The uid is the same as "bed".
	121	uid = data[self.key]
	122	res = self.searchResults({"%s" % self.key : uid})
	123	if len(res) > 0:
	124	raise ValueError("More than one record with uid %s" % uid)
	125	self.catalog_object(dict2ob(data), uid=uid)
	126	return uid
[834]	127
[2094]	128	###)
	129
[363]	130	def deleteRecord(self, uid):
	131	self.uncatalog_object(uid)
[834]	132
[2738]	133	def getRecordByKey(self,key):
	134	if not key:
	135	return None
	136	res = self.evalAdvancedQuery(Eq(self.key,key))
	137	if res:
	138	return res[0]
	139	return None
	140
[502]	141	def searchAndSetRecord(self, **data):
	142	raise NotImplemented
	143
[2094]	144	def modifyRecord(self, record=None, **data): ###(
[502]	145	#records = self.searchResults(uid=uid)
[5614]	146	#import pdb;pdb.set_trace()
[502]	147	uid = data[self.key]
[2069]	148	if record is None:
	149	records = self.searchResults({"%s" % self.key : uid})
	150	if len(records) > 1:
	151	# Can not happen, but anyway...
	152	raise ValueError("More than one record with uid %s" % uid)
	153	if len(records) == 0:
	154	raise KeyError("No record for uid %s" % uid)
	155	record = records[0]
[363]	156	record_data = {}
	157	for field in self.schema() + self.indexes():
	158	record_data[field] = getattr(record, field)
	159	# Add the updated data:
	160	record_data.update(data)
	161	self.catalog_object(dict2ob(record_data), uid)
	162
[2094]	163	###)
	164
	165	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
[1062]	166	if isinstance(name, str):
[2094]	167	name = (name,)
[1062]	168	paths = self._catalog.uids.items()
	169	i = 0
	170	#import pdb;pdb.set_trace()
	171	for p,rid in paths:
	172	i += 1
	173	metadata = self.getMetadataForRID(rid)
	174	record_data = {}
	175	for field in name:
	176	record_data[field] = metadata.get(field)
	177	uid = metadata.get(self.key)
	178	self.catalog_object(dict2ob(record_data), uid, idxs=name,
	179	update_metadata=0)
[1082]	180
[2094]	181	###)
	182
	183	security.declareProtected(ModifyPortalContent,"exportAllRecords") ###(
[780]	184	def exportAllRecords(self):
	185	"export a WAeUPTable"
	186	#import pdb;pdb.set_trace()
	187	fields = [field for field in self.schema()]
	188	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
	189	csv = []
	190	csv.append(','.join(['"%s"' % fn for fn in fields]))
	191	for uid in self._catalog.uids:
	192	records = self.searchResults({"%s" % self.key : uid})
	193	if len(records) > 1:
	194	# Can not happen, but anyway...
	195	raise ValueError("More than one record with uid %s" % uid)
	196	if len(records) == 0:
	197	raise KeyError("No record for uid %s" % uid)
	198	rec = records[0]
	199	csv.append(format % rec)
	200	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	201	open("%s/import/%s-%s.csv" % (i_home,self.getId(),current),"w+").write('\n'.join(csv))
[2094]	202
	203	###)
	204
[2189]	205	security.declareProtected(ModifyPortalContent,"dumpAll")###(
[3757]	206	def dumpAll(self,index=None,value=None):
[2189]	207	"""dump all data in the table to a csv"""
	208	member = self.portal_membership.getAuthenticatedMember()
[2974]	209	logger = logging.getLogger('WAeUPTables.WAeUPTable.dumpAll')
[2189]	210	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	211	export_file = "%s/export/%s_%s.csv" % (i_home,self.__name__,current,)
	212	res_list = []
	213	lines = []
	214	if hasattr(self,"export_keys"):
	215	fields = self.export_keys
	216	else:
	217	fields = []
	218	for f in self.schema():
	219	fields.append(f)
	220	headline = ','.join(fields)
	221	out = open(export_file,"wb")
	222	out.write(headline +'\n')
	223	out.close()
	224	out = open(export_file,"a")
	225	csv_writer = csv.DictWriter(out,fields,)
[3757]	226	if index is not None and value is not None:
	227	records = self.evalAdvancedQuery(Eq(index,value))
	228	else:
	229	records = self()
[2189]	230	nr2export = len(records)
	231	logger.info('%s starts dumping, %s records to export' % (member,nr2export))
	232	chunk = 2000
	233	total = 0
	234	start = DateTime.DateTime().timeTime()
	235	start_chunk = DateTime.DateTime().timeTime()
	236	for record in records:
	237	not_all = False
[4244]	238	d = self.record2dict(fields,record,index)
[2189]	239	lines.append(d)
	240	total += 1
	241	if total and not total % chunk or total == len(records):
	242	csv_writer.writerows(lines)
	243	anz = len(lines)
	244	logger.info("wrote %(anz)d total written %(total)d" % vars())
	245	end_chunk = DateTime.DateTime().timeTime()
	246	duration = end_chunk-start_chunk
	247	per_record = duration/anz
	248	till_now = end_chunk - start
	249	avarage_per_record = till_now/total
	250	estimated_end = DateTime.DateTime(start + avarage_per_record * nr2export)
	251	estimated_end = estimated_end.strftime("%H:%M:%S")
	252	logger.info('%(duration)4.1f, %(per_record)4.3f,end %(estimated_end)s' % vars())
	253	start_chunk = DateTime.DateTime().timeTime()
	254	lines = []
	255	end = DateTime.DateTime().timeTime()
	256	logger.info('total time %6.2f m' % ((end-start)/60))
	257	import os
	258	filename, extension = os.path.splitext(export_file)
	259	from subprocess import call
	260	msg = "wrote %(total)d records to %(export_file)s" % vars()
[2561]	261	#try:
	262	# retcode = call('gzip %s' % (export_file),shell=True)
	263	# if retcode == 0:
	264	# msg = "wrote %(total)d records to %(export_file)s.gz" % vars()
	265	#except OSError, e:
	266	# retcode = -99
	267	# logger.info("zip failed with %s" % e)
[2189]	268	logger.info(msg)
	269	args = {'portal_status_message': msg}
	270	#url = self.REQUEST.get('URL1') + '?' + urlencode(args)
	271	url = self.REQUEST.get('URL2')
[4537]	272	return 'ready'
	273	#return self.REQUEST.RESPONSE.redirect(url)
[2189]	274	###)
	275
[2185]	276
	277	security.declarePrivate("_import") ###(
	278	def _import_new(self,csv_items,schema, layout, mode,logger):
	279	"import data from csv.Dictreader Instance"
	280	start = True
	281	tr_count = 1
	282	total_imported = 0
	283	total_not_imported = 0
	284	total = 0
	285	iname = "%s" % filename
	286	not_imported = []
	287	valid_records = []
	288	invalid_records = []
	289	duplicate_records = []
	290	d = {}
	291	d['mode'] = mode
	292	d['valid_records'] = valid_records
	293	d['invalid_records'] = invalid_records
	294	d['invalid_records'] = duplicate_records
	295	# d['import_fn'] = import_fn
	296	# d['imported_fn'] = imported_fn
	297	# d['not_imported_fn'] = not_imported_fn
	298	validators = {}
	299	for widget in layout.keys():
	300	try:
	301	validators[widget] = layout[widget].validate
	302	except AttributeError:
	303	logger.info('%s has no validate attribute' % widget)
	304	return d
	305	for item in csv_items:
	306	if start:
	307	start = False
	308	logger.info('%s starts import from %s.csv' % (member,filename))
	309	#import_keys = [k for k in item.keys() if not k.startswith('ignore')]
	310	attrs = csv.reader(open("%s/import/%s.csv" % (i_home,filename),"rb")).next()
	311	import_keys = [k for k in attrs if not (k.startswith('ignore') or k.isupper())]
	312	diff2schema = set(import_keys).difference(set(schema.keys()))
	313	diff2layout = set(import_keys).difference(set(layout.keys()))
	314	if diff2layout:
	315	em = "not ignorable key(s) %s found in heading" % diff2layout
	316	logger.info(em)
	317	return d
	318	# s = ','.join(['"%s"' % fn for fn in import_keys])
	319	# open(not_imported_fn,"a").write(s + ',"Error"'+ '\n')
	320	# #s = '"id",' + s
	321	# open(imported_fn,"a").write(s + '\n')
	322	# format = ','.join(['"%%(%s)s"' % fn for fn in import_keys])
	323	# format_error = format + ',"%(Error)s"'
	324	# #format = '"%(id)s",'+ format
	325	adapters = [MappingStorageAdapter(schema, item)]
	326	dm = DataModel(item, adapters,context=self)
	327	ds = DataStructure(data=item,datamodel=dm)
	328	error_string = ""
	329	for k in import_keys:
	330	if not validators[k](ds,mode=mode):
	331	error_string += " %s : %s" % (k,ds.getError(k))
	332	if error_string:
	333	item['Error'] = error_string
	334	#invalid_records.append(dm)
	335	invalid_records.append(item)
	336	total_not_imported += 1
	337	else:
	338	em = format % item
	339	valid_records.append(dm)
	340	#logger.info("%(total_imported)d of %(total)d %(em)s" % vars())
	341	tr_count += 1
	342	total_imported += 1
	343	total += 1
	344	# if len(imported) > 0:
	345	# open(imported_fn,"a").write('\n'.join(imported))
	346	# if len(not_imported) > 0:
	347	# open(not_imported_fn,"a").write('\n'.join(not_imported))
	348	#em = "Imported: %d, not imported: %d of total %d" % (total_imported,total_not_imported,total)
	349	d['imported'] = total_imported
	350	d['not_imported'] = total_not_imported
	351	d['valid_records'] = valid_records
	352	d['invalid_records'] = invalid_records
	353	return d
	354	###)
	355
[2396]	356	security.declarePublic("missingValue")###(
	357	def missingValue(self):
	358	from Missing import MV
	359	return MV
	360	###)
[2094]	361	###)
[834]	362
[1146]	363	class AccommodationTable(WAeUPTable): ###(
[834]	364
[404]	365	meta_type = 'WAeUP Accommodation Tool'
[2094]	366	name = "portal_accommodation"
[502]	367	key = "bed"
[3043]	368	not_occupied = NOT_OCCUPIED
[2094]	369	def __init__(self,name=None):
	370	if name == None:
	371	name = self.name
	372	WAeUPTable.__init__(self, name)
[2866]	373
[3772]	374	def searchAndReserveBed(self, student_id,bed_type,random_order=False): ###(
[3406]	375	logger = logging.getLogger('WAeUPTables.AccommodationTable.searchAndReserveBed')
[2845]	376	records = self.evalAdvancedQuery(Eq('student',student_id))
[3406]	377	if len(records) == 1:
	378	#return -1,"Student with Id %s already booked bed %s." % (student_id,records[0].bed)
	379	logger.info('%s found (reserved) bed %s' % (student_id,records[0].bed))
	380	return -1,records[0].bed
	381	elif len(records) > 1:
	382	logger.info('%s found more than one (reserved) bed' % (student_id))
[3408]	383	return -3,'more than one bed'
[2845]	384	query = Eq('bed_type',bed_type) & Eq('student',NOT_OCCUPIED)
	385	records = self.evalAdvancedQuery(query,sortSpecs=('sort_id','bed'))
[635]	386	if len(records) == 0:
[3408]	387	logger.info('no bed %s available for %s' % (bed_type,student_id))
[3406]	388	return -2,"no bed"
[3772]	389	if random_order:
	390	import random
	391	bed_no = random.randint(0,len(records)-1)
	392	else:
	393	bed_no = 0
	394	rec = records[bed_no]
[635]	395	self.modifyRecord(bed=rec.bed,student=student_id)
[3406]	396	logger.info('%s booked bed %s' % (student_id,rec.bed))
[635]	397	return 1,rec.bed
[3043]	398	###)
[363]	399
[834]	400
[404]	401	InitializeClass(AccommodationTable)
[411]	402
[1146]	403	###)
	404
	405	class PinTable(WAeUPTable): ###(
[1030]	406	from ZODB.POSException import ConflictError
[2973]	407	security = ClassSecurityInfo()
[440]	408	meta_type = 'WAeUP Pin Tool'
[2094]	409	name = "portal_pins"
[502]	410	key = 'pin'
[2859]	411
[2094]	412	def __init__(self,name=None):
	413	if name == None:
	414	name = self.name
	415	WAeUPTable.__init__(self, name)
[1082]	416
[2973]	417	security.declareProtected(ModifyPortalContent,"dumpAll")###(
[4546]	418	def dumpAll(self,include_unused=None,index=None):
[2973]	419	"""dump all data in the table to a csv"""
	420	member = self.portal_membership.getAuthenticatedMember()
[2974]	421	logger = logging.getLogger('WAeUPTables.PinTable.dumpAll')
[2973]	422	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	423	export_file = "%s/export/%s_%s.csv" % (i_home,self.__name__,current,)
	424	res_list = []
	425	lines = []
	426	if hasattr(self,"export_keys"):
	427	fields = self.export_keys
	428	else:
	429	fields = []
	430	for f in self.schema():
	431	fields.append(f)
	432	headline = ','.join(fields)
	433	out = open(export_file,"wb")
	434	out.write(headline +'\n')
	435	out.close()
	436	out = open(export_file,"a")
	437	csv_writer = csv.DictWriter(out,fields,)
[5581]	438	if include_unused is not None and str(member) not in ('admin'):
[2973]	439	logger.info('%s tries to dump pintable with unused pins' % (member))
	440	return
	441	if include_unused is not None:
	442	records = self()
	443	else:
	444	records = self.evalAdvancedQuery(~Eq('student',''))
	445	nr2export = len(records)
	446	logger.info('%s starts dumping, %s records to export' % (member,nr2export))
	447	chunk = 2000
	448	total = 0
	449	start = DateTime.DateTime().timeTime()
	450	start_chunk = DateTime.DateTime().timeTime()
	451	for record in records:
	452	not_all = False
[4546]	453	d = self.record2dict(fields,record,index)
[2973]	454	lines.append(d)
	455	total += 1
	456	if total and not total % chunk or total == len(records):
	457	csv_writer.writerows(lines)
	458	anz = len(lines)
	459	logger.info("wrote %(anz)d total written %(total)d" % vars())
	460	end_chunk = DateTime.DateTime().timeTime()
	461	duration = end_chunk-start_chunk
	462	per_record = duration/anz
	463	till_now = end_chunk - start
	464	avarage_per_record = till_now/total
	465	estimated_end = DateTime.DateTime(start + avarage_per_record * nr2export)
	466	estimated_end = estimated_end.strftime("%H:%M:%S")
	467	logger.info('%(duration)4.1f, %(per_record)4.3f,end %(estimated_end)s' % vars())
	468	start_chunk = DateTime.DateTime().timeTime()
	469	lines = []
	470	end = DateTime.DateTime().timeTime()
	471	logger.info('total time %6.2f m' % ((end-start)/60))
	472	import os
	473	filename, extension = os.path.splitext(export_file)
	474	from subprocess import call
	475	msg = "wrote %(total)d records to %(export_file)s" % vars()
	476	#try:
	477	# retcode = call('gzip %s' % (export_file),shell=True)
	478	# if retcode == 0:
	479	# msg = "wrote %(total)d records to %(export_file)s.gz" % vars()
	480	#except OSError, e:
	481	# retcode = -99
	482	# logger.info("zip failed with %s" % e)
	483	logger.info(msg)
	484	args = {'portal_status_message': msg}
	485	#url = self.REQUEST.get('URL1') + '?' + urlencode(args)
	486	url = self.REQUEST.get('URL2')
	487	return self.REQUEST.RESPONSE.redirect(url)
	488	###)
[1082]	489
[2973]	490
	491
[710]	492	def searchAndSetRecord(self, uid, student_id,prefix):
[2191]	493
	494	# The following line must be activated after resetting the
	495	# the portal_pins table. This is to avoid duplicate entries
[2184]	496	# and disable duplicate payments.
[2191]	497
[2184]	498	#student_id = student_id.upper()
	499
[2716]	500	#records = self.searchResults(student = student_id)
[2579]	501	#if len(records) > 0 and prefix in ('CLR','APP'):
	502	# for r in records:
	503	# if r.pin != uid and r.prefix_batch.startswith(prefix):
	504	# return -2
[502]	505	records = self.searchResults({"%s" % self.key : uid})
	506	if len(records) > 1:
	507	# Can not happen, but anyway...
	508	raise ValueError("More than one record with uid %s" % uid)
	509	if len(records) == 0:
[2766]	510	return -1,None
[502]	511	record = records[0]
	512	if record.student == "":
	513	record_data = {}
	514	for field in self.schema() + self.indexes():
	515	record_data[field] = getattr(record, field)
	516	# Add the updated data:
[635]	517	record_data['student'] = student_id
[1030]	518	try:
	519	self.catalog_object(dict2ob(record_data), uid)
[2766]	520	return 1,record
[1030]	521	except ConflictError:
[2766]	522	return 2,record
[990]	523	if record.student.upper() != student_id.upper():
[2766]	524	return 0,record
[997]	525	if record.student.upper() == student_id.upper():
[2766]	526	return 2,record
	527	return -3,record
[440]	528	InitializeClass(PinTable)
[1146]	529	###)
[966]	530
[1146]	531	class PumeResultsTable(WAeUPTable): ###(
	532
[966]	533	meta_type = 'WAeUP PumeResults Tool'
[2094]	534	name = "portal_pumeresults"
[966]	535	key = "jamb_reg_no"
[2094]	536	def __init__(self,name=None):
	537	if name == None:
	538	name = self.name
	539	WAeUPTable.__init__(self, name)
[966]	540
	541
	542	InitializeClass(PumeResultsTable)
	543
[1146]	544	###)
[971]	545
[2094]	546	class ApplicantsCatalog(WAeUPTable): ###(
	547
[2113]	548	meta_type = 'WAeUP Applicants Catalog'
[2094]	549	name = "applicants_catalog"
	550	key = "reg_no"
	551	security = ClassSecurityInfo()
[2537]	552	#export_keys = (
	553	# "reg_no",
	554	# "status",
	555	# "lastname",
	556	# "sex",
	557	# "date_of_birth",
	558	# "lga",
	559	# "email",
	560	# "phone",
	561	# "passport",
	562	# "entry_mode",
	563	# "pin",
	564	# "screening_type",
	565	# "registration_date",
	566	# "testdate",
	567	# "application_date",
	568	# "screening_date",
	569	# "faculty",
	570	# "department",
	571	# "course1",
	572	# "course2",
	573	# "course3",
	574	# "eng_score",
	575	# "subj1",
	576	# "subj1score",
	577	# "subj2",
	578	# "subj2score",
	579	# "subj3",
	580	# "subj3score",
	581	# "aggregate",
	582	# "course_admitted",
	583	# )
[2632]	584
[2094]	585	def __init__(self,name=None):
	586	if name == None:
	587	name = self.name
	588	WAeUPTable.__init__(self, name)
	589
[2185]	590	security.declareProtected(ModifyPortalContent,"new_importCSV")###(
	591	def new_importCSV(self,filename="JAMB_data",
	592	schema_id="application",
[2503]	593	layout_id="import_application",
[2185]	594	mode='add'):
	595	""" import JAMB data """
	596	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	597	pm = self.portal_membership
	598	member = pm.getAuthenticatedMember()
	599	logger = logging.getLogger('WAeUPTables.ApplicantsCatalog.importCSV')
	600	lock_fn = "%s/import/%s_import_lock" % (i_home,filename)
	601	import_fn = "%s/import/%s.csv" % (i_home,filename)
	602	if mode not in ('add','edit'):
	603	logger.info("invalid mode: %s" % mode)
	604	if os.path.exists(lock_fn):
	605	logger.info("import of %(import_fn)s already in progress" % vars())
	606	return
	607	lock_file = open(lock_fn,"w")
	608	lock_file.write("%(current)s \n" % vars())
	609	lock_file.close()
	610	invalid_fn = "%s/import/%s_not_imported%s.csv" % (i_home,filename,current)
	611	duplicate_fn = "%s/import/%s_not_imported%s.csv" % (i_home,filename,current)
	612	stool = getToolByName(self, 'portal_schemas')
	613	ltool = getToolByName(self, 'portal_layouts')
	614	schema = stool._getOb(schema_id)
	615	if schema is None:
	616	em = 'No such schema %s' % schema_id
	617	logger.error(em)
	618	return
	619	for postfix in ('_import',''):
	620	layout_name = "%(layout_id)s%(postfix)s" % vars()
	621	if hasattr(ltool,layout_name):
	622	break
	623	layout = ltool._getOb(layout_name)
	624	if layout is None:
	625	em = 'No such layout %s' % layout_id
	626	logger.error(em)
	627	return
	628	try:
	629	csv_file = csv.DictReader(open(import_fn,"rb"))
	630	except:
	631	em = 'Error reading %s.csv' % filename
	632	logger.error(em)
[2191]	633	return
[2185]	634	d = self._import_new(csv_items,schema,layout,mode,logger)
	635	imported = []
	636	edited = []
	637	duplicates = []
	638	not_found = []
	639	if len(d['valid_records']) > 0:
	640	for record in d['valid_records']:
	641	#import pdb;pdb.set_trace()
	642	if mode == "add":
	643	try:
	644	self.addRecord(**dict(record.items()))
	645	imported.append(**dict(record.items()))
	646	logger.info("added %s" % record.items())
	647	except ValueError:
	648	dupplicate.append(**dict(record.items()))
	649	logger.info("duplicate %s" % record.items())
	650	elif mode == "edit":
	651	try:
	652	self.modifyRecord(**dict(record.items()))
	653	edited.append(**dict(record.items()))
	654	logger.info("edited %s" % record.items())
	655	except KeyError:
	656	not_found.append(**dict(record.items()))
	657	logger.info("not found %s" % record.items())
	658	invalid = d['invalid_records']
	659	for itype in ("imported","edited","not_found","duplicate","invalid"):
	660	outlist = locals[itype]
	661	if len(outlist):
	662	d = {}
	663	for k in outlist[0].keys():
	664	d[k] = k
[2191]	665	outlist[0] = d
[2185]	666	outfile = open("file_name_%s" % itype,'w')
	667	csv.DictWriter(outfile,outlist[0].keys()).writerows(outlist)
	668	logger.info("wrote %(itype)s records to %(, written to %(not_imported_fn)s" % d)
	669	###)
	670
[2094]	671	security.declareProtected(ModifyPortalContent,"importCSV")###(
	672	def importCSV(self,filename="JAMB_data",
	673	schema_id="application",
[2508]	674	layout_id="application_pce",
[2094]	675	mode='add'):
	676	""" import JAMB data """
	677	stool = getToolByName(self, 'portal_schemas')
	678	ltool = getToolByName(self, 'portal_layouts')
	679	schema = stool._getOb(schema_id)
	680	if schema is None:
	681	em = 'No such schema %s' % schema_id
	682	logger.error(em)
	683	return
	684	layout = ltool._getOb(layout_id)
	685	if layout is None:
	686	em = 'No such layout %s' % layout_id
	687	logger.error(em)
	688	return
[2099]	689	logger = logging.getLogger('WAeUPTables.ApplicantsCatalog.importCSV')
[2185]	690	d = self._import_old(filename,schema,layout,mode,logger)
[2094]	691	if len(d['valid_records']) > 0:
	692	for record in d['valid_records']:
	693	#import pdb;pdb.set_trace()
	694	if mode == "add":
	695	self.addRecord(**dict(record.items()))
	696	logger.info("added %s" % record.items())
	697	elif mode == "edit":
	698	self.modifyRecord(**dict(record.items()))
	699	logger.info("edited %s" % record.items())
	700	else:
	701	logger.info("invalid mode: %s" % mode)
	702	logger.info("%(mode)sed %(imported)d records, invalid written to %(not_imported_fn)s" % d)
[2632]	703	###)
[2094]	704
	705	InitializeClass(ApplicantsCatalog)
	706
	707	###)
	708
[1146]	709	class StudentsCatalog(WAeUPTable): ###(
[1620]	710	security = ClassSecurityInfo()
[1146]	711
[971]	712	meta_type = 'WAeUP Students Catalog'
	713	name = "students_catalog"
	714	key = "id"
[1700]	715	affected_types = { ###(
[1749]	716	'StudentApplication':
[2069]	717	{'id': 'application',
	718	'fields':
	719	('jamb_reg_no',
	720	'entry_mode',
	721	#'entry_level',
	722	'entry_session',
	723	)
	724	},
[1700]	725	'StudentClearance':
[2069]	726	{'id': 'clearance',
	727	'fields':
	728	('matric_no',
	729	'lga',
[5200]	730	'date_of_birth', # birthday
[2069]	731	)
	732	},
	733	'StudentPersonal':
	734	{'id': 'personal',
	735	'fields':
	736	('name',
	737	'sex',
	738	'perm_address',
	739	'email',
	740	'phone',
[5200]	741	'marit_stat',
[5202]	742	'firstname',
	743	'middlename',
	744	'lastname',
[2069]	745	)
	746	},
	747	'StudentStudyCourse':
	748	{'id': 'study_course',
	749	'fields':
	750	('course', # study_course
	751	'faculty', # from certificate
	752	'department', # from certificate
	753	'end_level', # from certificate
	754	'level', # current_level
[3780]	755	'mode', # from certificate
[2069]	756	'session', # current_session
	757	'verdict', # current_verdict
	758	)
	759	},
	760	}
[1700]	761	###)
[1625]	762
[2094]	763	def __init__(self,name=None):
	764	if name == None:
	765	name = self.name
	766	WAeUPTable.__init__(self, name)
[1620]	767	return
[5581]	768
	769	security.declareProtected(ModifyPortalContent,"exportMoodleData") ###(
	770	def exportMoodleData(self):
	771	"export a WAeUPTable"
	772	member = self.portal_membership.getAuthenticatedMember()
	773	logger = logging.getLogger('WAeUPTables.StudentsCatalog.exportMoodleData')
	774	if str(member) not in ('admin'):
	775	logger.info('%s tries to dump Moodle Data' % (member))
	776	return
	777	fields = [field for field in self.schema()]
[5583]	778	export_fields = ['username','firstname','lastname','email','currentsession','regstate','password','city','country','deleted']
[5581]	779	format = ','.join(['"%%(%s)s"' % fn for fn in export_fields])
	780	csv = []
	781	csv.append(','.join(['"%s"' % fn for fn in export_fields]))
	782	#import pdb;pdb.set_trace()
	783	for uid in self._catalog.uids:
	784	records = self.searchResults({"%s" % self.key : uid})
	785	if len(records) > 1:
	786	# Can not happen, but anyway...
	787	raise ValueError("More than one record with uid %s" % uid)
	788	if len(records) == 0:
	789	raise KeyError("No record for uid %s" % uid)
[5583]	790	rec = self.record2dict(fields,records[0],None)
	791	fn = rec['firstname'].replace(',',' ')
	792	mn = rec['middlename'].replace(',',' ')
	793	ln = rec['lastname'].replace(',',' ')
	794	rec['firstname'] = fn + ' ' + mn
	795	rec['lastname'] = ln
	796	rec['regstate'] = rec['review_state']
	797	rec['currentsession'] = rec['session']
[5581]	798	rec['username'] = rec['id']
[5583]	799	rec['city'] = ''
	800	rec['country'] = 'ng'
	801	rec['deleted'] = '0'
[5581]	802	rec['password'] = self.waeup_tool.getCredential(rec['id'])
	803	csv.append(format % rec)
	804	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	805	open("%s/export/moodle-%s.csv" % (i_home,current),"w+").write('\n'.join(csv))
	806	return 'ready'
[1625]	807
[1700]	808	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None):
	809	""" clears the whole enchilada """
	810	self._catalog.clear()
[971]	811
[1700]	812	if REQUEST and RESPONSE:
	813	RESPONSE.redirect(
	814	URL1 +
	815	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20Cleared')
[971]	816
[1700]	817	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
	818	""" clear the catalog, then re-index everything """
	819
	820	elapse = time.time()
	821	c_elapse = time.clock()
	822
	823	pgthreshold = self._getProgressThreshold()
	824	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
	825	self.refreshCatalog(clear=1, pghandler=handler)
	826
	827	elapse = time.time() - elapse
	828	c_elapse = time.clock() - c_elapse
	829
	830	RESPONSE.redirect(
	831	URL1 +
	832	'/manage_catalogAdvanced?manage_tabs_message=' +
	833	urllib.quote('Catalog Updated \n'
	834	'Total time: %s\n'
	835	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
	836	###)
	837
[2084]	838	def fill_certificates_dict(self): ###(
[2078]	839	"return certificate data in dict"
	840	certificates_brains = self.portal_catalog(portal_type ='Certificate')
	841	d = {}
	842	for cb in certificates_brains:
	843	certificate_doc = cb.getObject().getContent()
	844	cb_path = cb.getPath().split('/')
	845	ld = {}
	846	ld['faculty'] = cb_path[-4]
	847	ld['department'] = cb_path[-3]
	848	ld['end_level'] = getattr(certificate_doc,'end_level','999')
[3348]	849	ld['study_mode'] = getattr(certificate_doc,'study_mode','')
[2078]	850	d[cb.getId] = ld
	851	return d
[2084]	852	###)
	853
[2078]	854	def get_from_doc_department(self,doc,cached_data={}): ###(
[1620]	855	"return the students department"
[1700]	856	if doc is None:
[1620]	857	return None
[3354]	858	if hasattr(self,"_v_certificates") and self._v_certificates.has_key(doc.study_course):
[3348]	859	return self._v_certificates[doc.study_course]['department']
[1700]	860	certificate_res = self.portal_catalog(id = doc.study_course)
[1620]	861	if len(certificate_res) != 1:
	862	return None
	863	return certificate_res[0].getPath().split('/')[-3]
	864
[2078]	865	def get_from_doc_faculty(self,doc,cached_data={}):
[1700]	866	"return the students faculty"
	867	if doc is None:
[1620]	868	return None
[3354]	869	if hasattr(self,"_v_certificates") and self._v_certificates.has_key(doc.study_course):
[3348]	870	return self._v_certificates[doc.study_course]['faculty']
[1700]	871	certificate_res = self.portal_catalog(id = doc.study_course)
	872	if len(certificate_res) != 1:
	873	return None
	874	return certificate_res[0].getPath().split('/')[-4]
[1620]	875
[2099]	876	def get_from_doc_end_level(self,doc,cached_data={}):
[2069]	877	"return the students end_level"
	878	if doc is None:
	879	return None
[3354]	880	if hasattr(self,"_v_certificates") and self._v_certificates.has_key(doc.study_course):
[3348]	881	return self._v_certificates[doc.study_course]['end_level']
[2069]	882	certificate_res = self.portal_catalog(id = doc.study_course)
	883	if len(certificate_res) != 1:
	884	return None
	885	return getattr(certificate_res[0].getObject().getContent(),'end_level','unknown')
	886
[2078]	887	def get_from_doc_level(self,doc,cached_data={}):
[1700]	888	"return the students level"
	889	if doc is None:
[1620]	890	return None
[1700]	891	return getattr(doc,'current_level',None)
[1620]	892
[3780]	893	#def get_from_doc_mode(self,doc,cached_data={}):
	894	# "return the students mode"
	895	# if doc is None:
	896	# return None
	897	# cm = getattr(doc,'current_mode',None)
	898	# return cm
	899
[2078]	900	def get_from_doc_mode(self,doc,cached_data={}):
[1705]	901	"return the students mode"
[1700]	902	if doc is None:
[1620]	903	return None
[3780]	904	if hasattr(self,"_v_certificates") and self._v_certificates.has_key(doc.study_course):
	905	return self._v_certificates[doc.study_course]['study_mode']
	906	certificate_res = self.portal_catalog(id = doc.study_course)
	907	if len(certificate_res) != 1:
	908	return None
	909	return getattr(certificate_res[0].getObject().getContent(),'study_mode','unknown')
[1625]	910
[1749]	911
[5200]	912	def get_from_doc_marit_stat(self,doc,cached_data={}):
	913	"return the students marit_stat"
	914	if doc is None:
	915	return None
	916	ms = getattr(doc,'marit_stat',None)
	917	if ms == True:
	918	return 'married'
	919	elif ms == False:
	920	return 'single'
	921	else:
	922	return 'undefined'
	923
	924	def get_from_doc_date_of_birth(self,doc,cached_data={}):
	925	"return the students date of birth"
	926	if doc is None:
	927	return None
	928	return getattr(doc,'birthday',None)
	929
[2078]	930	def get_from_doc_session(self,doc,cached_data={}):
[1705]	931	"return the students current_session"
	932	if doc is None:
	933	return None
	934	return getattr(doc,'current_session',None)
	935
[2078]	936	def get_from_doc_entry_session(self,doc,cached_data={}):
[1700]	937	"return the students entry_session"
	938	if doc is None:
[1620]	939	return None
[1705]	940	es = getattr(doc,'entry_session',None)
[3958]	941	if es is not None and len(es) < 3:
[1705]	942	return es
[3743]	943	elif len(es) == 9:
	944	return es[2:4]
[1700]	945	try:
	946	digit = int(doc.jamb_reg_no[0])
	947	except:
[1986]	948	return "-1"
[3958]	949	if digit < 9:
[1700]	950	return "0%c" % doc.jamb_reg_no[0]
	951	return "9%c" % doc.jamb_reg_no[0]
	952
[2078]	953	def get_from_doc_course(self,doc,cached_data={}):
[1620]	954	"return the students study_course"
[1700]	955	if doc is None:
[1620]	956	return None
[1700]	957	return getattr(doc,'study_course',None)
[1620]	958
[2078]	959	def get_from_doc_name(self,doc,cached_data={}):
[1620]	960	"return the students name from the personal"
[1700]	961	if doc is None:
[1620]	962	return None
	963	return "%s %s %s" % (doc.firstname,doc.middlename,doc.lastname)
	964
[2078]	965	def get_from_doc_verdict(self,doc,cached_data={}):
[1700]	966	"return the students study_course"
	967	if doc is None:
[1620]	968	return None
[1700]	969	return getattr(doc,'current_verdict',None)
[1702]	970	###)
[1620]	971
[1702]	972	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
[3781]	973	if not hasattr(self,'_v_certificates'):
	974	self._v_certificates = self.fill_certificates_dict()
[1702]	975	if isinstance(name, str):
	976	name = (name,)
[1749]	977	reindextypes = {}
[1702]	978	reindex_special = []
	979	for n in name:
[3781]	980	if n in ("review_state"):
[1702]	981	reindex_special.append(n)
	982	else:
	983	for pt in self.affected_types.keys():
[1707]	984	if n in self.affected_types[pt]['fields']:
[1702]	985	if reindextypes.has_key(pt):
	986	reindextypes[pt].append(n)
	987	else:
	988	reindextypes[pt]= [n]
	989	break
[3781]	990	#cached_data = {}
	991	#if set(name).intersection(set(('faculty','department','end_level','mode'))):
	992	# cached_data = self.fill_certificates_dict()
[1702]	993	students = self.portal_catalog(portal_type="Student")
[1954]	994	if hasattr(self,'portal_catalog_real'):
	995	aq_portal = self.portal_catalog_real.evalAdvancedQuery
	996	else:
	997	aq_portal = self.portal_catalog.evalAdvancedQuery
[1702]	998	num_objects = len(students)
	999	if pghandler:
	1000	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
	1001	noattr = set(('StudentClearance','StudentPersonal')) & set(reindextypes.keys())
[2084]	1002	#import pdb;pdb.set_trace()
[1702]	1003	for i in xrange(num_objects):
	1004	if pghandler: pghandler.report(i)
	1005	student_brain = students[i]
[1707]	1006	student_object = student_brain.getObject()
[1702]	1007	data = {}
	1008	modified = False
	1009	sid = data['id'] = student_brain.getId
	1010	if reindex_special and 'review_state' in reindex_special:
	1011	modified = True
[3665]	1012	data['review_state'] = student_object.portal_workflow.getInfoFor(student_object,'review_state',None)
[1707]	1013	sub_objects = False
	1014	for pt in reindextypes.keys():
[1702]	1015	modified = True
[1707]	1016	try:
	1017	doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
	1018	sub_objects = True
	1019	except:
	1020	continue
[2084]	1021	for field in set(name).intersection(self.affected_types[pt]['fields']):
[1707]	1022	if hasattr(self,'get_from_doc_%s' % field):
[3781]	1023	data[field] = getattr(self,'get_from_doc_%s' % field)(doc)
[1707]	1024	else:
	1025	data[field] = getattr(doc,field)
	1026	if not sub_objects and noattr:
	1027	import_res = self.returning_import(id = sid)
	1028	if not import_res:
	1029	continue
	1030	import_record = import_res[0]
	1031	data['matric_no'] = import_record.matric_no
	1032	data['sex'] = import_record.Sex == 'F'
	1033	data['name'] = "%s %s %s" % (import_record.Firstname,
	1034	import_record.Middlename,
	1035	import_record.Lastname)
[1815]	1036	data['jamb_reg_no'] = import_record.Entryregno
[1702]	1037	if modified:
	1038	self.modifyRecord(**data)
	1039	if pghandler: pghandler.finish()
	1040	###)
[1620]	1041
	1042	def refreshCatalog(self, clear=0, pghandler=None): ###(
	1043	""" re-index everything we can find """
	1044	students_folder = self.portal_url.getPortalObject().campus.students
	1045	if clear:
[1724]	1046	self._catalog.clear()
[1700]	1047	students = self.portal_catalog(portal_type="Student")
	1048	num_objects = len(students)
[3781]	1049	#cached_data = self.fill_certificates_dict()
	1050	if not hasattr(self,'_v_certificates'):
	1051	self._v_certificates = self.fill_certificates_dict()
[1620]	1052	if pghandler:
	1053	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
	1054	for i in xrange(num_objects):
	1055	if pghandler: pghandler.report(i)
[1700]	1056	student_brain = students[i]
	1057	spath = student_brain.getPath()
[1727]	1058	student_object = student_brain.getObject()
[1620]	1059	data = {}
[1700]	1060	sid = data['id'] = student_brain.getId
[3665]	1061	#data['review_state'] = student_brain.review_state
	1062	data['review_state'] = student_object.portal_workflow.getInfoFor(student_object,'review_state',None)
[1707]	1063	sub_objects = False
	1064	for pt in self.affected_types.keys():
	1065	modified = True
	1066	try:
	1067	doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
	1068	sub_objects = True
	1069	except:
[1727]	1070	#from pdb import set_trace;set_trace()
[1707]	1071	continue
	1072	for field in self.affected_types[pt]['fields']:
	1073	if hasattr(self,'get_from_doc_%s' % field):
[2078]	1074	data[field] = getattr(self,'get_from_doc_%s' % field)(doc,
	1075	cached_data=cached_data)
[1707]	1076	else:
[1727]	1077	data[field] = getattr(doc,field,None)
	1078	if not sub_objects:
[1700]	1079	import_res = self.returning_import(id = sid)
	1080	if not import_res:
[1620]	1081	continue
[1700]	1082	import_record = import_res[0]
	1083	data['matric_no'] = import_record.matric_no
	1084	data['sex'] = import_record.Sex == 'F'
	1085	data['name'] = "%s %s %s" % (import_record.Firstname,
	1086	import_record.Middlename,
	1087	import_record.Lastname)
[1815]	1088	data['jamb_reg_no'] = import_record.Entryregno
[1700]	1089	self.addRecord(**data)
[1620]	1090	if pghandler: pghandler.finish()
	1091	###)
	1092
[1700]	1093	security.declarePrivate('notify_event_listener') ###(
[1620]	1094	def notify_event_listener(self,event_type,object,infos):
	1095	"listen for events"
[1716]	1096	if not infos.has_key('rpath'):
	1097	return
[1702]	1098	pt = getattr(object,'portal_type',None)
	1099	mt = getattr(object,'meta_type',None)
[1954]	1100	students_catalog = self
[1702]	1101	data = {}
	1102	if pt == 'Student' and\
	1103	mt == 'CPS Proxy Folder' and\
	1104	event_type.startswith('workflow'):
	1105	data['id'] = object.getId()
	1106	data['review_state'] = self.portal_workflow.getInfoFor(object,'review_state',None)
	1107	students_catalog.modifyRecord(**data)
	1108	return
[1700]	1109	rpl = infos['rpath'].split('/')
[2396]	1110	if pt == 'Student' and mt == 'CPS Proxy Folder':
[1700]	1111	student_id = object.id
[2396]	1112	if event_type == "sys_add_object":
	1113	try:
	1114	self.addRecord(id = student_id)
	1115	except ValueError:
	1116	pass
	1117	return
	1118	elif event_type == 'sys_del_object':
	1119	self.deleteRecord(student_id)
[1716]	1120	if pt not in self.affected_types.keys():
[1700]	1121	return
[1716]	1122	if event_type not in ('sys_modify_object'):
	1123	return
[1700]	1124	if mt == 'CPS Proxy Folder':
	1125	return
[3354]	1126	if not hasattr(self,'_v_certificates'):
	1127	self._v_certificates = self.fill_certificates_dict()
[1716]	1128	for field in self.affected_types[pt]['fields']:
[1700]	1129	if hasattr(self,'get_from_doc_%s' % field):
	1130	data[field] = getattr(self,'get_from_doc_%s' % field)(object)
	1131	else:
	1132	data[field] = getattr(object,field)
	1133	data['id'] = rpl[2]
[1716]	1134	self.modifyRecord(**data)
[1700]	1135	###)
[1620]	1136
[1625]	1137
[971]	1138	InitializeClass(StudentsCatalog)
	1139
[1146]	1140	###)
	1141
[3354]	1142	class CertificatesCatalog(WAeUPTable): ###(
	1143	security = ClassSecurityInfo()
	1144
	1145	meta_type = 'WAeUP Certificates Catalog'
	1146	name = "certificates_catalog"
	1147	key = "code"
	1148	def __init__(self,name=None):
	1149	if name == None:
	1150	name = self.name
	1151	WAeUPTable.__init__(self, name)
	1152
	1153	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
	1154	""" clear the catalog, then re-index everything """
	1155
	1156	elapse = time.time()
	1157	c_elapse = time.clock()
	1158
	1159	pgthreshold = self._getProgressThreshold()
	1160	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
	1161	self.refreshCatalog(clear=1, pghandler=handler)
	1162
	1163	elapse = time.time() - elapse
	1164	c_elapse = time.clock() - c_elapse
	1165
	1166	RESPONSE.redirect(
	1167	URL1 +
	1168	'/manage_catalogAdvanced?manage_tabs_message=' +
	1169	urllib.quote('Catalog Updated \n'
	1170	'Total time: %s\n'
	1171	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
	1172	###)
	1173
	1174	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
	1175	if isinstance(name, str):
	1176	name = (name,)
	1177	certificates = self.portal_catalog(portal_type="Certificate")
[3497]	1178	num_objects = len(certificates)
[3354]	1179	if pghandler:
	1180	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
	1181	for i in xrange(num_objects):
	1182	if pghandler: pghandler.report(i)
	1183	certificate_brain = certificates[i]
	1184	certificate_object = certificate_brain.getObject()
	1185	pl = certificate_brain.getPath().split('/')
	1186	data = {}
	1187	cid = data[self.key] = certificate_brain.getId
	1188	data['faculty'] = pl[-4]
	1189	data['department'] = pl[-3]
	1190	doc = certificate_object.getContent()
	1191	for field in name:
	1192	if field not in (self.key,'faculty','department'):
	1193	data[field] = getattr(doc,field)
	1194	self.modifyRecord(**data)
	1195	if pghandler: pghandler.finish()
	1196	###)
	1197
	1198	def refreshCatalog(self, clear=0, pghandler=None): ###(
	1199	""" re-index everything we can find """
	1200	if clear:
	1201	self._catalog.clear()
	1202	certificates = self.portal_catalog(portal_type="Certificate")
	1203	num_objects = len(certificates)
	1204	if pghandler:
	1205	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
	1206	#from pdb import set_trace;set_trace()
	1207	for i in xrange(num_objects):
	1208	if pghandler: pghandler.report(i)
	1209	certificate_brain = certificates[i]
	1210	certificate_doc = certificate_brain.getObject().getContent()
	1211	pl = certificate_brain.getPath().split('/')
	1212	data = {}
	1213	for field in self.schema():
	1214	data[field] = getattr(certificate_doc,field,None)
	1215	data[self.key] = certificate_brain.getId
	1216	ai = pl.index('academics')
	1217	data['faculty'] = pl[ai +1]
	1218	data['department'] = pl[ai +2]
	1219	if clear:
	1220	self.addRecord(**data)
	1221	else:
	1222	self.modifyRecord(**data)
	1223	if pghandler: pghandler.finish()
	1224	###)
	1225
	1226	security.declarePrivate('notify_event_listener') ###(
	1227	def notify_event_listener(self,event_type,object,infos):
	1228	"listen for events"
	1229	if not infos.has_key('rpath'):
	1230	return
	1231	pt = getattr(object,'portal_type',None)
	1232	mt = getattr(object,'meta_type',None)
	1233	if pt != 'Certificate':
	1234	return
	1235	data = {}
	1236	rpl = infos['rpath'].split('/')
	1237	if event_type not in ("sys_add_object","sys_modify_object","sys_del_object"):
	1238	return
	1239	certificate_id = object.getId()
	1240	data[self.key] = certificate_id
	1241	if event_type == "sys_add_object" and mt == 'CPS Proxy Folder':
	1242	try:
	1243	self.addRecord(**data)
	1244	except ValueError:
	1245	return
	1246	certificate_id = object.getId()
	1247	doc = object.getContent()
	1248	if doc is None:
	1249	return
	1250	for field in self.schema():
	1251	data[field] = getattr(doc,field,None)
	1252	data[self.key] = certificate_id
	1253	ai = rpl.index('academics')
	1254	data['faculty'] = rpl[ai +1]
	1255	data['department'] = rpl[ai +2]
	1256	self.modifyRecord(**data)
	1257	return
	1258	if event_type == "sys_del_object":
	1259	self.deleteRecord(certificate_id)
	1260	return
	1261	if event_type == "sys_modify_object" and mt == 'Certificate':
	1262	#from pdb import set_trace;set_trace()
	1263	for field in self.schema():
	1264	data[field] = getattr(object,field,None)
	1265	certificate_id = object.aq_parent.getId()
	1266	data[self.key] = certificate_id
	1267	ai = rpl.index('academics')
	1268	data['faculty'] = rpl[ai +1]
	1269	data['department'] = rpl[ai +2]
	1270	self.modifyRecord(**data)
	1271	###)
	1272
	1273
	1274	InitializeClass(CertificatesCatalog)
	1275	###)
	1276
[1146]	1277	class CoursesCatalog(WAeUPTable): ###(
[1716]	1278	security = ClassSecurityInfo()
[1146]	1279
	1280	meta_type = 'WAeUP Courses Catalog'
[2094]	1281	name = "courses_catalog"
[1146]	1282	key = "code"
[2094]	1283	def __init__(self,name=None):
	1284	if name == None:
	1285	name = self.name
	1286	WAeUPTable.__init__(self, name)
[1146]	1287
[1716]	1288	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
	1289	""" clear the catalog, then re-index everything """
[1146]	1290
[1716]	1291	elapse = time.time()
	1292	c_elapse = time.clock()
	1293
	1294	pgthreshold = self._getProgressThreshold()
	1295	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
	1296	self.refreshCatalog(clear=1, pghandler=handler)
	1297
	1298	elapse = time.time() - elapse
	1299	c_elapse = time.clock() - c_elapse
	1300
	1301	RESPONSE.redirect(
	1302	URL1 +
	1303	'/manage_catalogAdvanced?manage_tabs_message=' +
	1304	urllib.quote('Catalog Updated \n'
	1305	'Total time: %s\n'
	1306	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
	1307	###)
	1308
	1309	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
	1310	if isinstance(name, str):
	1311	name = (name,)
	1312	courses = self.portal_catalog(portal_type="Course")
	1313	num_objects = len(courses)
	1314	if pghandler:
	1315	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
	1316	for i in xrange(num_objects):
	1317	if pghandler: pghandler.report(i)
	1318	course_brain = courses[i]
	1319	course_object = course_brain.getObject()
	1320	pl = course_brain.getPath().split('/')
	1321	data = {}
	1322	cid = data[self.key] = course_brain.getId
	1323	data['faculty'] = pl[-4]
	1324	data['department'] = pl[-3]
	1325	doc = course_object.getContent()
	1326	for field in name:
	1327	if field not in (self.key,'faculty','department'):
	1328	data[field] = getattr(doc,field)
	1329	self.modifyRecord(**data)
	1330	if pghandler: pghandler.finish()
	1331	###)
	1332
	1333	def refreshCatalog(self, clear=0, pghandler=None): ###(
	1334	""" re-index everything we can find """
[1724]	1335	if clear:
	1336	self._catalog.clear()
[1716]	1337	courses = self.portal_catalog(portal_type="Course")
	1338	num_objects = len(courses)
	1339	if pghandler:
	1340	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
[1724]	1341	#from pdb import set_trace;set_trace()
[1716]	1342	for i in xrange(num_objects):
	1343	if pghandler: pghandler.report(i)
	1344	course_brain = courses[i]
[1724]	1345	course_doc = course_brain.getObject().getContent()
[1716]	1346	pl = course_brain.getPath().split('/')
	1347	data = {}
[1724]	1348	for field in self.schema():
[1749]	1349	data[field] = getattr(course_doc,field,None)
[1716]	1350	data[self.key] = course_brain.getId
[1724]	1351	ai = pl.index('academics')
	1352	data['faculty'] = pl[ai +1]
	1353	data['department'] = pl[ai +2]
	1354	if clear:
	1355	self.addRecord(**data)
	1356	else:
	1357	self.modifyRecord(**data)
[1716]	1358	if pghandler: pghandler.finish()
	1359	###)
	1360
	1361	security.declarePrivate('notify_event_listener') ###(
	1362	def notify_event_listener(self,event_type,object,infos):
	1363	"listen for events"
	1364	if not infos.has_key('rpath'):
	1365	return
	1366	pt = getattr(object,'portal_type',None)
	1367	mt = getattr(object,'meta_type',None)
	1368	if pt != 'Course':
	1369	return
	1370	data = {}
	1371	rpl = infos['rpath'].split('/')
	1372	if event_type not in ("sys_add_object","sys_modify_object","sys_del_object"):
	1373	return
	1374	course_id = object.getId()
	1375	data[self.key] = course_id
[1724]	1376	if event_type == "sys_add_object" and mt == 'CPS Proxy Folder':
[1716]	1377	try:
	1378	self.addRecord(**data)
	1379	except ValueError:
[1724]	1380	return
	1381	course_id = object.getId()
	1382	doc = object.getContent()
	1383	if doc is None:
	1384	return
	1385	for field in self.schema():
[1749]	1386	data[field] = getattr(doc,field,None)
[1724]	1387	data[self.key] = course_id
	1388	ai = rpl.index('academics')
	1389	data['faculty'] = rpl[ai +1]
	1390	data['department'] = rpl[ai +2]
	1391	self.modifyRecord(**data)
	1392	return
[1716]	1393	if event_type == "sys_del_object":
	1394	self.deleteRecord(course_id)
[1724]	1395	return
[1716]	1396	if event_type == "sys_modify_object" and mt == 'Course':
[1724]	1397	#from pdb import set_trace;set_trace()
[1716]	1398	for field in self.schema():
[1749]	1399	data[field] = getattr(object,field,None)
[1716]	1400	course_id = object.aq_parent.getId()
	1401	data[self.key] = course_id
[1724]	1402	ai = rpl.index('academics')
	1403	data['faculty'] = rpl[ai +1]
	1404	data['department'] = rpl[ai +2]
[1716]	1405	self.modifyRecord(**data)
	1406	###)
	1407
	1408
[1146]	1409	InitializeClass(CoursesCatalog)
[1151]	1410	###)
[1146]	1411
[2084]	1412	class CourseResults(WAeUPTable): ###(
[2069]	1413	security = ClassSecurityInfo()
	1414
	1415	meta_type = 'WAeUP Results Catalog'
	1416	name = "course_results"
[2084]	1417	key = "key" #student_id + level + course_id
[2094]	1418	def __init__(self,name=None):
	1419	if name == None:
	1420	name = self.name
	1421	WAeUPTable.__init__(self, name)
[2084]	1422	self._queue = []
[2099]	1423
[2094]	1424	def addMultipleRecords(self, records): ###(
	1425	"""add many records"""
[3362]	1426	existing_uids = []
[2094]	1427	for data in records:
[3362]	1428	uid = "%(student_id)s\|%(level_id)s\|%(course_id)s" % data
[2094]	1429	data['%s' % self.key] = uid
[3362]	1430	query = Eq(self.key, uid)
	1431	res = self.course_results.evalAdvancedQuery(query)
[2094]	1432	if len(res) > 0:
[3362]	1433	rec = res[0]
	1434	equal = True
	1435	for attr in ('student_id','level_id','course_id'):
	1436	if getattr(rec,attr,'') != data[attr]:
	1437	equal = False
	1438	break
	1439	if equal:
	1440	existing_uids += uid,
	1441	continue
[2094]	1442	self.catalog_object(dict2ob(data), uid=uid)
[3362]	1443	return existing_uids
[2094]	1444	###)
	1445
[2434]	1446	def deleteResultsHere(self,level_id,student_id): ###(
	1447	query = Eq('student_id',student_id) & Eq('level_id', level_id)
	1448	course_results = self.course_results.evalAdvancedQuery(query)
[3362]	1449	#import pdb;pdb.set_trace()
[2434]	1450	for result in course_results:
	1451	self.deleteRecord(result.key)
[2084]	1452	###)
	1453
[2434]	1454	def moveResultsHere(self,level,student_id): ###(
	1455	#import pdb;pdb.set_trace()
	1456	level_id = level.getId()
	1457	query = Eq('student_id',student_id) & Eq('level_id', level_id)
	1458	course_results = self.course_results.evalAdvancedQuery(query)
[2437]	1459	existing_courses = [cr.code for cr in course_results]
[2434]	1460	to_delete = []
	1461	for code,obj in level.objectItems():
[2437]	1462	to_delete.append(code)
[2434]	1463	carry_over = False
	1464	if code.endswith('_co'):
	1465	carry_over = True
[2437]	1466	code = code[:-3]
[2434]	1467	if code in existing_courses:
[2094]	1468	continue
[2434]	1469	course_result_doc = obj.getContent()
[2094]	1470	data = {}
[2434]	1471	course_id = code
[2094]	1472	for field in self.schema():
	1473	data[field] = getattr(course_result_doc,field,'')
	1474	data['key'] = key = "%(student_id)s\|%(level_id)s\|%(course_id)s" % vars()
[2099]	1475	data['student_id'] = student_id
	1476	data['level_id'] = level_id
[2439]	1477	session_id = self.getLevelSession(level.getContent(),student_id,level_id)
[2442]	1478	data['session_id'] = session_id
[2434]	1479	#data['queue_status'] = OBJECT_CREATED
[2099]	1480	data['code'] = course_id
[2434]	1481	data['carry_over'] = carry_over
[2094]	1482	self.catalog_object(dict2ob(data), uid=key)
[2434]	1483	level.manage_delObjects(to_delete)
	1484	###)
	1485
	1486	def getCourses(self,student_id,level_id): ###(
[2094]	1487	query = Eq('student_id',student_id) & Eq('level_id', level_id)
[2434]	1488	course_results = self.course_results.evalAdvancedQuery(query)
	1489	carry_overs = []
[2606]	1490	normal1 = []
	1491	normal2 = []
[2761]	1492	normal3 = []
[2757]	1493	total_credits = 0
	1494	gpa = 0
[2434]	1495	for brain in course_results:
	1496	d = {}
[2781]	1497
[2761]	1498	for field in self.schema():
[3707]	1499	d[field] = getattr(brain,field,None)
	1500	if repr(d[field]) == 'Missing.Value':
	1501	d[field] = ''
[2761]	1502	d['weight'] = ''
	1503	d['grade'] = ''
	1504	d['score'] = ''
	1505
[2750]	1506	if str(brain.credits).isdigit():
[2757]	1507	credits = int(brain.credits)
	1508	total_credits += credits
[2780]	1509	score = getattr(brain,'score',0)
	1510	if score and str(score).isdigit() and int(score) > 0:
	1511	score = int(score)
[3707]	1512	grade,weight = self.getGradesFromScore(score,'')
[2781]	1513	gpa += weight * credits
	1514	d['weight'] = weight
	1515	d['grade'] = grade
	1516	d['score'] = score
[3675]	1517
[3707]	1518	#if str(brain.ca1).isdigit() and str(brain.ca2).isdigit() and str(brain.exam).isdigit():
	1519	# d['score_calc'] = int(brain.ca1) + int(brain.ca2) + int(brain.exam)
	1520	#else:
	1521	# d['score_calc'] = ''
	1522	try:
	1523	d['score_calc'] = float(brain.ca1) + float(brain.ca2) + float(brain.exam)
	1524	except:
[3675]	1525	d['score_calc'] = ''
	1526
[3707]	1527	if d['score_calc']:
	1528	grade = self.getGradesFromScore(d['score_calc'],level_id)
	1529	d['grade'] = grade
	1530
[2757]	1531	d['coe'] = ''
[2434]	1532	if brain.core_or_elective:
	1533	d['coe'] = 'Core'
[2757]	1534	elif brain.core_or_elective == False:
	1535	d['coe'] = 'Elective'
[2434]	1536	id = code = d['id'] = brain.code
	1537	d['code'] = code
[2864]	1538	res = self.courses_catalog.evalAdvancedQuery(Eq('code',code))
	1539	if res:
	1540	course = res[0]
	1541	d['title'] = course.title
	1542	# The courses_catalog contains strings and integers in its semester field.
	1543	# Maybe this can be fixed by reindexing the catalog. The schema of course says 'CPS Int Field'.
	1544	d['semester'] = str(course.semester)
	1545	else:
[2866]	1546	d['title'] = "Course has been removed from course list"
[2864]	1547	d['semester'] = ''
[2448]	1548	if brain.carry_over:
[2761]	1549	d['coe'] = 'CO'
[2434]	1550	carry_overs.append(d)
	1551	else:
[2614]	1552	if d['semester'] == '1':
[2606]	1553	normal1.append(d)
[2614]	1554
	1555	elif d['semester'] == '2':
[2606]	1556	normal2.append(d)
	1557	else:
	1558	normal3.append(d)
	1559	#normal.sort(cmp=lambda x,y: cmp("%(semester)s%(code)s" % x,
	1560	# "%(semester)s%(code)s" % y))
[2503]	1561	carry_overs.sort(cmp=lambda x,y: cmp("%(semester)s%(code)s" % x,
[2460]	1562	"%(semester)s%(code)s" % y))
[2757]	1563	return total_credits,gpa,carry_overs,normal1,normal2,normal3
[2094]	1564	###)
	1565
[4693]	1566
	1567	# for transcript only
[3602]	1568	def getAllCourses(self,student_id): ###(
	1569	query = Eq('student_id',student_id)
	1570	course_results = self.course_results.evalAdvancedQuery(query)
[3603]	1571	courses = []
[3602]	1572	for brain in course_results:
	1573	d = {}
	1574
	1575	for field in self.schema():
	1576	d[field] = getattr(brain,field,'')
	1577
	1578	d['weight'] = ''
	1579	d['grade'] = ''
	1580	d['score'] = ''
	1581
	1582	if str(brain.credits).isdigit():
	1583	credits = int(brain.credits)
	1584	score = getattr(brain,'score',0)
	1585	if score and str(score).isdigit() and int(score) > 0:
	1586	score = int(score)
[4693]	1587	grade,weight = self.getGradesFromScore(score,'')
[3602]	1588	d['weight'] = weight
	1589	d['grade'] = grade
	1590	d['score'] = score
	1591	d['coe'] = ''
	1592	if brain.core_or_elective:
	1593	d['coe'] = 'Core'
	1594	elif brain.core_or_elective == False:
	1595	d['coe'] = 'Elective'
	1596	id = code = d['id'] = brain.code
	1597	d['code'] = code
	1598	res = self.courses_catalog.evalAdvancedQuery(Eq('code',code))
	1599	if res:
	1600	course = res[0]
	1601	d['title'] = course.title
	1602	# The courses_catalog contains strings and integers in its semester field.
	1603	# Maybe this can be fixed by reindexing the catalog. The schema of course says 'CPS Int Field'.
	1604	d['semester'] = str(course.semester)
	1605	else:
	1606	d['title'] = "Course has been removed from course list"
	1607	d['semester'] = ''
	1608	if brain.carry_over:
	1609	d['coe'] = 'CO'
	1610	courses.append(d)
	1611	return courses
	1612	###)
[3841]	1613
[4036]	1614	def getYearGroupAverage(self,session_id,level_id): ###(
	1615	query = Eq('session_id',session_id) & Eq('level_id',level_id)
	1616	course_results = self.course_results.evalAdvancedQuery(query)
	1617	yga1 = 0
[4302]	1618	yg1 = []
[4036]	1619	counter1 = 0
	1620	yga2 = 0
[4302]	1621	yg2 = []
[4036]	1622	counter2 = 0
	1623	yga3 = 0
[4302]	1624	yg3 = []
[4036]	1625	counter3 = 0
	1626	#import pdb;pdb.set_trace()
	1627	for brain in course_results:
	1628	try:
[4302]	1629	om = float(brain.ca1) + float(brain.ca2) + float(brain.exam)
	1630	if not om > 0:
[4036]	1631	continue
	1632	code = brain.code
	1633	res = self.courses_catalog.evalAdvancedQuery(Eq('code',code))
	1634	if res:
	1635	course = res[0]
	1636	# The courses_catalog contains strings and integers in its semester field.
	1637	# Maybe this can be fixed by reindexing the catalog. The schema of course says 'CPS Int Field'.
	1638	semester = str(course.semester)
	1639	else:
	1640	semester = ''
	1641	if semester == '1':
	1642	counter1 += 1
[4302]	1643	yga1 += om
	1644	yg1.append(om)
[4036]	1645	elif semester == '2':
	1646	counter2 += 1
[4302]	1647	yga2 += om
	1648	yg2.append(om)
[4036]	1649	if semester == '3':
	1650	counter3 += 1
[4302]	1651	yga3 += om
	1652	yg3.append(om)
[4036]	1653	except:
	1654	continue
	1655	if counter1:
	1656	yga1 /= counter1
	1657	yga1 = '%.2f' % yga1
	1658	if counter2:
	1659	yga2 /= counter2
	1660	yga2 = '%.2f' % yga2
	1661	if counter3:
	1662	yga3 /= counter3
	1663	yga3 = '%.2f' % yga3
[4302]	1664	return yga1, yga2, yga3, counter1, counter2, counter3, yg1, yg2, yg3
[4036]	1665	###)
	1666
[4302]	1667
	1668	#security.declarePublic("calculateCoursePosition")
	1669	def calculateCoursePosition(self,session_id,level_id,code,score,semester=None):
	1670	#"""calculate Course Position"""
	1671	query = Eq('session_id',session_id) & Eq('level_id',level_id) & Eq('code',code)
	1672	course_results = self.course_results.evalAdvancedQuery(query)
	1673	ygc = []
	1674	#import pdb;pdb.set_trace()
	1675	for brain in course_results:
	1676	try:
	1677	if not float(brain.ca1) + float(brain.ca2) + float(brain.exam) > 0:
	1678	continue
	1679	#code = brain.code
	1680	if semester:
	1681	res = self.courses_catalog.evalAdvancedQuery(Eq('code',code))
	1682	if res:
	1683	course = res[0]
	1684	# The courses_catalog contains strings and integers in its semester field.
	1685	# Maybe this can be fixed by reindexing the catalog. The schema of course says 'CPS Int Field'.
	1686	semester_from_course = str(course.semester)
	1687	else:
	1688	continue
	1689	if semester != semester_from_course:
	1690	continue
	1691	ygc.append(float(brain.ca1) + float(brain.ca2) + float(brain.exam))
	1692	except:
	1693	continue
	1694	ygc.sort(reverse=True)
	1695	if not len(ygc):
	1696	return 'no result'
	1697	#import pdb;pdb.set_trace()
	1698	for pos in range(len(ygc)):
	1699	if ygc[pos] <= float(score):
	1700	break
	1701	output = {}
	1702	output['pos'] = '%d of %d' % (pos+1,len(ygc))
	1703	output['ygc'] = ygc
	1704	return output
	1705
	1706	security.declareProtected(ModifyPortalContent,"calculateAllCoursePositions")
	1707	def calculateAllCoursePositions(self,session_id=None):
	1708	"""calculate All Course Positions"""
[4304]	1709	logger = logging.getLogger('WAeUPTables.CourseResults.calculateAllCoursePositions')
[4306]	1710	member = self.portal_membership.getAuthenticatedMember()
[4304]	1711	logger.info('%s starts recalculation of positions in session %s' % (member,session_id))
[4302]	1712	if session_id:
	1713	query = Eq('session_id',session_id)
	1714	else:
	1715	return 'no session_id provided'
	1716	course_results = self.course_results.evalAdvancedQuery(query)
	1717	for brain in course_results:
	1718	try:
	1719	if not float(brain.ca1) + float(brain.ca2) + float(brain.exam) > 0:
[5146]	1720	data = {}
	1721	data[self.key] = brain.key
	1722	data['pic'] = ''
	1723	self.modifyRecord(**data)
[4302]	1724	continue
	1725	res = self.courses_catalog.evalAdvancedQuery(Eq('code',brain.code))
	1726	if res:
	1727	course = res[0]
	1728	semester_from_course = str(course.semester)
	1729	else:
	1730	continue
	1731	score = float(brain.ca1) + float(brain.ca2) + float(brain.exam)
[5143]	1732	pic = self.calculateCoursePosition(session_id,brain.level_id,brain.code,score,semester_from_course)['pos']
[4302]	1733	data = {}
	1734	data[self.key] = brain.key
	1735	data['pic'] = pic
	1736	self.modifyRecord(**data)
	1737	except:
[5146]	1738	data = {}
	1739	data[self.key] = brain.key
	1740	data['pic'] = ''
	1741	self.modifyRecord(**data)
[4304]	1742	continue
	1743	logger.info('recalculation finished')
[4302]	1744	return 'ready'
	1745
[3988]	1746	def exportRemoveAllCourses(self,student_id,export=False,remove=False): ###(
[3841]	1747	""
	1748	query = Eq('student_id',student_id)
	1749	cr_catalog = self.course_results
	1750	course_results = cr_catalog.evalAdvancedQuery(query)
	1751	courses = []
	1752	fields = self.schema()
	1753	format = '"%(' + ')s","%('.join(fields) + ')s"'
	1754	for brain in course_results:
	1755	d = {}
	1756	for field in fields:
	1757	d[field] = getattr(brain,field,'')
	1758	courses.append(format % d)
	1759
	1760	if export:
	1761	export_file = "%s/export/course_results_removed.csv" % (i_home)
[3989]	1762	if not os.path.exists(export_file):
	1763	file_handler = open(export_file,"a")
	1764	headline = ','.join(fields)
	1765	file_handler.write(headline +'\n')
	1766	else:
	1767	file_handler = open(export_file,"a")
[3841]	1768	for line in courses:
	1769	file_handler.write(line +'\n')
[3602]	1770
[3841]	1771	if remove:
	1772	for brain in course_results:
	1773	key = getattr(brain,'key','')
	1774	cr_catalog.deleteRecord(key)
	1775
	1776	return courses
	1777	###)
[3984]	1778
	1779
[3841]	1780
[3602]	1781	InitializeClass(CourseResults)
	1782	###)
	1783
[1625]	1784	class OnlinePaymentsImport(WAeUPTable): ###(
[1620]	1785
	1786	meta_type = 'WAeUP Online Payment Transactions'
[1625]	1787	name = "online_payments_import"
[1620]	1788	key = "order_id"
[2094]	1789	def __init__(self,name=None):
	1790	if name == None:
	1791	name = self.name
	1792	WAeUPTable.__init__(self, name)
[1620]	1793
	1794
[2069]	1795	InitializeClass(OnlinePaymentsImport)
[1620]	1796	###)
	1797
[1151]	1798	class ReturningImport(WAeUPTable): ###(
[1146]	1799
[1151]	1800	meta_type = 'Returning Import Table'
	1801	name = "returning_import"
[1146]	1802	key = "matric_no"
[2094]	1803	def __init__(self,name=None):
	1804	if name == None:
	1805	name = self.name
	1806	WAeUPTable.__init__(self, name)
[1146]	1807
	1808
[1151]	1809	InitializeClass(ReturningImport)
	1810	###)
[1146]	1811
	1812	class ResultsImport(WAeUPTable): ###(
	1813
	1814	meta_type = 'Results Import Table'
	1815	name = "results_import"
	1816	key = "key"
[2094]	1817	def __init__(self,name=None):
	1818	if name == None:
	1819	name = self.name
	1820	WAeUPTable.__init__(self, name)
[1146]	1821
	1822
	1823	InitializeClass(ResultsImport)
	1824
	1825	###)
	1826
	1827	class PaymentsCatalog(WAeUPTable): ###(
[2738]	1828	security = ClassSecurityInfo()
[1146]	1829
	1830	meta_type = 'WAeUP Payments Catalog'
[2868]	1831	name = "payments_catalog"
	1832	key = "order_id"
[2094]	1833	def __init__(self,name=None):
	1834	if name == None:
	1835	name = self.name
	1836	WAeUPTable.__init__(self, name)
[1146]	1837
[2859]	1838
[2738]	1839	security.declarePrivate('notify_event_listener') ###(
	1840	def notify_event_listener(self,event_type,object,infos):
	1841	"listen for events"
	1842	if not infos.has_key('rpath'):
	1843	return
	1844	pt = getattr(object,'portal_type',None)
	1845	mt = getattr(object,'meta_type',None)
	1846	data = {}
[2904]	1847	if pt != 'Payment':
	1848	return
[3469]	1849	if event_type == 'sys_del_object' and mt == 'CPS Proxy Folder':
	1850	self.deleteRecord(object.getContent().order_id)
[2904]	1851	if mt == 'CPS Proxy Folder':
[2911]	1852	return # is handled only for the real object
[2738]	1853	if event_type not in ('sys_modify_object'):
	1854	return
	1855	for field in self.schema():
[2859]	1856	data[field] = getattr(object,field,'')
[2738]	1857	rpl = infos['rpath'].split('/')
[2904]	1858	#import pdb;pdb.set_trace()
	1859	student_id = rpl[-4]
[2738]	1860	data['student_id'] = student_id
[2907]	1861	modified = False
[2859]	1862	try:
	1863	self.modifyRecord(**data)
[2907]	1864	modified = True
[2859]	1865	except KeyError:
[2926]	1866	#logger = logging.getLogger('WAeUPTables.PaymentsCatalog.%s' % self.__name__)
	1867	#logger.info("could not modify entry for %(student_id)s with %(order_id)s" % data)
	1868	pass
[2907]	1869	if not modified:
	1870	try:
	1871	self.addRecord(**data)
	1872	except:
[2976]	1873	logger = logging.getLogger('WAeUPTables.PaymentsCatalog.notify_event_listener')
[2907]	1874	logger.info("could not add or modify entry for %(student_id)s with %(order_id)s" % data)
	1875	###)
[1146]	1876
[2738]	1877
[3988]	1878	def exportRemoveAllPayments(self,student_id,export=False,remove=False): ###(
[3984]	1879	""
	1880	query = Eq('student_id',student_id)
	1881	pm_catalog = self.payments_catalog
	1882	payments = pm_catalog.evalAdvancedQuery(query)
	1883	payments_dic = []
	1884	fields = self.schema()
	1885	format = '"%(' + ')s","%('.join(fields) + ')s"'
	1886	for brain in payments:
	1887	d = {}
	1888	for field in fields:
	1889	d[field] = getattr(brain,field,'')
	1890	payments_dic.append(format % d)
	1891
	1892	if export:
	1893	export_file = "%s/export/payments_removed.csv" % (i_home)
[3989]	1894	if not os.path.exists(export_file):
	1895	file_handler = open(export_file,"a")
	1896	headline = ','.join(fields)
	1897	file_handler.write(headline +'\n')
	1898	else:
	1899	file_handler = open(export_file,"a")
[3984]	1900	for line in payments_dic:
	1901	file_handler.write(line +'\n')
	1902
	1903	if remove:
	1904	for brain in payments:
	1905	order_id = getattr(brain,'order_id','')
	1906	pm_catalog.deleteRecord(order_id)
	1907
	1908	return payments_dic
	1909	###)
	1910
[5559]	1911	security.declareProtected(ModifyPortalContent,"dumpPayments")###(
[5561]	1912	def dumpPayments(self,session_id=''):
[5559]	1913	"""dump all valid payments and combine with student data """
[5561]	1914
	1915	if not session_id:
	1916	session_id = self.getSessionId()[0]
[5559]	1917	member = self.portal_membership.getAuthenticatedMember()
	1918	logger = logging.getLogger('WAeUPTables.WAeUPTable.dumpPayments')
	1919	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	1920	export_file = "%s/export/valid_payments%s_%s.csv" % (i_home,session_id,current,)
	1921
	1922	pm_catalog = self.payments_catalog
	1923	query = Eq('status','paid') & Eq('type','online') & Eq('session_id',session_id)
	1924	payments = pm_catalog.evalAdvancedQuery(query)
	1925	payments_dic = []
	1926	s_catalog = self.students_catalog
	1927	fields_pm = pm_catalog.schema()
	1928	fields_s = s_catalog.schema()
	1929	fields = fields_pm + fields_s
	1930
	1931	format = '"%(' + ')s","%('.join(fields) + ')s"'
	1932	#import pdb;pdb.set_trace()
	1933	for brain in payments:
	1934	d = {}
	1935	for field in fields_pm:
	1936	d[field] = getattr(brain,field,'')
	1937
	1938	student_id = getattr(brain,'student_id','')
	1939	query = Eq('id',student_id)
	1940	student = s_catalog.evalAdvancedQuery(query)
	1941	if student:
	1942	for field in fields_s:
	1943	d[field] = getattr(student[0],field,'')
	1944	payments_dic.append(format % d)
	1945
	1946	if not os.path.exists(export_file):
	1947	file_handler = open(export_file,"a")
	1948	headline = ','.join(fields)
	1949	file_handler.write(headline +'\n')
	1950	else:
	1951	file_handler = open(export_file,"a")
	1952	for line in payments_dic:
	1953	file_handler.write(line +'\n')
	1954
	1955	return 'ready'
	1956
	1957
[1146]	1958	InitializeClass(PaymentsCatalog)
	1959
	1960	###)
	1961
[4302]	1962	class RemovedStudentIds(WAeUPTable): ###(
	1963
	1964	meta_type = 'WAeUP Removed StudentIds'
	1965	name = "removed_student_ids"
	1966	key = "id"
	1967	def __init__(self,name=None):
	1968	if name == None:
	1969	name = self.name
	1970	WAeUPTable.__init__(self, name)
	1971
	1972
	1973	InitializeClass(RemovedStudentIds)
	1974
[5614]	1975	class AccommodationCatalog(WAeUPTable): ###(
	1976
	1977	meta_type = 'WAeUP Accommodation Catalog'
	1978	name = "accommodation_catalog"
	1979	key = "catkey" #student_id + session_id
	1980	def __init__(self,name=None):
	1981	if name == None:
	1982	name = self.name
	1983	WAeUPTable.__init__(self, name)
	1984
	1985
	1986	InitializeClass(AccommodationCatalog)
	1987
[4302]	1988	###)
	1989
[414]	1990	# BBB:
	1991	AccomodationTable = AccommodationTable

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

Context navigation

source: WAeUP_SRP/trunk/WAeUPTables.py @ 7657

Download in other formats: