yoti 1.6.4 → 1.10.0

data/lib/yoti/doc_scan/session/retrieve/recommendation_response.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class RecommendationResponse
+          # @return [String]
+          attr_reader :value
+
+          # @return [String]
+          attr_reader :reason
+
+          # @return [String]
+          attr_reader :recovery_suggestion
+
+          #
+          # @param [Hash] recommendation
+          #
+          def initialize(recommendation)
+            Validation.assert_is_a(String, recommendation['value'], 'value', true)
+            @value = recommendation['value']
+
+            Validation.assert_is_a(String, recommendation['reason'], 'reason', true)
+            @reason = recommendation['reason']
+
+            Validation.assert_is_a(String, recommendation['recovery_suggestion'], 'recovery_suggestion', true)
+            @recovery_suggestion = recommendation['recovery_suggestion']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/report_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class ReportResponse
+          # @return [RecommendationResponse]
+          attr_reader :recommendation
+
+          # @return [Array<BreakdownResponse>]
+          attr_reader :breakdown
+
+          #
+          # @param [Hash] report
+          #
+          def initialize(report)
+            @recommendation = RecommendationResponse.new(report['recommendation']) unless report['recommendation'].nil?
+
+            if report['breakdown'].nil?
+              @breakdown = []
+            else
+              Validation.assert_is_a(Array, report['breakdown'], 'breakdown')
+              @breakdown = report['breakdown'].map { |breakdown| BreakdownResponse.new(breakdown) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/resource_container.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class ResourceContainer
+          # @return [Array<IdDocumentResourceResponse>]
+          attr_reader :id_documents
+
+          # @return [Array<SupplementaryDocumentResourceResponse>]
+          attr_reader :supplementary_documents
+
+          # @return [Array<LivenessResourceResponse>]
+          attr_reader :liveness_capture
+
+          #
+          # @param [Hash] resources
+          #
+          def initialize(resources)
+            @id_documents = parse_id_documents(resources)
+            @supplementary_documents = parse_supplementary_documents(resources)
+
+            if resources['liveness_capture'].nil?
+              @liveness_capture = []
+            else
+              Validation.assert_is_a(Array, resources['liveness_capture'], 'liveness_capture')
+              @liveness_capture = resources['liveness_capture'].map do |resource|
+                case resource['liveness_type']
+                when Constants::ZOOM
+                  ZoomLivenessResourceResponse.new(resource)
+                else
+                  LivenessResourceResponse.new(resource)
+                end
+              end
+            end
+          end
+
+          #
+          # @return [Array<ZoomLivenessResourceResponse>]
+          #
+          def zoom_liveness_resources
+            @liveness_capture.select { |resource| resource.is_a?(ZoomLivenessResourceResponse) }
+          end
+
+          private
+
+          def parse_id_documents(resources)
+            return [] if resources['id_documents'].nil?
+
+            Validation.assert_is_a(Array, resources['id_documents'], 'id_documents')
+            resources['id_documents'].map do |resource|
+              IdDocumentResourceResponse.new(resource)
+            end
+          end
+
+          def parse_supplementary_documents(resources)
+            return [] if resources['supplementary_documents'].nil?
+
+            Validation.assert_is_a(Array, resources['supplementary_documents'], 'supplementary_documents')
+            resources['supplementary_documents'].map do |resource|
+              SupplementaryDocumentResourceResponse.new(resource)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/resource_response.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class ResourceResponse
+          # @return [String]
+          attr_reader :id
+
+          # @return [Array<TaskResponse>]
+          attr_reader :tasks
+
+          #
+          # @param [Hash] resource
+          #
+          def initialize(resource)
+            Validation.assert_is_a(String, resource['id'], 'id', true)
+            @id = resource['id']
+
+            if resource['tasks'].nil?
+              @tasks = []
+            else
+              Validation.assert_is_a(Array, resource['tasks'], 'tasks')
+              @tasks = resource['tasks'].map do |task|
+                case task['type']
+                when Constants::ID_DOCUMENT_TEXT_DATA_EXTRACTION
+                  TextExtractionTaskResponse.new(task)
+                when Constants::SUPPLEMENTARY_DOCUMENT_TEXT_DATA_EXTRACTION
+                  SupplementaryDocumentTextExtractionTaskResponse.new(task)
+                else
+                  TaskResponse.new(task)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/supplementary_document_resource_response.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class SupplementaryDocumentResourceResponse < ResourceResponse
+          # @return [String]
+          attr_reader :document_type
+
+          # @return [String]
+          attr_reader :issuing_country
+
+          # @return [Array<PageResponse>]
+          attr_reader :pages
+
+          # @return [DocumentFieldsResponse]
+          attr_reader :document_fields
+
+          # @return [FileResponse]
+          attr_reader :document_file
+
+          #
+          # @param [Hash] resource
+          #
+          def initialize(resource)
+            super(resource)
+
+            Validation.assert_is_a(String, resource['document_type'], 'document_type', true)
+            @document_type = resource['document_type']
+
+            Validation.assert_is_a(String, resource['issuing_country'], 'issuing_country', true)
+            @issuing_country = resource['issuing_country']
+
+            if resource['pages'].nil?
+              @pages = []
+            else
+              Validation.assert_is_a(Array, resource['pages'], 'pages')
+              @pages = resource['pages'].map { |page| PageResponse.new(page) }
+            end
+
+            @document_fields = DocumentFieldsResponse.new(resource['document_fields']) unless resource['document_fields'].nil?
+
+            @document_file = FileResponse.new(resource['file']) unless resource['file'].nil?
+          end
+
+          #
+          # @return [Array<SupplementaryDocumentTextExtractionTaskResponse>]
+          #
+          def text_extraction_tasks
+            @tasks.select { |task| task.is_a?(SupplementaryDocumentTextExtractionTaskResponse) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/supplementary_document_text_data_check_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class SupplementaryDocumentTextDataCheckResponse < CheckResponse
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/supplementary_document_text_extraction_task_response.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class SupplementaryDocumentTextExtractionTaskResponse < TaskResponse
+          #
+          # @return [Array<GeneratedSupplementaryDocumentTextDataCheckResponse>]
+          #
+          def generated_text_data_checks
+            @generated_checks.select { |check| check.is_a?(GeneratedSupplementaryDocumentTextDataCheckResponse) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/task_response.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class TaskResponse
+          # @return [String]
+          attr_reader :type
+
+          # @return [String]
+          attr_reader :id
+
+          # @return [String]
+          attr_reader :state
+
+          # @return [Array<String>]
+          attr_reader :resources_used
+
+          # @return [Array<GeneratedMedia>]
+          attr_reader :generated_media
+
+          # @return [Array<GeneratedCheckResponse>]
+          attr_reader :generated_checks
+
+          # @return [<DateTime>]
+          attr_reader :created
+
+          # @return [<DateTime>]
+          attr_reader :last_updated
+
+          #
+          # @param [Hash] task
+          #
+          def initialize(task)
+            Validation.assert_is_a(String, task['type'], 'type', true)
+            @type = task['type']
+
+            Validation.assert_is_a(String, task['id'], 'id', true)
+            @id = task['id']
+
+            Validation.assert_is_a(String, task['state'], 'state', true)
+            @state = task['state']
+
+            Validation.assert_is_a(Array, task['resources_used'], 'resources_used', true)
+            @resources_used = task['resources_used']
+
+            @created = DateTime.parse(task['created']) unless task['created'].nil?
+            @last_updated = DateTime.parse(task['last_updated']) unless task['last_updated'].nil?
+
+            if task['generated_checks'].nil?
+              @generated_checks = []
+            else
+              Validation.assert_is_a(Array, task['generated_checks'], 'generated_checks')
+              @generated_checks = map_generated_checks(task['generated_checks'])
+            end
+
+            if task['generated_media'].nil?
+              @generated_media = []
+            else
+              Validation.assert_is_a(Array, task['generated_media'], 'generated_media')
+              @generated_media = task['generated_media'].map { |media| GeneratedMedia.new(media) }
+            end
+          end
+
+          private
+
+          #
+          # @param [Array<Hash>] generated_checks
+          #
+          # @return [Array<GeneratedCheckResponse>]
+          #
+          def map_generated_checks(generated_checks)
+            generated_checks.map do |check|
+              case check['type']
+              when Constants::ID_DOCUMENT_TEXT_DATA_CHECK
+                GeneratedTextDataCheckResponse.new(check)
+              when Constants::SUPPLEMENTARY_DOCUMENT_TEXT_DATA_CHECK
+                GeneratedSupplementaryDocumentTextDataCheckResponse.new(check)
+              else
+                GeneratedCheckResponse.new(check)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/text_data_check_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class TextDataCheckResponse < CheckResponse
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/text_extraction_task_response.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class TextExtractionTaskResponse < TaskResponse
+          #
+          # @return [Array<GeneratedTextDataCheckResponse>]
+          #
+          def generated_text_data_checks
+            @generated_checks.select { |check| check.is_a?(GeneratedTextDataCheckResponse) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/session/retrieve/zoom_liveness_resource_response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Session
+      module Retrieve
+        class ZoomLivenessResourceResponse < LivenessResourceResponse
+          # @return [FaceMapResponse]
+          attr_reader :facemap
+
+          # @return [Array<FrameResponse>]
+          attr_reader :frames
+
+          #
+          # @param [Hash] resource
+          #
+          def initialize(resource)
+            super(resource)
+
+            @facemap = FaceMapResponse.new(resource['facemap']) unless resource['facemap'].nil?
+
+            if resource['frames'].nil?
+              @frames = []
+            else
+              Validation.assert_is_a(Array, resource['frames'], 'frames')
+              @frames = resource['frames'].map { |frame| FrameResponse.new(frame) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoti/doc_scan/support/supported_documents.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DocScan
+    module Support
+      class SupportedDocumentsResponse
+        # @return [Array<SupportedCountry>]
+        attr_reader :supported_countries
+
+        #
+        # @param [Hash] response
+        #
+        def initialize(response)
+          if response['supported_countries'].nil?
+            @supported_countries = []
+          else
+            Validation.assert_is_a(Array, response['supported_countries'], 'supported_countries')
+            @supported_countries = response['supported_countries'].map { |country| SupportedCountry.new(country) }
+          end
+        end
+      end
+
+      class SupportedCountry
+        # @return [String]
+        attr_reader :code
+
+        # @return [Array<SupportedDocument>]
+        attr_reader :supported_documents
+
+        #
+        # @param [Hash] country
+        #
+        def initialize(country)
+          Validation.assert_is_a(String, country['code'], 'code', true)
+          @code = country['code']
+
+          if country['supported_documents'].nil?
+            @supported_documents = []
+          else
+            Validation.assert_is_a(Array, country['supported_documents'], 'supported_documents')
+            @supported_documents = country['supported_documents'].map { |document| SupportedDocument.new(document) }
+          end
+        end
+      end
+
+      class SupportedDocument
+        # @return [String]
+        attr_reader :type
+
+        #
+        # @param [Hash] document
+        #
+        def initialize(document)
+          Validation.assert_is_a(String, document['type'], 'type', true)
+          @type = document['type']
+        end
+      end
+    end
+  end
+end