yoti 1.6.0 → 1.7.0

data/lib/yoti/doc_scan/constants.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    class Constants
+      ID_DOCUMENT_AUTHENTICITY = 'ID_DOCUMENT_AUTHENTICITY'
+      ID_DOCUMENT_TEXT_DATA_CHECK = 'ID_DOCUMENT_TEXT_DATA_CHECK'
+      ID_DOCUMENT_FACE_MATCH = 'ID_DOCUMENT_FACE_MATCH'
+      LIVENESS = 'LIVENESS'
+      ID_DOCUMENT_TEXT_DATA_EXTRACTION = 'ID_DOCUMENT_TEXT_DATA_EXTRACTION'
+      ID_DOCUMENT = 'ID_DOCUMENT'
+      ORTHOGONAL_RESTRICTIONS = 'ORTHOGONAL_RESTRICTIONS'
+      DOCUMENT_RESTRICTIONS = 'DOCUMENT_RESTRICTIONS'
+      INCLUDE = 'WHITELIST'
+      EXCLUDE = 'BLACKLIST'
+      ALWAYS = 'ALWAYS'
+      FALLBACK = 'FALLBACK'
+      NEVER = 'NEVER'
+      ZOOM = 'ZOOM'
+      CAMERA = 'CAMERA'
+      CAMERA_AND_UPLOAD = 'CAMERA_AND_UPLOAD'
+      RESOURCE_UPDATE = 'RESOURCE_UPDATE'
+      TASK_COMPLETION = 'TASK_COMPLETION'
+      CHECK_COMPLETION = 'CHECK_COMPLETION'
+      SESSION_COMPLETION = 'SESSION_COMPLETION'
+    end
+  end
+end

data/lib/yoti/doc_scan/session/create/create_session_result.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # The response to a successful CreateSession call
+        #
+        class CreateSessionResult
+          #
+          # Returns the time-to-live (TTL) for the client session
+          # token for the created session
+          #
+          # @return [Integer]
+          #
+          attr_reader :client_session_token_ttl
+
+          #
+          # Returns the client session token for the created session
+          #
+          # @return [String]
+          #
+          attr_reader :client_session_token
+
+          #
+          # Session ID of the created session
+          #
+          # @return [String]
+          #
+          attr_reader :session_id
+
+          #
+          # @param [Hash] response
+          #
+          def initialize(response)
+            Validation.assert_is_a(Integer, response['client_session_token_ttl'], 'client_session_token_ttl', true)
+            @client_session_token_ttl = response['client_session_token_ttl']
+
+            Validation.assert_is_a(String, response['client_session_token'], 'client_session_token', true)
+            @client_session_token = response['client_session_token']
+
+            Validation.assert_is_a(String, response['session_id'], 'session_id', true)
+            @session_id = response['session_id']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/create/document_filter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        class DocumentFilter
+          #
+          # @param [String] type
+          #
+          def initialize(type)
+            raise(TypeError, "#{self.class} cannot be instantiated") if self.class == DocumentFilter
+
+            Validation.assert_is_a(String, type, 'type')
+            @type = type
+          end
+
+          def to_json(*_args)
+            as_json.to_json
+          end
+
+          def as_json(*_args)
+            {
+              type: @type
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/create/document_restrictions_filter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        class DocumentRestrictionsFilter < DocumentFilter
+          #
+          # @param [String] inclusion
+          # @param [Array<DocumentRestriction>] documents
+          #
+          def initialize(inclusion, documents)
+            super(Constants::DOCUMENT_RESTRICTIONS)
+
+            Validation.assert_is_a(String, inclusion, 'country_restriction')
+            @inclusion = inclusion
+
+            Validation.assert_is_a(Array, documents, 'documents')
+            @documents = documents
+          end
+
+          def as_json(*_args)
+            super.merge(
+              inclusion: @inclusion,
+              documents: @documents.map(&:as_json)
+            ).compact
+          end
+
+          #
+          # @return [DocumentRestrictionsFilterBuilder]
+          #
+          def self.builder
+            DocumentRestrictionsFilterBuilder.new
+          end
+        end
+
+        class DocumentRestrictionsFilterBuilder
+          def initialize
+            @documents = []
+          end
+
+          #
+          # @return [self]
+          #
+          def for_inclusion
+            @inclusion = Constants::INCLUDE
+            self
+          end
+
+          #
+          # @return [self]
+          #
+          def for_exclusion
+            @inclusion = Constants::EXCLUDE
+            self
+          end
+
+          #
+          # @param [DocumentRestriction] document_restriction
+          #
+          # @return [self]
+          #
+          def with_document_restriction(document_restriction)
+            Validation.assert_is_a(DocumentRestriction, document_restriction, 'document_restriction')
+            @documents.push(document_restriction)
+            self
+          end
+
+          #
+          # @return [DocumentRestrictionsFilter]
+          #
+          def build
+            DocumentRestrictionsFilter.new(@inclusion, @documents)
+          end
+        end
+
+        class DocumentRestriction
+          #
+          # @param [Array<String>] country_codes
+          # @param [Array<String>] document_types
+          #
+          def initialize(country_codes, document_types)
+            Validation.assert_is_a(Array, country_codes, 'country_codes', true)
+            @country_codes = country_codes
+
+            Validation.assert_is_a(Array, document_types, 'document_types', true)
+            @document_types = document_types
+          end
+
+          def to_json(*_args)
+            as_json.to_json
+          end
+
+          def as_json(*_args)
+            json = {}
+            json[:document_types] = @document_types unless @document_types.nil?
+            json[:country_codes] = @country_codes unless @country_codes.nil?
+            json
+          end
+
+          #
+          # @return [DocumentRestrictionBuilder]
+          #
+          def self.builder
+            DocumentRestrictionBuilder.new
+          end
+        end
+
+        class DocumentRestrictionBuilder
+          #
+          # @param [Array<String>] document_types
+          #
+          # @return [self]
+          #
+          def with_document_types(document_types)
+            @document_types = document_types
+            self
+          end
+
+          #
+          # @param [Array<String>] country_codes
+          #
+          # @return [self]
+          #
+          def with_countries(country_codes)
+            @country_codes = country_codes
+            self
+          end
+
+          #
+          # @return [DocumentRestriction]
+          #
+          def build
+            DocumentRestriction.new(@country_codes, @document_types)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/create/notification_config.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Configures call-back Notifications to some backend endpoint provided
+        # by the Relying Business.
+        #
+        # Notifications can be configured to notified a client backend of certain
+        # events, avoiding the need to poll for the state of the Session.
+        #
+        class NotificationConfig
+          #
+          # @param [String] auth_token
+          #   The authorization token to be included in call-back messages
+          # @param [String] endpoint
+          #   The endpoint that notifications should be sent to
+          # @param [Array<String>] topics
+          #   The list of topics that should trigger notifications
+          #
+          def initialize(auth_token, endpoint, topics)
+            Validation.assert_is_a(String, auth_token, 'auth_token', true)
+            @auth_token = auth_token
+
+            Validation.assert_is_a(String, endpoint, 'endpoint', true)
+            @endpoint = endpoint
+
+            Validation.assert_is_a(Array, topics, 'auth_token', true)
+            @topics = topics.uniq unless topics.nil?
+          end
+
+          def to_json(*_args)
+            as_json.to_json
+          end
+
+          def as_json(*_args)
+            {
+              auth_token: @auth_token,
+              endpoint: @endpoint,
+              topics: @topics
+            }.compact
+          end
+
+          #
+          # @return [NotificationConfigBuilder]
+          #
+          def self.builder
+            NotificationConfigBuilder.new
+          end
+        end
+
+        class NotificationConfigBuilder
+          def initialize
+            @topics = []
+          end
+
+          #
+          # Sets the authorization token to be included in call-back messages
+          #
+          # @param [String] auth_token
+          #
+          # @return [self]
+          #
+          def with_auth_token(auth_token)
+            @auth_token = auth_token
+            self
+          end
+
+          #
+          # Sets the endpoint that notifications should be sent to
+          #
+          # @param [String] endpoint
+          #
+          # @return [self]
+          #
+          def with_endpoint(endpoint)
+            @endpoint = endpoint
+            self
+          end
+
+          #
+          # Adds a topic to the list of topics that trigger notification messages
+          #
+          # @param [String] topic
+          #
+          # @return [self]
+          #
+          def with_topic(topic)
+            Validation.assert_is_a(String, topic, 'topic')
+            @topics.push(topic)
+            self
+          end
+
+          #
+          # Adds RESOURCE_UPDATE to the list of topics that trigger notification messages
+          #
+          # @return [self]
+          #
+          def for_resource_update
+            with_topic(Constants::RESOURCE_UPDATE)
+          end
+
+          #
+          # Adds TASK_COMPLETION to the list of topics that trigger notification messages
+          #
+          # @return [self]
+          #
+          def for_task_completion
+            with_topic(Constants::TASK_COMPLETION)
+          end
+
+          #
+          # Adds CHECK_COMPLETION to the list of topics that trigger notification messages
+          #
+          # @return [self]
+          #
+          def for_check_completion
+            with_topic(Constants::CHECK_COMPLETION)
+          end
+
+          #
+          # Adds SESSION_COMPLETION to the list of topics that trigger notification messages
+          #
+          # @return [self]
+          #
+          def for_session_completion
+            with_topic(Constants::SESSION_COMPLETION)
+          end
+
+          #
+          # @return [NotificationConfig]
+          #
+          def build
+            NotificationConfig.new(@auth_token, @endpoint, @topics)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/create/orthogonal_restrictions_filter.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        class OrthogonalRestrictionsFilter < DocumentFilter
+          #
+          # @param [CountryRestriction] country_restriction
+          # @param [TypeRestriction] type_restriction
+          #
+          def initialize(country_restriction, type_restriction)
+            super(Constants::ORTHOGONAL_RESTRICTIONS)
+
+            Validation.assert_is_a(CountryRestriction, country_restriction, 'country_restriction', true)
+            @country_restriction = country_restriction
+
+            Validation.assert_is_a(TypeRestriction, type_restriction, 'type_restriction', true)
+            @type_restriction = type_restriction
+          end
+
+          def as_json(*_args)
+            json = super
+            json[:country_restriction] = @country_restriction.as_json unless @country_restriction.nil?
+            json[:type_restriction] = @type_restriction.as_json unless @type_restriction.nil?
+            json
+          end
+
+          #
+          # @return [OrthogonalRestrictionsFilterBuilder]
+          #
+          def self.builder
+            OrthogonalRestrictionsFilterBuilder.new
+          end
+        end
+
+        class OrthogonalRestrictionsFilterBuilder
+          #
+          # @param [Array<String>] country_codes
+          #
+          # @return [self]
+          #
+          def with_included_countries(country_codes)
+            @country_restriction = CountryRestriction.new(
+              Constants::INCLUDE,
+              country_codes
+            )
+            self
+          end
+
+          #
+          # @param [Array<String>] country_codes
+          #
+          # @return [self]
+          #
+          def with_excluded_countries(country_codes)
+            @country_restriction = CountryRestriction.new(
+              Constants::EXCLUDE,
+              country_codes
+            )
+            self
+          end
+
+          #
+          # @param [Array<String>] document_types
+          #
+          # @return [self]
+          #
+          def with_included_document_types(document_types)
+            @type_restriction = TypeRestriction.new(
+              Constants::INCLUDE,
+              document_types
+            )
+            self
+          end
+
+          #
+          # @param [Array<String>] document_types
+          #
+          # @return [self]
+          #
+          def with_excluded_document_types(document_types)
+            @type_restriction = TypeRestriction.new(
+              Constants::EXCLUDE,
+              document_types
+            )
+            self
+          end
+
+          #
+          # @return [OrthogonalRestrictionsFilter]
+          #
+          def build
+            OrthogonalRestrictionsFilter.new(@country_restriction, @type_restriction)
+          end
+        end
+
+        class CountryRestriction
+          #
+          # @param [String] inclusion
+          # @param [Array<String>] country_codes
+          #
+          def initialize(inclusion, country_codes)
+            Validation.assert_is_a(String, inclusion, 'inclusion')
+            @inclusion = inclusion
+
+            Validation.assert_is_a(Array, country_codes, 'country_codes')
+            @country_codes = country_codes
+          end
+
+          def to_json(*_args)
+            as_json.to_json
+          end
+
+          def as_json(*_args)
+            {
+              inclusion: @inclusion,
+              country_codes: @country_codes
+            }
+          end
+        end
+
+        class TypeRestriction
+          #
+          # @param [String] inclusion
+          # @param [Array<String>] document_types
+          #
+          def initialize(inclusion, document_types)
+            Validation.assert_is_a(String, inclusion, 'inclusion')
+            @inclusion = inclusion
+
+            Validation.assert_is_a(Array, document_types, 'document_types')
+            @document_types = document_types
+          end
+
+          def to_json(*_args)
+            as_json.to_json
+          end
+
+          def as_json(*_args)
+            {
+              inclusion: @inclusion,
+              document_types: @document_types
+            }
+          end
+        end
+      end
+    end
+  end
+end