Ignore:
Timestamp:
14 Nov 2007, 17:54:25 (17 years ago)
Author:
Henrik Bettermann
Message:

move unused methods from Students.py

File:
1 edited

Legend:

Unmodified
Added
Removed

  • WAeUP_SRP/base/Students.py

    r2640 r2654  
    116116    security = ClassSecurityInfo()
    117117
    118     security.declareProtected(ModifyPortalContent,"loadPumeResultsFromCSV")###(
    119     def loadPumeResultsFromCSV(self):
    120         """load Fulltime Studentdata from CSV values into pumeresults catalog"""
    121         import transaction
    122         import random
    123 ##        csv_d = {'jamb_reg_no': "RegNumber", ###(
    124 ##                 'status': "Admission Status",
    125 ##                 'name': "Name",
    126 ##                 'score': "Score",
    127 ##                 'sex': "Sex",
    128 ##                 'faculty': "Faculty",
    129 ##                 'department': "Dept",
    130 ##                 'course': "Course",
    131 ##                 'course_code_org': "Course Code",
    132 ##                 }
    133 ###)
    134 ##        csv_d = {'jamb_reg_no': "JAMBRegno",
    135 ##                'name': "Name",
    136 ##                'score': "Score",
    137 ##                 'sex': "Sex",
    138 ##                 'course': "Course",
    139 ##                 'faculty': "Faculty",
    140 ##                 'department': "Dept",
    141 ##                 'course_code_org': "Course Code",
    142 ##                 'status': "Admission Status",
    143 ##                 'result_type': None,
    144 ##                 }
    145 
    146         csv_d = {'jamb_reg_no': "reg_no",
    147                  'name': "fullname",
    148                  'score': "pume_score",
    149                  'sex': "sex",
    150                  'course': "study_course",
    151                  'course_code_org': "study_course",
    152                  'status': "admission_status",
    153                  'result_type': "entry_mode",
    154                  }
    155 
    156         csv_fields = [f[1] for f in csv_d.items() if f[1]]
    157         tr_count = 0
    158         total = 0
    159         #name = 'pup_new'
    160         #name = 'pup_update'
    161         name = 'Admitted_update'
    162         update = name.endswith('update')
    163         no_import = []
    164         ok_import = []
    165         ok_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_d.keys()]))
    166         no_import.append('%s' % ','.join(['"%s"' % fn for fn in csv_fields]))
    167         current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
    168         ok_import_name = "%s/import/%s_imported_%s.csv" % (i_home,name,current)
    169         #open(ok_import_name,"w").write('\n'.join(no_import))
    170         no_import_name = "%s/import/%s_not_imported_%s.csv" % (i_home,name,current)
    171         #open(no_import_name,"w").write('\n'.join(no_import))
    172         logger = logging.getLogger('Students.loadPumeResultsFromCSV')
    173         starttime = DateTime.now()
    174         logger.info('Start loading from %s.csv' % name)
    175         try:
    176             result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
    177         except:
    178             logger.error('Error reading %s.csv' % name)
    179             return
    180         pume = self.portal_pumeresults
    181         format = ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
    182         import_format = ','.join(['"%%(%s)s"' % fn for fn in csv_d.keys()])
    183         eduplicate = '%s,"duplicate"' % format
    184         eoriginal = '%s,"original"' % format
    185         einvalidjamb = '%s,"invalid JambRegNo"' % format
    186         added = 'added ,%s' % format
    187         #from pdb import set_trace;set_trace()
    188         for jamb in result:
    189             if not jamb.get(csv_d['score']):
    190                 logger.info('Student %s has no pume_score' % jamb.get(csv_d['jamb_reg_no']))
    191                 continue
    192             dict = {}
    193             for f,fn in csv_d.items():
    194                 dict[f] = jamb.get(csv_d[f])
    195             dict['result_type'] = 'CEST'
    196             jnr = jamb.get(csv_d['jamb_reg_no'])
    197             #if not checkJambNo(jnr):
    198             #    logger.info(einvalidjamb % jamb)
    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             res = pume(jamb_reg_no=jnr)
    206             if len(res) > 0:
    207                 if update:
    208                     try:
    209                         pume.modifyRecord(**dict)
    210                     # Can not happen, but anyway...
    211                     except ValueError:
    212                         logger.info(eduplicate % jamb)
    213                         continue
    214                     # Can not happen, but anyway...
    215                     except KeyError:
    216                         pume.addRecord(**dict)
    217                         logger.info(added % jamb)
    218                         continue
    219                 else:
    220                     data = res[0]
    221                     if data.name != jamb.get(csv_d['name']):
    222                         #set_trace()
    223                         logger.info(eduplicate % jamb)
    224                         #em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
    225                         #logger.info(em)
    226                         dd = {}
    227                         for f,fn in csv_d.items():
    228                             dd[fn] = getattr(data,f)
    229                         no_import.append(eoriginal % dd)
    230                         no_import.append(eduplicate % jamb)
    231                     continue
    232             else:
    233                 try:
    234                     pume.addRecord(**dict)
    235                     ok_import.append(import_format % dict)
    236                 except ValueError:
    237                     logger.info(eduplicate % jamb)
    238                     #em = 'Student with REG-NO %(jamb_reg_no)s already exists\n' % dict
    239                     #logger.info(em)
    240                     no_import.append(eduplicate % jamb)
    241         logger.info('End loading from %s.csv' % name)
    242         if len(no_import) > 1:
    243             open(no_import_name,"w+").write('\n'.join(no_import))
    244         open(ok_import_name,"w+").write('\n'.join(ok_import))
    245         return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
    246     ###)
    247 
    248     security.declareProtected(ModifyPortalContent,"createStudents")###(
    249     def createStudents(self):
    250         """
    251         load addmitted Studentdata from CSV values and create Studentobjects.
    252         This is the current method to create new addmitted Students.
    253         Before running the eventservice for the students_catalog must be disabled.
    254         """
    255         import transaction
    256         import random
    257         #from pdb import set_trace
    258         wftool = self.portal_workflow
    259         #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
    260         students_folder = self.portal_url.getPortalObject().campus.students
    261         levels =       {'ume_ft':'100',
    262                         'de_ft': '200',
    263                         'ug_pt': '100',
    264                         'de_pt': '200',
    265                         'pg_ft': '700',
    266                         'pg_pt': '700',
    267                         'dp_pt': '100',
    268                         'dp_ft': '100',
    269                         }
    270         csv_d = {'jamb_reg_no': "reg_no",
    271                  'entry_mode': 'entry_mode',
    272                  'jamb_firstname': "firstname",
    273                  'jamb_middlename': "middlename",
    274                  'jamb_lastname': "lastname",
    275                  'jamb_sex': "sex",
    276                  'jamb_state': "state",
    277                  'birthday': "date_of_birth",
    278                  'app_email': "email",
    279                  'study_course': "study_course",
    280                  'perm_address': "address",
    281                  'admission_status': "admission_status",
    282                  }
    283         csv_fields = [f[1] for f in csv_d.items()]
    284         tr_count = 0
    285         total = 0
    286         #name = 'pume_results'
    287         name = 'Admitted_update'
    288         no_import = []
    289         s = ','.join(['"%s"' % fn for fn in csv_fields])
    290         no_import.append('"Error",%s' % s)
    291         format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
    292         no_certificate = "no certificate %s" % format
    293         open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write('\n'.join(no_import))
    294         logger = logging.getLogger('Students.StudentsFolder.createStudents')
    295         logger.info('Start loading from %s.csv' % name)
    296         certs = {}
    297         try:
    298             results = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
    299         except:
    300             logger.error('Error reading %s.csv' % name)
    301             return
    302         for result in results:
    303             if not result.get(csv_d['admission_status']).startswith('Admitted'):
    304                 continue
    305             #result['Error'] = "Processing "
    306             #logger.info(format % result)
    307             jamb_reg_no = result.get(csv_d['jamb_reg_no'])
    308             res = self.students_catalog(jamb_reg_no = jamb_reg_no)
    309             if res:
    310                 em = 'Student with RegNo %s already exists\n' % jamb_reg_no
    311                 logger.info(em)
    312                 result['Error'] = "Student exists"
    313                 no_import.append(format % result)
    314                 continue
    315             cert_id = makeCertificateCode(result.get(csv_d['study_course']))
    316             if cert_id not in certs.keys():
    317                 res = self.portal_catalog(meta_type = "Certificate",id = cert_id)
    318                 if not res:
    319                     em = 'No Certificate with ID %s \n' % cert_id
    320                     logger.info(em)
    321                     result['Error'] = "No Certificate %s" % cert_id
    322                     no_import.append( format % result)
    323                     continue
    324                 cert = res[0]
    325                 cert_path = cert.getPath().split('/')
    326                 certificate = certs[cert_id] = {'faculty': cert_path[-4],
    327                                      'department': cert_path[-3]}
    328             cert_doc = certs[cert_id]
    329             catalog_entry = {}
    330             catalog_entry['jamb_reg_no'] = jamb_reg_no
    331             firstname = result.get(csv_d['jamb_firstname'])
    332             middlename = result.get(csv_d['jamb_middlename'])
    333             lastname = result.get(csv_d['jamb_lastname'])
    334             if len(firstname) < 3\
    335                and len(middlename) < 3\
    336                and len(lastname) < 3:
    337                 em = 'Student Names to short \n'
    338                 logger.info(em)
    339                 result['Error'] = "Names to short"
    340                 no_import.append( format % result)
    341                 continue
    342             perm_address = result.get(csv_d['perm_address'])
    343             sid = self.generateStudentId('x')
    344             students_folder.invokeFactory('Student', sid)
    345             catalog_entry['id'] = sid
    346             tr_count += 1
    347             logger.info('%(total)s+%(tr_count)s: Creating Student with ID %(sid)s reg_no %(jamb_reg_no)s ' % vars())
    348             student = getattr(self,sid)
    349             student.manage_setLocalRoles(sid, ['Owner',])
    350             student.invokeFactory('StudentApplication','application')
    351             da = {'Title': 'Application Data'}
    352             da["jamb_firstname"] = firstname
    353             da["jamb_middlename"] = middlename
    354             da["jamb_lastname"] = lastname
    355             catalog_entry['entry_session'] = da["entry_session"] = self.getSessionId()[0]
    356             catalog_entry['sex'] = sex = result.get(csv_d['jamb_sex']).startswith('F')
    357             da_fields = ('jamb_reg_no',
    358                          'jamb_sex',
    359                          'jamb_state',
    360                          'entry_mode',
    361                          'app_email',
    362                          )
    363             for f in da_fields:
    364                 da[f] = result.get(csv_d[f])
    365             catalog_entry['email'] = da['app_email']
    366             catalog_entry['entry_mode'] = da['entry_mode']
    367             app = student.application
    368             app_doc = app.getContent()
    369             app.getContent().edit(mapping=da)
    370             picture ="%s/import/pictures/%s.jpg" % (i_home,jamb_reg_no)
    371             app.manage_setLocalRoles(sid, ['Owner',])
    372 
    373             picture_id = da['jamb_reg_no'].replace('/','_')
    374             file = None
    375             for ext in ('jpg','JPG'):
    376                 picture ="%s/import/pictures_admitted_latest/%s.%s" % (i_home,picture_id,ext)
    377                 if os.path.exists(picture):
    378                     file = open(picture)
    379                     break
    380             if file is not None:
    381 
    382                 ## file conversion does not work
    383                 #img = PIL.Image.open(file)
    384                 #img.thumbnail((150,200),
    385                 #              resample=PIL.Image.ANTIALIAS)
    386                 #outfile = StringIO()
    387                 #img.save(outfile, format=img.format)
    388 
    389                 outfile = file.read()
    390                 app_doc.manage_addFile('passport',
    391                                        file=outfile,
    392                                        title="%s.jpg" % jamb_reg_no)
    393             #wftool.doActionFor(app,'close')
    394             dp = {}
    395             dp['firstname'] = firstname
    396             dp['middlename'] = middlename
    397             dp['lastname'] = lastname
    398             dp['email'] = da['app_email']
    399             dp['sex'] = sex
    400             dp['perm_address'] = perm_address
    401             catalog_entry['name'] = "%(firstname)s %(middlename)s %(lastname)s" % dp
    402             student.invokeFactory('StudentPersonal','personal')
    403             per = student.personal
    404             per_doc = per.getContent()
    405             per_doc.edit(mapping = dp)
    406             per.manage_setLocalRoles(sid, ['Owner',])
    407             wftool.doActionFor(student,'pume_pass')
    408             wftool.doActionFor(student,'admit')
    409             #
    410             # Clearance
    411             #
    412             student.invokeFactory('StudentClearance','clearance')
    413             #wftool.doActionFor(student.clearance,'open')
    414             clearance = student.clearance
    415             dc = {'Title': 'Clearance/Eligibility Record'}
    416             clearance = student.clearance
    417             date_str = result.get(csv_d['birthday'])
    418             try:
    419                 date = DateTime.DateTime(date_str)
    420             except:
    421                 #import pdb;pdb.set_trace()
    422                 date = None
    423             dc['birthday'] = date
    424             clearance.getContent().edit(mapping=dc)
    425             clearance.manage_setLocalRoles(sid, ['Owner',])
    426             #
    427             # Study Course
    428             #
    429             student.invokeFactory('StudentStudyCourse','study_course')
    430             study_course = student.study_course
    431             dsc = {}
    432             catalog_entry['level'] = dsc['current_level'] = levels.get(da['entry_mode'],'100')
    433             #catalog_entry['level'] = dsc['current_level'] = '100'  # Attention: not for DE students
    434             catalog_entry['session'] = dsc['current_session'] = da['entry_session']
    435             catalog_entry['mode'] = dsc['current_mode'] = da['entry_mode']
    436             catalog_entry['course'] = dsc['study_course'] = cert_id
    437             catalog_entry['faculty'] = certificate['faculty']
    438             catalog_entry['department'] = certificate['department']
    439             catalog_entry['verdict'] = dsc['current_verdict'] = 'N/A'
    440             catalog_entry['review_state'] = self.portal_workflow.getInfoFor(student,'review_state',None)
    441             study_course.getContent().edit(mapping=dsc)
    442             #import pdb;pdb.set_trace()
    443             self.students_catalog.addRecord(**catalog_entry)
    444             if tr_count > 100:
    445                 if len(no_import) > 0:
    446                     open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
    447                              '\n'.join(no_import) + "\n")
    448                     no_import = []
    449                 em = '%d transactions commited\n' % tr_count
    450                 transaction.commit()
    451                 logger.info(em)
    452                 total += tr_count
    453                 tr_count = 0
    454         open("%s/import/%s_not_imported.csv" % (i_home,name),"a").write(
    455                                                 '\n'.join(no_import))
    456         return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
    457     ###)
    458118
    459119    security.declareProtected(ModifyPortalContent,"transferStudents")###(
    … …  
    619279    ###)
    620280
    621     security.declareProtected(ModifyPortalContent,"importReturningStudents")###(
    622     def importReturningStudents(self):
    623         """load Returning Studentdata from CSV values"""
    624         import transaction
    625         import random
    626         #from pdb import set_trace
    627         wftool = self.portal_workflow
    628         current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
    629         #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
    630         students_folder = self.portal_url.getPortalObject().campus.students
    631         tr_count = 1
    632         total = 0
    633         #name = 'pume_results'
    634         name = 'Returning'
    635         table = self.returning_import
    636         no_import = []
    637         imported = []
    638         logger = logging.getLogger('Students.StudentsFolder.importReturningStudents')
    639         try:
    640             returning = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
    641         except:
    642             logger.error('Error reading %s.csv' % name)
    643             return
    644         l = self.portal_catalog({'meta_type': "Certificate"})
    645         certs = {}
    646         cert_docs = {}
    647         for f in l:
    648             certs[f.getId] = f.getObject().getContent()
    649         start = True
    650         res = table()
    651         regs = []
    652         if len(res) > 0:
    653             regs = [s.matric_no for s in res]
    654         #import pdb;pdb.set_trace()
    655         for student in returning:
    656             if start:
    657                 start = False
    658                 logger.info('Start loading from %s.csv' % name)
    659                 s = ','.join(['"%s"' % fn for fn in student.keys()])
    660                 imported.append(s)
    661                 no_import.append('%s,"Error"' % s)
    662                 format = ','.join(['"%%(%s)s"' % fn for fn in student.keys()])
    663                 format_error = format + ',"%(Error)s"'
    664                 no_certificate = "no certificate %s" % format
    665             student['matric_no'] = matric_no = student.get('matric_no').upper()
    666             student['Mode_of_Entry'] = entry_mode = student.get('Mode of Entry').upper()
    667             student['Permanent_Address'] = perm_address = student.get('Permanent Address')
    668             if matric_no == '':
    669                 student['Error'] = "Empty matric_no"
    670                 no_import.append( format_error % student)
    671                 continue
    672             if matric_no in regs or self.returning_import(matric_no = matric_no):
    673                 student['Error'] = "Duplicate"
    674                 no_import.append( format_error % student)
    675                 continue
    676             cert_id = makeCertificateCode(student.get('Coursemajorcode'))
    677             if cert_id not in certs.keys():
    678                 student['Error'] = "No Certificate %s" % cert_id
    679                 no_import.append( format_error % student)
    680                 continue
    681             try:
    682                 table.addRecord(**student)
    683             except ValueError:
    684                 student['Error'] = "Duplicate"
    685                 no_import.append( format_error % student)
    686                 continue
    687             regs.append(student.get('matric_no'))
    688             imported.append(format % student)
    689             tr_count += 1
    690             if tr_count > 1000:
    691                 if len(no_import) > 0:
    692                     open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
    693                              '\n'.join(no_import) + '\n')
    694                     no_import = []
    695                 open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
    696                                             '\n'.join(no_import) + "\n")
    697                 imported = []
    698                 em = '%d transactions commited total %s\n' % (tr_count,total)
    699                 transaction.commit()
    700                 regs = []
    701                 logger.info(em)
    702                 total += tr_count
    703                 tr_count = 0
    704         open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
    705                                             '\n'.join(imported))
    706         open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
    707                                                 '\n'.join(no_import))
    708         return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
    709     ###)
    710 
    711     security.declareProtected(ModifyPortalContent,"fixAllNames")###(
    712     def fixAllNames(self):
    713         "fix all students names"
    714         import transaction
    715         response = self.REQUEST.RESPONSE
    716         logger = logging.getLogger('fixAllNames')
    717         logger.info('Start')
    718         students = self.portal_catalog(portal_type='Student')
    719         count = 0
    720         total = 0
    721         for student in students:
    722             scat_res = self.students_catalog(id = student.getId)
    723             if not scat_res:
    724                 self.students_catalog.addRecord(id = student.getId)
    725                 scat_res = self.students_catalog(id = student.getId)
    726             student_entry = scat_res[0]
    727             old_new = self.fixName(student,student_entry)
    728             count += 1
    729             response_write(response,'"%d","%s",%s' % (count + total,student_entry.id,old_new))
    730             if count > 2000:
    731                 transaction.commit()
    732                 logger.info("%d transactions commited" % count)
    733                 total += count
    734                 count = 0
    735     ###)
    736 
    737     security.declareProtected(ModifyPortalContent,"fixName")###(
    738     def fixName(self,student_brain, student_entry):
    739         "fix the name of a student"
    740         fix = "first"
    741         if student_entry.get('name_fixed',None) == fix:
    742             return "Name already fixed"
    743         student_id = student_entry.id
    744         new_student = student_entry.jamb_reg_no.startswith('6')
    745         student_obj = student_brain.getObject()
    746         personal = getattr(student_obj,'personal',None)
    747         invalid = ''
    748         if personal is None:
    749             return '"%s","Returning","%s","%s"' % (invalid,student_entry.name,"not logged in")
    750         per_doc = personal.getContent()
    751         old_first = per_doc.firstname
    752         old_middle = per_doc.middlename
    753         old_last = per_doc.lastname
    754         new_first = ''
    755         new_middle = ''
    756         new_last = ''
    757         if new_student:
    758             if not old_first and not old_middle and old_last:
    759                 new_names = [n.capitalize() for n in old_last.split()]
    760                 if len(new_names) > 1:
    761                     old_first = new_names[0]
    762                     old_last = new_names[-1]
    763                     old_middle = ' '.join(new_names[1:-1])
    764                 else:
    765                     old_last = new_names[0]
    766                     old_first = ''
    767                     old_middle = ''
    768             if old_first:
    769                 new_first = old_first
    770             if old_middle:
    771                 new_middle = old_middle
    772             if old_last:
    773                 new_last = old_last
    774             if old_first.find('<') != -1 or\
    775                old_first.find('>') != -1 or\
    776                old_middle.find('<') != -1 or\
    777                old_middle.find('>') != -1 or\
    778                old_last.find('<') != -1 or\
    779                old_last.find('>') != -1:
    780                    invalid = "invalid characters"
    781         else:
    782             new_first = old_first
    783             if new_first.strip() == '-':
    784                 new_first = ''
    785             new_middle = old_middle
    786             if new_middle.strip() == '-':
    787                 new_middle = ''
    788             new_last = old_last
    789             if new_last.strip() == '-':
    790                 new_last = ''
    791         name = "%(new_first)s %(new_middle)s %(new_last)s" % vars()
    792         if new_student:
    793             text = "New"
    794         else:
    795             text = "Returning"
    796         old_new = '"%s","%s","%s","%s"' % (invalid,text,
    797                                            student_entry.name,
    798                                            name)
    799         if not invalid:
    800             self.students_catalog.modifyRecord(id = student_id,
    801                                       name_fixed = fix,
    802                                       name = name)
    803             per_doc.edit(mapping = {'firstname' : new_first,
    804                                 'middlename' : new_middle,
    805                                 'lastname' : new_last,
    806                                 })
    807         return old_new
    808     ###)
    809 
    810     security.declareProtected(ModifyPortalContent,"updateReturningStudents")###(
    811     def updateReturningStudents(self):
    812         """load and overwrite Returning Student Data from CSV values"""
    813         import transaction
    814         import random
    815         #from pdb import set_trace
    816         wftool = self.portal_workflow
    817         current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
    818         #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
    819         students_folder = self.portal_url.getPortalObject().campus.students
    820         tr_count = 1
    821         total = 0
    822         #name = 'pume_results'
    823         name = 'Returning_update'
    824         table = self.returning_import
    825         no_import = []
    826         imported = []
    827         logger = logging.getLogger('Students.StudentsFolder.updateReturningStudents')
    828         try:
    829             returning = 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 returning:
    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             matric_no = student.get('matric_no').upper()
    854             student['matric_no'] = matric_no
    855             if matric_no == '':
    856                 student['Error'] = "Empty matric_no"
    857                 no_import.append( format_error % student)
    858                 continue
    859 #            if matric_no in regs or self.returning_import(matric_no = matric_no):
    860 #                student['Error'] = "Duplicate"
    861 #                no_import.append( format_error % student)
    862 #                continue
    863 #            cert_id = makeCertificateCode(student.get('Coursemajorcode'))
    864 #            if cert_id not in certs.keys():
    865 #                student['Error'] = "No Certificate %s" % cert_id
    866 #                no_import.append( format_error % student)
    867 #                continue
    868             try:
    869                 table.modifyRecord(**student)
    870             except KeyError:
    871                 #import pdb;pdb.set_trace()
    872                 student['Error'] = "no Student found to update"
    873                 no_import.append( format_error % student)
    874                 continue
    875             #s = self.students_catalog(matric_no=matric_no)
    876             #if s:
    877             #    level = "%s" % (int(student.get('Level')) + 100)
    878             #    self.students_catalog.modifyRecord(id = s[0].id,
    879             #                                           level=level)
    880 
    881             regs.append(student.get('matric_no'))
    882             imported.append(format % student)
    883             tr_count += 1
    884             if tr_count > 1000:
    885                 if len(no_import) > 0:
    886                     open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
    887                              '\n'.join(no_import) + '\n')
    888                     no_import = []
    889                 open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
    890                                             '\n'.join(no_import) + "\n")
    891                 imported = []
    892                 em = '%d transactions commited total %s\n' % (tr_count,total)
    893                 transaction.commit()
    894                 regs = []
    895                 logger.info(em)
    896                 total += tr_count
    897                 tr_count = 0
    898         open("%s/import/%simported%s.csv" % (i_home,name,current),"a").write(
    899                                             '\n'.join(imported))
    900         open("%s/import/%s_not_imported%s.csv" % (i_home,name,current),"a").write(
    901                                                 '\n'.join(no_import))
    902         return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
    903     ###)
    904 
    905     security.declareProtected(ModifyPortalContent,"exportStudents")###(
    906     def exportStudents(self):
    907         """export Studentsdata to a file"""
    908         member = self.portal_membership.getAuthenticatedMember()
    909         logger = logging.getLogger('Students.exportStudents')
    910         current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
    911         students_folder = self.portal_url.getPortalObject().campus.students
    912         export_file = "%s/export/students_%s.csv" % (i_home,current)
    913 
    914         from Products.AdvancedQuery import Eq, Between, Le,In,MatchRegexp
    915         aq_students = self.students_catalog.evalAdvancedQuery
    916         toexport = {'students_catalog': ("id",
    917                                          "matric_no",
    918                                          "jamb_reg_no",
    919                                          "name",
    920                                          "review_state",
    921                                          "entry_session",
    922                                          "session",
    923                                          "entry_mode",
    924                                          "mode",
    925                                          "verdict",
    926                                          "sex",
    927                                          "email",
    928                                          "phone",
    929                                          "faculty",
    930                                          "department",
    931                                          "course",
    932                                          "level",
    933                                         ),
    934                     'personal': ('firstname',
    935                                  'middlename',
    936                                  'lastname',
    937                                  'perm_address',
    938                                  ),
    939                     'clearance': ('state',  # is not an attribute of clearance but is needed for splitting lga
    940                                   'lga',
    941                                  )
    942                   }
    943         res_list = []
    944         lines = []
    945         fields = []
    946         with_lga = False
    947         for k in toexport.keys():
    948             for f in toexport[k]:
    949                 if f == 'lga' :
    950                     with_lga = True
    951                 fields.append(f)
    952         headline = ','.join(fields).replace('level','current_level')
    953         open(export_file,"a").write(headline +'\n')
    954         format = '"%(' + ')s","%('.join(fields) + ')s"'
    955         query = In('review_state',('cleared_and_validated',
    956                                 'clearance_requested',
    957                                 'school_fee_paid',
    958                                 'courses_registered',
    959                                 'courses_validated'))
    960         #query = In('review_state',('clearance_requested'))
    961         students = aq_students(query)
    962         nr2export = len(students)
    963         logger.info('%s starts exportStudents, %s student records to export' % (member,nr2export))
    964         chunk = 1000
    965         total = 0
    966         start = DateTime.DateTime().timeTime()
    967         start_chunk = DateTime.DateTime().timeTime()
    968         ## alternative method slightly slower
    969         # student_recs = {}
    970         # for s in students:
    971         #      student_recs[s.id] = s
    972         # catalog_recs = {}
    973         # brains = self.portal_catalog(portal_type = 'Student')
    974         # for cat_rec in brains:
    975         #     sid = cat_rec.getId
    976         #     catalog_recs[sid] = cat_rec
    977         # #import pdb;pdb.set_trace()
    978         # start = DateTime.DateTime().timeTime()
    979         # start_chunk = DateTime.DateTime().timeTime()
    980         # for student in students:
    981         #     if student.id not in student_recs.keys():
    982         #         continue
    983         #     not_all = False
    984         #     d = self.getFormattedStudentEntry(student_recs[student.id])
    985         #     student_obj = catalog_recs[student.id].getObject()
    986         for student in students:
    987             not_all = False
    988             d = self.getFormattedStudentEntry(student)
    989             student_obj = getattr(students_folder,student.id)
    990             for k in toexport.keys()[1:]:
    991                 try:
    992                     object = getattr(student_obj,k)
    993                     object_doc = object.getContent()
    994                 except:
    995                     logger.info('%s %s record not found' % (student.id,k))
    996                     not_all = True
    997                     continue
    998                 for f in toexport[k]:
    999                     d[f] = getattr(object_doc,f,'')
    1000             if not_all:
    1001                 continue
    1002             if with_lga:
    1003                 d['state'],d['lga'] = formatLGA(d['lga'],voc = self.portal_vocabularies.local_gov_areas)
    1004             lines.append(format % d)
    1005             total += 1
    1006             if total and not total % chunk or total == len(students):
    1007                 open(export_file,"a").write('\n'.join(lines) +'\n')
    1008                 anz = len(lines)
    1009                 logger.info("wrote %(anz)d  total written %(total)d" % vars())
    1010                 end_chunk = DateTime.DateTime().timeTime()
    1011                 duration = end_chunk-start_chunk
    1012                 per_record = duration/anz
    1013                 till_now = end_chunk - start
    1014                 avarage_per_record = till_now/total
    1015                 estimated_end = DateTime.DateTime(start + avarage_per_record * nr2export)
    1016                 estimated_end = estimated_end.strftime("%H:%M:%S")
    1017                 logger.info('%(duration)4.1f, %(per_record)4.3f,end %(estimated_end)s' % vars())
    1018                 start_chunk = DateTime.DateTime().timeTime()
    1019                 lines = []
    1020         end = DateTime.DateTime().timeTime()
    1021         logger.info('total time %6.2f m' % ((end-start)/60))
    1022         filename, extension = os.path.splitext(export_file)
    1023         from subprocess import call
    1024         msg = "wrote %(total)d records to %(export_file)s" % vars()
    1025         try:
    1026             retcode = call('gzip %s' % (export_file),shell=True)
    1027             if retcode == 0:
    1028                 msg = "wrote %(total)d records to %(export_file)s.gz" % vars()
    1029         except OSError, e:
    1030             retcode = -99
    1031             logger.info("zip failed with %s" % e)
    1032         logger.info(msg)
    1033         args = {'portal_status_message': msg}
    1034         #url = self.REQUEST.get('URL1') + '?' + urlencode(args)
    1035         url = self.REQUEST.get('URL2')
    1036         return self.REQUEST.RESPONSE.redirect(url)
    1037     ###)
    1038281
    1039282    security.declareProtected(ModifyPortalContent,"dumpStudentsCatalog")###(
    … …  
    1216459    ###)
    1217460
    1218     security.declareProtected(ModifyPortalContent,"updateStudyCourse")###(
    1219     def updateStudyCourse(self):
    1220         """update StudyCourse from CSV values"""
    1221         import transaction
    1222         import random
    1223         from pdb import set_trace
    1224         wftool = self.portal_workflow
    1225         #students_folder = self.portal_catalog({'meta_type': 'StudentsFolder'})[-1].getObject()
    1226         students_folder = self.portal_url.getPortalObject().campus.students
    1227         csv_d = {'jamb_reg_no': "RegNumber",
    1228                  'jamb_lastname': "Name",
    1229                  'session': "Session",
    1230                  'pume_tot_score': "PUME SCORE",
    1231                  'jamb_score': "JambScore",
    1232                  'jamb_sex': "Sex",
    1233                  'jamb_state': "State",
    1234 ##                 'jamb_first_cos': "AdminCourse",
    1235                  'faculty': "AdminFaculty",
    1236                  'course_code': "AdmitCoscode",
    1237                  'stud_status':"AdmitStatus",
    1238                  'department': "AdmitDept",
    1239                  'jamb_lga': "LGA",
    1240                  'app_email': "email",
    1241                  'app_mobile': "PhoneNumbers",
    1242                  }
    1243         csv_fields = [f[1] for f in csv_d.items()]
    1244         tr_count = 0
    1245         total = 0
    1246         #name = 'pume_results'
    1247         name = 'StudyCourseChange'
    1248         no_import = []
    1249         s = ','.join(['"%s"' % fn for fn in csv_fields])
    1250         no_import.append('"Error",%s' % s)
    1251         format = '"%(Error)s",' + ','.join(['"%%(%s)s"' % fn for fn in csv_fields])
    1252         no_certificate = "no certificate %s" % format
    1253         open("%s/import/%s_not_imported.csv" % (i_home,name),"w").write(
    1254                     '\n'.join(no_import))
    1255         logger = logging.getLogger('Students.StudentsFolder.updateStudyCourse')
    1256         logger.info('Start loading from %s.csv' % name)
    1257         l = self.portal_catalog({'meta_type': "Certificate"})
    1258         try:
    1259             result = csv.DictReader(open("%s/import/%s.csv" % (i_home,name),"rb"))
    1260         except:
    1261             logger.error('Error reading %s.csv' % name)
    1262             return
    1263         for jamb in result:
    1264             jamb['Error'] = "Processing "
    1265             logger.info(format % jamb)
    1266             jamb_reg_no = jamb.get(csv_d['jamb_reg_no'])
    1267             res = self.portal_catalog({'portal_type': "StudentApplication",
    1268                                      'SearchableText': jamb_reg_no })
    1269             if not res:
    1270                 em = 'Student with jamb_reg_no %s does not exists\n' % jamb_reg_no
    1271                 logger.info(em)
    1272                 jamb['Error'] = "Student does not exist"
    1273                 no_import.append(format % jamb)
    1274                 continue
    1275             sid = res[0].getPath().split('/')[-2]
    1276             cert_id = makeCertificateCode(jamb.get(csv_d['course_code']))
    1277             res = self.portal_catalog(portal_type = "Certificate", id = cert_id)
    1278             if not res:
    1279                 em = 'No Certificate with ID %s \n' % cert_id
    1280                 logger.info(em)
    1281                 jamb['Error'] = "No Certificate %s" % cert_id
    1282                 no_import.append( format % jamb)
    1283                 continue
    1284             cert_brain = res[0]
    1285             catalog_entry = {}
    1286             student = getattr(self,sid)
    1287             #
    1288             # Study Course
    1289             #
    1290             study_course = student.study_course
    1291             dsc = {}
    1292             cert_pl = cert_brain.getPath().split('/')
    1293             catalog_entry['id'] = sid
    1294             catalog_entry['faculty'] = cert_pl[-4]
    1295             catalog_entry['department'] = cert_pl[-3]
    1296             catalog_entry['course'] = cert_id
    1297             dsc['study_course'] = cert_id
    1298             study_course.getContent().edit(mapping=dsc)
    1299             self.students_catalog.modifyRecord(**catalog_entry)
    1300             if tr_count > 10:
    1301                 if len(no_import) > 1:
    1302                     open("%s/import/%s_not_imported.csv" % (i_home,name),"w+").write(
    1303                              '\n'.join(no_import))
    1304                     no_import = []
    1305                 em = '%d transactions commited\n' % tr_count
    1306                 transaction.commit()
    1307                 logger.info(em)
    1308                 total += tr_count
    1309                 tr_count = 0
    1310             tr_count += 1
    1311         return self.REQUEST.RESPONSE.redirect("%s" % self.REQUEST.get('URL1'))
    1312     ###)
     461
    1313462
    1314463    security.declareProtected(View,"fixOwnership") ###(
Note: See TracChangeset for help on using the changeset viewer.