source: main/waeup.uniben/trunk/src/waeup/uniben/applicants/utils.py

## $Id: utils.py 17826 2024-06-27 16:10:40Z henrik $
##
## Copyright (C) 2011 Uli Fouquet & Henrik Bettermann
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
"""General helper functions and utilities for the application section.
"""

import grok
from time import time
from datetime import datetime
from kofacustom.nigeria.applicants.utils import NigeriaApplicantsUtils
from waeup.kofa.applicants.workflow import (INITIALIZED,
    STARTED, PAID, ADMITTED, NOT_ADMITTED, SUBMITTED, CREATED)
from waeup.uniben.applicants.interfaces import REGISTRATION_CATS, DESTINATION_COST
from waeup.uniben.interfaces import MessageFactory as _

class CustomApplicantsUtils(NigeriaApplicantsUtils):
    """A collection of parameters and methods subject to customization.
    """

    ADDITIONAL_FILES = (
                 ('Eligibility Form','eligibility'),
                 ('Statement of Result','res_stat'),
                 )

    APP_TYPES_DICT = {
        'pude': ['Post-UDE Screening', 'PUDE'],
        'sandwich': ['Part-Time Degree in Education', 'SAND'],
        'pt': ['Part-Time Degree Programmes', 'PTP'],
        'ptext': ['Part-Time Degree Programmes (extended application)', 'PTP'],
        'putme': ['Post-UTME Screening Exercise', 'PUTME'],
        'app': ['General Studies', 'APP'],
        'cest': ['Common Entry Screening Test', 'CEST'],
        'ct': ['Certificate Programmes', 'CTP'],
        'dp': ['Diploma Programmes', 'DPP'],
        'dpft': ['Diploma Full-Time Programmes', 'DPP'],
        'pg': ['Postgraduate Programmes (main advert)', 'PG'],
        'pgcoe': ['CoE Programmes', 'PG'],
        'pgn': ['NILS Postgraduate Programmes', 'PG'],
        'pgsp': ['SPESSE Postgraduate Programmes', 'PG'],
        'pre': ['JUPEB Pre-Degree (Foundation) Studies', 'PRE'],
        'cbt': ['UNIBEN CBT Practice Test', 'CBT'],
        'ab': ['Asaba Programmes', 'ASA'],
        'ak': ['Akoka Programmes', 'AKO'],
        'akj': ['Akoka JUPEB', 'AKO'],
        'ictwk': ['ICT Week Registration', 'ICT'],
        'ase': ['Uniben Admission Screening Exercise', 'ASE'],
        'asea': ['Uniben Admission Screening Exercise '
                 '(1st supplementary advert)', 'ASE'],
        'aseb': ['Uniben Admission Screening Exercise '
                 '(2nd supplementary advert)', 'ASE'],
        'spft': ['Special Full-Time Programmes', 'SP'],
        'tscf': ['Transcript (without student record)', 'TRF'],
        'tscs': ['Transcript (with student record)', 'TRS'],
        'flc': ['French Language Centre', 'FR'],
        'cdl': ['Centre For Distance Learning Programmes', 'CDL'],
        }


    SEPARATORS_DICT = {
        'form.applicant_id': _(u'Base Data'),
        'form.course1': _(u'Programmes/Courses Desired'),
        'form.hq_type': _(u'Higher Education Record'),
        'form.presently': _(u'Course or Programme Presently Attending'),
        'form.nysc_year': _(u'NYSC Information'),
        'form.employer': _(u'Employment History'),
        'form.jamb_reg_number': _(u'JAMB Data'),
        'form.course_admitted': _(u'Application Process Information'),
        'form.pp_school': _(u'Post Primary School Qualification'),
        'form.presently_inst': _(u'Presently attending a course or programme'),
        'form.fst_sit_fname': _(u'Ordinary Level First Sitting Record'),
        'form.scd_sit_fname': _(u'Ordinary Level Second Sitting Record'),
        'form.referees': _(u'Referees'),
        }


    # Temporarily disabled
    def xxx_getApplicantsStatistics(self, container):
        state_stats = {INITIALIZED:0, STARTED:0, PAID:0, SUBMITTED:0,
            ADMITTED:0, NOT_ADMITTED:0, CREATED:0}
        faculty_keys = grok.getSite()['faculties'].keys()
        fac_stats = dict([(i,0) for i in faculty_keys])
        for key in container.keys():
            state = container[key].state
            state_stats[state] += 1
            cert = getattr(container[key],'course1',None)
            if  cert is not None and state == SUBMITTED:
                faculty = cert.__parent__.__parent__.__parent__
                fac_stats[faculty.__name__] += 1
        return state_stats, fac_stats


    def setPaymentDetails(self, container, payment, applicant):
        """Set the payment data of an applicant.
        In contrast to its `StudentsUtils` counterpart, the payment ticket
        must exist and is an argument of this method.
        """
        timestamp = ("%d" % int(time()*10000))[1:]
        if container.year:
            session = str(container.year)
            try:
                session_config = grok.getSite()['configuration'][session]
            except KeyError:
                return _(u'Session configuration object is not available.')
        payment.p_id = "p%s" % timestamp
        payment.p_item = container.title
        if container.year:
            payment.p_session = container.year
        else:
            payment.p_session = datetime.now().year
        payment.amount_auth = 0.0
        if applicant.special:
            if applicant.special_application:
                fee_name = applicant.special_application + '_fee'
                payment.amount_auth = getattr(session_config, fee_name, None)
                payment.p_category = applicant.special_application
            return
        elif applicant.__parent__.prefix == 'ictwk':
            payment.p_category = 'registration'
            for cat in applicant.registration_cats:
                payment.amount_auth += REGISTRATION_CATS[cat][1]
            return
        elif applicant.container_code.startswith('tsc'):
            if not applicant.charge:
                return _(u'No transcript charge selected.')
            cost = DESTINATION_COST[applicant.charge][1]
            payment.amount_auth = applicant.no_copies * cost
            payment.p_category = 'transcript'
            return
        else:
            payment.p_category = 'application'
            container_fee = container.application_fee
            if not container_fee:
                return _('Amount could not be determined.')
            payment.amount_auth = container_fee
        return

    def isPictureEditable(self, container):
        """False if applicants are not allowed to edit uploaded pictures.
        """
        if container.code.startswith('ase'):
            return False
        if container.code.startswith('pude'):
            return False
        return container.with_picture

    def sortCertificates(self, context, resultset):
        """Sort already filtered certificates in `AppCatCertificateSource`.
        """
        resultlist = sorted(resultset, key=lambda
            value: value.__parent__.__parent__.__parent__.code +
            value.__parent__.__parent__.code +
            value.code)
        curr_course = context.course1
        if curr_course is not None and curr_course not in resultlist:
            resultlist = [curr_course,] + resultlist
        return resultlist

    def getCertTitle(self, context, value):
        """Compose the titles in `AppCatCertificateSource`.
        """
        try: title = "%s / %s / %s (%s)" % (
            value.__parent__.__parent__.__parent__.title,
            value.__parent__.__parent__.title,
            value.title, value.code)
        except AttributeError:
            title = "NA / %s (%s)" % (value.title, value.code)
        return title