Context navigation

source: WAeUP_SRP/base/Academics.py @ 2587

Last change on this file since 2587 was 2291, checked in by joachim, 17 years ago
remove debug line
Property svn:keywords set to `Id`
File size: 38.9 KB

Rev	Line
[68]	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
[319]	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
[200]	13	#from Products.CMFCore.DirectoryView import registerDirectory
[68]	14
[200]	15	#registerDirectory('skins', globals())
	16	#registerDirectory('skins/waeup_default', globals())
	17	#registerDirectory('skins/waeup_faculty', globals())
[68]	18
[526]	19	import DateTime
[279]	20	import csv,re
	21	import logging
	22	import Globals
	23	p_home = Globals.package_home(globals())
	24	i_home = Globals.INSTANCE_HOME
	25
[719]	26	def makeCertificateCode(code): ###(
[361]	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
[719]	35	###)
	36
[278]	37	class AcademicsFolder(CPSDocument): ###(
	38	"""
[319]	39	WAeUP AcademicsFolder containing StudyCourses
[278]	40	"""
	41	meta_type = 'AcademicsFolder'
	42	portal_type = meta_type
	43	security = ClassSecurityInfo()
[440]	44	use_catalog_for_folder_contents = True
[278]	45
[364]	46	security.declareProtected(View,"Title")
	47	def Title(self):
	48	"""compose title"""
[382]	49	return "Academic Section"
[256]	50
[592]	51	def importLocalRoles(self,portal_type): ###(
	52	name = '%sLocalRoles' % portal_type
[1571]	53	logger = logging.getLogger('Academics.AcademicsFolder.importLocalRoles')
[592]	54	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
[602]	55	logger.info('Start importing %(name)s to %(name)s_%(current)s.csv' % vars())
[592]	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}):
[602]	67	odict[f.getId] = f.getObject()
[592]	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])
[1571]	76	logger.info('Importing role for %s %s %s' % (obj_id, member_id,roles_dict[r]))
[592]	77
	78	###)
	79
[351]	80	security.declareProtected(ModifyPortalContent,"loadFacultiesFromCSV")###(
[319]	81	def loadFacultiesFromCSV(self):
[278]	82	"""install Universityspecific Faculies from CSV values"""
	83	#return
[592]	84	if self.REQUEST.get('localroles'):
	85	self.importLocalRoles('Faculty')
	86	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[549]	87	name = 'Faculties'
[282]	88	no_import = False
[1571]	89	logger = logging.getLogger('Academics.AcademicsFolder.loadFacultiesFromCSV')
[563]	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	)
[719]	109	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
[563]	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
[592]	131	if self.REQUEST.get('localroles'):
	132	self.importLocalRoles('Department')
	133	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[563]	134	name = 'Departments'
	135	no_import = False
[1571]	136	logger = logging.getLogger('Academics.AcademicsFolder.loadDepartmentsFromCSV')
[563]	137	fields = ("code",
	138	"review_state",
	139	"title",
	140	"title_prefix",
	141	"faculty_code",
	142	)
[719]	143	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
[563]	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")
[719]	150	heading = ','.join(['"%s"' % fn for fn in fields])
[563]	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)
[602]	181
[563]	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
[1146]	189	not_allowed =re.compile('[^A-Z0-9]')
[563]	190	wf = self.portal_workflow
	191	name = 'Courses'
	192	no_import = False
[1571]	193	logger = logging.getLogger('Academics.AcademicsFolder.loadCoursesFromCSV')
[563]	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	)
[719]	205	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
[563]	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
[1146]	211	imported = []
	212	not_imported = []
[719]	213	heading = ','.join(['"%s"' % fn for fn in fields])
[1146]	214	imported.append(heading)
	215	not_imported.append(heading)
	216	#no_import.write('%s\n' % heading)
[2190]	217	#l = self.portal_catalog({'meta_type': "Faculty"})
	218	#facs = {}
	219	#for f in l:
	220	# facs[f.id] = f.getObject()
[563]	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:
[1146]	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
[563]	237	depid = course.get('department_code').upper()
	238	if depid in deps.keys():
	239	dept= deps.get(depid)
	240	else:
[1146]	241	msg = ',"Department not found"'
	242	#logger.info(msg)
	243	#not_imported.append('"%s",' % msg)
	244	not_imported.append(format % course + msg)
