source: WAeUP_SRP/trunk/Academics.py @ 278

Last change on this file since 278 was 278, checked in by joachim, 18 years ago

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