killbill-stripe 0.1.0 → 0.2.0

data/lib/stripe/{config/application.rb → application.rb}

@@ -1,23 +1,29 @@
+# -- encoding : utf-8 --
+
+set :views, File.expand_path(File.dirname(__FILE__) + '/views')
+
+include Killbill::Plugin::ActiveMerchant::Sinatra
+
 configure do
   # Usage: rackup -Ilib -E test
   if development? or test?
-    Killbill::Stripe.initialize! unless Killbill::Stripe.initialized
+    # Make sure the plugin is initialized
+    plugin              = ::Killbill::Stripe::PaymentPlugin.new
+    plugin.logger       = Logger.new(STDOUT)
+    plugin.logger.level = Logger::INFO
+    plugin.conf_dir     = File.dirname(File.dirname(__FILE__)) + '/..'
+    plugin.start_plugin
   end
 end
 
 helpers do
-  def plugin
-    Killbill::Stripe::PrivatePaymentPlugin.instance
+  def plugin(session = {})
+    ::Killbill::Stripe::PrivatePaymentPlugin.new(:stripe,
+                                                 ::Killbill::Stripe::StripePaymentMethod,
+                                                 ::Killbill::Stripe::StripeTransaction,
+                                                 ::Killbill::Stripe::StripeResponse,
+                                                 session)
   end
-
-  def required_parameter!(parameter_name, parameter_value, message='must be specified!')
-    halt 400, "#{parameter_name} #{message}" if parameter_value.blank?
-  end
-end
-
-after do
-  # return DB connections to the Pool if required
-  ActiveRecord::Base.connection.close
 end
 
 # http://127.0.0.1:9292/plugins/killbill-stripe
@@ -26,11 +32,11 @@ get '/plugins/killbill-stripe' do
   required_parameter! :kb_account_id, kb_account_id
 
   # URL to Stripe.js
-  stripejs_url = Killbill::Stripe.config[:stripe][:stripejs_url] || 'https://js.stripe.com/v2/'
+  stripejs_url = config[:stripe][:stripejs_url] || 'https://js.stripe.com/v2/'
   required_parameter! :stripejs_url, stripejs_url, 'is not configured'
 
   # Public API key
-  publishable_key = Killbill::Stripe.config[:stripe][:api_publishable_key]
+  publishable_key = config[:stripe][:api_publishable_key]
   required_parameter! :publishable_key, publishable_key, 'is not configured'
 
   # Redirect
@@ -38,12 +44,12 @@ get '/plugins/killbill-stripe' do
   required_parameter! :success_page, success_page, 'is not specified'
 
   locals = {
-      :stripejs_url => stripejs_url,
+      :stripejs_url    => stripejs_url,
       :publishable_key => publishable_key,
-      :kb_account_id => kb_account_id,
-      :success_page => success_page
+      :kb_account_id   => kb_account_id,
+      :success_page    => success_page
   }
-  erb :stripejs, :views => File.expand_path(File.dirname(__FILE__) + '/../views'), :locals => locals
+  erb :stripejs, :locals => locals
 end
 
 # This is mainly for testing. Your application should redirect from the Stripe.js checkout above
@@ -59,7 +65,7 @@ end
 
 # curl -v http://127.0.0.1:9292/plugins/killbill-stripe/1.0/pms/1
 get '/plugins/killbill-stripe/1.0/pms/:id', :provides => 'json' do
-  if pm = Killbill::Stripe::StripePaymentMethod.find_by_id(params[:id].to_i)
+  if pm = ::Killbill::Stripe::StripePaymentMethod.find_by_id(params[:id].to_i)
     pm.to_json
   else
     status 404
@@ -68,9 +74,18 @@ end
 
 # curl -v http://127.0.0.1:9292/plugins/killbill-stripe/1.0/transactions/1
 get '/plugins/killbill-stripe/1.0/transactions/:id', :provides => 'json' do
