Context navigation

Academics.py @ 17947

Last change on this file since 17947 was 1593, checked in by uli, 18 years ago
Merged current trunk into uli-branch.
Property svn:keywords set to `Id`
File size: 39.3 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
[1593]	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])
[1593]	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
[1593]	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
[1593]	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
[1593]	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)
[563]	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:
[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)
[1146]	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()
[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)
[1146]	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 = []
[1593]	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
[1593]	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)
[1593]	447	logger.info('Creating CertificateCourse %(code)s in Certificate %(certificate_code)s StudyLevel %(level)s' % cert_course)
[563]	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
[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
[1593]	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]
[1593]	506	logger.info('Exporting %s %s ' % (obj.id, lr))
[592]	507	export.append('"%s","%s"' % (obj.getId(),lr))
	508	open("%s/import/%s-%s.csv" % (i_home,name,current),"w+").write('\n'.join(export))
	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
[1593]	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:
[1593]	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)
	539	open("%s/import/%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
[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
[1593]	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)
[1593]	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
	575	open("%s/import/%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
[549]	583	name = 'Courses'
[526]	584	no_import = False
[1593]	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)
[1593]	615	logger.info('Exporting %s %s ' % (course.id, course.title))
[526]	616	continue
	617	open("%s/import/%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
[549]	625	name = 'Certificates'
[526]	626	no_import = False
[1593]	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)
[1593]	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
	673	open("%s/import/%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
[549]	681	name = 'CertificateCourses'
[526]	682	no_import = False
[1593]	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",'
	689	heading += '"certificate_code","level","semester","core_or_elective"'
	690	dataline = '"%(code)s","%(review_state)s","%(faculty_code)s","%(department_code)s",'
[527]	691	dataline += '"%(certificate_code)s","%(level)s","%(semester)s","%(core_or_elective)s"'
[526]	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
[527]	700	for certificate in department.certificates.objectValues():
[526]	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:
[527]	707	di['semester'] = semesters.index(sem) + 1
[526]	708	for course in semester.objectValues():
[576]	709	di['code'] = course.getId()
[526]	710	course_d = course.getContent()
[529]	711	di['core_or_elective'] = getattr(course_d,'core_or_elective',None)
[526]	712	di['review_state'] = self.portal_workflow.getInfoFor(course,'review_state','no_state')
	713	try:
	714	export.append(dataline % di)
[1593]	715	logger.info('Exporting %s %s ' % (certificate.id, certificate.title))
[526]	716	except:
[1593]	717	logger.info('Could not export %s %s ' % (certificate.id, certificate.title))
[526]	718	continue
	719	open("%s/import/%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
[278]	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
[256]	733	class Certificate(CPSDocument): ###(
[238]	734	"""
[319]	735	WAeUP Certificate
[238]	736	"""
[256]	737	meta_type = 'Certificate'
[238]	738	portal_type = meta_type
	739	security = ClassSecurityInfo()
[319]	740
[238]	741	def __init__(self, id, **kw):
	742	CPSDocument.__init__(self, id, **kw)
	743
[256]	744	## security.declareProtected(View,"Title")
	745	## def Title(self):
	746	## """compose title"""
	747	## return "Certificate of %s" % (self.title)
[238]	748
[256]	749	InitializeClass(Certificate)
[238]	750
[256]	751	def addCertificate(container, id, REQUEST=None, **kw):
	752	"""Add a Certificate."""
	753	ob = Certificate(id, **kw)
[238]	754	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	755
	756	###)
	757
[454]	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"""
[458]	769	try:
	770	return "Level %s" % self.aq_parent.getId()
	771	except:
	772	return "no Title for %s" % self.getId()
[454]	773
[527]	774
[454]	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
[256]	784	class CertificateCourse(CPSDocument): ###(
[238]	785	"""
[319]	786	WAeUP CertificateCourse
[238]	787	"""
[256]	788	meta_type = 'CertificateCourse'
[238]	789	portal_type = meta_type
	790	security = ClassSecurityInfo()
[319]	791
[279]	792	def getCourseEntry(self,cid):
	793	res = self.portal_catalog({'meta_type': "Course",
	794	'id': cid})
	795	if res:
[319]	796	return res[-1]
[279]	797	else:
	798	return None
[319]	799
[256]	800	security.declareProtected(View,"Title")
	801	def Title(self):
	802	"""compose title"""
[583]	803	#import pdb;pdb.set_trace()
	804	ce = self.getCourseEntry(self.aq_parent.getId())
[454]	805	#print self.id, self.aq_parent.id
[279]	806	if ce:
	807	return "%s" % ce.Title
	808	return "No such course"
[238]	809
[279]	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
[280]	816	return "0"
[319]	817
[279]	818	security.declareProtected(View,"passmark")
	819	def passmark(self):
	820	"""passmark from course"""
	821	ce = self.getCourseEntry(self.id)
[296]	822	if ce is not None and hasattr(ce,"passmark"):
	823	return ce.passmark
[319]	824
	825
[280]	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 "?"
[279]	833
[319]	834
[256]	835	InitializeClass(CertificateCourse)
[238]	836
[256]	837	def addCertificateCourse(container, id, REQUEST=None, **kw):
	838	"""Add a CertificateCourse."""
	839	ob = CertificateCourse(id, **kw)
[238]	840	return CPSBase_adder(container, ob, REQUEST=REQUEST)
	841	###)
	842
[68]	843	class Faculty(CPSDocument): ###(
	844	"""
[319]	845	WAeUP Faculty containing Departments
[68]	846	"""
	847	meta_type = 'Faculty'
	848	portal_type = meta_type
	849	security = ClassSecurityInfo()
[319]	850
[238]	851	## def __init__(self, id, **kw):
	852	## CPSDocument.__init__(self, id, **kw)
[173]	853
[200]	854	security.declareProtected(View,"Title")
	855	def Title(self):
	856	"""compose title"""
[238]	857	return "%s" % (self.title)
[319]	858
[389]	859
[296]	860	security.declareProtected(View,"LongTitle")
	861	def LongTitle(self):
	862	"""compose long_title"""
[389]	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")
[296]	868	return "%s %s" % (itype,self.title)
[200]	869
[68]	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()
[173]	886
[296]	887	security.declareProtected(View,"LongTitle")
	888	def LongTitle(self):
	889	"""compose long_title"""
[389]	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")
[296]	895	return "%s %s" % (itype,self.title)
	896
[68]	897	InitializeClass(Department)
	898
	899	def addDepartment(container, id, REQUEST=None, **kw):
	900	"""Add a Department."""
[296]	901	object = Department(id, **kw)
[295]	902	id = object.getId()
[319]	903	container._setObject(id, object)
[309]	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)
[295]	913	if REQUEST is not None:
	914	url = container.absolute_url()
	915	REQUEST.RESPONSE.redirect('%s/manage_main' % url)
[309]	916
[68]	917	###)
	918
	919	class Course(CPSDocument): ###(
	920	"""
[319]	921	WAeUP Course
[68]	922	"""
	923	meta_type = 'Course'
	924	portal_type = meta_type
	925	security = ClassSecurityInfo()
[152]	926
	927	security.declareProtected(View,"Title")
	928	def Title(self):
	929	"""compose title"""
[238]	930	return self.title
[319]	931
[68]	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	###)
[139]	939
[319]	940

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

Context navigation

source: WAeUP_SRP/branches/uli/Academics.py @ 17947

Download in other formats: