Changeset 2084

Timestamp:

3 Aug 2007, 05:58:51 (18 years ago)

Author:

joachim

Message:

add course_results catalog

Location:

WAeUP_SRP/trunk

Files:

• WAeUPTables.py (modified) (10 diffs)
• profiles/default/course_results.xml (added)

WAeUP_SRP/trunk/WAeUPTables.py

@@ -35 +35 @@
 from Products.AdvancedQuery import Eq, Between, Le,In
 
+ADDING_SHEDULED = "adding_sheduled"
+OBJECT_CREATED = "object_created"
+
 from interfaces import IWAeUPTable
 
@@ -66 +69 @@
         #      URL1 +
         #      '/manage_catalogAdvanced?manage_tabs_message=Catalog%20Clearing%20disabled')
-
 
         self._catalog.clear()
@@ -313 +315 @@
     ###)
 
-    def fill_certificates_dict(self):
+    def fill_certificates_dict(self): ###(
         "return certificate data in  dict"
         certificates_brains = self.portal_catalog(portal_type ='Certificate')
@@ -326 +328 @@
             d[cb.getId] = ld
         return d
-            
+    ###)
+
     def get_from_doc_department(self,doc,cached_data={}): ###(
         "return the students department"
@@ -442 +445 @@
             pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
         noattr = set(('StudentClearance','StudentPersonal')) & set(reindextypes.keys())
+        #import pdb;pdb.set_trace()
         for i in xrange(num_objects):
             if pghandler: pghandler.report(i)
             student_brain = students[i]
             student_object = student_brain.getObject()
+            # query = Eq('path',student_brain.getPath())
+            # sub_brains_list = aq_portal(query)
+            # sub_brains = {}
+            # for sub_brain in sub_brains_list:
+            #     sub_brains[sub_brain.portal_type] = sub_brain
+            # student_path = student_brain.getPath()
             data = {}
             modified = False
@@ -457 +467 @@
                 try:
                     doc = getattr(student_object,self.affected_types[pt]['id']).getContent()
+                    #doc = sub_brains[pt].getObject().getContent()
+                    # path = "%s/%s" % (student_path,self.affected_types[pt]['id'])
+                    # doc = self.unrestrictedTraverse(path).getContent()
                     sub_objects = True
                 except:
                     continue
