workarea-kount 3.3.0

data/lib/workarea/kount/engine.rb

@@ -0,0 +1,8 @@
+module Workarea
+  module Kount
+    class Engine < ::Rails::Engine
+      include Workarea::Plugin
+      isolate_namespace Workarea::Kount
+    end
+  end
+end

data/lib/workarea/kount/errors.rb

@@ -0,0 +1,2 @@
+class Workarea::Kount::Errors < StandardError; end
+class Workarea::Kount::Errors::PaymentNotSupportedError < Workarea::Kount::Errors; end

data/lib/workarea/kount/gateway.rb

@@ -0,0 +1,50 @@
+module Workarea
+  module Kount
+    class Gateway
+      delegate :merchant_id, :key, :ksalt, to: Workarea::Kount
+      attr_reader :options
+
+      RESPONSE_FORMAT = 'JSON'
+
+      VERSION = '0630'
+      ENDPOINT_PROD = 'https://risk.kount.net'
+      ENDPOINT_TEST = 'https://risk.test.kount.net'
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def call(body)
+        body = body.merge(VERS: VERSION, MERC: Kount.merchant_id, FRMT: RESPONSE_FORMAT)
+
+        response = RestClient::Resource
+          .new(endpoint, verify_ssl: verify_ssl_option, timeout: 1)
+          .post(body, x_kount_api_key: Kount.key)
+
+        begin
+          Response.new(JSON.parse(response))
+        rescue
+          Response.from_error(response.body)
+        end
+      end
+
+      private
+
+        def test?
+          options.fetch(:is_test, false)
+        end
+
+        def endpoint
+          test? ? ENDPOINT_TEST : ENDPOINT_PROD
+        end
+
+        def verify_ssl_option
+          if test?
+            OpenSSL::SSL::VERIFY_NONE
+          else
+            OpenSSL::SSL::VERIFY_PEER
+          end
+        end
+    end
+  end
+end

data/lib/workarea/kount/mappings.rb

@@ -0,0 +1,195 @@
+module Workarea
+  module Kount
+    class Mappings
+      MAPPING = {
+        # REQUEST INFO
+        version: 'VERS',
+        mode: 'MODE',
+        sdk: 'SDK',
+        merchant_id: 'MERC',
+        session_id: 'SESS',
+        merchant_order_number: 'ORDR',
+        site: 'SITE',
+        format: 'FRMT',
+        transaction_id: 'TRAN',
+
+        # MONEY
+        currency: 'CURR',
+        total: 'TOTL',
+        cash: 'CASH',
+
+        # USER INFO
+        phone_number: 'ANID',
+        email: 'EMAL',
+        customer_name: 'NAME',
+        dob: 'DOB',
+        gender: 'GENDER',
+
+        ship_to_name: 'S2NM',
+        ship_to_email: 'S2EM',
+
+        # SHIPPING ADDRESS
+        ship_to_address1: 'S2A1',
+        ship_to_address2: 'S2A2',
+        ship_to_city: 'S2CI',
+        ship_to_state: 'S2ST',
+        ship_to_postal: 'S2PC',
+        ship_to_country_code: 'S2CC',
+        ship_to_phone_number: 'S2PN',
+
+        # BILLING ADDRESS
+        bill_to_address1: 'B2A1',
+        bill_to_address2: 'B2A2',
+        bill_to_city: 'B2CI',
+        bill_to_state: 'B2ST',
+        bill_to_postal: 'B2PC',
+        bill_to_country_code: 'B2CC',
+        bill_to_phone_number: 'B2PN',
+
+        bill_to_premises: 'BPREMISE', # UK
+        bill_to_street: 'BSTREET', # UK
+        ship_to_premises: 'SPREMISE', # UK
+        ship_to_street: 'SSTREET', # UK
+
+        # PAYMENT
+        payment_type: 'PTYP',
+        payment_data: 'PTOK',
+        payment_encoding: 'PENC', # KASH
+
+        driver_license_number: 'DRIV',
+        customer_id: 'UNIQ',
+        customer_created_at: 'EPOC', # EPOC when user was created
+        ip_address: 'IPAD',
+        http_user_agent: 'UAGT',
+        shipping_type: 'SHPT',
+
+        # ORDER STATUS CODES
+        merchant_ack: 'MACK',
+        authorization_status: 'AUTH',
+        avs_zip_response: 'AVSZ',
+        avs_street_response: 'AVST',
+        cvv_response: 'CVVR',
+        refund_charge_back_status: 'RFCB'
+      }.freeze
+
+      AUTO_MAPPING = {
+        'D' => :declined,
+        'R' => :review,
+        'E' => :manager_review,
+        'A' => :approved
+      }.freeze
+
+      # Public: A hash that maps Kount response key names to readable Ruby symbols
+      RESPONSE_MAPPING = {
+        "VELO":               :velocity,
+        "REGION":             :region,
+        "FLASH":              :flash,
+        "TRAN":               :transaction_id,
+        "DEVICE_LAYERS":      :device_layers,
+        "JAVASCRIPT":         :javascript,
+        "HTTP_COUNTRY":       :http_country,
+        "MODE":               :mode,
+        "EMAILS":             :emails,
+        "TIMEZONE":           :timezone,
+        "MOBILE_TYPE":        :mobile_type,
+        "WARNING_COUNT":      :warning_count,
+        "REGN":               :region,
+        "LOCALTIME":          :localtime,
+        "COUNTRY":            :country,
+        "REAS":               :reason_variable,
+        "CARDS":              :cards,
+        "PROXY":              :proxy,
+        "VOICE_DEVICE":       :voice_device,
+        "BRND":               :payment_brand,
+        "NETW":               :network,
+        "KAPT":               :has_ris_record,
+        "FINGERPRINT":        :fingerprint,
+        "COOKIES":            :cookies,
+        "LANGUAGE":           :language,
+        "RULES_TRIGGERED":    :rules_triggered,
+        "SESS":               :session_id,
+        "GEOX":               :worst_contry_associated,
+        "DEVICES":            :devices,
+        "VMAX":               :vmax,
+        "SITE":               :site,
+        "ORDR":               :order_id,
+        "AUTO":               :auto,
+        "SCOR":               :score,
+        "COUNTERS_TRIGGERED": :counters_triggered,
+        "VERS":               :version,
+        "MERC":               :merchant_id,
+        "PC_REMOTE":          :pc_remote,
+        "MOBILE_DEVICE":      :mobile_device,
+        "MOBILE_FORWARDER":   :mobile_forwarder,
+        "KYCF":               :know_your_customer,
+        "ERROR_COUNT":        :error_count,
+        "ERRO":               :error
+      }.freeze
+
+      # Public: A hash that maps Kount Error Numbers to Error Codes
+      ERRORS = {
+        '201': 'MISSING_VERS',
+        '202': 'MISSING_MODE',
+        '203': 'MISSING_MERC',
+        '204': 'MISSING_SESS',
+        '205': 'MISSING_TRAN',
+        '211': 'MISSING_CURR',
+        '212': 'MISSING_TOTL',
+        '221': 'MISSING_EMAL',
+        '222': 'MISSING_ANID',
+        '223': 'MISSING_SITE',
+        '231': 'MISSING_PTYP',
+        '232': 'MISSING_CARD',
+        '233': 'MISSING_MICR',
+        '234': 'MISSING_PYPL',
+        '235': 'MISSING_PTOK',
+        '241': 'MISSING_IPAD',
+        '251': 'MISSING_MACK',
+        '261': 'MISSING_POST',
+        '271': 'MISSING_PROD_TYPE',
+        '272': 'MISSING_PROD_ITEM',
+        '273': 'MISSING_PROD_DESC',
+        '274': 'MISSING_PROD_QUANT',
+        '275': 'MISSING_PROD_PRICE',
+        '301': 'BAD_VERS',
+        '302': 'BAD_MODE',
+        '303': 'BAD_MERC',
+        '304': 'BAD_SESS',
+        '305': 'BAD_TRAN',
+        '311': 'BAD_CURR',
+        '312': 'BAD_TOTL',
+        '321': 'BAD_EMAL',
+        '322': 'BAD_ANID',
+        '323': 'BAD_SITE',
+        '324': 'BAD_FRMT',
+        '331': 'BAD_PTYP',
+        '332': 'BAD_CARD',
+        '333': 'BAD_MICR',
+        '334': 'BAD_PYPL',
+        '335': 'BAD_GOOG',
+        '336': 'BAD_BLML',
+        '337': 'BAD_PENC',
+        '341': 'BAD_IPAD',
+        '351': 'BAD_MACK',
+        '362': 'BAD_CART',
+        '371': 'BAD_PROD_TYPE',
+        '372': 'BAD_PROD_ITEM',
+        '373': 'BAD_PROD_DESC',
+        '374': 'BAD_PROD_QUANT',
+        '375': 'BAD_PROD_PRICE',
+        '399': 'BAD_OPTN',
+        '401': 'EXTRA_DATA',
+        '402': 'MISMATCH_PTYP',
+        '403': 'UNNECESSARY_ANID',
+        '404': 'UNNECESSARY_PTOK',
+        '501': 'UNAUTH_REQ',
+        '502': 'UNAUTH_MERC',
+        '503': 'UNAUTH_IP',
+        '504': 'UNAUTH_PASS',
+        '601': 'SYS_ERR',
+        '602': 'SYS_NOPROCESS',
+        '701': 'NO_HDR'
+      }.freeze
+    end
+  end
+end

data/lib/workarea/kount/payment_types.rb

@@ -0,0 +1,50 @@
+module Workarea
+  module Kount
+    class PaymentTypes
+      # Credit card (VISA, MasterCard, Amercian Express, etc)
+      CREDIT_CARD   = 'CARD'
+      #Generic Token
+      TOKEN         = 'TOKEN'
+      # PayPal
+      PAYPAL        = 'PYPL'
+      # Check
+      CHECK         = 'CHEK'
+      # Merchant issued gift card (not the ones with VISA/MC on them)
+      GIFT_CARD     = 'GIFT'
+      # Carte Bleue
+      CARTE_BLEUE   = 'CARTE_BLEUE'
+      # Sofort
+      SOFORT        = 'SOFORT'
+      # Elv
+      ELV           = 'ELV'
+      # Poli
+      POLI          = 'POLI'
+      # Neteller
+      NETELLER      = 'NETELLER'
+      # Giropay
+      GIROPAY       = 'GIROPAY'
+      # BPay
+      BPAY          = 'BPAY'
+      # Interac
+      INTERAC       = 'INTERAC'
+      # Apple Pay
+      APPLE_PAY     = 'APAY'
+      # Skrill
+      SKRILL        = 'SKRILL'
+      # Moneybooker (basically another name for Skrill)
+      MONEYBOOKERS  = 'SKRILL'
+      # Mercado Pago
+      MERCADO_PAGO  = 'MERCADE_PAGO'
+      # Bill Me Later
+      BILL_ME_LATER = 'BLML'
+      # Google Checkout
+      GOOGLE_CHECKOUT = 'GOOG'
+      # Green Dot Money Pack
+      GREEN_DOT_MONEY_PACK = 'GDMP'
+      # Single Euro Payments Area
+      SINGLE_EURO_PAYMENTS_AREA = 'SEPA'
+      # None
+      NONE = 'NONE'
+    end
+  end
+end

data/lib/workarea/kount/response.rb

@@ -0,0 +1,141 @@
+module Workarea
+  module Kount
+    class Response
+      attr_reader :body
+      delegate :keys, :[], to: :body
+
+      def self.from_error(error_string)
+        body = error_string.strip.split("\n").each_with_object({}) do |string, response|
+          key, value = string.split("=")
+          response[key] = value
+        end
+
+        Response.new(body)
+      end
+
+      def initialize(body)
+        @body = body
+      end
+
+      def result_hash
+        @result_hash ||=
+          begin
+            body_dup          = body.dup
+            rule_ids          = []
+            rule_descriptions = []
+
+            errors            = []
+            warnings          = []
+
+            body_dup.each do |key, value|
+              if key =~ /^RULE_ID_(\d+)/
+                rule_ids[$1.to_i] = value
+                body_dup.delete(key)
+              end
+
+              if key =~ /^RULE_DESCRIPTION_(\d+)/
+                rule_descriptions[$1.to_i] = value
+                body_dup.delete(key)
+              end
+
+              if key =~ /^WARNING_(\d+)/
+                warnings[$1.to_i] = value
+                body_dup.delete(key)
+              end
+
+              if key =~ /^ERROR_(\d+)/
+                errors[$1.to_i] = value
+                body_dup.delete(key)
+              end
+            end
+
+            if rule_ids.present?
+              rules = rule_ids.each_with_index.map do |rule_id, i|
+                { rule_id: rule_id, rule_description: rule_descriptions[i] }
+              end
+            end
+
+            response_values = body_dup.map do |key, value|
+              [
+                Workarea::Kount::Mappings::RESPONSE_MAPPING.fetch(key, key),
+                value
+              ]
+            end.to_h
+
+            response_values.merge(
+              rules:        rules,
+              errors_kount: errors, # this was named this way, b/c of how ActiveRecord handles "errors=", ugh!
+              warnings:     warnings
+            )
+          end
+      end
+
+      def triggered_rules
+        result_hash[:rules]
+      end
+
+      # Symbol for the decision made by Kount
+      #
+      # Returns a symbol for the decision made by Kount
+      def decision
+        Workarea::Kount::Mappings::AUTO_MAPPING.fetch(result_hash["AUTO"], :approve)
+      end
+
+      def transaction_id
+        body["TRAN"]
+      end
+
+      def success?
+        body["MODE"] != "E" && result_hash["ERROR_COUNT"].to_i == 0
+      end
+
+      def score
+        body["SCOR"]
+      end
+
+      def credit_cards
+        body["CARDS"]
+      end
+
+      def email_addresses
+        body["EMAILS"]
+      end
+
+      def devices
+        body["DEVICES"]
+      end
+
+      def mongoize
+        body
+      end
+
+      class << self
+        def demongoize(object)
+          return nil if object.blank?
+
+          Response.new(object)
+        end
+
+        def mongoize(object)
+          case object
+          when Response then object.mongoize
+          else object
+          end
+        end
+
+        def evolve(object)
+          raise 'querying on an Workarea::Kount::Response is unsupported at this time'
+        end
+      end
+
+      private
+
+        # Takes the raw_response and parses it to key values for the
+        # keyvalue format
+        #
+        # Returns a hash of key values
+        def parsed_response
+        end
+    end
+  end
+end