killbill-stripe 0.1.0 → 0.2.0

data/killbill-stripe.gemspec

@@ -18,24 +18,31 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.bindir        = 'bin'
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
   s.rdoc_options << '--exclude' << '.'
 
-  s.add_dependency 'killbill', '~> 3.0.0'
-  s.add_dependency 'activemerchant', '~> 1.42.3'
-  s.add_dependency 'activerecord', '~> 3.2.1'
-  s.add_dependency 'money', '~> 6.0.0'
+  s.add_dependency 'killbill', '~> 3.1.12'
+  s.add_dependency 'activemerchant', '~> 1.44.1'
+  s.add_dependency 'offsite_payments', '~> 2.0.1'
+  s.add_dependency 'activerecord', '~> 4.1.0'
+  s.add_dependency 'actionpack', '~> 4.1.0'
+  s.add_dependency 'actionview', '~> 4.1.0'
+  s.add_dependency 'activesupport', '~> 4.1.0'
+  s.add_dependency 'money', '~> 6.1.1'
+  s.add_dependency 'monetize', '~> 0.3.0'
   s.add_dependency 'sinatra', '~> 1.3.4'
   if defined?(JRUBY_VERSION)
-    s.add_dependency 'activerecord-jdbcmysql-adapter', '~> 1.2.9'
+    s.add_dependency 'activerecord-jdbcmysql-adapter', '~> 1.3.7'
+    # Required to avoid errors like java.lang.NoClassDefFoundError: org/bouncycastle/asn1/DERBoolean
+    s.add_dependency 'jruby-openssl', '~> 0.9.4'
   end
 
   s.add_development_dependency 'jbundler', '~> 0.4.1'
   s.add_development_dependency 'rake', '>= 10.0.0'
   s.add_development_dependency 'rspec', '~> 2.12.0'
   if defined?(JRUBY_VERSION)
-    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter', '~> 1.2.6'
+    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter', '~> 1.3.7'
   else
     s.add_development_dependency 'sqlite3', '~> 1.3.7'
   end

data/lib/stripe.rb

@@ -1,30 +1,24 @@
+require 'action_controller'
 require 'active_record'
-require 'activemerchant'
+require 'action_view'
+require 'active_merchant'
+require 'active_support'
 require 'bigdecimal'
 require 'money'
+require 'monetize'
+require 'offsite_payments'
 require 'pathname'
-require 'set'
 require 'sinatra'
 require 'singleton'
 require 'yaml'
 
 require 'killbill'
-
-require 'stripe/config/configuration'
-require 'stripe/config/properties'
+require 'killbill/helpers/active_merchant'
 
 require 'stripe/api'
 require 'stripe/private_api'
 
-require 'stripe/models/stripe_payment_method'
-require 'stripe/models/stripe_response'
-require 'stripe/models/stripe_transaction'
-
-require 'stripe/stripe_utils'
-require 'stripe/stripe/gateway'
+require 'stripe/models/payment_method'
+require 'stripe/models/response'
+require 'stripe/models/transaction'
 
-class Object
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-end

data/lib/stripe/api.rb

@@ -1,248 +1,188 @@
-module Killbill::Stripe
-  class PaymentPlugin < Killbill::Plugin::Payment
-    def start_plugin
-      Killbill::Stripe.initialize! @logger, @conf_dir, @kb_apis
+module Killbill #:nodoc:
+  module Stripe #:nodoc:
+    class PaymentPlugin < ::Killbill::Plugin::ActiveMerchant::PaymentPlugin
 
-      super
+      def initialize
+        gateway_builder = Proc.new do |config|
+          ::ActiveMerchant::Billing::StripeGateway.new :login => config[:api_secret_key]
+        end
 
-      @logger.info 'Killbill::Stripe::PaymentPlugin started'
-    end
+        super(gateway_builder,
+              :stripe,
+              ::Killbill::Stripe::StripePaymentMethod,
+              ::Killbill::Stripe::StripeTransaction,
+              ::Killbill::Stripe::StripeResponse)
+      end
 
-    # return DB connections to the Pool if required
-    def after_request
-      ActiveRecord::Base.connection.close
-    end
+      def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        pm = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
+
+        # Pass extra parameters for the gateway here
+        options = {
+            :customer => pm.stripe_customer_id
+        }
 
-    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, call_context = nil, options = {})
-      # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
-      amount_in_cents = Money.new_with_amount(amount, currency).cents.to_i
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-      # If the payment was already made, just return the status
-      stripe_transaction = StripeTransaction.from_kb_payment_id(kb_payment_id) rescue nil
-      return stripe_transaction.stripe_response.to_payment_response unless stripe_transaction.nil?
+      def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-      options[:order_id] ||= kb_payment_id
-      options[:currency] ||= currency.to_s.upcase
-      options[:description] ||= Killbill::Stripe.stripe_payment_description || "Kill Bill payment for #{kb_payment_id}"
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-      # Retrieve the Stripe payment method
-      pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
-      options[:customer] ||= pm.stripe_customer_id
+      def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        pm = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
-      # Go to Stripe
-      stripe_response = Killbill::Stripe.gateway.purchase amount_in_cents, pm.stripe_card_id_or_token, options
-      response = save_response_and_transaction stripe_response, :charge, kb_payment_id, amount_in_cents, currency
+        # Pass extra parameters for the gateway here
+        options = {
+            :customer => pm.stripe_customer_id
+        }
 
-      response.to_payment_response
-    end
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-    def get_payment_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
-      # We assume the payment is immutable in Stripe and only look at our tables
-      stripe_transaction = StripeTransaction.from_kb_payment_id(kb_payment_id)
-      stripe_transaction.stripe_response.to_payment_response
-    end
+      def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def process_refund(kb_account_id, kb_payment_id, amount, currency, call_context = nil, options = {})
-      # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
-      amount_in_cents = Money.new_with_amount(amount, currency).cents.to_i
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+      end
 
-      stripe_transaction = StripeTransaction.find_candidate_transaction_for_refund(kb_payment_id, amount_in_cents)
+      def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-      # Go to Stripe
-      stripe_response = Killbill::Stripe.gateway.refund amount_in_cents, stripe_transaction.stripe_txn_id, options
-      response = save_response_and_transaction stripe_response, :refund, kb_payment_id, amount_in_cents, currency
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-      response.to_refund_response
-    end
+      def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def get_refund_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
-      # We assume the refund is immutable in Stripe and only look at our tables
-      stripe_transactions = StripeTransaction.refunds_from_kb_payment_id(kb_payment_id)
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-      stripe_transactions.map { |t| t.stripe_response.to_refund_response }
-    end
+      def get_payment_info(kb_account_id, kb_payment_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, call_context = nil, options = {})
-      # Do we have a customer for that account already?
-      stripe_customer_id = StripePaymentMethod.stripe_customer_id_from_kb_account_id(kb_account_id)
-
-      # This will either update the current customer if present, or create a new one
-      options[:customer] ||= stripe_customer_id
-      options[:set_default] ||= set_default
-
-      # Magic field, see also private_api.rb (works only when creating an account)
-      if options[:customer].blank?
-        options[:description] ||= kb_account_id
-      else
-        options[:description] = nil
-      end
-
-      # Registering a card or a token from Stripe.js?
-      cc_or_token = find_value_from_payment_method_props(payment_method_props, 'token') || find_value_from_payment_method_props(payment_method_props, 'cardId')
-      if cc_or_token.blank?
-        # Nope - real credit card
-        cc_or_token = ActiveMerchant::Billing::CreditCard.new(
-              :number             => find_value_from_payment_method_props(payment_method_props, 'ccNumber'),
-              :month              => find_value_from_payment_method_props(payment_method_props, 'ccExpirationMonth'),
-              :year               => find_value_from_payment_method_props(payment_method_props, 'ccExpirationYear'),
-              :verification_value => find_value_from_payment_method_props(payment_method_props, 'ccVerificationValue'),
-              :first_name         => find_value_from_payment_method_props(payment_method_props, 'ccFirstName'),
-              :last_name          => find_value_from_payment_method_props(payment_method_props, 'ccLastName')
-        )
-      end
-
-      options[:billing_address] ||= {
-              :address1           => find_value_from_payment_method_props(payment_method_props, 'address1'),
-              :address2           => find_value_from_payment_method_props(payment_method_props, 'address2'),
-              :city               => find_value_from_payment_method_props(payment_method_props, 'city'),
-              :zip                => find_value_from_payment_method_props(payment_method_props, 'zip'),
-              :state              => find_value_from_payment_method_props(payment_method_props, 'state'),
-              :country            => find_value_from_payment_method_props(payment_method_props, 'country')
-      }
-
-      # Go to Stripe
-      stripe_response = Killbill::Stripe.gateway.store cc_or_token, options
-      response = save_response_and_transaction stripe_response, :add_payment_method
-
-      if response.success
-        unless stripe_customer_id.blank?
-          card_response = stripe_response.responses.first.params
-          customer_response = stripe_response.responses.last.params
-        else
-          card_response = stripe_response.params['cards']['data'][0]
-          customer_response = stripe_response.params
-        end
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, properties, context)
+      end
 
-        StripePaymentMethod.create :kb_account_id => kb_account_id,
-                                   :kb_payment_method_id => kb_payment_method_id,
-                                   :stripe_customer_id => customer_response['id'],
-                                   :stripe_card_id_or_token => card_response['id'],
-                                   :cc_first_name => card_response['name'],
-                                   :cc_last_name => nil,
-                                   :cc_type => card_response['type'],
-                                   :cc_exp_month => card_response['exp_month'],
-                                   :cc_exp_year => card_response['exp_year'],
-                                   :cc_last_4 => card_response['last4'],
-                                   :address1 => card_response['address_line1'],
-                                   :address2 => card_response['address_line2'],
-                                   :city => card_response['address_city'],
-                                   :state => card_response['address_state'],
-                                   :zip => card_response['address_zip'],
-                                   :country => card_response['address_country']
-      else
-        raise response.message
+      def search_payments(search_key, offset, limit, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+
+        properties = merge_properties(properties, options)
+        super(search_key, offset, limit, properties, context)
       end
-    end
 
-    def delete_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
-      pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
+      def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
+        # Do we have a customer for that account already?
+        stripe_customer_id = StripePaymentMethod.stripe_customer_id_from_kb_account_id(kb_account_id, context.tenant_id)
 
-      # Delete the card on the customer object
-      stripe_response = Killbill::Stripe.gateway.unstore(pm.stripe_customer_id, pm.stripe_card_id_or_token)
-      response = save_response_and_transaction stripe_response, :delete_payment_method
+        # Pass extra parameters for the gateway here
+        options = {
+            # This will either update the current customer if present, or create a new one
+            :customer => stripe_customer_id,
+            # Magic field, see also private_api.rb (works only when creating an account)
+            :description => kb_account_id
+        }
 
-      if response.success
-        StripePaymentMethod.mark_as_deleted! kb_payment_method_id
-      else
-        raise response.message
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
       end
-    end
 
-    def get_payment_method_detail(kb_account_id, kb_payment_method_id, tenant_context = nil, options = {})
-      StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
-    end
+      def delete_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+        pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
-    def set_default_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
-      pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
+        # Pass extra parameters for the gateway here
+        options = {
+            :customer_id => pm.stripe_customer_id
+        }
 
-      # Update the default payment method on the customer object
-      stripe_response = Killbill::Stripe.gateway.update_customer(pm.stripe_customer_id, :default_card => pm.stripe_card_id_or_token)
-      response = save_response_and_transaction stripe_response, :set_default_payment_method
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, properties, context)
+      end
 
-      if response.success
-        # TODO Update our records
-      else
-        raise response.message
+      def get_payment_method_detail(kb_account_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, properties, context)
       end
-    end
 
-    def get_payment_methods(kb_account_id, refresh_from_gateway = false, call_context = nil, options = {})
-      StripePaymentMethod.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_info_response }
-    end
+      def set_default_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+        pm                    = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
-    def reset_payment_methods(kb_account_id, payment_methods)
-      return if payment_methods.nil?
-
-      stripe_pms = StripePaymentMethod.from_kb_account_id(kb_account_id)
-
-      payment_methods.delete_if do |payment_method_info_plugin|
-        should_be_deleted = false
-        stripe_pms.each do |stripe_pm|
-          # Do stripe_pm and payment_method_info_plugin represent the same Stripe payment method?
-          if stripe_pm.external_payment_method_id == payment_method_info_plugin.external_payment_method_id
-            # Do we already have a kb_payment_method_id?
-            if stripe_pm.kb_payment_method_id == payment_method_info_plugin.payment_method_id
-              should_be_deleted = true
-              break
-            elsif stripe_pm.kb_payment_method_id.nil?
-              # We didn't have the kb_payment_method_id - update it
-              stripe_pm.kb_payment_method_id = payment_method_info_plugin.payment_method_id
-              should_be_deleted = stripe_pm.save
-              break
-              # Otherwise the same card points to 2 different kb_payment_method_id. This should never happen,
-              # but we cowardly will insert a second row below
-            end
-          end
-        end
+        # Update the default payment method on the customer object
+        stripe_response       = gateway.update_customer(pm.stripe_customer_id, :default_card => pm.token)
+        response, transaction = save_response_and_transaction stripe_response, :set_default_payment_method, kb_account_id, context.tenant_id
 
-        should_be_deleted
+        if response.success
+          # TODO Update our records
+        else
+          raise response.message
+        end
       end
 
-      # The remaining elements in payment_methods are not in our table (this should never happen?!)
-      payment_methods.each do |payment_method_info_plugin|
-        StripePaymentMethod.create :kb_account_id => kb_account_id,
-                                   :kb_payment_method_id => payment_method_info_plugin.payment_method_id,
-                                   :stripe_card_id_or_token => payment_method_info_plugin.external_payment_method_id
-      end
-    end
+      def get_payment_methods(kb_account_id, refresh_from_gateway, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def search_payments(search_key, offset = 0, limit = 100, call_context = nil, options = {})
-      StripeResponse.search(search_key, offset, limit, :payment)
-    end
+        properties = merge_properties(properties, options)
+        super(kb_account_id, refresh_from_gateway, properties, context)
+      end
 
-    def search_refunds(search_key, offset = 0, limit = 100, call_context = nil, options = {})
-      StripeResponse.search(search_key, offset, limit, :refund)
-    end
+      def search_payment_methods(search_key, offset, limit, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def search_payment_methods(search_key, offset = 0, limit = 100, call_context = nil, options = {})
-      StripePaymentMethod.search(search_key, offset, limit)
-    end
+        properties = merge_properties(properties, options)
+        super(search_key, offset, limit, properties, context)
+      end
 
-    private
+      def reset_payment_methods(kb_account_id, payment_methods, properties, context)
+        super
+      end
 
-    def find_value_from_payment_method_props(payment_method_props, key)
-      return payment_method_props[key] if payment_method_props.is_a? Hash
-      prop = (payment_method_props.properties.find { |kv| kv.key == key })
-      prop.nil? ? nil : prop.value
-    end
+      def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
 
-    def save_response_and_transaction(stripe_response, api_call, kb_payment_id=nil, amount_in_cents=0, currency=nil)
-      @logger.warn "Unsuccessful #{api_call}: #{stripe_response.message}" unless stripe_response.success?
+        # Add your custom static hidden tags here
+        options = {
+            #:token => config[:stripe][:token]
+        }
+        descriptor_fields = merge_properties(descriptor_fields, options)
 
-      # Save the response to our logs
-      response = StripeResponse.from_response(api_call, kb_payment_id, stripe_response)
-      response.save!
+        super(kb_account_id, descriptor_fields, properties, context)
+      end
 
-      if response.success and !kb_payment_id.blank? and !response.stripe_txn_id.blank?
-        # Record the transaction
-        transaction = response.create_stripe_transaction!(:amount_in_cents => amount_in_cents,
-                                                          :currency => currency,
-                                                          :api_call => api_call,
-                                                          :kb_payment_id => kb_payment_id,
-                                                          :stripe_txn_id => response.stripe_txn_id)
-        @logger.debug "Recorded transaction: #{transaction.inspect}"
+      def process_notification(notification, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+
+        super(notification, properties, context) do |gw_notification, service|
+          # Retrieve the payment
+          # gw_notification.kb_payment_id =
+          #
+          # Set the response body
+          # gw_notification.entity =
+        end
       end
-      response
     end
   end
 end