killbill-litle 1.10.0 → 2.0.0

data/lib/litle/config/application.rb

@@ -1,66 +0,0 @@
-configure do
-  # Usage: rackup -Ilib -E test
-  if development? or test?
-    Killbill::Litle.initialize! unless Killbill::Litle.initialized
-  end
-end
-
-helpers do
-  def plugin
-    Killbill::Litle::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-litle
-get '/plugins/killbill-litle' do
-  kb_account_id = request.GET['kb_account_id']
-  required_parameter! :kb_account_id, kb_account_id
-
-  secure_page_url = Killbill::Litle.config[:litle][:secure_page_url]
-  required_parameter! :secure_page_url, secure_page_url, 'is not configured'
-
-  # Allow currency override if needed
-  currency = request.GET['currency'] || plugin.get_currency(kb_account_id)
-  paypage_id = Killbill::Litle.config[:litle][:paypage_id][currency.to_sym]
-  required_parameter! :paypage_id, paypage_id, "is not configured for currency #{currency.to_sym}"
-
-  locals = {
-      :currency => currency,
-      :secure_page_url => secure_page_url,
-      :paypage_id => paypage_id,
-      :kb_account_id => kb_account_id,
-      :merchant_txn_id => request.GET['merchant_txn_id'] || '1',
-      :order_id => request.GET['order_id'] || '1',
-      :report_group => request.GET['report_group'] || 'Default Report Group',
-      :success_page => params[:successPage],
-      :failure_page => params[:failurePage]
-  }
-  erb :paypage, :views => File.expand_path(File.dirname(__FILE__) + '/../views'), :locals => locals
-end
-
-# curl -v http://127.0.0.1:9292/plugins/killbill-litle/1.0/pms/1
-get '/plugins/killbill-litle/1.0/pms/:id', :provides => 'json' do
-  if pm = Killbill::Litle::LitlePaymentMethod.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-litle/1.0/transactions/1
-get '/plugins/killbill-litle/1.0/transactions/:id', :provides => 'json' do
-  if transaction = Killbill::Litle::LitleTransaction.find_by_id(params[:id].to_i)
-    transaction.to_json
-  else
-    status 404
-  end
-end

data/lib/litle/config/configuration.rb

@@ -1,51 +0,0 @@
-require 'logger'
-
-module Killbill::Litle
-  mattr_reader :logger
-  mattr_reader :config
-  mattr_reader :gateways
-  mattr_reader :currency_conversions
-  mattr_reader :kb_apis
-  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}/litle.yml"
-    @@config = Properties.new(config_file)
-    @@config.parse!
-    @@test = @@config[:litle][:test]
-
-    @@logger.log_level = Logger::DEBUG if (@@config[:logger] || {})[:debug]
-
-    @@gateways = Killbill::Litle::Gateway.from_config(@@config[:litle])
-
-    @@currency_conversions = @@config[:currency_conversions]
-
-    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
-
-  def self.converted_currency(currency)
-    currency_sym = currency.to_s.upcase.to_sym
-    @@currency_conversions && @@currency_conversions[currency_sym]
-  end
-
-
-  def self.gateway_for_currency(currency)
-    currency_sym = currency.to_s.upcase.to_sym
-    gateway = @@gateways[currency_sym]
-    raise "Gateway for #{currency} not configured!" if gateway.nil?
-    gateway
-  end
-end

data/lib/litle/config/properties.rb

@@ -1,23 +0,0 @@
-module Killbill::Litle
-  class Properties
-    def initialize(file = 'litle.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 Litle plugin. Config is #{@config.inspect}" if @config.blank? || !@config[:litle] || !@config[:litle][:merchant_id] || !@config[:litle][:password]
-    end
-  end
-end

data/lib/litle/litle/gateway.rb

@@ -1,32 +0,0 @@
-module Killbill::Litle
-  class Gateway
-    def self.from_config(config)
-      if config[:test]
-        ActiveMerchant::Billing::Base.mode = :test
-      end
-
-      if config[:log_file]
-        ActiveMerchant::Billing::LitleGateway.wiredump_device = File.open(config[:log_file], 'w')
-        ActiveMerchant::Billing::LitleGateway.wiredump_device.sync = true
-      end
-
-      gateways = {}
-      config[:merchant_id].each do |currency, mid|
-        gateways[currency.upcase.to_sym] = Gateway.new(currency, config[:username], config[:password], mid)
-      end
-      gateways
-    end
-
-    def initialize(currency, user, password, merchant_id)
-      @currency = currency
-      @gateway = ActiveMerchant::Billing::LitleGateway.new({:user => user,
-                                                            :password => password,
-                                                            :merchant_id => merchant_id
-                                                           })
-    end
-
-    def method_missing(m, *args, &block)
-      @gateway.send(m, *args, &block)
-    end
-  end
-end

data/lib/litle/models/litle_payment_method.rb

@@ -1,167 +0,0 @@
-module Killbill::Litle
-  class LitlePaymentMethod < ActiveRecord::Base
-    attr_accessible :kb_account_id,
-                    :kb_payment_method_id,
-                    :litle_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, :litle_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.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 Litle 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 litle_token, cc_type, cc_exp_month, cc_exp_year, cc_last_4, state and zip, partial match for the reset
-      where_clause =     t[:litle_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
-
-      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)
-      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
-      # No concept of default payment method in Litle
-      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
-
-    def to_litle_card_token
-      ActiveMerchant::Billing::LitleGateway::LitleCardToken.new(:token => litle_token, :month => cc_exp_month, :year => cc_exp_year)
-    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/litle/models/litle_response.rb

@@ -1,199 +0,0 @@
-module Killbill::Litle
-  class LitleResponse < ActiveRecord::Base
-    has_one :litle_transaction
-    attr_accessible :api_call,
-                    :kb_payment_id,
-                    :message,
-                    # Either litleToken (registerToken call) or litleTxnId
-                    :authorization,
-                    :fraud_review,
-                    :test,
-                    :params_litleonelineresponse_message,
-                    :params_litleonelineresponse_response,
-                    :params_litleonelineresponse_version,
-                    :params_litleonelineresponse_xmlns,
-                    :params_litleonelineresponse_saleresponse_customer_id,
-                    :params_litleonelineresponse_saleresponse_id,
-                    :params_litleonelineresponse_saleresponse_report_group,
-                    :params_litleonelineresponse_saleresponse_litle_txn_id,
-                    :params_litleonelineresponse_saleresponse_order_id,
-                    :params_litleonelineresponse_saleresponse_response,
-                    :params_litleonelineresponse_saleresponse_response_time,
-                    :params_litleonelineresponse_saleresponse_message,
-                    :params_litleonelineresponse_saleresponse_auth_code,
-                    :avs_result_code,
-                    :avs_result_message,
-                    :avs_result_street_match,
-                    :avs_result_postal_match,
-                    :cvv_result_code,
-                    :cvv_result_message,
-                    :success
-
-    def litle_token
-      authorization
-    end
-
-    def litle_txn_id
-      potential_litle_txn_id = params_litleonelineresponse_saleresponse_litle_txn_id || authorization
-      if potential_litle_txn_id.blank?
-        nil
-      else
-        # Litle seems to return the precision sometimes along with the txnId (e.g. 053499651324799+19)
-        # And sometimes it adds a ;credit
-        # TODO Figure out WTF is going on here
-        potential_litle_txn_id.to_s.split(';')[0].split('+')[0]
-      end
-    end
-
-    def self.from_response(api_call, kb_payment_id, response)
-      LitleResponse.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_litleonelineresponse_message => extract(response, "litleOnlineResponse", "message"),
-                            :params_litleonelineresponse_response => extract(response, "litleOnlineResponse", "response"),
-                            :params_litleonelineresponse_version => extract(response, "litleOnlineResponse", "version"),
-                            :params_litleonelineresponse_xmlns => extract(response, "litleOnlineResponse", "xmlns"),
-                            :params_litleonelineresponse_saleresponse_customer_id => extract(response, "litleOnlineResponse", "saleResponse", "customerId"),
-                            :params_litleonelineresponse_saleresponse_id => extract(response, "litleOnlineResponse", "saleResponse", "id"),
-                            :params_litleonelineresponse_saleresponse_report_group => extract(response, "litleOnlineResponse", "saleResponse", "reportGroup"),
-                            :params_litleonelineresponse_saleresponse_litle_txn_id => extract(response, "litleOnlineResponse", "saleResponse", "litleTxnId"),
-                            :params_litleonelineresponse_saleresponse_order_id => extract(response, "litleOnlineResponse", "saleResponse", "orderId"),
-                            :params_litleonelineresponse_saleresponse_response => extract(response, "litleOnlineResponse", "saleResponse", "response"),
-                            :params_litleonelineresponse_saleresponse_response_time => extract(response, "litleOnlineResponse", "saleResponse", "responseTime"),
-                            :params_litleonelineresponse_saleresponse_message => extract(response, "litleOnlineResponse", "saleResponse", "message"),
-                            :params_litleonelineresponse_saleresponse_auth_code => extract(response, "litleOnlineResponse", "saleResponse", "authCode"),
-                            :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[:params_litleonelineresponse_saleresponse_id].eq(search_key)
-                     .or(t[:params_litleonelineresponse_saleresponse_litle_txn_id].eq(search_key))
-                     .or(t[:params_litleonelineresponse_saleresponse_order_id].eq(search_key))
-                     .or(t[:params_litleonelineresponse_saleresponse_auth_code].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 litle_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 = litle_transaction.amount_in_cents
-        currency = litle_transaction.currency
-        created_date = litle_transaction.created_at
-        first_reference_id = params_litleonelineresponse_saleresponse_id
-        second_reference_id = litle_transaction.litle_txn_id
-      end
-
-      effective_date = params_litleonelineresponse_saleresponse_response_time || created_date
-      gateway_error = message || params_litleonelineresponse_saleresponse_message
-      gateway_error_code = params_litleonelineresponse_saleresponse_response
-
-      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