source: WAeUP_SRP/trunk/Academics.py @ 279

Last change on this file since 279 was 279, checked in by joachim, 19 years ago

=modifications to level view
  • Property svn:keywords set to Id
File size: 17.9 KB
Line 
1#-*- mode: python; mode: fold -*-
2from Globals import InitializeClass
3from AccessControl import ClassSecurityInfo
4
5from Products.CMFCore.utils import UniqueObject, getToolByName
6from Products.CMFCore.permissions import View
7from Products.CMFCore.permissions import ModifyPortalContent
8from Products.CPSCore.CPSBase import CPSBase_adder, CPSBaseFolder
9#from Products.CPSCore.CPSBase import CPSBaseDocument as BaseDocument
10from Products.CPSDocument.CPSDocument import CPSDocument
11#from Products.CPSCore.CPSBase import CPSBaseBTreeFolder as BaseBTreeFolder
12#from Products.CPSCore.CPSBase import CPSBaseBTreeDocument as BaseBTreeDocument
13#from Products.CMFCore.DirectoryView import registerDirectory
14
15#registerDirectory('skins', globals())
16#registerDirectory('skins/waeup_default', globals())
17#registerDirectory('skins/waeup_faculty', globals())
18
19import csv,re
20import logging
21import Globals
22p_home = Globals.package_home(globals())
23i_home = Globals.INSTANCE_HOME
24
25class AcademicsFolder(CPSDocument): ###(
26    """
27    WAeUP AcademicsFolder containing StudyCourses
28    """
29    meta_type = 'AcademicsFolder'
30    portal_type = meta_type
31    security = ClassSecurityInfo()
32
33##    security.declareProtected(View,"Title")
34##    def Title(self):
35##        """compose title"""
36##        return "AcademicsFolder of %s" % (self.title)
37
38    security.declareProtected(View,"loadFacultiesFromCSV")###(
39    def loadFacultiesFromCSV(self):
40        """install Universityspecific Faculies from CSV values"""
41        #return
42        logger = logging.getLogger('loadfaculties')
43        logger.info('Start loading Faculties')
44        academics = self.portal_catalog({'meta_type': 'AcademicsFolder'})[-1].getObject()
45        try:
46            faculties = csv.DictReader(open("%s/import/faculty.csv" % i_home,"rb"))
47        except:
48            return
49        l = self.portal_catalog({'meta_type': "Faculty"})
50        facs = {}
51        for f in l:
52            facs[f.id] = f.getObject()
53        for faculty in faculties:
54            logger.info('processing %(Session)s %(FacultyCode)s %(Description)s %(CollegeCode)s %(FacultyKey)s %(Status)s %(degree_grade)s %(Bankcode)s' % faculty)
55            fid = faculty['FacultyCode']
56            f = facs.get(fid,None)
57            if f is None:
58                #self.log('Creating Faculty %(id)s = %(Title)s' % faculty)
59                logger.info('Creating Faculty with ID %(FacultyCode)s %(Description)s' % faculty)
60                academics.invokeFactory('Faculty', fid)
61                f = getattr(self,fid)
62            d = {'Title': faculty['Description']}
63            f.getContent().edit(mapping=d)
64    ###)
65
66    security.declareProtected(ModifyPortalContent,"yamlDumpFaculties")###(
67    def yamlDumpFaculties(self):
68        """dump Faculies to Yaml"""
69        #return
70        import yaml
71        logger = logging.getLogger('dumpfaculties')
72        logger.info('Start dumping Faculties')
73        academics = self.portal_catalog({'meta_type': 'AcademicsFolder'})[-1].getObject()
74        l = self.portal_catalog({'meta_type': "Faculty"})
75        facs = {}
76        for f in l:
77            facs[f.id] = f.getObject()
78        for fid in facs.keys():
79            faculty = facs.get(fid).aq_self
80            logger.info('dumping %s %s ' % (faculty.id, faculty.title))
81            print yaml.dump(faculty)
82           
83    ###)
84
85    security.declareProtected(ModifyPortalContent,"loadDepartmentsFromCSV")###(
86    def loadDepartmentsFromCSV(self):
87        """install Universityspecific Faculies from CSV values"""
88        #return
89        logger = logging.getLogger('loaddepartments')
90        try:
91            deps = csv.DictReader(open("%s/import/departments.csv" % i_home,"rb"))
92        except:
93            return
94        l = self.portal_catalog({'meta_type': "Faculty"})
95        facs = {}
96        for f in l:
97            facs[f.id] = f.getObject()
98        for dep in deps:
99            logger.info('Processing %(Session)s %(DeptCode)s %(Description)s %(FacultyCode)s' % dep)
100            fid = dep['FacultyCode']
101            f = facs.get(fid,None)
102            if f is None:
103                logger.info( "No Faculty with ID: %s" % fid)
104            else:
105                did = dep.get('DeptCode')
106                d = getattr(f,did,None)
107                if d is None or d.portal_type == "Faculty":
108                    #self.log('Creating Department %(DeptCode)s = %(Description)s' % dep)
109                    logger.info('Creating Department %(DeptCode)s = %(Description)s' % dep)
110                    f.invokeFactory('Department', did)
111                    d = getattr(f,did)
112                dict = {'Title': dep['Description']}
113                d.getContent().edit(mapping=dict)
114    ###)
115   
116    security.declareProtected(ModifyPortalContent,"loadCoursesFromCSV")###(
117    def loadCoursesFromCSV(self):
118        """install Universityspecific Courses from CSV values"""
119        #return
120        logger = logging.getLogger('loadcourses')
121        try:
122            courses = csv.DictReader(open("%s/import/courses.csv" % i_home,"rb"))
123        except:
124            return
125        l = self.portal_catalog({'meta_type': "Faculty"})
126        facs = {}
127        for f in l:
128            facs[f.id] = f.getObject()
129        dl = self.portal_catalog({'meta_type': "Department"})
130        deps = {}
131        for d in dl:
132            deps[d.id] = d.getObject()
133        cl = self.portal_catalog({'meta_type': "Course"})
134        course_list = [ c.id for c in cl]
135        for course in courses:
136            logger.info('Processing %(CourseCode)s %(Description)s %(Credits)s %(Dept)s %(Semester)s %(Session)s %(PassMark)s %(CourseKey)s %(Category)s %(AdmStatus)s %(FORMERCODE)s' % course)
137            if course.get("FORMERCODE").endswith('BITS'):
138                continue
139            depid = course.get('Dept').upper()
140            if depid in deps.keys():
141                dept= deps.get(depid)
142    ##        elif depid in facs.keys():
143    ##            dept= facs.get(depid)
144            else:
145                logger.info("Dep %(Dept)s for Course %(CourseCode)s not found" % course)
146                continue
147            course_id = ''.join(re.split('\W+',course.get('CourseCode')))
148            if len(course_id) == 3:
149                course_id = "%s000" % course_id
150            elif len(course_id) != 6:
151                logger.info("invalid course_code %(CourseCode)s" % course)
152                #print course_id,course.get('CourseCode'),course.get('Description')
153                continue
154    ##        if course_id in course_list:
155    ##            continue
156            c = getattr(dept,course_id,None)
157            if c is None:
158                #self.log('Creating Department %(DeptCode)s = %(Description)s' % dep)
159                logger.info('Creating Course %(CourseCode)s  %(Description)s in Department %(Dept)s' % course)
160                dept.invokeFactory('Course', course_id)
161                c = getattr(dept,course_id)
162            dict = {'Title': course['Description']}
163            dict['code'] = course_id
164            dict['org_code'] = course.get('CourseCode')
165            dict['credits'] = course.get('Credits')
166            dict['semester'] = course.get('Semester')
167            dict['session'] = course.get('Session')
168            dict['category'] = course.get('Category')
169            dict['passmark'] = course.get('PassMark')
170            c.getContent().edit(mapping=dict)
171    ###)
172
173    security.declareProtected(ModifyPortalContent,"loadCertificatesFromCSV")###(
174    def loadCertificatesFromCSV(self):
175        """install Universityspecific Certificates from CSV values"""
176        #return
177        logger = logging.getLogger('loadcertificates')
178        try:
179            certificates = csv.DictReader(open("%s/import/certificates.csv" % i_home,"rb"))
180        except:
181            return
182        f_ids = [f.id for f in self.portal_catalog({'meta_type': "Faculty"})]
183        #d_ids = [d.id for d in self.portal_catalog({'meta_type': "Department"})]
184        dl = self.portal_catalog({'meta_type': "Department"})
185        deps = {}
186        for d in dl:
187            deps[d.id] = d.getObject()
188        for certificate in certificates:
189            logger.info('Processing %(CertCode)s %(Description)s %(Faculty)s %(MaxPass)s %(MaxLoad)s %(session)s %(PromotionCredits)s %(Probationcredits)s %(StartLevel)s %(endLevel)s %(Nyears)s %(Ncore)s %(MaxElect)s %(MPREFIX)s %(Dept)s %(Admstatus)s %(category)s' % certificate)
190            depid = certificate.get('Dept')
191            facid = certificate.get('Faculty')
192            if facid not in f_ids:
193                logger.info('Faculty %(Faculty)s for %(CertCode)s %(Description)s not found' % certificate)
194                continue
195            if not deps.has_key(depid):
196                logger.info('Department %(Dept)s for %(CertCode)s %(Description)s not found' % certificate)
197                continue
198            certificate_id = "%(category)s_%(Admstatus)s_%(Dept)s" % certificate
199            dep = deps[depid]
200            c = getattr(dep,certificate_id,None)
201            if c is None:
202                #self.log('Creating Department %(DeptCode)s = %(Description)s' % dep)
203                logger.info('Creating certificate %(CertCode)s  %(Description)s in Department %(Dept)s' % certificate)
204                dep.invokeFactory('Certificate', certificate_id)
205                c = getattr(dep,certificate_id)
206            dict = {'Title': certificate['Description']}
207            code = certificate.get('CertCode')
208            code = code.replace('.','')
209            code = code.replace('(','')
210            code = code.replace(')','')
211            code = code.replace('/','')
212            code = code.replace(' ','')
213            code = code.replace('_','')
214            dict['code'] = code
215            dict['faculty'] = certificate.get('Faculty')
216            dict['department'] = certificate.get('Dept')
217            dict['max_pass'] = certificate.get('MaxPass')
218            dict['max_load'] = certificate.get('MaxLoad')
219            dict['admin_status'] = certificate.get('Admstatus')
220            dict['category'] = certificate.get('category')
221            dict['m_prefix'] = certificate.get('MPREFIX')
222            dict['nr_years'] = int(certificate.get('Nyears'))
223            nc = certificate.get('Ncore','1')
224            try:
225                dict['n_core'] = int(nc)
226            except:
227                dict['n_core'] = 1
228            dict['start_level'] = certificate.get('StartLevel')
229            dict['end_level'] = certificate.get('endLevel')
230            dict['promotion_credits'] = certificate.get('PromotionCredits')
231            dict['probation_credits'] = certificate.get('ProbationCredits')
232            c.getContent().edit(mapping=dict)
233    ###)
234
235    security.declareProtected(ModifyPortalContent,"loadCertificateCoursesFromCSV")###(
236    def loadCertificateCoursesFromCSV(self):
237        """install Certificate Courses from CSV values"""
238        #return
239        logger = logging.getLogger('loadcertificatecourses')
240        try:
241            cert_courses = csv.DictReader(open("%s/import/course_level_courses.csv" % i_home,"rb"))
242        except:
243            return
244        d_ids = [d.id for d in self.portal_catalog({'meta_type': "Department"})]
245        for cert_course in cert_courses:
246            logger.info('Processing %(CosCode)s %(CertCode)s %(CoreKey)s %(Session)s %(Level)s %(Core)s %(Elective)s %(Mandatory)s %(AdmStatus)s %(Dept)s %(Semester)s' % cert_course)
247            depid = cert_course.get('Dept')
248            code = cert_course.get('CertCode')
249            code = code.replace('.','')
250            code = code.replace('(','')
251            code = code.replace(')','')
252            code = code.replace('/','')
253            code = code.replace(' ','')
254            code = code.replace('_','')
255            if cert_course.get('Session') != '2002/2003':
256                continue
257            certificate = self.portal_catalog({'meta_type': "Certificate",
258                                               'SearchableText': code})
259            if not certificate:
260                print code
261                logger.info('CertCode %(CertCode)s for %(CosCode)s not found' % cert_course)
262                continue
263            certificate = certificate[-1].getObject()
264            certificate_code = certificate.getId()
265            if depid not in d_ids:
266                logger.info('Department %(Dept)s for %(CertCode)s not found' % cert_course)
267                continue
268            course_code = cert_course.get('CosCode')
269            level = cert_course.get('Level')
270            l = getattr(certificate,level,None)
271            if l is None:
272                #self.log('Creating Department %(DeptCode)s = %(Description)s' % dep)
273                logger.info('Creating Level %(Level)s in certificate %(CertCode)s' % cert_course)
274                certificate.invokeFactory('StudyLevel', level)
275                l = getattr(certificate, level)
276                l.invokeFactory('Semester','first')
277                l.invokeFactory('Semester','second')
278            first_s = getattr(l,'first')
279            second_s = getattr(l,'second')
280            if cert_course.get('Semester') == '1':
281                semester = first_s
282            else:
283                semester = second_s
284            if hasattr(semester,course_code):
285                logger.info('Duplicate %(CosCode)s in Level %(Level)s' % cert_course)
286                continue
287               
288            semester.invokeFactory('CertificateCourse',course_code)
289            cc = getattr(semester,course_code)
290            dict = {}
291            dict['code'] = cert_course.get('CosCode')
292            dict['certificate_code'] = code
293            dict['certificate_code_org'] = cert_course.get('CertCode')
294            dict['department'] = cert_course.get('Dept')
295            dict['admin_status'] = cert_course.get('Admstatus')
296            dict['session'] = cert_course.get('Session')
297            if cert_course.get('Core') != '':
298                dict['core_or_elective'] = True
299            else:
300                dict['core_or_elective'] = False
301            dict['level'] = cert_course.get('Level')
302            cc.getContent().edit(mapping=dict)
303    ###)
304
305InitializeClass(AcademicsFolder)
306
307def addAcademicsFolder(container, id, REQUEST=None, **kw):
308    """Add a AcademicsFolder."""
309    ob = AcademicsFolder(id, **kw)
310    return CPSBase_adder(container, ob, REQUEST=REQUEST)
311
312###)
313
314class Certificate(CPSDocument): ###(
315    """
316    WAeUP Certificate
317    """
318    meta_type = 'Certificate'
319    portal_type = meta_type
320    security = ClassSecurityInfo()
321   
322    def __init__(self, id, **kw):
323        CPSDocument.__init__(self, id, **kw)
324
325##    security.declareProtected(View,"Title")
326##    def Title(self):
327##        """compose title"""
328##        return "Certificate of %s" % (self.title)
329
330InitializeClass(Certificate)
331
332def addCertificate(container, id, REQUEST=None, **kw):
333    """Add a Certificate."""
334    ob = Certificate(id, **kw)
335    return CPSBase_adder(container, ob, REQUEST=REQUEST)
336
337###)
338
339class CertificateCourse(CPSDocument): ###(
340    """
341    WAeUP CertificateCourse 
342    """
343    meta_type = 'CertificateCourse'
344    portal_type = meta_type
345    security = ClassSecurityInfo()
346   
347    def getCourseEntry(self,cid):
348        res = self.portal_catalog({'meta_type': "Course",
349                                           'id': cid})
350        if res:
351            return res[-1] 
352        else:
353            return None
354       
355    security.declareProtected(View,"Title")
356    def Title(self):
357        """compose title"""
358        ce = self.getCourseEntry(self.id)
359        if ce:
360            return "%s" % ce.Title
361        return "No such course"
362
363    security.declareProtected(View,"credits")
364    def credits(self):
365        """credits from course"""
366        ce = self.getCourseEntry(self.id)
367        if ce:
368            return "%s" % ce.credits
369        return 0
370   
371    security.declareProtected(View,"passmark")
372    def passmark(self):
373        """passmark from course"""
374        ce = self.getCourseEntry(self.id)
375        if ce:
376            return "%s" % ce.passmark
377        return "No such course"
378   
379
380InitializeClass(CertificateCourse)
381
382def addCertificateCourse(container, id, REQUEST=None, **kw):
383    """Add a CertificateCourse."""
384    ob = CertificateCourse(id, **kw)
385    return CPSBase_adder(container, ob, REQUEST=REQUEST)
386###)
387
388class Faculty(CPSDocument): ###(
389    """
390    WAeUP Faculty containing Departments
391    """
392    meta_type = 'Faculty'
393    portal_type = meta_type
394    security = ClassSecurityInfo()
395   
396##    def __init__(self, id, **kw):
397##        CPSDocument.__init__(self, id, **kw)
398
399    security.declareProtected(View,"Title")
400    def Title(self):
401        """compose title"""
402        return "%s" % (self.title)
403
404InitializeClass(Faculty)
405
406def addFaculty(container, id, REQUEST=None, **kw):
407    """Add a Faculty."""
408    ob = Faculty(id, **kw)
409    return CPSBase_adder(container, ob, REQUEST=REQUEST)
410
411###)
412
413class Department(CPSDocument): ###(
414    """
415    WAeUP Department containing the courses and students
416    """
417    meta_type = 'Department'
418    portal_type = meta_type
419    security = ClassSecurityInfo()
420
421##    security.declareProtected(View,"Title")
422##    def Title(self):
423##        """compose title"""
424##        reg_nr = self.getId()[1:]
425##        return "Department of %s" % (self.title)
426
427InitializeClass(Department)
428
429def addDepartment(container, id, REQUEST=None, **kw):
430    """Add a Department."""
431    ob = Department(id, **kw)
432    return CPSBase_adder(container, ob, REQUEST=REQUEST)
433###)
434
435class Course(CPSDocument): ###(
436    """
437    WAeUP Course 
438    """
439    meta_type = 'Course'
440    portal_type = meta_type
441    security = ClassSecurityInfo()
442
443    security.declareProtected(View,"Title")
444    def Title(self):
445        """compose title"""
446        return self.title
447   
448InitializeClass(Course)
449
450def addCourse(container, id, REQUEST=None, **kw):
451    """Add a Course."""
452    ob = Course(id, **kw)
453    return CPSBase_adder(container, ob, REQUEST=REQUEST)
454###)
455
456class CourseTicket(CPSDocument): ###(
457    """
458    WAeUP CourseTicket 
459    """
460    meta_type = 'CourseTicket'
461    portal_type = meta_type
462    security = ClassSecurityInfo()
463   
464InitializeClass(CourseTicket)
465
466def addCourseTicket(container, id, REQUEST=None, **kw):
467    """Add a CourseTicket."""
468    ob = CourseTicket(id, **kw)
469    return CPSBase_adder(container, ob, REQUEST=REQUEST)
470###)
471
Note: See TracBrowser for help on using the repository browser.