killbill 3.0.0 → 3.1.0

data/lib/killbill/gen/plugin-api/refund_info_plugin.rb

@@ -32,7 +32,7 @@ module Killbill
 
         include org.killbill.billing.payment.plugin.api.RefundInfoPlugin
 
-        attr_accessor :kb_payment_id, :amount, :currency, :created_date, :effective_date, :status, :gateway_error, :gateway_error_code, :first_refund_reference_id, :second_refund_reference_id
+        attr_accessor :kb_payment_id, :amount, :currency, :created_date, :effective_date, :status, :gateway_error, :gateway_error_code, :first_refund_reference_id, :second_refund_reference_id, :properties
 
         def initialize()
         end
@@ -77,6 +77,15 @@ module Killbill
 
           # conversion for second_refund_reference_id [type = java.lang.String]
           @second_refund_reference_id = @second_refund_reference_id.to_s unless @second_refund_reference_id.nil?
+
+          # conversion for properties [type = java.util.List]
+          tmp = java.util.ArrayList.new
+          (@properties || []).each do |m|
+            # conversion for m [type = org.killbill.billing.payment.api.PluginProperty]
+            m = m.to_java unless m.nil?
+            tmp.add(m)
+          end
+          @properties = tmp
           self
         end
 
@@ -124,6 +133,16 @@ module Killbill
 
           # conversion for second_refund_reference_id [type = java.lang.String]
           @second_refund_reference_id = j_obj.second_refund_reference_id
+
+          # conversion for properties [type = java.util.List]
+          @properties = j_obj.properties
+          tmp = []
+          (@properties || []).each do |m|
+            # conversion for m [type = org.killbill.billing.payment.api.PluginProperty]
+            m = Killbill::Plugin::Model::PluginProperty.new.to_ruby(m) unless m.nil?
+            tmp << m
+          end
+          @properties = tmp
           self
         end
 

data/lib/killbill/gen/plugin-api/require_gen.rb

@@ -23,6 +23,9 @@
 #
 
 
+require 'killbill/gen/plugin-api/hosted_payment_page_descriptor_fields'
+require 'killbill/gen/plugin-api/hosted_payment_page_form_descriptor'
+require 'killbill/gen/plugin-api/hosted_payment_page_notification'
 require 'killbill/gen/plugin-api/payment_method_info_plugin'
 require 'killbill/gen/plugin-api/payment_plugin_api'
 require 'killbill/gen/plugin-api/payment_plugin_api_exception'

data/lib/killbill/helpers/active_merchant.rb

@@ -0,0 +1,21 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      require 'killbill'
+
+      require 'active_support/core_ext'
+      require File.dirname(__FILE__) + '/active_merchant/core_ext.rb'
+      require File.dirname(__FILE__) + '/active_merchant/configuration.rb'
+
+      Dir[File.dirname(__FILE__) + '/active_merchant/*.rb'].each do |f|
+        # Get camelized class name
+        filename = File.basename(f, '.rb')
+        # Camelize the string to get the class name
+        class_name = filename.camelize.to_sym
+
+        # Register for autoloading
+        autoload class_name, f
+      end
+    end
+  end
+end

data/lib/killbill/helpers/active_merchant/active_record.rb

@@ -0,0 +1,17 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module ActiveRecord
+        Dir[File.dirname(__FILE__) + '/active_record/models/*.rb'].each do |f|
+          # Get camelized class name
+          filename = File.basename(f, '.rb')
+          # Camelize the string to get the class name
+          class_name = filename.camelize.to_sym
+
+          # Register for autoloading
+          autoload class_name, f
+        end
+      end
+    end
+  end
+end

data/lib/killbill/helpers/active_merchant/active_record/models/helpers.rb

@@ -0,0 +1,25 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module Helpers
+
+        # Useful helper to extract params from AM response objects, e.g. extract(response, 'card', 'address_country')
+        def 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
+  end
+end

data/lib/killbill/helpers/active_merchant/active_record/models/payment_method.rb

@@ -0,0 +1,195 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module ActiveRecord
+        require 'active_record'
+        require 'killbill/helpers/active_merchant/active_record/models/helpers'
+
+        class PaymentMethod < ::ActiveRecord::Base
+
+          extend ::Killbill::Plugin::ActiveMerchant::Helpers
+
+          self.abstract_class = true
+
+          def self.from_response(kb_account_id, kb_payment_method_id, cc_or_token, response, options, extra_params = {}, model = PaymentMethod)
+            model.new({
+                          :kb_account_id        => kb_account_id,
+                          :kb_payment_method_id => kb_payment_method_id,
+                          :token                => response.authorization,
+                          :cc_first_name        => cc_or_token.kind_of?(::ActiveMerchant::Billing::CreditCard) ? cc_or_token.first_name : nil,
+                          :cc_last_name         => cc_or_token.kind_of?(::ActiveMerchant::Billing::CreditCard) ? cc_or_token.last_name : nil,
+                          :cc_type              => cc_or_token.kind_of?(::ActiveMerchant::Billing::CreditCard) ? cc_or_token.brand : nil,
+                          :cc_exp_month         => cc_or_token.kind_of?(::ActiveMerchant::Billing::CreditCard) ? cc_or_token.month : nil,
+                          :cc_exp_year          => cc_or_token.kind_of?(::ActiveMerchant::Billing::CreditCard) ? cc_or_token.year : nil,
+                          :cc_last_4            => cc_or_token.kind_of?(::ActiveMerchant::Billing::CreditCard) ? cc_or_token.last_digits : nil,
+                          :address1             => (options[:billing_address] || {})[:address1],
+                          :address2             => (options[:billing_address] || {})[:address2],
+                          :city                 => (options[:billing_address] || {})[:city],
+                          :state                => (options[:billing_address] || {})[:state],
+                          :zip                  => (options[:billing_address] || {})[:zip],
+                          :country              => (options[:billing_address] || {})[:country]
+                      }.merge!(extra_params))
+          end
+
+          def self.from_kb_account_id(kb_account_id)
+            where('kb_account_id = ? AND is_deleted = ?', kb_account_id, false)
+          end
+
+          def self.from_kb_payment_method_id(kb_payment_method_id)
+            payment_methods = where('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 "Kill Bill payment method #{kb_payment_method_id} mapping to multiple active plugin payment methods" 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
+
+          # Override in your plugin if needed
+          def self.search_where_clause(t, search_key)
+            where_clause =     t[:kb_account_id].eq(search_key)
+                           .or(t[:kb_payment_method_id].eq(search_key))
+                           .or(t[: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
+
+            where_clause
+          end
+
+          # VisibleForTesting
+          def self.search_query(search_key, offset = nil, limit = nil)
+            t = self.arel_table
+
+            query = t.where(search_where_clause(t, search_key))
+                     .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
+
+          # Override in your plugin if needed
+          def external_payment_method_id
+            token
+          end
+
+          # Override in your plugin if needed
+          def is_default
+            false
+          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 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
+
+          # Deprecated
+          def create_pm_kv_info(key, value)
+            create_plugin_property(key, value)
+          end
+
+          def create_plugin_property(key, value)
+            prop = Killbill::Plugin::Model::PluginProperty.new
+            prop.key = key
+            prop.value = value
+            prop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/killbill/helpers/active_merchant/active_record/models/response.rb

@@ -0,0 +1,178 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module ActiveRecord
+        require 'active_record'
+        require 'active_merchant'
+        require 'money'
+        require 'killbill/helpers/active_merchant/active_record/models/helpers'
+
+        class Response < ::ActiveRecord::Base
+
+          extend ::Killbill::Plugin::ActiveMerchant::Helpers
+
+          self.abstract_class = true
+
+          def self.from_response(api_call, kb_payment_id, response, extra_params = {}, model = Response)
+            model.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?,
+                          :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?
+                      }.merge!(extra_params))
+          end
+
+          def to_payment_response(transaction=nil)
+            to_killbill_response :payment, transaction
+          end
+
+          def to_refund_response(transaction=nil)
+            to_killbill_response :refund, transaction
+          end
+
+          # Override in your plugin if needed
+          def self.search_where_clause(t, search_key, api_call)
+            # Exact matches only
+            where_clause = t[:kb_payment_id].eq(search_key)
+                       .or(t[:message].eq(search_key))
+                       .or(t[:authorization].eq(search_key))
+                       .or(t[:fraud_review].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))
+
+            where_clause
+          end
+
+          # VisibleForTesting
+          def self.search_query(api_call, search_key, offset = nil, limit = nil)
+            t = self.arel_table
+
+            query = t.where(search_where_clause(t, search_key, api_call))
+                     .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         = ::Killbill::Plugin::ActiveMerchant::ActiveRecord::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
+
+          # Override in your plugin if needed
+          def txn_id
+            authorization
+          end
+
+          # Override in your plugin if needed
+          def first_payment_reference_id
+            nil
+          end
+
+          # Override in your plugin if needed
+          def second_payment_reference_id
+            nil
+          end
+
+          # Override in your plugin if needed
+          def first_reference_id
+            nil
+          end
+
+          # Override in your plugin if needed
+          def second_reference_id
+            nil
+          end
+
+          # Override in your plugin if needed
+          def effective_date
+            created_at
+          end
+
+          # Override in your plugin if needed
+          def gateway_error
+            message
+          end
+
+          # Override in your plugin if needed
+          def gateway_error_code
+            nil
+          end
+
+          private
+
+          def to_killbill_response(type, transaction)
+            if transaction.nil?
+              amount_in_cents = nil
+              currency        = nil
+              created_date    = created_at
+            else
+              amount_in_cents = transaction.amount_in_cents
+              currency        = transaction.currency
+              created_date    = transaction.created_at
+            end
+
+            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
+        end
+      end
+    end
+  end
+end