Produits Entr'ouvert » EOPayment

                   'siret': '00000000000001-01', \

               }

           >>> p = Payment(kind=SPPLUS, options=spplus_options)

           >>> print (transaction_id, kind, data) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE

           ('...', 1, 'https://www.spplus.net/paiement/init.do?...')

          Arguments:

          amount -- the amount of money to ask

          email -- the email of the customer (optional)

          usually redundant with the hardwired settings in the bank

          configuration panel. At this url you must use the Payment.response

          method to analyze the bank returned values.

import urllib

import string

import logging

try:

    from cgi import parse_qs

       You must pass the following keys inside the options dictionnary:

        - dummy_service_url, the URL of the dummy payment service, it defaults

          to the one operated by Entr'ouvert.

          payment

        - origin: a human string to display to the user about the origin of

          the request.

        - siret: an identifier for the eCommerce site, fake.

    '''

    description = {

            'caption': 'Dummy payment backend',

            'parameters': [

                {   'name': 'dummy_service_url',

                    'caption': 'URL of the dummy payment service',

                    'default': SERVICE_URL,

                    'type': str,

                },

                {   'name': 'origin',

                    'caption': 'name of the requesting service, '

                               'to present in the user interface',

                    'caption': 'dummy siret parameter',

                    'type': str,

                },

                {   'name': 'consider_all_response_signed',

                    'caption': 'All response will be considered as signed '

                         '(to test payment locally for example, as you '

                    'type': bool,

                    'default': False,

                },

            ],

    }

                ' next_url %s info1 %s info2 %s info3 %s kwargs: %s',

                __name__, amount, name, address, email, phone, info1, info2, info3, next_url, kwargs)

        transaction_id = self.transaction_id(30, ALPHANUM, 'dummy', self.siret)

        query = {

                'transaction_id': transaction_id,

                'siret': self.siret,

                'amount': amount,

                'email': email,

                'origin': self.origin

        }

        query.update(dict(name=name, address=address, email=email, phone=phone,

    description = {

        'caption': N_('Système de paiement Ogone / Ingenico Payment System e-Commerce'),

        'parameters': [

            {'name': 'environment',

                'default': ENVIRONMENT_TEST,

                'caption': N_(u'Environnement'),

                'LANGUAGE': language,

                'CURRENCY': self.currency,

        }

        if name:

            params['CN'] = name

        if email:

import base64

from gettext import gettext as _

import string

from common import (PaymentCommon, PaymentResponse, FORM, PAID, ERROR, Form,

        ORDERID_TRANSACTION_SEPARATOR)

    '''Paybox backend for eopayment.

       If you want to handle Instant Payment Notification, you must pass

       Email is mandatory to emit payment requests with paybox.

        'caption': _('Paybox'),

        'parameters': [

            {

                'name': 'platform',

                'caption': _('Plateforme cible'),

                'default': 'test',

            {

                'name': 'callback',

                'caption': _('Callback URL'),

            },

        ]

    }

        d['PBX_HASH'] = 'SHA512'

        d['PBX_TIME'] = kwargs.get('time') or (unicode(datetime.datetime.utcnow().isoformat('T')).split('.')[0]+'+00:00')

        d['PBX_ARCHIVAGE'] = transaction_id

        d = d.items()

        d = sign(d, self.shared_secret.decode('hex'))

        url = URLS[self.platform]

import os

import os.path

import uuid

from common import PaymentCommon, HTML, PaymentResponse

from cb import CB_RESPONSE_CODES

        params['amount'] = str(int(Decimal(amount) * 100))

        if email:

            params['customer_email'] = email

        code, error, form = self.execute('request', params)

        if int(code) == 0:

            return params[ORDER_ID], HTML, form

import uuid

import hashlib

from gettext import gettext as _

from common import PaymentCommon, FORM, Form, PaymentResponse, PAID, ERROR, CANCELED

            {

                'name': 'normal_return_url',

                'caption': _('Normal return URL'),

                'required': True,

            },

            {

        data['merchantId'] = self.merchand_id

        data['keyVersion'] = self.key_version

        data['normalReturnUrl'] = self.normal_return_url

        data['currencyCode'] = self.currency_code

        return data

        data['amount'] = unicode(int(Decimal(amount) * 100))

        if email:

            data['billingContact.email'] = email

            data['normalReturnUrl'] = next_url

        form = Form(

            url=self.get_url(),

# -*- coding: utf-8 -*-

from decimal import Decimal

import binascii

import hmac

import hashlib

import urlparse

import datetime as dt

import logging

import re

import Crypto.Cipher.DES

from common import (PaymentCommon, URL, PaymentResponse, RECEIVED, ACCEPTED,

        PAID, ERROR)

__all__ = ['Payment']

KEY_DES_KEY = '\x45\x1f\xba\x4f\x4c\x3f\xd4\x97'

    description = {

            'caption': "SPPlus payment service of French bank Caisse d'epargne",

            'parameters': [

                {   'name': 'cle',

                    'caption': 'Secret key, a 40 digits hexadecimal number',

                    'regexp': re.compile('^ *((?:[a-fA-F0-9] *){40}) *$')

    def request(self, amount, name=None, address=None, email=None, phone=None,

            orderid=None, info1=None, info2=None, info3=None, next_url=None,

            logger=LOGGER, **kwargs):

        reference = self.transaction_id(20, ALPHANUM, 'spplus', self.siret)

        validite = dt.date.today()+dt.timedelta(days=1)

        validite = validite.strftime('%d/%m/%Y')

                'moyen': self.moyen }

        if email:

            fields['email'] = email

        logger.debug('sending fields %s' % fields)

        query = urllib.urlencode(fields)

        url = '%s?%s&hmac=%s' % (SERVICE_URL, query, sign_url_paiement(self.cle,

import logging

import string

import urlparse

from gettext import gettext as _

from common import PaymentCommon, PaymentResponse, PAID, ERROR, FORM, Form

    description = {

        'caption': 'SystemPay, système de paiment du groupe BPCE',

        'parameters': [

            {'name': 'service_url',

                'default': service_url,

                'caption': _(u'URL du service de paiment'),

        kwargs.update(add_vads({'amount': unicode(amount)}))

        if amount < 0:

            raise ValueError('amount must be an integer >= 0')

        if next_url:

        if name is not None:

            kwargs['vads_cust_name'] = unicode(name)

        if address is not None:

from urlparse import parse_qs

from gettext import gettext as _

import logging

from systempayv2 import isonow

                    'help_text': _(u'ne pas modifier si vous ne savez pas'),

                    'validation': lambda x: x.startswith('http'),

                    'required': True,

            ],

    }

                    'a decimal integer with less than 4 digits '

                    'before and 2 digits after the decimal point '

                    ', here it is %s' % repr(amount))

                raise ValueError('URLCL invalid URL format')

        try:

            if exer is not None:

        }

        if exer:

            params['exer'] = exer

        url = '%s?%s' % (self.service_url, urlencode(params))

        return transaction_id, URL, url