Added stripe gateway

.gitignore

@@ -4,10 +4,14 @@
 src
 tmp
 *.db
-
+*.*~
+#*#
 example/tmp
 example/localsettings.py
 
 docs/_build/*
 
 *_flymake.py*
+#*
+.py#
+

CONTRIBUTORS.txt

@@ -10,3 +10,4 @@ Thanks go out to all the contributors listed in alphabetical order:
 * Markus Gattol <markus.gattol@sunoano.org>
 * Shabda Raaj <shabda@agiliq.com>
 * Thejaswi Puthraya <thejaswi.puthraya@gmail.com>
+* Plaban Nayak <plaban.nayak@gmail.com>

billing/forms/samurai_forms.py

@@ -0,0 +1,8 @@
+from django import forms
+
+
+class SamuraiForm(forms.Form):
+    credit_card__number = forms.CharField()
+    credit_card__cvc = forms.CharField(max_length=4)
+    credit_card__expiration_month = forms.CharField(max_length=7)
+    credit_card__expiration_year = forms.CharField(max_length=7)

billing/forms/stripe_forms.py

@@ -0,0 +1,8 @@
+from django import forms
+
+
+class StripeForm(forms.Form):
+    credit_card__number = forms.CharField()
+    credit_card__cvc = forms.CharField(max_length=4)
+    credit_card__expiration_month = forms.CharField(max_length=7)
+    credit_card__expiration_year = forms.CharField(max_length=7)

billing/gateway.py

@@ -28,7 +28,7 @@ class Gateway(object):
     # Sequence of countries supported by the gateway in ISO 3166 alpha-2 format.
     # http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
     supported_countries = []
-    # Sequence of supported card types by the gateway. Members should be valid 
+    # Sequence of supported card types by the gateway. Members should be valid
     # subclasses of the Credit Card object.
     supported_cardtypes = []
     # Home page URL for the gateway. Used for information purposes only.
@@ -55,39 +55,39 @@ def validate_card(self, credit_card):
         # Gateways might provide some random number which
         # might not pass Luhn's test.
         if self.test_mode:
-            return True 
+            return True
         return credit_card.is_valid()
 
-    def purchase(self, money, credit_card, options = None):
+    def purchase(self, money, credit_card, options=None):
         """One go authorize and capture transaction"""
         raise NotImplementedError
 
-    def authorize(self, money, credit_card, options = None):
+    def authorize(self, money, credit_card, options=None):
         """Authorization for a future capture transaction"""
         raise NotImplementedError
 
-    def capture(self, money, authorization, options = None):
+    def capture(self, money, authorization, options=None):
         """Capture funds from a previously authorized transaction"""
         raise NotImplementedError
 
-    def void(self, identification, options = None):
+    def void(self, identification, options=None):
         """Null/Blank/Delete a previous transaction"""
         raise NotImplementedError
 
-    def credit(self, money, identification, options = None):
+    def credit(self, money, identification, options=None):
         """Refund a previously 'settled' transaction"""
         raise NotImplementedError
 
-    def recurring(self, money, creditcard, options = None):
+    def recurring(self, money, creditcard, options=None):
         """Setup a recurring transaction"""
         raise NotImplementedError
 
-    def store(self, creditcard, options = None):
+    def store(self, creditcard, options=None):
         """Store the credit card and user profile information
         on the gateway for future use"""
         raise NotImplementedError
 
-    def unstore(self, identification, options = None):
+    def unstore(self, identification, options=None):
         """Delete the previously stored credit card and user
         profile information on the gateway"""
         raise NotImplementedError
@@ -98,14 +98,13 @@ def get_gateway(gateway, *args, **kwargs):
     This caches gateway classes in a module-level dictionnary to avoid hitting
     the filesystem every time we require a gateway.
 
-    Should the list of available gateways change at runtime, one should then 
+    Should the list of available gateways change at runtime, one should then
     invalidate the cache, the simplest of ways would be to:
 
     >>> gateway_cache = {}
     """
     # Is the class in the cache?
     clazz = gateway_cache.get(gateway, None)
-
     if not clazz:
         # Let's actually load it (it's not in the cache)
         gateway_filename = "%s_gateway" %gateway

billing/gateways/samurai_gateway.py

@@ -0,0 +1,95 @@
+from billing import Gateway
+from billing.utils.credit_card import InvalidCard, Visa, MasterCard, \
+     AmericanExpress, Discover
+import samurai
+from django.conf import settings
+
+
+class SamuraiGateway(Gateway):
+    supported_cardtypes = [Visa, MasterCard, AmericanExpress, Discover]
+    supported_countries = ['US']
+    default_currency = "USD"
+    homepage_url = "https://samurai.feefighters.com/"
+    display_name = "Samurai"
+
+    def __init__(self):
+        import samurai.config as config
+        config.merchant_key = settings.SAMURAI_MERCHANT_KEY
+        config.merchant_password = settings.SAMURAI_MERCHANT_PASSWORD
+        config.processor_token = settings.SAMURAI_PROCESSOR_TOKEN
+        self.samurai = samurai
+
+    def purchase(self, money, credit_card):
+        if not self.validate_card(credit_card):
+            raise InvalidCard("Invalid Card")
+        try:
+            from samurai.payment_method import PaymentMethod
+            from samurai.processor import Processor
+            pm = PaymentMethod.create(credit_card.number, credit_card.verification_value,
+                                      credit_card.month, credit_card.year)
+            payment_method_token = pm.payment_method_token
+            response = Processor.purchase(payment_method_token, money)
+        except Exception, error:
+            return {'status': 'FAILURE', 'response': error}
+        return {'status': 'SUCCESS', 'response': response}
+
+    def authorize(self, money, credit_card, options=None):
+        if not self.validate_card(credit_card):
+            raise InvalidCard("Invalid Card")
+        try:
+            from samurai.payment_method import PaymentMethod
+            from samurai.processor import Processor
+            pm = PaymentMethod.create(credit_card.number, credit_card.verification_value, credit_card.month, credit_card.year)
+            payment_method_token = pm.payment_method_token
+            response = Processor.authorize(payment_method_token, money)
+        except Exception, error:
+            return {'status': 'FAILURE', 'response': error}
+        return {'status': 'SUCCESS', 'response': response}
+
+    def capture(self, money, identification, options=None):
+        from samurai.transaction import Transaction
+        trans = Transaction.find(identification)
+        if not trans.errors:
+            new_trans = trans.capture(money)
+            return{'status': "SUCCESS", "response": new_trans}
+        else:
+            return{"status": "FAILURE", "response": trans.errors}
+
+    def reverse(self, money, identification, options=None):
+        from samurai.transaction import Transaction
+        trans = Transaction.find(identification)
+        if not trans.errors:
+            new_trans = trans.reverse(money)
+            return{'status': "SUCCESS", "response": new_trans}
+        else:
+            return{"status": "FAILURE", "response": trans.errors}
+
+    def void(self, identification, options=None):
+        from samurai.transaction import Transaction
+        trans = Transaction.find(identification)
+        if not trans.errors:
+            new_trans = trans.void()
+            return{'status': "SUCCESS", "response": new_trans}
+        else:
+            return{"status": "FAILURE", "response": trans.errors}
+
+    def credit(self, money, identification, options=None):
+        from samurai.transaction import Transaction
+        trans = Transaction.find(identification)
+        if not trans.errors:
+            new_trans = trans.credit(money)
+            return{'status': "SUCCESS", "response": new_trans}
+        else:
+            return{"status": "FAILURE", "response": trans.errors}
+
+    def store(self, credit_card, options=None):
+        from samurai.payment_method import PaymentMethod
+        pm = PaymentMethod.create(credit_card.number, credit_card.verification_value, credit_card.month, credit_card.year)
+        response = pm.retain()
+        return {'status': 'SUCCESS', 'response': response}
+
+    def unstore(self, identification, options=None):
+        from samurai.payment_method import PaymentMethod
+        payment_method = PaymentMethod.find(identification)
+        payment_method = payment_method.redact()
+        return {"status": "SUCCESS", "response": payment_method}

billing/gateways/stripe_gateway.py

@@ -0,0 +1,118 @@
+from billing import Gateway
+from billing.utils.credit_card import InvalidCard, Visa, MasterCard, \
+     AmericanExpress, Discover
+import stripe
+from django.conf import settings
+
+
+class StripeGateway(Gateway):
+    supported_cardtypes = [Visa, MasterCard, AmericanExpress, Discover]
+    supported_countries = ['US']
+    default_currency = "USD"
+    homepage_url = "https://stripe.com/"
+    display_name = "Stripe"
+
+    def __init__(self):
+        stripe.api_key = settings.STRIPE_API_KEY
+        self.stripe = stripe
+
+    def purchase(self, amount, credit_card, options=None):
+        if not self.validate_card(credit_card):
+            raise InvalidCard("Invalid Card")
+        try:
+            response = self.stripe.Charge.create(
+                amount=amount * 100,
+                currency=self.default_currency.lower(),
+                card={
+                   'number': credit_card.number,
+                   'exp_month': credit_card.month,
+                   'exp_year': credit_card.year,
+                   'cvc': credit_card.verification_value
+                   },)
+        except self.stripe.CardError, error:
+            return {'status': 'FAILURE', 'response': error}
+        return {'status': 'SUCCESS', 'response': response}
+
+    def store(self, credit_card, options=None):
+        if not self.validate_card(credit_card):
+            raise InvalidCard("Invalid Card")
+        customer = self.stripe.Customer.create(
+                   card={
+                   'number': credit_card.number,
+                   'exp_month': credit_card.month,
+                   'exp_year': credit_card.year,
+                   'cvc': credit_card.verification_value
+                    },
+                    description="Storing for future use"
+        )
+        return {'status': 'SUCCESS', 'response': customer}
+
+    def recurring(self, credit_card, options=None):
+        if not self.validate_card(credit_card):
+            raise InvalidCard("Invalid Card")
+        response = None
+        try:
+            plan_id = options['plan_id']
+            self.stripe.Plan.retrieve(options['plan_id'])
+            try:
+                response = self.stripe.Customer.create(
+                    card={
+                        'number': credit_card.number,
+                        'exp_month': credit_card.month,
+                        'exp_year': credit_card.year,
+                        'cvc': credit_card.verification_value
+                    },
+                    plan=plan_id,
+                    description="Thanks for subscribing"
+                )
+                return {"status": "SUCCESS", "response": response}
+            except self.stripe.CardError, error:
+                return {"status": "FAILURE", "response": error}
+        except self.stripe.InvalidRequestError, error:
+            return {"status": "FAILURE", "response": error}
+        except TypeError:
+            return {"status": "FAILURE", "response": "please give a plan id"}
+
+    def unstore(self, identification, options=None):
+        try:
+            customer = self.stripe.Customer.retrieve(identification)
+            response = customer.delete()
+            return {"status": "SUCCESS", "response": response}
+        except self.stripe.InvalidRequestError, error:
+            return {"status": "FAILURE", "response": error}
+
+    def credit(self, identification, money=None, options=None):
+        try:
+            charge = self.stripe.Charge.retrieve(identification)
+            response = charge.refund(amount=money)
+            return {"status": "SUCCESS", "response": response}
+        except self.stripe.InvalidRequestError, error:
+            return {"status": "FAILURE", "error": error}
+
+    def authorize(self, money, credit_card, options=None):
+        if not self.validate_card(credit_card):
+            raise InvalidCard("Invalid Card")
+        try:
+            token = self.stripe.Token.create(
+                card={
+                    'number': credit_card.number,
+                    'exp_month': credit_card.month,
+                    'exp_year': credit_card.year,
+                    'cvc': credit_card.verification_value
+                },
+                amount=money * 100
+            )
+            return {'status': "SUCCESS", "response": token}
+        except self.stripe.InvalidRequestError, error:
+            return {"status": "FAILURE", "response": error}
+
+    def capture(self, money, authorization, options=None):
+        try:
+            response = self.stripe.Charge.create(
+                amount=money * 100,
+                card=authorization,
+                currency="usd"
+            )
+            return {'status': "SUCCESS", "response": response}
+        except self.stripe.InvalidRequestError, error:
+            return {"status": "FAILURE", "response": error}

billing/integrations/samurai_integration.py

@@ -0,0 +1,27 @@
+from billing import Integration
+from django.conf import settings
+from django.conf.urls.defaults import patterns, url
+from django.views.decorators.csrf import csrf_exempt
+from django.http import HttpResponse
+from billing.forms.samurai_forms import SamuraiForm
+
+
+class SamuraiIntegration(Integration):
+    def __init__(self):
+        super(SamuraiIntegration, self).__init__()
+
+    def generate_form(self):
+        initial_data = self.fields
+        form = SamuraiForm(initial=initial_data)
+        return form
+
+
+    @csrf_exempt
+    def get_token(self, request):
+        token = request.POST['samuraiToken']
+        return HttpResponse('Success')
+
+    def get_urls(self):
+        urlpatterns = patterns('',
+           url('^samurai-get-token/$', self.get_token, name="get_token"),)
+        return urlpatterns

billing/integrations/stripe_integration.py

@@ -0,0 +1,29 @@
+from billing import Integration
+from django.conf import settings
+from django.conf.urls.defaults import patterns, url
+import stripe
+from billing.forms.stripe_forms  import StripeForm
+from django.views.decorators.csrf import csrf_exempt
+from django.http import HttpResponse
+
+
+class StripeIntegration(Integration):
+    def __init__(self):
+        super(StripeIntegration, self).__init__()
+        stripe.api_key = settings.STRIPE_API_KEY
+        self.stripe = stripe
+
+    def generate_form(self):
+        initial_data = self.fields
+        form = StripeForm(initial=initial_data)
+        return form
+
+    @csrf_exempt
+    def get_token(self, request):
+        token = request.POST['stripeToken']
+        return HttpResponse('Success')
+
+    def get_urls(self):
+        urlpatterns = patterns('',
+           url('^stripe-get-token/$', self.get_token, name="get_token"),)
+        return urlpatterns

billing/templates/billing/samurai.html

@@ -0,0 +1,6 @@
+<div class="payment-errors"> </div>
+<form method="post" id="payment-form">{% csrf_token %}
+
+  {{ integration.generate_form.as_p }}
+<input type="submit" value="Pay" class="submit-button"/>
+</form>

billing/templates/billing/stripe.html

@@ -0,0 +1,6 @@
+<div class="payment-errors"> </div>
+<form method="post" id="payment-form">{% csrf_token %}
+
+  {{ integration.generate_form.as_p }}
+<input type="submit" value="Pay" class="submit-button"/>
+</form>