yoti 1.6.3 → 1.9.0

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Requests creation of a Document Authenticity Check
+        #
+        class RequestedDocumentAuthenticityCheck < RequestedCheck
+          def initialize(config)
+            Validation.assert_is_a(
+              RequestedDocumentAuthenticityCheckConfig,
+              config,
+              'config'
+            )
+
+            super(Constants::ID_DOCUMENT_AUTHENTICITY, config)
+          end
+
+          #
+          # @return [RequestedDocumentAuthenticityCheckBuilder]
+          #
+          def self.builder
+            RequestedDocumentAuthenticityCheckBuilder.new
+          end
+        end
+
+        #
+        # The configuration applied when creating a {RequestedDocumentAuthenticityCheck}
+        #
+        class RequestedDocumentAuthenticityCheckConfig
+          #
+          # @param [String] manual_check
+          #
+          def initialize(manual_check)
+            Validation.assert_is_a(String, manual_check, 'manual_check', true)
+            @manual_check = manual_check
+          end
+
+          def as_json(*_args)
+            {
+              manual_check: @manual_check
+            }.compact
+          end
+        end
+
+        #
+        # Builder to assist the creation of {RequestedDocumentAuthenticityCheck}
+        #
+        class RequestedDocumentAuthenticityCheckBuilder
+          #
+          # Requires that a manual follow-up check is always performed
+          #
+          # @return [self]
+          #
+          def with_manual_check_always
+            @manual_check = Constants::ALWAYS
+            self
+          end
+
+          #
+          # Requires that a manual follow-up check is performed only on failed checks,
+          # and those with a low level of confidence
+          #
+          # @return [self]
+          #
+          def with_manual_check_fallback
+            @manual_check = Constants::FALLBACK
+            self
+          end
+
+          #
+          # Requires that only an automated check is performed.  No manual follow-up
+          # Check will ever be initiated
+          #
+          # @return [self]
+          #
+          def with_manual_check_never
+            @manual_check = Constants::NEVER
+            self
+          end
+
+          #
+          # @return [RequestedDocumentAuthenticityCheck]
+          #
+          def build
+            config = RequestedDocumentAuthenticityCheckConfig.new(@manual_check)
+            RequestedDocumentAuthenticityCheck.new(config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Requests creation of a Face Match Check
+        #
+        class RequestedFaceMatchCheck < RequestedCheck
+          #
+          # @param [RequestedFaceMatchCheckConfig] config
+          #
+          def initialize(config)
+            Validation.assert_is_a(
+              RequestedFaceMatchCheckConfig,
+              config,
+              'config'
+            )
+
+            super(Constants::ID_DOCUMENT_FACE_MATCH, config)
+          end
+
+          #
+          # @return [RequestedFaceMatchCheckBuilder]
+          #
+          def self.builder
+            RequestedFaceMatchCheckBuilder.new
+          end
+        end
+
+        #
+        # The configuration applied when creating a {RequestedFaceMatchCheck}
+        #
+        class RequestedFaceMatchCheckConfig
+          #
+          # @param [String] manual_check
+          #
+          def initialize(manual_check)
+            Validation.assert_is_a(String, manual_check, 'manual_check')
+            @manual_check = manual_check
+          end
+
+          def as_json(*_args)
+            {
+              manual_check: @manual_check
+            }
+          end
+        end
+
+        #
+        # Builder to assist the creation of {RequestedFaceMatchCheck}
+        #
+        class RequestedFaceMatchCheckBuilder
+          #
+          # Requires that a manual follow-up check is always performed
+          #
+          # @return [self]
+          #
+          def with_manual_check_always
+            @manual_check = Constants::ALWAYS
+            self
+          end
+
+          #
+          # Requires that a manual follow-up check is performed only on failed checks,
+          # and those with a low level of confidence
+          #
+          # @return [self]
+          #
+          def with_manual_check_fallback
+            @manual_check = Constants::FALLBACK
+            self
+          end
+
+          #
+          # Requires that only an automated check is performed.  No manual follow-up
+          # Check will ever be initiated
+          #
+          # @return [self]
+          #
+          def with_manual_check_never
+            @manual_check = Constants::NEVER
+            self
+          end
+
+          def build
+            config = RequestedFaceMatchCheckConfig.new(@manual_check)
+            RequestedFaceMatchCheck.new(config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Requests creation of an ID Document Comparison Check
+        #
+        class RequestedIdDocumentComparisonCheck < RequestedCheck
+          def initialize(config)
+            Validation.assert_is_a(
+              RequestedIdDocumentComparisonCheckConfig,
+              config,
+              'config'
+            )
+
+            super(Constants::ID_DOCUMENT_COMPARISON, config)
+          end
+
+          #
+          # @return [RequestedIdDocumentComparisonCheckBuilder]
+          #
+          def self.builder
+            RequestedIdDocumentComparisonCheckBuilder.new
+          end
+        end
+
+        #
+        # The configuration applied when creating a {RequestedIdDocumentComparisonCheck}
+        #
+        class RequestedIdDocumentComparisonCheckConfig
+          def as_json(*_args)
+            {}
+          end
+        end
+
+        #
+        # Builder to assist the creation of {RequestedIdDocumentComparisonCheck}
+        #
+        class RequestedIdDocumentComparisonCheckBuilder
+          #
+          # @return [RequestedIdDocumentComparisonCheck]
+          #
+          def build
+            config = RequestedIdDocumentComparisonCheckConfig.new
+            RequestedIdDocumentComparisonCheck.new(config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Requests creation of a Liveness Check
+        #
+        class RequestedLivenessCheck < RequestedCheck
+          #
+          # @param [RequestedLivenessCheckConfig] config
+          #
+          def initialize(config)
+            Validation.assert_is_a(
+              RequestedLivenessCheckConfig,
+              config,
+              'config'
+            )
+
+            super(Constants::LIVENESS, config)
+          end
+
+          #
+          # @return [RequestedLivenessCheckBuilder]
+          #
+          def self.builder
+            RequestedLivenessCheckBuilder.new
+          end
+        end
+
+        #
+        # The configuration applied when creating a {RequestedLivenessCheck}
+        #
+        class RequestedLivenessCheckConfig
+          #
+          # @param [String] liveness_type
+          # @param [String] max_retries
+          #
+          def initialize(liveness_type, max_retries)
+            Validation.assert_is_a(String, liveness_type, 'liveness_type')
+            @liveness_type = liveness_type
+
+            Validation.assert_is_a(Integer, max_retries, 'max_retries')
+            @max_retries = max_retries
+          end
+
+          def as_json(*_args)
+            {
+              liveness_type: @liveness_type,
+              max_retries: @max_retries
+            }
+          end
+        end
+
+        #
+        # Builder to assist the creation of {RequestedLivenessCheck}
+        #
+        class RequestedLivenessCheckBuilder
+          def initialize
+            @max_retries = 1
+          end
+
+          #
+          # Sets the type of the liveness check to the supplied value
+          #
+          # @param [String] liveness_type
+          #
+          # @return [self]
+          #
+          def for_liveness_type(liveness_type)
+            @liveness_type = liveness_type
+            self
+          end
+
+          #
+          # Sets the type to be of a ZOOM liveness check
+          #
+          # @return [self]
+          #
+          def for_zoom_liveness
+            for_liveness_type(Constants::ZOOM)
+          end
+
+          #
+          # Sets the maximum number of retries allowed by the user
+          #
+          # @param [Integer] max_retries
+          #
+          # @return [self]
+          #
+          def with_max_retries(max_retries)
+            @max_retries = max_retries
+            self
+          end
+
+          #
+          # @return [RequestedLivenessCheck]
+          #
+          def build
+            config = RequestedLivenessCheckConfig.new(@liveness_type, @max_retries)
+            RequestedLivenessCheck.new(config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        #
+        # Requests creation of a Task to be performed on each document
+        #
+        class RequestedTask
+          #
+          # @param [String] type The type of the Task to create
+          # @param [#as_json] config Configuration to apply to the Task
+          #
+          def initialize(type, config)
+            raise(TypeError, "#{self.class} cannot be instantiated") if self.class == RequestedTask
+
+            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

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Create
+        class RequestedTextExtractionTask < RequestedTask
+          #
+          # @param [RequestedTextExtractionTaskConfig] config
+          #
+          def initialize(config)
+            Validation.assert_is_a(
+              RequestedTextExtractionTaskConfig,
+              config,
+              'config'
+            )
+
+            super(Constants::ID_DOCUMENT_TEXT_DATA_EXTRACTION, config)
+          end
+
+          #
+          # @return [RequestedTextExtractionTaskBuilder]
+          #
+          def self.builder
+            RequestedTextExtractionTaskBuilder.new
+          end
+        end
+
+        #
+        # The configuration applied when creating each TextExtractionTask
+        #
+        class RequestedTextExtractionTaskConfig
+          #
+          # @param [String] manual_check
+          #   Describes the manual fallback behaviour applied to each Task
+          # @param [String, nil] chip_data
+          #   Describes the chip data requirement for each Task
+          #
+          def initialize(manual_check, chip_data)
+            Validation.assert_is_a(String, manual_check, 'manual_check')
+            @manual_check = manual_check
+
+            Validation.assert_is_a(String, chip_data, 'chip_data', true)
+            @chip_data = chip_data
+          end
+
+          def as_json(*_args)
+            {
+              manual_check: @manual_check,
+              chip_data: @chip_data
+            }.compact
+          end
+        end
+
+        #
+        # Builder to assist creation of {RequestedTextExtractionTask}
+        #
+        class RequestedTextExtractionTaskBuilder
+          #
+          # Requires that the Task is always followed by a manual TextDataCheck
+          #
+          # @return [self]
+          #
+          def with_manual_check_always
+            @manual_check = Constants::ALWAYS
+            self
+          end
+
+          #
+          # Requires that only failed Tasks are followed by a manual TextDataCheck
+          #
+          # @return [self]
+          #
+          def with_manual_check_fallback
+            @manual_check = Constants::FALLBACK
+            self
+          end
+
+          #
+          # The TextExtractionTask will never fallback to a manual TextDataCheck
+          #
+          # @return [self]
+          #
+          def with_manual_check_never
+            @manual_check = Constants::NEVER
+            self
+          end
+
+          #
+          # @return [self]
+          #
+          def with_chip_data_desired
+            @chip_data = Constants::DESIRED
+            self
+          end
+
+          #
+          # @return [self]
+          #
+          def with_chip_data_ignore
+            @chip_data = Constants::IGNORE
+            self
+          end
+
+          #
+          # @return [RequestedTextExtractionTask]
+          #
+          def build
+            config = RequestedTextExtractionTaskConfig.new(@manual_check, @chip_data)
+            RequestedTextExtractionTask.new(config)
+          end
+        end
+      end
+    end
+  end
+end