source: WAeUP_SRP/trunk/Students.py @ 1831

Last change on this file since 1831 was 1829, checked in by Henrik Bettermann, 17 years ago

fixed

  • Property svn:keywords set to Id
File size: 56.8 KB
Line 
1#-*- mode: python; mode: fold -*-
2# $Id: Students.py 1829 2007-05-30 03:50:14Z henrik $
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
18from Products.AdvancedQuery import Eq, Between, Le,In
19import DateTime
20import logging
21import csv,re,os
22import Globals
23p_home = Globals.package_home(globals())
24i_home = Globals.INSTANCE_HOME
25MAX_TRANS = 1000
26from urllib import urlencode
27
28import DateTime
29#import PIL.Image
30from StringIO import StringIO
31
32def makeCertificateCode(code): ###(
33    code = code.replace('.','')
34    code = code.replace('(','')
35    code = code.replace(')','')
36    code = code.replace('/','')
37    code = code.replace(' ','')
38    code = code.replace('_','')
39    return code
40
41###)
42
43def response_write(response,s):
44    response.setHeader('Content-type','text/html; charset=ISO-8859-15')
45    while s.find('<') > -1:
46        s = s.replace('<','&lt;')
47    while s.find('>') > -1:
48        #from pdb import set_trace;set_trace()
49        s = s.replace('>','&gt;')
50    response.write("%s<br>\n" % s)
51
52def getInt(s): ###(
53    try:
54        return int(s)
55    except:
56        return 0
57
58def getFloat(s):
59    try:
60        return float(s)
61    except:
62        return 0.0
63
64###)
65
66def getStudentByRegNo(self,reg_no): ###(
67    """search student by JAMB Reg No and return StudentFolder"""
68    search = ZCatalog.searchResults(self.portal_catalog,{'meta_type': 'StudentApplication',
69                                  'SearchableText': reg_no,
70                                  })
71    if len(search) < 1:
72        return None
73    return search[0].getObject().aq_parent
74
75###)
76
77def checkJambNo(jnr):
78    try:
79        if len(jnr) != 10:
80            return False
81    except:
82        return False
83    try:
84        int(jnr[:8])
85        return True
86    except:
87        return False
88
89class StudentsFolder(CPSDocument): ###(
90    """
91    WAeUP container for the various WAeUP containers data
92    """
93    meta_type = 'StudentsFolder'
94    portal_type = meta_type
95    security = ClassSecurityInfo()
96
97    security.declareProtected(ModifyPortalContent,"loadPumeResultsFromCSV")###(
98    def loadPumeResultsFromCSV(self):
99        """load Fulltime Studentdata from CSV values into pumeresults catalog"""
100        import transaction
101        import random
102##        csv_d = {'jamb_reg_no': "RegNumber", ###(
103##                 'status': "Admission Status",
104##                 'name': "Name",
105##                 'score': "Score",
106##                 'sex': "Sex",
107##                 'faculty': "Faculty",
108##                 'department': "Dept",
109##                 'course': "Course",
110##                 'course_code_org': "Course Code",
111##                 }
112###)
113##        csv_d = {'jamb_reg_no': "JAMBRegno",
114##                'name': "Name",
115##                'score': "Score",
116##                 'sex': "Sex",
117##                 'course': "Course",
118##                 'faculty': "Faculty",
119##                 'department': "Dept",
120##                 'course_code_org': "Course Code",
121##                 'status': "Admission Status",
122##                 'result_type': None,
123##                 }
124
125        csv_d = {'jamb_reg_no': "reg_no",
126                 'name': "fullname",
127                 'score': "pume_score",
128                 'sex': "sex",
129                 'course': "study_course",
130                 'course_code_org': "study_course",
131                 'status': "admission_status",
132                 'result_type': "entry_mode",
133                 }
134
135        csv_fields = [f[1] for f in csv_d.items() if f[1]]
136        tr_count = 0
137        total = 0
138        #name = 'pup_new'
139        #name = 'pup_update'
140        name = 'Admitted'
141        update = name.endswith('update')
142        no_import = []
143        ok_import = []
144        ok_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_d.keys()]))
145        no_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_fields]))
146        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
147        ok_import_name = "%s/import/%s_imported_%s.csv" % (i_home,name,current)
148        #open(ok_import_name,"w").write('\n'.join(no_import))
149        no_import_name = "%s/import/%s_not_imported_%s.csv" % (i_home,name,current)
150        #open(no_import_name,"w").write('\n'.join(no_import))
151        logger = logging.getLogger('Import.%s' % name)
152        starttime = DateTime.now()
153        logger.info('Start loading from %s.csv' % name)
154        try:
155            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
156        except:
157            logger.error('Error reading %s.csv' % name)
158            return
159        pume = self.portal_pumeresults
160        format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
161        import_format = ','.join(['"%%(%s)s"' % fn for fn in csv_d.keys()])
162        eduplicate = '%s,"duplicate"' % format
163        einvalidjamb = '%s,"invalid JambRegNo"' % format
164        added = 'added ,%s' % format
165        #from pdb import set_trace;set_trace()
166        for jamb in result:
167            dict = {}
168            for f,fn in csv_d.items():
169                dict[f] = jamb.get(csv_d[f])
170            dict['result_type'] = 'CEST'
171            jnr = jamb.get(csv_d['jamb_reg_no'])
172            #if not checkJambNo(jnr):
173            #    logger.info(einvalidjamb % jamb)
174            #    dd = {}
175            #    for f,fn in csv_d.items():
176            #        dd[fn] = getattr(data,f)
177            #        no_import.append(eduplicate % dd)
178            #        no_import.append(eduplicate % jamb)
179            #    continue
180            res = pume(jamb_reg_no=jnr)
181            if len(res) > 0:
182                if update:
183                    try:
184                        pume.modifyRecord(**dict)
185                    except ValueError:
186                        logger.info(eduplicate % jamb)
187                        continue
188                    except KeyError:
189                        pume.addRecord(**dict)
190                        logger.info(added % jamb)
191                        continue
192                else:
193                    data = res[0]
194                    if data.name != jamb.get(csv_d['name']):
195                        #set_trace()
196                        logger.info(eduplicate % jamb)
197                        #em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
198                        #logger.info(em)
199                        dd = {}
200                        for f,fn in csv_d.items():
201                            dd[fn] = getattr(data,f)
202                        no_import.append(eduplicate % dd)
203                        no_import.append(eduplicate % jamb)
204                    continue
205            try:
206                pume.addRecord(**dict)
207                ok_import.append(import_format % dict)
208            except ValueError:
209                logger.info(eduplicate % jamb)
210                #em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
211                #logger.info(em)
212                no_import.append(eduplicate % jamb)
213        logger.info('End loading from %s.csv' % name)
214        if len(no_import) > 1:
215            open(no_import_name,"w+").write('\n'.join(no_import))
216        open(ok_import_name,"w+").write('\n'.join(ok_import))
217        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
218    ###)
219
220    security.declareProtected(ModifyPortalContent,"createStudents")###(
221    def createStudents(self):
222        """
223        load addmitted Studentdata from CSV values and create Studentobjects.
224        This is the current method to create new addmitted Students.
225        Before running the eventservice for the students_catalog must be disabled.
226        """
227        import transaction
228        import random
229        #from pdb import set_trace
230        wftool = self.portal_workflow
231        #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
232        students_folder = self.portal_url.getPortalObject().campus.students
233        levels =       {'ume_ft':'100',
234                        'de_ft': '200',
235                        'ug_pt': '100',
236                        'de_pt': '200',
237                        'pg_ft': '700',
238                        'pg_pt': '700',
239                        'dp_pt': '100',
240                        'dp_ft': '100',
241                        }
242        csv_d = {'jamb_reg_no': "reg_no",
243                 'entry_mode': 'entry_mode',
244                 'jamb_firstname': "firstname",
245                 'jamb_middlename': "middlename",
246                 'jamb_lastname': "lastname",
247                 'jamb_sex': "sex",
248                 'jamb_state': "state",
249                 'birthday': "date_of_birth",
250                 'app_email': "email",
251                 'study_course': "study_course",
252                 'perm_address': "address",
253                 'admission_status': "admission_status",
254                 }
255        csv_fields = [f[1] for f in csv_d.items()]
256        tr_count = 0
257        total = 0
258        #name = 'pume_results'
259        name = 'Admitted'
260        no_import = []
261        s = ','.join(['"%s"' % fn for fn in csv_fields])
262        no_import.append('"Error",%s' % s)
263        format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
264        no_certificate = "no certificate %s" % format
265        open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
266        logger = logging.getLogger('Students.StudentsFolder.createStudents')
267        logger.info('Start loading from %s.csv' % name)
268        certs = {}
269        try:
270            results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
271        except:
272            logger.error('Error reading %s.csv' % name)
273            return
274        for result in results:
275            if not result.get(csv_d['admission_status']).startswith('Admitted'):
276                continue
277            #result['Error'] = "Processing "
278            #logger.info(format % result)
279            jamb_reg_no = result.get(csv_d['jamb_reg_no'])
280            res = self.students_catalog(jamb_reg_no = jamb_reg_no)
281            if res:
282                em = 'Student with RegNo %s already exists\n' % jamb_reg_no
283                logger.info(em)
284                result['Error'] = "Student exists"
285                no_import.append(format % result)
286                continue
287            cert_id = makeCertificateCode(result.get(csv_d['study_course']))
288            if cert_id not in certs.keys():
289                res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
290                if not res:
291                    em = 'No Certificate with ID %s \n' % cert_id
292                    logger.info(em)
293                    result['Error'] = "No Certificate %s" % cert_id
294                    no_import.append( format % result)
295                    continue
296                cert = res[0]
297                cert_path = cert.getPath().split('/')
298                certificate = certs[cert_id] = {'faculty': cert_path[-4],
299                                     'department': cert_path[-3]}
300            cert_doc = certs[cert_id]
301            catalog_entry = {}
302            catalog_entry['jamb_reg_no'] = jamb_reg_no
303            firstname = result.get(csv_d['jamb_firstname'])
304            middlename = result.get(csv_d['jamb_middlename'])
305            lastname = result.get(csv_d['jamb_lastname'])
306            perm_address = result.get(csv_d['perm_address'])
307            sid = self.generateStudentId('x')
308            students_folder.invokeFactory('Student', sid)
309            catalog_entry['id'] = sid
310            tr_count += 1
311            logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s reg_no %(jamb_reg_no)s ' % vars())
312            student = getattr(self,sid)
313            student.manage_setLocalRoles(sid, ['Owner',])
314            student.invokeFactory('StudentApplication','application')
315            da = {'Title': 'Application Data'}
316            da["jamb_firstname"] = firstname
317            da["jamb_middlename"] = middlename
318            da["jamb_lastname"] = lastname
319            catalog_entry['entry_session'] = da["entry_session"] = self.getSessionId()[-2:]
320            catalog_entry['sex'] = sex = result.get(csv_d['jamb_sex']).startswith('F')
321            da_fields = ('jamb_reg_no',
322                         'jamb_sex',
323                         'jamb_state',
324                         'entry_mode',
325                         'app_email',
326                         )
327            for f in da_fields:
328                da[f] = result.get(csv_d[f])
329            catalog_entry['email'] = da['app_email']
330            catalog_entry['entry_mode'] = da['entry_mode']
331            app = student.application
332            app_doc = app.getContent()
333            app.getContent().edit(mapping=da)
334            picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
335            app.manage_setLocalRoles(sid, ['Owner',])
336
337            picture_id = da['jamb_reg_no'].replace('/','_')
338            file = None
339            for ext in ('jpg','JPG'):
340                picture ="%s/import/pictures_admitted_latest/%s.%s" % (i_home,picture_id,ext)
341                if os.path.exists(picture):
342                    file = open(picture)
343                    break
344            if file is not None:
345
346                ## file conversion does not work
347                #img = PIL.Image.open(file)
348                #img.thumbnail((150,200),
349                #              resample=PIL.Image.ANTIALIAS)
350                #outfile = StringIO()
351                #img.save(outfile, format=img.format)
352
353                outfile = file.read()
354                app_doc.manage_addFile('passport',
355                                       file=outfile,
356                                       title="%s.jpg" % jamb_reg_no)
357            #wftool.doActionFor(app,'close')
358            dp = {}
359            dp['firstname'] = firstname
360            dp['middlename'] = middlename
361            dp['lastname'] = lastname
362            dp['email'] = da['app_email']
363            dp['sex'] = sex
364            dp['perm_address'] = perm_address
365            catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
366            student.invokeFactory('StudentPersonal','personal')
367            per = student.personal
368            per_doc = per.getContent()
369            per_doc.edit(mapping = dp)
370            per.manage_setLocalRoles(sid, ['Owner',])
371            wftool.doActionFor(student,'pume_pass')
372            wftool.doActionFor(student,'admit')
373            #
374            # Clearance
375            #
376            student.invokeFactory('StudentClearance','clearance')
377            #wftool.doActionFor(student.clearance,'open')
378            clearance = student.clearance
379            dc = {'Title': 'Clearance/Eligibility Record'}
380            clearance = student.clearance
381            date_str = result.get(csv_d['birthday'])
382            try:
383                date = DateTime.DateTime(date_str)
384            except:
385                #import pdb;pdb.set_trace()
386                date = None
387            dc['birthday'] = date
388            clearance.getContent().edit(mapping=dc)
389            clearance.manage_setLocalRoles(sid, ['Owner',])
390            #
391            # Study Course
392            #
393            student.invokeFactory('StudentStudyCourse','study_course')
394            study_course = student.study_course
395            dsc = {}
396            catalog_entry['level'] = dsc['current_level'] = levels.get(da['entry_mode'],'100')
397            #catalog_entry['level'] = dsc['current_level'] = '100'  # Attention: not for DE students
398            catalog_entry['session'] = dsc['current_session'] = da['entry_session']
399            catalog_entry['mode'] = dsc['current_mode'] = da['entry_mode']
400            catalog_entry['course'] = dsc['study_course'] = cert_id
401            catalog_entry['faculty'] = certificate['faculty']
402            catalog_entry['department'] = certificate['department']
403            catalog_entry['verdict'] = dsc['current_verdict'] = 'N/A'
404            catalog_entry['review_state'] = self.portal_workflow.getInfoFor(student,'review_state',None)
405            study_course.getContent().edit(mapping=dsc)
406            #import pdb;pdb.set_trace()
407            self.students_catalog.addRecord(**catalog_entry)
408            if tr_count > 1000:
409                if len(no_import) > 0:
410                    open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
411                             '\n'.join(no_import) + "\n")
412                    no_import = []
413                em = '%d transactions commited\n' % tr_count
414                transaction.commit()
415                logger.info(em)
416                total += tr_count
417                tr_count = 0
418        open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
419                                                '\n'.join(no_import))
420        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
421    ###)
422
423    security.declareProtected(ModifyPortalContent,"transferStudents")###(
424    def transferStudents(self,filename):
425        """
426        load Interfaculty transferStudents Studentdata from CSV values.
427        """
428        import transaction
429        import random
430        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
431        pm = self.portal_membership
432        member = pm.getAuthenticatedMember()
433        logger = logging.getLogger('Students.StudentsFolder.transferStudents')
434        #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
435        students_folder = self.portal_url.getPortalObject().campus.students
436        csv_fields = ('old_matric_no',
437                      'matric_no',
438                      'study_course',
439                      'current_mode',
440                      'current_level',
441                      )
442        tr_count = 0
443        total = 0
444        total_imported = 0
445        total_not_imported = 0
446        imported = []
447        not_imported = []
448        certs = {}
449        try:
450            results = csv.DictReader(open("%s/import/%s.csv" % (i_home,filename),"rb"))
451        except:
452            logger.error('Error reading %s.csv' % filename)
453            return
454        start = True
455        for result in results:
456            total += 1
457            if start:
458                start = False
459                logger.info('%s starts import from %s.csv' % (member,filename))
460                import_keys = [k for k in result.keys() if not k.startswith('ignore')]
461                diff2schema = set(import_keys).difference(set(csv_fields))
462                if diff2schema:
463                    em = "not ignorable key(s) %s found in heading" % diff2schema
464                    return em
465                s = ','.join(['"%s"' % fn for fn in import_keys])
466                open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(s + ',"Error"'+ '\n')
467                s = '"id",' + s
468                open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(s + '\n')
469                format = ','.join(['"%%(%s)s"' % fn for fn in import_keys])
470                format_error = format + ',"%(Error)s"'
471                format = '"%(id)s",'+ format
472            old_matric_no = result.get('old_matric_no')
473            res = self.students_catalog(matric_no = old_matric_no)
474            result['id'] = "None"
475            if not res:
476                em = 'Student with Matric_no %s not found' % old_matric_no
477                logger.info(em)
478                result['Error'] = "Student not exists"
479                not_imported.append(format_error % result)
480                total_not_imported += 1
481                continue
482            student_brain = res[0]
483            student_object = getattr(students_folder,student_brain.id)
484            result['id'] = student_brain.id
485            cert_id = makeCertificateCode(result.get('study_course'))
486            if cert_id not in certs.keys():
487                res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
488                if not res:
489                    em = 'No Certificate with ID %s \n' % cert_id
490                    logger.info(em)
491                    result['Error'] = "No Certificate %s" % cert_id
492                    not_imported.append( format_error % result)
493                    total_not_imported += 1
494                    continue
495                cert = res[0]
496                cert_path = cert.getPath().split('/')
497                certificate = certs[cert_id] = {'faculty': cert_path[-4],
498                                     'department': cert_path[-3]}
499            cert_doc = certs[cert_id]
500            clearance = getattr(student_object,'clearance',None)
501            if clearance is None:
502                em = 'Student has no clearance object'
503                logger.info(em)
504                result['Error'] = em
505                not_imported.append( format_error % result)
506                total_not_imported += 1
507                continue
508            clearance_doc = clearance.getContent()
509            study_course = student_object.study_course
510            study_course_doc = study_course.getContent()
511            old_study_course = study_course_doc.study_course
512            old_current_level = study_course_doc.current_level
513            current_level = result.get('current_level',None)
514            try:
515                icl = int(current_level)
516            except:
517                em = 'Invalid new level %s' % current_level
518                logger.info(em)
519                result['Error'] = em
520                not_imported.append( format_error % result)
521                total_not_imported += 1
522                continue
523            if icl <= int(old_current_level) and study_course.objectIds():
524                em = 'Already registered level %s new %s' % (old_current_level,current_level)
525                logger.info(em)
526                result['Error'] = em
527                not_imported.append( format_error % result)
528                total_not_imported += 1
529                continue
530            #from pdb import set_trace; set_trace()
531            cd = {}
532            matric_no_history = getattr(clearance_doc,'matric_no_history',[])
533            if not matric_no_history:
534                matric_no_history = []
535            matric_no_history.append(old_matric_no)
536            cd['matric_no_history'] = matric_no_history
537            cd['matric_no'] = result.get('matric_no')
538            clearance_doc.edit(mapping = cd)
539            dsc = {}
540            study_course_history = getattr(study_course_doc,'study_course_history',[])
541            if not study_course_history:
542                study_course_history = []
543            study_course_history.append(old_study_course)
544            dsc['study_course_history'] = study_course_history
545            dsc['study_course'] = result.get('study_course')
546            dsc['current_level'] = current_level
547            dsc['current_mode'] = result.get('current_mode')
548            study_course_doc.edit(mapping=dsc)
549            imported.append( format % result)
550            tr_count += 1
551            total_imported += 1
552            if tr_count > 1000:
553                if len(not_imported) > 0:
554                    open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(
555                             '\n'.join(not_imported) + '\n')
556                    not_imported = []
557                if len(imported) > 0:
558                    open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(
559                             '\n'.join(imported) + '\n')
560                    imported = []
561                em = '%d transactions committed\n' % (tr_count)
562                transaction.commit()
563                regs = []
564                logger.info(em)
565                tr_count = 0
566        if len(imported) > 0:
567            open("%s/import/%s_imported%s.csv" % (i_home,filename,current),"a").write(
568                                                '\n'.join(imported))
569        if len(not_imported) > 0:
570            open("%s/import/%s_not_imported%s.csv" % (i_home,filename,current),"a").write(
571                                                '\n'.join(not_imported))
572        em = "Imported: %d, not imported: %d of total %d" % (total_imported,total_not_imported,total)
573        logger.info(em)
574        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
575    ###)
576
577    security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
578    def importReturningStudents(self):
579        """load Returning Studentdata from CSV values"""
580        import transaction
581        import random
582        #from pdb import set_trace
583        wftool = self.portal_workflow
584        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
585        #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
586        students_folder = self.portal_url.getPortalObject().campus.students
587        tr_count = 1
588        total = 0
589        #name = 'pume_results'
590        name = 'Returning'
591        table = self.returning_import
592        no_import = []
593        imported = []
594        logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
595        try:
596            returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
597        except:
598            logger.error('Error reading %s.csv' % name)
599            return
600        l = self.portal_catalog({'meta_type': "Certificate"})
601        certs = {}
602        cert_docs = {}
603        for f in l:
604            certs[f.getId] = f.getObject().getContent()
605        start = True
606        res = table()
607        regs = []
608        if len(res) > 0:
609            regs = [s.matric_no for s in res]
610        #import pdb;pdb.set_trace()
611        for student in returning:
612            if start:
613                start = False
614                logger.info('Start loading from %s.csv' % name)
615                s = ','.join(['"%s"' % fn for fn in student.keys()])
616                imported.append(s)
617                no_import.append('%s,"Error"' % s)
618                format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
619                format_error = format + ',"%(Error)s"'
620                no_certificate = "no certificate %s" % format
621            student['matric_no'] = matric_no = student.get('matric_no').upper()
622            student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
623            student['Permanent_Address'] = perm_address = student.get('Permanent Address')
624            if matric_no == '':
625                student['Error'] = "Empty matric_no"
626                no_import.append( format_error % student)
627                continue
628            if matric_no in regs or self.returning_import(matric_no = matric_no):
629                student['Error'] = "Duplicate"
630                no_import.append( format_error % student)
631                continue
632            cert_id = makeCertificateCode(student.get('Coursemajorcode'))
633            if cert_id not in certs.keys():
634                student['Error'] = "No Certificate %s" % cert_id
635                no_import.append( format_error % student)
636                continue
637            try:
638                table.addRecord(**student)
639            except ValueError:
640                student['Error'] = "Duplicate"
641                no_import.append( format_error % student)
642                continue
643            regs.append(student.get('matric_no'))
644            imported.append(format % student)
645            tr_count += 1
646            if tr_count > 1000:
647                if len(no_import) > 0:
648                    open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
649                             '\n'.join(no_import) + '\n')
650                    no_import = []
651                open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
652                                            '\n'.join(no_import) + "\n")
653                imported = []
654                em = '%d transactions commited total %s\n' % (tr_count,total)
655                transaction.commit()
656                regs = []
657                logger.info(em)
658                total += tr_count
659                tr_count = 0
660        open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
661                                            '\n'.join(imported))
662        open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
663                                                '\n'.join(no_import))
664        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
665    ###)
666
667    security.declareProtected(ModifyPortalContent,"fixAllNames")###(
668    def fixAllNames(self):
669        "fix all students names"
670        import transaction
671        response = self.REQUEST.RESPONSE
672        logger = logging.getLogger('fixAllNames')
673        logger.info('Start')
674        students = self.portal_catalog(portal_type='Student')
675        count = 0
676        total = 0
677        for student in students:
678            scat_res = self.students_catalog(id = student.getId)
679            if not scat_res:
680                self.students_catalog.addRecord(id = student.getId)
681                scat_res = self.students_catalog(id = student.getId)
682            student_entry = scat_res[0]
683            old_new = self.fixName(student,student_entry)
684            count += 1
685            response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
686            if count > 2000:
687                transaction.commit()
688                logger.info("%d transactions commited" % count)
689                total += count
690                count = 0
691    ###)
692
693    security.declareProtected(ModifyPortalContent,"fixName")###(
694    def fixName(self,student_brain, student_entry):
695        "fix the name of a student"
696        fix = "first"
697        if student_entry.get('name_fixed',None) == fix:
698            return "Name already fixed"
699        student_id = student_entry.id
700        new_student = student_entry.jamb_reg_no.startswith('6')
701        student_obj = student_brain.getObject()
702        personal = getattr(student_obj,'personal',None)
703        invalid = ''
704        if personal is None:
705            return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
706        per_doc = personal.getContent()
707        old_first = per_doc.firstname
708        old_middle = per_doc.middlename
709        old_last = per_doc.lastname
710        new_first = ''
711        new_middle = ''
712        new_last = ''
713        if new_student:
714            if not old_first and not old_middle and old_last:
715                new_names = [n.capitalize() for n in old_last.split()]
716                if len(new_names) > 1:
717                    old_first = new_names[0]
718                    old_last = new_names[-1]
719                    old_middle = ' '.join(new_names[1:-1])
720                else:
721                    old_last = new_names[0]
722                    old_first = ''
723                    old_middle = ''
724            if old_first:
725                new_first = old_first
726            if old_middle:
727                new_middle = old_middle
728            if old_last:
729                new_last = old_last
730            if old_first.find('<') != -1 or\
731               old_first.find('>') != -1 or\
732               old_middle.find('<') != -1 or\
733               old_middle.find('>') != -1 or\
734               old_last.find('<') != -1 or\
735               old_last.find('>') != -1:
736                   invalid = "invalid characters"
737        else:
738            new_first = old_first
739            if new_first.strip() == '-':
740                new_first = ''
741            new_middle = old_middle
742            if new_middle.strip() == '-':
743                new_middle = ''
744            new_last = old_last
745            if new_last.strip() == '-':
746                new_last = ''
747        name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
748        if new_student:
749            text = "New"
750        else:
751            text = "Returning"
752        old_new = '"%s","%s","%s","%s"' % (invalid,text,
753                                           student_entry.name,
754                                           name)
755        if not invalid:
756            self.students_catalog.modifyRecord(id = student_id,
757                                      name_fixed = fix,
758                                      name = name)
759            per_doc.edit(mapping = {'firstname' : new_first,
760                                'middlename' : new_middle,
761                                'lastname' : new_last,
762                                })
763        return old_new
764    ###)
765
766    security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
767    def updateReturningStudents(self):
768        """load and overwrite Returning Student Data from CSV values"""
769        import transaction
770        import random
771        #from pdb import set_trace
772        wftool = self.portal_workflow
773        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
774        #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
775        students_folder = self.portal_url.getPortalObject().campus.students
776        tr_count = 1
777        total = 0
778        #name = 'pume_results'
779        name = 'Returning_update'
780        table = self.returning_import
781        no_import = []
782        imported = []
783        logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
784        try:
785            returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
786        except:
787            logger.error('Error reading %s.csv' % name)
788            return
789        l = self.portal_catalog({'meta_type': "Certificate"})
790        certs = {}
791        cert_docs = {}
792        for f in l:
793            certs[f.getId] = f.getObject().getContent()
794        start = True
795        res = table()
796        regs = []
797        if len(res) > 0:
798            regs = [s.matric_no for s in res]
799        for student in returning:
800            if start:
801                start = False
802                logger.info('Start loading from %s.csv' % name)
803                s = ','.join(['"%s"' % fn for fn in student.keys()])
804                imported.append(s)
805                no_import.append('%s,"Error"' % s)
806                format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
807                format_error = format + ',"%(Error)s"'
808                no_certificate = "no certificate %s" % format
809            matric_no = student.get('matric_no').upper()
810            student['matric_no'] = matric_no
811            if matric_no == '':
812                student['Error'] = "Empty matric_no"
813                no_import.append( format_error % student)
814                continue
815#            if matric_no in regs or self.returning_import(matric_no = matric_no):
816#                student['Error'] = "Duplicate"
817#                no_import.append( format_error % student)
818#                continue
819#            cert_id = makeCertificateCode(student.get('Coursemajorcode'))
820#            if cert_id not in certs.keys():
821#                student['Error'] = "No Certificate %s" % cert_id
822#                no_import.append( format_error % student)
823#                continue
824            try:
825                table.modifyRecord(**student)
826            except KeyError:
827                #import pdb;pdb.set_trace()
828                student['Error'] = "no Student found to update"
829                no_import.append( format_error % student)
830                continue
831            #s = self.students_catalog(matric_no=matric_no)
832            #if s:
833            #    level = "%s" % (int(student.get('Level')) + 100)
834            #    self.students_catalog.modifyRecord(id = s[0].id,
835            #                                           level=level)
836
837            regs.append(student.get('matric_no'))
838            imported.append(format % student)
839            tr_count += 1
840            if tr_count > 1000:
841                if len(no_import) > 0:
842                    open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
843                             '\n'.join(no_import) + '\n')
844                    no_import = []
845                open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
846                                            '\n'.join(no_import) + "\n")
847                imported = []
848                em = '%d transactions commited total %s\n' % (tr_count,total)
849                transaction.commit()
850                regs = []
851                logger.info(em)
852                total += tr_count
853                tr_count = 0
854        open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
855                                            '\n'.join(imported))
856        open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
857                                                '\n'.join(no_import))
858        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
859    ###)
860
861    security.declareProtected(ModifyPortalContent,"importResults")###(
862    def importResults(self):
863        """load Returning Students Results from CSV"""
864        import transaction
865        import random
866        #from pdb import set_trace
867        wftool = self.portal_workflow
868        current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
869        #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
870        students_folder = self.portal_url.getPortalObject().campus.students
871        tr_count = 1
872        total = 0
873        #name = 'pume_results'
874        name = 'Results'
875        table = self.results_import
876        no_import = []
877        imported = []
878        logger = logging.getLogger('Students.StudentsFolder.importResults')
879        try:
880            results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
881        except:
882            logger.error('Error reading %s.csv' % name)
883            return
884        l = self.portal_catalog({'meta_type': "Course"})
885        courses = [f.getId for f in l]
886        start = True
887        res = table()
888        regs = []
889        if len(res) > 0:
890            regs = [s.key for s in res]
891        no_course = []
892        no_course_list = []
893        course_count = 0
894        for result in results:
895            if start:
896                start = False
897                logger.info('Start loading from %s.csv' % name)
898                s = ','.join(['"%s"' % fn for fn in result.keys()])
899                imported.append(s)
900                no_import.append('%s,"Error"' % s)
901                format = ','.join(['"%%(%s)s"' % fn for fn in result.keys()])
902                format_error = format + ',"%(Error)s"'
903                no_certificate = "no certificate %s" % format
904            course_id = result.get('CosCode')
905            if not course_id:
906                course_id = 'N/A'
907                result['CosCode'] = course_id
908            matric_no = result.get('matric_no').upper()
909            result['matric_no'] = matric_no
910            key = matric_no+course_id
911            if matric_no == '':
912                result['Error'] = "Empty matric_no"
913                no_import.append( format_error % result)
914                continue
915            if key in regs or self.results_import(key = key):
916                result['Error'] = "Duplicate"
917                no_import.append( format_error % result)
918                continue
919            if course_id not in courses:
920                if course_id not in no_course:
921                    course_count +=1
922                    no_course.append(course_id)
923                    no_course_list.append('"%s"' % course_id)
924                    #result['Error'] = "No Course"
925                    #logger.info(format_error % result)
926
927            result['key'] = key
928            try:
929                table.addRecord(**result)
930            except ValueError:
931                #import pdb;pdb.set_trace()
932                result['Error'] = "Duplicate"
933                no_import.append( format_error % result)
934                continue
935
936            regs.append(key)
937            imported.append(format % result)
938            tr_count += 1
939            if tr_count > 1000:
940                if len(no_import) > 0:
941                    open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
942                             '\n'.join(no_import)+'\n')
943                    no_import = []
944                open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
945                                            '\n'.join(imported) + '\n')
946                imported = []
947                if no_course_list:
948                    open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
949                                            '\n'.join(no_course_list) + '\n')
950                    no_course_list = []
951                em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
952                transaction.commit()
953                logger.info(em)
954                regs = []
955                total += tr_count
956                tr_count = 0
957        open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
958                                            '\n'.join(imported))
959        open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
960                                                '\n'.join(no_import))
961        if no_course_list:
962            open("%s/import/%sno_courses%s.csv" % (i_home,name,current),"a").write(
963                                    '\n'.join(no_course_list))
964        em = '%d transactions commited total %s\n courses not found %s' % (tr_count,total,course_count)
965        logger.info(em)
966        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
967    ###)
968
969    security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
970    def updateStudyCourse(self):
971        """update StudyCourse from CSV values"""
972        import transaction
973        import random
974        from pdb import set_trace
975        wftool = self.portal_workflow
976        #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
977        students_folder = self.portal_url.getPortalObject().campus.students
978        csv_d = {'jamb_reg_no': "RegNumber",
979                 'jamb_lastname': "Name",
980                 'session': "Session",
981                 'pume_tot_score': "PUME SCORE",
982                 'jamb_score': "JambScore",
983                 'jamb_sex': "Sex",
984                 'jamb_state': "State",
985##                 'jamb_first_cos': "AdminCourse",
986                 'faculty': "AdminFaculty",
987                 'course_code': "AdmitCoscode",
988                 'stud_status':"AdmitStatus",
989                 'department': "AdmitDept",
990                 'jamb_lga': "LGA",
991                 'app_email': "email",
992                 'app_mobile': "PhoneNumbers",
993                 }
994        csv_fields = [f[1] for f in csv_d.items()]
995        tr_count = 0
996        total = 0
997        #name = 'pume_results'
998        name = 'StudyCourseChange'
999        no_import = []
1000        s = ','.join(['"%s"' % fn for fn in csv_fields])
1001        no_import.append('"Error",%s' % s)
1002        format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
1003        no_certificate = "no certificate %s" % format
1004        open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
1005                    '\n'.join(no_import))
1006        logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
1007        logger.info('Start loading from %s.csv' % name)
1008        l = self.portal_catalog({'meta_type': "Certificate"})
1009        try:
1010            result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
1011        except:
1012            logger.error('Error reading %s.csv' % name)
1013            return
1014        for jamb in result:
1015            jamb['Error'] = "Processing "
1016            logger.info(format % jamb)
1017            jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
1018            res = self.portal_catalog({'portal_type': "StudentApplication",
1019                                     'SearchableText': jamb_reg_no })
1020            if not res:
1021                em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
1022                logger.info(em)
1023                jamb['Error'] = "Student does not exist"
1024                no_import.append(format % jamb)
1025                continue
1026            sid = res[0].getPath().split('/')[-2]
1027            cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
1028            res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
1029            if not res:
1030                em = 'No Certificate with ID %s \n' % cert_id
1031                logger.info(em)
1032                jamb['Error'] = "No Certificate %s" % cert_id
1033                no_import.append( format % jamb)
1034                continue
1035            cert_brain = res[0]
1036            catalog_entry = {}
1037            student = getattr(self,sid)
1038            #
1039            # Study Course
1040            #
1041            study_course = student.study_course
1042            dsc = {}
1043            cert_pl = cert_brain.getPath().split('/')
1044            catalog_entry['id'] = sid
1045            catalog_entry['faculty'] = cert_pl[-4]
1046            catalog_entry['department'] = cert_pl[-3]
1047            catalog_entry['course'] = cert_id
1048            dsc['study_course'] = cert_id
1049            study_course.getContent().edit(mapping=dsc)
1050            self.students_catalog.modifyRecord(**catalog_entry)
1051            if tr_count > 10:
1052                if len(no_import) > 1:
1053                    open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
1054                             '\n'.join(no_import))
1055                    no_import = []
1056                em = '%d transactions commited\n' % tr_count
1057                transaction.commit()
1058                logger.info(em)
1059                total += tr_count
1060                tr_count = 0
1061            tr_count += 1
1062        return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
1063    ###)
1064
1065    security.declareProtected(View,"fixOwnership") ###(
1066    def fixOwnership(self):
1067        """fix Ownership"""
1068        for s in self.portal_catalog(meta_type = 'Student'):
1069            student = s.getObject()
1070            sid = s.getId
1071            import pdb;pdb.set_trace()
1072            student.application.manage_setLocalRoles(sid, ['Owner',])
1073            student.personal.manage_setLocalRoles(sid, ['Owner',])
1074    ###)
1075
1076    security.declareProtected(View,"Title") ###(
1077    def Title(self):
1078        """compose title"""
1079        return "Student Section"
1080    ###)
1081
1082    def generateStudentId(self,letter,students = None): ###(
1083        import random
1084        r = random
1085        if students is None:
1086            students = self.portal_url.getPortalObject().campus.students
1087        if letter not in ('ABCDEFGIHKLMNOPQRSTUVWXY'):
1088            letter= r.choice('ABCDEFGHKLMNPQRSTUVWXY')
1089        sid = "%c%d" % (letter,r.randint(99999,1000000))
1090        while hasattr(students, sid):
1091            sid = "%c%d" % (letter,r.randint(99999,1000000))
1092        return sid
1093        #return "%c%d" % (r.choice('ABCDEFGHKLMNPQRSTUVWXY'),r.randint(99999,1000000))
1094    ###)
1095
1096InitializeClass(StudentsFolder)
1097
1098def addStudentsFolder(container, id, REQUEST=None, **kw): ###(
1099    """Add a Student."""
1100    ob = StudentsFolder(id, **kw)
1101    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1102    ###)
1103
1104###)
1105
1106class Student(CPSDocument): ###(
1107    """
1108    WAeUP Student container for the various student data
1109    """
1110    meta_type = 'Student'
1111    portal_type = meta_type
1112    security = ClassSecurityInfo()
1113
1114    security.declareProtected(View,"Title")
1115    def Title(self):
1116        """compose title"""
1117        reg_nr = self.getId()[1:]
1118        data = getattr(self,'personal',None)
1119        if data:
1120            content = data.getContent()
1121            return "%s %s %s" % (content.firstname,content.middlename,content.lastname)
1122        data = getattr(self,'application',None)
1123        if data:
1124            content = data.getContent()
1125            return "%s" % (content.jamb_lastname)
1126        return self.title
1127
1128    security.declarePrivate('makeStudentMember') ###(
1129    def makeStudentMember(self,sid,password='uNsEt'):
1130        """make the student a member"""
1131        membership = self.portal_membership
1132        membership.addMember(sid,
1133                             password ,
1134                             roles=('Member',
1135                                     'Student',
1136                                     ),
1137                             domains='',
1138                             properties = {'memberareaCreationFlag': False,
1139                                           'homeless': True},)
1140        member = membership.getMemberById(sid)
1141        self.portal_registration.afterAdd(member, sid, password, None)
1142        self.manage_setLocalRoles(sid, ['Owner',])
1143
1144###)
1145
1146    security.declareProtected(View,'createSubObjects') ###(
1147    def createSubObjects(self):
1148        """make the student a member"""
1149        dp = {'Title': 'Personal Data'}
1150        app_doc = self.application.getContent()
1151        names = app_doc.jamb_lastname.split()
1152        if len(names) == 3:
1153            dp['firstname'] = names[0].capitalize()
1154            dp['middlename'] = names[1].capitalize()
1155            dp['lastname'] = names[2].capitalize()
1156        elif len(names) == 2:
1157            dp['firstname'] = names[0].capitalize()
1158            dp['lastname'] = names[1].capitalize()
1159        else:
1160            dp['lastname'] = app_doc.jamb_lastname
1161        dp['sex'] = app_doc.jamb_sex == 'F'
1162        dp['lga'] = "%s/%s" % (app_doc.jamb_state,app_doc.jamb_lga )
1163        proxy = self.aq_parent
1164        proxy.invokeFactory('StudentPersonal','personal')
1165        per = proxy.personal
1166        per_doc = per.getContent()
1167        per_doc.edit(mapping = dp)
1168        per.manage_setLocalRoles(proxy.getId(), ['Owner',])
1169        #self.portal_workflow.doActionFor(per,'open',dest_container=per)
1170
1171###)
1172
1173InitializeClass(Student)
1174
1175def addStudent(container, id, REQUEST=None, **kw):
1176    """Add a Student."""
1177    ob = Student(id, **kw)
1178    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1179
1180###)
1181
1182class StudentAccommodation(CPSDocument): ###(
1183    """
1184    WAeUP Student container for the various student data
1185    """
1186    meta_type = 'StudentAccommodation'
1187    portal_type = meta_type
1188    security = ClassSecurityInfo()
1189
1190    security.declareProtected(View,"Title")
1191    def Title(self):
1192        """compose title"""
1193        content = self.getContent()
1194        #return "Accommodation Data for %s %s" % (content.firstname,content.lastname)
1195        return "Accommodation Data for Session %s" % content.session
1196
1197
1198InitializeClass(StudentAccommodation)
1199
1200def addStudentAccommodation(container, id, REQUEST=None, **kw):
1201    """Add a Students personal data."""
1202    ob = StudentAccommodation(id, **kw)
1203    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1204
1205###)
1206
1207class StudentPersonal(CPSDocument): ###(
1208    """
1209    WAeUP Student container for the various student data
1210    """
1211    meta_type = 'StudentPersonal'
1212    portal_type = meta_type
1213    security = ClassSecurityInfo()
1214
1215    security.declareProtected(View,"Title")
1216    def Title(self):
1217        """compose title"""
1218        content = self.getContent()
1219        #return "Personal Data for %s %s" % (content.firstname,content.lastname)
1220        return "Personal Data"
1221
1222
1223InitializeClass(StudentPersonal)
1224
1225def addStudentPersonal(container, id, REQUEST=None, **kw):
1226    """Add a Students personal data."""
1227    ob = StudentPersonal(id, **kw)
1228    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1229
1230###)
1231
1232class StudentClearance(CPSDocument): ###(
1233    """
1234    WAeUP Student container for the various student data
1235    """
1236    meta_type = 'StudentClearance'
1237    portal_type = meta_type
1238    security = ClassSecurityInfo()
1239
1240    security.declareProtected(View,"Title")
1241    def Title(self):
1242        """compose title"""
1243        content = self.getContent()
1244        #return "Clearance/Eligibility Record for %s %s" % (content.firstname,content.lastname)
1245        return "Clearance/Eligibility Record"
1246
1247
1248InitializeClass(StudentClearance)
1249
1250def addStudentClearance(container, id, REQUEST=None, **kw):
1251    """Add a Students personal data."""
1252    ob = StudentClearance(id, **kw)
1253    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1254
1255###)
1256
1257class StudentStudyLevel(CPSDocument): ###(
1258    """
1259    WAeUP Student container for the various student data
1260    """
1261    meta_type = 'StudentStudyLevel'
1262    portal_type = meta_type
1263    security = ClassSecurityInfo()
1264
1265    security.declareProtected(View,"Title")
1266    def Title(self):
1267        """compose title"""
1268        return "Level %s" % self.aq_parent.getId()
1269
1270    def create_course_results(self,cert_id,current_level): ###(
1271        "create all courses in a level"
1272        aq_portal = self.portal_catalog.evalAdvancedQuery
1273        res = self.portal_catalog(portal_type="Certificate", id = cert_id)
1274        l = []
1275        import transaction
1276        if res:
1277            cert = res[0]
1278            path = cert.getPath()
1279            query = Eq("path","%s/%s" % (path,current_level)) &\
1280                    Eq('portal_type','CertificateCourse')
1281            courses = aq_portal(query)
1282            #from pdb import set_trace;set_trace()
1283            self_proxy = self.aq_parent
1284            for c in courses:
1285                d = self.getCourseInfo(c.getId)
1286                cr_id = self_proxy.invokeFactory('StudentCourseResult',c.getId)
1287                course_result = getattr(self_proxy,cr_id)
1288                self.portal_workflow.doActionFor(course_result,'open')
1289                d['core_or_elective'] = getattr(c.getObject().getContent(),'core_or_elective')
1290                course_result.getContent().edit(mapping=d)
1291                #transaction.commit()
1292    ###)
1293
1294InitializeClass(StudentStudyLevel)
1295
1296def addStudentStudyLevel(container, id, REQUEST=None, **kw):
1297    """Add a Students personal data."""
1298    ob = StudentStudyLevel(id, **kw)
1299    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1300
1301###)
1302
1303class StudentStudyCourse(CPSDocument): ###(
1304    """
1305    WAeUP Student container for the various student data
1306    """
1307    meta_type = 'StudentStudyCourse'
1308    portal_type = meta_type
1309    security = ClassSecurityInfo()
1310
1311    security.declareProtected(View,"Title")
1312    def Title(self):
1313        """compose title"""
1314        content = self.getContent()
1315        return "Study Course"
1316
1317
1318InitializeClass(StudentStudyCourse)
1319
1320def addStudentStudyCourse(container, id, REQUEST=None, **kw):
1321    """Add a Students personal data."""
1322    ob = StudentStudyCourse(id, **kw)
1323    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1324
1325###)
1326
1327class StudentApplication(CPSDocument): ###(
1328    """
1329    WAeUP Student container for the various student data
1330    """
1331    meta_type = 'StudentApplication'
1332    portal_type = meta_type
1333    security = ClassSecurityInfo()
1334
1335    security.declareProtected(View,"Title")
1336    def Title(self):
1337        """compose title"""
1338        return "Application Data"
1339
1340
1341InitializeClass(StudentApplication)
1342
1343def addStudentApplication(container, id, REQUEST=None, **kw):
1344    """Add a Students eligibility data."""
1345    ob = StudentApplication(id, **kw)
1346    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1347###)
1348
1349class StudentPume(CPSDocument): ###(
1350    """
1351    WAeUP Student container for the various student data
1352    """
1353    meta_type = 'StudentPume'
1354    portal_type = meta_type
1355    security = ClassSecurityInfo()
1356
1357    security.declareProtected(View,"Title")
1358    def Title(self):
1359        """compose title"""
1360        return "PUME Results"
1361
1362
1363InitializeClass(StudentPume)
1364
1365def addStudentPume(container, id, REQUEST=None, **kw):
1366    """Add a Students PUME data."""
1367    ob = StudentPume(id, **kw)
1368    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1369###)
1370
1371##class StudentSemester(CPSDocument): ###(
1372##    """
1373##    WAeUP StudentSemester containing the courses and students
1374##    """
1375##    meta_type = 'StudentSemester'
1376##    portal_type = meta_type
1377##    security = ClassSecurityInfo()
1378##
1379##InitializeClass(StudentSemester)
1380##
1381##def addStudentSemester(container, id, REQUEST=None, **kw):
1382##    """Add a StudentSemester."""
1383##    ob = StudentSemester(id, **kw)
1384##    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1385##
1386#####)
1387
1388##class Semester(CPSDocument): ###(
1389##    """
1390##    WAeUP Semester containing the courses and students
1391##    """
1392##    meta_type = 'Semester'
1393##    portal_type = meta_type
1394##    security = ClassSecurityInfo()
1395##
1396##InitializeClass(Semester)
1397##
1398##def addSemester(container, id, REQUEST=None, **kw):
1399##    """Add a Semester."""
1400##    ob = Semester(id, **kw)
1401##    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1402##
1403#####)
1404
1405class StudentCourseResult(CPSDocument): ###(
1406    """
1407    WAeUP StudentCourseResult
1408    """
1409    meta_type = 'StudentCourseResult'
1410    portal_type = meta_type
1411    security = ClassSecurityInfo()
1412
1413    def getCourseEntry(self,cid):
1414        res = self.portal_catalog({'meta_type': "Course",
1415                                           'id': cid})
1416        if res:
1417            return res[-1]
1418        else:
1419            return None
1420
1421    security.declareProtected(View,"Title")
1422    def Title(self):
1423        """compose title"""
1424        cid = self.aq_parent.getId()
1425        ce = self.getCourseEntry(cid)
1426        if ce:
1427            return "%s" % ce.Title
1428        return "No course with id %s" % cid
1429
1430InitializeClass(StudentCourseResult)
1431
1432def addStudentCourseResult(container, id, REQUEST=None, **kw):
1433    """Add a StudentCourseResult."""
1434    ob = StudentCourseResult(id, **kw)
1435    return CPSBase_adder(container, ob, REQUEST=REQUEST)
1436###)
1437
1438# Backward Compatibility StudyLevel
1439
1440from Products.WAeUP_SRP.Academics import StudyLevel
1441
1442from Products.WAeUP_SRP.Academics import addStudyLevel
1443
Note: See TracBrowser for help on using the repository browser.