Context navigation

source: WAeUP_SRP/trunk/WAeUPTables.py @ 2082

Last change on this file since 2082 was 2078, checked in by joachim, 17 years ago
optimize reindex
Property svn:keywords set to `Id`
File size: 32.4 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 2078 2007-07-30 14:10:40Z joachim $
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	import urllib
28	import DateTime,time
29	import csv,re
30	import logging
31	import Globals
32	p_home = Globals.package_home(globals())
33	i_home = Globals.INSTANCE_HOME
34	from Products.CMFCore.CatalogTool import CatalogTool
35	from Products.AdvancedQuery import Eq, Between, Le,In
36
37	from interfaces import IWAeUPTable
38
39	class AttributeHolder(object):
40	pass
41
42	def dict2ob(dict):
43	ob = AttributeHolder()
44	for key, value in dict.items():
45	setattr(ob, key, value)
46	return ob
47
48	class WAeUPTable(ZCatalog): ###(
49
50	implements(IWAeUPTable)
51	security = ClassSecurityInfo()
52
53	def refreshCatalog(self, clear=0, pghandler=None):
54	""" don't refresh for a normal table """
55
56	if self.REQUEST and self.REQUEST.RESPONSE:
57	self.REQUEST.RESPONSE.redirect(
58	URL1 +
59	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20refresh%20not%20implemented')
60
61	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None):
62	""" clears the whole enchilada """
63
64	#if REQUEST and RESPONSE:
65	# RESPONSE.redirect(
66	# URL1 +
67	# '/manage_catalogAdvanced?manage_tabs_message=Catalog%20Clearing%20disabled')
68
69
70	self._catalog.clear()
71	if REQUEST and RESPONSE:
72	RESPONSE.redirect(
73	URL1 +
74	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20cleared')
75
76	def addRecord(self, **data):
77	# The uid is the same as "bed".
78	uid = data[self.key]
79	res = self.searchResults({"%s" % self.key : uid})
80	if len(res) > 0:
81	raise ValueError("More than one record with uid %s" % uid)
82	self.catalog_object(dict2ob(data), uid=uid)
83	return uid
84
85	def deleteRecord(self, uid):
86	self.uncatalog_object(uid)
87
88	def searchAndSetRecord(self, **data):
89	raise NotImplemented
90
91	def modifyRecord(self, record=None, **data):
92	#records = self.searchResults(uid=uid)
93	uid = data[self.key]
94	if record is None:
95	records = self.searchResults({"%s" % self.key : uid})
96	if len(records) > 1:
97	# Can not happen, but anyway...
98	raise ValueError("More than one record with uid %s" % uid)
99	if len(records) == 0:
100	raise KeyError("No record for uid %s" % uid)
101	record = records[0]
102	record_data = {}
103	for field in self.schema() + self.indexes():
104	record_data[field] = getattr(record, field)
105	# Add the updated data:
106	record_data.update(data)
107	self.catalog_object(dict2ob(record_data), uid)
108
109	def reindexIndex(self, name, REQUEST,pghandler=None):
110	if isinstance(name, str):
111	name = (name,)
112	paths = self._catalog.uids.items()
113	i = 0
114	#import pdb;pdb.set_trace()
115	for p,rid in paths:
116	i += 1
117	metadata = self.getMetadataForRID(rid)
118	record_data = {}
119	for field in name:
120	record_data[field] = metadata.get(field)
121	uid = metadata.get(self.key)
122	self.catalog_object(dict2ob(record_data), uid, idxs=name,
123	update_metadata=0)
124
125	security.declareProtected(ModifyPortalContent,"exportAllRecords")
126	def exportAllRecords(self):
127	"export a WAeUPTable"
128	#import pdb;pdb.set_trace()
129	fields = [field for field in self.schema()]
130	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
131	csv = []
132	csv.append(','.join(['"%s"' % fn for fn in fields]))
133	for uid in self._catalog.uids:
134	records = self.searchResults({"%s" % self.key : uid})
135	if len(records) > 1:
136	# Can not happen, but anyway...
137	raise ValueError("More than one record with uid %s" % uid)
138	if len(records) == 0:
139	raise KeyError("No record for uid %s" % uid)
140	rec = records[0]
141	csv.append(format % rec)
142	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
143	open("%s/import/%s-%s.csv" % (i_home,self.getId(),current),"w+").write('\n'.join(csv))
144	###)
145
146	class AccommodationTable(WAeUPTable): ###(
147
148	meta_type = 'WAeUP Accommodation Tool'
149	name = "accommodation"
150	key = "bed"
151	def __init__(self):
152	WAeUPTable.__init__(self, 'portal_accommodation')
153
154	def searchAndReserveBed(self, student_id,bed_type):
155	records = self.searchResults({'student' : student_id})
156	if len(records) > 0:
157	return -1,"Student with Id %s already booked bed %s." % (student_id,records[0].bed)
158
159	records = [r for r in self.searchResults({'bed_type' : bed_type}) if not r.student]
160	#import pdb;pdb.set_trace()
161	if len(records) == 0:
162	return -2,"No bed available"
163	rec = records[0]
164	self.modifyRecord(bed=rec.bed,student=student_id)
165	s_logger = logging.getLogger('WAeUPTables.AccommodationTable.searchAndReserveBed')
166	s_logger.info('%s reserved bed %s' % (student_id,rec.bed))
167	return 1,rec.bed
168
169
170	InitializeClass(AccommodationTable)
171
172	###)
173
174	class PinTable(WAeUPTable): ###(
175	from ZODB.POSException import ConflictError
176	meta_type = 'WAeUP Pin Tool'
177	name = "pins"
178	key = 'pin'
179	def __init__(self):
180	WAeUPTable.__init__(self, 'portal_pins')
181
182
183	def searchAndSetRecord(self, uid, student_id,prefix):
184	#records = self.searchResults(uid=uid)
185	records = self.searchResults(student = student_id)
186	#import pdb;pdb.set_trace()
187	if len(records) > 0 and prefix in ('CLR','APP'):
188	for r in records:
189	if r.pin != uid and r.prefix_batch.startswith(prefix):
190	return -2
191	records = self.searchResults({"%s" % self.key : uid})
192	if len(records) > 1:
193	# Can not happen, but anyway...
194	raise ValueError("More than one record with uid %s" % uid)
195	if len(records) == 0:
196	return -1
197	record = records[0]
198	if record.student == "":
199	record_data = {}
200	for field in self.schema() + self.indexes():
201	record_data[field] = getattr(record, field)
202	# Add the updated data:
203	record_data['student'] = student_id
204	try:
205	self.catalog_object(dict2ob(record_data), uid)
206	return 1
207	except ConflictError:
208	return 2
209	if record.student.upper() != student_id.upper():
210	return 0
211	if record.student.upper() == student_id.upper():
212	return 2
213	return -3
214
215	InitializeClass(PinTable)
216
217	###)
218
219	class PumeResultsTable(WAeUPTable): ###(
220
221	meta_type = 'WAeUP PumeResults Tool'
222	name = "pumeresults"
223	key = "jamb_reg_no"
224	def __init__(self):
225	WAeUPTable.__init__(self, 'portal_pumeresults')
226
227
228	InitializeClass(PumeResultsTable)
229
230	###)
231
232	class StudentsCatalog(WAeUPTable): ###(
233	security = ClassSecurityInfo()
234
235	meta_type = 'WAeUP Students Catalog'
236	name = "students_catalog"
237	key = "id"
238	affected_types = { ###(
239	'StudentApplication':
240	{'id': 'application',
241	'fields':
242	('jamb_reg_no',
243	'entry_mode',
244	#'entry_level',
245	'entry_session',
246	)
247	},
248	'StudentClearance':
249	{'id': 'clearance',
250	'fields':
251	('matric_no',
252	'lga',
253	)
254	},
255	'StudentPersonal':
256	{'id': 'personal',
257	'fields':
258	('name',
259	'sex',
260	'perm_address',
261	'email',
262	'phone',
263	)
264	},
265	'StudentStudyCourse':
266	{'id': 'study_course',
267	'fields':
268	('course', # study_course
269	'faculty', # from certificate
270	'department', # from certificate
271	'end_level', # from certificate
272	'level', # current_level
273	'mode', # current_mode
274	'session', # current_session
275	'verdict', # current_verdict
276	)
277	},
278	}
279	###)
280
281	def __init__(self):
282	WAeUPTable.__init__(self, 'students_catalog')
283	return
284
285	def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None):
286	""" clears the whole enchilada """
287	self._catalog.clear()
288
289	if REQUEST and RESPONSE:
290	RESPONSE.redirect(
291	URL1 +
292	'/manage_catalogAdvanced?manage_tabs_message=Catalog%20Cleared')
293
294	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
295	""" clear the catalog, then re-index everything """
296
297	elapse = time.time()
298	c_elapse = time.clock()
299
300	pgthreshold = self._getProgressThreshold()
301	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
302	self.refreshCatalog(clear=1, pghandler=handler)
303
304	elapse = time.time() - elapse
305	c_elapse = time.clock() - c_elapse
306
307	RESPONSE.redirect(
308	URL1 +
309	'/manage_catalogAdvanced?manage_tabs_message=' +
310	urllib.quote('Catalog Updated \n'
311	'Total time: %s\n'
312	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
313	###)
314
315	def fill_certificates_dict(self):
316	"return certificate data in dict"
317	certificates_brains = self.portal_catalog(portal_type ='Certificate')
318	d = {}
319	for cb in certificates_brains:
320	certificate_doc = cb.getObject().getContent()
321	cb_path = cb.getPath().split('/')
322	ld = {}
323	ld['faculty'] = cb_path[-4]
324	ld['department'] = cb_path[-3]
325	ld['end_level'] = getattr(certificate_doc,'end_level','999')
326	d[cb.getId] = ld
327	return d
328
329	def get_from_doc_department(self,doc,cached_data={}): ###(
330	"return the students department"
331	if doc is None:
332	return None
333	if cached_data.has_key(doc.study_course):
334	return cached_data[doc.study_course]['department']
335	certificate_res = self.portal_catalog(id = doc.study_course)
336	if len(certificate_res) != 1:
337	return None
338	return certificate_res[0].getPath().split('/')[-3]
339
340	def get_from_doc_faculty(self,doc,cached_data={}):
341	"return the students faculty"
342	if doc is None:
343	return None
344	if cached_data.has_key(doc.study_course):
345	return cached_data[doc.study_course]['faculty']
346	certificate_res = self.portal_catalog(id = doc.study_course)
347	if len(certificate_res) != 1:
348	return None
349	return certificate_res[0].getPath().split('/')[-4]
350
351	def get_from_doc_end_level(self,doc,cached_data={}):
352	"return the students end_level"
353	if doc is None:
354	return None
355	if cached_data.has_key(doc.study_course):
356	return cached_data[doc.study_course]['end_level']
357	certificate_res = self.portal_catalog(id = doc.study_course)
358	if len(certificate_res) != 1:
359	return None
360	return getattr(certificate_res[0].getObject().getContent(),'end_level','unknown')
361
362	def get_from_doc_level(self,doc,cached_data={}):
363	"return the students level"
364	if doc is None:
365	return None
366	return getattr(doc,'current_level',None)
367
368	def get_from_doc_mode(self,doc,cached_data={}):
369	"return the students mode"
370	if doc is None:
371	return None
372	cm = getattr(doc,'current_mode',None)
373	return cm
374
375
376	def get_from_doc_session(self,doc,cached_data={}):
377	"return the students current_session"
378	if doc is None:
379	return None
380	return getattr(doc,'current_session',None)
381
382	def get_from_doc_entry_session(self,doc,cached_data={}):
383	"return the students entry_session"
384	if doc is None:
385	return None
386	es = getattr(doc,'entry_session',None)
387	if es is not None and len(es) == 2:
388	return es
389	try:
390	digit = int(doc.jamb_reg_no[0])
391	except:
392	return "-1"
393	if digit < 8:
394	return "0%c" % doc.jamb_reg_no[0]
395	return "9%c" % doc.jamb_reg_no[0]
396
397	def get_from_doc_course(self,doc,cached_data={}):
398	"return the students study_course"
399	if doc is None:
400	return None
401	return getattr(doc,'study_course',None)
402
403	def get_from_doc_name(self,doc,cached_data={}):
404	"return the students name from the personal"
405	if doc is None:
406	return None
407	return "%s %s %s" % (doc.firstname,doc.middlename,doc.lastname)
408
409	def get_from_doc_verdict(self,doc,cached_data={}):
410	"return the students study_course"
411	if doc is None:
412	return None
413	return getattr(doc,'current_verdict',None)
414	###)
415
416	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
417	if isinstance(name, str):
418	name = (name,)
419	reindextypes = {}
420	reindex_special = []
421	for n in name:
422	if n in ("review_state","registered_courses"):
423	reindex_special.append(n)
424	else:
425	for pt in self.affected_types.keys():
426	if n in self.affected_types[pt]['fields']:
427	if reindextypes.has_key(pt):
428	reindextypes[pt].append(n)
429	else:
430	reindextypes[pt]= [n]
431	break
432	cached_data = {}
433	if set(name).intersection(set(('faculty','department','end_level'))):
434	cached_data = self.fill_certificates_dict()
435	students = self.portal_catalog(portal_type="Student")
436	if hasattr(self,'portal_catalog_real'):
437	aq_portal = self.portal_catalog_real.evalAdvancedQuery
438	else:
439	aq_portal = self.portal_catalog.evalAdvancedQuery
440	num_objects = len(students)
441	if pghandler:
442	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
443	noattr = set(('StudentClearance','StudentPersonal')) & set(reindextypes.keys())
444	for i in xrange(num_objects):
445	if pghandler: pghandler.report(i)
446	student_brain = students[i]
447	student_object = student_brain.getObject()
448	data = {}
449	modified = False
450	sid = data['id'] = student_brain.getId
451	if reindex_special and 'review_state' in reindex_special:
452	modified = True
453	data['review_state'] = student_brain.review_state
454	sub_objects = False
455	for pt in reindextypes.keys():
456	modified = True
457	try:
458	doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
459	sub_objects = True
460	except:
461	continue
462	for field in self.affected_types[pt]['fields']:
463	if hasattr(self,'get_from_doc_%s' % field):
464	data[field] = getattr(self,'get_from_doc_%s' % field)(doc,
465	cached_data=cached_data)
466	else:
467	data[field] = getattr(doc,field)
468	if not sub_objects and noattr:
469	import_res = self.returning_import(id = sid)
470	if not import_res:
471	continue
472	import_record = import_res[0]
473	data['matric_no'] = import_record.matric_no
474	data['sex'] = import_record.Sex == 'F'
475	data['name'] = "%s %s %s" % (import_record.Firstname,
476	import_record.Middlename,
477	import_record.Lastname)
478	data['jamb_reg_no'] = import_record.Entryregno
479	if reindex_special and 'registered_courses' in reindex_special:
480	try:
481	study_course = getattr(student_object,"study_course")
482	level_ids = study_course.objectIds()
483	except:
484	continue
485	if not level_ids:
486	continue
487	modified = True
488	level_ids.sort()
489	course_ids = getattr(study_course,level_ids[-1]).objectIds()
490	courses = []
491	for c in course_ids:
492	if c.endswith('_co'):
493	courses.append(c[:-3])
494	else:
495	courses.append(c)
496	data['registered_courses'] = courses
497	if modified:
498	self.modifyRecord(**data)
499	if pghandler: pghandler.finish()
500	###)
501
502	def refreshCatalog(self, clear=0, pghandler=None): ###(
503	""" re-index everything we can find """
504	students_folder = self.portal_url.getPortalObject().campus.students
505	if clear:
506	self._catalog.clear()
507	students = self.portal_catalog(portal_type="Student")
508	num_objects = len(students)
509	cached_data = self.fill_certificates_dict()
510	if pghandler:
511	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
512	for i in xrange(num_objects):
513	if pghandler: pghandler.report(i)
514	student_brain = students[i]
515	spath = student_brain.getPath()
516	student_object = student_brain.getObject()
517	data = {}
518	sid = data['id'] = student_brain.getId
519	data['review_state'] = student_brain.review_state
520	sub_objects = False
521	for pt in self.affected_types.keys():
522	modified = True
523	try:
524	doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
525	sub_objects = True
526	except:
527	#from pdb import set_trace;set_trace()
528	continue
529	for field in self.affected_types[pt]['fields']:
530	if hasattr(self,'get_from_doc_%s' % field):
531	data[field] = getattr(self,'get_from_doc_%s' % field)(doc,
532	cached_data=cached_data)
533	else:
534	data[field] = getattr(doc,field,None)
535	if not sub_objects:
536	import_res = self.returning_import(id = sid)
537	if not import_res:
538	continue
539	import_record = import_res[0]
540	data['matric_no'] = import_record.matric_no
541	data['sex'] = import_record.Sex == 'F'
542	data['name'] = "%s %s %s" % (import_record.Firstname,
543	import_record.Middlename,
544	import_record.Lastname)
545	data['jamb_reg_no'] = import_record.Entryregno
546	else:
547	study_course = getattr(student_object,'study_course',None)
548	current_level = data.get('level',None)
549	data['registered_courses'] = []
550	if study_course and current_level and current_level in study_course.objectIds():
551	level_obj = getattr(study_course,current_level)
552	courses = []
553	for c in level_obj.objectIds():
554	if c.endswith('_co'):
555	courses.append(c[:-3])
556	else:
557	courses.append(c)
558	data['registered_courses'] = courses
559	self.addRecord(**data)
560	if pghandler: pghandler.finish()
561	###)
562
563	security.declarePrivate('notify_event_listener') ###(
564	def notify_event_listener(self,event_type,object,infos):
565	"listen for events"
566	if not infos.has_key('rpath'):
567	return
568	pt = getattr(object,'portal_type',None)
569	mt = getattr(object,'meta_type',None)
570	students_catalog = self
571	data = {}
572	if pt == 'Student' and\
573	mt == 'CPS Proxy Folder' and\
574	event_type.startswith('workflow'):
575	data['id'] = object.getId()
576	data['review_state'] = self.portal_workflow.getInfoFor(object,'review_state',None)
577	students_catalog.modifyRecord(**data)
578	return
579	rpl = infos['rpath'].split('/')
580	if pt == 'Student' and mt == 'CPS Proxy Folder'\
581	and event_type == "sys_add_object":
582	student_id = object.id
583	try:
584	self.addRecord(id = student_id)
585	except ValueError:
586	pass
587	return
588	elif pt == 'StudentCourseResult' and mt == 'CPS Proxy Folder':
589	if event_type not in ("sys_add_object","sys_del_object"):
590	return
591	level_session = getattr(object.aq_parent.getContent(),'session','unknown')
592	if level_session not in (self.getSessionId()[-2:],'2006/2007'):
593	return
594	course_id = object.getId()
595	if course_id.endswith('_co'):
596	course_id = course_id[:-3]
597	student_id = object.absolute_url_path().split('/')[-4]
598	res = students_catalog(id = student_id)
599	if not res:
600	return
601	student_rec = res[0]
602	registered_courses = getattr(student_rec,'registered_courses',None)
603	if not registered_courses:
604	registered_courses = []
605	#import pdb;pdb.set_trace()
606	if event_type == "sys_add_object":
607	if course_id not in registered_courses:
608	registered_courses.append(course_id)
609	else:
610	return
611	elif registered_courses and event_type == "sys_del_object":
612	removed = False
613	while course_id in registered_courses:
614	removed = True
615	registered_courses.remove(course_id)
616	if not removed:
617	return
618	data['id'] = student_id
619	data['registered_courses'] = registered_courses
620	self.modifyRecord(record = student_rec, **data)
621	return
622	if pt not in self.affected_types.keys():
623	return
624	if event_type not in ('sys_modify_object'):
625	return
626	if mt == 'CPS Proxy Folder':
627	return
628	for field in self.affected_types[pt]['fields']:
629	if hasattr(self,'get_from_doc_%s' % field):
630	data[field] = getattr(self,'get_from_doc_%s' % field)(object)
631	else:
632	data[field] = getattr(object,field)
633	data['id'] = rpl[2]
634	self.modifyRecord(**data)
635	###)
636
637
638	InitializeClass(StudentsCatalog)
639
640	###)
641
642	class StatisticsCatalog(StudentsCatalog): ###(
643	security = ClassSecurityInfo()
644	meta_type = 'WAeUP Statistics Catalog'
645	name = "statistics"
646	affected_types = { ###(
647	'StudentApplication':
648	{'id': 'application',
649	'fields':
650	('jamb_reg_no',
651	'entry_mode',
652	#'entry_level',
653	'entry_session',
654	)
655	},
656	'StudentClearance':
657	{'id': 'clearance',
658	'fields':
659	('matric_no',
660	)
661	},
662	'StudentPersonal':
663	{'id': 'personal',
664	'fields':
665	('name',
666	'sex',
667	'email',
668	'phone',
669	)
670	},
671	'StudentStudyCourse':
672	{'id': 'study_course',
673	'fields':
674	('course',
675	'faculty',
676	'department',
677	'level',
678	'mode',
679	'session',
680	'verdict',
681	)
682	},
683	}
684	###)
685
686
687	InitializeClass(StudentsCatalog)
688	###)
689
690	class CoursesCatalog(WAeUPTable): ###(
691	security = ClassSecurityInfo()
692
693	meta_type = 'WAeUP Courses Catalog'
694	name = "courses_catalog"
695	key = "code"
696	def __init__(self):
697	WAeUPTable.__init__(self, 'courses_catalog')
698
699	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
700	""" clear the catalog, then re-index everything """
701
702	elapse = time.time()
703	c_elapse = time.clock()
704
705	pgthreshold = self._getProgressThreshold()
706	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
707	self.refreshCatalog(clear=1, pghandler=handler)
708
709	elapse = time.time() - elapse
710	c_elapse = time.clock() - c_elapse
711
712	RESPONSE.redirect(
713	URL1 +
714	'/manage_catalogAdvanced?manage_tabs_message=' +
715	urllib.quote('Catalog Updated \n'
716	'Total time: %s\n'
717	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
718	###)
719
720	def reindexIndex(self, name, REQUEST,pghandler=None): ###(
721	if isinstance(name, str):
722	name = (name,)
723	courses = self.portal_catalog(portal_type="Course")
724	num_objects = len(courses)
725	if pghandler:
726	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
727	for i in xrange(num_objects):
728	if pghandler: pghandler.report(i)
729	course_brain = courses[i]
730	course_object = course_brain.getObject()
731	pl = course_brain.getPath().split('/')
732	data = {}
733	cid = data[self.key] = course_brain.getId
734	data['faculty'] = pl[-4]
735	data['department'] = pl[-3]
736	doc = course_object.getContent()
737	for field in name:
738	if field not in (self.key,'faculty','department'):
739	data[field] = getattr(doc,field)
740	self.modifyRecord(**data)
741	if pghandler: pghandler.finish()
742	###)
743
744	def refreshCatalog(self, clear=0, pghandler=None): ###(
745	""" re-index everything we can find """
746	if clear:
747	self._catalog.clear()
748	courses = self.portal_catalog(portal_type="Course")
749	num_objects = len(courses)
750	if pghandler:
751	pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
752	#from pdb import set_trace;set_trace()
753	for i in xrange(num_objects):
754	if pghandler: pghandler.report(i)
755	course_brain = courses[i]
756	course_doc = course_brain.getObject().getContent()
757	pl = course_brain.getPath().split('/')
758	data = {}
759	for field in self.schema():
760	data[field] = getattr(course_doc,field,None)
761	data[self.key] = course_brain.getId
762	ai = pl.index('academics')
763	data['faculty'] = pl[ai +1]
764	data['department'] = pl[ai +2]
765	if clear:
766	self.addRecord(**data)
767	else:
768	self.modifyRecord(**data)
769	if pghandler: pghandler.finish()
770	###)
771
772	security.declarePrivate('notify_event_listener') ###(
773	def notify_event_listener(self,event_type,object,infos):
774	"listen for events"
775	if not infos.has_key('rpath'):
776	return
777	pt = getattr(object,'portal_type',None)
778	mt = getattr(object,'meta_type',None)
779	if pt != 'Course':
780	return
781	data = {}
782	rpl = infos['rpath'].split('/')
783	if event_type not in ("sys_add_object","sys_modify_object","sys_del_object"):
784	return
785	course_id = object.getId()
786	data[self.key] = course_id
787	if event_type == "sys_add_object" and mt == 'CPS Proxy Folder':
788	try:
789	self.addRecord(**data)
790	except ValueError:
791	return
792	course_id = object.getId()
793	doc = object.getContent()
794	if doc is None:
795	return
796	for field in self.schema():
797	data[field] = getattr(doc,field,None)
798	data[self.key] = course_id
799	ai = rpl.index('academics')
800	data['faculty'] = rpl[ai +1]
801	data['department'] = rpl[ai +2]
802	self.modifyRecord(**data)
803	return
804	if event_type == "sys_del_object":
805	self.deleteRecord(course_id)
806	return
807	if event_type == "sys_modify_object" and mt == 'Course':
808	#from pdb import set_trace;set_trace()
809	for field in self.schema():
810	data[field] = getattr(object,field,None)
811	course_id = object.aq_parent.getId()
812	data[self.key] = course_id
813	ai = rpl.index('academics')
814	data['faculty'] = rpl[ai +1]
815	data['department'] = rpl[ai +2]
816	self.modifyRecord(**data)
817	###)
818
819
820	InitializeClass(CoursesCatalog)
821	###)
822
823	class ResultsCatalog(WAeUPTable): ###(
824	security = ClassSecurityInfo()
825
826	meta_type = 'WAeUP Results Catalog'
827	name = "course_results"
828	key = "key"
829	def __init__(self):
830	WAeUPTable.__init__(self, 'course_results')
831
832	def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
833	""" clear the catalog, then re-index everything """
834
835	elapse = time.time()
836	c_elapse = time.clock()
837
838	pgthreshold = self._getProgressThreshold()
839	handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
840	#self.refreshCatalog(clear=1, pghandler=handler)
841
842	elapse = time.time() - elapse
843	c_elapse = time.clock() - c_elapse
844
845	RESPONSE.redirect(
846	URL1 +
847	'/manage_catalogAdvanced?manage_tabs_message=' +
848	urllib.quote('Catalog Updated \n'
849	'Total time: %s\n'
850	'Total CPU time: %s' % (`elapse`, `c_elapse`)))
851	###)
852
853
854	InitializeClass(ResultsCatalog)
855	###)
856
857	class OnlinePaymentsImport(WAeUPTable): ###(
858
859	meta_type = 'WAeUP Online Payment Transactions'
860	name = "online_payments_import"
861	key = "order_id"
862	def __init__(self):
863	WAeUPTable.__init__(self, self.name)
864
865
866	InitializeClass(OnlinePaymentsImport)
867	###)
868
869	class ReturningImport(WAeUPTable): ###(
870
871	meta_type = 'Returning Import Table'
872	name = "returning_import"
873	key = "matric_no"
874	def __init__(self):
875	WAeUPTable.__init__(self, 'returning_import')
876
877
878	InitializeClass(ReturningImport)
879	###)
880
881	class ResultsImport(WAeUPTable): ###(
882
883	meta_type = 'Results Import Table'
884	name = "results_import"
885	key = "key"
886	def __init__(self):
887	WAeUPTable.__init__(self, 'results_import')
888
889
890	InitializeClass(ResultsImport)
891
892	###)
893
894	class PaymentsCatalog(WAeUPTable): ###(
895
896	meta_type = 'WAeUP Payments Catalog'
897	name = "students_catalog"
898	key = "id"
899	def __init__(self):
900	WAeUPTable.__init__(self, 'payments_catalog')
901
902
903	InitializeClass(PaymentsCatalog)
904
905	###)
906
907	# BBB:
908	AccomodationTable = AccommodationTable

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

Download in other formats: