minfraud 1.1.0

data/lib/minfraud/errors.rb

@@ -0,0 +1,10 @@
+module Minfraud
+  # A list of Minfraud custom errors
+  class BaseError          < StandardError; end
+
+  class NotEnumValueError  < BaseError; end
+  class RequestFormatError < BaseError; end
+  class ClientError        < BaseError; end
+  class AuthorizationError < BaseError; end
+  class ServerError        < BaseError; end
+end

data/lib/minfraud/http_service.rb

@@ -0,0 +1,30 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Minfraud
+  module HTTPService
+    class << self
+      # @return [Hash] default HTTPService configuration
+      def configuration
+        {
+          middleware: DEFAULT_MIDDLEWARE,
+          server:     DEFAULT_SERVER
+        }
+      end
+    end
+
+    # Minfraud default middleware stack
+    DEFAULT_MIDDLEWARE = Proc.new do |builder|
+      builder.request    :json
+
+      builder.basic_auth *::Minfraud.configuration.values
+
+      builder.response   :json, content_type: /\bjson$/
+
+      builder.adapter    Faraday.default_adapter
+    end
+
+    # Minfraud default server
+    DEFAULT_SERVER = 'https://minfraud.maxmind.com/minfraud/v2.0'.freeze
+  end
+end

data/lib/minfraud/http_service/request.rb

@@ -0,0 +1,37 @@
+require 'faraday'
+
+module Minfraud
+  module HTTPService
+    class Request
+      # @attribute middleware
+      # @return [Proc] A proc containing Faraday configuration
+      attr_reader :middleware
+
+      # @attribute server
+      # @return [String] an API endpoint
+      attr_reader :server
+
+      # Creates Minfraud::HTTPService::Request instance
+      # @param  [Hash] params hash of parameters
+      # @return [Minfraud::HTTPService::Request] Request instance
+      def initialize(params = {})
+        @middleware = params[:middleware]
+        @server     = params[:server]
+      end
+
+      # Performs an HTTP request to the specified endpoint with given body
+      # @param  [Hash] params hash of parameters.
+      # @return [Farday::Response] Faraday::Response instance
+      def perform(params)
+        adapter.send(*params.values_at(:verb, :endpoint, :body))
+      end
+
+      private
+      # Creates memoized Faraday::Connection instance
+      # @return [Faraday::Connection] Faraday::Connection instance
+      def adapter
+        @adapter ||= Faraday.new(server, {}, &middleware)
+      end
+    end
+  end
+end

data/lib/minfraud/http_service/response.rb

@@ -0,0 +1,64 @@
+require 'minfraud/model/error'
+require 'minfraud/model/factors'
+require 'minfraud/model/insights'
+require 'minfraud/model/score'
+
+module Minfraud
+  module HTTPService
+    # Response class for HTTP requests
+    class Response
+      # @attribute status
+      # @return [Integer] HTTP response status
+      attr_reader :status
+
+      # @attribute body
+      # @return [Minfraud::Model::Score, Minfraud::Model::Insights,
+      #   Minfraud::Model::Factors] HTTP response body
+      attr_reader :body
+
+      # @attribute headers
+      # @return [Hash] HTTP response headers
+      attr_reader :headers
+
+      # Creates Minfraud::HTTPService::Response instance
+      # @param  [Hash] params hash of parameters
+      # @return [Minfraud::HTTPService::Response] Response instance
+      def initialize(params = {})
+        @status  = params[:status]
+        @body    = make_body(
+          params[:endpoint],
+          params[:body],
+          params[:locales]
+        )
+        @headers = params[:headers]
+      end
+
+      # Returns minFraud-specific response code
+      # @return [Symbol, nil] minFraud specific request code
+      def code
+        return nil if body.nil?
+
+        body.code.intern if body.respond_to?(:code) && body.code
+      end
+
+      private
+
+      def make_body(endpoint, body, locales)
+        if @status != 200
+          # Won't be a Hash when the body is not JSON.
+          return nil unless body.is_a?(Hash)
+
+          return Minfraud::Model::Error.new(body)
+        end
+
+        ENDPOINT_TO_CLASS[endpoint].new(body, locales)
+      end
+
+      ENDPOINT_TO_CLASS = {
+        factors: Minfraud::Model::Factors,
+        insights: Minfraud::Model::Insights,
+        score: Minfraud::Model::Score
+      }.freeze
+    end
+  end
+end

data/lib/minfraud/model/abstract.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Minfraud
+  module Model
+    # @!visibility private
+    class Abstract
+      def initialize(record)
+        @record = record
+      end
+
+      protected
+
+      def get(key)
+        return nil if @record.nil? || !@record.key?(key)
+
+        @record[key]
+      end
+    end
+  end
+end

data/lib/minfraud/model/address.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'minfraud/model/abstract'
+
+module Minfraud
+  module Model
+    # Abstract model for a postal address.
+    class Address < Abstract
+      # The distance in kilometers from the address to the IP location.
+      #
+      # @return [Integer, nil]
+      attr_reader :distance_to_ip_location
+
+      # This property is true if the address is in the IP country. The property
+      # is false when the address is not in the IP country. If the address
+      # could not be parsed or was not provided or if the IP address could not
+      # be geolocated, the property will be nil.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_in_ip_country
+
+      # This property is true if the postal code provided with the address is
+      # in the city for the address. The property is false when the postal code
+      # is not in the city. If the address was not provided or could not be
+      # parsed, the property will be nil.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_postal_in_city
+
+      # The latitude associated with the address.
+      #
+      # @return [Float, nil]
+      attr_reader :latitude
+
+      # The longitude associated with the address.
+      #
+      # @return [Float, nil]
+      attr_reader :longitude
+
+      # @!visibility private
+      def initialize(record)
+        super(record)
+
+        @distance_to_ip_location = get('distance_to_ip_location')
+        @is_in_ip_country = get('is_in_ip_country')
+        @is_postal_in_city = get('is_postal_in_city')
+        @latitude = get('latitude')
+        @longitude = get('longitude')
+      end
+    end
+  end
+end

data/lib/minfraud/model/billing_address.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'minfraud/model/address'
+
+module Minfraud
+  module Model
+    # Model containing information about the billing address.
+    class BillingAddress < Address
+    end
+  end
+end

data/lib/minfraud/model/credit_card.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'minfraud/model/abstract'
+require 'minfraud/model/issuer'
+
+module Minfraud
+  module Model
+    # Model with details about the credit card used.
+    class CreditCard < Abstract
+      # The card brand, such as "Visa", "Discover", "American Express", etc.
+      #
+      # @return [String, nil]
+      attr_reader :brand
+
+      # This property contains the two letter ISO 3166-1 alpha-2 country code
+      # (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) associated with the
+      # location of the majority of customers using this credit card as
+      # determined by their billing address. In cases where the location of
+      # customers is highly mixed, this defaults to the country of the bank
+      # issuing the card.
+      #
+      # @return [String, nil]
+      attr_reader :country
+
+      # This property is true if the card is a business card.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_business
+
+      # This property is true if the country of the billing address matches the
+      # country of the majority of customers using this credit card. In cases
+      # where the location of customers is highly mixed, the match is to the
+      # country of the bank issuing the card.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_issued_in_billing_address_country
+
+      # This property is true if the card is a prepaid card.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_prepaid
+
+      # This property is true if the card is a virtual card.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_virtual
+
+      # An object containing information about the credit card issuer.
+      #
+      # @return [Minfraud::Model::Issuer]
+      attr_reader :issuer
+
+      # The card's type. The valid values are: charge, credit, debit.
+      #
+      # @return [String, nil]
+      attr_reader :type
+
+      # @!visibility private
+      def initialize(record)
+        super(record)
+
+        @brand = get('brand')
+        @country = get('country')
+        @is_business = get('is_business')
+        @is_issued_in_billing_address_country = get(
+          'is_issued_in_billing_address_country'
+        )
+        @is_prepaid = get('is_prepaid')
+        @is_virtual = get('is_virtual')
+        @issuer = Minfraud::Model::Issuer.new(get('issuer'))
+        @type = get('type')
+      end
+    end
+  end
+end

