path: root/doc/modules.rst

Provided backends
=================


Dummy
-----

.. class:: payments.dummy.DummyProvider

   This is a dummy backend suitable for testing your store without contacting any payment gateways. Instead of using an external service it will simply show you a form that allows you to confirm or reject the payment.

Example::

      PAYMENT_VARIANTS = {
          'dummy': ('payments.dummy.DummyProvider', {})}


Authorize.Net
-------------

.. class:: payments.authorizenet.AuthorizeNetProvider(login_id, transaction_key[, endpoint='https://secure.authorize.net/gateway/transact.dll'])

   This backend implements payments using the Advanced Integration Method (AIM) from `Authorize.Net <https://www.authorize.net/>`_.

   :param login_id: Your API Login ID assigned by Authorize.net
   :param transaction_key: Your unique Transaction Key assigned by Authorize.net
   :param endpoint: The API endpoint to use. To test using staging environment, use ``'https://test.authorize.net/gateway/transact.dll'`` instead

Example::

      # use staging environment
      PAYMENT_VARIANTS = {
          'authorizenet': ('payments.authorizenet.AuthorizeNetProvider', {
              'login_id': '1234login',
              'transaction_key': '1234567890abcdef',
              'endpoint': 'https://test.authorize.net/gateway/transact.dll'})}


Braintree (Python 2 only)
-------------------------

.. class:: payments.braintree.BraintreeProvider(merchant_id, public_key, private_key)

   This backend implements payments using `Braintree <https://www.braintreepayments.com/>`_.

   :param merchant_id: Merchant ID assigned by Braintree
   :param public_key: Public key assigned by Braintree
   :param private_key: Private key assigned by Braintree

Example::

      # use sandbox
      PAYMENT_VARIANTS = {
          'braintree': ('payments.braintree.BraintreeProvider', {
              'merchant_id': '112233445566',
              'public_key': '1234567890abcdef',
              'private_key': 'abcdef123456'})}


Cybersource
-----------

.. class:: payments.cybersource.CyberSourceProvider(merchant_id, password[, org_id=None, fingerprint_url='https://h.online-metrix.net/fp/', sandbox=True, capture=True])

   This backend implements payments using `Cybersource <http://www.cybersource.com/www/>`_.

   :param merchant_id: Your Merchant ID
   :param password: Generated transaction security key for the SOAP toolkit
   :param org_id: Provide this parameter to enable Cybersource Device Fingerprinting
   :param fingerprint_url: Address of the fingerprint server
   :param sandbox: Whether to use a sandbox environment for testing
   :param capture: Whether to capture the payment automatically.  See :ref:`capture-payments` for more details.

Example::

      # use sandbox
      PAYMENT_VARIANTS = {
          'cybersource': ('payments.cybersource.CyberSourceProvider', {
              'merchant_id': 'example',
              'password': '1234567890abcdef',
              'capture': False,
              'sandbox': True})}