-                for field in self.affected_types[pt]['fields']:
+                for field in set(name).intersection(self.affected_types[pt]['fields']):
                     if hasattr(self,'get_from_doc_%s' % field):
                         data[field] = getattr(self,'get_from_doc_%s' % field)(doc,
@@ -640 +653 @@
 ###)
 
-class StatisticsCatalog(StudentsCatalog): ###(
-    security = ClassSecurityInfo()
-    meta_type = 'WAeUP Statistics Catalog'
-    name = "statistics"
-    affected_types = {   ###(
-                      'StudentApplication':
-                          {'id': 'application',
-                           'fields':
-                             ('jamb_reg_no',
-                              'entry_mode',
-                              #'entry_level',
-                              'entry_session',
-                              )
-                              },
-                      'StudentClearance':
-                          {'id': 'clearance',
-                           'fields':
-                             ('matric_no',
-                              )
-                              },
-                         'StudentPersonal':
-                          {'id': 'personal',
-                           'fields':
-                             ('name',
-                              'sex',
-                              'email',
-                              'phone',
-                              )
-                              },
-                         'StudentStudyCourse':
-                          {'id': 'study_course',
-                           'fields':
-                             ('course',
-                              'faculty',
-                              'department',
-                              'level',
-                              'mode',
-                              'session',
-                              'verdict',
-                              )
-                              },
-                         }
-    ###)
-
-
-InitializeClass(StudentsCatalog)
-###)
-
 class CoursesCatalog(WAeUPTable): ###(
     security = ClassSecurityInfo()
@@ -821 +786 @@
 ###)
 
-class ResultsCatalog(WAeUPTable): ###(
+class CourseResults(WAeUPTable): ###(
     security = ClassSecurityInfo()
 
     meta_type = 'WAeUP Results Catalog'
     name = "course_results"
-    key = "key"
+    key = "key" #student_id + level + course_id
     def __init__(self):
         WAeUPTable.__init__(self, 'course_results')
+        self._queue = []
+        
+    def addRecord(self, **data): ###(
+        # The uid is the same as "bed".
+        uid = key = "%(student_id)s|%(level_id)s|%(course_id)s" % data
+        if key in self._queue:
+            return uid
+        data['queue_status'] = ADDING_SHEDULED
+        data['%s' % self.key] = uid
+        res = self.searchResults({"%s" % self.key : uid})
+        if len(res) > 0:
+            raise ValueError("More than one record with uid %s" % uid)
+        self.catalog_object(dict2ob(data), uid=uid)
+        if not hasattr(self,'_queue'):
+            self._queue = []
+        self._queue.append(key)
+        self._p_changed = 1
+        return uid
+    ###)
+
+    def deleteRecord(self, uid): ###(
+        self.uncatalog_object(uid)
+        if uid in self._queue:
+            self._queue.remove(uid)
+    ###)
+
+    def getCourses(self,student_id,level_id): ###(
+        query = Eq('student_id',student_id) & Eq('level_id', level_id)
+        carry_overs = []
+        normal = []
+        credits = 0 
+        for brain in self.course_results.evalAdvancedQuery(query):
+            d = {}
+            credits += int(brain.credits) 
+            for field in self.schema():
+                d[field] = getattr(brain,field,'')
+            d['sheduled'] = brain.queue_status == ADDING_SHEDULED
+            d['coe'] = 'Elective'
+            if brain.core_or_elective:
+                d['coe'] = 'Core'
+            d['title'] = self.courses_catalog.evalAdvancedQuery(Eq('code',brain.code))[0].title
+            if brain.code.endswith('_co'):
+                carry_overs.append(d)
+            else:
+                normal.append(d)
+        normal.sort(cmp=lambda x,y: cmp(x['semester'], y['semester']))
+        carry_overs.sort(cmp=lambda x,y: cmp(x['semester'], y['semester']))
+        return credits,carry_overs,normal
+    ###)
+
+    def addObject(self,record): ###(
+        key = record.key
+        student_id,level_id,course_id = key.split('|')
+        level = getattr(getattr(self.portal_url.getPortalObject().campus.students,student_id).study_course,level_id)
+        cr_id = level.invokeFactory('StudentCourseResult', course_id)
+        course_result = getattr(level,cr_id)
+        self.portal_workflow.doActionFor(course_result,'open')
+        d = {}
+        for field in self.schema():
+            d[field] = getattr(record,field,'')
+        course_result.getContent().edit(mapping=d)
+    ###)
+        
+    security.declareProtected(ModifyPortalContent,"process_queue") ###(
+    def process_queue(self,limit=None):
+        """adds objects and removes them from the queue.
+        If limit is specified, at most (limit) events are removed.
+        """
+        if not hasattr(self,'_queue'):
+            return 0
+        queue= self._queue
+        if not limit or len(queue) <= limit:
+            keys = self._queue[:]
+        else:
+            keys = queue[:limit]
+        if not keys:
+            records = self.evalAdvancedQuery(Eq('queue_status',ADDING_SHEDULED))
+        else:
+            records = self.evalAdvancedQuery(In("%s" % self.key,keys))
+        for record in records:
+            if record.queue_status == OBJECT_CREATED:
+                continue
+            self.addObject(record)
+            data = {}
+            data['key'] = record.key
+            data['queue_status'] = OBJECT_CREATED
+            self.modifyRecord(**data)
+        count = 0
+        for key in keys:
+            count +=1
+            if key in self._queue:
+                self._queue.remove(key)
+        self._p_changed = 1
+        return count,len(self._queue)
+    ###)
+
+    def manage_catalogClear(self, REQUEST=None, RESPONSE=None, URL1=None): ###(
+        """ clears the whole enchilada """
+        self._catalog.clear()
+
+        if REQUEST and RESPONSE:
+            RESPONSE.redirect(
+              URL1 +
+              '/manage_catalogAdvanced?manage_tabs_message=Catalog%20Cleared')
+    ###)
 
     def manage_catalogReindex(self, REQUEST, RESPONSE, URL1): ###(
@@ -838 +908 @@
         pgthreshold = self._getProgressThreshold()
         handler = (pgthreshold > 0) and ZLogHandler(pgthreshold) or None
-        #self.refreshCatalog(clear=1, pghandler=handler)
+        self.refreshCatalog(clear=1, pghandler=handler)
 
         elapse = time.time() - elapse
@@ -851 +921 @@
     ###)
 
-
-InitializeClass(ResultsCatalog)
+    def refreshCatalog(self, clear=1, pghandler=None): ###(
+        """ re-index everything we can find """
+        students_folder = self.portal_url.getPortalObject().campus.students
+        if clear:
+            self._catalog.clear()
+        course_results = self.portal_catalog(portal_type="StudentCourseResult")
+        num_objects = len(course_results)
+        if pghandler:
+            pghandler.init('Refreshing catalog: %s' % self.absolute_url(1), num_objects)
+        #import pdb;pdb.set_trace()
+        for i in xrange(num_objects):
+            if pghandler: 
+                pghandler.report(i)
+            course_result_brain = course_results[i]
+            path_list = course_result_brain.getPath().split('/')
+            course_result_object = course_result_brain.getObject()
+            course_result_doc = course_result_object.getContent()
+            data = {}
+            level_id = path_list[-2]
+            course_id = path_list[-1]
+            student_id = path_list[-4]
+            for field in self.schema():
+                data[field] = getattr(course_result_doc,field,'')
+            data['key'] = key = "%(student_id)s|%(level_id)s|%(course_id)s" % vars()
+            data['student_id'] = student_id 
+            data['level_id'] = level_id 
+            data['queue_status'] = OBJECT_CREATED
+            self.catalog_object(dict2ob(data), uid=key)
+        if pghandler: pghandler.finish()
+    ###)
+
+    security.declarePrivate('notify_event_listener') ###(
+    def notify_event_listener(self,event_type,object,infos):
+        "listen for events"
+        if not infos.has_key('rpath'):
+            return
+        pt = getattr(object,'portal_type',None)
+        mt = getattr(object,'meta_type',None)
+        data = {}
+        rpl = infos['rpath'].split('/')
+        if mt == 'CPS Proxy Folder':
+            return
+        if pt == 'StudentCourseResult' and event_type == "sys_modify_object":
+            data["%s" % self.key] = uid = "%s|%s|%s" % (rpl[-5],rpl[-3],rpl[-2])
+            records = self.searchResults({"%s" % self.key : uid})
+            if len(records) > 1:
+                # Can not happen, but anyway...
+                raise ValueError("More than one record with uid %s" % uid)
+            if len(records) == 0:
+                raise KeyError("No record for uid %s" % uid)
+            record = records[0]
+            #import pdb;pdb.set_trace()
+            for field in ('core_or_elective','score'):
+                value = getattr(object,field,None)
+                data[field] = value
+            self.modifyRecord(record,**data)
+    ###)
+
+InitializeClass(CourseResults)
 ###)