source: WAeUP_SRP/trunk/Students.py @ 1146

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

added import for registered and results,
the csv-files must contain a modified heading
results can be viewed with session_results_anon_view
modified Courses import to use courses catalog
  • Property svn:keywords set to Id
File size: 77.0 KB
Line 
1#-*- mode: python; mode: fold -*-
2# $Id: Students.py 1146 2006-12-29 07:00:35Z joachim $
3from string import Template
4from Globals import InitializeClass
5from AccessControl import ClassSecurityInfo
6from AccessControl.SecurityManagement import newSecurityManager
7from zExceptions import BadRequest
8from Products.ZCatalog.ZCatalog import ZCatalog
9from Products.CMFCore.utils import UniqueObject, getToolByName
10from Products.CMFCore.permissions import View
11from Products.CMFCore.permissions import ModifyPortalContent
12from Products.CPSCore.CPSBase import CPSBase_adder, CPSBaseFolder
13#from Products.CPSCore.CPSBase import CPSBaseDocument as BaseDocument
14from Products.CPSDocument.CPSDocument import CPSDocument
15from Products.CPSCore.CPSBase import CPSBaseBTreeFolder as BaseBTreeFolder
16from Products.CPSCore.CPSMembershipTool import CPSUnrestrictedUser
17from Products.WAeUP_SRP.Academics import makeCertificateCode
18import logging
19import csv,re,os
20import Globals
21p_home = Globals.package_home(globals())
22i_home = Globals.INSTANCE_HOME
23MAX_TRANS = 1000
24import DateTime
25import PIL.Image
26from StringIO import StringIO
27
28def makeCertificateCode(code): ###(
29    code = code.replace('.','')
30    code = code.replace('(','')
31    code = code.replace(')','')
32    code = code.replace('/','')
33    code = code.replace(' ','')
34    code = code.replace('_','')
35    return code
36
37###)
38
39def getInt(s): ###(
40    try:
41        return int(s)
42    except:
43        return 0
44
45def getFloat(s):
46    try:
47        return float(s)
48    except:
49        return 0.0
50
51###)
52
53def getStudentByRegNo(self,reg_no): ###(
54    """search student by JAMB Reg No and return StudentFolder"""
55    search = ZCatalog.searchResults(self.portal_catalog,{'meta_type': 'StudentApplication',
56                                  'SearchableText': reg_no,
57                                  })
58    if len(search) < 1:
59        return None
60    return search[0].getObject().aq_parent
61
62###)
63
64def checkJambNo(jnr):
65    try:
66        if len(jnr) != 10:
67            return False
68    except:
69        return False
70    try:
71        int(jnr[:8])
72        return True
73    except:
74        return False
75
76class StudentsFolder(CPSDocument): ###(
77    """
78    WAeUP container for the various WAeUP containers data
79    """
80    meta_type = 'StudentsFolder'
81    portal_type = meta_type
82    security = ClassSecurityInfo()
83
84    security.declareProtected(ModifyPortalContent,"loadFullTimeStudentsFromCSV")###(
85    def loadFullTimeStudentsFromCSV(self):
86        """load Fulltime Studentdata from CSV values"""
87        import transaction
88        import random
89        tr_count = 0
90        name = 'short_full_time'
91        no_import = False
92        if not no_import:
93            no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
94            no_import.write('"MatricNo","EntryRegNo","CurrentSession","StudentLevel","fullname","FirstName","MiddleName","Lastname","FormerSurname","Sex","Nationality","State","LGA","PermanentAddress","PermanentAddressCity","CampusAddress","PhoneNumber","Emailaddress","Mode","CourseMajor","Faculty","Dept"\n')
95        logger = logging.getLogger('Import.%s' % name)
96        logger.info('Start loading from %s.csv' % name)
97        pwlist  = []
98        pwlist.append('"student_id","firstname","middlename","lastname","matric_no","jamb_reg_no","access_code"')
99        pwl_template = Template('"$student_id","$firstname","$middlename","$lastname","$matric_no","$jamb_reg_no","$access_code"')
100        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
101        try:
102            students = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
103        except:
104            logger.error('Error reading %s.csv' % name)
105            return
106        l = self.portal_catalog({'meta_type': "StudentClearance",})
107        matrics = []
108        for s in l:
109            matrics.append(s.getObject().getContent().matric_no)
110        print matrics
111        l = self.portal_catalog({'meta_type': "Certificate"})
112        certs = {}
113        for c in l:
114            ca,ac,fa,dep_id,co,certcode = c.relative_path.split('/')
115            cid = "%(dep_id)s_%(certcode)s" % vars()
116            certs[cid] = c.getObject()
117        for student in students:
118            logger.info('processing "%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
119            sid = student.get('MatricNo')
120            if sid == "":
121                em = 'Empty MatricNo\n'
122                logger.info(em)
123                no_import.write(em)
124                no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
125                continue
126            certcode = makeCertificateCode(student.get('CourseMajor'))
127            dep_id = student.get('Dept')
128            fac_id = student.get('Faculty')
129            cid = "%(dep_id)s_%(certcode)s" % vars()
130            if cid not in certs.keys():
131                em = 'Certificate with ID %s %s not found\n' % (certcode, student.get('CourseMajor'))
132                logger.info(em)
133                no_import.write(em)
134                no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
135                continue
136            certificate_doc = certs[cid].getContent()
137            level = student.get('StudentLevel')
138            try:
139                int(level)
140            except:
141                em = 'Student with ID %(MatricNo)s StudentLevel is empty\n' % student
142                logger.info(em)
143                no_import.write(em)
144                no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
145                continue
146            matric_no = student.get('MatricNo')
147            if matric_no not in matrics:
148                matrics.append(matric_no)
149                sid = self.generateStudentId(student.get('Lastname')[0])
150                #self.log('Creating Faculty %(id)s = %(Title)s' % faculty)
151                students_folder.invokeFactory('Student', sid)
152                logger.info('%(tr_count)s: Creating Student with ID %(sid)s Matric_no %(matric_no)s ' % vars())
153                student_obj = getattr(self,sid)
154                access_code = "%d" % random.randint(1000000000,9999999999)
155                student_obj.getContent().makeStudentMember(sid,access_code,)
156                pwl_dict = {'student_id': sid,'access_code':access_code}
157                student_obj.invokeFactory('StudentApplication','application')
158                application = student_obj.application
159                da = {'Title': 'Application Data'}
160                student_obj.invokeFactory('StudentPersonal','personal')
161                da['jamb_reg_no'] = student.get('EntryRegNo')
162                personal = student_obj.personal
163                dp = {'Title': 'Personal Data'}
164                student_obj.invokeFactory('StudentClearance','clearance')
165                clearance = student_obj.clearance
166                dc = {'Title': 'Clearance/Eligibility Record'}
167                dc['matric_no'] = matric_no
168                state = student.get('State')
169                lga = student.get('LGA')
170                if state and lga:
171                    lga =  state + ' / ' + lga
172                else:
173                    lga = "None"
174                dc['lga'] = lga
175                dc['nationality'] = student.get('Nationality')
176                dc['email'] = student.get('Emailaddress')
177                dp['firstname'] = student.get('FirstName')
178                dp['middlename'] = student.get('MiddleName')
179                dp['lastname'] = student.get('Lastname')
180                dp['former_surname'] = student.get('FormerSurname')
181                dp['sex'] = student.get('Sex') == 'F'
182                dp['perm_address'] = student.get('PermanentAddress')
183                dp['perm_city'] = student.get('PermanentAddressCity')
184                dp['campus_address'] = student.get('CampusAddress')
185                dp['phone'] = student.get('PhoneNumber')
186                application.getContent().edit(mapping=da)
187                personal.getContent().edit(mapping=dp)
188                clearance.getContent().edit(mapping=dc)
189                #
190                # Study Course
191                #
192                student_obj.invokeFactory('StudentStudyCourse','study_course')
193                studycourse = student_obj.study_course
194                dsc = {}
195                from_certificate = ['title',
196                                   'max_elect',
197                                   'max_pass',
198                                   'n_core',
199                                   'nr_years',
200                                   'probation_credits',
201                                   'promotion_credits',
202                                   'start_level',
203                                  ]
204                for f in from_certificate:
205                    dsc[f] = getattr(certificate_doc,f)
206                dsc['faculty'] = fac_id
207                dsc['department'] = dep_id
208                dsc['study_course'] = certcode
209                css = student.get('CurrentSession') or '2004-2005'
210                cs = int(css.split('-')[0]) - 2000
211                cl = int(student.get('StudentLevel') or '100')/100
212                dsc['entry_session'] = "200%s" % (cs - cl)
213                dsc['clr_ac_pin'] = access_code
214                studycourse.getContent().edit(mapping=dsc)
215                #
216                # Level
217                #
218##                l = getattr(studycourse,level,None)
219##                if 0 and l is None:
220##                    #self.log('Creating Department %(DeptCode)s = %(Description)s' % dep)
221##                    logger.info('Creating Level %(StudentLevel)s for %(fullname)s' % student)
222##                    studycourse.invokeFactory('StudentStudyLevel', level)
223##                    l = getattr(studycourse, level)
224##                    certificate = certs[certcode]
225##                    cert_level = getattr(certificate,level,None)
226##                    if cert_level is None:
227##                        logger.info('Level %(level)s not in %(certcode)s' % vars())
228##                    l.getContent().edit(mapping={'Title': "Level %s" % level})
229            else:
230                em = 'Student with ID %(MatricNo)s %(fullname)s already exists\n' % student
231                logger.info(em)
232                no_import.write(em)
233                no_import.write('"%(MatricNo)s","%(EntryRegNo)s","%(CurrentSession)s","%(StudentLevel)s","%(fullname)s","%(FirstName)s","%(MiddleName)s","%(Lastname)s","%(FormerSurname)s","%(Sex)s","%(Nationality)s","%(State)s","%(LGA)s","%(PermanentAddress)s","%(PermanentAddressCity)s","%(CampusAddress)s","%(PhoneNumber)s","%(Emailaddress)s","%(Mode)s","%(CourseMajor)s","%(Faculty)s","%(Dept)s"\n' % student)
234                continue
235            if tr_count > MAX_TRANS:
236                transaction.commit()
237                em = 'Transaction commited\n' % student
238                logger.info(em)
239                tr_count = 0
240            tr_count += 1
241            pwl_dict.update(dc)
242            pwl_dict.update(da)
243            pwl_dict.update(dp)
244            wftool = self.portal_workflow
245            pwlist.append(pwl_template.substitute(pwl_dict))
246            wftool.doActionFor(student_obj,'clear_and_validate')
247            student_obj.manage_setLocalRoles(sid, ['Owner',])
248            wftool.doActionFor(application,'close')
249            application.manage_setLocalRoles(sid, ['Owner',])
250            wftool.doActionFor(clearance,'close')
251            clearance.manage_setLocalRoles(sid, ['Owner',])
252            wftool.doActionFor(personal,'close')
253            personal.manage_setLocalRoles(sid, ['Owner',])
254            wftool.doActionFor(studycourse,'close_for_edit')
255            studycourse.manage_setLocalRoles(sid, ['Owner',])
256        open("%s/import/pwlist-%s.csv" % (i_home,name),"w+").write('\n'.join(pwlist))
257        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
258    ###)
259
260    security.declareProtected(ModifyPortalContent,"loadPumeResultsFromCSV")###(
261    def loadPumeResultsFromCSV(self):
262        """load Fulltime Studentdata from CSV values into pumeresults catalog"""
263        import transaction
264        import random
265##        csv_d = {'jamb_reg_no': "RegNumber", ###(
266##                 'status': "Admission Status",
267##                 'name': "Name",
268##                 'score': "Score",
269##                 'sex': "Sex",
270##                 'faculty': "Faculty",
271##                 'department': "Dept",
272##                 'course': "Course",
273##                 'course_code_org': "Course Code",
274##                 }
275###)
276        csv_d = {'jamb_reg_no': "JAMBRegno",
277                 'name': "Name",
278                 'score': "Score",
279                 'sex': "Sex",
280                 'course': "Course",
281                 'faculty': "Faculty",
282                 'department': "Dept",
283                 'course_code_org': "Course Code",
284                 'status': "Admission Status",
285                 'result_type': None,
286                 }
287        csv_fields = [f[1] for f in csv_d.items() if f[1]]
288        tr_count = 0
289        total = 0
290        name = 'pup_new'
291        #name = 'pup_update'
292        update = name.endswith('update')
293        no_import = []
294        ok_import = []
295        ok_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_d.keys()]))
296        no_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_fields]))
297        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
298        ok_import_name = "%s/import/%s_imported_%s.csv" % (i_home,name,current)
299        #open(ok_import_name,"w").write('\n'.join(no_import))
300        no_import_name = "%s/import/%s_not_imported_%s.csv" % (i_home,name,current)
301        #open(no_import_name,"w").write('\n'.join(no_import))
302        logger = logging.getLogger('Import.%s' % name)
303        starttime = DateTime.now()
304        logger.info('Start loading from %s.csv' % name)
305        try:
306            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
307        except:
308            logger.error('Error reading %s.csv' % name)
309            return
310        pume = self.portal_pumeresults
311        format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
312        import_format = ','.join(['"%%(%s)s"' % fn for fn in csv_d.keys()])
313        eduplicate = '%s,"duplicate"' % format
314        einvalidjamb = '%s,"invalid JambRegNo"' % format
315        added = 'added ,%s' % format
316        #from pdb import set_trace;set_trace()
317        for jamb in result:
318            dict = {}
319            for f,fn in csv_d.items():
320                dict[f] = jamb.get(csv_d[f])
321            dict['result_type'] = 'DE'
322            jnr = jamb.get(csv_d['jamb_reg_no'])
323            if not checkJambNo(jnr):
324                logger.info(einvalidjamb % jamb)
325                dd = {}
326                for f,fn in csv_d.items():
327                    dd[fn] = getattr(data,f)
328                    no_import.append(eduplicate % dd)
329                    no_import.append(eduplicate % jamb)
330                continue
331            res = pume(jamb_reg_no=jnr)
332            if len(res) > 0:
333                if update:
334                    try:
335                        pume.modifyRecord(**dict)
336                    except ValueError:
337                        logger.info(eduplicate % jamb)
338                        continue
339                    except KeyError:
340                        pume.addRecord(**dict)
341                        logger.info(added % jamb)
342                        continue
343                else:
344                    data = res[0]
345                    if data.name != jamb.get(csv_d['name']):
346                        #set_trace()
347                        logger.info(eduplicate % jamb)
348                        #em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
349                        #logger.info(em)
350                        dd = {}
351                        for f,fn in csv_d.items():
352                            dd[fn] = getattr(data,f)
353                        no_import.append(eduplicate % dd)
354                        no_import.append(eduplicate % jamb)
355                    continue
356            try:
357                pume.addRecord(**dict)
358                ok_import.append(import_format % dict)
359            except ValueError:
360                logger.info(eduplicate % jamb)
361                #em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
362                #logger.info(em)
363                no_import.append(eduplicate % jamb)
364        logger.info('End loading from %s.csv' % name)
365        if len(no_import) > 1:
366            open(no_import_name,"w+").write('\n'.join(no_import))
367        open(ok_import_name,"w+").write('\n'.join(ok_import))
368        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
369    ###)
370
371    security.declareProtected(ModifyPortalContent,"createDEStudents")###(
372    def createDEStudents(self):
373        """load Fulltime Studentdata from CSV values"""
374        import transaction
375        import random
376        #from pdb import set_trace
377        wftool = self.portal_workflow
378        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
379        csv_d = {'jamb_reg_no': "RegNumber",
380                 'jamb_lastname': "Name",
381                 'session': "Session",
382                 'pume_tot_score': "PUDE SCORE",
383                 ##'jamb_score': "JambScore",
384                 'entry_mode': "EntryMode",
385                 'jamb_sex': "Sex",
386                 'jamb_state': "State",
387                 'jamb_first_cos': "AdminCourse",
388                 'faculty': "AdminFaculty",
389                 'course_code': "AdmitCoscode",
390                 'stud_status':"AdmitStatus",
391                 'department': "AdmitDept",
392                 'jamb_lga': "LGA",
393                 'app_email': "email",
394                 'app_mobile': "PhoneNumbers",
395                 }
396        csv_fields = [f[1] for f in csv_d.items()]
397        tr_count = 0
398        total = 0
399        #name = 'pume_results'
400        name = 'DE_Admitted'
401        no_import = []
402        s = ','.join(['"(%s)"' % fn for fn in csv_fields])
403        no_import.append('"Error",%s' % s)
404        format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
405        no_certificate = "no certificate %s" % format
406        open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
407        logger = logging.getLogger('Import.%s' % name)
408        logger.info('start loading from %s.csv' % name)
409        l = self.portal_catalog({'meta_type': "Certificate"})
410        certs = {}
411        cert_docs = {}
412        for f in l:
413            certs[f.getId] = f.getObject().getContent()
414        try:
415            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
416        except:
417            logger.error('Error reading %s.csv' % name)
418            return
419        for jamb in result:
420            jamb['Error'] = "Processing "
421            logger.info(format % jamb)
422            jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
423            res = self.portal_catalog({'portal_type': "StudentApplication",
424                                     'SearchableText': jamb_reg_no })
425            if res:
426                em = 'Student with RegNo %s already exists\n' % jamb_reg_no
427                logger.info(em)
428                jamb['Error'] = "Student exists"
429                no_import.append(format % jamb)
430                continue
431            cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
432            if cert_id not in certs.keys():
433                em = 'No Certificate with ID %s \n' % cert_id
434                logger.info(em)
435                jamb['Error'] = "No Certificate %s" % cert_id
436                no_import.append( format % jamb)
437                continue
438            jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
439            cert_doc = certs[cert_id]
440            catalog_entry = {}
441            catalog_entry['jamb_reg_no'] = jamb_reg_no
442            jamb_name = jamb.get(csv_d['jamb_lastname'])
443            jamb_name.replace('>','')
444            jamb_name.replace('<','')
445            names = jamb_name.split()
446            letter = names[-1][0].upper()
447            sid = self.generateStudentId(letter)
448            not_created = True
449            while not_created:
450                try:
451                    students_folder.invokeFactory('Student', sid)
452                    not_created = False
453                except BadRequest:
454                    sid = self.generateStudentId(letter)
455            catalog_entry['id'] = sid
456            tr_count += 1
457            logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
458            student = getattr(self,sid)
459            student.manage_setLocalRoles(sid, ['Owner',])
460            student.invokeFactory('StudentPume','pume')
461            dp = {'Title': 'Pume Data'}
462            student.invokeFactory('StudentApplication','application')
463            da = {'Title': 'Application Data'}
464            da["jamb_lastname"] = jamb_name
465            da_fields = ('jamb_reg_no',
466                         'jamb_sex',
467                         'entry_mode',
468                         #'jamb_score',
469                         'jamb_first_cos',
470                         'jamb_sex',
471                         'jamb_state',
472                         'jamb_lga',
473                         'app_email',
474                         'app_mobile',
475                         )
476            for f in da_fields:
477                da[f] = jamb.get(csv_d[f])
478            catalog_entry['email'] = jamb.get(csv_d['app_email'])
479            app = student.application
480            app_doc = app.getContent()
481            picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
482            #import pdb;pdb.set_trace()
483            if os.path.exists(picture):
484                file = open(picture)
485                if False:
486                    img = PIL.Image.open(file)
487                    img.thumbnail((150,200),
488                                  resample=PIL.Image.ANTIALIAS)
489                    # We now need a buffer to write to. It can't be the same
490                    # as the inbuffer as the PNG writer will write over itself.
491                    outfile = StringIO()
492                    img.save(outfile, format=img.format)
493                else:
494                    outfile = file.read()
495                app_doc.manage_addFile('passport',
496                                       file=outfile,
497                                       title="%s.jpg" % jamb_reg_no)
498            app.getContent().edit(mapping=da)
499            app.manage_setLocalRoles(sid, ['Owner',])
500            #wftool.doActionFor(app,'close')
501            dp_fields = (
502                         #'pume_eng_score',
503                         #'pume_gen_score',
504                         'pume_tot_score',
505                         )
506            dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
507            pume = student.pume
508            pume.getContent().edit(mapping=dp)
509            #wftool.doActionFor(pume,'close')
510            pume.manage_setLocalRoles(sid, ['Owner',])
511            #student.getContent().createSubObjects()
512            dp = {}
513            if len(names) == 3:
514                dp['firstname'] = names[0].capitalize()
515                dp['middlename'] = names[1].capitalize()
516                dp['lastname'] = names[2].capitalize()
517            elif len(names) == 2:
518                dp['firstname'] = names[0].capitalize()
519                dp['middlename'] = ''
520                dp['lastname'] = names[1].capitalize()
521            else:
522                dp['firstname'] = ''
523                dp['middlename'] = ''
524                dp['lastname'] = jamb_name
525            dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
526            catalog_entry['sex'] = dp['sex']
527            catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
528            student.invokeFactory('StudentPersonal','personal')
529            per = student.personal
530            per_doc = per.getContent()
531            per_doc.edit(mapping = dp)
532            per.manage_setLocalRoles(sid, ['Owner',])
533            if jamb.get(csv_d['stud_status']) == "Admitted":
534                wftool.doActionFor(student,'pume_pass')
535                wftool.doActionFor(student,'admit')
536            else:
537                wftool.doActionFor(student,'pume_fail')
538                wftool.doActionFor(student,'reject_admission')
539                continue
540            #
541            # Clearance
542            #
543            student.invokeFactory('StudentClearance','clearance')
544            #wftool.doActionFor(student.clearance,'open')
545            dp = {'Title': 'Clearance/Eligibility Record'}
546            student.clearance.manage_setLocalRoles(sid, ['Owner',])
547            #
548            # Study Course
549            #
550            student.invokeFactory('StudentStudyCourse','study_course')
551            study_course = student.study_course
552            dsc = {}
553            from_certificate = ['title',
554                               'max_elect',
555                               'max_pass',
556                               'n_core',
557                               'nr_years',
558                               'probation_credits',
559                               'promotion_credits',
560                               'start_level',
561                              ]
562            for f in from_certificate:
563                dsc[f] = getattr(cert_doc,f)
564            dsc['faculty'] = jamb.get(csv_d['faculty'])
565            dsc['department'] = jamb.get(csv_d['department'])
566            catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
567            catalog_entry['department'] = jamb.get(csv_d['department'])
568            catalog_entry['course'] = cert_id
569            catalog_entry['level'] = getattr(cert_doc,'start_level')
570            dsc['study_course'] = cert_id
571            dsc['entry_session'] = jamb.get(csv_d['session'])
572            study_course.getContent().edit(mapping=dsc)
573            self.students_catalog.addRecord(**catalog_entry)
574            if tr_count > 10:
575                if len(no_import) > 1:
576                    open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
577                             '\n'.join(no_import))
578                    no_import = []
579                em = '%d transactions commited\n' % tr_count
580                transaction.commit()
581                logger.info(em)
582                total += tr_count
583                tr_count = 0
584        open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
585                                               '\n'.join(no_import))
586        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
587    ###)
588
589    security.declareProtected(ModifyPortalContent,"createNewStudents")###(
590    def createNewStudents(self):
591        """load Fulltime Studentdata from CSV values"""
592        import transaction
593        import random
594        #from pdb import set_trace
595        wftool = self.portal_workflow
596        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
597        csv_d = {'jamb_reg_no': "RegNumber",
598                 'jamb_lastname': "Name",
599                 'session': "Session",
600                 'pume_tot_score': "PUME SCORE",
601                 'jamb_score': "JambScore",
602                 'jamb_sex': "Sex",
603                 'jamb_state': "State",
604##                 'jamb_first_cos': "AdminCourse",
605                 'faculty': "AdminFaculty",
606                 'course_code': "AdmitCoscode",
607                 'stud_status':"AdmitStatus",
608                 'department': "AdmitDept",
609                 'jamb_lga': "LGA",
610                 'app_email': "email",
611                 'app_mobile': "PhoneNumbers",
612                 }
613        csv_fields = [f[1] for f in csv_d.items()]
614        tr_count = 0
615        total = 0
616        #name = 'pume_results'
617        name = 'Admitted'
618        no_import = []
619        s = ','.join(['"(%s)"' % fn for fn in csv_fields])
620        no_import.append('"Error",%s' % s)
621        format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
622        no_certificate = "no certificate %s" % format
623        open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
624        logger = logging.getLogger('Import.%s' % name)
625        logger.info('start loading from %s.csv' % name)
626        l = self.portal_catalog({'meta_type': "Certificate"})
627        certs = {}
628        cert_docs = {}
629        for f in l:
630            certs[f.getId] = f.getObject().getContent()
631        try:
632            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
633        except:
634            logger.error('Error reading %s.csv' % name)
635            return
636        for jamb in result:
637            jamb['Error'] = "Processing "
638            logger.info(format % jamb)
639            jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
640            res = self.portal_catalog({'portal_type': "StudentApplication",
641                                     'SearchableText': jamb_reg_no })
642            if res:
643                em = 'Student with RegNo %s already exists\n' % jamb_reg_no
644                logger.info(em)
645                jamb['Error'] = "Student exists"
646                no_import.append(format % jamb)
647                continue
648            cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
649            if cert_id not in certs.keys():
650                em = 'No Certificate with ID %s \n' % cert_id
651                logger.info(em)
652                jamb['Error'] = "No Certificate %s" % cert_id
653                no_import.append( format % jamb)
654                continue
655            res = self.portal_pumeresults(jamb_reg_no = jamb_reg_no)
656            if len(res) == 1:
657                self.portal_pumeresults.modifyRecord(jamb_reg_no = jamb_reg_no,
658                                                     status = jamb.get(csv_d['stud_status']),
659                                                     )
660            jamb_reg_no =jamb.get(csv_d['jamb_reg_no'])
661            cert_doc = certs[cert_id]
662            catalog_entry = {}
663            catalog_entry['jamb_reg_no'] = jamb_reg_no
664            jamb_name = jamb.get(csv_d['jamb_lastname'])
665            jamb_name.replace('>','')
666            jamb_name.replace('<','')
667            names = jamb_name.split()
668            letter = names[-1][0].upper()
669            sid = self.generateStudentId(letter)
670            not_created = True
671            while not_created:
672                try:
673                    students_folder.invokeFactory('Student', sid)
674                    not_created = False
675                except BadRequest:
676                    sid = self.generateStudentId(letter)
677            catalog_entry['id'] = sid
678            tr_count += 1
679            logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
680            student = getattr(self,sid)
681            student.manage_setLocalRoles(sid, ['Owner',])
682            student.invokeFactory('StudentPume','pume')
683            dp = {'Title': 'Pume Data'}
684            student.invokeFactory('StudentApplication','application')
685            da = {'Title': 'Application Data'}
686            da["jamb_lastname"] = jamb_name
687            da_fields = ('jamb_reg_no',
688                         'jamb_sex',
689                         #'jamb_state',
690                         'jamb_score',
691##                         'jamb_first_cos',
692                         'jamb_sex',
693                         'jamb_state',
694                         'jamb_lga',
695                         'app_email',
696                         'app_mobile',
697                         )
698            for f in da_fields:
699                da[f] = jamb.get(csv_d[f])
700            catalog_entry['email'] = jamb.get(csv_d['app_email'])
701            app = student.application
702            app_doc = app.getContent()
703            picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
704            #import pdb;pdb.set_trace()
705            if os.path.exists(picture):
706                file = open(picture)
707                if False:
708                    img = PIL.Image.open(file)
709                    img.thumbnail((150,200),
710                                  resample=PIL.Image.ANTIALIAS)
711                    # We now need a buffer to write to. It can't be the same
712                    # as the inbuffer as the PNG writer will write over itself.
713                    outfile = StringIO()
714                    img.save(outfile, format=img.format)
715                else:
716                    outfile = file.read()
717                app_doc.manage_addFile('passport',
718                                       file=outfile,
719                                       title="%s.jpg" % jamb_reg_no)
720            app.getContent().edit(mapping=da)
721            app.manage_setLocalRoles(sid, ['Owner',])
722            #wftool.doActionFor(app,'close')
723            dp_fields = (
724                         #'pume_eng_score',
725                         #'pume_gen_score',
726                         'pume_tot_score',
727                         )
728            dp['pume_tot_score'] = jamb.get(csv_d['pume_tot_score']) or "No Option Shaded"
729            pume = student.pume
730            pume.getContent().edit(mapping=dp)
731            #wftool.doActionFor(pume,'close')
732            pume.manage_setLocalRoles(sid, ['Owner',])
733            #student.getContent().createSubObjects()
734            dp = {}
735            if len(names) == 3:
736                dp['firstname'] = names[0].capitalize()
737                dp['middlename'] = names[1].capitalize()
738                dp['lastname'] = names[2].capitalize()
739            elif len(names) == 2:
740                dp['firstname'] = names[0].capitalize()
741                dp['middlename'] = ''
742                dp['lastname'] = names[1].capitalize()
743            else:
744                dp['firstname'] = ''
745                dp['middlename'] = ''
746                dp['lastname'] = jamb_name
747            dp['sex'] = jamb.get(csv_d['jamb_sex']) == 'F'
748            catalog_entry['sex'] = dp['sex']
749            catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
750            student.invokeFactory('StudentPersonal','personal')
751            per = student.personal
752            per_doc = per.getContent()
753            per_doc.edit(mapping = dp)
754            per.manage_setLocalRoles(sid, ['Owner',])
755            if jamb.get(csv_d['stud_status']) == "Admitted":
756                wftool.doActionFor(student,'pume_pass')
757                wftool.doActionFor(student,'admit')
758            else:
759                wftool.doActionFor(student,'pume_fail')
760                wftool.doActionFor(student,'reject_admission')
761                continue
762            #
763            # Clearance
764            #
765            student.invokeFactory('StudentClearance','clearance')
766            #wftool.doActionFor(student.clearance,'open')
767            dp = {'Title': 'Clearance/Eligibility Record'}
768            student.clearance.manage_setLocalRoles(sid, ['Owner',])
769            #
770            # Study Course
771            #
772            student.invokeFactory('StudentStudyCourse','study_course')
773            study_course = student.study_course
774            dsc = {}
775            from_certificate = ['title',
776                               'max_elect',
777                               'max_pass',
778                               'n_core',
779                               'nr_years',
780                               'probation_credits',
781                               'promotion_credits',
782                               'start_level',
783                              ]
784            for f in from_certificate:
785                dsc[f] = getattr(cert_doc,f)
786            dsc['faculty'] = jamb.get(csv_d['faculty'])
787            dsc['department'] = jamb.get(csv_d['department'])
788            catalog_entry['faculty'] = jamb.get(csv_d['faculty'])
789            catalog_entry['department'] = jamb.get(csv_d['department'])
790            catalog_entry['course'] = cert_id
791            catalog_entry['level'] = getattr(cert_doc,'start_level')
792            dsc['study_course'] = cert_id
793            dsc['entry_session'] = jamb.get(csv_d['session'])
794            study_course.getContent().edit(mapping=dsc)
795            self.students_catalog.addRecord(**catalog_entry)
796            if tr_count > 10:
797                if len(no_import) > 0:
798                    open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
799                             '\n'.join(no_import))
800                    no_import = []
801                em = '%d transactions commited\n' % tr_count
802                transaction.commit()
803                logger.info(em)
804                total += tr_count
805                tr_count = 0
806        open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
807                                                '\n'.join(no_import))
808        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
809    ###)
810
811    security.declareProtected(ModifyPortalContent,"importRegisteredStudents")###(
812    def importRegisteredStudents(self):
813        """load Registered Studentdata from CSV values"""
814        import transaction
815        import random
816        #from pdb import set_trace
817        wftool = self.portal_workflow
818        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
819        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
820        tr_count = 1
821        total = 0
822        #name = 'pume_results'
823        name = 'Registered'
824        table = self.registered_import
825        no_import = []
826        imported = []
827        logger = logging.getLogger('Import.%s' % name)
828        try:
829            registered = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
830        except:
831            logger.error('Error reading %s.csv' % name)
832            return
833        l = self.portal_catalog({'meta_type': "Certificate"})
834        certs = {}
835        cert_docs = {}
836        for f in l:
837            certs[f.getId] = f.getObject().getContent()
838        start = True
839        res = table()
840        regs = []
841        if len(res) > 0:
842            regs = [s.matric_no for s in res]
843        for student in registered:
844            if start:
845                start = False
846                logger.info('start loading from %s.csv' % name)
847                s = ','.join(['"(%s)"' % fn for fn in student.keys()])
848                imported.append(s)
849                no_import.append('%s,"Error"' % s)
850                format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
851                format_error = format + ',"%(Error)s"'
852                no_certificate = "no certificate %s" % format
853            if student.get('matric_no') == '':
854                student['Error'] = "Empty matric_no" 
855                no_import.append( format_error % student)
856                continue
857            if student.get('matric_no') in regs:
858                student['Error'] = "Duplicate" 
859                no_import.append( format_error % student)
860                continue
861            cert_id = makeCertificateCode(student.get('Coursemajorcode'))
862            if cert_id not in certs.keys():
863                student['Error'] = "No Certificate %s" % cert_id
864                no_import.append( format_error % student)
865                continue
866            try:
867                table.addRecord(**student)
868            except ValueError:
869                import pdb;pdb.set_trace()
870                student['Error'] = "Duplicate" 
871                no_import.append( format_error % student)
872                continue
873            regs.append(student.get('matric_no'))
874            imported.append(format % student)
875            tr_count += 1
876            if tr_count > 1000:
877                if len(no_import) > 0:
878                    open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
879                             '\n'.join(no_import))
880                    no_import = []
881                    imported = []
882                open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
883                                            '\n'.join(no_import))
884                em = '%d transactions commited total %s\n' % (tr_count,total)
885                transaction.commit()
886                logger.info(em)
887                total += tr_count
888                tr_count = 0
889        open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
890                                            '\n'.join(no_import))
891        open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
892                                                '\n'.join(no_import))
893        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
894    ###)
895
896    security.declareProtected(ModifyPortalContent,"importResults")###(
897    def importResults(self):
898        """load Registered Studentdata from CSV values"""
899        import transaction
900        import random
901        #from pdb import set_trace
902        wftool = self.portal_workflow
903        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
904        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
905        tr_count = 1
906        total = 0
907        #name = 'pume_results'
908        name = 'Results'
909        table = self.results_import
910        no_import = []
911        imported = []
912        logger = logging.getLogger('Import.%s' % name)
913        try:
914            results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
915        except:
916            logger.error('Error reading %s.csv' % name)
917            return
918        l = self.portal_catalog({'meta_type': "Course"})
919        courses = [f.getId for f in l]
920        start = True
921        res = table()
922        regs = []
923        if len(res) > 0:
924            regs = [s.key for s in res]
925        no_course = []
926        no_course_list = []
927        course_count = 0
928        for result in results:
929            if start:
930                start = False
931                logger.info('start loading from %s.csv' % name)
932                s = ','.join(['"(%s)"' % fn for fn in result.keys()])
933                imported.append(s)
934                no_import.append('%s,"Error"' % s)
935                format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
936                format_error = format + ',"%(Error)s"'
937                no_certificate = "no certificate %s" % format
938            course_id = result.get('CosCode')
939            key = result.get('matric_no')+course_id
940            if key == '':
941                result['Error'] = "Empty matric_no" 
942                no_import.append( format_error % result)
943                continue
944            if key in regs:
945                result['Error'] = "Duplicate" 
946                no_import.append( format_error % result)
947                continue
948            if course_id not in courses:
949                if course_id not in no_course:
950                    course_count +=1
951                    no_course.append(course_id)
952                    no_course_list.append('"%s"' % course_id)
953                    #result['Error'] = "No Course"
954                    #logger.info(format_error % result)
955            result['key'] = key
956            try:
957                table.addRecord(**result)
958            except ValueError:
959                import pdb;pdb.set_trace()
960                result['Error'] = "Duplicate" 
961                no_import.append( format_error % result)
962                continue
963            regs.append(key)
964            imported.append(format % result)
965            tr_count += 1
966            if tr_count > 1000:
967                if len(no_import) > 0:
968                    open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
969                             '\n'.join(no_import))
970                    no_import = []
971                open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
972                                            '\n'.join(imported))
973                imported = []
974                if no_course_list:
975                    open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
976                                            '\n'.join(no_course_list))
977                    no_course_list = []
978                em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
979                transaction.commit()
980                logger.info(em)
981                total += tr_count
982                tr_count = 0
983        open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
984                                            '\n'.join(imported))
985        open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
986                                                '\n'.join(no_import))
987        if no_course_list:
988            open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
989                                    '\n'.join(no_course_list))
990        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
991    ###)
992
993    security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
994    def updateStudyCourse(self):
995        """update StudyCourse from CSV values"""
996        import transaction
997        import random
998        from pdb import set_trace
999        wftool = self.portal_workflow
1000        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1001        csv_d = {'jamb_reg_no': "RegNumber",
1002                 'jamb_lastname': "Name",
1003                 'session': "Session",
1004                 'pume_tot_score': "PUME SCORE",
1005                 'jamb_score': "JambScore",
1006                 'jamb_sex': "Sex",
1007                 'jamb_state': "State",
1008##                 'jamb_first_cos': "AdminCourse",
1009                 'faculty': "AdminFaculty",
1010                 'course_code': "AdmitCoscode",
1011                 'stud_status':"AdmitStatus",
1012                 'department': "AdmitDept",
1013                 'jamb_lga': "LGA",
1014                 'app_email': "email",
1015                 'app_mobile': "PhoneNumbers",
1016                 }
1017        csv_fields = [f[1] for f in csv_d.items()]
1018        tr_count = 0
1019        total = 0
1020        #name = 'pume_results'
1021        name = 'StudyCourseChange'
1022        no_import = []
1023        s = ','.join(['"(%s)"' % fn for fn in csv_fields])
1024        no_import.append('"Error",%s' % s)
1025        format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1026        no_certificate = "no certificate %s" % format
1027        open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1028                    '\n'.join(no_import))
1029        logger = logging.getLogger('Import.%s' % name)
1030        logger.info('Start loading from %s.csv' % name)
1031        l = self.portal_catalog({'meta_type': "Certificate"})
1032        try:
1033            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1034        except:
1035            logger.error('Error reading %s.csv' % name)
1036            return
1037        for jamb in result:
1038            jamb['Error'] = "Processing "
1039            logger.info(format % jamb)
1040            jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1041            res = self.portal_catalog({'portal_type': "StudentApplication",
1042                                     'SearchableText': jamb_reg_no })
1043            if not res:
1044                em = 'Student with RegNo %s does not exists\n' % jamb_reg_no
1045                logger.info(em)
1046                jamb['Error'] = "Student not exists"
1047                no_import.append(format % jamb)
1048                continue
1049            sid = res[0].getPath().split('/')[-2]
1050            cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
1051            res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
1052            if not res:
1053                em = 'No Certificate with ID %s \n' % cert_id
1054                logger.info(em)
1055                jamb['Error'] = "No Certificate %s" % cert_id
1056                no_import.append( format % jamb)
1057                continue
1058            cert_brain = res[0]
1059            catalog_entry = {}
1060            student = getattr(self,sid)
1061            #
1062            # Study Course
1063            #
1064            study_course = student.study_course
1065            dsc = {}
1066            cert_pl = cert_brain.getPath().split('/')
1067            catalog_entry['id'] = sid
1068            catalog_entry['faculty'] = cert_pl[-4]
1069            catalog_entry['department'] = cert_pl[-3]
1070            catalog_entry['course'] = cert_id
1071            dsc['study_course'] = cert_id
1072            study_course.getContent().edit(mapping=dsc)
1073            self.students_catalog.modifyRecord(**catalog_entry)
1074            if tr_count > 10:
1075                if len(no_import) > 1:
1076                    open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
1077                             '\n'.join(no_import))
1078                    no_import = []
1079                em = '%d transactions commited\n' % tr_count
1080                transaction.commit()
1081                logger.info(em)
1082                total += tr_count
1083                tr_count = 0
1084            tr_count += 1
1085        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1086    ###)
1087
1088    security.declareProtected(ModifyPortalContent,"OLDloadPumeResultsFromCSV")###(
1089    def OLDloadPumeResultsFromCSV(self):
1090        """load Fulltime Studentdata from CSV values"""
1091        import transaction
1092        import random
1093        wftool = self.portal_workflow
1094        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1095        csv_d = {'jamb_reg_no': "JAMBRegno",
1096                 'jamb_lastname': "Name",
1097                 'pume_options': "Options",
1098                 'session': "Session",
1099                 'days': "Days",
1100                 'response': "Responce",
1101                 'wrong': "Wrong",
1102                 'pume_eng_score': "EngScore",
1103                 'pume_gen_score': "GenScore",
1104                 'pume_tot_score': "Score",
1105                 'batch': "Batch",
1106                 'serial': "SerialNo",
1107                 'jamb_score': "JambScore",
1108                 'omitted':"Omitted",
1109                 'search_key': "SearchKey",
1110                 'jamb_sex': "Sex",
1111                 'fac1': "Fac1",
1112                 'fac2': "Fac2",
1113                 'jamb_first_cos': "CourseofStudy",
1114                 'stud_status':"StudStatus",
1115                 'registered': "Registered",
1116                 'jamb_state': "State",
1117                 'eng_fail': "EngFail",
1118                 'gen_fail': "GenFail",
1119                 'un_ans_eng': "UnAnsEng",
1120                 'un_ans_eng': "UnAnsGen",
1121                 'total_ans': "TotalUnAns",
1122                 'dept': "Dept",
1123                 'jamb_second_cos': "Course2",
1124                 'jamb_third_cos': "course3",
1125                 }
1126        csv_fields = [f[1] for f in csv_d.items()]
1127        tr_count = 0
1128        name = 'pume_results'
1129        no_import = []
1130        s = ','.join(['"(%s)"' % fn for fn in csv_fields])
1131        no_import.append('%s\n' % s)
1132        logger = logging.getLogger('Import.%s' % name)
1133        logger.info('Start loading from %s.csv' % name)
1134        try:
1135            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1136        except:
1137            logger.error('Error reading %s.csv' % name)
1138            return
1139        for jamb in result:
1140            format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1141            processing = "processing %s" % format
1142            logger.info(processing % jamb)
1143            jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1144            #import pdb;pdb.set_trace()
1145            res = self.portal_catalog({'portal_type': "StudentApplication",
1146                                     'jamb_reg_no': jamb_reg_no })
1147            if res:
1148                em = 'Student with REG-NO %s already exists\n' % jamb_reg_no
1149                logger.info(em)
1150                no_import.append(em)
1151                no_import.append(format % jamb)
1152                continue
1153            cert_id = jamb.get(csv_d['jamb_first_cos']).upper()
1154            res = self.portal_catalog({'portal_type': "Certificate",
1155                                     'id': cert_id })
1156            if len(res) < 1:
1157                em = 'No Certificate with ID %s \n' % cert_id
1158                logger.info(em)
1159                no_import.append(em)
1160                no_import.append(format % jamb)
1161                continue
1162            cert = res[0].getObject()
1163            cert_path = res[0].getPath()
1164            cert_doc = cert.getContent()
1165            jamb_name = jamb.get(csv_d['jamb_lastname'])
1166            jamb_name.replace('>','')
1167            names = jamb_name.split()
1168            letter = names[-1][0].upper()
1169            sid = self.generateStudentId(letter)
1170            not_created = True
1171            while not_created:
1172                try:
1173                    students_folder.invokeFactory('Student', sid)
1174                    not_created = False
1175                except BadRequest:
1176                    sid = self.generateStudentId(letter)
1177            logger.info('%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
1178            student = getattr(self,sid)
1179            student.manage_setLocalRoles(sid, ['Owner',])
1180            student.invokeFactory('StudentClearance','clearance')
1181            #wftool.doActionFor(student.clearance,'open')
1182            dp = {'Title': 'Clearance/Eligibility Record'}
1183            student.clearance.manage_setLocalRoles(sid, ['Owner',])
1184            student.invokeFactory('StudentPume','pume')
1185            dp = {'Title': 'Pume Data'}
1186            student.invokeFactory('StudentApplication','application')
1187            da = {'Title': 'Application Data'}
1188            da["jamb_lastname"] = jamb_name
1189            da_fields = ('jamb_reg_no',
1190                         'jamb_sex',
1191                         'jamb_state',
1192                         'jamb_score',
1193                         'jamb_first_cos',
1194                         'jamb_sex',
1195                         'jamb_state',
1196                         'jamb_first_cos',
1197                         'jamb_second_cos',
1198                         )
1199            for f in da_fields:
1200                da[f] = jamb.get(csv_d[f])
1201            app = student.application
1202            app.getContent().edit(mapping=da)
1203            app.manage_setLocalRoles(sid, ['Owner',])
1204            #wftool.doActionFor(app,'close')
1205            dp_fields = (
1206                         'pume_eng_score',
1207                         'pume_gen_score',
1208                         'pume_tot_score',
1209                         )
1210            for f in dp_fields:
1211                dp[f] = float(jamb.get(csv_d[f]))
1212            pume = student.pume
1213            pume.getContent().edit(mapping=dp)
1214            #wftool.doActionFor(pume,'close')
1215            pume.manage_setLocalRoles(sid, ['Owner',])
1216            #
1217            # Study Course
1218            #
1219            student.invokeFactory('StudentStudyCourse','study_course')
1220            study_course = student.study_course
1221            dsc = {}
1222            from_certificate = ['title',
1223                               'max_elect',
1224                               'max_pass',
1225                               'n_core',
1226                               'nr_years',
1227                               'probation_credits',
1228                               'promotion_credits',
1229                               'start_level',
1230                              ]
1231            for f in from_certificate:
1232                dsc[f] = getattr(cert_doc,f)
1233            cpl = cert_path.split('/')
1234            dsc['faculty'] = cpl[-4]
1235            dsc['department'] = cpl[-3]
1236            dsc['study_course'] = cert_id
1237            dsc['entry_session'] = jamb.get(csv_d['session'])
1238            study_course.getContent().edit(mapping=dsc)
1239            student.getContent().createSubObjects()
1240            if dp['pume_tot_score']>49:
1241                wftool.doActionFor(student,'pume_pass')
1242                wftool.doActionFor(student,'admit')
1243            else:
1244                wftool.doActionFor(student,'pume_fail')
1245                wftool.doActionFor(student,'reject_admission')
1246            if len(no_import) > 1:
1247                open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1248                     '\n'.join(no_import))
1249        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1250    ###)
1251
1252    security.declareProtected(ModifyPortalContent,"loadFullTimeStudentsResultsFromCSV") ###(
1253    def loadFullTimeStudentsResultsFromCSV(self):
1254        """load Fulltime Studentdata from CSV values"""
1255        #return
1256        level_wf_actions = {}
1257        level_wf_actions["SUCCESSFUL STUDENT"] = "pass_A"
1258        level_wf_actions["STUDENT WITH CARRYOVER COURSES"] = "pass_B"
1259        level_wf_actions["STUDENT FOR PROBATION"] = "probate_C"
1260        level_wf_actions["STUDENT ON PROBATION/TRANSFER"] = "reject_D"
1261        import transaction
1262        wftool = self.portal_workflow
1263        tr_count = 0
1264        name = 'short_full_time_results_2004_2005'
1265        no_import = False
1266        if not no_import:
1267            no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
1268            no_import.write('"Matnumber","CosCode","Ansbook","CosStuatus","Session","Mat_Cos","Score","CarryLevel","Grade","Weight","Semster","Verdict","Level","id","GPA"\n')
1269        logger = logging.getLogger('import.%s' % name)
1270        logger.info('Start loading from %s.csv' % name)
1271        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1272        try:
1273            results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1274        except:
1275            logger.error('Error reading %s.csv' % name)
1276            return
1277        l = self.portal_catalog({'meta_type': "Course"})
1278        courses = {}
1279        for c in l:
1280            courses[c.id] = c.getObject()
1281        level_changed = False
1282        student_changed = False
1283        sid = ''
1284        #import pdb;pdb.set_trace()
1285        for result in results:
1286            temp_sid = result.get('Matnumber')
1287            if temp_sid != sid:
1288                student_changed = True
1289                res = self.portal_catalog({'meta_type': "StudentClearance",
1290                                         'SearchableText': temp_sid })
1291                if not res:
1292                    em = 'Student with ID %(Matnumber)s not found\n' % result
1293                    logger.info(em)
1294                    no_import.write(em)
1295                    no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
1296                    continue
1297                elif len(res) > 1:
1298                    em = 'More than one Student with ID %(Matnumber)s found\n' % result
1299                    logger.info(em)
1300                    no_import.write(em)
1301                    no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
1302                    continue
1303                sid = temp_sid
1304                sf = res[0].getObject().aq_parent
1305                sc = getattr(sf,'study_course')
1306                level = ''
1307            else:
1308                student_changed = False
1309            course = result.get('CosCode')
1310            if course not in courses.keys():
1311                em = 'Course with ID %(CosCode)s not found\n' % result
1312                logger.info(em)
1313                no_import.write(em)
1314                no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
1315                continue
1316            course_doc = courses[course].getContent()
1317            temp_level = result.get('Level')
1318            student_id = sf.getId()
1319            result['StudentId'] = student_id
1320            if temp_level != level:
1321                try:
1322                    int(temp_level)
1323                except:
1324                    em = 'Result with ID %(Matnumber)s Course %(CosCode)s Level is empty\n' % result
1325                    logger.info(em)
1326                    no_import.write(em)
1327                    no_import.write('"%(Matnumber)s","%(CosCode)s","%(Ansbook)s","%(CosStuatus)s","%(Session)s","%(Mat_Cos)s","%(Score)s","%(CarryLevel)s","%(Grade)s","%(Weight)s","%(Semster)s","%(Verdict)s","%(Level)s","%(id)s","%(GPA)s"\n' % result)
1328                    continue
1329                level_changed = True
1330                if 'dlev' in vars().keys():
1331                    wftool.doActionFor(l,level_wf_actions[dlev['verdict']])
1332                level = temp_level
1333                l = getattr(sc,level,None)
1334                if l is None:
1335                    logger.info('Creating Level %(Level)s for %(StudentId)s %(Matnumber)s' % result)
1336                    sc.invokeFactory('StudentStudyLevel', level)
1337                    l = getattr(sc, level)
1338                    l.manage_setLocalRoles(student_id, ['Owner',])
1339            else:
1340                level_changed = False
1341            cr = getattr(l,course,None)
1342            if cr is None:
1343                logger.info('Creating Course %(CosCode)s for %(StudentId)s %(Matnumber)s in Level %(Level)s' % result)
1344                l.invokeFactory('StudentCourseResult',course)
1345            cr = getattr(l,course)
1346            dcr = {}
1347            from_course = ['title',
1348                           'credits',
1349                           'passmark',
1350                           ]
1351            for f in from_course:
1352                dcr[f] = getattr(course_doc,f)
1353            dlev = {}
1354            dcr['ansbook'] = result.get('Ansbook')
1355            dcr['semester'] = getInt(result.get('Semster'))
1356            dcr['status'] = result.get('CosStuatus')
1357            dcr['score'] = getInt(result.get('Score'))
1358            dlev['session'] = result.get('Session')
1359            dcr['carry_level'] = result.get('CarryLevel')
1360            dcr['grade'] = result.get('Grade')
1361            dcr['weight'] = result.get('Weight')
1362            dlev['verdict'] = result.get('Verdict')
1363            dcr['import_id'] = result.get('id')
1364            gpa = result.get('GPA').replace(',','.')
1365            dlev['imported_gpa'] = getFloat(gpa)
1366            cr.getContent().edit(mapping = dcr)
1367            cr.manage_setLocalRoles(student_id, ['Owner',])
1368            l.getContent().edit(mapping = dlev)
1369            if tr_count > MAX_TRANS:
1370                transaction.commit()
1371                tr_count = 0
1372            tr_count += 1
1373            wftool.doActionFor(cr,'close')
1374        wftool.doActionFor(l,level_wf_actions[dlev['verdict']])
1375        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1376
1377###)
1378
1379    security.declareProtected(ModifyPortalContent,"loadJAMBFromCSV")###(
1380    def loadJAMBFromCSV(self):
1381        """load JAMB data from CSV values"""
1382        #return
1383        students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
1384        import transaction
1385        tr_count = 0
1386        name = 'SampleJAMBDataII'
1387        wftool = self.portal_workflow
1388        no_import = False
1389        if not no_import:
1390            no_import = open("%s/import/%s_not_imported.csv" % (i_home,name),"w")
1391            no_import.write('REG-NO,NAME,SEX,STATE,LGA,ENG-SCORE,SUBJ1,SUBJ1-SCORE,SUBJ2,SUBJ2-SCORE,SUBJ3,SUBJ3-SCORE,AGGREGATE,UNIV1,FACULTY1,COURSE1,UNIV2,FACULTY2,COURSE2')
1392        logger = logging.getLogger('Import.%s' % name)
1393        logger.info('Start loading from %s.csv' % name)
1394        try:
1395            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1396        except:
1397            logger.error('Error reading %s.csv' % name)
1398            return
1399        for jamb in result:
1400            logger.info('processing %(REG-NO)s,%(NAME)s,%(SEX)s,%(STATE)s,%(LGA)s,%(ENG-SCORE)s,%(SUBJ1)s,%(SUBJ1-SCORE)s,%(SUBJ2)s,%(SUBJ2-SCORE)s,%(SUBJ3)s,%(SUBJ3-SCORE)s,%(AGGREGATE)s,%(UNIV1)s,%(FACULTY1)s,%(COURSE1)s,%(UNIV2)s,%(FACULTY2)s,%(COURSE2)s\n' % jamb)
1401            jamb_reg_no = jamb.get('REG-NO')
1402            res = self.portal_catalog({'meta_type': "StudentApplication",
1403                                     'jamb_reg_no': jamb_reg_no })
1404            if res:
1405                em = 'Student with REG-NO %(REG-NO)s already exists\n' % jamb
1406                logger.info(em)
1407                no_import.write(em)
1408                no_import.write('%(REG-NO)s,%(NAME)s,%(SEX)s,%(STATE)s,%(LGA)s,%(ENG-SCORE)s,%(SUBJ1)s,%(SUBJ1-SCORE)s,%(SUBJ2)s,%(SUBJ2-SCORE)s,%(SUBJ3)s,%(SUBJ3-SCORE)s,%(AGGREGATE)s,%(UNIV1)s,%(FACULTY1)s,%(COURSE1)s,%(UNIV2)s,%(FACULTY2)s,%(COURSE2)s\n' % jamb)
1409                continue
1410            jamb_name = jamb.get("NAME")
1411            jamb_name.replace('>','')
1412            names = jamb_name.split()
1413            letter = names[-1][0].upper()
1414            sid = self.generateStudentId(letter)
1415            not_created = True
1416            while not_created:
1417                try:
1418                    students_folder.invokeFactory('Student', sid)
1419                    not_created = False
1420                except BadRequest:
1421                    sid = self.generateStudentId(letter)
1422            logger.info('%(tr_count)s: Creating Student with ID %(sid)s REG-NO %(jamb_reg_no)s ' % vars())
1423            student = getattr(self,sid)
1424            student.manage_setLocalRoles(sid, ['Owner',])
1425            student.invokeFactory('StudentApplication','application')
1426            da = {'Title': 'Application Data'}
1427            da["jamb_reg_no"] = jamb.get("REG-NO")
1428            da["jamb_lastname"] = jamb_name
1429            da["jamb_sex"] = jamb.get("SEX")
1430            da["jamb_state"] = jamb.get("STATE")
1431            da["jamb_lga"] = jamb.get("LGA")
1432            da["jamb_score"] = jamb.get("AGGREGATE")
1433            da["jamb_first_cos"] = jamb.get("COURSE1")
1434            da["jamb_second_cos"] = jamb.get("COURSE2")
1435            da["jamb_first_uni"] = jamb.get("UNIV1")
1436            da["jamb_second_uni"] = jamb.get("UNIV2")
1437            app = student.application
1438            app_doc = app.getContent()
1439            app_doc.edit(mapping=da)
1440            #wftool.doActionFor(app,'open',dest_container=app)
1441            app.manage_setLocalRoles(sid, ['Owner',])
1442            student.getContent().createSubObjects()
1443        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1444    ###)
1445
1446
1447    security.declareProtected(View,"fixOwnership")
1448    def fixOwnership(self):
1449        """fix Ownership"""
1450        for s in self.portal_catalog(meta_type = 'Student'):
1451            student = s.getObject()
1452            sid = s.getId
1453            import pdb;pdb.set_trace()
1454            student.application.manage_setLocalRoles(sid, ['Owner',])
1455            student.personal.manage_setLocalRoles(sid, ['Owner',])
1456
1457    security.declareProtected(View,"Title")
1458    def Title(self):
1459        """compose title"""
1460        return "Student Section"
1461
1462    def generateStudentId(self,letter): ###(
1463        import random
1464        r = random
1465        if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
1466            letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
1467        students = self.portal_catalog(meta_type = "StudentsFolder")[-1]
1468        sid = "%c%d" % (letter,r.randint(99999,1000000))
1469        while hasattr(students, sid):
1470            sid = "%c%d" % (letter,r.randint(99999,1000000))
1471        return sid
1472        #return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
1473    ###)
1474
1475InitializeClass(StudentsFolder)
1476
1477def addStudentsFolder(container, id, REQUEST=None, **kw):
1478    """Add a Student."""
1479    ob = StudentsFolder(id, **kw)
1480    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1481###)
1482
1483class Student(CPSDocument): ###(
1484    """
1485    WAeUP Student container for the various student data
1486    """
1487    meta_type = 'Student'
1488    portal_type = meta_type
1489    security = ClassSecurityInfo()
1490
1491    security.declareProtected(View,"Title")
1492    def Title(self):
1493        """compose title"""
1494        reg_nr = self.getId()[1:]
1495        data = getattr(self,'personal',None)
1496        if data:
1497            content = data.getContent()
1498            return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
1499        data = getattr(self,'application',None)
1500        if data:
1501            content = data.getContent()
1502            return "%s" % (content.jamb_lastname)
1503        return self.title
1504
1505    security.declarePrivate('makeStudentMember') ###(
1506    def makeStudentMember(self,sid,password='uNsEt'):
1507        """make the student a member"""
1508        membership = self.portal_membership
1509        membership.addMember(sid,
1510                             password ,
1511                             roles=('Member',
1512                                     'Student',
1513                                     ),
1514                             domains='',
1515                             properties = {'memberareaCreationFlag': False,
1516                                           'homeless': True},)
1517        member = membership.getMemberById(sid)
1518        self.portal_registration.afterAdd(member, sid, password, None)
1519        self.manage_setLocalRoles(sid, ['Owner',])
1520
1521###)
1522
1523    security.declareProtected(View,'createSubObjects') ###(
1524    def createSubObjects(self):
1525        """make the student a member"""
1526        dp = {'Title': 'Personal Data'}
1527        app_doc = self.application.getContent()
1528        names = app_doc.jamb_lastname.split()
1529        if len(names) == 3:
1530            dp['firstname'] = names[0].capitalize()
1531            dp['middlename'] = names[1].capitalize()
1532            dp['lastname'] = names[2].capitalize()
1533        elif len(names) == 2:
1534            dp['firstname'] = names[0].capitalize()
1535            dp['lastname'] = names[1].capitalize()
1536        else:
1537            dp['lastname'] = app_doc.jamb_lastname
1538        dp['sex'] = app_doc.jamb_sex == 'F'
1539        dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1540        proxy = self.aq_parent
1541        proxy.invokeFactory('StudentPersonal','personal')
1542        per = proxy.personal
1543        per_doc = per.getContent()
1544        per_doc.edit(mapping = dp)
1545        per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1546        #self.portal_workflow.doActionFor(per,'open',dest_container=per)
1547
1548###)
1549
1550InitializeClass(Student)
1551
1552def addStudent(container, id, REQUEST=None, **kw):
1553    """Add a Student."""
1554    ob = Student(id, **kw)
1555    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1556
1557###)
1558
1559class StudentAccommodation(CPSDocument): ###(
1560    """
1561    WAeUP Student container for the various student data
1562    """
1563    meta_type = 'StudentAccommodation'
1564    portal_type = meta_type
1565    security = ClassSecurityInfo()
1566
1567    security.declareProtected(View,"Title")
1568    def Title(self):
1569        """compose title"""
1570        content = self.getContent()
1571        #return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1572        return "Accommodation Data for Session %s" % content.session
1573
1574
1575InitializeClass(StudentAccommodation)
1576
1577def addStudentAccommodation(container, id, REQUEST=None, **kw):
1578    """Add a Students personal data."""
1579    ob = StudentAccommodation(id, **kw)
1580    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1581
1582###)
1583
1584class StudentPersonal(CPSDocument): ###(
1585    """
1586    WAeUP Student container for the various student data
1587    """
1588    meta_type = 'StudentPersonal'
1589    portal_type = meta_type
1590    security = ClassSecurityInfo()
1591
1592    security.declareProtected(View,"Title")
1593    def Title(self):
1594        """compose title"""
1595        content = self.getContent()
1596        #return "Personal Data for %s %s" % (content.firstname,content.lastname)
1597        return "Personal Data"
1598
1599
1600InitializeClass(StudentPersonal)
1601
1602def addStudentPersonal(container, id, REQUEST=None, **kw):
1603    """Add a Students personal data."""
1604    ob = StudentPersonal(id, **kw)
1605    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1606
1607###)
1608
1609class StudentClearance(CPSDocument): ###(
1610    """
1611    WAeUP Student container for the various student data
1612    """
1613    meta_type = 'StudentClearance'
1614    portal_type = meta_type
1615    security = ClassSecurityInfo()
1616
1617    security.declareProtected(View,"Title")
1618    def Title(self):
1619        """compose title"""
1620        content = self.getContent()
1621        #return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1622        return "Clearance/Eligibility Record"
1623
1624
1625InitializeClass(StudentClearance)
1626
1627def addStudentClearance(container, id, REQUEST=None, **kw):
1628    """Add a Students personal data."""
1629    ob = StudentClearance(id, **kw)
1630    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1631
1632###)
1633
1634class StudentStudyLevel(CPSDocument): ###(
1635    """
1636    WAeUP Student container for the various student data
1637    """
1638    meta_type = 'StudentStudyLevel'
1639    portal_type = meta_type
1640    security = ClassSecurityInfo()
1641
1642    security.declareProtected(View,"Title")
1643    def Title(self):
1644        """compose title"""
1645        return "Level %s" % self.aq_parent.getId()
1646
1647##    security.declarePublic("gpa")
1648##    def gpa(self):
1649##        """calculate the gpa"""
1650##        sum = 0
1651##        course_count = 0
1652##        for sc in self.objectValues():
1653##            result = sc.getContent()
1654##            if not result.grade:
1655##                continue
1656##            res = self.portal_catalog({'meta_type': 'Course',
1657##                                          'id': sc.aq_parent.id})
1658##            if len(res) != 1:
1659##                continue
1660##            course = res[0].getObject().getContent()
1661##            sum += course.credits * ['F','E','D','C','B','A'].index(result.grade)
1662##            course_count += 1
1663##        if course_count:
1664##            return sum/course_count
1665##        return 0.0
1666
1667InitializeClass(StudentStudyLevel)
1668
1669def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1670    """Add a Students personal data."""
1671    ob = StudentStudyLevel(id, **kw)
1672    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1673
1674###)
1675
1676class StudentStudyCourse(CPSDocument): ###(
1677    """
1678    WAeUP Student container for the various student data
1679    """
1680    meta_type = 'StudentStudyCourse'
1681    portal_type = meta_type
1682    security = ClassSecurityInfo()
1683
1684    security.declareProtected(View,"Title")
1685    def Title(self):
1686        """compose title"""
1687        content = self.getContent()
1688        return "Study Course"
1689
1690
1691InitializeClass(StudentStudyCourse)
1692
1693def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1694    """Add a Students personal data."""
1695    ob = StudentStudyCourse(id, **kw)
1696    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1697
1698###)
1699
1700class StudentApplication(CPSDocument): ###(
1701    """
1702    WAeUP Student container for the various student data
1703    """
1704    meta_type = 'StudentApplication'
1705    portal_type = meta_type
1706    security = ClassSecurityInfo()
1707
1708    security.declareProtected(View,"Title")
1709    def Title(self):
1710        """compose title"""
1711        return "Application Data"
1712
1713
1714InitializeClass(StudentApplication)
1715
1716def addStudentApplication(container, id, REQUEST=None, **kw):
1717    """Add a Students eligibility data."""
1718    ob = StudentApplication(id, **kw)
1719    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1720###)
1721
1722
1723class StudentPume(CPSDocument): ###(
1724    """
1725    WAeUP Student container for the various student data
1726    """
1727    meta_type = 'StudentPume'
1728    portal_type = meta_type
1729    security = ClassSecurityInfo()
1730
1731    security.declareProtected(View,"Title")
1732    def Title(self):
1733        """compose title"""
1734        return "PUME Results"
1735
1736
1737InitializeClass(StudentPume)
1738
1739def addStudentPume(container, id, REQUEST=None, **kw):
1740    """Add a Students PUME data."""
1741    ob = StudentPume(id, **kw)
1742    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1743###)
1744
1745##class StudentSemester(CPSDocument): ###(
1746##    """
1747##    WAeUP StudentSemester containing the courses and students
1748##    """
1749##    meta_type = 'StudentSemester'
1750##    portal_type = meta_type
1751##    security = ClassSecurityInfo()
1752##
1753##InitializeClass(StudentSemester)
1754##
1755##def addStudentSemester(container, id, REQUEST=None, **kw):
1756##    """Add a StudentSemester."""
1757##    ob = StudentSemester(id, **kw)
1758##    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1759##
1760#####)
1761
1762##class Semester(CPSDocument): ###(
1763##    """
1764##    WAeUP Semester containing the courses and students
1765##    """
1766##    meta_type = 'Semester'
1767##    portal_type = meta_type
1768##    security = ClassSecurityInfo()
1769##
1770##InitializeClass(Semester)
1771##
1772##def addSemester(container, id, REQUEST=None, **kw):
1773##    """Add a Semester."""
1774##    ob = Semester(id, **kw)
1775##    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1776##
1777#####)
1778
1779class StudentCourseResult(CPSDocument): ###(
1780    """
1781    WAeUP StudentCourseResult
1782    """
1783    meta_type = 'StudentCourseResult'
1784    portal_type = meta_type
1785    security = ClassSecurityInfo()
1786
1787    def getCourseEntry(self,cid):
1788        res = self.portal_catalog({'meta_type': "Course",
1789                                           'id': cid})
1790        if res:
1791            return res[-1]
1792        else:
1793            return None
1794
1795    security.declareProtected(View,"Title")
1796    def Title(self):
1797        """compose title"""
1798        cid = self.aq_parent.getId()
1799        ce = self.getCourseEntry(cid)
1800        if ce:
1801            return "%s" % ce.Title
1802        return "No course with id %s" % cid
1803
1804InitializeClass(StudentCourseResult)
1805
1806def addStudentCourseResult(container, id, REQUEST=None, **kw):
1807    """Add a StudentCourseResult."""
1808    ob = StudentCourseResult(id, **kw)
1809    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1810###)
1811
1812# Backward Compatibility StudyLevel
1813
1814from Products.WAeUP_SRP.Academics import StudyLevel
1815
1816from Products.WAeUP_SRP.Academics import addStudyLevel
1817
Note: See TracBrowser for help on using the repository browser.