source: main/waeup.aaue/trunk/src/waeup/aaue/students/utils.py @ 15369

Last change on this file since 15369 was 15368, checked in by Henrik Bettermann, 6 years ago

Add SHS matric number constructor.

  • Property svn:keywords set to Id
File size: 26.4 KB
Line 
1## $Id: utils.py 15368 2019-03-25 06:30:13Z henrik $
2##
3## Copyright (C) 2011 Uli Fouquet & Henrik Bettermann
4## This program is free software; you can redistribute it and/or modify
5## it under the terms of the GNU General Public License as published by
6## the Free Software Foundation; either version 2 of the License, or
7## (at your option) any later version.
8##
9## This program is distributed in the hope that it will be useful,
10## but WITHOUT ANY WARRANTY; without even the implied warranty of
11## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12## GNU General Public License for more details.
13##
14## You should have received a copy of the GNU General Public License
15## along with this program; if not, write to the Free Software
16## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17##
18import grok
19from time import time
20from zope.component import createObject, queryUtility
21from zope.catalog.interfaces import ICatalog
22from waeup.kofa.interfaces import (
23    ADMITTED, CLEARANCE, REQUESTED, CLEARED, RETURNING, PAID,
24    academic_sessions_vocab)
25from kofacustom.nigeria.students.utils import NigeriaStudentsUtils
26from waeup.kofa.accesscodes import create_accesscode
27from waeup.kofa.students.utils import trans
28from waeup.aaue.interswitch.browser import gateway_net_amt, GATEWAY_AMT
29from waeup.aaue.interfaces import MessageFactory as _
30
31MINIMUM_UNITS_THRESHOLD = 15
32
33class CustomStudentsUtils(NigeriaStudentsUtils):
34    """A collection of customized methods.
35
36    """
37
38    PORTRAIT_CHANGE_STATES = (ADMITTED,)
39
40    def GPABoundaries(self, faccode=None, depcode=None,
41                            certcode=None, student=None):
42        if student and student.current_mode.startswith('dp'):
43            return ((1.5, 'IRNS / NER / NYV'),
44                    (2.4, 'Pass'),
45                    (3.5, 'Merit'),
46                    (4.5, 'Credit'),
47                    (5, 'Distinction'))
48        elif student:
49            return ((1, 'FRNS / NER / NYV'),
50                    (1.5, 'Pass'),
51                    (2.4, '3rd Class Honours'),
52                    (3.5, '2nd Class Honours Lower Division'),
53                    (4.5, '2nd Class Honours Upper Division'),
54                    (5, '1st Class Honours'))
55        # Session Results Presentations depend on certificate
56        results = None
57        if certcode:
58            cat = queryUtility(ICatalog, name='certificates_catalog')
59            results = list(
60                cat.searchResults(code=(certcode, certcode)))
61        if results and results[0].study_mode.startswith('dp'):
62            return ((1.5, 'IRNS / NER / NYV'),
63                    (2.4, 'Pass'),
64                    (3.5, 'Merit'),
65                    (4.5, 'Credit'),
66                    (5, 'Distinction'))
67        else:
68            return ((1, 'FRNS / NER / NYV'),
69                    (1.5, 'Pass'),
70                    (2.4, '3rd Class Honours'),
71                    (3.5, '2nd Class Honours Lower Division'),
72                    (4.5, '2nd Class Honours Upper Division'),
73                    (5, '1st Class Honours'))
74
75    def getClassFromCGPA(self, gpa, student):
76        gpa_boundaries = self.GPABoundaries(student=student)
77
78        try:
79            certificate = getattr(student['studycourse'],'certificate',None)
80            end_level = getattr(certificate, 'end_level', None)
81            final_level = max([studylevel.level for studylevel in student['studycourse'].values()])
82            if end_level and final_level >= end_level:
83                dummy, repeat = divmod(final_level, 100)
84                if gpa <= 5.1 and repeat == 20:
85                    # Irrespective of the CGPA of a student, if the He/She has
86                    # 3rd Extension, such student will be graduated with a "Pass".
87                    return 1, gpa_boundaries[1][1]
88        except ValueError:
89            pass
90
91        if gpa < gpa_boundaries[0][0]:
92            # FRNS / Fail
93            return 0, gpa_boundaries[0][1]
94        if student.entry_session < 2013 or \
95            student.current_mode.startswith('dp'):
96            if gpa < gpa_boundaries[1][0]:
97                # Pass
98                return 1, gpa_boundaries[1][1]
99        else:
100            if gpa < gpa_boundaries[1][0]:
101                # FRNS
102                # Pass degree has been phased out in 2013 for non-diploma
103                # students
104                return 0, gpa_boundaries[0][1]
105        if gpa < gpa_boundaries[2][0]:
106            # 3rd / Merit
107            return 2, gpa_boundaries[2][1]
108        if gpa < gpa_boundaries[3][0]:
109            # 2nd L / Credit
110            return 3, gpa_boundaries[3][1]
111        if gpa < gpa_boundaries[4][0]:
112            # 2nd U / Distinction
113            return 4, gpa_boundaries[4][1]
114        if gpa <= gpa_boundaries[5][0]:
115            # 1st
116            return 5, gpa_boundaries[5][1]
117        return
118
119    def getDegreeClassNumber(self, level_obj):
120        """Get degree class number (used for SessionResultsPresentation
121        reports).
122        """
123        certificate = getattr(level_obj.__parent__,'certificate', None)
124        end_level = getattr(certificate, 'end_level', None)
125        if end_level and level_obj.level >= end_level:
126            if level_obj.level > end_level:
127                # spill-over level
128                if level_obj.gpa_params[1] == 0:
129                    # no credits taken
130                    return 0
131            elif level_obj.gpa_params[1] < MINIMUM_UNITS_THRESHOLD:
132                # credits taken below limit
133                return 0
134            failed_courses = level_obj.passed_params[4]
135            not_taken_courses = level_obj.passed_params[5]
136            if '_m' in failed_courses:
137                return 0
138            if len(not_taken_courses) \
139                and not not_taken_courses == 'Nil':
140                return 0
141        elif level_obj.gpa_params[1] < MINIMUM_UNITS_THRESHOLD:
142            # credits taken below limit
143            return 0
144        if level_obj.level_verdict in ('FRNS', 'NER', 'NYV'):
145            return 0
146        # use gpa_boundaries above
147        return self.getClassFromCGPA(
148            level_obj.cumulative_params[0], level_obj.student)[0]
149
150    def increaseMatricInteger(self, student):
151        """Increase counter for matric numbers.
152        This counter can be a centrally stored attribute or an attribute of
153        faculties, departments or certificates. In the base package the counter
154        is as an attribute of the site configuration container.
155        """
156        if student.current_mode in ('ug_pt', 'de_pt', 'shs'):
157            grok.getSite()['configuration'].next_matric_integer += 1
158            return
159        elif student.is_postgrad:
160            grok.getSite()['configuration'].next_matric_integer_3 += 1
161            return
162        elif student.current_mode in ('dp_ft',):
163            grok.getSite()['configuration'].next_matric_integer_4 += 1
164            return
165        grok.getSite()['configuration'].next_matric_integer_2 += 1
166        return
167
168    def _concessionalPaymentMade(self, student):
169        if len(student['payments']):
170            for ticket in student['payments'].values():
171                if ticket.p_state == 'paid' and \
172                    ticket.p_category == 'concessional':
173                    return True
174        return False
175
176    def constructMatricNumber(self, student):
177        faccode = student.faccode
178        depcode = student.depcode
179        certcode = student.certcode
180        degree = getattr(
181            getattr(student.get('studycourse', None), 'certificate', None),
182                'degree', None)
183        year = unicode(student.entry_session)[2:]
184        if not student.state in (PAID, ) or not student.is_fresh or \
185            student.current_mode in ('found', 'ijmbe'):
186            return _('Matriculation number cannot be set.'), None
187        #if student.current_mode not in ('mug_ft', 'mde_ft') and \
188        #    not self._concessionalPaymentMade(student):
189        #    return _('Matriculation number cannot be set.'), None
190        if student.is_postgrad:
191            next_integer = grok.getSite()['configuration'].next_matric_integer_3
192            if not degree or next_integer == 0:
193                return _('Matriculation number cannot be set.'), None
194            if student.faccode in ('IOE'):
195                return None, "AAU/SPS/%s/%s/%s/%05d" % (
196                    faccode, year, degree, next_integer)
197            return None, "AAU/SPS/%s/%s/%s/%s/%05d" % (
198                faccode, depcode, year, degree, next_integer)
199        if student.current_mode in ('shs',):
200            next_integer = grok.getSite()['configuration'].next_matric_integer
201            if next_integer == 0:
202                return _('Matriculation number cannot be set.'), None
203            return None, "SHS/%s/%s/%s/%05d" % (
204                faccode, depcode, year, next_integer)
205        if student.current_mode in ('ug_pt', 'de_pt'):
206            next_integer = grok.getSite()['configuration'].next_matric_integer
207            if next_integer == 0:
208                return _('Matriculation number cannot be set.'), None
209            return None, "PTP/%s/%s/%s/%05d" % (
210                faccode, depcode, year, next_integer)
211        if student.current_mode in ('dp_ft',):
212            next_integer = grok.getSite()['configuration'].next_matric_integer_4
213            if next_integer == 0:
214                return _('Matriculation number cannot be set.'), None
215            return None, "IOE/DIP/%s/%05d" % (year, next_integer)
216        next_integer = grok.getSite()['configuration'].next_matric_integer_2
217        if next_integer == 0:
218            return _('Matriculation number cannot be set.'), None
219        if student.faccode in ('FBM', 'FCS'):
220            return None, "CMS/%s/%s/%s/%05d" % (
221                faccode, depcode, year, next_integer)
222        return None, "%s/%s/%s/%05d" % (faccode, depcode, year, next_integer)
223
224    def getReturningData(self, student):
225        """ This method defines what happens after school fee payment
226        of returning students depending on the student's senate verdict.
227        """
228        prev_level = student['studycourse'].current_level
229        cur_verdict = student['studycourse'].current_verdict
230        if cur_verdict in ('A','B','L','M','N','Z',):
231            # Successful student
232            new_level = divmod(int(prev_level),100)[0]*100 + 100
233        elif cur_verdict == 'C':
234            # Student on probation
235            new_level = int(prev_level) + 10
236        else:
237            # Student is somehow in an undefined state.
238            # Level has to be set manually.
239            new_level = prev_level
240        new_session = student['studycourse'].current_session + 1
241        return new_session, new_level
242
243    def _isPaymentDisabled(self, p_session, category, student):
244        academic_session = self._getSessionConfiguration(p_session)
245        if category.startswith('schoolfee'):
246            if 'sf_all' in academic_session.payment_disabled:
247                return True
248            if 'sf_pg' in academic_session.payment_disabled and \
249                student.is_postgrad:
250                return True
251            if 'sf_ug_pt' in academic_session.payment_disabled and \
252                student.current_mode in ('ug_pt', 'de_pt'):
253                return True
254            if 'sf_found' in academic_session.payment_disabled and \
255                student.current_mode == 'found':
256                return True
257        if category.startswith('clearance') and \
258            'cl_regular' in academic_session.payment_disabled and \
259            student.current_mode in ('ug_ft', 'de_ft', 'mug_ft', 'mde_ft'):
260            return True
261        if category == 'hostel_maintenance' and \
262            'maint_all' in academic_session.payment_disabled:
263            return True
264        return False
265
266    def setPaymentDetails(self, category, student,
267            previous_session=None, previous_level=None):
268        """Create Payment object and set the payment data of a student for
269        the payment category specified.
270
271        """
272        details = {}
273        p_item = u''
274        amount = 0.0
275        error = u''
276        if previous_session:
277            if previous_session < student['studycourse'].entry_session:
278                return _('The previous session must not fall below '
279                         'your entry session.'), None
280            if category == 'schoolfee':
281                # School fee is always paid for the following session
282                if previous_session > student['studycourse'].current_session:
283                    return _('This is not a previous session.'), None
284            else:
285                if previous_session > student['studycourse'].current_session - 1:
286                    return _('This is not a previous session.'), None
287            p_session = previous_session
288            p_level = previous_level
289            p_current = False
290        else:
291            p_session = student['studycourse'].current_session
292            p_level = student['studycourse'].current_level
293            p_current = True
294        academic_session = self._getSessionConfiguration(p_session)
295        if academic_session == None:
296            return _(u'Session configuration object is not available.'), None
297        # Determine fee.
298        if category == 'transfer':
299            amount = academic_session.transfer_fee
300        elif category == 'transcript_local':
301            amount = academic_session.transcript_fee_local
302        elif category == 'transcript_inter':
303            amount = academic_session.transcript_fee_inter
304        elif category == 'bed_allocation':
305            amount = academic_session.booking_fee
306        elif category == 'restitution':
307            if student.current_session != 2016 \
308                or student.current_mode not in ('ug_ft', 'dp_ft') \
309                or student.is_fresh:
310                return _(u'Restitution fee payment not required.'), None
311            amount = academic_session.restitution_fee
312        elif category == 'hostel_maintenance':
313            amount = 0.0
314            bedticket = student['accommodation'].get(
315                str(student.current_session), None)
316            if bedticket is not None and bedticket.bed is not None:
317                p_item = bedticket.display_coordinates
318                if bedticket.bed.__parent__.maint_fee > 0:
319                    amount = bedticket.bed.__parent__.maint_fee
320                else:
321                    # fallback
322                    amount = academic_session.maint_fee
323            else:
324                return _(u'No bed allocated.'), None
325        elif student.current_mode == 'found' and category not in (
326            'schoolfee', 'clearance', 'late_registration'):
327            return _('Not allowed.'), None
328        elif category.startswith('clearance'):
329            if student.state not in (ADMITTED, CLEARANCE, REQUESTED, CLEARED):
330                return _(u'Acceptance Fee payments not allowed.'), None
331            if student.current_mode in (
332                'ug_ft', 'ug_pt', 'de_ft', 'de_pt',
333                'transfer', 'mug_ft', 'mde_ft') \
334                and category != 'clearance_incl':
335                    return _("Additional fees must be included."), None
336            if student.current_mode == 'ijmbe':
337                amount = academic_session.clearance_fee_ijmbe
338            elif student.current_mode == 'dp_ft':
339                amount = academic_session.clearance_fee_dp
340            elif student.faccode == 'FP':
341                amount = academic_session.clearance_fee_fp
342            elif student.current_mode.endswith('_pt'):
343                if student.is_postgrad:
344                    amount = academic_session.clearance_fee_pg_pt
345                else:
346                    amount = academic_session.clearance_fee_ug_pt
347            elif student.faccode == 'FCS':
348                # Students in clinical medical sciences pay the medical
349                # acceptance fee
350                amount = academic_session.clearance_fee_med
351            elif student.is_postgrad:  # and not part-time
352                if category != 'clearance':
353                    return _("No additional fees required."), None
354                amount = academic_session.clearance_fee_pg
355            else:
356                amount = academic_session.clearance_fee
357            p_item = student['studycourse'].certificate.code
358            if amount in (0.0, None):
359                return _(u'Amount could not be determined.'), None
360            # Add Matric Gown Fee and Lapel Fee
361            if category == 'clearance_incl':
362                amount += gateway_net_amt(academic_session.matric_gown_fee) + \
363                    gateway_net_amt(academic_session.lapel_fee)
364        elif category == 'late_registration':
365            if student.is_postgrad:
366                amount = academic_session.late_pg_registration_fee
367            else:
368                amount = academic_session.late_registration_fee
369        elif category.startswith('schoolfee'):
370            try:
371                certificate = student['studycourse'].certificate
372                p_item = certificate.code
373            except (AttributeError, TypeError):
374                return _('Study course data are incomplete.'), None
375            if student.is_postgrad and category != 'schoolfee':
376                return _("No additional fees required."), None
377            if not previous_session and student.current_mode in (
378                'ug_ft', 'ug_pt', 'de_ft', 'de_pt',
379                'transfer', 'mug_ft', 'mde_ft') \
380                and not category in (
381                'schoolfee_incl', 'schoolfee_1', 'schoolfee_2'):
382                    return _("You must choose a payment which includes "
383                             "additional fees."), None
384            if category in ('schoolfee_1', 'schoolfee_2'):
385                if student.current_mode == 'ug_pt':
386                    return _("Part-time students are not allowed "
387                             "to pay by instalments."), None
388                if student.entry_session < 2015:
389                    return _("You are not allowed "
390                             "to pay by instalments."), None
391            if previous_session:
392                # Students can pay for previous sessions in all
393                # workflow states.  Fresh students are excluded by the
394                # update method of the PreviousPaymentAddFormPage.
395                if previous_level == 100:
396                    amount = getattr(certificate, 'school_fee_1', 0.0)
397                else:
398                    if student.entry_session in (2015, 2016):
399                        amount = getattr(certificate, 'school_fee_2', 0.0)
400                    else:
401                        amount = getattr(certificate, 'school_fee_3', 0.0)
402            elif student.state == CLEARED and category != 'schoolfee_2':
403                amount = getattr(certificate, 'school_fee_1', 0.0)
404                # Cut school fee by 50%
405                if category == 'schoolfee_1' and amount:
406                    amount = gateway_net_amt(amount) / 2 + GATEWAY_AMT
407            elif student.is_fresh and category == 'schoolfee_2':
408                amount = getattr(certificate, 'school_fee_1', 0.0)
409                # Cut school fee by 50%
410                if amount:
411                    amount = gateway_net_amt(amount) / 2 + GATEWAY_AMT
412            elif student.state == RETURNING and category != 'schoolfee_2':
413                if not student.father_name:
414                    return _("Personal data form is not properly filled."), None
415                # In case of returning school fee payment the payment session
416                # and level contain the values of the session the student
417                # has paid for.
418                p_session, p_level = self.getReturningData(student)
419                try:
420                    academic_session = grok.getSite()[
421                        'configuration'][str(p_session)]
422                except KeyError:
423                    return _(u'Session configuration object is not available.'), None
424                if student.entry_session in (2015, 2016, 2017):
425                    amount = getattr(certificate, 'school_fee_2', 0.0)
426                else:
427                    amount = getattr(certificate, 'school_fee_3', 0.0)
428                # Cut school fee by 50%
429                if category == 'schoolfee_1' and amount:
430                    amount = gateway_net_amt(amount) / 2 + GATEWAY_AMT
431            elif category == 'schoolfee_2':
432                amount = getattr(certificate, 'school_fee_2', 0.0)
433                # Cut school fee by 50%
434                if amount:
435                    amount = gateway_net_amt(amount) / 2 + GATEWAY_AMT
436            else:
437                return _('Wrong state.'), None
438            if amount in (0.0, None):
439                return _(u'Amount could not be determined.'), None
440            # Add Student Union Fee, Student Id Card Fee, Sports Dev. Fee,
441            # Library Dev. Fee and Welfare Assurance
442            if category in ('schoolfee_incl', 'schoolfee_1'):
443                if student.current_mode != 'ijmbe':
444                    amount += gateway_net_amt(academic_session.welfare_fee) + \
445                        gateway_net_amt(academic_session.union_fee)
446                if student.entry_session == 2018 and student.is_fresh:
447                    amount += gateway_net_amt(academic_session.sports_fee)
448                    if student.is_postgrad:
449                        amount += gateway_net_amt(academic_session.library_fee_pg)
450                    else:
451                        amount += gateway_net_amt(academic_session.library_fee)
452                if student.entry_session == 2016 \
453                    and student.entry_mode == 'ug_ft' \
454                    and student.state == CLEARED:
455                    amount += gateway_net_amt(academic_session.id_card_fee)
456            # Add non-indigenous fee and session specific penalty fees
457            if student.is_postgrad:
458                amount += academic_session.penalty_pg
459                if student.lga and not student.lga.startswith('edo'):
460                    amount += 20000.0
461            else:
462                amount += academic_session.penalty_ug
463        elif not student.is_postgrad:
464            fee_name = category + '_fee'
465            amount = getattr(academic_session, fee_name, 0.0)
466        if amount in (0.0, None):
467            return _(u'Amount could not be determined.'), None
468        # Create ticket.
469        for key in student['payments'].keys():
470            ticket = student['payments'][key]
471            if ticket.p_state == 'paid' and\
472               ticket.p_category == category and \
473               not ticket.p_category.startswith('transcript') and \
474               ticket.p_item == p_item and \
475               ticket.p_session == p_session:
476                  return _('This type of payment has already been made.'), None
477            # Additional condition in AAUE
478            if category in ('schoolfee', 'schoolfee_incl', 'schoolfee_1'):
479                if ticket.p_state == 'paid' and \
480                   ticket.p_category in ('schoolfee',
481                                         'schoolfee_incl',
482                                         'schoolfee_1') and \
483                   ticket.p_item == p_item and \
484                   ticket.p_session == p_session:
485                      return _(
486                          'Another school fee payment for this '
487                          'session has already been made.'), None
488
489        if self._isPaymentDisabled(p_session, category, student):
490            return _('This category of payments has been disabled.'), None
491        payment = createObject(u'waeup.StudentOnlinePayment')
492        timestamp = ("%d" % int(time()*10000))[1:]
493        payment.p_id = "p%s" % timestamp
494        payment.p_category = category
495        payment.p_item = p_item
496        payment.p_session = p_session
497        payment.p_level = p_level
498        payment.p_current = p_current
499        payment.amount_auth = amount
500        return None, payment
501
502    def _admissionText(self, student, portal_language):
503        inst_name = grok.getSite()['configuration'].name
504        entry_session = student['studycourse'].entry_session
505        entry_session = academic_sessions_vocab.getTerm(entry_session).title
506        text = trans(_(
507            'This is to inform you that you have been offered provisional'
508            ' admission into ${a} for the ${b} academic session as follows:',
509            mapping = {'a': inst_name, 'b': entry_session}),
510            portal_language)
511        return text
512
513    def warnCreditsOOR(self, studylevel, course=None):
514        studycourse = studylevel.__parent__
515        certificate = getattr(studycourse,'certificate', None)
516        current_level = studycourse.current_level
517        if None in (current_level, certificate):
518            return
519        end_level = certificate.end_level
520        if current_level >= end_level:
521            limit = 52
522        else:
523            limit = 48
524        if course and studylevel.total_credits + course.credits > limit:
525            return  _('Maximum credits exceeded.')
526        elif studylevel.total_credits > limit:
527            return _('Maximum credits exceeded.')
528        return
529
530    def getBedCoordinates(self, bedticket):
531        """Return descriptive bed coordinates.
532        This method can be used to customize the `display_coordinates`
533        property method in order to  display a
534        customary description of the bed space.
535        """
536        bc = bedticket.bed_coordinates.split(',')
537        if len(bc) == 4:
538            return bc[0]
539        return bedticket.bed_coordinates
540
541    def getAccommodationDetails(self, student):
542        """Determine the accommodation data of a student.
543        """
544        d = {}
545        d['error'] = u''
546        hostels = grok.getSite()['hostels']
547        d['booking_session'] = hostels.accommodation_session
548        d['allowed_states'] = hostels.accommodation_states
549        d['startdate'] = hostels.startdate
550        d['enddate'] = hostels.enddate
551        d['expired'] = hostels.expired
552        # Determine bed type
553        bt = 'all'
554        if student.sex == 'f':
555            sex = 'female'
556        else:
557            sex = 'male'
558        special_handling = 'regular'
559        d['bt'] = u'%s_%s_%s' % (special_handling,sex,bt)
560        return d
561
562    def checkAccommodationRequirements(self, student, acc_details):
563        msg = super(CustomStudentsUtils, self).checkAccommodationRequirements(
564            student, acc_details)
565        if msg:
566            return msg
567        if student.current_mode not in ('ug_ft', 'de_ft', 'mug_ft', 'mde_ft'):
568            return _('You are not eligible to book accommodation.')
569        return
570
571    # AAUE prefix
572    STUDENT_ID_PREFIX = u'E'
573
574    STUDENT_EXPORTER_NAMES = ('students', 'studentstudycourses',
575            'studentstudylevels', 'coursetickets',
576            'studentpayments', 'studentunpaidpayments',
577            'bedtickets', 'sfpaymentsoverview',
578            'studylevelsoverview', 'combocard', 'bursary',
579            'levelreportdata')
Note: See TracBrowser for help on using the repository browser.