source: main/waeup.kofa/trunk/src/waeup/kofa/students/payments.py @ 9258

## $Id: payments.py 9258 2012-09-30 13:05:04Z 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
##
"""
Student payment components.
"""
import grok
from zope.component.interfaces import IFactory
from zope.interface import implementedBy
from waeup.kofa.interfaces import MessageFactory as _
from waeup.kofa.students.interfaces import (
    IStudentPaymentsContainer, IStudentNavigation, IStudentOnlinePayment)
from waeup.kofa.payments import PaymentsContainer, OnlinePayment
from waeup.kofa.payments.interfaces import IPaymentWebservice
from waeup.kofa.utils.helpers import attrs_to_fields
from waeup.kofa.accesscodes import create_accesscode

class StudentPaymentsContainer(PaymentsContainer):
    """This is a container for student payments.
    """
    grok.implements(IStudentPaymentsContainer, IStudentNavigation)
    grok.provides(IStudentPaymentsContainer)

    def __init__(self):
        super(StudentPaymentsContainer, self).__init__()
        return

    @property
    def student(self):
        return self.__parent__

    def writeLogMessage(self, view, message):
        return self.__parent__.writeLogMessage(view, message)

StudentPaymentsContainer = attrs_to_fields(StudentPaymentsContainer)

class StudentOnlinePayment(OnlinePayment):
    """This is an online payment.
    """
    grok.implements(IStudentOnlinePayment, IStudentNavigation)
    grok.provides(IStudentOnlinePayment)

    def __init__(self):
        super(StudentOnlinePayment, self).__init__()
        return

    @property
    def student(self):
        try:
            return self.__parent__.__parent__
        except AttributeError:
            return None

    @property
    def student_state(self):
        try:
            return self.student.state
        except AttributeError:
            return None

    def writeLogMessage(self, view, message):
        return self.__parent__.__parent__.writeLogMessage(view, message)

    def _createActivationCodes(self):
        student = self.student
        if self.p_category == 'clearance':
            # Create CLR access code
            pin, error = create_accesscode(
                'CLR',0,self.amount_auth,student.student_id)
            if error:
                return error
            self.ac = pin
        elif self.p_category in ('schoolfee', 'schoolfee_1'):
            # Create SFE access code
            pin, error = create_accesscode(
                'SFE',0,self.amount_auth,student.student_id)
            if error:
                return error
            self.ac = pin
        elif self.p_category == 'bed_allocation':
            # Create HOS access code
            pin, error = create_accesscode(
                'HOS',0,self.amount_auth,student.student_id)
            if error:
                return error
            self.ac = pin
        return None

    def doAfterStudentPayment(self):
        """Process student after payment was made.
        """
        if self.p_current:
            error = self._createActivationCodes()
            if error is not None:
                return False, error, error
        log = 'successful payment: %s' % self.p_id
        msg = _('Successful payment')
        return True, msg, log

    def doAfterStudentPaymentApproval(self):
        """Process student after payment was approved.
        """
        if self.p_current:
            error = self._createActivationCodes()
            if error is not None:
                return False, error, error
        log = 'payment approved: %s' % self.p_id
        msg = _('Payment approved')
        return True, msg, log

    def approveStudentPayment(self):
        """Approve payment and process student.
        """
        if self.p_state == 'paid':
            return False, _('This ticket has already been paid.'), None
        self.approve()
        return self.doAfterStudentPaymentApproval()


StudentOnlinePayment = attrs_to_fields(StudentOnlinePayment)

class PaymentWebservice(grok.Adapter):
    """An adapter to publish student data through a webservice.
    """
    grok.context(IStudentOnlinePayment)
    grok.implements(IPaymentWebservice)

    @property
    def display_fullname(self):
        "Name of  payee."
        return self.context.student.display_fullname

    @property
    def id(self):
        "Id of payee"
        return self.context.student.student_id

    @property
    def faculty(self):
        "Faculty of payee"
        return self.context.student.faccode

    @property
    def department(self):
        "Department of payee"
        return self.context.student.depcode

# Student online payments must be importable. So we might need a factory.
class StudentOnlinePaymentFactory(grok.GlobalUtility):
    """A factory for student online payments.
    """
    grok.implements(IFactory)
    grok.name(u'waeup.StudentOnlinePayment')
    title = u"Create a new online payment.",
    description = u"This factory instantiates new online payment instances."

    def __call__(self, *args, **kw):
        return StudentOnlinePayment()

    def getInterfaces(self):
        return implementedBy(StudentOnlinePayment)