Context navigation

Academics.py @ 6695

Last change on this file since 6695 was 3983, checked in by Henrik Bettermann, 16 years ago
exportCertificateCoursesToCSV: don't log all
Property svn:keywords set to `Id`
File size: 39.2 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",'
[3379]	633	heading += '"category","study_mode","end_level","m_prefix","max_elect","max_pass",'
[526]	634	heading += '"n_core","nr_years","original_code","probation_credits",'
[3438]	635	heading += '"promotion_credits","start_level","admin_status","application_category"'
[527]	636	dataline = '"%(code)s","%(review_state)s","%(title)s","%(faculty_code)s","%(department_code)s",'
[3379]	637	dataline += '"%(category)s","%(study_mode)s","%(end_level)s","%(m_prefix)s","%(max_elect)s","%(max_pass)s",'
[526]	638	dataline += '"%(n_core)s","%(nr_years)s","%(original_code)s","%(probation_credits)s",'
[3438]	639	dataline += '"%(promotion_credits)s","%(start_level)s","%(admin_status)s","%(application_category)s"'
[526]	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)
[3378]	652	di['study_mode'] = getattr(certificate_d,'study_mode',None)
[529]	653	di['category'] = getattr(certificate_d,'category',None)
	654	di['admin_status'] = getattr(certificate_d,'admin_status',None)
	655	di['end_level'] = getattr(certificate_d,'end_level',None)
	656	di['m_prefix'] = getattr(certificate_d,'m_prefix',None)
	657	di['max_elect'] = getattr(certificate_d,'max_elect',None)
	658	di['max_load'] = getattr(certificate_d,'max_load',None)
	659	di['max_pass'] = getattr(certificate_d,'max_pass',None)
	660	di['n_core'] = getattr(certificate_d,'n_core',None)
	661	di['nr_years'] = getattr(certificate_d,'nr_years',None)
	662	di['original_code'] = getattr(certificate_d,'original_code',None)
	663	di['probation_credits'] = getattr(certificate_d,'probation_credits',None)
	664	di['promotion_credits'] = getattr(certificate_d,'promotion_credits',None)
	665	di['start_level'] = getattr(certificate_d,'start_level',None)
[3438]	666	di['application_category'] = getattr(certificate_d,'application_category',None)
[526]	667	di['code'] = di['code'] or certificate.id
	668	di['review_state'] = self.portal_workflow.getInfoFor(certificate,'review_state','no_state')
	669	try:
	670	export.append(dataline % di)
[1571]	671	logger.info('Exporting %s %s ' % (certificate.id, certificate.title))
[526]	672	except:
	673	logger.info('could not export %s %s ' % (certificate.id, certificate.title))
	674	continue
[2081]	675	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	676	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	677	###)
	678
	679	security.declareProtected(ModifyPortalContent,"exportCertificateCoursesToCSV")###(
	680	def exportCertificateCoursesToCSV(self):
	681	"""export CertificateCourses to CSV"""
	682	#return
[549]	683	name = 'CertificateCourses'
[526]	684	no_import = False
[1571]	685	logger = logging.getLogger('Academics.AcademicsFolder.exportCertificateCoursesToCSV')
[526]	686	current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
	687	logger.info('Start exporting %(name)s to %(name)s_%(current)s.csv' % vars())
	688	faculties = [f.getObject() for f in self.portal_catalog({'meta_type': 'Faculty'})]
	689	export = []
	690	heading = '"code","review_state","faculty_code","department_code",'
[2282]	691	heading += '"certificate_code","level","core_or_elective"'
[526]	692	dataline = '"%(code)s","%(review_state)s","%(faculty_code)s","%(department_code)s",'
[2282]	693	dataline += '"%(certificate_code)s","%(level)s","%(core_or_elective)s"'
[526]	694	export.append(heading)
	695	semesters = ['first','second']
	696	for faculty in faculties:
	697	di = {}
	698	di['faculty_code'] = faculty.id
	699	for department in faculty.objectValues():
	700	di['department_code'] = department.id
[527]	701	for certificate in department.certificates.objectValues():
[526]	702	di['certificate_code'] = certificate.id
[3983]	703	logger.info('Exporting %s/%s/%s' % (faculty.id,department.id,certificate.id))
[526]	704	for level in certificate.objectValues():
	705	di['level'] = level.id
[2282]	706	for course in level.objectValues():
	707	di['code'] = course.getId()
	708	course_d = course.getContent()
	709	di['core_or_elective'] = getattr(course_d,'core_or_elective',None)
	710	di['review_state'] = self.portal_workflow.getInfoFor(course,'review_state','no_state')
	711	try:
	712	export.append(dataline % di)
	713	except:
[3983]	714	logger.info('Could not export %s %s' % (certificate.id, di['code']))
[2282]	715	continue
[2081]	716	open("%s/export/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
[526]	717	return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
	718	###)
	719
	720
[278]	721	InitializeClass(AcademicsFolder)
	722
	723	def addAcademicsFolder(container, id, REQUEST=None, **kw):
	724	"""Add a AcademicsFolder."""
	725	ob = AcademicsFolder(id, **kw)
	726	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	727
	728	###)
	729
[256]	730	class Certificate(CPSDocument): ###(
[238]	731	"""
[319]	732	WAeUP Certificate
[238]	733	"""
[256]	734	meta_type = 'Certificate'
[238]	735	portal_type = meta_type
	736	security = ClassSecurityInfo()
[319]	737
[238]	738	def __init__(self, id, **kw):
	739	CPSDocument.__init__(self, id, **kw)
	740
[256]	741	## security.declareProtected(View,"Title")
	742	## def Title(self):
	743	## """compose title"""
	744	## return "Certificate of %s" % (self.title)
[238]	745
[256]	746	InitializeClass(Certificate)
[238]	747
[256]	748	def addCertificate(container, id, REQUEST=None, **kw):
	749	"""Add a Certificate."""
	750	ob = Certificate(id, **kw)
[238]	751	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	752
	753	###)
	754
[454]	755	class StudyLevel(CPSDocument): ###(
	756	"""
	757	WAeUP StudyLevel containing the courses and students
	758	"""
	759	meta_type = 'StudyLevel'
	760	portal_type = meta_type
	761	security = ClassSecurityInfo()
	762
	763	security.declareProtected(View,"Title")
	764	def Title(self):
	765	"""compose title"""
[2609]	766	return self.portal_vocabularies.levels.get(self.aq_parent.getId())
	767	# try:
	768	# #return "Level %s" % self.aq_parent.getId()
	769	# except:
	770	# return "no Title for %s" % self.getId()
[454]	771
[527]	772
[454]	773	InitializeClass(StudyLevel)
	774
	775	def addStudyLevel(container, id, REQUEST=None, **kw):
	776	"""Add a StudyLevel."""
	777	ob = StudyLevel(id, **kw)
	778	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	779
	780	###)
	781
[256]	782	class CertificateCourse(CPSDocument): ###(
[238]	783	"""
[319]	784	WAeUP CertificateCourse
[238]	785	"""
[256]	786	meta_type = 'CertificateCourse'
[238]	787	portal_type = meta_type
	788	security = ClassSecurityInfo()
[319]	789
[279]	790	def getCourseEntry(self,cid):
[3477]	791	res = self.courses_catalog({'code': cid})
[279]	792	if res:
[319]	793	return res[-1]
[279]	794	else:
	795	return None
[319]	796
[256]	797	security.declareProtected(View,"Title")
	798	def Title(self):
	799	"""compose title"""
[583]	800	#import pdb;pdb.set_trace()
	801	ce = self.getCourseEntry(self.aq_parent.getId())
[454]	802	#print self.id, self.aq_parent.id
[279]	803	if ce:
[3477]	804	return "%s" % ce.title
[279]	805	return "No such course"
[238]	806
[279]	807	security.declareProtected(View,"credits")
	808	def credits(self):
	809	"""credits from course"""
	810	ce = self.getCourseEntry(self.id)
	811	if ce:
	812	return "%s" % ce.credits
[280]	813	return "0"
[319]	814
[279]	815	security.declareProtected(View,"passmark")
	816	def passmark(self):
	817	"""passmark from course"""
	818	ce = self.getCourseEntry(self.id)
[296]	819	if ce is not None and hasattr(ce,"passmark"):
	820	return ce.passmark
[319]	821
	822
[280]	823	security.declareProtected(View,"coursepath")
	824	def coursepath(self):
	825	"""coursepath from course"""
	826	ce = self.getCourseEntry(self.id)
	827	if ce:
	828	return ce.getPath()
	829	return "?"
[279]	830
[319]	831
[256]	832	InitializeClass(CertificateCourse)
[238]	833
[256]	834	def addCertificateCourse(container, id, REQUEST=None, **kw):
	835	"""Add a CertificateCourse."""
	836	ob = CertificateCourse(id, **kw)
[238]	837	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	838	###)
	839
[68]	840	class Faculty(CPSDocument): ###(
	841	"""
[319]	842	WAeUP Faculty containing Departments
[68]	843	"""
	844	meta_type = 'Faculty'
	845	portal_type = meta_type
	846	security = ClassSecurityInfo()
[319]	847
[238]	848	## def __init__(self, id, **kw):
	849	## CPSDocument.__init__(self, id, **kw)
[173]	850
[200]	851	security.declareProtected(View,"Title")
	852	def Title(self):
	853	"""compose title"""
[238]	854	return "%s" % (self.title)
[319]	855
[389]	856
[296]	857	security.declareProtected(View,"LongTitle")
	858	def LongTitle(self):
	859	"""compose long_title"""
[389]	860	prefix = getattr(self,'title_prefix',None)
	861	if prefix is None:
	862	prefix = getattr(self,'institution_type','faculty')
	863	self.getContent().edit(mapping = {'title_prefix': prefix})
	864	itype = self.portal_vocabularies.institution_types_voc.get(prefix,default="Faculty of")
[296]	865	return "%s %s" % (itype,self.title)
[200]	866
[68]	867	InitializeClass(Faculty)
	868
	869	def addFaculty(container, id, REQUEST=None, **kw):
	870	"""Add a Faculty."""
	871	ob = Faculty(id, **kw)
	872	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	873
	874	###)
	875
	876	class Department(CPSDocument): ###(
	877	"""
	878	WAeUP Department containing the courses and students
	879	"""
	880	meta_type = 'Department'
	881	portal_type = meta_type
	882	security = ClassSecurityInfo()
[173]	883
[296]	884	security.declareProtected(View,"LongTitle")
	885	def LongTitle(self):
	886	"""compose long_title"""
[389]	887	prefix = getattr(self,'title_prefix',None)
	888	if prefix is None:
	889	prefix = getattr(self,'institution_type','department')
	890	self.getContent().edit(mapping = {'title_prefix': prefix})
	891	itype = self.portal_vocabularies.institution_types_voc.get(prefix,default="Department of")
[296]	892	return "%s %s" % (itype,self.title)
	893
[68]	894	InitializeClass(Department)
	895
	896	def addDepartment(container, id, REQUEST=None, **kw):
	897	"""Add a Department."""
[296]	898	object = Department(id, **kw)
[295]	899	id = object.getId()
[319]	900	container._setObject(id, object)
[309]	901	## dep = getattr(container,id).getEditableContent() #getContent()
	902	## dep.invokeFactory('CoursesFolder','Courses')
	903	## o = getattr(dep,'Courses')
	904	## dict = {'Title': 'Courses'}
	905	## o.getContent().edit(mapping=dict)
	906	## dep.invokeFactory('CertificatesFolder','Certificates')
	907	## o = getattr(dep,'Certificates')
	908	## dict = {'Title': 'Certificates'}
	909	## o.geetContent().edit(mapping=dict)
[295]	910	if REQUEST is not None:
	911	url = container.absolute_url()
	912	REQUEST.RESPONSE.redirect('%s/manage_main' % url)
[309]	913
[68]	914	###)
	915
	916	class Course(CPSDocument): ###(
	917	"""
[319]	918	WAeUP Course
[68]	919	"""
	920	meta_type = 'Course'
	921	portal_type = meta_type
	922	security = ClassSecurityInfo()
[152]	923
	924	security.declareProtected(View,"Title")
	925	def Title(self):
	926	"""compose title"""
[238]	927	return self.title
[319]	928
[68]	929	InitializeClass(Course)
	930
	931	def addCourse(container, id, REQUEST=None, **kw):
	932	"""Add a Course."""
	933	ob = Course(id, **kw)
	934	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	935	###)
[139]	936
[319]	937

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

Context navigation

source: WAeUP_SRP/trunk/Academics.py @ 6695

Download in other formats: