source: main/waeup.kofa/trunk/src/waeup/kofa/utils/utils.py @ 8214

## $Id: utils.py 8181 2012-04-16 16:03:10Z 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 utilities for Kofa.
"""
import os
import grok
import string
import pytz
from random import SystemRandom as r
from zope.i18n import translate
from zope.interface import implements
from waeup.kofa.interfaces import IKofaUtils
from waeup.kofa.interfaces import MessageFactory as _
from waeup.kofa.smtp import send_mail as send_mail_internally
from waeup.kofa.utils.countries import COUNTRIES
from waeup.kofa.utils.helpers import get_sorted_preferred

def send_mail(from_name,from_addr,rcpt_name,rcpt_addr,subject,body,config):
    """Wrapper for the real SMTP functionality in :mod:`waeup.kofa.smtp`.

    Merely here to stay compatible with lots of calls to this place.
    """
    mail_id = send_mail_internally(
        from_name, from_addr, rcpt_name, rcpt_addr,
        subject, body, config)
    return True

#: A list of phone prefixes (order num, country, prefix).
#: Items with same order num will be sorted alphabetically.
#: The lower the order num, the higher the precedence.
INT_PHONE_PREFIXES = [
    (99, _('Germany'), '49'),
    ( 1, _('Nigeria'), '234'),
    (99, _('U.S.'), '1'),
    ]

def sorted_phone_prefixes(data = INT_PHONE_PREFIXES, request=None):
    """Sorted tuples of phone prefixes.

    Ordered as shown above and formatted for use in select boxes.

    If request is given, we'll try to translate all country names in
    order to sort alphabetically correctly.

    XXX: This is a function (and not a constant) as different
    languages might give different orders. This is not tested yet.

    XXX: If we really want to use alphabetic ordering here, we might
    think about caching results of translations.
    """
    if request is not None:
        data = [
            (x, translate(y, context=request), z)
            for x, y, z in data]
    return tuple([
        ('%s (+%s)' % (x[1],x[2]), '+%s' % x[2])
        for x in sorted(data)
        ])

class KofaUtils(grok.GlobalUtility):
    """A collection of parameters and methods subject to customization.

    """
    grok.implements(IKofaUtils)
    # This the only place where we define the portal language
    # which is used for the translation of system messages
    # (e.g. object histories).
    PORTAL_LANGUAGE = 'en'

    PREFERRED_LANGUAGES_DICT = {
        'en':(1, u'English'),
        'fr':(2, u'Français'),
        'de':(3, u'Deutsch'),
        'ha':(4, u'Hausa'),
        'yo':(5, u'Yoruba'),
        'ig':(6, u'Igbo'),
        }

    #: A function to return
    @classmethod
    def sorted_phone_prefixes(cls, data=INT_PHONE_PREFIXES, request=None):
        return sorted_phone_prefixes(data, request)

    EXAM_SUBJECTS_DICT = {
        'math': 'Mathematics',
        'computer_science': 'Computer Science',
        }

    #: Exam grades. The tuple is sorted as it should be displayed in
    #: select boxes.
    EXAM_GRADES = (
        ('A', 'Best'),
        ('B', 'Better'),
        ('C', 'Good'),
        )

    INST_TYPES_DICT = {
        'none': '',
        'faculty': 'Faculty of',
        'department': 'Department of',
        'school': 'School of',
        'office': 'Office for',
        'centre': 'Centre for',
        'institute': 'Institute of',
        'school_for': 'School for',
        'college': 'College of',
        }

    STUDY_MODES_DICT = {
        'ug_ft': 'Undergraduate Full-Time',
        'ug_pt': 'Undergraduate Part-Time',
        'pg_ft': 'Postgraduate Full-Time',
        'pg_pt': 'Postgraduate Part-Time',
        }

    APP_CATS_DICT = {
        'basic': 'Basic Application',
        'no': 'no application',
        'pg': 'Postgraduate',
        'sandwich': 'Sandwich',
        'cest': 'Part-Time, Diploma, Certificate'
        }

    SEMESTER_DICT = {
        1: 'First Semester',
        2: 'Second Semester',
        3: 'Combined',
        9: 'N/A'
        }

    def sendContactForm(self,from_name,from_addr,rcpt_name,rcpt_addr,
                from_username,usertype,portal,body,subject):
        """Send an email with data provided by forms.
        """
        config = grok.getSite()['configuration']
        text = _(u"""Fullname: ${a}
User Id: ${b}
User Type: ${c}
Portal: ${d}

${e}
""")
        text = _(text,
            mapping = {
            'a':from_name,
            'b':from_username,
            'c':usertype,
            'd':portal,
            'e':body})
        body = translate(text, 'waeup.kofa',
            target_language=self.PORTAL_LANGUAGE)
        return send_mail(
            from_name,from_addr,rcpt_name,rcpt_addr,subject,body,config)

    @property
    def tzinfo(self):
        # For Nigeria: pytz.timezone('Africa/Lagos')
        return pytz.utc

    def fullname(self,firstname,lastname,middlename=None):
        """Full name constructor.
        """
        # We do not necessarily have the middlename attribute
        if middlename:
            return string.capwords(
                '%s %s %s' % (firstname, middlename, lastname))
        else:
            return string.capwords(
                '%s %s' % (firstname, lastname))

    def genPassword(self, length=8, chars=string.letters + string.digits):
        """Generate a random password.
        """
        return ''.join([r().choice(chars) for i in range(length)])


    def sendCredentials(self, user, password=None, login_url=None, msg=None):
        """Send credentials as email.

        Input is the applicant for which credentials are sent and the
        password.

        Returns True or False to indicate successful operation.
        """
        subject = 'Your Kofa credentials'
        text = _(u"""Dear ${a},

${b}
Student Registration and Information Portal of
${c}.

Your user name: ${d}
Your password: ${e}
Login page: ${f}

Please remember your user name and keep
your password secret!

Please also note that passwords are case-sensitive.

Regards
""")
        config = grok.getSite()['configuration']
        from_name = config.name_admin
        from_addr = config.email_admin
        rcpt_name = user.title
        rcpt_addr = user.email
        text = _(text,
            mapping = {
            'a':rcpt_name,
            'b':msg,
            'c':config.name,
            'd':user.name,
            'e':password,
            'f':login_url})

        body = translate(text, 'waeup.kofa',
            target_language=self.PORTAL_LANGUAGE)
        return send_mail(
            from_name,from_addr,rcpt_name,rcpt_addr,subject,body,config)