Merchant-Defined Data
"""""""""""""""""""""

Cybersource allows you to pass Merchant-Defined Data, which is additional information about the payment or the order, such as an order number, additional customer information, or a special comment or request from the customer. This can be accomplished by passing your data to the :class:`Payment` instance::

      >>> payment.attrs.merchant_defined_data = {'01': 'foo', '02': 'bar'}


Fraud statuses
""""""""""""""

Cybersource provides services used for fraud detection. When using this gateway, you can check the fraud status of your payment by accessing ``payment.fraud_status`` and ``payment.fraud_message`` fields. The possible fraud statuses are:

``unknown``
      The fraud status is unknown. This is the default status for other gateways, that do not involve fraud detection.

``accept``
      Fraud was not detected.

``reject``
      Fraud service detected some problems with the payment. Inspect the details by accessing the ``payment.fraud_message`` field.

``review``
      The payment was marked for review.


Dotpay
------

.. class:: payments.dotpay.DotpayProvider(seller_id, pin[, channel=0[, lock=False], lang='pl'])

   This backend implements payments using a popular Polish gateway, `Dotpay.pl <http://www.dotpay.pl>`_.

   Due to API limitations there is no support for transferring purchased items.


   :param seller_id: Seller ID assigned by Dotpay
   :param pin: PIN assigned by Dotpay
   :param channel: Default payment channel (consult reference guide)
   :param lang: UI language
   :param lock: Whether to disable channels other than the default selected above

Example::

      # use defaults for channel and lang but lock available channels
      PAYMENT_VARIANTS = {
          'dotpay': ('payments.dotpay.DotpayProvider', {
              'seller_id': '123',
              'pin': '0000',
              'lock': True})}


Google Wallet
-------------

.. class:: payments.wallet.GoogleWalletProvider(seller_id, seller_secret[, library='https://wallet.google.com/inapp/lib/buy.js'])

   This backend implements payments using `Google Wallet <https://developers.google.com/commerce/wallet/digital/>`_ for digital goods API.

   :param seller_id: Seller ID assigned by Google Wallet
   :param seller_secret: Seller secret assigned by Google Wallet
   :param library: The API library to use. To test using sandbox, use ``'https://sandbox.google.com/checkout/inapp/lib/buy.js'`` instead

Example::

      # use sandbox
      PAYMENT_VARIANTS = {
          'wallet': ('payments.wallet.GoogleWalletProvider', {
              'seller_id': '112233445566',
              'seller_secret': '1234567890abcdef',
              'library': 'https://sandbox.google.com/checkout/inapp/lib/buy.js'})}

This backend requires js files that should be added to the template using ``{{ form.media }}`` e.g:

.. code-block:: html

      <!-- templates/payment.html -->
      <form action="{{ form.action }}" method="{{ form.method }}">
          {{ form.as_p }}
          <p><input type="submit" value="Proceed" /></p>
      </form>
      {{ form.media }}

To specify the `postback URL` at the Merchant Settings page use direct url to `process payment view` in conjunction with your `variant name`:

E.g: ``https://example.com/payments/process/wallet``


PayPal
------

.. class:: payments.paypal.PaypalProvider(client_id, secret[, endpoint='https://api.paypal.com', capture=True])

   This backend implements payments using `PayPal.com <https://www.paypal.com/>`_.

   :param client_id: Client ID assigned by PayPal or your email address
   :param secret: Secret assigned by PayPal
   :param endpoint: The API endpoint to use. To test using sandbox, use ``'https://api.sandbox.paypal.com'`` instead
   :param capture: Whether to capture the payment automatically. See :ref:`capture-payments` for more details.


Example::

      # use sandbox
      PAYMENT_VARIANTS = {
          'paypal': ('payments.paypal.PaypalProvider', {
              'client_id': 'user@example.com',
              'secret': 'iseedeadpeople',
              'endpoint': 'https://api.sandbox.paypal.com',
              'capture': False})}

.. class:: payments.paypal.PaypalCardProvider(client_id, secret[, endpoint='https://api.paypal.com'])

   This backend implements payments using `PayPal.com <https://www.paypal.com/>`_ but the credit card data is collected by your site.

   Parameters are identical to those of :class:`payments.paypal.PaypalProvider`.

Example::

      PAYMENT_VARIANTS = {
          'paypal': ('payments.paypal.PaypalCardProvider', {
              'client_id': 'user@example.com',
              'secret': 'iseedeadpeople'})}


Sage Pay
--------

.. class:: payments.sagepay.SagepayProvider(vendor, encryption_key[, endpoint='https://live.sagepay.com/gateway/service/vspform-register.vsp'])

   This backend implements payments using `SagePay.com <https://www.sagepay.com/>`_ Form API.

   Purchased items are not currently transferred.

   :param vendor: Your vendor code
   :param encryption_key: Encryption key assigned by Sage Pay
   :param endpoint: The API endpoint to use. To test using simulator, use ``'https://test.sagepay.com/Simulator/VSPFormGateway.asp'`` instead

Example::

      # use simulator
      PAYMENT_VARIANTS = {
          'sage': ('payments.sagepay.SagepayProvider', {
              'vendor': 'example',
              'encryption_key': '1234567890abcdef',
              'endpoint': 'https://test.sagepay.com/Simulator/VSPFormGateway.asp'})}


Stripe
------

.. class:: payments.stripe.StripeProvider(secret_key, public_key)

   This backend implements payments using `Stripe <https://stripe.com/>`_.

   :param secret_key: Secret key assigned by Stripe.
   :param public_key: Public key assigned by Stripe.

Example::

      # use sandbox
      PAYMENT_VARIANTS = {
          'stripe': ('payments.stripe.StripeProvider', {
              'secret_key': 'sk_test_123456',
              'public_key': 'pk_test_123456'})}

This backend requires js files that should be added to the template using ``{{ form.media }}`` e.g:

.. code-block:: html

      <!-- templates/payment.html -->
      <form action="{{ form.action }}" method="{{ form.method }}">
          {{ form.as_p }}
          <p><input type="submit" value="Proceed" /></p>
      </form>
      {{ form.media }}