Produits Entr'ouvert » w.c.s. » Au quotidien

import random

import string

import urllib

from datetime import datetime as dt

from decimal import Decimal

from quixote import redirect, get_request, get_session

from quixote.directory import Directory

if not set:

    from sets import Set as set

try:

    import eopayment

except ImportError:

    eopayment = None

from qommon.storage import StorableObject

from qommon.form import *

from qommon import errors, get_logger

from wcs.formdef import FormDef

from wcs.formdata import Evolution

from wcs.workflows import WorkflowStatusItem, register_item_class, \

        render_list_of_roles

from wcs.roles import logged_users_role, get_user_roles

def is_payment_supported():

    if not eopayment:

        return False

    return get_cfg('aq-permissions', {}).get('payments', None) is not None

class Regie(StorableObject):

    _names = 'regies'

    label = None

    description = None

    service = None

    service_options = None

    def get_payment_object(self):

        return eopayment.Payment(kind=self.service,

                                 options=self.service_options)

class Invoice(StorableObject):

    _names = 'invoices'

    _hashed_indexes = ['user_id', 'regie_id']

    user_id = None

    regie_id = None

    formdef_id = None

    formdata_id = None

    amount = None

    date = None

    paid = False

    paid_date = None

class Transaction(StorableObject):

    _names = 'transactions'

    _hashed_indexes = ['invoice_ids']

    _indexes = ['eop_transaction_id']

    invoice_ids = None

    eop_transaction_id = None

    start = None

    end = None

    bank_data = None

    def __init__(self, *args, **kwargs):

        self.invoice_ids = list()

        StorableObject.__init__(self, *args, **kwargs)

    def get_new_id(cls):

        keys = cls.keys()

        r = random.SystemRandom()

        while True:

            id = ''.join([r.choice(string.digits) for x in range(16)])

            if not id in keys:

                return id

    get_new_id = classmethod(get_new_id)

class PaymentWorkflowStatusItem(WorkflowStatusItem):

    description = N_('Payment Creation')

    key = 'payment'

    endpoint = False

    by = None

    amount = None

    waiting_status = None

    regie_id = None

    def render_as_line(self):

        if self.by and self.regie_id:

            return _('Payable to %(regie)s by %(roles)s') % {

                'regie': Regie.get(self.regie_id).label,

                'roles': render_list_of_roles(self.by)}

        else:

            return _('Payable (not completed)')

    def get_parameters(self):

        return ('by', 'amount', 'waiting_status', 'regie_id')

    def fill_admin_form(self, form):

        if self.by and not type(self.by) is list:

            self.by = None

        self.add_parameters_widgets(form, self.get_parameters())

    def add_parameters_widgets(self, form, parameters, prefix='', formdef=None):

        if 'amount' in parameters:

            form.add(StringWidget, '%samount' % prefix, title=_('Amount'), value=self.amount)

        if 'by' in parameters:

            form.add(WidgetList, '%sby' % prefix, title=_('By'), element_type=SingleSelectWidget,

                value=self.by,

                add_element_label=_('Add Role'),

                element_kwargs={

                    'render_br': False,

                    'options': [(None, '---'),

                                ('_submitter', _('Sender')),

                                ('_receiver', _('Receiver')),

                                (logged_users_role().id, logged_users_role().name),

                                (None, '----')] + get_user_roles()})

        if 'waiting_status' in parameters:

            form.add(SingleSelectWidget, '%swaiting_status' % prefix,

                title=_('Status while waiting validation'), value = self.waiting_status,

                options = [(None, '---')] + [(x.id, x.name) for x in self.parent.parent.possible_status])

        if 'regie_id' in parameters:

            form.add(SingleSelectWidget, '%sregie_id' % prefix,

                title=_('Regie'), value=self.regie_id,

                options = [(None, '---')] + [(x.id, x.label) for x in Regie.select()])

    def calculate_amount(self, formdata):

        if not self.amount:

            return 0

        if not self.amount.startswith('='):

            return self.amount

        vars = formdata.get_as_dict()

        amount = eval(self.amount[1:], vars)

        # XXX: catch and report the error somehow

        return amount

    def perform(self, formdata):

        invoice = Invoice()

        invoice.user_id = get_request().user.id

        invoice.regie_id = self.regie_id

        invoice.formdef_id = formdata.formdef.id

        invoice.formdata_id = formdata.id

        invoice.amount = self.calculate_amount(formdata)

        invoice.date = dt.now()

        invoice.store()

        wf_status = [x for x in self.parent.parent.possible_status \

                     if x.id == self.waiting_status][0]

        formdata.status = 'wf-%s' % wf_status.id

        formdata.store()

        return get_publisher().get_root_url() + 'myspace/invoices/'

register_item_class(PaymentWorkflowStatusItem)

def request_payment(invoice_ids, url, add_regie=True):

    invoices = [ Invoice.get(invoice_id) for invoice_id in invoice_ids ]

    invoices = filter(lambda x: not x.paid, invoices)

    regie_ids = set([invoice.regie_id for invoice in invoices])

    # Do not apply if more than one regie is used or no invoice is not paid

    if len(invoices) == 0 or len(regie_ids) != 1:

        return redirect(get_publisher().get_root_url() + 'myspace/invoices/')

    if add_regie:

        url = '%s%s' % (url, list(regie_ids)[0])

    transaction = Transaction()

    transaction.store()

    transaction.invoice_ids = invoice_ids

    transaction.start = dt.now()

    amount = Decimal(0)

    for invoice in invoices:

        amount += Decimal(invoice.amount)

    regie = Regie.get(invoice.regie_id)

    payment = regie.get_payment_object()

    (eop_transaction_id, kind, data) = payment.request(amount, next_url=url)

    transaction.eop_transaction_id = eop_transaction_id

    transaction.store()

    if kind == eopayment.URL:

        return redirect(data)

    elif kind == eopayment.FORM:

        raise NotImplementedError()

    else:

        raise NotImplementedError()

class PaymentValidationDirectory(Directory):

    _q_exports = ['redirect']

    def __init__(self, formdata, wfstatusitem, wfstatus):

        self.formdata = formdata

        self.wfstatus = wfstatus

        self.wfstatusitem = wfstatusitem

    def redirect(self):

        invoice = Invoice.get(get_request().form.get('invoice'))

        req = get_request()

        # FIXME: with

        #   url = self.formdata.get_url() + 'payment/'

        # it does not work inside iframe- sites FormData.get_url() use

        # get_server() with clean=True, and I don't if it's necessary or not

        url = self.formdata.get_url()

        return request_payment([invoice.id], url, add_regie=False)

    def _q_lookup(self, component):

        PublicPaymentDirectory._q_lookup(self, component)

        return redirect('..')

class PaymentValidationWorkflowStatusItem(WorkflowStatusItem):

    description = N_('Payment Validation')

    key = 'payment-validation'

    endpoint = False

    directory_name = 'payment'

    directory_class = PaymentValidationDirectory

    next_status = None

    def render_as_line(self):

        return _('Wait for payment validation')

    def get_parameters(self):

        return ('next_status',)

    def add_parameters_widgets(self, form, parameters, prefix='', formdef=None):

        if 'next_status' in parameters:

            form.add(SingleSelectWidget, '%snext_status' % prefix,

                title=_('Status once validated'), value = self.next_status,

                options = [(None, '---')] + [(x.id, x.name) for x in self.parent.parent.possible_status])

    def validated(self, formdata, invoice_id):

        invoice = Invoice.get(invoice_id)

        if invoice.formdata_id != formdata.id:

            raise 'XXX'

        if invoice.formdef_id != formdata.formdef.id:

            raise 'XXX'

        invoice.paid = True

        invoice.paid_date = dt.now()

        invoice.store()

        evo = Evolution()

        evo.time = time.localtime()

        wf_status = [x for x in self.parent.parent.possible_status \

                     if x.id == self.next_status][0]

        evo.status = 'wf-%s' % wf_status.id

        formdata.status = evo.status

        if not formdata.evolution:

            formdata.evolution = []

        formdata.evolution.append(evo)

        formdata.store()

register_item_class(PaymentValidationWorkflowStatusItem)

class PublicPaymentRegieBackDirectory(Directory):

    def _q_lookup(self, component):

        logger = get_logger()

        try:

            regie = Regie.get(component)

        except KeyError:

            raise errors.TraversalError()

        query_string = get_request().get_query()

        payment = regie.get_payment_object()

        (result, eop_transaction_id, bank_data, return_content) = payment.response(query_string)

        if not return_content:

            if result:

                # TODO: Here return success message

                get_session().message = ('error', _('Payment succeeded'))

            else:

                # TODO: here return failure message

                get_session().message = ('info', _('Payment failed'))

            req = get_request()

            url = '%s://%s%s/myspace/invoices/' % (

                    req.get_scheme(), req.get_server(clean=False),

                    urllib.quote(req.environ.get('SCRIPT_NAME')),)

            return redirect(url)

        else:

            get_response().set_content_type('text/plain')

            if result is False:

                logger.error('transaction %s finished with failure, bank_data:%s' % (

                                        eop_transaction_id, bank_data))

                return return_content

            logger.info('transaction %s successful, bank_data:%s' % (

                                    eop_transaction_id, bank_data))

            transaction = Transaction.get_on_index(eop_transaction_id,

                    'eop_transaction_id')

            transaction.end = dt.now()

            transaction.bank_data = bank_data

            transaction.store()

            for invoice_id in transaction.invoice_ids:

                invoice = Invoice.get(invoice_id)

                formdef = FormDef.get(invoice.formdef_id)

                formdata = formdef.data_class().get(invoice.formdata_id)

                wf_status = formdata.get_workflow_status()

                for item in wf_status.items:

                    if isinstance(item, PaymentValidationWorkflowStatusItem):

                        item.validated(formdata, invoice_id)

            return return_content

class PublicPaymentDirectory(Directory):

    _q_exports = ['', 'init', 'back']

    back = PublicPaymentRegieBackDirectory()

    def init(self):

        invoice_ids = get_request().form.get('invoice')

        if type(invoice_ids) is not list:

            invoice_ids = [invoice_ids]

        req = get_request()

        url = '%s://%s%s%spayment/back/' % (

                req.get_scheme(), req.get_server(clean=False),

                urllib.quote(req.environ.get('SCRIPT_NAME')),

                get_publisher().get_root_url())

        return request_payment(invoice_ids, url)