-  if transaction = Killbill::Stripe::StripeTransaction.find_by_id(params[:id].to_i)
+  if transaction = ::Killbill::Stripe::StripeTransaction.find_by_id(params[:id].to_i)
     transaction.to_json
   else
     status 404
   end
 end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-stripe/1.0/responses/1
+get '/plugins/killbill-stripe/1.0/responses/:id', :provides => 'json' do
+  if transaction = ::Killbill::Stripe::StripeResponse.find_by_id(params[:id].to_i)
+    transaction.to_json
+  else
+    status 404
+  end
+end

data/lib/stripe/models/payment_method.rb

@@ -0,0 +1,58 @@
+module Killbill #:nodoc:
+  module Stripe #:nodoc:
+    class StripePaymentMethod < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod
+
+      self.table_name = 'stripe_payment_methods'
+
+      def self.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, cc_or_token, response, options, extra_params = {}, model = ::Killbill::Stripe::StripePaymentMethod)
+        stripe_customer_id = self.stripe_customer_id_from_kb_account_id(kb_account_id, kb_tenant_id)
+        unless stripe_customer_id.blank?
+          card_response     = response.responses.first.params
+          customer_response = response.responses.last.params
+        else
+          card_response     = response.params['cards']['data'][0]
+          customer_response = response.params
+        end
+
+        super(kb_account_id,
+              kb_payment_method_id,
+              kb_tenant_id,
+              cc_or_token,
+              response,
+              options,
+              {
+                  :stripe_customer_id => customer_response['id'],
+                  :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']
+              }.merge!(extra_params),
+              model)
+      end
+
+      def self.search_where_clause(t, search_key)
+        super.or(t[:stripe_customer_id].eq(search_key))
+      end
+
+      def self.stripe_customer_id_from_kb_account_id(kb_account_id, tenant_id)
+        pms = from_kb_account_id(kb_account_id, tenant_id)
+        return nil if pms.empty?
+
+        stripe_customer_ids = Set.new
+        pms.each { |pm| stripe_customer_ids << pm.stripe_customer_id }
+        raise "No Stripe customer id found for account #{kb_account_id}" if stripe_customer_ids.empty?
+        raise "Kill Bill account #{kb_account_id} mapping to multiple Stripe customers: #{stripe_customer_ids}" if stripe_customer_ids.size > 1
+        stripe_customer_ids.first
+      end
+    end
+  end
+end

data/lib/stripe/models/response.rb

@@ -0,0 +1,80 @@
+module Killbill #:nodoc:
+  module Stripe #:nodoc:
+    class StripeResponse < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Response
+
+      self.table_name = 'stripe_responses'
+
+      has_one :stripe_transaction
+
+      def self.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, response, extra_params = {}, model = ::Killbill::Stripe::StripeResponse)
+        super(api_call,
+              kb_account_id,
+              kb_payment_id,
+              kb_payment_transaction_id,
+              transaction_type,
+              payment_processor_account_id,
+              kb_tenant_id,
+              response,
+              {
+                  :params_id                       => extract(response, 'id'),
+                  :params_object                   => extract(response, 'object'),
+                  :params_created                  => extract(response, 'created'),
+                  :params_livemode                 => extract(response, 'livemode'),
+                  :params_paid                     => extract(response, 'paid'),
+                  :params_amount                   => extract(response, 'amount'),
+                  :params_currency                 => extract(response, 'currency'),
+                  :params_refunded                 => extract(response, 'refunded'),
+                  :params_card_id                  => extract(response, 'card', 'id'),
+                  :params_card_object              => extract(response, 'card', 'object'),
+                  :params_card_last4               => extract(response, 'card', 'last4'),
+                  :params_card_type                => extract(response, 'card', 'type'),
+                  :params_card_exp_month           => extract(response, 'card', 'exp_month'),
+                  :params_card_exp_year            => extract(response, 'card', 'exp_year'),
+                  :params_card_fingerprint         => extract(response, 'card', 'fingerprint'),
+                  :params_card_customer            => extract(response, 'card', 'customer'),
+                  :params_card_country             => extract(response, 'card', 'country'),
+                  :params_card_name                => extract(response, 'card', 'name'),
+                  :params_card_address_line1       => extract(response, 'card', 'address_line1'),
+                  :params_card_address_line2       => extract(response, 'card', 'address_line2'),
+                  :params_card_address_city        => extract(response, 'card', 'address_city'),
+                  :params_card_address_state       => extract(response, 'card', 'address_state'),
+                  :params_card_address_zip         => extract(response, 'card', 'address_zip'),
+                  :params_card_address_country     => extract(response, 'card', 'address_country'),
+                  :params_card_cvc_check           => extract(response, 'card', 'cvc_check'),
+                  :params_card_address_line1_check => extract(response, 'card', 'address_line1_check'),
+                  :params_card_address_zip_check   => extract(response, 'card', 'address_zip_check'),
+                  :params_captured                 => extract(response, 'captured'),
+                  :params_refunds                  => extract(response, 'refunds'),
+                  :params_balance_transaction      => extract(response, 'balance_transaction'),
+                  :params_failure_message          => extract(response, 'failure_message'),
+                  :params_failure_code             => extract(response, 'failure_code'),
+                  :params_amount_refunded          => extract(response, 'amount_refunded'),
+                  :params_customer                 => extract(response, 'customer'),
+                  :params_email                    => extract(response, 'email'),
+                  :params_delinquent               => extract(response, 'delinquent'),
+                  :params_subscription             => extract(response, 'subscription'),
+                  :params_discount                 => extract(response, 'discount'),
+                  :params_account_balance          => extract(response, 'account_balance'),
+                  :params_cards                    => extract(response, 'cards'),
+                  :params_invoice                  => extract(response, 'invoice'),
+                  :params_description              => extract(response, 'description'),
+                  :params_dispute                  => extract(response, 'dispute'),
+                  :params_metadata                 => extract(response, 'metadata'),
+                  :params_error_type               => extract(response, 'error', 'type'),
+                  :params_error_message            => extract(response, 'error', 'message')
+              }.merge!(extra_params),
+              model)
+      end
+
+      def self.search_where_clause(t, search_key)
+        where_clause = t[:params_id].eq(search_key)
+                   .or(t[:params_card_id].eq(search_key))
+
+        # Only search successful payments and refunds
+        where_clause = where_clause.and(t[:success].eq(true))
+
+        super.or(where_clause)
+      end
+    end
+  end
+end

data/lib/stripe/models/transaction.rb

@@ -0,0 +1,11 @@
+module Killbill #:nodoc:
+  module Stripe #:nodoc:
+    class StripeTransaction < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Transaction
+
+      self.table_name = 'stripe_transactions'
+
+      belongs_to :stripe_response
+
+    end
+  end
+end

data/lib/stripe/private_api.rb

@@ -1,52 +1,34 @@
-module Killbill::Stripe
-  class PrivatePaymentPlugin
-    include Singleton
+module Killbill #:nodoc:
+  module Stripe #:nodoc:
+    class PrivatePaymentPlugin < ::Killbill::Plugin::ActiveMerchant::PrivatePaymentPlugin
 
-    def add_payment_method(params)
-      stripe_customer_id = StripePaymentMethod.stripe_customer_id_from_kb_account_id(params[:kbAccountId])
+      def add_payment_method(params)
+        stripe_customer_id = StripePaymentMethod.stripe_customer_id_from_kb_account_id(params[:kbAccountId], params[:kbTenantId])
 
-      # This will either update the current customer if present, or create a new one
-      stripe_response = gateway.store params[:stripeToken], { :description => params[:kbAccountId], :customer => stripe_customer_id }
-      response = save_response stripe_response, :add_payment_method
-      raise response.message unless response.success
+        # This will either update the current customer if present, or create a new one
+        stripe_response    = gateway.store params[:stripeToken], {:description => params[:kbAccountId], :customer => stripe_customer_id}
+        response           = save_response stripe_response, :add_payment_method
+        raise response.message unless response.success
 
-      # Create the payment method (not associated to a Kill Bill payment method yet)
-      pm = Killbill::Stripe::StripePaymentMethod.create! :kb_account_id => params[:kbAccountId],
-                                                         :kb_payment_method_id => nil,
-                                                         :stripe_customer_id => stripe_customer_id,
-                                                         :stripe_token => params[:stripeToken],
-                                                         :cc_first_name => params[:stripeCardName],
-                                                         :cc_last_name => nil,
-                                                         :cc_type => params[:stripeCardType],
-                                                         :cc_exp_month => params[:stripeCardExpMonth],
-                                                         :cc_exp_year => params[:stripeCardExpYear],
-                                                         :cc_last_4 => params[:stripeCardLast4],
-                                                         :address1 => params[:stripeCardAddressLine1],
-                                                         :address2 => params[:stripeCardAddressLine2],
-                                                         :city => params[:stripeCardAddressCity],
-                                                         :state => params[:stripeCardAddressState],
-                                                         :zip => params[:stripeCardAddressZip],
-                                                         :country => params[:stripeCardAddressCountry] || params[:stripeCardCountry]
-      pm
-    end
-
-    def save_response(stripe_response, api_call)
-      logger.warn "Unsuccessful #{api_call}: #{stripe_response.message}" unless stripe_response.success?
-
-      # Save the response to our logs
-      response = StripeResponse.from_response(api_call, nil, stripe_response)
-      response.save!
-      response
-    end
-
-    def gateway
-      # The gateway should have been configured when the plugin started
-      Killbill::Stripe.gateway
-    end
-
-    def logger
-      # The logger should have been configured when the plugin started
-      Killbill::Stripe.logger
+        # Create the payment method (not associated to a Kill Bill payment method yet)
+        Killbill::Stripe::StripePaymentMethod.create! :kb_account_id        => params[:kbAccountId],
+                                                      :kb_payment_method_id => nil,
+                                                      :kb_tenant_id         => params[:kbTenantId],
+                                                      :stripe_customer_id   => stripe_customer_id,
+                                                      :token                => params[:stripeToken],
+                                                      :cc_first_name        => params[:stripeCardName],
+                                                      :cc_last_name         => nil,
+                                                      :cc_type              => params[:stripeCardType],
+                                                      :cc_exp_month         => params[:stripeCardExpMonth],
+                                                      :cc_exp_year          => params[:stripeCardExpYear],
+                                                      :cc_last_4            => params[:stripeCardLast4],
+                                                      :address1             => params[:stripeCardAddressLine1],
+                                                      :address2             => params[:stripeCardAddressLine2],
+                                                      :city                 => params[:stripeCardAddressCity],
+                                                      :state                => params[:stripeCardAddressState],
+                                                      :zip                  => params[:stripeCardAddressZip],
+                                                      :country              => params[:stripeCardAddressCountry] || params[:stripeCardCountry]
+      end
     end
   end
 end

data/pom.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-~ Copyright 2010-2013 Ning, Inc.
+~ Copyright 2014 The Billing Project, LLC
 ~
-~  Ning licenses this file to you under the Apache License, version 2.0
+~  The Billing Project licenses this file to you under the Apache License, version 2.0
 ~  (the "License"); you may not use this file except in compliance with the
 ~  License.  You may obtain a copy of the License at:
 ~
@@ -25,7 +25,7 @@
     <groupId>org.kill-bill.billing.plugin.ruby</groupId>
     <artifactId>stripe-plugin</artifactId>
     <packaging>pom</packaging>
-    <version>0.1.0</version>
+    <version>0.2.0</version>
     <name>stripe-plugin</name>
     <url>http://github.com/killbill/killbill-stripe-plugin</url>
     <description>Plugin for accessing Stripe as a payment gateway</description>

data/release.sh

@@ -1,31 +1,31 @@
 set -e
 
-if [ "GNU" != "$(tar --help | grep GNU | head -1 | awk '{print $1}')" ]; then
-  echo "Unable to release: make sure to use GNU tar"
+if [ 'GNU' != "$(tar --help | grep GNU | head -1 | awk '{print $1}')" ]; then
+  echo 'Unable to release: make sure to use GNU tar'
   exit 1
 fi
 
 if $(ruby -e'require "java"'); then
   # Good
-  echo "Detected JRuby"
+  echo 'Detected JRuby'
 else
-  echo "Unable to release: make sure to use JRuby"
+  echo 'Unable to release: make sure to use JRuby'
   exit 1
 fi
 
 VERSION=`grep -E '<version>([0-9]+\.[0-9]+\.[0-9]+)</version>' pom.xml | sed 's/[\t \n]*<version>\(.*\)<\/version>[\t \n]*/\1/'`
 if [ "$VERSION" != "$(cat $PWD/VERSION)" ]; then
-  echo "Unable to release: make sure the versions in pom.xml and VERSION match"
+  echo 'Unable to release: make sure the versions in pom.xml and VERSION match'
   exit 1
 fi
 
-echo "Cleaning up"
+echo 'Cleaning up'
 rake killbill:clean ; rake build
 
-echo "Pushing the gem to Rubygems"
+echo 'Pushing the gem to Rubygems'
 rake release
 
-echo "Building artifact"
+echo 'Building artifact'
 rake killbill:package
 
 ARTIFACT="$PWD/pkg/killbill-stripe-$VERSION.tar.gz"

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'bundler'
 require 'stripe'
+require 'killbill/helpers/active_merchant/killbill_spec_helper'
 
 require 'logger'
 
@@ -13,25 +14,11 @@ end
 
 require 'active_record'
 ActiveRecord::Base.establish_connection(
-  :adapter => 'sqlite3',
-  :database => 'test.db'
+    :adapter => 'sqlite3',
+    :database => 'test.db'
 )
 # For debugging
 #ActiveRecord::Base.logger = Logger.new(STDOUT)
 # Create the schema
 require File.expand_path(File.dirname(__FILE__) + '../../db/schema.rb')
 
-begin
-  require 'securerandom'
-  SecureRandom.uuid
-rescue LoadError, NoMethodError
-  # See http://jira.codehaus.org/browse/JRUBY-6176
-  module SecureRandom
-    def self.uuid
-      ary = self.random_bytes(16).unpack("NnnnnN")
-      ary[2] = (ary[2] & 0x0fff) | 0x4000
-      ary[3] = (ary[3] & 0x3fff) | 0x8000
-      "%08x-%04x-%04x-%04x-%04x%08x" % ary
-    end unless respond_to?(:uuid)
-  end
-end

data/spec/stripe/base_plugin_spec.rb

@@ -14,10 +14,12 @@ describe Killbill::Stripe::PaymentPlugin do
       eos
       file.close
 
-      @plugin = Killbill::Stripe::PaymentPlugin.new
-      @plugin.logger = Logger.new(STDOUT)
+      @plugin              = Killbill::Stripe::PaymentPlugin.new
+      @plugin.logger       = Logger.new(STDOUT)
       @plugin.logger.level = Logger::INFO
-      @plugin.conf_dir = File.dirname(file)
+      @plugin.conf_dir     = File.dirname(file)
+      @account_api         = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaUserAccountApi.new
+      @plugin.kb_apis      = Killbill::Plugin::KillbillApi.new('stripe', {})
 
       # Start the plugin here - since the config file will be deleted
       @plugin.start_plugin
@@ -30,15 +32,18 @@ describe Killbill::Stripe::PaymentPlugin do
 
   it 'should reset payment methods' do
     kb_account_id = '129384'
+    kb_tenant_id  = '092384'
+    context       = @plugin.kb_apis.create_context(kb_tenant_id)
 
-    @plugin.get_payment_methods(kb_account_id).size.should == 0
-    verify_pms kb_account_id, 0
+    @plugin.get_payment_methods(kb_account_id, false, [], context).size.should == 0
+    verify_pms kb_account_id, 0, context
 
     # Create a pm with a kb_payment_method_id
-    Killbill::Stripe::StripePaymentMethod.create :kb_account_id => kb_account_id,
+    Killbill::Stripe::StripePaymentMethod.create :kb_account_id        => kb_account_id,
+                                                 :kb_tenant_id         => kb_tenant_id,
                                                  :kb_payment_method_id => 'kb-1',
-                                                 :stripe_card_id_or_token => 'stripe-1'
-    verify_pms kb_account_id, 1
+                                                 :token                => 'stripe-1'
+    verify_pms kb_account_id, 1, context
 
     # Add some in KillBill and reset
     payment_methods = []
@@ -46,26 +51,27 @@ describe Killbill::Stripe::PaymentPlugin do
     payment_methods << create_pm_info_plugin(kb_account_id, 'kb-3', false, 'stripe-3')
     payment_methods << create_pm_info_plugin(kb_account_id, 'kb-2', false, 'stripe-2')
     payment_methods << create_pm_info_plugin(kb_account_id, 'kb-4', false, 'stripe-4')
-    @plugin.reset_payment_methods kb_account_id, payment_methods
-    verify_pms kb_account_id, 4
+    @plugin.reset_payment_methods kb_account_id, payment_methods, [], context
+    verify_pms kb_account_id, 4, context
 
     # Add a payment method without a kb_payment_method_id
     Killbill::Stripe::StripePaymentMethod.create :kb_account_id => kb_account_id,
-                                                 :stripe_card_id_or_token => 'stripe-5'
-    @plugin.get_payment_methods(kb_account_id).size.should == 5
+                                                 :kb_tenant_id  => kb_tenant_id,
+                                                 :token         => 'stripe-5'
+    @plugin.get_payment_methods(kb_account_id, false, nil, context).size.should == 5
 
     # Verify we can match it
     payment_methods << create_pm_info_plugin(kb_account_id, 'kb-5', false, 'stripe-5')
-    @plugin.reset_payment_methods kb_account_id, payment_methods
-    verify_pms kb_account_id, 5
+    @plugin.reset_payment_methods kb_account_id, payment_methods, [], context
+    verify_pms kb_account_id, 5, context
 
     @plugin.stop_plugin
   end
 
   private
 
-  def verify_pms(kb_account_id, size)
-    pms = @plugin.get_payment_methods(kb_account_id)
+  def verify_pms(kb_account_id, size, context)
+    pms = @plugin.get_payment_methods(kb_account_id, false, [], context)
     pms.size.should == size
     pms.each do |pm|
       pm.account_id.should == kb_account_id
@@ -75,10 +81,10 @@ describe Killbill::Stripe::PaymentPlugin do
   end
 
   def create_pm_info_plugin(kb_account_id, kb_payment_method_id, is_default, external_payment_method_id)
-    pm_info_plugin = Killbill::Plugin::Model::PaymentMethodInfoPlugin.new
-    pm_info_plugin.account_id = kb_account_id
-    pm_info_plugin.payment_method_id = kb_payment_method_id
-    pm_info_plugin.is_default = is_default
+    pm_info_plugin                            = Killbill::Plugin::Model::PaymentMethodInfoPlugin.new
+    pm_info_plugin.account_id                 = kb_account_id
+    pm_info_plugin.payment_method_id          = kb_payment_method_id
+    pm_info_plugin.is_default                 = is_default
     pm_info_plugin.external_payment_method_id = external_payment_method_id
     pm_info_plugin
   end