[563]	245	continue
[928]	246	if course_id in course_list:
[1146]	247	msg = ',"Multiple Course Code"'
	248	#logger.info(msg)
	249	#not_imported.append('"%s",' % msg)
	250	not_imported.append(format % course + msg)
[928]	251	continue
[1146]	252	level = "%c00" % course_id[-3]
	253	course['level'] = level
[563]	254	cf = dept.courses
	255	c = getattr(cf,course_id,None)
[2190]	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]
[1146]	267	#import pdb;pdb.set_trace()
[563]	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)
[928]	271	course_list.append(course_id)
[1146]	272	imported.append(format % course)
[563]	273	c = getattr(cf,course_id)
[2190]	274	#self.courses_catalog.addRecord(**cd)
	275	#else:
	276	# self.courses_catalog.modifyRecord(**cd)
[563]	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')
[1146]	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))
[563]	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 = []
[1571]	298	logger = logging.getLogger('Academics.AcademicsFolder.loadCertificatesFromCSV')
[563]	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	)
[719]	317	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
[563]	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")
[719]	365	heading = ','.join(['"%s"' % fn for fn in fields])
[563]	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
[1571]	376	logger = logging.getLogger('Academics.AcademicsFolder.loadCertificateCoursesFromCSV')
[563]	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	)
[719]	389	format = ','.join(['"%%(%s)s"' % fn for fn in fields])
[563]	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
[929]	395	## d_ids = [d.id for d in self.portal_catalog({'meta_type': "Department"})]
[563]	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:
[720]	400	ca,ac,fa,depid,co,code = f.relative_path.split('/')
[929]	401	## pid = "%(depid)s_%(code)s" % vars()
	402	pid = "%(code)s" % vars()
[720]	403	certs[pid] = f.getObject()
[563]	404	for cert_course in cert_courses:
	405	processing = "processing %s" % format
	406	logger.info(processing % cert_course)
[929]	407	## depid = cert_course.get('department_code')
[563]	408	course_code = cert_course.get('code')
	409	code = cert_course.get('certificate_code')
[929]	410	## pid = "%(depid)s_%(code)s" % vars()
[937]	411	pid = "%(code)s" % vars()
[720]	412	if not pid in certs.keys():
[563]	413	em = 'CertCode %(certificate_code)s for %(code)s not found\n' % cert_course
	414	logger.info(em)
[718]	415	#no_import_list.append(em)
[719]	416	no_import_list.append(format % cert_course + ',"Certificate"\n')
[563]	417	continue
[720]	418	certificate = certs[pid]
[563]	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)
[718]	423	#no_import_list.append(em)
[719]	424	no_import_list.append(format % cert_course + ',"Course"\n')
[563]	425	continue
[929]	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
[563]	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)
[718]	443	#no_import_list.append(msg + "\n")
[719]	444	no_import_list.append(format % cert_course + ',"duplicate"\n')
[563]	445	continue
	446	l.invokeFactory('CertificateCourse',course_code)
[1571]	447	logger.info('Creating CertificateCourse %(code)s in Certificate %(certificate_code)s StudyLevel %(level)s' % cert_course)
[563]	448	cc = getattr(l,course_code)
[2190]	449	#semester = 'first'
	450	#try:
	451	# sem = int(cert_course.get('semester'))
	452	# cert_course['semester'] = ('first','second')[sem - 1]
	453	#except:
	454	# pass
[691]	455	cert_course['core_or_elective'] = cert_course['core_or_elective'] in ("TRUE","True")
[563]	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")
[719]	462	heading = ','.join(['"%s"' % fn for fn in fields])
[563]	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
[278]	469
	470	security.declareProtected(ModifyPortalContent,"yamlDumpFaculties")###(
[319]	471	def yamlDumpFaculties(self):
[278]	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)
[526]	486	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[319]	487
[278]	488	###)
	489
[319]	490
[592]	491	def exportLocalRoles(self,portal_type): ###(
[593]	492	name = '%sLocalRoles' % portal_type
[1571]	493	logger = logging.getLogger('Academics.AcademicsFolder.exportLocalRoles')
[592]	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())
[595]	496	objects = [f.getObject() for f in self.portal_catalog({'meta_type': portal_type})]
[592]	497	export = []
	498	export.append('"code","users"')
[593]	499	#import pdb;pdb.set_trace()
[592]	500	for obj in objects:
[602]	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]
[1571]	506	logger.info('Exporting %s %s ' % (obj.id, lr))
[592]	507	export.append('"%s","%s"' % (obj.getId(),lr))
[2081]	508	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[592]	509	###)
[602]	510
[526]	511	security.declareProtected(ModifyPortalContent,"exportFacultiesToCSV")###(
	512	def exportFacultiesToCSV(self):
	513	"""export Faculies to CSV"""
	514	#return
[592]	515	if self.REQUEST.get('localroles'):
	516	self.exportLocalRoles('Faculty')
	517	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[549]	518	name = 'Faculties'
[526]	519	no_import = False
[1571]	520	logger = logging.getLogger('Academics.AcademicsFolder.exportFacultiesToCSV')
[526]	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())
[557]	523	objects = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
[526]	524	export = []
	525	export.append('"code","review_state","title","title_prefix","college_code","degree_grade","bank_code"')
	526	for obj in objects:
[1571]	527	logger.info('Exporting %s %s ' % (obj.id, obj.title))
[526]	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)
[2081]	539	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	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
[592]	548	if self.REQUEST.get('localroles'):
	549	self.exportLocalRoles('Department')
	550	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
[549]	551	name = 'Departments'
[526]	552	no_import = False
[1571]	553	logger = logging.getLogger('Academics.AcademicsFolder.exportDepartmentsToCSV')
[526]	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:
[576]	566	di['code'] = department.getId()
[526]	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')
[527]	570	export.append('"%(code)s","%(review_state)s","%(title)s","%(title_prefix)s","%(faculty_code)s"' % di)
[1571]	571	logger.info('Exporting %s %s ' % (department.id, department.title))
[526]	572	except:
	573	logger.info('could not export %s %s ' % (department.id, department.title))
	574	continue
[2081]	575	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	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
[549]	583	name = 'Courses'
[526]	584	no_import = False
[1571]	585	logger = logging.getLogger('Academics.AcademicsFolder.exportCoursesToCSV')
[526]	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()
[576]	596	fields = ("title",
[567]	597	"credits",
	598	"org_code",
	599	"passmark",
	600	"semester",
	601	"session",
	602	)
[526]	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
[527]	608	for course in department.courses.objectValues():
[576]	609	di['code'] = course.getId()
[526]	610	course_d = course.getContent()
[567]	611	for f in fields:
	612	di[f] = getattr(course_d,f,None)
[569]	613	di['review_state'] = self.portal_workflow.getInfoFor(course,'review_state','no_state')
[567]	614	export.append(dataline % di)
[1571]	615	logger.info('Exporting %s %s ' % (course.id, course.title))
[526]	616	continue
[2081]	617	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	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
[549]	625	name = 'Certificates'
[526]	626	no_import = False
[1571]	627	logger = logging.getLogger('Academics.AcademicsFolder.exportCertificatesToCSV')
[526]	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"'
[527]	636	dataline = '"%(code)s","%(review_state)s","%(title)s","%(faculty_code)s","%(department_code)s",'
[526]	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
[527]	647	for certificate in department.certificates.objectValues():
[526]	648	certificate_d = certificate.getContent()
[576]	649	di['code'] = certificate.id
	650	#di['code'] = getattr(certificate_d,'code',None)
[529]	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)
[526]	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)
[1571]	669	logger.info('Exporting %s %s ' % (certificate.id, certificate.title))
[526]	670	except:
	671	logger.info('could not export %s %s ' % (certificate.id, certificate.title))
	672	continue
[2081]	673	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	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
[549]	681	name = 'CertificateCourses'
[526]	682	no_import = False
[1571]	683	logger = logging.getLogger('Academics.AcademicsFolder.exportCertificateCoursesToCSV')
[526]	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",'
[2282]	689	heading += '"certificate_code","level","core_or_elective"'
[526]	690	dataline = '"%(code)s","%(review_state)s","%(faculty_code)s","%(department_code)s",'
[2282]	691	dataline += '"%(certificate_code)s","%(level)s","%(core_or_elective)s"'
[526]	692	export.append(heading)
	693	semesters = ['first','second']
	694	for faculty in faculties:
	695	di = {}
	696	di['faculty_code'] = faculty.id
	697	for department in faculty.objectValues():
	698	di['department_code'] = department.id
