Context navigation

source: WAeUP_SRP/trunk_not_used/WAeUPTables.py @ 2310

Last change on this file since 2310 was 2192, checked in by Henrik Bettermann, 17 years ago
ok, this works
Property svn:keywords set to `Id`
File size: 61.8 KB

Line
1	#-- mode: python; mode: fold --
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 2192 2007-09-11 12:48:10Z henrik $
20
21	from zope.interface import implements
22	from Globals import InitializeClass
23	from Products.ZCatalog.ZCatalog import ZCatalog
24	from Products.ZCatalog.ProgressHandler import ZLogHandler
25	from AccessControl import ClassSecurityInfo
26	from Products.CMFCore.permissions import ModifyPortalContent
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
33	import urllib
34	import DateTime,time
35	import csv,re
36	import logging
37	import Globals
38	p_home = Globals.package_home(globals())
39	i_home = Globals.INSTANCE_HOME
40
41	ADDING_SHEDULED = "adding_sheduled"
42	OBJECT_CREATED = "object_created"
43
44	from interfaces import IWAeUPTable
45
46	class AttributeHolder(object):
47	pass
48
49	def dict2ob(dict):
50	ob = AttributeHolder()
51	for key, value in dict.items():
52	setattr(ob, key, value)
53	return ob
54
55	class WAeUPTable(ZCatalog): ###(
56
57	implements(IWAeUPTable)
58	security = ClassSecurityInfo()
59	meta_type = None
60
61	def __init__(self,name=None):
62	if name == None:
63	name = self.name
64	ZCatalog.__init__(self,name)
65
66	def refreshCatalog(self, clear=0, pghandler=None): ###(
67	""" don't refresh for a normal table """
68
69	if self.REQUEST and self.REQUEST.RESPONSE:
70	self.REQUEST.RESPONSE.redirect(
71	URL1 +
72	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20refresh%20not%20implemented')
73
74	###)
75
76	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None): ###(
77	""" clears the whole enchilada """
78
79	#if REQUEST and RESPONSE:
80	# RESPONSE.redirect(
81	# URL1 +
82	# '/manage_catalogAdvanced?manage_tabs_message=Catalog%20Clearing%20disabled')
83
84	self._catalog.clear()
85	if REQUEST and RESPONSE:
86	RESPONSE.redirect(
87	URL1 +
88	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20cleared')
89
90	###)
91
92	def record2dict(self,fields,record):
93	d = {}
94	for key in fields:
95	v = getattr(record, key, None)
96	if key == 'sex':
97	if v:
98	v = 'F'
99	else:
100	v = 'M'
101	d[key] = v
102	elif v:
103	if key == 'lga':
104	v = self.portal_vocabularies.local_gov_areas.get(v)
105	d[key] = v
106	else:
107	d[key] = ''
108	return d
109
110	def addRecord(self, **data): ###(
111	# The uid is the same as "bed".
112	uid = data[self.key]
113	res = self.searchResults({"%s" % self.key : uid})
114	if len(res) > 0:
115	raise ValueError("More than one record with uid %s" % uid)
116	self.catalog_object(dict2ob(data), uid=uid)
117	return uid
118
119	###)
120
121	def deleteRecord(self, uid):
122	self.uncatalog_object(uid)
123
124	def searchAndSetRecord(self, **data):
125	raise NotImplemented
126
127	def modifyRecord(self, record=None, **data): ###(
128	#records = self.searchResults(uid=uid)
129	uid = data[self.key]
130	if record is None:
131	records = self.searchResults({"%s" % self.key : uid})
132	if len(records) > 1:
133	# Can not happen, but anyway...
134	raise ValueError("More than one record with uid %s" % uid)
135	if len(records) == 0:
136	raise KeyError("No record for uid %s" % uid)
137	record = records[0]
138	record_data = {}
139	for field in self.schema() + self.indexes():
140	record_data[field] = getattr(record, field)
141	# Add the updated data:
142	record_data.update(data)
143	self.catalog_object(dict2ob(record_data), uid)
144
145	###)
146
147	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
148	if isinstance(name, str):
149	name = (name,)
150	paths = self._catalog.uids.items()
151	i = 0
152	#import pdb;pdb.set_trace()
153	for p,rid in paths:
154	i += 1
155	metadata = self.getMetadataForRID(rid)
156	record_data = {}
157	for field in name:
158	record_data[field] = metadata.get(field)
159	uid = metadata.get(self.key)
160	self.catalog_object(dict2ob(record_data), uid, idxs=name,
161	update_metadata=0)
162
163	###)
164
165	security.declareProtected(ModifyPortalContent,"exportAllRecords") ###(
166	def exportAllRecords(self):
167	"export a WAeUPTable"
168	#import pdb;pdb.set_trace()
169	fields = [field for field in self.schema()]
170	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
171	csv = []
172	csv.append(','.join(['"%s"' % fn for fn in fields]))
173	for uid in self._catalog.uids:
174	records = self.searchResults({"%s" % self.key : uid})
175	if len(records) > 1:
176	# Can not happen, but anyway...
177	raise ValueError("More than one record with uid %s" % uid)
178	if len(records) == 0:
179	raise KeyError("No record for uid %s" % uid)
180	rec = records[0]
181	csv.append(format % rec)
182	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
183	open("%s/import/%s-%s.csv" % (i_home,self.getId(),current),"w+").write('\n'.join(csv))
184
185	###)
186
187	security.declareProtected(ModifyPortalContent,"dumpAll")###(
188	def dumpAll(self):
189	"""dump all data in the table to a csv"""
190	member = self.portal_membership.getAuthenticatedMember()
191	logger = logging.getLogger('WAeUPTables.dump_%s' % self.__name__)
192	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
193	export_file = "%s/export/%s_%s.csv" % (i_home,self.__name__,current,)
194	print export_file
195	res_list = []
196	lines = []
197	if hasattr(self,"export_keys"):
198	fields = self.export_keys
199	else:
200	fields = []
201	for f in self.schema():
202	fields.append(f)
203	headline = ','.join(fields)
204	#open(export_file,"a").write(headline +'\n')
205	out = open(export_file,"wb")
206	out.write(headline +'\n')
207	out.close()
208	out = open(export_file,"a")
209	csv_writer = csv.DictWriter(out,fields,)
210	format = '"%(' + ')s","%('.join(fields) + ')s"'
211	records = self()
212	nr2export = len(records)
213	logger.info('%s starts dumping, %s records to export' % (member,nr2export))
214	chunk = 2000
215	total = 0
216	start = DateTime.DateTime().timeTime()
217	start_chunk = DateTime.DateTime().timeTime()
218	for record in records:
219	not_all = False
220	d = self.record2dict(fields,record)
221	#d['state'],d['lga'] = formatLGA(d['lga'],voc = self.portal_vocabularies.local_gov_areas)
222	#lines.append(format % d)
223	lines.append(d)
224	total += 1
225	if total and not total % chunk or total == len(records):
226	#open(export_file,"a").write('\n'.join(lines) +'\n')
227	csv_writer.writerows(lines)
228	anz = len(lines)
229	logger.info("wrote %(anz)d total written %(total)d" % vars())
230	end_chunk = DateTime.DateTime().timeTime()
231	duration = end_chunk-start_chunk
232	per_record = duration/anz
233	till_now = end_chunk - start
234	avarage_per_record = till_now/total
235	estimated_end = DateTime.DateTime(start + avarage_per_record * nr2export)
236	estimated_end = estimated_end.strftime("%H:%M:%S")
237	logger.info('%(duration)4.1f, %(per_record)4.3f,end %(estimated_end)s' % vars())
238	start_chunk = DateTime.DateTime().timeTime()
239	lines = []
240	end = DateTime.DateTime().timeTime()
241	logger.info('total time %6.2f m' % ((end-start)/60))
242	import os
243	filename, extension = os.path.splitext(export_file)
244	from subprocess import call
245	msg = "wrote %(total)d records to %(export_file)s" % vars()
246	try:
247	retcode = call('gzip %s' % (export_file),shell=True)
248	if retcode == 0:
249	msg = "wrote %(total)d records to %(export_file)s.gz" % vars()
250	except OSError, e:
251	retcode = -99
252	logger.info("zip failed with %s" % e)
253	logger.info(msg)
254	args = {'portal_status_message': msg}
255	#url = self.REQUEST.get('URL1') + '?' + urlencode(args)
256	url = self.REQUEST.get('URL2')
257	return self.REQUEST.RESPONSE.redirect(url)
258	###)
259
260	security.declarePrivate("_import_old") ###(
261	def _import_old(self,filename,schema,layout, mode,logger):
262	"import data from csv"
263	import transaction
264	import random
265	pm = self.portal_membership
266	member = pm.getAuthenticatedMember()
267	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
268	import_fn = "%s/import/%s.csv" % (i_home,filename)
269	imported_fn = "%s/import/%s_imported%s.csv" % (i_home,filename,current)
270	not_imported_fn = "%s/import/%s_not_imported%s.csv" % (i_home,filename,current)
271	start = True
272	tr_count = 1
273	total_imported = 0
274	total_not_imported = 0
275	total = 0
276	iname = "%s" % filename
277	not_imported = []
278	imported = []
279	valid_records = []
280	invalid_records = []
281	d = {}
282	d['mode'] = mode
283	d['imported'] = total_imported
284	d['not_imported'] = total_not_imported
285	d['valid_records'] = valid_records
286	d['invalid_records'] = invalid_records
287	d['import_fn'] = import_fn
288	d['imported_fn'] = imported_fn
289	d['not_imported_fn'] = not_imported_fn
290	if schema is None:
291	em = 'No schema specified'
292	logger.error(em)
293	return d
294	if layout is None:
295	em = 'No layout specified'
296	logger.error(em)
297	return d
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	# if mode == 'edit':
306	# importer = self.importEdit
307	# elif mode == 'add':
308	# importer = self.importAdd
309	# else:
310	# importer = None
311	try:
312	items = csv.DictReader(open(import_fn,"rb"),
313	dialect="excel",
314	skipinitialspace=True)
315	except:
316	em = 'Error reading %s.csv' % filename
317	logger.error(em)
318	return d
319	#import pdb;pdb.set_trace()
320	for item in items:
321	if start:
322	start = False
323	logger.info('%s starts import from %s.csv' % (member,filename))
324	#import_keys = [k for k in item.keys() if not k.startswith('ignore')]
325	attrs = csv.reader(open("%s/import/%s.csv" % (i_home,filename),"rb"),
326	dialect="excel",
327	skipinitialspace=True).next()
328	import_keys = [k for k in attrs if not (k.startswith('ignore') or k.isupper())]
329	diff2schema = set(import_keys).difference(set(schema.keys()))
330	diff2layout = set(import_keys).difference(set(layout.keys()))
331	if diff2layout:
332	em = "not ignorable key(s) %s found in heading" % diff2layout
333	logger.info(em)
334	return d
335	s = ','.join(['"%s"' % fn for fn in import_keys])
336	open(not_imported_fn,"a").write(s + ',"Error"'+ '\n')
337	#s = '"id",' + s
338	open(imported_fn,"a").write(s + '\n')
339	format = ','.join(['"%%(%s)s"' % fn for fn in import_keys])
340	format_error = format + ',"%(Error)s"'
341	#format = '"%(id)s",'+ format
342	adapters = [MappingStorageAdapter(schema, item)]
343	dm = DataModel(item, adapters,context=self)
344	ds = DataStructure(data=item,datamodel=dm)
345	error_string = ""
346	for k in import_keys:
347	if not validators[k](ds,mode=mode):
348	error_string += " %s : %s" % (k,ds.getError(k))
349	# if not error_string and importer:
350	# item.update(dm)
351	# item['id'],error = importer(item)
352	# if error:
353	# error_string += error
354	if error_string:
355	item['Error'] = error_string
356	invalid_records.append(dm)
357	not_imported.append(format_error % item)
358	total_not_imported += 1
359	else:
360	em = format % item
361	valid_records.append(dm)
362	imported.append(em)
363	#logger.info("%(total_imported)d of %(total)d %(em)s" % vars())
364	tr_count += 1
365	total_imported += 1
366	total += 1
367	if len(imported) > 0:
368	open(imported_fn,"a").write('\n'.join(imported))
369	if len(not_imported) > 0:
370	open(not_imported_fn,"a").write('\n'.join(not_imported))
371	#em = "Imported: %d, not imported: %d of total %d" % (total_imported,total_not_imported,total)
372	d['imported'] = total_imported
373	d['not_imported'] = total_not_imported
374	d['valid_records'] = valid_records
375	d['invalid_records'] = invalid_records
376	d['imported_fn'] = imported_fn
377	d['not_imported_fn'] = not_imported_fn
378	#logger.info(em)
379	return d
380	###)
381
382	security.declarePrivate("_import") ###(
383	def _import_new(self,csv_items,schema, layout, mode,logger):
384	"import data from csv.Dictreader Instance"
385	start = True
386	tr_count = 1
387	total_imported = 0
388	total_not_imported = 0
389	total = 0
390	iname = "%s" % filename
391	not_imported = []
392	valid_records = []
393	invalid_records = []
394	duplicate_records = []
395	d = {}
396	d['mode'] = mode
397	d['valid_records'] = valid_records
398	d['invalid_records'] = invalid_records
399	d['invalid_records'] = duplicate_records
400	# d['import_fn'] = import_fn
401	# d['imported_fn'] = imported_fn
402	# d['not_imported_fn'] = not_imported_fn
403	validators = {}
404	for widget in layout.keys():
405	try:
406	validators[widget] = layout[widget].validate
407	except AttributeError:
408	logger.info('%s has no validate attribute' % widget)
409	return d
410	for item in csv_items:
411	if start:
412	start = False
413	logger.info('%s starts import from %s.csv' % (member,filename))
414	#import_keys = [k for k in item.keys() if not k.startswith('ignore')]
415	attrs = csv.reader(open("%s/import/%s.csv" % (i_home,filename),"rb")).next()
416	import_keys = [k for k in attrs if not (k.startswith('ignore') or k.isupper())]
417	diff2schema = set(import_keys).difference(set(schema.keys()))
418	diff2layout = set(import_keys).difference(set(layout.keys()))
419	if diff2layout:
420	em = "not ignorable key(s) %s found in heading" % diff2layout
421	logger.info(em)
422	return d
423	# s = ','.join(['"%s"' % fn for fn in import_keys])
424	# open(not_imported_fn,"a").write(s + ',"Error"'+ '\n')
425	# #s = '"id",' + s
426	# open(imported_fn,"a").write(s + '\n')
427	# format = ','.join(['"%%(%s)s"' % fn for fn in import_keys])
428	# format_error = format + ',"%(Error)s"'
429	# #format = '"%(id)s",'+ format
430	adapters = [MappingStorageAdapter(schema, item)]
431	dm = DataModel(item, adapters,context=self)
432	ds = DataStructure(data=item,datamodel=dm)
433	error_string = ""
434	for k in import_keys:
435	if not validators[k](ds,mode=mode):
436	error_string += " %s : %s" % (k,ds.getError(k))
437	if error_string:
438	item['Error'] = error_string
439	#invalid_records.append(dm)
440	invalid_records.append(item)
441	total_not_imported += 1
442	else:
443	em = format % item
444	valid_records.append(dm)
445	#logger.info("%(total_imported)d of %(total)d %(em)s" % vars())
446	tr_count += 1
447	total_imported += 1
448	total += 1
449	# if len(imported) > 0:
450	# open(imported_fn,"a").write('\n'.join(imported))
451	# if len(not_imported) > 0:
452	# open(not_imported_fn,"a").write('\n'.join(not_imported))
453	#em = "Imported: %d, not imported: %d of total %d" % (total_imported,total_not_imported,total)
454	d['imported'] = total_imported
455	d['not_imported'] = total_not_imported
456	d['valid_records'] = valid_records
457	d['invalid_records'] = invalid_records
458	return d
459	###)
460
461	###)
462
463	class AccommodationTable(WAeUPTable): ###(
464
465	meta_type = 'WAeUP Accommodation Tool'
466	name = "portal_accommodation"
467	key = "bed"
468	def __init__(self,name=None):
469	if name == None:
470	name = self.name
471	WAeUPTable.__init__(self, name)
472
473	def searchAndReserveBed(self, student_id,bed_type):
474	records = self.searchResults({'student' : student_id})
475	if len(records) > 0:
476	return -1,"Student with Id %s already booked bed %s." % (student_id,records[0].bed)
477
478	records = [r for r in self.searchResults({'bed_type' : bed_type}) if not r.student]
479	#import pdb;pdb.set_trace()
480	if len(records) == 0:
481	return -2,"No bed available"
482	rec = records[0]
483	self.modifyRecord(bed=rec.bed,student=student_id)
484	s_logger = logging.getLogger('WAeUPTables.AccommodationTable.searchAndReserveBed')
485	s_logger.info('%s reserved bed %s' % (student_id,rec.bed))
486	return 1,rec.bed
487
488
489	InitializeClass(AccommodationTable)
490
491	###)
492
493	class PinTable(WAeUPTable): ###(
494	from ZODB.POSException import ConflictError
495	meta_type = 'WAeUP Pin Tool'
496	name = "portal_pins"
497	key = 'pin'
498	def __init__(self,name=None):
499	if name == None:
500	name = self.name
501	WAeUPTable.__init__(self, name)
502
503
504	def searchAndSetRecord(self, uid, student_id,prefix):
505
506	# The following line must be activated after resetting the
507	# the portal_pins table. This is to avoid duplicate entries
508	# and disable duplicate payments.
509
510	#student_id = student_id.upper()
511
512	records = self.searchResults(student = student_id)
513	if len(records) > 0 and prefix in ('CLR','APP'):
514	for r in records:
515	if r.pin != uid and r.prefix_batch.startswith(prefix):
516	return -2
517	records = self.searchResults({"%s" % self.key : uid})
518	if len(records) > 1:
519	# Can not happen, but anyway...
520	raise ValueError("More than one record with uid %s" % uid)
521	if len(records) == 0:
522	return -1
523	record = records[0]
524	if record.student == "":
525	record_data = {}
526	for field in self.schema() + self.indexes():
527	record_data[field] = getattr(record, field)
528	# Add the updated data:
529	record_data['student'] = student_id
530	try:
531	self.catalog_object(dict2ob(record_data), uid)
532	return 1
533	except ConflictError:
534	return 2
535	if record.student.upper() != student_id.upper():
536	return 0
537	if record.student.upper() == student_id.upper():
538	return 2
539	return -3
540
541	InitializeClass(PinTable)
542
543	###)
544
545	class PumeResultsTable(WAeUPTable): ###(
546
547	meta_type = 'WAeUP PumeResults Tool'
548	name = "portal_pumeresults"
549	key = "jamb_reg_no"
550	def __init__(self,name=None):
551	if name == None:
552	name = self.name
553	WAeUPTable.__init__(self, name)
554
555
556	InitializeClass(PumeResultsTable)
557
558	###)
559
560	class ApplicantsCatalog(WAeUPTable): ###(
561
562	meta_type = 'WAeUP Applicants Catalog'
563	name = "applicants_catalog"
564	key = "reg_no"
565	security = ClassSecurityInfo()
566	export_keys = (
567	"reg_no",
568	"status",
569	"lastname",
570	"sex",
571	"date_of_birth",
572	"lga",
573	"email",
574	"phone",
575	"passport",
576	"entry_mode",
577	"pin",
578	"screening_type",
579	"registration_date",
580	"testdate",
581	"application_date",
582	"screening_date",
583	"faculty",
584	"department",
585	"course1",
586	"course2",
587	"course3",
588	"eng_score",
589	"subj1",
590	"subj1score",
591	"subj2",
592	"subj2score",
593	"subj3",
594	"subj3score",
595	"aggregate",
596	"course_admitted",
597	)
598	def __init__(self,name=None):
599	if name == None:
600	name = self.name
601	WAeUPTable.__init__(self, name)
602
603
604
605	security.declareProtected(ModifyPortalContent,"new_importCSV")###(
606	def new_importCSV(self,filename="JAMB_data",
607	schema_id="application",
608	layout_id="application_import",
609	mode='add'):
610	""" import JAMB data """
611	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
612	pm = self.portal_membership
613	member = pm.getAuthenticatedMember()
614	logger = logging.getLogger('WAeUPTables.ApplicantsCatalog.importCSV')
615	lock_fn = "%s/import/%s_import_lock" % (i_home,filename)
616	import_fn = "%s/import/%s.csv" % (i_home,filename)
617	if mode not in ('add','edit'):
618	logger.info("invalid mode: %s" % mode)
619	if os.path.exists(lock_fn):
620	logger.info("import of %(import_fn)s already in progress" % vars())
621	return
622	lock_file = open(lock_fn,"w")
623	lock_file.write("%(current)s \n" % vars())
624	lock_file.close()
625	invalid_fn = "%s/import/%s_not_imported%s.csv" % (i_home,filename,current)
626	duplicate_fn = "%s/import/%s_not_imported%s.csv" % (i_home,filename,current)
627	stool = getToolByName(self, 'portal_schemas')
628	ltool = getToolByName(self, 'portal_layouts')
629	schema = stool._getOb(schema_id)
630	if schema is None:
631	em = 'No such schema %s' % schema_id
632	logger.error(em)
633	return
634	for postfix in ('_import',''):
635	layout_name = "%(layout_id)s%(postfix)s" % vars()
636	if hasattr(ltool,layout_name):
637	break
638	layout = ltool._getOb(layout_name)
639	if layout is None:
640	em = 'No such layout %s' % layout_id
641	logger.error(em)
642	return
643	try:
644	csv_file = csv.DictReader(open(import_fn,"rb"))
645	except:
646	em = 'Error reading %s.csv' % filename
647	logger.error(em)
648	return
649	d = self._import_new(csv_items,schema,layout,mode,logger)
650	imported = []
651	edited = []
652	duplicates = []
653	not_found = []
654	if len(d['valid_records']) > 0:
655	for record in d['valid_records']:
656	#import pdb;pdb.set_trace()
657	if mode == "add":
658	try:
659	self.addRecord(**dict(record.items()))
660	imported.append(**dict(record.items()))
661	logger.info("added %s" % record.items())
662	except ValueError:
663	dupplicate.append(**dict(record.items()))
664	logger.info("duplicate %s" % record.items())
665	elif mode == "edit":
666	try:
667	self.modifyRecord(**dict(record.items()))
668	edited.append(**dict(record.items()))
669	logger.info("edited %s" % record.items())
670	except KeyError:
671	not_found.append(**dict(record.items()))
672	logger.info("not found %s" % record.items())
673	invalid = d['invalid_records']
674	for itype in ("imported","edited","not_found","duplicate","invalid"):
675	outlist = locals[itype]
676	if len(outlist):
677	d = {}
678	for k in outlist[0].keys():
679	d[k] = k
680	outlist[0] = d
681	outfile = open("file_name_%s" % itype,'w')
682	csv.DictWriter(outfile,outlist[0].keys()).writerows(outlist)
683	logger.info("wrote %(itype)s records to %(, written to %(not_imported_fn)s" % d)
684	###)
685
686	security.declareProtected(ModifyPortalContent,"importCSV")###(
687	def importCSV(self,filename="JAMB_data",
688	schema_id="application",
689	layout_id="application",
690	mode='add'):
691	""" import JAMB data """
692	stool = getToolByName(self, 'portal_schemas')
693	ltool = getToolByName(self, 'portal_layouts')
694	schema = stool._getOb(schema_id)
695	if schema is None:
696	em = 'No such schema %s' % schema_id
697	logger.error(em)
698	return
699	layout = ltool._getOb(layout_id)
700	if layout is None:
701	em = 'No such layout %s' % layout_id
702	logger.error(em)
703	return
704	logger = logging.getLogger('WAeUPTables.ApplicantsCatalog.importCSV')
705	d = self._import_old(filename,schema,layout,mode,logger)
706	if len(d['valid_records']) > 0:
707	for record in d['valid_records']:
708	#import pdb;pdb.set_trace()
709	if mode == "add":
710	self.addRecord(**dict(record.items()))
711	logger.info("added %s" % record.items())
712	elif mode == "edit":
713	self.modifyRecord(**dict(record.items()))
714	logger.info("edited %s" % record.items())
715	else:
716	logger.info("invalid mode: %s" % mode)
717	logger.info("%(mode)sed %(imported)d records, invalid written to %(not_imported_fn)s" % d)
718	###)
719
720	InitializeClass(ApplicantsCatalog)
721
722	###)
723
724	class StudentsCatalog(WAeUPTable): ###(
725	security = ClassSecurityInfo()
726
727	meta_type = 'WAeUP Students Catalog'
728	name = "students_catalog"
729	key = "id"
730	affected_types = { ###(
731	'StudentApplication':
732	{'id': 'application',
733	'fields':
734	('jamb_reg_no',
735	'entry_mode',
736	#'entry_level',
737	'entry_session',
738	)
739	},
740	'StudentClearance':
741	{'id': 'clearance',
742	'fields':
743	('matric_no',
744	'lga',
745	)
746	},
747	'StudentPersonal':
748	{'id': 'personal',
749	'fields':
750	('name',
751	'sex',
752	'perm_address',
753	'email',
754	'phone',
755	)
756	},
757	'StudentStudyCourse':
758	{'id': 'study_course',
759	'fields':
760	('course', # study_course
761	'faculty', # from certificate
762	'department', # from certificate
763	'end_level', # from certificate
764	'level', # current_level
765	'mode', # current_mode
766	'session', # current_session
767	'verdict', # current_verdict
768	)
769	},
770	}
771	###)
772
773	def __init__(self,name=None):
774	if name == None:
775	name = self.name
776	WAeUPTable.__init__(self, name)
777	return
778
779	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None):
780	""" clears the whole enchilada """
781	self._catalog.clear()
782
783	if REQUEST and RESPONSE:
784	RESPONSE.redirect(
785	URL1 +
786	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20Cleared')
787
788	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
789	""" clear the catalog, then re-index everything """
790
791	elapse = time.time()
792	c_elapse = time.clock()
793
794	pgthreshold = self._getProgressThreshold()
795	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
796	self.refreshCatalog(clear=1, pghandler=handler)
797
798	elapse = time.time() - elapse
799	c_elapse = time.clock() - c_elapse
800
801	RESPONSE.redirect(
802	URL1 +
803	'/manage_catalogAdvanced?manage_tabs_message=' +
804	urllib.quote('Catalog Updated \n'
805	'Total time: %s\n'
806	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
807	###)
808
809	def fill_certificates_dict(self): ###(
810	"return certificate data in dict"
811	certificates_brains = self.portal_catalog(portal_type ='Certificate')
812	d = {}
813	for cb in certificates_brains:
814	certificate_doc = cb.getObject().getContent()
815	cb_path = cb.getPath().split('/')
816	ld = {}
817	ld['faculty'] = cb_path[-4]
818	ld['department'] = cb_path[-3]
819	ld['end_level'] = getattr(certificate_doc,'end_level','999')
820	d[cb.getId] = ld
821	return d
822	###)
823
824	def get_from_doc_department(self,doc,cached_data={}): ###(
825	"return the students department"
826	if doc is None:
827	return None
828	if cached_data.has_key(doc.study_course):
829	return cached_data[doc.study_course]['department']
830	certificate_res = self.portal_catalog(id = doc.study_course)
831	if len(certificate_res) != 1:
832	return None
833	return certificate_res[0].getPath().split('/')[-3]
834
835	def get_from_doc_faculty(self,doc,cached_data={}):
836	"return the students faculty"
837	if doc is None:
838	return None
839	if cached_data.has_key(doc.study_course):
840	return cached_data[doc.study_course]['faculty']
841	certificate_res = self.portal_catalog(id = doc.study_course)
842	if len(certificate_res) != 1:
843	return None
844	return certificate_res[0].getPath().split('/')[-4]
845
846	def get_from_doc_end_level(self,doc,cached_data={}):
847	"return the students end_level"
848	if doc is None:
849	return None
850	if cached_data.has_key(doc.study_course):
851	return cached_data[doc.study_course]['end_level']
852	certificate_res = self.portal_catalog(id = doc.study_course)
853	if len(certificate_res) != 1:
854	return None
855	return getattr(certificate_res[0].getObject().getContent(),'end_level','unknown')
856
857	def get_from_doc_level(self,doc,cached_data={}):
858	"return the students level"
859	if doc is None:
860	return None
861	return getattr(doc,'current_level',None)
862
863	def get_from_doc_mode(self,doc,cached_data={}):
864	"return the students mode"
865	if doc is None:
866	return None
867	cm = getattr(doc,'current_mode',None)
868	return cm
869
870
871	def get_from_doc_session(self,doc,cached_data={}):
872	"return the students current_session"
873	if doc is None:
874	return None
875	return getattr(doc,'current_session',None)
876
877	def get_from_doc_entry_session(self,doc,cached_data={}):
878	"return the students entry_session"
879	if doc is None:
880	return None
881	es = getattr(doc,'entry_session',None)
882	if es is not None and len(es) == 2:
883	return es
884	try:
885	digit = int(doc.jamb_reg_no[0])
886	except:
887	return "-1"
888	if digit < 8:
889	return "0%c" % doc.jamb_reg_no[0]
890	return "9%c" % doc.jamb_reg_no[0]
891
892	def get_from_doc_course(self,doc,cached_data={}):
893	"return the students study_course"
894	if doc is None:
895	return None
896	return getattr(doc,'study_course',None)
897
898	def get_from_doc_name(self,doc,cached_data={}):
899	"return the students name from the personal"
900	if doc is None:
901	return None
902	return "%s %s %s" % (doc.firstname,doc.middlename,doc.lastname)
903
904	def get_from_doc_verdict(self,doc,cached_data={}):
905	"return the students study_course"
906	if doc is None:
907	return None
908	return getattr(doc,'current_verdict',None)
909	###)
910
911	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
912	if isinstance(name, str):
913	name = (name,)
914	reindextypes = {}
915	reindex_special = []
916	for n in name:
917	if n in ("review_state","registered_courses"):
918	reindex_special.append(n)
919	else:
920	for pt in self.affected_types.keys():
921	if n in self.affected_types[pt]['fields']:
922	if reindextypes.has_key(pt):
923	reindextypes[pt].append(n)
924	else:
925	reindextypes[pt]= [n]
926	break
927	cached_data = {}
928	if set(name).intersection(set(('faculty','department','end_level'))):
929	cached_data = self.fill_certificates_dict()
930	students = self.portal_catalog(portal_type="Student")
931	if hasattr(self,'portal_catalog_real'):
932	aq_portal = self.portal_catalog_real.evalAdvancedQuery
933	else:
934	aq_portal = self.portal_catalog.evalAdvancedQuery
935	num_objects = len(students)
936	if pghandler:
937	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
938	noattr = set(('StudentClearance','StudentPersonal')) & set(reindextypes.keys())
939	#import pdb;pdb.set_trace()
940	for i in xrange(num_objects):
941	if pghandler: pghandler.report(i)
942	student_brain = students[i]
943	student_object = student_brain.getObject()
944	# query = Eq('path',student_brain.getPath())
945	# sub_brains_list = aq_portal(query)
946	# sub_brains = {}
947	# for sub_brain in sub_brains_list:
948	# sub_brains[sub_brain.portal_type] = sub_brain
949	# student_path = student_brain.getPath()
950	data = {}
951	modified = False
952	sid = data['id'] = student_brain.getId
953	if reindex_special and 'review_state' in reindex_special:
954	modified = True
955	data['review_state'] = student_brain.review_state
956	sub_objects = False
957	for pt in reindextypes.keys():
958	modified = True
959	try:
960	doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
961	#doc = sub_brains[pt].getObject().getContent()
962	# path = "%s/%s" % (student_path,self.affected_types[pt]['id'])
963	# doc = self.unrestrictedTraverse(path).getContent()
964	sub_objects = True
965	except:
966	continue
967	for field in set(name).intersection(self.affected_types[pt]['fields']):
968	if hasattr(self,'get_from_doc_%s' % field):
969	data[field] = getattr(self,'get_from_doc_%s' % field)(doc,
970	cached_data=cached_data)
971	else:
972	data[field] = getattr(doc,field)
973	if not sub_objects and noattr:
974	import_res = self.returning_import(id = sid)
975	if not import_res:
976	continue
977	import_record = import_res[0]
978	data['matric_no'] = import_record.matric_no
979	data['sex'] = import_record.Sex == 'F'
980	data['name'] = "%s %s %s" % (import_record.Firstname,
981	import_record.Middlename,
982	import_record.Lastname)
983	data['jamb_reg_no'] = import_record.Entryregno
984	if reindex_special and 'registered_courses' in reindex_special:
985	try:
986	study_course = getattr(student_object,"study_course")
987	level_ids = study_course.objectIds()
988	except:
989	continue
990	if not level_ids:
991	continue
992	modified = True
993	level_ids.sort()
994	course_ids = getattr(study_course,level_ids[-1]).objectIds()
995	courses = []
996	for c in course_ids:
997	if c.endswith('_co'):
998	courses.append(c[:-3])
999	else:
1000	courses.append(c)
1001	data['registered_courses'] = courses
1002	if modified:
1003	self.modifyRecord(**data)
1004	if pghandler: pghandler.finish()
1005	###)
1006
1007	def refreshCatalog(self, clear=0, pghandler=None): ###(
1008	""" re-index everything we can find """
1009	students_folder = self.portal_url.getPortalObject().campus.students
1010	if clear:
1011	self._catalog.clear()
1012	students = self.portal_catalog(portal_type="Student")
1013	num_objects = len(students)
1014	cached_data = self.fill_certificates_dict()
1015	if pghandler:
1016	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
1017	for i in xrange(num_objects):
1018	if pghandler: pghandler.report(i)
1019	student_brain = students[i]
1020	spath = student_brain.getPath()
1021	student_object = student_brain.getObject()
1022	data = {}
1023	sid = data['id'] = student_brain.getId
1024	data['review_state'] = student_brain.review_state
1025	sub_objects = False
1026	for pt in self.affected_types.keys():
1027	modified = True
1028	try:
1029	doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
1030	sub_objects = True
1031	except:
1032	#from pdb import set_trace;set_trace()
1033	continue
1034	for field in self.affected_types[pt]['fields']:
1035	if hasattr(self,'get_from_doc_%s' % field):
1036	data[field] = getattr(self,'get_from_doc_%s' % field)(doc,
1037	cached_data=cached_data)
1038	else:
1039	data[field] = getattr(doc,field,None)
1040	if not sub_objects:
1041	import_res = self.returning_import(id = sid)
1042	if not import_res:
1043	continue
1044	import_record = import_res[0]
1045	data['matric_no'] = import_record.matric_no
1046	data['sex'] = import_record.Sex == 'F'
1047	data['name'] = "%s %s %s" % (import_record.Firstname,
1048	import_record.Middlename,
1049	import_record.Lastname)
1050	data['jamb_reg_no'] = import_record.Entryregno
1051	else:
1052	study_course = getattr(student_object,'study_course',None)
1053	current_level = data.get('level',None)
1054	data['registered_courses'] = []
1055	if study_course and current_level and current_level in study_course.objectIds():
1056	level_obj = getattr(study_course,current_level)
1057	courses = []
1058	for c in level_obj.objectIds():
1059	if c.endswith('_co'):
1060	courses.append(c[:-3])
1061	else:
1062	courses.append(c)
1063	data['registered_courses'] = courses
1064	self.addRecord(**data)
1065	if pghandler: pghandler.finish()
1066	###)
1067
1068	security.declarePrivate('notify_event_listener') ###(
1069	def notify_event_listener(self,event_type,object,infos):
1070	"listen for events"
1071	if not infos.has_key('rpath'):
1072	return
1073	pt = getattr(object,'portal_type',None)
1074	mt = getattr(object,'meta_type',None)
1075	students_catalog = self
1076	data = {}
1077	if pt == 'Student' and\
1078	mt == 'CPS Proxy Folder' and\
1079	event_type.startswith('workflow'):
1080	data['id'] = object.getId()
1081	data['review_state'] = self.portal_workflow.getInfoFor(object,'review_state',None)
1082	students_catalog.modifyRecord(**data)
1083	return
1084	rpl = infos['rpath'].split('/')
1085	if pt == 'Student' and mt == 'CPS Proxy Folder'\
1086	and event_type == "sys_add_object":
1087	student_id = object.id
1088	try:
1089	self.addRecord(id = student_id)
1090	except ValueError:
1091	pass
1092	return
1093	elif pt == 'StudentCourseResult' and mt == 'CPS Proxy Folder':
1094	if event_type not in ("sys_add_object","sys_del_object"):
1095	return
1096	level_session = getattr(object.aq_parent.getContent(),'session','unknown')
1097	if level_session not in (self.getSessionId()[-2:],'2006/2007'):
1098	return
1099	course_id = object.getId()
1100	if course_id.endswith('_co'):
1101	course_id = course_id[:-3]
1102	student_id = object.absolute_url_path().split('/')[-4]
1103	res = students_catalog(id = student_id)
1104	if not res:
1105	return
1106	student_rec = res[0]
1107	registered_courses = getattr(student_rec,'registered_courses',None)
1108	if not registered_courses:
1109	registered_courses = []
1110	#import pdb;pdb.set_trace()
1111	if event_type == "sys_add_object":
1112	if course_id not in registered_courses:
1113	registered_courses.append(course_id)
1114	else:
1115	return
1116	elif registered_courses and event_type == "sys_del_object":
1117	removed = False
1118	while course_id in registered_courses:
1119	removed = True
1120	registered_courses.remove(course_id)
1121	if not removed:
1122	return
1123	data['id'] = student_id
1124	data['registered_courses'] = registered_courses
1125	self.modifyRecord(record = student_rec, **data)
1126	return
1127	if pt not in self.affected_types.keys():
1128	return
1129	if event_type not in ('sys_modify_object'):
1130	return
1131	if mt == 'CPS Proxy Folder':
1132	return
1133	for field in self.affected_types[pt]['fields']:
1134	if hasattr(self,'get_from_doc_%s' % field):
1135	data[field] = getattr(self,'get_from_doc_%s' % field)(object)
1136	else:
1137	data[field] = getattr(object,field)
1138	data['id'] = rpl[2]
1139	self.modifyRecord(**data)
1140	###)
1141
1142
1143	InitializeClass(StudentsCatalog)
1144
1145	###)
1146
1147	class CoursesCatalog(WAeUPTable): ###(
1148	security = ClassSecurityInfo()
1149
1150	meta_type = 'WAeUP Courses Catalog'
1151	name = "courses_catalog"
1152	key = "code"
1153	def __init__(self,name=None):
1154	if name == None:
1155	name = self.name
1156	WAeUPTable.__init__(self, name)
1157
1158	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
1159	""" clear the catalog, then re-index everything """
1160
1161	elapse = time.time()
1162	c_elapse = time.clock()
1163
1164	pgthreshold = self._getProgressThreshold()
1165	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
1166	self.refreshCatalog(clear=1, pghandler=handler)
1167
1168	elapse = time.time() - elapse
1169	c_elapse = time.clock() - c_elapse
1170
1171	RESPONSE.redirect(
1172	URL1 +
1173	'/manage_catalogAdvanced?manage_tabs_message=' +
1174	urllib.quote('Catalog Updated \n'
1175	'Total time: %s\n'
1176	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
1177	###)
1178
1179	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
1180	if isinstance(name, str):
1181	name = (name,)
1182	courses = self.portal_catalog(portal_type="Course")
1183	num_objects = len(courses)
1184	if pghandler:
1185	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
1186	for i in xrange(num_objects):
1187	if pghandler: pghandler.report(i)
1188	course_brain = courses[i]
1189	course_object = course_brain.getObject()
1190	pl = course_brain.getPath().split('/')
1191	data = {}
1192	cid = data[self.key] = course_brain.getId
1193	data['faculty'] = pl[-4]
1194	data['department'] = pl[-3]
1195	doc = course_object.getContent()
1196	for field in name:
1197	if field not in (self.key,'faculty','department'):
1198	data[field] = getattr(doc,field)
1199	self.modifyRecord(**data)
1200	if pghandler: pghandler.finish()
1201	###)
1202
1203	def refreshCatalog(self, clear=0, pghandler=None): ###(
1204	""" re-index everything we can find """
1205	if clear:
1206	self._catalog.clear()
1207	courses = self.portal_catalog(portal_type="Course")
1208	num_objects = len(courses)
1209	if pghandler:
1210	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
1211	#from pdb import set_trace;set_trace()
1212	for i in xrange(num_objects):
1213	if pghandler: pghandler.report(i)
1214	course_brain = courses[i]
1215	course_doc = course_brain.getObject().getContent()
1216	pl = course_brain.getPath().split('/')
1217	data = {}
1218	for field in self.schema():
1219	data[field] = getattr(course_doc,field,None)
1220	data[self.key] = course_brain.getId
1221	ai = pl.index('academics')
1222	data['faculty'] = pl[ai +1]
1223	data['department'] = pl[ai +2]
1224	if clear:
1225	self.addRecord(**data)
1226	else:
1227	self.modifyRecord(**data)
1228	if pghandler: pghandler.finish()
1229	###)
1230
1231	security.declarePrivate('notify_event_listener') ###(
1232	def notify_event_listener(self,event_type,object,infos):
1233	"listen for events"
1234	if not infos.has_key('rpath'):
1235	return
1236	pt = getattr(object,'portal_type',None)
1237	mt = getattr(object,'meta_type',None)
1238	if pt != 'Course':
1239	return
1240	data = {}
1241	rpl = infos['rpath'].split('/')
1242	if event_type not in ("sys_add_object","sys_modify_object","sys_del_object"):
1243	return
1244	course_id = object.getId()
1245	data[self.key] = course_id
1246	if event_type == "sys_add_object" and mt == 'CPS Proxy Folder':
1247	try:
1248	self.addRecord(**data)
1249	except ValueError:
1250	return
1251	course_id = object.getId()
1252	doc = object.getContent()
1253	if doc is None:
1254	return
1255	for field in self.schema():
1256	data[field] = getattr(doc,field,None)
1257	data[self.key] = course_id
1258	ai = rpl.index('academics')
1259	data['faculty'] = rpl[ai +1]
1260	data['department'] = rpl[ai +2]
1261	self.modifyRecord(**data)
1262	return
1263	if event_type == "sys_del_object":
1264	self.deleteRecord(course_id)
1265	return
1266	if event_type == "sys_modify_object" and mt == 'Course':
1267	#from pdb import set_trace;set_trace()
1268	for field in self.schema():
1269	data[field] = getattr(object,field,None)
1270	course_id = object.aq_parent.getId()
1271	data[self.key] = course_id
1272	ai = rpl.index('academics')
1273	data['faculty'] = rpl[ai +1]
1274	data['department'] = rpl[ai +2]
1275	self.modifyRecord(**data)
1276	###)
1277
1278
1279	InitializeClass(CoursesCatalog)
1280	###)
1281
1282	class CourseResults(WAeUPTable): ###(
1283	security = ClassSecurityInfo()
1284
1285	meta_type = 'WAeUP Results Catalog'
1286	name = "course_results"
1287	key = "key" #student_id + level + course_id
1288	def __init__(self,name=None):
1289	if name == None:
1290	name = self.name
1291	WAeUPTable.__init__(self, name)
1292	self._queue = []
1293
1294	def addRecord(self, **data): ###(
1295	"""add one record"""
1296
1297	uid = key = "%(student_id)s\|%(level_id)s\|%(course_id)s" % data
1298	if key in self._queue:
1299	return uid
1300	data['queue_status'] = ADDING_SHEDULED
1301	data['%s' % self.key] = uid
1302	res = self.searchResults({"%s" % self.key : uid})
1303	if len(res) > 0:
1304	raise ValueError("More than one record with uid %s" % uid)
1305	self.catalog_object(dict2ob(data), uid=uid)
1306	if not hasattr(self,'_queue'):
1307	self._queue = []
1308	self._queue.append(key)
1309	self._p_changed = 1
1310	return uid
1311	###)
1312
1313	# def _p_resolveConflict(self, oldstate, committed, newstate):
1314	# # Apply the changes made in going from old to newstate to
1315	# # committed
1316
1317	# # Note that in the case of undo, the olddata is the data for
1318	# # the transaction being undone and newdata is the data for the
1319	# # transaction previous to the undone transaction.
1320
1321	# # Find the conflict policy on the new state to make sure changes
1322	# # to it will be applied
1323
1324	# # Committed is always the currently committed data.
1325	# import pdb;pdb.set_trace()
1326	# oldstate_data = oldstate['_queue']
1327	# committed_data = committed['_queue']
1328	# newstate_data = newstate['_queue']
1329
1330	# # Merge newstate changes into committed
1331	# for uid, new in newstate_data.items():
1332
1333	# # Decide if this is a change
1334	# old = oldstate_data.get(uid)
1335	# current = committed_data.get(uid)
1336
1337
1338	def addMultipleRecords(self, records): ###(
1339	"""add many records"""
1340	added_keys = []
1341	for data in records:
1342	uid = key = "%(student_id)s\|%(level_id)s\|%(course_id)s" % data
1343	added_keys.append(key)
1344	if key in self._queue:
1345	return uid
1346	data['queue_status'] = ADDING_SHEDULED
1347	data['%s' % self.key] = uid
1348	res = self.searchResults({"%s" % self.key : uid})
1349	if len(res) > 0:
1350	raise ValueError("More than one record with uid %s" % uid)
1351	self.catalog_object(dict2ob(data), uid=uid)
1352	if not hasattr(self,'_queue'):
1353	self._queue = added_keys
1354	self._queue.extend(added_keys)
1355	self._p_changed = 1
1356	return uid
1357	###)
1358
1359	def deleteRecord(self, uid): ###(
1360	self.uncatalog_object(uid)
1361	if uid in self._queue:
1362	self._queue.remove(uid)
1363	###)
1364
1365	def updateCourseResults(self,student_id,level_id,portal_catalog_results,course_results): ###(
1366	# query = Eq('path',"%s/campus/students/%s/study_course/%s" %
1367	# (self.portal_url.getPortalPath(),
1368	# student_id,
1369	# level_id)) &\
1370	# Eq('portal_type', "StudentCourseResult")
1371	# level_results = self.portal_catalog_real.evalAdvancedQuery(query)
1372	# level_results = [r for r in course_results
1373	# if level_id in r.relative_path.split('/')]
1374	course_results_ids = [cr.getId for cr in course_results]
1375	for r in portal_catalog_results:
1376	if r.getId in course_results_ids:
1377	continue
1378	course_result_doc = r.getObject().getContent()
1379	data = {}
1380	course_id = r.getId
1381	for field in self.schema():
1382	data[field] = getattr(course_result_doc,field,'')
1383	data['key'] = key = "%(student_id)s\|%(level_id)s\|%(course_id)s" % vars()
1384	data['student_id'] = student_id
1385	data['level_id'] = level_id
1386	data['queue_status'] = OBJECT_CREATED
1387	data['code'] = course_id
1388	self.catalog_object(dict2ob(data), uid=key)
1389	query = Eq('student_id',student_id) & Eq('level_id', level_id)
1390	return self.course_results.evalAdvancedQuery(query)
1391	###)
1392
1393	def getCourses(self,student_id,level_id): ###(
1394	level_path = "%s/campus/students/%s/study_course/%s" % (self.portal_url.getPortalPath(),
1395	student_id,
1396	level_id)
1397	# portal_catalog_query = Eq('path',level_path) &\
1398	# Eq('portal_type', "StudentCourseResult")
1399	# portal_catalog_results = self.portal_catalog_real.evalAdvancedQuery(portal_catalog_query)
1400	portal_catalog_results = self.portal_catalog(path = level_path,
1401	portal_type = "StudentCourseResult")
1402	query = Eq('student_id',student_id) & Eq('level_id', level_id)
1403	course_results = self.course_results.evalAdvancedQuery(query)
1404	if len(course_results) != len(portal_catalog_results):
1405	course_results = self.updateCourseResults(student_id,
1406	level_id,
1407	portal_catalog_results,
1408	course_results)
1409	carry_overs = []
1410	normal = []
1411	credits = 0
1412	for brain in course_results:
1413	d = {}
1414	credits += int(brain.credits)
1415	for field in self.schema():
1416	d[field] = getattr(brain,field,'')
1417	d['sheduled'] = brain.queue_status == ADDING_SHEDULED
1418	d['coe'] = 'Elective'
1419	if brain.core_or_elective:
1420	d['coe'] = 'Core'
1421	id = code = d['id'] = brain.code
1422	is_carry_over = False
1423	if code.endswith('_co'):
1424	is_carry_over = True
1425	code = code[:-3]
1426	d['code'] = code
1427	d['title'] = self.courses_catalog.evalAdvancedQuery(Eq('code',code))[0].title
1428	if is_carry_over:
1429	d['coe'] = 'Core'
1430	carry_overs.append(d)
1431	else:
1432	normal.append(d)
1433	normal.sort(cmp=lambda x,y: cmp(x['semester'], y['semester']))
1434	carry_overs.sort(cmp=lambda x,y: cmp(x['semester'], y['semester']))
1435	return credits,carry_overs,normal
1436	###)
1437
1438	def addObject(self,record): ###(
1439	key = record.key
1440	student_id,level_id,course_id = key.split('\|')
1441	level = getattr(getattr(self.portal_url.getPortalObject().campus.students,student_id).study_course,level_id)
1442	cr_id = level.invokeFactory('StudentCourseResult', course_id)
1443	course_result = getattr(level,cr_id)
1444	self.portal_workflow.doActionFor(course_result,'open')
1445	d = {}
1446	for field in self.schema():
1447	d[field] = getattr(record,field,'')
1448	course_result.getContent().edit(mapping=d)
1449	###)
1450
1451	security.declareProtected(ModifyPortalContent,"process_queue") ###(
1452	def process_queue(self,limit=None):
1453	"""adds objects and removes them from the queue.
1454	If limit is specified, at most (limit) events are removed.
1455	"""
1456	if not hasattr(self,'_queue'):
1457	return 0
1458	queue= self._queue
1459	if not limit or len(queue) <= limit:
1460	keys = self._queue[:]
1461	else:
1462	keys = queue[:limit]
1463	if not keys:
1464	records = self.evalAdvancedQuery(Eq('queue_status',ADDING_SHEDULED))
1465	else:
1466	records = self.evalAdvancedQuery(In("%s" % self.key,keys))
1467	for record in records:
1468	if record.queue_status == OBJECT_CREATED:
1469	continue
1470	self.addObject(record)
1471	data = {}
1472	data['key'] = record.key
1473	data['queue_status'] = OBJECT_CREATED
1474	self.modifyRecord(**data)
1475	count = 0
1476	for key in keys:
1477	count +=1
1478	if key in self._queue:
1479	self._queue.remove(key)
1480	self._p_changed = 1
1481	return count,len(self._queue)
1482	###)
1483
1484	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None): ###(
1485	""" clears the whole enchilada """
1486	self._catalog.clear()
1487
1488	if REQUEST and RESPONSE:
1489	RESPONSE.redirect(
1490	URL1 +
1491	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20Cleared')
1492	###)
1493
1494	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
1495	""" clear the catalog, then re-index everything """
1496
1497	elapse = time.time()
1498	c_elapse = time.clock()
1499
1500	pgthreshold = self._getProgressThreshold()
1501	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
1502	self.refreshCatalog(clear=1, pghandler=handler)
1503
1504	elapse = time.time() - elapse
1505	c_elapse = time.clock() - c_elapse
1506
1507	RESPONSE.redirect(
1508	URL1 +
1509	'/manage_catalogAdvanced?manage_tabs_message=' +
1510	urllib.quote('Catalog Updated \n'
1511	'Total time: %s\n'
1512	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
1513	###)
1514
1515	def refreshCatalog(self, clear=1, pghandler=None): ###(
1516	""" re-index everything we can find """
1517	students_folder = self.portal_url.getPortalObject().campus.students
1518	if clear:
1519	self._catalog.clear()
1520	course_results = self.portal_catalog(portal_type="StudentCourseResult")
1521	num_objects = len(course_results)
1522	if pghandler:
1523	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
1524	#import pdb;pdb.set_trace()
1525	for i in xrange(num_objects):
1526	if pghandler:
1527	pghandler.report(i)
1528	course_result_brain = course_results[i]
1529	path_list = course_result_brain.getPath().split('/')
1530	course_result_doc = course_result_brain.getObject().getContent()
1531	data = {}
1532	level_id = path_list[-2]
1533	course_id = path_list[-1]
1534	student_id = path_list[-4]
1535	for field in self.schema():
1536	data[field] = getattr(course_result_doc,field,'')
1537	data['key'] = key = "%(student_id)s\|%(level_id)s\|%(course_id)s" % vars()
1538	data['student_id'] = student_id
1539	data['level_id'] = level_id
1540	data['queue_status'] = OBJECT_CREATED
1541	self.catalog_object(dict2ob(data), uid=key)
1542	if pghandler: pghandler.finish()
1543	###)
1544
1545	security.declarePrivate('notify_event_listener') ###(
1546	def notify_event_listener(self,event_type,object,infos):
1547	"listen for events"
1548	if not infos.has_key('rpath'):
1549	return
1550	pt = getattr(object,'portal_type',None)
1551	mt = getattr(object,'meta_type',None)
1552	data = {}
1553	rpl = infos['rpath'].split('/')
1554	if mt == 'CPS Proxy Folder':
1555	return
1556	if pt == 'StudentCourseResult' and event_type == "sys_modify_object":
1557	data["%s" % self.key] = uid = "%s\|%s\|%s" % (rpl[-5],rpl[-3],rpl[-2])
1558	records = self.searchResults({"%s" % self.key : uid})
1559	if len(records) > 1:
1560	# Can not happen, but anyway...
1561	raise ValueError("More than one record with uid %s" % uid)
1562	if len(records) == 0:
1563	raise KeyError("No record for uid %s" % uid)
1564	record = records[0]
1565	for field in ('core_or_elective','score'):
1566	value = getattr(object,field,None)
1567	data[field] = value
1568	try:
1569	self.modifyRecord(record,**data)
1570	except KeyError:
1571	pass
1572	if pt == 'StudentStudyLevel' and event_type == "sys_del_object":
1573	#import pdb;pdb.set_trace()
1574	student_id = rpl[-3]
1575	level_id = rpl[-1]
1576	res = self.searchResults(student_id = student_id,
1577	level_id = level_id)
1578	for cr in res:
1579	self.deleteRecord(cr.key)
1580	###)
1581
1582	InitializeClass(CourseResults)
1583	###)
1584
1585	class OnlinePaymentsImport(WAeUPTable): ###(
1586
1587	meta_type = 'WAeUP Online Payment Transactions'
1588	name = "online_payments_import"
1589	key = "order_id"
1590	def __init__(self,name=None):
1591	if name == None:
1592	name = self.name
1593	WAeUPTable.__init__(self, name)
1594
1595
1596	InitializeClass(OnlinePaymentsImport)
1597	###)
1598
1599	class ReturningImport(WAeUPTable): ###(
1600
1601	meta_type = 'Returning Import Table'
1602	name = "returning_import"
1603	key = "matric_no"
1604	def __init__(self,name=None):
1605	if name == None:
1606	name = self.name
1607	WAeUPTable.__init__(self, name)
1608
1609
1610	InitializeClass(ReturningImport)
1611	###)
1612
1613	class ResultsImport(WAeUPTable): ###(
1614
1615	meta_type = 'Results Import Table'
1616	name = "results_import"
1617	key = "key"
1618	def __init__(self,name=None):
1619	if name == None:
1620	name = self.name
1621	WAeUPTable.__init__(self, name)
1622
1623
1624	InitializeClass(ResultsImport)
1625
1626	###)
1627
1628	class PaymentsCatalog(WAeUPTable): ###(
1629
1630	meta_type = 'WAeUP Payments Catalog'
1631	name = "students_catalog"
1632	key = "id"
1633	def __init__(self,name=None):
1634	if name == None:
1635	name = self.name
1636	WAeUPTable.__init__(self, name)
1637
1638
1639	InitializeClass(PaymentsCatalog)
1640
1641	###)
1642
1643	# BBB:
1644	AccomodationTable = AccommodationTable

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

Download in other formats: