killbill-stripe 0.1.0

data/lib/stripe/config/application.rb

@@ -0,0 +1,76 @@
+configure do
+  # Usage: rackup -Ilib -E test
+  if development? or test?
+    Killbill::Stripe.initialize! unless Killbill::Stripe.initialized
+  end
+end
+
+helpers do
+  def plugin
+    Killbill::Stripe::PrivatePaymentPlugin.instance
+  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
+get '/plugins/killbill-stripe' do
+  kb_account_id = request.GET['kb_account_id']
+  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/'
+  required_parameter! :stripejs_url, stripejs_url, 'is not configured'
+
+  # Public API key
+  publishable_key = Killbill::Stripe.config[:stripe][:api_publishable_key]
+  required_parameter! :publishable_key, publishable_key, 'is not configured'
+
+  # Redirect
+  success_page = params[:successPage] || '/plugins/killbill-stripe'
+  required_parameter! :success_page, success_page, 'is not specified'
+
+  locals = {
+      :stripejs_url => stripejs_url,
+      :publishable_key => publishable_key,
+      :kb_account_id => kb_account_id,
+      :success_page => success_page
+  }
+  erb :stripejs, :views => File.expand_path(File.dirname(__FILE__) + '/../views'), :locals => locals
+end
+
+# This is mainly for testing. Your application should redirect from the Stripe.js checkout above
+# to a custom endpoint where you call the Kill Bill add payment method JAX-RS API.
+# If you really want to use this endpoint, you'll have to call the Kill Bill refresh payment methods API
+# to get a Kill Bill payment method id assigned.
+post '/plugins/killbill-stripe' do
+  pm = plugin.add_payment_method params
+
+  status 201
+  redirect '/plugins/killbill-stripe/1.0/pms/' + pm.id.to_s
+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)
+    pm.to_json
+  else
+    status 404
+  end
+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)
+    transaction.to_json
+  else
+    status 404
+  end
+end

data/lib/stripe/config/configuration.rb

@@ -0,0 +1,38 @@
+require 'logger'
+
+module Killbill::Stripe
+  mattr_reader :logger
+  mattr_reader :config
+  mattr_reader :gateway
+  mattr_reader :kb_apis
+  mattr_reader :stripe_payment_description
+  mattr_reader :initialized
+  mattr_reader :test
+
+  def self.initialize!(logger=Logger.new(STDOUT), conf_dir=File.expand_path('../../../', File.dirname(__FILE__)), kb_apis = nil)
+    @@logger = logger
+    @@kb_apis = kb_apis
+
+    config_file = "#{conf_dir}/stripe.yml"
+    @@config = Properties.new(config_file)
+    @@config.parse!
+    @@test = @@config[:stripe][:test]
+
+    @@logger.log_level = Logger::DEBUG if (@@config[:logger] || {})[:debug]
+
+    @@stripe_payment_description = @@config[:stripe][:payment_description]
+
+    @@gateway = Killbill::Stripe::Gateway.from_config(@@config[:stripe])
+
+    if defined?(JRUBY_VERSION)
+      # See https://github.com/jruby/activerecord-jdbc-adapter/issues/302
+      require 'jdbc/mysql'
+      Jdbc::MySQL.load_driver(:require) if Jdbc::MySQL.respond_to?(:load_driver)
+    end
+
+    ActiveRecord::Base.establish_connection(@@config[:database])
+    ActiveRecord::Base.logger = @@logger
+
+    @@initialized = true
+  end
+end

data/lib/stripe/config/properties.rb

@@ -0,0 +1,23 @@
+module Killbill::Stripe
+  class Properties
+    def initialize(file = 'stripe.yml')
+      @config_file = Pathname.new(file).expand_path
+    end
+
+    def parse!
+      raise "#{@config_file} is not a valid file" unless @config_file.file?
+      @config = YAML.load_file(@config_file.to_s)
+      validate!
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    private
+
+    def validate!
+      raise "Bad configuration for Stripe plugin. Config is #{@config.inspect}" if @config.blank? || !@config[:stripe] || !@config[:stripe][:api_secret_key]
+    end
+  end
+end

data/lib/stripe/models/stripe_payment_method.rb

@@ -0,0 +1,182 @@
+module Killbill::Stripe
+  class StripePaymentMethod < ActiveRecord::Base
+    attr_accessible :kb_account_id,
+                    :kb_payment_method_id,
+                    :stripe_customer_id,
+                    :stripe_card_id_or_token,
+                    :cc_first_name,
+                    :cc_last_name,
+                    :cc_type,
+                    :cc_exp_month,
+                    :cc_exp_year,
+                    :cc_last_4,
+                    :address1,
+                    :address2,
+                    :city,
+                    :state,
+                    :zip,
+                    :country
+
+    alias_attribute :external_payment_method_id, :stripe_card_id_or_token
+
+    def self.from_kb_account_id(kb_account_id)
+      find_all_by_kb_account_id_and_is_deleted(kb_account_id, false)
+    end
+
+    def self.stripe_customer_id_from_kb_account_id(kb_account_id)
+      pms = from_kb_account_id(kb_account_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 "Killbill account #{kb_account_id} mapping to multiple Stripe customers: #{stripe_customer_ids}" if stripe_customer_ids.size > 1
+      stripe_customer_ids.first
+    end
+
+    def self.from_kb_payment_method_id(kb_payment_method_id)
+      payment_methods = find_all_by_kb_payment_method_id_and_is_deleted(kb_payment_method_id, false)
+      raise "No payment method found for payment method #{kb_payment_method_id}" if payment_methods.empty?
+      raise "Killbill payment method mapping to multiple active Stripe tokens for payment method #{kb_payment_method_id}" if payment_methods.size > 1
+      payment_methods[0]
+    end
+
+    def self.mark_as_deleted!(kb_payment_method_id)
+      payment_method = from_kb_payment_method_id(kb_payment_method_id)
+      payment_method.is_deleted = true
+      payment_method.save!
+    end
+
+    # VisibleForTesting
+    def self.search_query(search_key, offset = nil, limit = nil)
+      t = self.arel_table
+
+      # Exact match for kb_account_id, kb_payment_method_id, stripe_customer_id, stripe_card_id_or_token, cc_type, cc_exp_month,
+      # cc_exp_year, cc_last_4, state and zip, partial match for the reset
+      where_clause =     t[:kb_account_id].eq(search_key)
+                     .or(t[:kb_payment_method_id].eq(search_key))
+                     .or(t[:stripe_customer_id].eq(search_key))
+                     .or(t[:stripe_card_id_or_token].eq(search_key))
+                     .or(t[:cc_type].eq(search_key))
+                     .or(t[:state].eq(search_key))
+                     .or(t[:zip].eq(search_key))
+                     .or(t[:cc_first_name].matches("%#{search_key}%"))
+                     .or(t[:cc_last_name].matches("%#{search_key}%"))
+                     .or(t[:address1].matches("%#{search_key}%"))
+                     .or(t[:address2].matches("%#{search_key}%"))
+                     .or(t[:city].matches("%#{search_key}%"))
+                     .or(t[:country].matches("%#{search_key}%"))
+
+      # Coming from Kill Bill, search_key will always be a String. Check to see if it represents a numeric for numeric-only fields
+      if search_key.is_a?(Numeric) or search_key.to_s =~ /\A[-+]?[0-9]*\.?[0-9]+\Z/
+        where_clause = where_clause.or(t[:cc_exp_month].eq(search_key))
+                                   .or(t[:cc_exp_year].eq(search_key))
+                                   .or(t[:cc_last_4].eq(search_key))
+      end
+
+      # Remove garbage payment methods (added in the plugin but not reconcilied with Kill Bill yet)
+      query = t.where(where_clause)
+               .where(t[:kb_payment_method_id].not_eq(nil))
+               .order(t[:id])
+
+      if offset.blank? and limit.blank?
+        # true is for count distinct
+        query.project(t[:id].count(true))
+      else
+        query.skip(offset) unless offset.blank?
+        query.take(limit) unless limit.blank?
+        query.project(t[Arel.star])
+        # Not chainable
+        query.distinct
+      end
+      query
+    end
+
+    def self.search(search_key, offset = 0, limit = 100)
+      pagination = Killbill::Plugin::Model::Pagination.new
+      pagination.current_offset = offset
+      pagination.total_nb_records = self.count_by_sql(self.search_query(search_key))
+      pagination.max_nb_records = self.count
+      pagination.next_offset = (!pagination.total_nb_records.nil? && offset + limit >= pagination.total_nb_records) ? nil : offset + limit
+      # Reduce the limit if the specified value is larger than the number of records
+      actual_limit = [pagination.max_nb_records, limit].min
+      pagination.iterator = StreamyResultSet.new(actual_limit) do |offset,limit|
+        self.find_by_sql(self.search_query(search_key, offset, limit))
+            .map(&:to_payment_method_response)
+      end
+      pagination
+    end
+
+    def to_payment_method_response
+      properties = []
+      properties << create_pm_kv_info('token', external_payment_method_id)
+      properties << create_pm_kv_info('ccName', cc_name)
+      properties << create_pm_kv_info('ccType', cc_type)
+      properties << create_pm_kv_info('ccExpirationMonth', cc_exp_month)
+      properties << create_pm_kv_info('ccExpirationYear', cc_exp_year)
+      properties << create_pm_kv_info('ccLast4', cc_last_4)
+      properties << create_pm_kv_info('address1', address1)
+      properties << create_pm_kv_info('address2', address2)
+      properties << create_pm_kv_info('city', city)
+      properties << create_pm_kv_info('state', state)
+      properties << create_pm_kv_info('zip', zip)
+      properties << create_pm_kv_info('country', country)
+
+      pm_plugin = Killbill::Plugin::Model::PaymentMethodPlugin.new
+      pm_plugin.kb_payment_method_id = kb_payment_method_id
+      pm_plugin.external_payment_method_id = external_payment_method_id
+      pm_plugin.is_default_payment_method = is_default
+      pm_plugin.properties = properties
+      pm_plugin.type = 'CreditCard'
+      pm_plugin.cc_name = cc_name
+      pm_plugin.cc_type = cc_type
+      pm_plugin.cc_expiration_month = cc_exp_month
+      pm_plugin.cc_expiration_year = cc_exp_year
+      pm_plugin.cc_last4 = cc_last_4
+      pm_plugin.address1 = address1
+      pm_plugin.address2 = address2
+      pm_plugin.city = city
+      pm_plugin.state = state
+      pm_plugin.zip = zip
+      pm_plugin.country = country
+
+      pm_plugin
+    end
+
+    def to_payment_method_info_response
+      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
+
+    def is_default
+      # There is a concept of default credit card in Stripe but it's not exposed by the API
+      # Return false to let Kill Bill knows it's authoritative on the matter
+      false
+    end
+
+    def cc_name
+      if cc_first_name and cc_last_name
+        "#{cc_first_name} #{cc_last_name}"
+      elsif cc_first_name
+        cc_first_name
+      elsif cc_last_name
+        cc_last_name
+      else
+        nil
+      end
+    end
+
+    private
+
+    def create_pm_kv_info(key, value)
+      prop = Killbill::Plugin::Model::PaymentMethodKVInfo.new
+      prop.key = key
+      prop.value = value
+      prop
+    end
+  end
+end

data/lib/stripe/models/stripe_response.rb

@@ -0,0 +1,242 @@
+module Killbill::Stripe
+  class StripeResponse < ActiveRecord::Base
+    has_one :stripe_transaction
+    attr_accessible :api_call,
+                    :kb_payment_id,
+                    :message,
+                    :authorization,
+                    :fraud_review,
+                    :test,
+                    :params_id,
+                    :params_object,
+                    :params_created,
+                    :params_livemode,
+                    :params_paid,
+                    :params_amount,
+                    :params_currency,
+                    :params_refunded,
+                    :params_card_id,
+                    :params_card_object,
+                    :params_card_last4,
+                    :params_card_type,
+                    :params_card_exp_month,
+                    :params_card_exp_year,
+                    :params_card_fingerprint,
+                    :params_card_customer,
+                    :params_card_country,
+                    :params_card_name,
+                    :params_card_address_line1,
+                    :params_card_address_line2,
+                    :params_card_address_city,
+                    :params_card_address_state,
+                    :params_card_address_zip,
+                    :params_card_address_country,
+                    :params_card_cvc_check,
+                    :params_card_address_line1_check,
+                    :params_card_address_zip_check,
+                    :params_captured,
+                    :params_refunds,
+                    :params_balance_transaction,
+                    :params_failure_message,
+                    :params_failure_code,
+                    :params_amount_refunded,
+                    :params_customer,
+                    :params_invoice,
+                    :params_description,
+                    :params_dispute,
+                    :params_metadata,
+                    :params_error_type,
+                    :params_error_message,
+                    :avs_result_code,
+                    :avs_result_message,
+                    :avs_result_street_match,
+                    :avs_result_postal_match,
+                    :cvv_result_code,
+                    :cvv_result_message,
+                    :success
+
+    def stripe_txn_id
+      params_id || authorization
+    end
+
+    def self.from_response(api_call, kb_payment_id, response)
+      StripeResponse.new({
+                            :api_call => api_call,
+                            :kb_payment_id => kb_payment_id,
+                            :message => response.message,
+                            :authorization => response.authorization,
+                            :fraud_review => response.fraud_review?,
+                            :test => response.test?,
+                            :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_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"),
+                            :avs_result_code => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
+                            :avs_result_message => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
+                            :avs_result_street_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
+                            :avs_result_postal_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
+                            :cvv_result_code => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
+                            :cvv_result_message => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
+                            :success => response.success?
+                        })
+    end
+
+    def to_payment_response
+      to_killbill_response :payment
+    end
+
+    def to_refund_response
+      to_killbill_response :refund
+    end
+
+    # VisibleForTesting
+    def self.search_query(api_call, search_key, offset = nil, limit = nil)
+      t = self.arel_table
+
+      # Exact matches only
+      where_clause =     t[:authorization].eq(search_key)
+                     .or(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[:api_call].eq(api_call))
+                                 .and(t[:success].eq(true))
+
+      query = t.where(where_clause)
+               .order(t[:id])
+
+      if offset.blank? and limit.blank?
+        # true is for count distinct
+        query.project(t[:id].count(true))
+      else
+        query.skip(offset) unless offset.blank?
+        query.take(limit) unless limit.blank?
+        query.project(t[Arel.star])
+        # Not chainable
+        query.distinct
+      end
+      query
+    end
+
+    def self.search(search_key, offset = 0, limit = 100, type = :payment)
+      api_call = type == :payment ? 'charge' : 'refund'
+      pagination = Killbill::Plugin::Model::Pagination.new
+      pagination.current_offset = offset
+      pagination.total_nb_records = self.count_by_sql(self.search_query(api_call, search_key))
+      pagination.max_nb_records = self.where(:api_call => api_call, :success => true).count
+      pagination.next_offset = (!pagination.total_nb_records.nil? && offset + limit >= pagination.total_nb_records) ? nil : offset + limit
+      # Reduce the limit if the specified value is larger than the number of records
+      actual_limit = [pagination.max_nb_records, limit].min
+      pagination.iterator = StreamyResultSet.new(actual_limit) do |offset,limit|
+        self.find_by_sql(self.search_query(api_call, search_key, offset, limit))
+            .map { |x| type == :payment ? x.to_payment_response : x.to_refund_response }
+      end
+      pagination
+    end
+
+    private
+
+    def to_killbill_response(type)
+      if stripe_transaction.nil?
+        amount_in_cents = nil
+        currency = nil
+        created_date = created_at
+        first_payment_reference_id = nil
+        second_payment_reference_id = nil
+      else
+        amount_in_cents = stripe_transaction.amount_in_cents
+        currency = stripe_transaction.currency
+        created_date = stripe_transaction.created_at
+        first_reference_id = params_balance_transaction
+        second_reference_id = stripe_transaction.stripe_txn_id
+      end
+
+      unless params_created.blank?
+        effective_date = DateTime.strptime(params_created.to_s, "%s") rescue nil
+      end
+      effective_date ||= created_date
+      gateway_error = message || params_error_message
+      gateway_error_code = params_error_type
+
+      if type == :payment
+        p_info_plugin = Killbill::Plugin::Model::PaymentInfoPlugin.new
+        p_info_plugin.kb_payment_id = kb_payment_id
+        p_info_plugin.amount = Money.new(amount_in_cents, currency).to_d if currency
+        p_info_plugin.currency = currency
+        p_info_plugin.created_date = created_date
+        p_info_plugin.effective_date = effective_date
+        p_info_plugin.status = (success ? :PROCESSED : :ERROR)
+        p_info_plugin.gateway_error = gateway_error
+        p_info_plugin.gateway_error_code = gateway_error_code
+        p_info_plugin.first_payment_reference_id = first_reference_id
+        p_info_plugin.second_payment_reference_id = second_reference_id
+        p_info_plugin
+      else
+        r_info_plugin = Killbill::Plugin::Model::RefundInfoPlugin.new
+        r_info_plugin.kb_payment_id = kb_payment_id
+        r_info_plugin.amount = Money.new(amount_in_cents, currency).to_d if currency
+        r_info_plugin.currency = currency
+        r_info_plugin.created_date = created_date
+        r_info_plugin.effective_date = effective_date
+        r_info_plugin.status = (success ? :PROCESSED : :ERROR)
+        r_info_plugin.gateway_error = gateway_error
+        r_info_plugin.gateway_error_code = gateway_error_code
+        r_info_plugin.first_refund_reference_id = first_reference_id
+        r_info_plugin.second_refund_reference_id = second_reference_id
+        r_info_plugin
+      end
+    end
+
+    def self.extract(response, key1, key2=nil, key3=nil)
+      return nil if response.nil? || response.params.nil?
+      level1 = response.params[key1]
+
+      if level1.nil? or (key2.nil? and key3.nil?)
+        return level1
+      end
+      level2 = level1[key2]
+
+      if level2.nil? or key3.nil?
+        return level2
+      else
+        return level2[key3]
+      end
+    end
+  end
+end