jumio 1.0.0

data/lib/jumio/entities/types.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module Jumio
+  module Entities
+    # A base entity including all of the default dry-types
+    module Types
+      include Dry.Types(default: :nominal)
+    end
+  end
+end

data/lib/jumio/entities/verification.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'identity_verification'
+require_relative 'reject_reason'
+require_relative 'requestable_record'
+
+module Jumio
+  module Entities
+    # Document authenticity details
+    #
+    # https://github.com/Jumio/implementation-guides/blob/master/netverify/netverify-retrieval-api.md#retrieving-verification-data-only
+    class Verification < RequestableRecord
+      attribute :identityVerification, IdentityVerification.meta(omittable: true)
+      attribute :rejectReason,         RejectReason.meta(omittable: true)
+      attribute :mrzCheck,             Types::Strict::String.meta(omittable: true)
+    end
+  end
+end

data/lib/jumio/entities/verification_response.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'api_entity'
+
+module Jumio
+  module Entities
+    # Successful initiation of a new Netverify Scan
+    #
+    # https://github.com/Jumio/implementation-guides/blob/master/netverify/netverify-web-v4.md#response
+    class VerificationResponse < ApiEntity
+      attribute :timestamp,            Types::Strict::String # Timestamp (UTC) of the response. Format: YYYY-MM-DDThh:mm:ss.SSSZ
+      attribute :redirectUrl,          Types::Strict::String # URL used to load the Netverify client.
+      attribute :transactionReference, Types::Strict::String # Jumio reference number for the transaction.
+    end
+  end
+end

data/lib/jumio/entities.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'jumio/entities/address'
+require 'jumio/entities/api_entity'
+require 'jumio/entities/document'
+require 'jumio/entities/identity_verification'
+require 'jumio/entities/reject_reason_details'
+require 'jumio/entities/reject_reason'
+require 'jumio/entities/requestable_record'
+require 'jumio/entities/scan_status'
+require 'jumio/entities/scan'
+require 'jumio/entities/transaction'
+require 'jumio/entities/types'
+require 'jumio/entities/verification_response'
+require 'jumio/entities/verification'

data/lib/jumio/factories.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'jumio/entities'
+require 'active_support/core_ext/hash/deep_merge'
+
+module Jumio
+  module Factories
+    def self.scan_status_failed(options = {})
+      Entities::ScanStatus.new({
+        timestamp: '2018-10-29T15:56:54.398Z',
+        scanReference: 'WEB_UPLOAD',
+        status: 'FAILED'
+      }.deep_merge(options))
+    end
+
+    def self.scan_status_pending(options = {})
+      Entities::ScanStatus.new({
+        timestamp: '2018-10-29T15:56:54.398Z',
+        scanReference: 'WEB_UPLOAD',
+        status: 'PENDING'
+      }.deep_merge(options))
+    end
+
+    def self.scan_denied_fraud(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'DENIED_FRAUD'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+        verification: {
+          rejectReason: {
+            rejectReasonCode: '106',
+            rejectReasonDescription: 'FAKE'
+          }
+        }
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_identity_match(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'APPROVED_VERIFIED',
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z',
+        },
+        verification: {
+          identityVerification: {
+            similarity: 'MATCH',
+            validity: 'true'
+          }
+        }
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_identity_match_and_us_id(options = {})
+      Entities::Scan.new({
+        document: {
+          address: {
+            city: "SAN FRANCISCO",
+            country: "USA",
+            stateCode: "US-CA",
+            streetName: "20TH",
+            streetNumber: "560",
+            streetSuffix: "ST",
+            zip: "94107"
+          },
+          dob: '1980-01-02',
+          expiry: "2022-01-02",
+          firstName: 'John',
+          issuingCountry: "USA",
+          lastName: 'Doe',
+          number: 'A1234567',
+          status: 'APPROVED_VERIFIED',
+          usState: 'CA'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z',
+        },
+        verification: {
+          identityVerification: {
+            similarity: 'MATCH',
+            validity: 'true'
+          }
+        }
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_match_not_possible(options = {})
+      params = {
+        verification: {
+          identityVerification: {
+            similarity: 'NOT_POSSIBLE',
+            validity: 'true'
+          }
+        }
+      }.deep_merge(options)
+      scan_with_identity_match(params)
+    end
+
+    def self.scan_with_wrong_person(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'APPROVED_VERIFIED'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+        verification: {
+          identityVerification: {
+            similarity: 'NO_MATCH',
+            validity: 'true'
+          }
+        }
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_unacceptable_selfie(reason, options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'APPROVED_VERIFIED'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+        verification: {
+          identityVerification: {
+            reason: reason,
+            similarity: 'NOT_POSSIBLE',
+            validity: 'false'
+          }
+        }
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_unsupported_id_type(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'DENIED_UNSUPPORTED_ID_TYPE'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_unsupported_id_country(options = {})
+      params = {
+        document: { status: 'DENIED_UNSUPPORTED_ID_COUNTRY' }
+      }.deep_merge(options)
+      scan_with_unsupported_id_type(params)
+    end
+
+    def self.scan_with_error_not_readable_id(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'ERROR_NOT_READABLE_ID'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+        verification: {
+          rejectReason: {
+            rejectReasonCode: '200',
+            rejectReasonDescription: 'NOT_READABLE_DOCUMENT'
+          }
+        }
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_no_id_uploaded(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'NO_ID_UPLOADED'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'FAILED',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+      }.deep_merge(options))
+    end
+
+    def self.scan_with_no_identity_verification(options = {})
+      Entities::Scan.new({
+        document: {
+          status: 'APPROVED_VERIFIED'
+        },
+        transaction: {
+          date: '2018-10-29T15:56:54.398Z',
+          source: 'WEB_UPLOAD',
+          status: 'DONE',
+          updatedAt: '2018-10-29T15:56:54.398Z'
+        },
+        verification: {
+          mrzCheck: 'NOT_AVAILABLE'
+        }
+      }.deep_merge(options))
+    end
+
+    def self.verfication_response(options = {})
+      Entities::VerificationResponse.new({
+        timestamp: '2018-10-29T15:56:54.398Z',
+        transactionReference: 'a527ae56-ea7a-4476-a2de-1a678bd6189d',
+        redirectUrl: 'https://netverify.com/web/v4/app?authorizationToken=TOKEN&locale=en-US'
+      }.deep_merge(options))
+    end
+  end
+end

data/lib/jumio/http_client.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Jumio
+  class RecordNotFound < StandardError; end
+
+  # Makes HTTPS requests to Jumio JSON apis
+  class HttpClient
+    # @param token [String, nil]
+    # @param secret [String, nil]
+    # @param base_url [String, nil]
+    def initialize(token: nil, secret: nil, base_url: nil)
+      @api_token = (token || Jumio.api.token)
+      @api_secret = (secret || Jumio.api.secret)
+      @api_base_url = (base_url || Jumio.api.base_url)
+    end
+
+    # @param url [String]
+    # @raise [RecordNotFound] On 404 response
+    # @raise [Net::HTTPError] On JSON response parsing error
+    # @return [Hash] The response
+    def get(url)
+      uri = URI.join(@api_base_url, url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        req = Net::HTTP::Get.new(uri)
+        req.basic_auth(@api_token, @api_secret)
+        req['Accept'] = 'application/json'
+        req['Content-Type'] = 'application/json'
+        req['User-Agent'] = user_agent
+        http.request(req)
+      end
+      handle_response(response)
+    end
+
+    # @param url [String]
+    # @param body [String]
+    # @raise [RecordNotFound] On 404 response
+    # @raise [Net::HTTPError] On JSON response parsing error
+    # @return [Hash] The response
+    def post(url, body)
+      uri = URI.join(@api_base_url, url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        req = Net::HTTP::Post.new(uri)
+        req.basic_auth(@api_token, @api_secret)
+        req['Accept'] = 'application/json'
+        req['Content-Type'] = 'application/json'
+        req['User-Agent'] = user_agent
+        req.body = body.to_json
+        http.request(req)
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def handle_response(response)
+      JSON.parse(response.body).tap do |body|
+        response.error! if body['error']
+        raise RecordNotFound, body['message'] if body['httpStatus'] == '404'
+      end
+    rescue JSON::ParserError => error
+      raise Net::HTTPError.new("JSON::ParserError: #{error.message}", response)
+    end
+
+    def user_agent
+      "#{Jumio.merchant.company_name} #{Jumio.merchant.app_name}/v#{Jumio.merchant.version}"
+    end
+  end
+end

data/lib/jumio/operations/get_scan_details.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'jumio/container'
+
+module Jumio
+  module Operations
+    # Fetch all available information for a Netverify transaction
+    class GetScanDetails
+      include JDC_CONTAINER[scan_repository: 'repositories.scan']
+
+      # @param scan_reference [String] Jumio’s reference number of an existing scan from your account
+      # @param client [Jumio::HttpClient, nil] The HTTP client to use
+      # @return [Entities::Scan]
+      def call(scan_reference, client = nil)
+        raise ArgumentError, 'Scan reference required' unless scan_reference.present?
+        scan_repository.get_details(scan_reference, client)
+      end
+    end
+  end
+end

data/lib/jumio/operations/get_scan_status.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'jumio/container'
+
+module Jumio
+  module Operations
+    # Fetch only the upload status of a Netverify transaction
+    class GetScanStatus
+      include JDC_CONTAINER[scan_repository: 'repositories.scan']
+
+      # @param scan_reference [String] Jumio’s reference number of an existing scan from your account
+      # @return [Entities::ScanStatus]
+      def call(scan_reference, client = nil)
+        raise ArgumentError, 'Scan reference required' unless scan_reference.present?
+        scan_repository.get_status(scan_reference, client)
+      end
+    end
+  end
+end

data/lib/jumio/operations/initiate_verification.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+require 'jumio/container'
+require 'jumio/schemas'
+
+module Jumio
+  module Operations
+    # Request a new Netverify session
+    class InitiateVerification
+      include Dry::Monads::Result::Mixin
+      include JDC_CONTAINER[verification_repository: 'repositories.verification']
+
+      # @param verification_params [Hash] Request payload for initiating a new Netverify scan.
+      # @param client [Jumio::HttpClient, nil] The HTTP client to use
+      # @return [Failure, Entities::VerificationResponse]
+      def call(verification_params, client = nil)
+        validation = Schemas::VerificationRequest.call(verification_params)
+        return Failure.new(validation.message_set.to_h) unless validation.success?
+        verification_repository.initiate(verification_params, client)
+      end
+    end
+  end
+end

data/lib/jumio/operations.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'jumio/operations/get_scan_details'
+require 'jumio/operations/get_scan_status'
+require 'jumio/operations/initiate_verification'

data/lib/jumio/repositories/scan.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'jumio/entities'
+
+module Jumio
+  module Repositories
+    # A wrapper for the Netverify scan retreival API
+    #
+    # https://github.com/Jumio/implementation-guides/blob/master/netverify/netverify-retrieval-api.md
+    class Scan
+      include JDC_CONTAINER[default_client: 'http_client']
+
+      # @param scan_reference [String] Jumio’s reference number of an existing scan from your account
+      # @param client [Jumio::HttpClient, nil] The HTTP client to use
+      # @return [Entities::ScanStatus]
+      def get_status(scan_reference, client = nil)
+        raw_scan_status = (client || default_client.new).get("netverify/v2/scans/#{scan_reference}")
+        Entities::ScanStatus.new(raw_scan_status)
+      end
+
+      # @param scan_reference [String] Jumio’s reference number of an existing scan from your account
+      # @param client [Jumio::HttpClient, nil] The HTTP client to use
+      # @return [Entities::Scan]
+      def get_details(scan_reference, client = nil)
+        raw_scan = (client || default_client.new).get("netverify/v2/scans/#{scan_reference}/data")
+        Entities::Scan.new(raw_scan)
+      end
+    end
+  end
+end

data/lib/jumio/repositories/verification.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'jumio/entities'
+
+module Jumio
+  module Repositories
+    class Verification
+      # A wrapper for the Netverify web client api
+      #
+      # https://github.com/Jumio/implementation-guides/blob/master/netverify/netverify-web-v4.md
+      include JDC_CONTAINER[default_client: 'http_client']
+
+      # @param verification_params [Hash] Request payload for initiating a new Netverify scan.
+      # @param client [Jumio::HttpClient, nil] The HTTP client to use
+      # @return [Entities::VerificationResponse]
+      def initiate(verification_params, client = nil)
+        raw_verification = (client || default_client.new).post('v4/initiate', verification_params)
+        Entities::VerificationResponse.new(raw_verification)
+      end
+    end
+  end
+end

data/lib/jumio/repositories.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'jumio/repositories/scan'
+require 'jumio/repositories/verification'

data/lib/jumio/schemas/verification_request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+module Jumio
+  module Schemas
+    # Request payload for initiating a new Netverify scan.
+    # These options customize the upload flow on a per-request basis.
+    # Default values for many of these options can be set in the Customer Portal.
+    #
+    # https://github.com/Jumio/implementation-guides/blob/master/netverify/netverify-web-v4.md#request-body
+    VerificationRequest = Dry::Schema.define do
+      # Your internal reference for the transaction.
+      required(:customerInternalReference).filled(:str?)
+      # Your internal reference for the user.
+      required(:userReference).filled(:str?)
+
+      # Sends verification result to this URL upon completion.
+      optional(:callbackUrl).filled(:str?)
+      # Redirects to this URL after an unsuccessful transaction.
+      optional(:errorUrl).filled(:str?)
+      # Renders content in the specified language.
+      optional(:locale).filled(:str?)
+      # Preset the country and document type to bypass the selection screen.
+      optional(:presets).schema do
+        required(:index).value(eql?: 1)
+        # Possible values: ISO 3166-1 alpha-3 country code
+        required(:country).filled(:str?).value(size?: 3)
+        required(:type).value(included_in?: ['PASSPORT', 'DRIVING_LICENSE', 'ID_CARD'])
+      end
+      # Your reporting criteria for the transaction.
+      optional(:reportingCriteria).filled(:str?)
+      # Redirects to this URL after a successful transaction.
+      optional(:successUrl).filled(:str?)
+      # Applies this acquisition workflow to the transaction.
+      optional(:workflowId).filled(:int?)
+    end
+  end
+end

data/lib/jumio/schemas.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'jumio/schemas/verification_request'

data/lib/jumio/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jumio
+  VERSION = '1.0.0'
+end

data/lib/jumio.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'jumio/client'
+require 'jumio/http_client'
+require 'jumio/config'
+require 'jumio/container'
+require 'jumio/entities'
+require 'jumio/factories'
+require 'jumio/operations'
+require 'jumio/repositories'
+require 'jumio/version'
+
+module Jumio
+  # Configuration free methods
+  #
+  # These use the default http_client configured with Jumio.api
+  #
+  # To use a per instance configuration client, use
+  # Jumio::Client.new(:token, :secret)
+
+  def self.get_scan_details
+    Container.resolve('get_scan_details')
+  end
+
+  def self.get_scan_status
+    Container.resolve('get_scan_status')
+  end
+
+  def self.initiate_verification
+    Container.resolve('initiate_verification')
+  end
+end