data/lib/minfraud/model/device.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'minfraud/model/abstract'
+
+module Minfraud
+  module Model
+    # Model with information about the device.
+    #
+    # In order to receive device output from minFraud Insights or minFraud
+    # Factors, you must be using the Device Tracking Add-on
+    # (https://dev.maxmind.com/minfraud/device/).
+    class Device < Abstract
+      # This number represents our confidence that the device_id refers to a
+      # unique device as opposed to a cluster of similar devices. A confidence
+      # of 0.01 indicates very low confidence that the device is unique,
+      # whereas 99 indicates very high confidence.
+      #
+      # @return [Float, nil]
+      attr_reader :confidence
+
+      # A UUID that MaxMind uses for the device associated with this IP
+      # address. Note that many devices cannot be uniquely identified because
+      # they are too common (for example, all iPhones of a given model and OS
+      # release). In these cases, the minFraud service will simply not return a
+      # UUID for that device.
+      #
+      # @return [String, nil]
+      attr_reader :id
+
+      # This is the date and time of the last sighting of the device. This is
+      # an RFC 3339 date-time.
+      #
+      # @return [String, nil]
+      attr_reader :last_seen
+
+      # This is the local date and time of the transaction in the time zone of
+      # the device. This is determined by using the UTC offset associated with
+      # the device. This is an RFC 3339 date-time
+      #
+      # @return [String, nil]
+      attr_reader :local_time
+
+      # @!visibility private
+      def initialize(record)
+        super(record)
+
+        @confidence = get('confidence')
+        @id = get('id')
+        @last_seen = get('last_seen')
+        @local_time = get('local_time')
+      end
+    end
+  end
+end

data/lib/minfraud/model/disposition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'minfraud/model/abstract'
+
+module Minfraud
+  module Model
+    # Model with the disposition set by custom rules.
+    #
+    # In order to receive a disposition, you must be using minFraud custom
+    # rules.
+    class Disposition < Abstract
+      # The action to take on the transaction as defined by your custom rules.
+      # The current set of values are "accept", "manual_review", and "reject".
+      # If you do not have custom rules set up, this will be nil.
+      #
+      # @return [String, nil]
+      attr_reader :action
+
+      # The reason for the action. The current possible values are
+      # "custom_rule", "block_list", and "default". If you do not have custom
+      # rules set up, this will be nil.
+      #
+      # @return [String, nil]
+      attr_reader :reason
+
+      # @!visibility private
+      def initialize(record)
+        super(record)
+
+        @action = get('action')
+        @reason = get('reason')
+      end
+    end
+  end
+end

data/lib/minfraud/model/email.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'minfraud/model/abstract'
+require 'minfraud/model/email_domain'
+
+module Minfraud
+  module Model
+    # Model containing information about the email address.
+    class Email < Abstract
+      # An object containing information about the email domain.
+      #
+      # @return [Minfraud::Model::EmailDomain]
+      attr_reader :domain
+
+      # A date string (e.g. 2017-04-24) to identify the date an email address
+      # was first seen by MaxMind. This is expressed using the ISO 8601 date
+      # format.
+      #
+      # @return [String, nil]
+      attr_reader :first_seen
+
+      # Whether this email address is from a disposable email provider. The
+      # value will be nil when no email address or email domain has been passed
+      # as an input.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_disposable
+
+      # This property is true if MaxMind believes that this email is hosted by
+      # a free email provider such as Gmail or Yahoo! Mail.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_free
+
+      # This field is true if MaxMind believes that this email is likely to be
+      # used for fraud. Note that this is also factored into the overall
+      # risk_score in the response as well.
+      #
+      # @return [Boolean, nil]
+      attr_reader :is_high_risk
+
+      # @!visibility private
+      def initialize(record)
+        super(record)
+
+        @domain = Minfraud::Model::EmailDomain.new(get('domain'))
+        @first_seen = get('first_seen')
+        @is_disposable = get('is_disposable')
+        @is_free = get('is_free')
+        @is_high_risk = get('is_high_risk')
+      end
+    end
+  end
+end