[527]	699	for certificate in department.certificates.objectValues():
[526]	700	di['certificate_code'] = certificate.id
	701	for level in certificate.objectValues():
	702	di['level'] = level.id
[2282]	703	for course in level.objectValues():
	704	di['code'] = course.getId()
	705	course_d = course.getContent()
	706	di['core_or_elective'] = getattr(course_d,'core_or_elective',None)
	707	di['review_state'] = self.portal_workflow.getInfoFor(course,'review_state','no_state')
	708	try:
	709	export.append(dataline % di)
	710	logger.info('Exporting %s %s ' % (certificate.id, certificate.title))
	711	except:
	712	logger.info('Could not export %s %s ' % (certificate.id, certificate.title))
	713	continue
[2081]	714	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	715	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	716	###)
	717
	718
[278]	719	InitializeClass(AcademicsFolder)
	720
	721	def addAcademicsFolder(container, id, REQUEST=None, **kw):
	722	"""Add a AcademicsFolder."""
	723	ob = AcademicsFolder(id, **kw)
	724	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	725
	726	###)
	727
[256]	728	class Certificate(CPSDocument): ###(
[238]	729	"""
[319]	730	WAeUP Certificate
[238]	731	"""
[256]	732	meta_type = 'Certificate'
[238]	733	portal_type = meta_type
	734	security = ClassSecurityInfo()
[319]	735
[238]	736	def __init__(self, id, **kw):
	737	CPSDocument.__init__(self, id, **kw)
	738
[256]	739	## security.declareProtected(View,"Title")
	740	## def Title(self):
	741	## """compose title"""
	742	## return "Certificate of %s" % (self.title)
[238]	743
[256]	744	InitializeClass(Certificate)
[238]	745
[256]	746	def addCertificate(container, id, REQUEST=None, **kw):
	747	"""Add a Certificate."""
	748	ob = Certificate(id, **kw)
[238]	749	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	750
	751	###)
	752
[454]	753	class StudyLevel(CPSDocument): ###(
	754	"""
	755	WAeUP StudyLevel containing the courses and students
	756	"""
	757	meta_type = 'StudyLevel'
	758	portal_type = meta_type
	759	security = ClassSecurityInfo()
	760
	761	security.declareProtected(View,"Title")
	762	def Title(self):
	763	"""compose title"""
[458]	764	try:
	765	return "Level %s" % self.aq_parent.getId()
	766	except:
	767	return "no Title for %s" % self.getId()
[454]	768
[527]	769
[454]	770	InitializeClass(StudyLevel)
	771
	772	def addStudyLevel(container, id, REQUEST=None, **kw):
	773	"""Add a StudyLevel."""
	774	ob = StudyLevel(id, **kw)
	775	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	776
	777	###)
	778
[256]	779	class CertificateCourse(CPSDocument): ###(
[238]	780	"""
[319]	781	WAeUP CertificateCourse
[238]	782	"""
[256]	783	meta_type = 'CertificateCourse'
[238]	784	portal_type = meta_type
	785	security = ClassSecurityInfo()
[319]	786
[279]	787	def getCourseEntry(self,cid):
	788	res = self.portal_catalog({'meta_type': "Course",
	789	'id': cid})
	790	if res:
[319]	791	return res[-1]
[279]	792	else:
	793	return None
[319]	794
[256]	795	security.declareProtected(View,"Title")
	796	def Title(self):
	797	"""compose title"""
[583]	798	#import pdb;pdb.set_trace()
	799	ce = self.getCourseEntry(self.aq_parent.getId())
[454]	800	#print self.id, self.aq_parent.id
[279]	801	if ce:
	802	return "%s" % ce.Title
	803	return "No such course"
[238]	804
[279]	805	security.declareProtected(View,"credits")
	806	def credits(self):
	807	"""credits from course"""
	808	ce = self.getCourseEntry(self.id)
	809	if ce:
	810	return "%s" % ce.credits
[280]	811	return "0"
[319]	812
[279]	813	security.declareProtected(View,"passmark")
	814	def passmark(self):
	815	"""passmark from course"""
	816	ce = self.getCourseEntry(self.id)
[296]	817	if ce is not None and hasattr(ce,"passmark"):
	818	return ce.passmark
[319]	819
	820
