kount-ris 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 51d8bf9de3c132036eec7a8a69f4ecf77bccefab
+  data.tar.gz: 2097106f86b04f3ed9a8e28375e66ff86f4a08bd
+SHA512:
+  metadata.gz: 031156bd644f58898a830b67ed8845390f79afb862070631099dba7e19058046273ffd0f93bbd6d82a5d3b11483ef6e4e96c95b713a3effc20a335fc1d23a8ac
+  data.tar.gz: a8bb0dfc941deb9a0a13abbcb9d61d17d10a40c8ef25bb7875902869b8450f2053b7e2922c77f52024c9441be5ccb4ca171e04aa2a0cb746cb6b8cc02402441f

data/README.md

@@ -0,0 +1,58 @@
+# Kount::RIS
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/kount/ris`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kount-ris'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kount-ris
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/kount-ris. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Code of Conduct
+
+Everyone interacting in the Kount::RIS project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/kount-ris/blob/master/CODE_OF_CONDUCT.md).
+
+## To-Do
+
+1. cleanup configuration
+  - default Kount configuration options should be set by an initializer in the main application
+  - this could be loaded from yml or any other method perferd by the application
+  - some default defaults could be included in the configuration
+  - Kount.configuration should store/return an instance of Kount::Configuration
+
+2. consolidate custom validations
+  - validating nested/associated objects on a Inquiry or Response object is completed using custom validation methods
+  - these methods are all very similar and could be consolidated into some common code libraries
+  - this could probably be added into Kount::RIS::Base
+
+3. Add support for Kount.configurations
+  - this class method would hold a hash of named Kount::Configuration objects
+  - an Inquiry should have an association to a Kount::Configuration, either the default Kount.configuration, a named Kount::Configuration, or a passed Kount::Configuration object
+
+4. store response TIMEZONE value in Device#timezone as a DateTime offset

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/app/models/kount.rb

@@ -0,0 +1,28 @@
+module Kount
+  class << self
+    def configure(conf={})
+      Configuration.set(conf)
+    end
+
+    def configuration
+      {
+        merchant_id: Kount::Configuration.merchant_id,
+        company_server_url: Kount::Configuration.company_server_url,
+        api_key: Kount::Configuration.api_key,
+        gateway_id: Kount::Configuration.gateway_id,
+        site_id: Kount::Configuration.site_id,
+        api_version: Kount::Configuration.api_version || '0630',
+        response_format: Kount::Configuration.response_format,
+        payment_type: Kount::Configuration.payment_type,
+        currency_code: Kount::Configuration.currency_code,
+        shipping_method: Kount::Configuration.shipping_method,
+        logger: Kount::Configuration.logger,
+        simple_log_level: Kount::Configuration.simple_log_level,
+        simple_log_file: Kount::Configuration.simple_log_file,
+        simple_log_path: Kount::Configuration.simple_log_path,
+        salt: Kount::Configuration.salt,
+        api_host: Kount::Configuration.api_host,
+      }.compact
+    end
+  end
+end

data/app/models/kount/configuration.rb

@@ -0,0 +1,13 @@
+module Kount
+  class Configuration
+    mattr_accessor :merchant_id, :company_server_url, :api_key, :gateway_id, :site_id, :salt, :api_host
+    mattr_accessor :api_version, :response_format, :payment_type, :currency_code, :shipping_method
+    mattr_accessor :logger, :simple_log_level, :simple_log_file, :simple_log_path
+
+    class << self
+      def set(conf = {})
+        conf.each { |setting, value| self.send("#{setting}=", value) }
+      end
+    end
+  end
+end

data/app/models/kount/khash.rb

@@ -0,0 +1,44 @@
+require 'digest/sha1'
+
+module Kount
+  class KHASH
+    PREFIX_LENGTH = 6
+    SUFFIX_LENGTH = 16
+
+    attr_accessor :payment_type, :salt, :merchant_id
+    attr_reader :original_value, :value
+
+    def initialize(attrs = {})
+      attrs = { value: attrs } unless attrs.is_a?(Hash)
+      attrs.symbolize_keys!
+
+      self.payment_type = RIS::Inquiry::PAYMENT_TYPES.key(attrs[:payment_type]) || attrs[:payment_type] || 'card'
+      self.salt = attrs[:salt] || Kount::Configuration.salt
+      self.merchant_id = attrs[:merchant_id] || Kount::Configuration.merchant_id
+      self.original_value = attrs[:value]
+    end
+
+    def original_value=(value)
+      @original_value = value.to_s
+      hash_value!
+      @original_value    
+    end
+
+    def to_s
+      @value
+    end
+
+    private
+
+    def hash_value!
+      prefix = payment_type.to_s.downcase == 'card' ? original_value.first(PREFIX_LENGTH) : merchant_id.to_s
+
+      character_array = (0...36).map{ |i| i.to_s(36).upcase }.join
+      digest = Digest::SHA1.hexdigest("#{original_value}.#{salt}")
+      suffix = SUFFIX_LENGTH.times.collect { |i| character_array[digest[(i*2)..((i*2)+6)].to_i(16) % 36] }.join
+      @value = prefix.concat(suffix)
+    end
+  end
+end
+
+

data/app/models/kount/ris.rb

@@ -0,0 +1,5 @@
+module Kount
+  module RIS
+
+  end
+end

data/app/models/kount/ris/address.rb

@@ -0,0 +1,31 @@
+module Kount
+  module RIS
+    class Address < Base
+      attr_accessor :address_1, :address_2, :premise, :thoroughfare, :city, :region, :postal_code, :country_code, :phone
+
+      validates :address_1, length: { maximum: 256 } # address line 1
+      validates :address_2, length: { maximum: 256 } # address line 2
+      validates :premise, length: { maximum: 256 } # Premise (used in EU addresses)
+      validates :thoroughfare, length: { maximum: 256 } # Thoroughfare (used in EU addresses)
+      validates :city, length: { maximum: 256 } # country code
+      validates :region, length: { maximum: 256 } # state / region / province
+      validates :postal_code, length: { maximum: 20 } # postal code
+      validates :country_code, length: 2 # country code
+      validates :phone, length: { maximum: 32 } # phone number
+
+      def to_h
+        {
+          address_1: address_1,
+          address_2: address_2,
+          premise: premise,
+          thoroughfare: thoroughfare,
+          city: city,
+          region: region,
+          postal_code: postal_code,
+          country_code: country_code,
+          phone: phone,
+        }
+      end
+    end
+  end
+end

data/app/models/kount/ris/base.rb

@@ -0,0 +1,17 @@
+module Kount
+  module RIS
+    class Base
+      include ActiveModel::Model
+
+      COUNTRY_CODES = %w[AF AX AL DZ AS AD AO AI AQ AG AR AM AW AU AT AZ BS BH BD BB BY BE BZ
+          BJ BM BT BO BA BW BV BR VG IO BN BG BF BI KH CM CA CV KY CF TD CL CN HK MO CX CC CO
+          KM CG CD CK CR CI HR CU CY CZ DK DJ DM DO EC EG SV GQ ER EE ET FK FO FJ FI FR GF PF
+          TF GA GM GE DE GH GI GR GL GD GP GU GT GG GN GW GY HT HM VA HN HU IS IN ID IR IQ IE
+          IM IL IT JM JP JE JO KZ KE KI KP KR KW KG LA LV LB LS LR LY LI LT LU MK MG MW MY MV
+          ML MT MH MQ MR MU YT MX FM MD MC MN ME MS MA MZ MM NA NR NP NL AN NC NZ NI NE NG NU
+          NF MP NO OM PK PW PS PA PG PY PE PH PN PL PT PR QA RE RO RU RW BL SH KN LC MF PM VC
+          WS SM ST SA SN RS SC SL SG SK SI SB SO ZA GS SS ES LK SD SR SJ SZ SE CH SY TW TJ TZ
+          TH TL TG TK TO TT TN TR TM TC TV UG UA AE GB US UM UY UZ VU VE VN VI WF EH YE ZM ZW]
+    end
+  end
+end

data/app/models/kount/ris/device.rb

@@ -0,0 +1,122 @@
+module Kount
+  module RIS
+    class Device < Base
+      attr_accessor :browser, :cookies_enabled, :first_seen_at, :layers, :screen_resolution, :fingerprint,
+        :flash_enabled, :configured_country_code, :javascript_enabled, :captured, :language_country_code,
+        :localtime, :using_forwarder, :mobile_type, :operating_system, :remote_access, :configured_region,
+        :timezone, :user_agent, :voice_enabled, :region, :country_code
+
+      alias_method :cookies_enabled?, :cookies_enabled
+      alias_method :flash_enabled?, :flash_enabled
+      alias_method :javascript_enabled?, :javascript_enabled
+      alias_method :captured?, :captured
+      alias_method :using_forwarder?, :using_forwarder
+      alias_method :remote_access?, :remote_access
+      alias_method :voice_enabled?, :voice_enabled
+
+      NETWORK_TYPES = {
+        'a' => 'Anonymous',
+        'h' => 'High School',
+        'l' => 'Library',
+        'n' => 'Normal',
+        'o' => 'Open Proxy',
+        'p' => 'Prison',
+        's' => 'Satellite',
+      }
+
+      class << self
+        def network_types
+          NETWORK_TYPES
+        end
+      end
+
+      def network_types
+        self.class.network_types
+      end
+
+      def network_type=(value)
+        return @network_type = nil if value.nil?
+
+        network_type_value = network_types.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid network type" unless network_types.include?(network_type_value)
+        @network_type = network_type_value
+      end
+
+      def network_type
+        network_types[@network_type]
+      end
+
+      validates :browser, length: { maximum: 64 } # web browser name
+      validates :cookies_enabled, inclusion: { in: [true, false] }, allow_nil: true # browser has cookies enabled
+      validates :layers, length: { maximum: 55 } # string built from device operating system, browser, javascript, cookie, & flash settings
+      validates :screen_resolution, length: { maximum: 10 } # device screen resolution
+      validates :fingerprint, length: { maximum: 32 } # device uuid
+      validates :flash_enabled, inclusion: { in: [true, false] }, allow_nil: true # browser has flash installed/enabled
+      validates :configured_country_code, length: { maximum: 2 } # country configured for the device
+      validates :javascript_enabled, inclusion: { in: [true, false] }, allow_nil: true # browser has javascript enabled
+      validates :captured, inclusion: { in: [true, false] }, allow_nil: true # was device data captured?
+      validates :language_country_code, length: { maximum: 2 } # device configured language
+      validates :using_forwarder, inclusion: { in: [true, false] }, allow_nil: true # If device is mobile, is it using a forwarder to process the carrier’s service
+      validates :mobile_type, length: { maximum: 32 } # mobile device name
+      validates :network_type, inclusion: { in: network_types.values }, allow_nil: true # network type
+      validates :operating_system, length: { maximum: 64 } # operating system
+      validates :remote_access, inclusion: { in: [true, false] }, allow_nil: true # is the device accessable remotely
+      validates :configured_region, length: { maximum: 64 } # device configured region
+      validates :timezone, length: { maximum: 6 } # device configured timezone
+      validates :user_agent, length: { maximum: 1024 } # browser user agent
+      validates :voice_enabled, inclusion: { in: [true, false] }, allow_nil: true # is the device voice enabled
+      validates :region, length: { maximum: 64 } # device location region
+      validates :country_code, length: { maximum: 2 } # iso country code where the device is located
+
+      validate :first_seen_at_is_date, if: lambda { |obj| obj.first_seen_at.present? } # date the device was first seen
+      validate :localtime_is_datetime, if: lambda { |obj| obj.localtime.present? } # device localtime
+
+      def mobile?
+        mobile_type.present?
+      end
+
+      def to_h
+        {
+          browser: browser,
+          cookies_enabled: cookies_enabled,
+          first_seen_at: first_seen_at,
+          layers: layers,
+          screen_resolution: screen_resolution,
+          fingerprint: fingerprint,
+          flash_enabled: flash_enabled,
+          configured_country_code: configured_country_code,
+          javascript_enabled: javascript_enabled,
+          captured: captured,
+          language_country_code: language_country_code,
+          localtime: localtime,
+          using_forwarder: using_forwarder,
+          mobile_type: mobile_type,
+          operating_system: operating_system,
+          remote_access: remote_access,
+          configured_region: configured_region,
+          timezone: timezone,
+          user_agent: user_agent,
+          voice_enabled: voice_enabled,
+          region: region,
+          country_code: country_code,
+        }
+      end
+
+      private
+
+      def first_seen_at_is_date
+        self.first_seen_at = first_seen_at.to_date if first_seen_at.is_a?(Date) || first_seen_at.is_a?(DateTime)
+
+        errors.add(:first_seen_at, 'must be a Date object') unless first_seen_at.is_a?(Date)
+      end
+
+      def localtime_is_datetime
+        self.localtime = localtime.to_datetime if localtime.is_a?(Date) || localtime.is_a?(Time)
+
+        errors.add(:localtime, 'must be a DateTime object') unless localtime.is_a?(DateTime)
+      end
+
+    end
+  end
+end
+

data/app/models/kount/ris/inquiry.rb

@@ -0,0 +1,440 @@
+require 'net/http'
+require 'uri'
+
+module Kount
+  module RIS
+    class Inquiry < Base
+      attr_accessor :id, :authorized, :email, :ip_address, :acknowledged, :merchant_id, :products, :session_id,
+        :site_id, :total, :kount_id, :api_version, :gateway_id, :avs_code, :shipping_address, :customer_id,
+        :billing_address, :recipient_email, :recipient_name, :last_four, :amount, :cvv_code, :order_number,
+        :shipping_method, :birthdate, :account_created_at, :user_agent, :name, :api_host, :card_type, :api_key
+      attr_reader :mode, :response_format, :gender, :response, :card_number
+
+      alias_method :authorized?, :authorized
+      alias_method :acknowledged?, :acknowledged
+
+      PAYMENT_TYPES = {
+        'apay' => 'Apple Pay',
+        'card' => 'Credit Card',
+        'pypl' => 'PayPal',
+        'chek' => 'Check',
+        'none' => 'None',
+        'gdmp' => 'Green Dot Money Pack',
+        'goog' => 'Google Checkout',
+        'blml' => 'Bill Me Later',
+        'gift' => 'Gift Card',
+        'bpay' => 'BPAY',
+        'netellar' => 'Netellar',
+        'giropay' => 'GiroPay',
+        'elv' => 'ELV',
+        'mercade_pago' => 'Mercade Pago',
+        'sepa' => 'Single Euro Payments Area',
+        'interac' => 'Interac',
+        'poli' => 'POLi',
+        'skrill' => 'Skrill/Moneybookers',
+        'sofort' => 'Sofort',
+        'token' => 'Token',
+      }.freeze
+      SHIPPING_METHODS = {
+        'sd' => 'Same Day',
+        'nd' => 'Next Day',
+        '2d' => 'Second Day',
+        'st' => 'Standard',
+      }.freeze
+      MODES = %w[q u p x e j w].freeze
+      RESPONSE_FORMATS = %w[sdk xml json yaml].freeze
+      GENDERS = %w[male female].freeze
+      CARD_TYPES = %w[visa mastercard amex discover]
+
+      class << self
+        def currency_codes
+          Kount::RIS::Base::COUNTRY_CODES
+        end
+      
+        def payment_types
+          PAYMENT_TYPES
+        end
+
+        def shipping_methods
+          SHIPPING_METHODS
+        end
+
+        def modes
+          MODES
+        end
+
+        def response_formats
+          RESPONSE_FORMATS
+        end
+
+        def genders
+          GENDERS
+        end
+
+        def card_types
+          CARD_TYPES
+        end
+      end
+
+      def currency_codes
+        self.class.currency_codes
+      end
+
+      def payment_types
+        self.class.payment_types
+      end
+
+      def shipping_methods
+        self.class.shipping_methods
+      end
+
+      def modes
+        self.class.modes
+      end
+
+      def response_formats
+        self.class.response_formats
+      end
+
+      def genders
+        self.class.genders
+      end
+
+      def card_types
+        self.class.card_types
+      end
+
+      validates :id, presence: { if: lambda { |obj| obj.mode?(:p) } }, length: { maximum: 32 } # automatic number identification
+      validates :authorized, presence: { if: lambda { |obj| obj.mode?(:p, :q) } }, inclusion: { in: [true, false] } # authorization status
+      validates :currency_code, inclusion: { in: currency_codes }, presence: { if: lambda { |obj| obj.mode?(:p, :q) } } # Country of currency submitted on order
+      validates :email, presence: { if: lambda { |obj| obj.mode?(:q) } }, length: { maximum: 64 } # customer email address
+      validates :ip_address, presence: { if: lambda { |obj| obj.mode?(:p, :q) } }, length: { maximum: 16 } # customer ip address
+      validates :acknowledged, presence: { if: lambda { |obj| obj.mode?(:p, :q) } }, inclusion: { in: [true, false] } # Merchants acknowledgement to ship/process the order
+      validates :merchant_id, presence: { if: lambda { |obj| obj.mode?(:p, :q, :u, :x) } }, length: { maximum: 6 } # Merchant ID assigned to the merchant by Kount
+      validates :mode, inclusion: { in: modes }, presence: true # RIS inquiry mode
+      validates :payment_type, inclusion: { in: payment_types.values }, presence: { if: lambda { |obj| obj.mode?(:p, :q) } }
+      validates :session_id, presence: { if: lambda { |obj| obj.mode?(:p, :q, :u, :x) } }, length: { maximum: 32 } # GUID session id
+      validates :site_id, presence: { if: lambda { |obj| obj.mode?(:p, :q) } }, length: { maximum: 8 } # website identifier configured in Web Agent Console
+      validates :total, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # products total, automatically calculated if not provided
+      validates :kount_id, presence: { if: lambda { |obj| obj.mode?(:u, :x) } } # kount issued transaction id, required if updating
+      validates :api_version, presence: { if: lambda { |obj| obj.mode?(:p, :q, :u, :x) } }, length: { maximum: 4 } # api version
+      validates :gateway_id, presence: { if: lambda { |obj| obj.mode?(:j, :w) } }, length: { maximum: 32 } # used only for Kount Central Merchants
+      validates :recipient_email, length: { maximum: 64 } # Recipient Email Address
+      validates :recipient_name, length: { maximum: 64 } # Recipient Name
+      validates :shipping_method, inclusion: { in: shipping_methods.values }, allow_nil: true # Shipping Method
+      validates :customer_id, length: { maximum: 32 } # unique customer identifier
+      validates :user_agent, length: { maximum: 1024 } # HTTP header user agent
+      validates :amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # transaction amount
+      validates :response_format, inclusion: { in: response_formats }, presence: true # response_format
+      validates :last_four, format: { with: /\A[0-9]{4}\z/ }, length: { is: 4 }, allow_nil: true
+      validates :name, length: { maximum: 64 } # cardholder's name
+      validates :gender, inclusion: { in: genders }, allow_nil: true # gender
+      validates :order_number, length: { maximum: 32 } # cardholder's name
+      validates :card_type, inclusion: { in: card_types }, allow_nil: true # Shipping Method
+      validate :products_are_valid
+      validate :shipping_address_is_valid, if: lambda { |obj| obj.shipping_address.present? }
+      validate :billing_address_is_valid, if: lambda { |obj| obj.billing_address.present? }
+      validate :birthdate_is_date, if: lambda { |obj| obj.birthdate.present? }
+      validate :account_created_at_is_datetime, if: lambda { |obj| obj.account_created_at.present? }
+      validate :real_world_ip_address, unless: lambda { |obj| obj.mode?(:p) }
+
+      def currency_code=(value)
+        @currency_code = value.to_s.downcase
+      end
+
+      def currency_code
+        @currency_code.upcase if @currency_code
+      end
+
+      def payment_type=(value)
+        return @payment_type = nil if value.nil?
+
+        payment_type_value = payment_types.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid payment type" unless payment_types.include?(payment_type_value)
+        @payment_type = payment_type_value
+      end
+
+      def payment_type
+        payment_types[@payment_type]
+      end
+
+      def shipping_method=(value)
+        return @shipping_method = nil if value.nil?
+
+        shipping_method_value = shipping_methods.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid shipping method" unless shipping_methods.include?(shipping_method_value)
+        @shipping_method = shipping_method_value
+      end
+
+      def shipping_method
+        shipping_methods[@shipping_method]
+      end
+
+      def mode=(value)
+        return @mode = nil if value.nil?
+
+        mode_value = value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid mode" unless modes.include?(mode_value)
+        @mode = mode_value
+      end
+
+      def response_format=(value)
+        return @response_format = nil if value.nil?
+
+        response_format_value = value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid response format" unless response_formats.include?(response_format_value)
+        @response_format = response_format_value
+      end
+
+      def gender=(value)
+        return @gender = nil if value.nil?
+
+        gender_value = value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid gender" unless genders.include?(gender_value)
+        @gender = gender_value
+      end
+
+      def card_number=(value)
+        @card_number = value.to_s
+        @last_four = value.to_s.last(4)
+        @card_type = case value.to_s.first
+        when '3' then 'amex'
+        when '4' then 'visa'
+        when '5' then 'mastercard'
+        when '6' then 'discover'
+        end
+      end
+
+      def initialize(attrs = {})
+        attrs.symbolize_keys!
+        attrs.reverse_merge!(Kount.configuration.except(:company_server_url, :salt))
+        attrs.reverse_merge!({
+          authorized: true,
+          acknowledged: true,
+          email: 'noemail@kount.com',
+          ip_address: '10.0.0.1',
+          mode: :q,
+        })
+        if attrs[:mode] == 'p'
+          attrs.reverse_merge!({ id: '0123456789' })
+          attrs.merge!({ ip_address: '10.0.0.1' })
+        end
+
+        super(attrs.except(:products_attributes, :shipping_address_attributes, :billing_address_attributes))
+
+        self.products = Array(attrs[:products_attributes]).collect { |product_attributes| Product.new(product_attributes) }
+        self.shipping_address = Address.new(attrs[:shipping_address_attributes]) if attrs.include?(:shipping_address_attributes)
+        self.billing_address = Address.new(attrs[:billing_address_attributes]) if attrs.include?(:billing_address_attributes)
+
+        self
+      end
+
+      def payment_token
+        card_number =~ /x/i ? card_number : KHASH.new(card_number).to_s
+      end
+
+      def avs_match_street
+        {
+          a: { visa: true, mastercard: true, discover: true, amex: true },
+          b: { visa: true },
+          d: { visa: true },
+          f: { visa: true, amex: true },
+          m: { visa: true, amex: true },
+          n: { visa: false, mastercard: false, discover: false, amex: false },
+          o: { amex: true },
+          t: { discover: false },
+          w: { visa: false, mastercard: false, discover: false, amex: false },
+          x: { visa: true, mastercard: true, discover: true },
+          y: { visa: true, mastercard: true, discover: true, amex: true },
+          z: { visa: false, mastercard: false, discover: false, amex: false },
+        }.dig(avs_code.to_s.downcase.to_sym, card_type.to_sym) if avs_code.present? && card_type.present?
+      end
+      alias_method :avs_match_street?, :avs_match_street
+
+      def avs_match_zip
+        {
+          a: { visa: false, mastercard: true, discover: false, amex: true },
+          d: { visa: true },
+          f: { visa: true },
+          l: { amex: true },
+          m: { visa: true, amex: true },
+          n: { visa: false, mastercard: false, discover: false, amex: false },
+          p: { visa: true },
+          t: { discover: true },
+          w: { visa: true, mastercard: true, discover: true, amex: false },
+          x: { visa: true, mastercard: true, discover: true },
+          y: { visa: true, mastercard: true, discover: true, amex: true },
+          z: { visa: true, mastercard: true, discover: true, amex: true },
+        }.dig(avs_code.to_s.downcase.to_sym, card_type.to_sym) if avs_code.present? && card_type.present?
+      end
+      alias_method :avs_match_zip?, :avs_match_zip
+
+      def cvv_match
+        case cvv_code.to_s.to_sym
+        when :m, :y, :'0' then true
+        when :n, :'1' then false
+        end if cvv_code.present?
+      end
+      alias_method :cvv_match?, :cvv_match
+
+      def mode?(*modes)
+        Array(modes).collect(&:to_s).include? mode
+      end
+
+      def to_query_params
+        query_params = {
+          ANID: id,
+          AUTH: ((authorized? ? 'A' : 'D') unless authorized.nil?),
+          CURR: currency_code,
+          EMAL: email,
+          IPAD: ip_address,
+          MACK: ('Y' if acknowledged?),
+          MERC: merchant_id,
+          MODE: (mode.to_s.upcase unless mode.nil?),
+          PROD_DESC: products.collect(&:description),
+          PROD_ITEM: products.collect(&:id),
+          PROD_PRICE: products.collect(&:price),
+          PROD_QUANT: products.collect(&:quantity),
+          PROD_TYPE: products.collect(&:category),
+          PTOK: payment_token,
+          PTYP: @payment_type,
+          SESS: session_id,
+          SITE: site_id,
+          TOTL: (total || products.sum { |product| product.price * product.quantity }),
+          TRAN: kount_id,
+          VERS: api_version,
+          CUSTOMER_ID: gateway_id,
+          AVST: (avs_match_street.nil? ? 'X' : (avs_match_street? ? 'M' : 'N')),
+          AVSZ: (avs_match_zip.nil? ? 'X' : (avs_match_zip? ? 'M' : 'N')),
+          CASH: amount,
+          CVVR: (cvv_match.nil? ? 'X' : (cvv_match? ? 'M' : 'N')),
+          S2EM: recipient_email,
+          S2NM: recipient_name,
+          SHTP: @shipping_method,
+          UNIQ: customer_id,
+          UAGT: user_agent,
+          DOB: (birthdate.strftime('%Y-%m-%d') unless birthdate.nil?),
+          EPOC: (account_created_at.to_i unless account_created_at.nil?),
+          FRMT: (response_format.to_s.upcase unless response_format.nil?),
+          GENDER: gender,
+          LAST4: last_four,
+          NAME: name,
+          ORDR: order_number,
+        }
+
+        query_params.merge!({
+          B2A1: shipping_address.address_1,
+          B2A2: shipping_address.address_2,
+          B2CC: shipping_address.country_code,
+          B2CI: shipping_address.city,
+          B2PC: shipping_address.postal_code,
+          B2PN: shipping_address.phone,
+          B2ST: shipping_address.region,
+          BPREMISE: shipping_address.premise,
+          BSTREET: shipping_address.thoroughfare,
+        }) if shipping_address.present?
+
+        query_params.merge!({
+          S2A1: billing_address.address_1,
+          S2A2: billing_address.address_2,
+          S2CC: billing_address.country_code,
+          S2CI: billing_address.city,
+          S2PC: billing_address.postal_code,
+          S2PN: billing_address.phone,
+          S2ST: billing_address.region,
+          SPREMISE: billing_address.premise,
+          SSTREET: billing_address.thoroughfare,
+        }) if billing_address.present?
+
+        # validate total length of URL including domain - 4k limit
+
+        query_params.compact!
+      end
+
+      def to_query
+        to_query_params.to_query
+      end
+
+      def submit!
+        uri = URI.parse("https://#{api_host}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["X-Kount-Api-Key"] = api_key
+        request.set_form_data(to_query_params)
+
+        response = http.request(request)
+
+        response_params = response.body.split("\n").collect { |params| Rack::Utils.parse_nested_query(params) }.reduce({}, :merge)
+
+        @response = Response.new(response_params)
+      end
+
+      private
+
+      def products_are_valid
+        unless products.is_a?(Array)
+          errors.add(:products, 'must be an Array of Product objects')
+          return false
+        end
+
+        if products.none? && mode?(:p, :q)
+          errors.add(:products, 'can\'t be empty')
+          return false
+        end
+
+        products.each.with_index(1) do |product, i|
+          unless product.valid?
+            product.errors.full_messages.each do |error|
+              errors.add(:products, "element #{i} #{error}")
+            end
+          end
+        end
+      end
+
+      def shipping_address_is_valid
+        unless shipping_address.is_a?(Address)
+          errors.add(:shipping_address, 'must be an Address object')
+          return false
+        end
+
+        unless shipping_address.valid?
+          shipping_address.errors.full_messages.each do |error|
+            errors.add(:shipping_address, error)
+          end
+        end
+      end
+
+      def billing_address_is_valid
+        unless billing_address.is_a?(Address)
+          errors.add(:billing_address, 'must be an Address object')
+          return false
+        end
+
+        unless billing_address.valid?
+          billing_address.errors.full_messages.each do |error|
+            errors.add(:billing_address, error)
+          end
+        end
+      end
+
+      def birthdate_is_date
+        self.birthdate = birthdate.to_date if birthdate.is_a?(Date) || birthdate.is_a?(DateTime)
+
+        errors.add(:birthdate, 'must be a Date object') unless birthdate.is_a?(Date)
+      end
+
+      def account_created_at_is_datetime
+        self.account_created_at = account_created_at.to_datetime if account_created_at.is_a?(Date) || account_created_at.is_a?(Time)
+
+        errors.add(:account_created_at, 'must be a DateTime object') unless account_created_at.is_a?(DateTime)
+      end
+
+      def real_world_ip_address
+        errors.add(:ip_address, 'may not be in a private scope') if ip_address.to_s =~ /\A(10|172|192)\./
+      end
+
+    end
+  end
+end