yoti 1.6.3 → 1.9.0

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

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Requests creation of a Check to be performed on a document
+        #
+        class RequestedCheck
+          #
+          # @param [String] type The type of the Check to create
+          # @param [#as_json] config The configuration to apply to the Check
+          #
+          def initialize(type, config)
+            raise(TypeError, "#{self.class} cannot be instantiated") if self.class == RequestedCheck
+
+            Validation.assert_is_a(String, type, 'type')
+            @type = type
+
+            Validation.assert_respond_to(:as_json, config, 'config')
+            @config = config
+          end
+
+          def to_json(*_args)
+            as_json.to_json
+          end
+
+          def as_json(*_args)
+            {
+              type: @type,
+              config: @config.as_json
+            }
+          end
+        end
+      end
+    end
+  end
+end