[280]	821	security.declareProtected(View,"coursepath")
	822	def coursepath(self):
	823	"""coursepath from course"""
	824	ce = self.getCourseEntry(self.id)
	825	if ce:
	826	return ce.getPath()
	827	return "?"
[279]	828
[319]	829
[256]	830	InitializeClass(CertificateCourse)
[238]	831
[256]	832	def addCertificateCourse(container, id, REQUEST=None, **kw):
	833	"""Add a CertificateCourse."""
	834	ob = CertificateCourse(id, **kw)
[238]	835	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	836	###)
	837
[68]	838	class Faculty(CPSDocument): ###(
	839	"""
[319]	840	WAeUP Faculty containing Departments
[68]	841	"""
	842	meta_type = 'Faculty'
	843	portal_type = meta_type
	844	security = ClassSecurityInfo()
[319]	845
[238]	846	## def __init__(self, id, **kw):
	847	## CPSDocument.__init__(self, id, **kw)
[173]	848
[200]	849	security.declareProtected(View,"Title")
	850	def Title(self):
	851	"""compose title"""
[238]	852	return "%s" % (self.title)
[319]	853
[389]	854
[296]	855	security.declareProtected(View,"LongTitle")
	856	def LongTitle(self):
	857	"""compose long_title"""
[389]	858	prefix = getattr(self,'title_prefix',None)
	859	if prefix is None:
	860	prefix = getattr(self,'institution_type','faculty')
	861	self.getContent().edit(mapping = {'title_prefix': prefix})
	862	itype = self.portal_vocabularies.institution_types_voc.get(prefix,default="Faculty of")
[296]	863	return "%s %s" % (itype,self.title)
[200]	864
[68]	865	InitializeClass(Faculty)
	866
	867	def addFaculty(container, id, REQUEST=None, **kw):
	868	"""Add a Faculty."""
	869	ob = Faculty(id, **kw)
	870	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	871
	872	###)
	873
	874	class Department(CPSDocument): ###(
	875	"""
	876	WAeUP Department containing the courses and students
	877	"""
	878	meta_type = 'Department'
	879	portal_type = meta_type
	880	security = ClassSecurityInfo()
[173]	881
[296]	882	security.declareProtected(View,"LongTitle")
	883	def LongTitle(self):
	884	"""compose long_title"""
[389]	885	prefix = getattr(self,'title_prefix',None)
	886	if prefix is None:
	887	prefix = getattr(self,'institution_type','department')
	888	self.getContent().edit(mapping = {'title_prefix': prefix})
	889	itype = self.portal_vocabularies.institution_types_voc.get(prefix,default="Department of")
[296]	890	return "%s %s" % (itype,self.title)
	891
[68]	892	InitializeClass(Department)
	893
	894	def addDepartment(container, id, REQUEST=None, **kw):
	895	"""Add a Department."""
[296]	896	object = Department(id, **kw)
[295]	897	id = object.getId()
[319]	898	container._setObject(id, object)
[309]	899	## dep = getattr(container,id).getEditableContent() #getContent()
	900	## dep.invokeFactory('CoursesFolder','Courses')
	901	## o = getattr(dep,'Courses')
	902	## dict = {'Title': 'Courses'}
	903	## o.getContent().edit(mapping=dict)
	904	## dep.invokeFactory('CertificatesFolder','Certificates')
	905	## o = getattr(dep,'Certificates')
	906	## dict = {'Title': 'Certificates'}
	907	## o.geetContent().edit(mapping=dict)
[295]	908	if REQUEST is not None:
	909	url = container.absolute_url()
	910	REQUEST.RESPONSE.redirect('%s/manage_main' % url)
[309]	911
[68]	912	###)
	913
	914	class Course(CPSDocument): ###(
	915	"""
[319]	916	WAeUP Course
[68]	917	"""
	918	meta_type = 'Course'
	919	portal_type = meta_type
	920	security = ClassSecurityInfo()
[152]	921
	922	security.declareProtected(View,"Title")
	923	def Title(self):
	924	"""compose title"""
[238]	925	return self.title
[319]	926
[68]	927	InitializeClass(Course)
	928
	929	def addCourse(container, id, REQUEST=None, **kw):
	930	"""Add a Course."""
	931	ob = Course(id, **kw)
	932	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	933	###)
[139]	934
[319]	935

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

Download in other formats: