Context navigation

source: WAeUP_SRP/trunk_not_used/Academics.py @ 2467

Last change on this file since 2467 was 2190, checked in by Henrik Bettermann, 17 years ago
cleaning
Property svn:keywords set to `Id`
File size: 39.3 KB

Line
1	#-- mode: python; mode: fold --
2	from Globals import InitializeClass
3	from AccessControl import ClassSecurityInfo
4
5	from Products.CMFCore.utils import UniqueObject, getToolByName
6	from Products.CMFCore.permissions import View
7	from Products.CMFCore.permissions import ModifyPortalContent
8	from Products.CPSCore.CPSBase import CPSBase_adder, CPSBaseFolder
9	#from Products.CPSCore.CPSBase import CPSBaseDocument as BaseDocument
10	from Products.CPSDocument.CPSDocument import CPSDocument
11	#from Products.CPSCore.CPSBase import CPSBaseBTreeFolder as BaseBTreeFolder
12	#from Products.CPSCore.CPSBase import CPSBaseBTreeDocument as BaseBTreeDocument
13	#from Products.CMFCore.DirectoryView import registerDirectory
14
15	#registerDirectory('skins', globals())
16	#registerDirectory('skins/waeup_default', globals())
17	#registerDirectory('skins/waeup_faculty', globals())
18
19	import DateTime
20	import csv,re
21	import logging
22	import Globals
23	p_home = Globals.package_home(globals())
24	i_home = Globals.INSTANCE_HOME
25
26	def makeCertificateCode(code): ###(
27	code = code.replace('.','')
28	code = code.replace('(','')
29	code = code.replace(')','')
30	code = code.replace('/','')
31	code = code.replace(' ','')
32	code = code.replace('_','')
33	return code
34
35	###)
36
37	class AcademicsFolder(CPSDocument): ###(
38	"""
39	WAeUP AcademicsFolder containing StudyCourses
40	"""
41	meta_type = 'AcademicsFolder'
42	portal_type = meta_type
43	security = ClassSecurityInfo()
44	use_catalog_for_folder_contents = True
45
46	security.declareProtected(View,"Title")
47	def Title(self):
48	"""compose title"""
49	return "Academic Section"
50
51	def importLocalRoles(self,portal_type): ###(
52	name = '%sLocalRoles' % portal_type
53	logger = logging.getLogger('Academics.AcademicsFolder.importLocalRoles')
54	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
55	logger.info('Start importing %(name)s to %(name)s_%(current)s.csv' % vars())
56	export = []
57	export.append('"code","users"')
58	pm = self.portal_membership
59	#import pdb;pdb.set_trace()
60	try:
61	imp_roles = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
62	except:
63	logger.error('Error reading %s.csv' % name)
64	return
65	odict = {}
66	for f in self.portal_catalog({'meta_type': portal_type}):
67	odict[f.getId] = f.getObject()
68	for role in imp_roles:
69	obj_id = role['code']
70	if obj_id in odict.keys():
71	roles_dict = eval(role['users'])
72	for r in roles_dict.keys():
73	if r.startswith('user'):
74	member_id = r.split(':')[1]
75	odict[obj_id].manage_setLocalRoles(member_id, roles_dict[r])
76	logger.info('Importing role for %s %s %s' % (obj_id, member_id,roles_dict[r]))
77
78	###)
79
80	security.declareProtected(ModifyPortalContent,"loadFacultiesFromCSV")###(
81	def loadFacultiesFromCSV(self):
82	"""install Universityspecific Faculies from CSV values"""
83	#return
84	if self.REQUEST.get('localroles'):
85	self.importLocalRoles('Faculty')
86	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
87	name = 'Faculties'
88	no_import = False
89	logger = logging.getLogger('Academics.AcademicsFolder.loadFacultiesFromCSV')
90	logger.info('Start loading from %s.csv' % name)
91	academics = self.portal_catalog({'meta_type': 'AcademicsFolder'})[-1].getObject()
92	try:
93	faculties = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
94	except:
95	logger.error('Error reading %s.csv' % name)
96	return
97	l = self.portal_catalog({'meta_type': "Faculty"})
98	facs = {}
99	for f in l:
100	facs[f.id] = f.getObject()
101	fields = ("code",
102	"review_state",
103	"title",
104	"title_prefix",
105	"college_code",
106	"degree_grade",
107	"bank_code",
108	)
109	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
110	for faculty in faculties:
111	processing = "processing %s" % format
112	logger.info(processing % faculty)
113	fid = faculty.get('code')
114	f = facs.get(fid,None)
115	if f is None:
116	#self.log('Creating Faculty %(id)s = %(Title)s' % faculty)
117	logger.info('Creating Faculty with ID %(code)s %(title)s' % faculty)
118	academics.invokeFactory('Faculty', fid)
119	f = getattr(self,fid)
120	d = {'Title': faculty.get('title')}
121	else:
122	d = {}
123	f.getContent().edit(mapping=faculty)
124	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
125	###)
126
127	security.declareProtected(ModifyPortalContent,"loadDepartmentsFromCSV")###(
128	def loadDepartmentsFromCSV(self):
129	"""install Universityspecific Faculies from CSV values"""
130	#return
131	if self.REQUEST.get('localroles'):
132	self.importLocalRoles('Department')
133	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
134	name = 'Departments'
135	no_import = False
136	logger = logging.getLogger('Academics.AcademicsFolder.loadDepartmentsFromCSV')
137	fields = ("code",
138	"review_state",
139	"title",
140	"title_prefix",
141	"faculty_code",
142	)
143	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
144	try:
145	deps = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
146	except:
147	logger.error('Error reading %s.csv' % name)
148	return
149	no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
150	heading = ','.join(['"%s"' % fn for fn in fields])
151	no_import.write('%s\n' % heading)
152	l = self.portal_catalog({'meta_type': "Faculty"})
153	facs = {}
154	for f in l:
155	facs[f.id] = f.getObject()
156	for dep in deps:
157	processing = "processing %s" % format
158	logger.info(processing % dep)
159	fid = dep['faculty_code']
160	f = facs.get(fid,None)
161	if f is None:
162	logger.info( "No Faculty with ID: %s" % fid)
163	no_import.write( "No Faculty with ID: %s\n" % fid)
164	no_import.write(format % dep + "\n")
165	else:
166	did = dep.get('code')
167	d = getattr(f,did,None)
168	if d is None or d.portal_type == "Faculty":
169	logger.info('Creating Department %(code)s = %(title)s' % dep)
170	f.invokeFactory('Department', did)
171	d = getattr(f,did)
172	d.invokeFactory('CoursesFolder','courses')
173	courses = getattr(d,'courses')
174	dict = {'Title': 'Courses'}
175	courses.getContent().edit(mapping=dict)
176	d.invokeFactory('CertificatesFolder','certificates')
177	certificates = getattr(d,'certificates')
178	dict = {'Title': 'Certificates'}
179	certificates.getContent().edit(mapping=dict)
180	d.getContent().edit(mapping=dep)
181
182	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
183	###)
184
185	security.declareProtected(ModifyPortalContent,"loadCoursesFromCSV")###(
186	def loadCoursesFromCSV(self):
187	"""install Universityspecific Courses from CSV values"""
188	#return
189	not_allowed =re.compile('[^A-Z0-9]')
190	wf = self.portal_workflow
191	name = 'Courses'
192	no_import = False
193	logger = logging.getLogger('Academics.AcademicsFolder.loadCoursesFromCSV')
194	fields = ("code",
195	"review_state",
196	"title",
197	"faculty_code",
198	"department_code",
199	"credits",
200	"org_code",
201	"passmark",
202	"semester",
203	"session",
204	)
205	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
206	try:
207	courses = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
208	except:
209	logger.error('Error reading %s.csv' % name)
210	return
211	imported = []
212	not_imported = []
213	heading = ','.join(['"%s"' % fn for fn in fields])
214	imported.append(heading)
215	not_imported.append(heading)
216	#no_import.write('%s\n' % heading)
217	#l = self.portal_catalog({'meta_type': "Faculty"})
218	#facs = {}
219	#for f in l:
220	# facs[f.id] = f.getObject()
221	dl = self.portal_catalog({'meta_type': "Department"})
222	deps = {}
223	for d in dl:
224	deps[d.id] = d.getObject()
225	cl = self.portal_catalog({'meta_type': "Course"})
226	course_list = [ c.id for c in cl]
227	for course in courses:
228	#processing = "processing %s" % format
229	#logger.info(processing % course)
230	course_id = course.get('code')
231	if not_allowed.search(course_id):
232	msg = ',"Invalid Course Code"'
233	#logger.info(msg)
234	#not_imported.append('"%s",' % msg)
235	not_imported.append(format % course + msg)
236	continue
237	depid = course.get('department_code').upper()
238	if depid in deps.keys():
239	dept= deps.get(depid)
240	else:
241	msg = ',"Department not found"'
242	#logger.info(msg)
243	#not_imported.append('"%s",' % msg)
244	not_imported.append(format % course + msg)
245	continue
246	if course_id in course_list:
247	msg = ',"Multiple Course Code"'
248	#logger.info(msg)
249	#not_imported.append('"%s",' % msg)
250	not_imported.append(format % course + msg)
251	continue
252	level = "%c00" % course_id[-3]
253	course['level'] = level
254	cf = dept.courses
255	c = getattr(cf,course_id,None)
256	#cd_fields = (('code','code'),
257	# ('faculty','faculty_code'),
258	# ('department','department_code'),
259	# ('title','title'),
260	# ('credits','credits'),
261	# ('level','level'),
262	# ('semester','semester'),
263	# )
264	#cd = {}
265	#for t,f in cd_fields:
266	# cd[t] = course[f]
267	#import pdb;pdb.set_trace()
268	if c is None:
269	logger.info('Creating Course %(code)s %(title)s in Department %(department_code)s' % course)
270	cf.invokeFactory('Course', course_id)
271	course_list.append(course_id)
272	imported.append(format % course)
273	c = getattr(cf,course_id)
274	#self.courses_catalog.addRecord(**cd)
275	#else:
276	# self.courses_catalog.modifyRecord(**cd)
277	c.getContent().edit(mapping=course)
278	review_state = course.get('review_state')
279	if review_state == "checked" and wf.getInfoFor(c,'review_state',None) != 'checked':
280	self.portal_workflow.doActionFor(c,'approve')
281	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
282	if len(not_imported) > 1:
283	open("%s/import/%s_%s_not_imported.csv" % (i_home,name,current),"w")\
284	.write('\n'.join(not_imported))
285	open("%s/import/%s_%s_imported.csv" % (i_home,name,current),"w")\
286	.write('\n'.join(imported))
287	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
288	###)
289
290	security.declareProtected(ModifyPortalContent,"loadCertificatesFromCSV")###(
291
292	def loadCertificatesFromCSV(self):
293	"""install Universityspecific Certificates from CSV values"""
294	#return
295	name = 'Certificates'
296	wf = self.portal_workflow
297	no_import_list = []
298	logger = logging.getLogger('Academics.AcademicsFolder.loadCertificatesFromCSV')
299	fields = ("code",
300	"review_state",
301	"title",
302	"faculty_code",
303	"department_code",
304	"category",
305	"end_level",
306	"m_prefix",
307	"max_elect",
308	"max_pass",
309	"n_core",
310	"nr_years",
311	"original_code",
312	"probation_credits",
313	"promotion_credits",
314	"start_level",
315	"admin_status",
316	)
317	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
318	try:
319	courses = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
320	except:
321	logger.error('Error reading %s.csv' % name)
322	return
323	try:
324	certificates = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
325	except:
326	logger.error('Error reading %s.csv' % name)
327	return
328	f_ids = [f.id for f in self.portal_catalog({'meta_type': "Faculty"})]
329	dl = self.portal_catalog({'meta_type': "Department"})
330	deps = {}
331	for d in dl:
332	deps[d.id] = d.getObject()
333	for certificate in certificates:
334	processing = "processing %s" % format
335	logger.info(processing % certificate)
336	depid = certificate.get('department_code')
337	facid = certificate.get('faculty_code')
338	if facid not in f_ids:
339	msg = 'Faculty %(faculty_code)s for %(code)s %(title)s not found' % certificate
340	logger.info(msg)
341	no_import_list.append(msg)
342	no_import_list.append(format % certificate + "\n")
343	continue
344	if not deps.has_key(depid):
345	msg = 'Department %(department_code)s for %(code)s %(title)s not found' % certificate
346	logger.info(msg)
347	no_import_list.append(msg)
348	no_import_list.append(format % certificate + "\n")
349	continue
350	dep = deps[depid]
351	cf= dep.certificates
352	code = certificate.get('code')
353	certificate_id = code
354	c = getattr(cf,certificate_id,None)
355	if c is None:
356	logger.info('Creating certificate %(code)s %(title)s in Department %(department_code)s' % certificate)
357	cf.invokeFactory('Certificate', certificate_id)
358	c = getattr(cf,certificate_id)
359	c.getContent().edit(mapping=certificate)
360	review_state = c.get('review_state')
361	if review_state == "checked" and wf.getInfoFor(c,'review_state',None) != 'checked':
362	self.portal_workflow.doActionFor(c,'approve')
363	if no_import_list:
364	no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
365	heading = ','.join(['"%s"' % fn for fn in fields])
366	no_import.write('%s\n' % heading)
367	for line in no_import_list:
368	no_import.write(line)
369	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
370	###)
371
372	security.declareProtected(ModifyPortalContent,"loadCertificateCoursesFromCSV")###(
373	def loadCertificateCoursesFromCSV(self):
374	"""install Certificate Courses from CSV values"""
375	#return
376	logger = logging.getLogger('Academics.AcademicsFolder.loadCertificateCoursesFromCSV')
377	name = 'CertificateCourses'
378	wf = self.portal_workflow
379	no_import_list = []
380	fields = ("code",
381	"review_state",
382	"faculty_code",
383	"department_code",
384	"certificate_code",
385	"level",
386	"semester",
387	"core_or_elective",
388	)
389	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
390	try:
391	cert_courses = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
392	except:
393	logger.error('Error reading %s.csv' % name)
394	return
395	## d_ids = [d.id for d in self.portal_catalog({'meta_type': "Department"})]
396	c_ids = [c.id for c in self.portal_catalog({'meta_type': "Course"})]
397	l = self.portal_catalog({'meta_type': "Certificate"})
398	certs = {}
399	for f in l:
400	ca,ac,fa,depid,co,code = f.relative_path.split('/')
401	## pid = "%(depid)s_%(code)s" % vars()
402	pid = "%(code)s" % vars()
403	certs[pid] = f.getObject()
404	for cert_course in cert_courses:
405	processing = "processing %s" % format
406	logger.info(processing % cert_course)
407	## depid = cert_course.get('department_code')
408	course_code = cert_course.get('code')
409	code = cert_course.get('certificate_code')
410	## pid = "%(depid)s_%(code)s" % vars()
411	pid = "%(code)s" % vars()
412	if not pid in certs.keys():
413	em = 'CertCode %(certificate_code)s for %(code)s not found\n' % cert_course
414	logger.info(em)
415	#no_import_list.append(em)
416	no_import_list.append(format % cert_course + ',"Certificate"\n')
417	continue
418	certificate = certs[pid]
419	certificate_code = certificate.getId()
420	if course_code not in c_ids:
421	em = 'Course %(code)s for %(certificate_code)s Level %(level)s not found in Courses\n' % cert_course
422	logger.info(em)
423	#no_import_list.append(em)
424	no_import_list.append(format % cert_course + ',"Course"\n')
425	continue
426	## if depid not in d_ids:
427	## em = 'Department %(department_code)s for %(certificate_code)s not found\n' % cert_course
428	## logger.info(em)
429	## #no_import_list.append(em)
430	## no_import_list.append(format % cert_course + ',"Department"\n')
431	## continue
432	level = cert_course.get('level')
433	l = getattr(certificate,level,None)
434	if l is None:
435	logger.info('Creating Level %(level)s in certificate %(certificate_code)s' % cert_course)
436	certificate.invokeFactory('StudyLevel', level)
437	l = getattr(certificate, level)
438	l.getContent().edit(mapping={'Title': "Level %s" % level})
439	certificate.orderObjects('id')
440	if hasattr(l,course_code):
441	msg = 'Duplicate %(code)s in Level %(level)s' % cert_course
442	logger.info(msg)
443	#no_import_list.append(msg + "\n")
444	no_import_list.append(format % cert_course + ',"duplicate"\n')
445	continue
446	l.invokeFactory('CertificateCourse',course_code)
447	logger.info('Creating CertificateCourse %(code)s in Certificate %(certificate_code)s StudyLevel %(level)s' % cert_course)
448	cc = getattr(l,course_code)
449	#semester = 'first'
450	#try:
451	# sem = int(cert_course.get('semester'))
452	# cert_course['semester'] = ('first','second')[sem - 1]
453	#except:
454	# pass
455	cert_course['core_or_elective'] = cert_course['core_or_elective'] in ("TRUE","True")
456	cc.getContent().edit(mapping=cert_course)
457	review_state = cc.get('review_state')
458	if review_state == "checked" and wf.getInfoFor(cc,'review_state',None) != 'checked':
459	self.portal_workflow.doActionFor(cc,'approve')
460	if no_import_list:
461	no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
462	heading = ','.join(['"%s"' % fn for fn in fields])
463	no_import.write('%s\n' % heading)
464	for line in no_import_list:
465	no_import.write(line)
466	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
467	###)
468
469
470	security.declareProtected(ModifyPortalContent,"yamlDumpFaculties")###(
471	def yamlDumpFaculties(self):
472	"""dump Faculies to Yaml"""
473	#return
474	import yaml
475	logger = logging.getLogger('dumpfaculties')
476	logger.info('Start dumping Faculties')
477	academics = self.portal_catalog({'meta_type': 'AcademicsFolder'})[-1].getObject()
478	l = self.portal_catalog({'meta_type': "Faculty"})
479	facs = {}
480	for f in l:
481	facs[f.id] = f.getObject()
482	for fid in facs.keys():
483	faculty = facs.get(fid).aq_self
484	logger.info('dumping %s %s ' % (faculty.id, faculty.title))
485	print yaml.dump(faculty)
486	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
487
488	###)
489
490
491	def exportLocalRoles(self,portal_type): ###(
492	name = '%sLocalRoles' % portal_type
493	logger = logging.getLogger('Academics.AcademicsFolder.exportLocalRoles')
494	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
495	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
496	objects = [f.getObject() for f in self.portal_catalog({'meta_type': portal_type})]
497	export = []
498	export.append('"code","users"')
499	#import pdb;pdb.set_trace()
500	for obj in objects:
501	lr = {}
502	for (username, roles) in obj.get_local_roles():
503	lr[ 'user:' + username ] = [x for x in roles]
504	for (groupname, roles) in obj.get_local_group_roles():
505	lr[ 'group:' + group ] = [x for x in roles]
506	logger.info('Exporting %s %s ' % (obj.id, lr))
507	export.append('"%s","%s"' % (obj.getId(),lr))
508	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
509	###)
510
511	security.declareProtected(ModifyPortalContent,"exportFacultiesToCSV")###(
512	def exportFacultiesToCSV(self):
513	"""export Faculies to CSV"""
514	#return
515	if self.REQUEST.get('localroles'):
516	self.exportLocalRoles('Faculty')
517	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
518	name = 'Faculties'
519	no_import = False
520	logger = logging.getLogger('Academics.AcademicsFolder.exportFacultiesToCSV')
521	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
522	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
523	objects = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
524	export = []
525	export.append('"code","review_state","title","title_prefix","college_code","degree_grade","bank_code"')
526	for obj in objects:
527	logger.info('Exporting %s %s ' % (obj.id, obj.title))
528	obj_d = obj.getContent()
529	di = {}
530	di['code'] = obj_d.code
531	di['title'] = obj_d.title
532	di['title_prefix'] = obj_d.title_prefix
533	di['college_code'] = obj_d.college_code
534	di['degree_grade'] = obj_d.degree_grade
535	di['bank_code'] = obj_d.bank_code
536	di['code'] = di['code'] or obj.id
537	di['review_state'] = self.portal_workflow.getInfoFor(obj,'review_state','no_state')
538	export.append('"%(code)s","%(review_state)s","%(title)s","%(title_prefix)s","%(college_code)s","%(degree_grade)s","%(bank_code)s"' % di)
539	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
540	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
541
542	###)
543
544	security.declareProtected(ModifyPortalContent,"exportDepartmentsToCSV")###(
545	def exportDepartmentsToCSV(self):
546	"""export Faculies to CSV"""
547	#return
548	if self.REQUEST.get('localroles'):
549	self.exportLocalRoles('Department')
550	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
551	name = 'Departments'
552	no_import = False
553	logger = logging.getLogger('Academics.AcademicsFolder.exportDepartmentsToCSV')
554	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
555	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
556	faculties = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
557	export = []
558	export.append('"code","review_state","title","title_prefix","faculty_code"')
559	#import pdb;pdb.set_trace()
560	for faculty in faculties:
561	di = {}
562	di['faculty_code'] = faculty.id
563	for department in faculty.objectValues():
564	department_d = department.getContent()
565	try:
566	di['code'] = department.getId()
567	di['title'] = department_d.title
568	di['title_prefix'] = department_d.title_prefix
569	di['review_state'] = self.portal_workflow.getInfoFor(department,'review_state','no_state')
570	export.append('"%(code)s","%(review_state)s","%(title)s","%(title_prefix)s","%(faculty_code)s"' % di)
571	logger.info('Exporting %s %s ' % (department.id, department.title))
572	except:
573	logger.info('could not export %s %s ' % (department.id, department.title))
574	continue
575	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
576	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
577	###)
578
579	security.declareProtected(ModifyPortalContent,"exportCoursesToCSV")###(
580	def exportCoursesToCSV(self):
581	"""export Courses to CSV"""
582	#return
583	name = 'Courses'
584	no_import = False
585	logger = logging.getLogger('Academics.AcademicsFolder.exportCoursesToCSV')
586	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
587	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
588	faculties = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
589	export = []
590	heading = '"code","review_state","title","faculty_code","department_code",'
591	heading += '"credits","org_code","passmark","semester","session"'
592	dataline = '"%(code)s","%(review_state)s","%(title)s","%(faculty_code)s","%(department_code)s",'
593	dataline += '"%(credits)s","%(org_code)s","%(passmark)s","%(semester)s","%(session)s"'
594	export.append(heading)
595	#import pdb;pdb.set_trace()
596	fields = ("title",
597	"credits",
598	"org_code",
599	"passmark",
600	"semester",
601	"session",
602	)
603	for faculty in faculties:
604	di = {}
605	di['faculty_code'] = faculty.id
606	for department in faculty.objectValues():
607	di['department_code'] = department.id
608	for course in department.courses.objectValues():
609	di['code'] = course.getId()
610	course_d = course.getContent()
611	for f in fields:
612	di[f] = getattr(course_d,f,None)
613	di['review_state'] = self.portal_workflow.getInfoFor(course,'review_state','no_state')
614	export.append(dataline % di)
615	logger.info('Exporting %s %s ' % (course.id, course.title))
616	continue
617	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
618	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
619	###)
620
621	security.declareProtected(ModifyPortalContent,"exportCertificatesToCSV")###(
622	def exportCertificatesToCSV(self):
623	"""export Certificates to CSV"""
624	#return
625	name = 'Certificates'
626	no_import = False
627	logger = logging.getLogger('Academics.AcademicsFolder.exportCertificatesToCSV')
628	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
629	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
630	faculties = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
631	export = []
632	heading = '"code","review_state","title","faculty_code","department_code",'
633	heading += '"category","end_level","m_prefix","max_elect","max_pass",'
634	heading += '"n_core","nr_years","original_code","probation_credits",'
635	heading += '"promotion_credits","start_level","admin_status"'
636	dataline = '"%(code)s","%(review_state)s","%(title)s","%(faculty_code)s","%(department_code)s",'
637	dataline += '"%(category)s","%(end_level)s","%(m_prefix)s","%(max_elect)s","%(max_pass)s",'
638	dataline += '"%(n_core)s","%(nr_years)s","%(original_code)s","%(probation_credits)s",'
639	dataline += '"%(promotion_credits)s","%(start_level)s","%(admin_status)s"'
640	export.append(heading)
641	#import pdb;pdb.set_trace()
642	for faculty in faculties:
643	di = {}
644	di['faculty_code'] = faculty.id
645	for department in faculty.objectValues():
646	di['department_code'] = department.id
647	for certificate in department.certificates.objectValues():
648	certificate_d = certificate.getContent()
649	di['code'] = certificate.id
650	#di['code'] = getattr(certificate_d,'code',None)
651	di['title'] = getattr(certificate_d,'title',None)
652	di['category'] = getattr(certificate_d,'category',None)
653	di['admin_status'] = getattr(certificate_d,'admin_status',None)
654	di['end_level'] = getattr(certificate_d,'end_level',None)
655	di['m_prefix'] = getattr(certificate_d,'m_prefix',None)
656	di['max_elect'] = getattr(certificate_d,'max_elect',None)
657	di['max_load'] = getattr(certificate_d,'max_load',None)
658	di['max_pass'] = getattr(certificate_d,'max_pass',None)
659	di['n_core'] = getattr(certificate_d,'n_core',None)
660	di['nr_years'] = getattr(certificate_d,'nr_years',None)
661	di['original_code'] = getattr(certificate_d,'original_code',None)
662	di['probation_credits'] = getattr(certificate_d,'probation_credits',None)
663	di['promotion_credits'] = getattr(certificate_d,'promotion_credits',None)
664	di['start_level'] = getattr(certificate_d,'start_level',None)
665	di['code'] = di['code'] or certificate.id
666	di['review_state'] = self.portal_workflow.getInfoFor(certificate,'review_state','no_state')
667	try:
668	export.append(dataline % di)
669	logger.info('Exporting %s %s ' % (certificate.id, certificate.title))
670	except:
671	logger.info('could not export %s %s ' % (certificate.id, certificate.title))
672	continue
673	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
674	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
675	###)
676
677	security.declareProtected(ModifyPortalContent,"exportCertificateCoursesToCSV")###(
678	def exportCertificateCoursesToCSV(self):
679	"""export CertificateCourses to CSV"""
680	#return
681	name = 'CertificateCourses'
682	no_import = False
683	logger = logging.getLogger('Academics.AcademicsFolder.exportCertificateCoursesToCSV')
684	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
685	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
686	faculties = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
687	export = []
688	heading = '"code","review_state","faculty_code","department_code",'
689	heading += '"certificate_code","level","semester","core_or_elective"'
690	dataline = '"%(code)s","%(review_state)s","%(faculty_code)s","%(department_code)s",'
691	dataline += '"%(certificate_code)s","%(level)s","%(semester)s","%(core_or_elective)s"'
692	export.append(heading)
693	#import pdb;pdb.set_trace()
694	semesters = ['first','second']
695	for faculty in faculties:
696	di = {}
697	di['faculty_code'] = faculty.id
698	for department in faculty.objectValues():
699	di['department_code'] = department.id
700	for certificate in department.certificates.objectValues():
701	di['certificate_code'] = certificate.id
702	for level in certificate.objectValues():
703	di['level'] = level.id
704	for sem in semesters:
705	semester = getattr(level,sem,None)
706	if semester is not None:
707	di['semester'] = semesters.index(sem) + 1
708	for course in semester.objectValues():
709	di['code'] = course.getId()
710	course_d = course.getContent()
711	di['core_or_elective'] = getattr(course_d,'core_or_elective',None)
712	di['review_state'] = self.portal_workflow.getInfoFor(course,'review_state','no_state')
713	try:
714	export.append(dataline % di)
715	logger.info('Exporting %s %s ' % (certificate.id, certificate.title))
716	except:
717	logger.info('Could not export %s %s ' % (certificate.id, certificate.title))
718	continue
719	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
720	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
721	###)
722
723
724	InitializeClass(AcademicsFolder)
725
726	def addAcademicsFolder(container, id, REQUEST=None, **kw):
727	"""Add a AcademicsFolder."""
728	ob = AcademicsFolder(id, **kw)
729	return CPSBase_adder(container, ob, REQUEST=REQUEST)
730
731	###)
732
733	class Certificate(CPSDocument): ###(
734	"""
735	WAeUP Certificate
736	"""
737	meta_type = 'Certificate'
738	portal_type = meta_type
739	security = ClassSecurityInfo()
740
741	def __init__(self, id, **kw):
742	CPSDocument.__init__(self, id, **kw)
743
744	## security.declareProtected(View,"Title")
745	## def Title(self):
746	## """compose title"""
747	## return "Certificate of %s" % (self.title)
748
749	InitializeClass(Certificate)
750
751	def addCertificate(container, id, REQUEST=None, **kw):
752	"""Add a Certificate."""
753	ob = Certificate(id, **kw)
754	return CPSBase_adder(container, ob, REQUEST=REQUEST)
755
756	###)
757
758	class StudyLevel(CPSDocument): ###(
759	"""
760	WAeUP StudyLevel containing the courses and students
761	"""
762	meta_type = 'StudyLevel'
763	portal_type = meta_type
764	security = ClassSecurityInfo()
765
766	security.declareProtected(View,"Title")
767	def Title(self):
768	"""compose title"""
769	try:
770	return "Level %s" % self.aq_parent.getId()
771	except:
772	return "no Title for %s" % self.getId()
773
774
775	InitializeClass(StudyLevel)
776
777	def addStudyLevel(container, id, REQUEST=None, **kw):
778	"""Add a StudyLevel."""
779	ob = StudyLevel(id, **kw)
780	return CPSBase_adder(container, ob, REQUEST=REQUEST)
781
782	###)
783
784	class CertificateCourse(CPSDocument): ###(
785	"""
786	WAeUP CertificateCourse
787	"""
788	meta_type = 'CertificateCourse'
789	portal_type = meta_type
790	security = ClassSecurityInfo()
791
792	def getCourseEntry(self,cid):
793	res = self.portal_catalog({'meta_type': "Course",
794	'id': cid})
795	if res:
796	return res[-1]
797	else:
798	return None
799
800	security.declareProtected(View,"Title")
801	def Title(self):
802	"""compose title"""
803	#import pdb;pdb.set_trace()
804	ce = self.getCourseEntry(self.aq_parent.getId())
805	#print self.id, self.aq_parent.id
806	if ce:
807	return "%s" % ce.Title
808	return "No such course"
809
810	security.declareProtected(View,"credits")
811	def credits(self):
812	"""credits from course"""
813	ce = self.getCourseEntry(self.id)
814	if ce:
815	return "%s" % ce.credits
816	return "0"
817
818	security.declareProtected(View,"passmark")
819	def passmark(self):
820	"""passmark from course"""
821	ce = self.getCourseEntry(self.id)
822	if ce is not None and hasattr(ce,"passmark"):
823	return ce.passmark
824
825
826	security.declareProtected(View,"coursepath")
827	def coursepath(self):
828	"""coursepath from course"""
829	ce = self.getCourseEntry(self.id)
830	if ce:
831	return ce.getPath()
832	return "?"
833
834
835	InitializeClass(CertificateCourse)
836
837	def addCertificateCourse(container, id, REQUEST=None, **kw):
838	"""Add a CertificateCourse."""
839	ob = CertificateCourse(id, **kw)
840	return CPSBase_adder(container, ob, REQUEST=REQUEST)
841	###)
842
843	class Faculty(CPSDocument): ###(
844	"""
845	WAeUP Faculty containing Departments
846	"""
847	meta_type = 'Faculty'
848	portal_type = meta_type
849	security = ClassSecurityInfo()
850
851	## def __init__(self, id, **kw):
852	## CPSDocument.__init__(self, id, **kw)
853
854	security.declareProtected(View,"Title")
855	def Title(self):
856	"""compose title"""
857	return "%s" % (self.title)
858
859
860	security.declareProtected(View,"LongTitle")
861	def LongTitle(self):
862	"""compose long_title"""
863	prefix = getattr(self,'title_prefix',None)
864	if prefix is None:
865	prefix = getattr(self,'institution_type','faculty')
866	self.getContent().edit(mapping = {'title_prefix': prefix})
867	itype = self.portal_vocabularies.institution_types_voc.get(prefix,default="Faculty of")
868	return "%s %s" % (itype,self.title)
869
870	InitializeClass(Faculty)
871
872	def addFaculty(container, id, REQUEST=None, **kw):
873	"""Add a Faculty."""
874	ob = Faculty(id, **kw)
875	return CPSBase_adder(container, ob, REQUEST=REQUEST)
876
877	###)
878
879	class Department(CPSDocument): ###(
880	"""
881	WAeUP Department containing the courses and students
882	"""
883	meta_type = 'Department'
884	portal_type = meta_type
885	security = ClassSecurityInfo()
886
887	security.declareProtected(View,"LongTitle")
888	def LongTitle(self):
889	"""compose long_title"""
890	prefix = getattr(self,'title_prefix',None)
891	if prefix is None:
892	prefix = getattr(self,'institution_type','department')
893	self.getContent().edit(mapping = {'title_prefix': prefix})
894	itype = self.portal_vocabularies.institution_types_voc.get(prefix,default="Department of")
895	return "%s %s" % (itype,self.title)
896
897	InitializeClass(Department)
898
899	def addDepartment(container, id, REQUEST=None, **kw):
900	"""Add a Department."""
901	object = Department(id, **kw)
902	id = object.getId()
903	container._setObject(id, object)
904	## dep = getattr(container,id).getEditableContent() #getContent()
905	## dep.invokeFactory('CoursesFolder','Courses')
906	## o = getattr(dep,'Courses')
907	## dict = {'Title': 'Courses'}
908	## o.getContent().edit(mapping=dict)
909	## dep.invokeFactory('CertificatesFolder','Certificates')
910	## o = getattr(dep,'Certificates')
911	## dict = {'Title': 'Certificates'}
912	## o.geetContent().edit(mapping=dict)
913	if REQUEST is not None:
914	url = container.absolute_url()
915	REQUEST.RESPONSE.redirect('%s/manage_main' % url)
916
917	###)
918
919	class Course(CPSDocument): ###(
920	"""
921	WAeUP Course
922	"""
923	meta_type = 'Course'
924	portal_type = meta_type
925	security = ClassSecurityInfo()
926
927	security.declareProtected(View,"Title")
928	def Title(self):
929	"""compose title"""
930	return self.title
931
932	InitializeClass(Course)
933
934	def addCourse(container, id, REQUEST=None, **kw):
935	"""Add a Course."""
936	ob = Course(id, **kw)
937	return CPSBase_adder(container, ob, REQUEST=REQUEST)
938	###)
939
940

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

Download in other formats: