kount-ris 0.1.0

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

@@ -0,0 +1,28 @@
+module Kount
+  module RIS
+    class Location < Base
+      attr_accessor :ip_address, :country_code, :latitude, :longitude, :city, :region, :owner
+
+      validates :ip_address, length: { maximum: 16 }
+      validates :country_code, length: { maximum: 16 }
+      validates :latitude, length: { maximum: 16 }
+      validates :longitude, length: { maximum: 16 }
+      validates :city, length: { maximum: 255 }
+      validates :region, length: { maximum: 255 }
+      validates :owner, length: { maximum: 64 } # owner of IP address or address block
+
+      def to_h
+        {
+          ip_address: ip_address,
+          country_code: country_code,
+          latitude: latitude,
+          longitude: longitude,
+          city: city,
+          region: region,
+          owner: owner,
+        }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+module Kount
+  module RIS
+    class Persona < Base
+      attr_accessor :card_count, :device_count, :email_count, :country_code, :order_count, :active_order_count
+
+      validates :card_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # number of cards kount has associated to persona
+      validates :device_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # number of devices kount has associated to persona
+      validates :email_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # number of emails associated to persona
+      validates :country_code, length: { maximum: 2 } # contry related to the persona
+      validates :order_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # number of orders from persona
+      validates :active_order_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true # count orders from persona within the most active 6 hour window in last 14 days
+
+      def to_h
+        {
+          card_count: card_count,
+          device_count: device_count,
+          email_count: email_count,
+          country_code: country_code,
+          order_count: order_count,
+          active_order_count: active_order_count,
+        }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+module Kount
+  module RIS
+    class Product < Base
+      attr_accessor :description, :id, :price, :quantity, :category
+
+      validates :description, presence: true, length: { maximum: 256 } # product description
+      validates :id, presence: true, length: { maximum: 256 } # product identifier or SKU
+      validates :price, presence: true, numericality: { greater_than_or_equal_to: 0 } # product price
+      validates :quantity, presence: true, numericality: { greater_than: 0 } # quantity being purchased
+      validates :category, presence: true, length: { maximum: 256 } # the product category
+
+      def initialize(attrs)
+        attrs.symbolize_keys!
+        attrs.reverse_merge!({ quantity: 1 })
+        super(attrs)
+      end
+
+      def to_h
+        {
+          description: description,
+          id: id,
+          price: price,
+          quantity: quantity,
+          category: category,
+        }
+      end
+    end
+  end
+end
+      

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

@@ -0,0 +1,389 @@
+module Kount
+  module RIS
+    class Response < Base
+      attr_accessor :score, :reason_text, :merchant_id, :mode, :order_number, :session_id, :site_id,
+        :api_version, :kount_id, :counters, :rules, :warnings, :errors, :persona, :device, :proxy_location,
+        :pierced_location, :error_code
+
+      DECISIONS = {
+        'a' => 'Approve',
+        'd' => 'Decline',
+        'r' => 'Review',
+        'e' => 'Esclate',
+      }.freeze
+      CARD_TYPES = {
+        'disc' => 'Discover',
+        'visa' => 'Visa',
+        # # FILL
+      }.freeze
+      REASON_CODES = { 
+        'amnt' => 'Amount',
+        'geox' => 'Persona related country with highest probability of fraud',
+        'list' => 'VIP List (EMail, Card, Address, Gift Card, Device ID)',
+        'netw' => 'Network Type',
+        'scor' => 'Score',
+        'velo' => 'Sales velocity in a fourteen day time frame',
+        'vmax' => 'Sales velocity in a six hour time frame',
+      }.freeze
+      STATUSES = {
+        'a' => 'Approve',
+        'd' => 'Decline',
+        'r' => 'Review',
+        'e' => 'Esclate',
+        'c' => 'Original transaction was approved but due to dynamic scoring the transaction now has an elevated score and may require reevaluation',
+        'x' => 'Transaction was flagged for review but never acted upon and has timed out',
+        'y' => 'Original transaction was approved but updated with AUTH=D and then timed out',
+      }.freeze
+
+      class << self
+        def decisions
+          DECISIONS
+        end
+
+        def card_types
+          CARD_TYPES
+        end
+
+        def reason_codes
+          REASON_CODES
+        end
+
+        def statuses
+          STATUSES
+        end
+      end
+
+      def decisions
+        self.class.decisions
+      end
+
+      def card_types
+        self.class.card_types
+      end
+
+      def reason_codes
+        self.class.reason_codes
+      end
+
+      def statuses
+        self.class.statuses
+      end
+
+      def decision=(value)
+        return @decision = nil if value.nil?
+
+
+        decision_value = decisions.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid decision" unless decisions.include?(decision_value)
+        @decision = decision_value
+      end
+
+      def decision
+        decisions[@decision]
+      end
+
+      def card_type=(value)
+        return @card_type = nil if value.nil?
+
+        card_type_value = card_types.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid card type" unless card_types.include?(card_type_value)
+        @card_type = card_type_value
+      end
+
+      def card_type
+        card_types[@card_type]
+      end
+
+      def reason_code=(value)
+        return @reason_code = nil if value.nil?
+
+        reason_code_value = reason_codes.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid reason code" unless reason_codes.include?(reason_code_value)
+        @reason_code = reason_code_value
+      end
+
+      def reason_code
+        reason_codes[@reason_code]
+      end
+
+      def status=(value)
+        return @status = nil if value.nil?
+
+        status_value = statuses.detect { |k,v| k if v.downcase == value.to_s.downcase }&.first || value.to_s.downcase
+        raise ArgumentError, "'#{value}' is not a valid status" unless statuses.include?(status_value)
+        @status = status_value
+      end
+
+      def status
+        statuses[@status]
+      end
+
+      validates :score, numericality: { in: 0..100 } # score 0-99 ?
+      validates :reason_text, length: { maximum: 16 } # reason for score, custom text
+      validates :merchant_id, length: { maximum: 6 } # (matches inquiry)
+      validates :mode, length: { maximum: 1 } # (matches inquiry)
+      validates :order_number, length: { maximum: 32 } # transaction order number
+      validates :session_id, length: { maximum: 32 } # (matches inquiry)
+      validates :site_id, length: { maximum: 8 } # (matches inquiry)
+      validates :api_version, length: { maximum: 4 } # (matches inquiry)
+      validates :kount_id, length: { maximum: 12 } # Kount transaction ID number
+      validates :error_code, length: { is: 3 }, allow_nil: true # error code, also in errors
+
+      validates :decision, inclusion: { in: decisions.values }, allow_nil: true # decision from Count for transaction
+      validates :card_type, inclusion: { in: card_types.values }, allow_nil: true # credit card type
+      validates :reason_code, inclusion: { in: reason_codes.values }, allow_nil: true # reason for score, if 'None' use #reason_text
+      validates :status, inclusion: { in: statuses.values }, allow_nil: true # extended decision details -> STAT
+
+      validate :counters_are_valid # array of Trigger::Counter objects -> {count} COUNTERS_TRIGGERED, COUNTER_NAME_X, COUNTER_VALUE_X
+      validate :rules_are_valid # array of Trigger::Rule objects -> {count} RULES_TRIGGERED / RULE_DESCRIPTION_X / RULE_ID_X
+      validate :warnings_are_valid # array of Trigger::Warning objects -> {count} WARNING_COUNT / WARNING_N
+      validate :errors_are_valid # array of Trigger::Error objects -> {count} ERROR_COUNT / ERROR_N
+      validate :persona_is_valid # Persona object
+      validate :device_is_valid # Device object
+      validate :proxy_location_is_valid # Location object -> {ALSO} PROXY derived from #proxy_location
+      validate :pierced_location_is_valid # Location object
+
+      def initialize(attrs = {})
+        self.score = attrs['SCOR'].to_i if attrs.include?('SCOR')
+        self.reason_text = attrs['REASON_CODE']
+        self.merchant_id = attrs['MERC']
+        self.mode = attrs['MODE']
+        self.order_number = attrs['ORDER']
+        self.session_id = attrs['SESS']
+        self.site_id = attrs['SITE']
+        self.api_version = attrs['VERS']
+        self.kount_id = attrs['TRAN']
+        self.error_code = attrs['ERRO']
+
+        self.decision = attrs['AUTO']
+        self.card_type = attrs['BRND']
+        self.reason_code = attrs['REAS']
+        self.status = attrs['STAT']
+
+        device_attributes = {
+          browser: attrs['BROWSER'],
+          cookies_enabled: ((attrs['COOKIES'].downcase == 'y' ? true : false) if attrs.include?('COOKIES')),
+          first_seen_at: ((Date.strptime(attrs['DDFS'], '%Y-%m-%d') rescue nil) if attrs.include?('DDFS')),
+          layers: attrs['DEVICE_LAYERS'],
+          screen_resolution: attrs['DSR'],
+          fingerprint: attrs['FINGERPRINT'],
+          flash_enabled: ((attrs['FLASH'].downcase == 'y' ? true : false) if attrs.include?('FLASH')),
+          configured_country_code: attrs['HTTP_COUNTRY'],
+          javascript_enabled: ((attrs['JAVASCRIPT'].downcase == 'y' ? true : false) if attrs.include?('JAVASCRIPT')),
+          captured: ((attrs['KAPT'].downcase == 'y' ? true : false) if attrs.include?('KAPT')),
+          language_country_code: attrs['LANGUAGE'],
+          localtime: ((Date.strptime(attrs['LOCALTIME'], '%Y-%m-%d %H:%M:%S') rescue nil) if attrs.include?('LOCALTIME')),
+          using_forwarder: ((attrs['MOBILE_FORWARDER'].downcase == 'y' ? true : false) if attrs.include?('MOBILE_FORWARDER')),
+          mobile_type: attrs['MOBILE_TYPE'],
+          network_type: attrs['NETW'],
+          operating_system: attrs['OS'],
+          remote_access: ((attrs['PC_REMOTE'].downcase == 'y' ? true : false) if attrs.include?('PC_REMOTE')),
+          configured_region: attrs['REGN'],
+          timezone: attrs['TIMEZONE'],
+          user_agent: attrs['UAS'],
+          voice_enabled: ((attrs['VOICE_DEVICE'].downcase == 'y' ? true : false) if attrs.include?('VOICE_DEVICE')),
+          region: attrs['REGION'],
+          country_code: attrs['COUNTRY'],
+        }.compact
+        self.device = Device.new(device_attributes)
+
+        persona_attributes = {
+          card_count: attrs['CARDS'],
+          device_count: attrs['DEVICES'],
+          email_count: attrs['EMAILS'],
+          country_code: attrs['GEOX'],
+          order_count: attrs['VELO'],
+          active_order_count: attrs['VMAX'],
+        }.compact
+        self.persona = Persona.new(persona_attributes) if persona_attributes.any?
+
+        proxy_location_attributes = {
+          ip_address: attrs['IP_IPAD'],
+          country_code: attrs['IP_COUNTRY'],
+          latitude: attrs['IP_LAT'],
+          longitude: attrs['IP_LON'],
+          city: attrs['IP_CITY'],
+          region: attrs['IP_REGION'],
+          owner: attrs['IP_ORG'],
+        }.compact
+        self.proxy_location = Location.new(proxy_location_attributes) if proxy_location_attributes.any?
+
+        pierced_location_attributes = {
+          ip_address: attrs['PIP_IPAD'],
+          country_code: attrs['PIP_COUNTRY'],
+          latitude: attrs['PIP_LAT'],
+          longitude: attrs['PIP_LON'],
+          city: attrs['PIP_CITY'],
+          region: attrs['PIP_REGION'],
+          owner: attrs['PIP_ORG'],
+        }.compact
+        self.pierced_location = Location.new(pierced_location_attributes) if pierced_location_attributes.any?
+
+        self.counters = attrs['COUNTERS_TRIGGERED'].to_i.times.collect.with_index(1) do |_,i|
+          Trigger::Counter.new(
+            name: attrs["COUNTER_NAME_#{i}"],
+            count: attrs["COUNTER_VALUE_#{i}"].to_i,
+          )
+        end
+
+        self.errors = attrs['ERROR_COUNT'].to_i.times.collect.with_index(1) do |_,i|
+          Trigger::Error.new(
+            message: attrs["ERROR_#{i}"],
+          )
+        end
+
+        self.rules = attrs['RULES_TRIGGERED'].to_i.times.collect.with_index(1) do |_,i|
+          Trigger::Rule.new(
+            description: attrs["RULE_DESCRIPTION_#{i}"],
+            id: attrs["RULE_ID_#{i}"].to_i,
+          )
+        end
+
+        self.warnings = attrs['WARNING_COUNT'].to_i.times.collect.with_index(1) do |_,i|
+          Trigger::Warning.new(
+            message: attrs["WARNING_#{i}"],
+          )
+        end
+      end
+
+      def to_h
+        {
+          score: score,
+          reason_text: reason_text,
+          merchant_id: merchant_id,
+          mode: mode,
+          order_number: order_number,
+          session_id: session_id,
+          site_id: site_id
+          api_version: api_version,
+          kount_id: kount_id,
+          counters: counters.collect(&:to_h),
+          rules: rules.collect(&:to_h),
+          warnings: warnings.collect(&:to_h),
+          errors: errors.collect(&:to_h),
+          persona: persona.to_h,
+          device: device.to_h,
+          proxy_location: proxy_location.to_h,
+          pierced_location: pierced_location.to_h,
+          error_code: error_code,
+        }
+      end
+
+      private
+      
+      def counters_are_valid
+        unless counters.is_a?(Array)
+          errors.add(:counters, 'must be an Array of Counter objects')
+          return false
+        end
+
+        counters.each.with_index(1) do |counter, i|
+          unless counter.valid?
+            counter.errors.full_messages.each do |error|
+              errors.add(:counters, "element #{i} #{error}")
+            end
+          end
+        end
+      end
+
+      def rules_are_valid
+        unless rules.is_a?(Array)
+          errors.add(:rules, 'must be an Array of Rule objects')
+          return false
+        end
+
+        rules.each.with_index(1) do |rule, i|
+          unless rule.valid?
+            rule.errors.full_messages.each do |error|
+              errors.add(:rules, "element #{i} #{error}")
+            end
+          end
+        end
+      end
+
+      def warnings_are_valid
+        unless warnings.is_a?(Array)
+          errors.add(:warnings, 'must be an Array of Warning objects')
+          return false
+        end
+
+        warnings.each.with_index(1) do |warning, i|
+          unless warning.valid?
+            warning.errors.full_messages.each do |error|
+              errors.add(:warnings, "element #{i} #{error}")
+            end
+          end
+        end
+      end
+
+      def errors_are_valid
+        unless errors.is_a?(Array)
+          errors.add(:errors, 'must be an Array of Error objects')
+          return false
+        end
+
+        errors.each.with_index(1) do |error, i|
+          unless error.valid?
+            error.errors.full_messages.each do |error|
+              errors.add(:errors, "element #{i} #{error}")
+            end
+          end
+        end
+      end
+
+      def persona_is_valid
+        unless persona.is_a?(Persona)
+          errors.add(:persona, 'must be an Persona object')
+          return false
+        end
+
+        unless persona.valid?
+          persona.errors.full_messages.each do |error|
+            errors.add(:persona, error)
+          end
+        end
+      end
+
+      def device_is_valid
+        unless device.is_a?(Device)
+          errors.add(:device, 'must be an Device object')
+          return false
+        end
+
+        unless device.valid?
+          device.errors.full_messages.each do |error|
+            errors.add(:device, error)
+          end
+        end
+      end
+
+      def proxy_location_is_valid
+        unless proxy_location.is_a?(Location)
+          errors.add(:proxy_location, 'must be an Location object')
+          return false
+        end
+
+        unless proxy_location.valid?
+          proxy_location.errors.full_messages.each do |error|
+            errors.add(:proxy_location, error)
+          end
+        end
+      end
+
+      def pierced_location_is_valid
+        unless pierced_location.is_a?(Location)
+          errors.add(:pierced_location, 'must be an Location object')
+          return false
+        end
+
+        unless pierced_location.valid?
+          pierced_location.errors.full_messages.each do |error|
+            errors.add(:pierced_location, error)
+          end
+        end
+      end
+
+    end
+  end
+end
+