yoti 1.5.0 → 1.6.0

data/lib/yoti/dynamic_share_service/extension/extension.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DynamicSharingService
+    class Extension
+      attr_reader :type
+      attr_reader :content
+
+      def to_json(*_args)
+        as_json.to_json
+      end
+
+      def as_json(*_args)
+        {
+          type: @type,
+          content: @content
+        }
+      end
+
+      def self.builder
+        ExtensionBuilder.new
+      end
+    end
+
+    class ExtensionBuilder
+      def initialize
+        @extension = Extension.new
+      end
+
+      def with_type(type)
+        @extension.instance_variable_set(:@type, type)
+        self
+      end
+
+      def with_content(content)
+        @extension.instance_variable_set(:@content, content)
+        self
+      end
+
+      def build
+        Marshal.load Marshal.dump @extension
+      end
+    end
+  end
+end

data/lib/yoti/dynamic_share_service/extension/location_constraint_extension.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DynamicSharingService
+    # A Location Constraint
+    class LocationConstraintExtension
+      EXTENSION_TYPE = 'LOCATION_CONSTRAINT'
+
+      attr_reader :content
+      attr_reader :type
+
+      def initialize
+        @content = {}
+        @type = EXTENSION_TYPE
+      end
+
+      def as_json(*_args)
+        {
+          type: @type,
+          content: @content
+        }
+      end
+
+      def to_json(*_args)
+        as_json.to_json
+      end
+
+      def self.builder
+        LocationConstraintExtensionBuilder.new
+      end
+    end
+
+    # Builder for LocationConstraintExtension
+    class LocationConstraintExtensionBuilder
+      def with_latitude(latitude)
+        raise ArgumentError, 'Latitude must be Integer or Float'\
+          unless latitude.is_a?(Integer) || latitude.is_a?(Float)
+        raise ArgumentError, 'Latitude must be between -90 and 90'\
+          unless latitude >= -90 && latitude <= 90
+
+        @latitude = latitude
+        self
+      end
+
+      def with_longitude(longitude)
+        raise ArgumentError, 'Longitude must be Integer or Float'\
+          unless longitude.is_a?(Integer) || longitude.is_a?(Float)
+        raise ArgumentError, 'Longitude must be between -180 and 180'\
+          unless longitude >= -180 && longitude <= 180
+
+        @longitude = longitude
+        self
+      end
+
+      def with_radius(radius)
+        raise ArgumentError, 'Radius must be Integer or Float'\
+          unless radius.is_a?(Integer) || radius.is_a?(Float)
+        raise ArgumentError, 'Radius must be >= 0' unless radius >= 0
+
+        @radius = radius
+        self
+      end
+
+      def with_max_uncertainty(uncertainty)
+        raise ArgumentError, 'Uncertainty must be Integer or Float'\
+          unless uncertainty.is_a?(Integer) || uncertainty.is_a?(Float)
+        raise ArgumentError, 'Uncertainty must be >= 0' unless uncertainty >= 0
+
+        @uncertainty = uncertainty
+        self
+      end
+
+      def build
+        @radius ||= 150 unless @radius
+        @uncertainty ||= 150 unless @uncertainty
+
+        extension = LocationConstraintExtension.new
+        extension.instance_variable_get(:@content)[:expected_device_location] = {
+          latitude: @latitude,
+          longitude: @longitude,
+          radius: @radius,
+          max_uncertainty_radius: @uncertainty
+        }
+        extension
+      end
+    end
+  end
+end

data/lib/yoti/dynamic_share_service/extension/thirdparty_attribute_extension.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DynamicSharingService
+    class ThirdPartyAttributeExtensionBuilder
+      def initialize
+        @expiry_date = nil
+        @definitions = []
+      end
+
+      def with_expiry_date(expiry_date)
+        @expiry_date = expiry_date
+        self
+      end
+
+      def with_definitions(*names)
+        names.each do |s|
+          @definitions += [{ name: s }]
+        end
+        self
+      end
+
+      def build
+        extension = ThirdPartyAttributeExtension.new
+        extension.instance_variable_get(:@content)[:expiry_date] = @expiry_date
+        extension.instance_variable_get(:@content)[:definitions] = @definitions
+        extension
+      end
+    end
+
+    class ThirdPartyAttributeExtension
+      EXTENSION_TYPE = 'THIRD_PARTY_ATTRIBUTE'
+
+      attr_reader :content
+      attr_reader :type
+
+      def initialize
+        @content = {}
+        @type = EXTENSION_TYPE
+      end
+
+      def as_json(*_args)
+        {
+          type: @type,
+          content: @content
+        }
+      end
+
+      def to_json(*_args)
+        as_json.to_json
+      end
+
+      def self.builder
+        ThirdPartyAttributeExtensionBuilder.new
+      end
+    end
+  end
+end

data/lib/yoti/dynamic_share_service/extension/transactional_flow_extension.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DynamicSharingService
+    # Extension for transactional flows
+    class TransactionalFlowExtension
+      EXTENSION_TYPE = 'TRANSACTIONAL_FLOW'
+      attr_reader :content
+      attr_reader :type
+
+      def initialize
+        @type = EXTENSION_TYPE
+      end
+
+      def to_json(*_args)
+        as_json.to_json
+      end
+
+      def as_json(*_args)
+        {
+          content: @content,
+          type: @type
+        }
+      end
+
+      def self.builder
+        TransactionalFlowExtensionBuilder.new
+      end
+    end
+
+    # Builder for TransactionalFlowExtension
+    class TransactionalFlowExtensionBuilder
+      def initialize
+        @extension = TransactionalFlowExtension.new
+      end
+
+      def with_content(content)
+        @extension.instance_variable_set(:@content, content)
+        self
+      end
+
+      def build
+        Marshal.load Marshal.dump @extension
+      end
+    end
+  end
+end

data/lib/yoti/dynamic_share_service/policy/dynamic_policy.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DynamicSharingService
+    # Describes a policy for a dynamic share
+    class DynamicPolicy
+      SELFIE_AUTH_TYPE = 1
+      PIN_AUTH_TYPE = 2
+
+      attr_reader :wanted_auth_types
+      attr_reader :wanted
+
+      def wanted_remember_me
+        return true if @wanted_remember_me
+
+        false
+      end
+
+      def to_json(*args)
+        as_json.to_json(*args)
+      end
+
+      def as_json(*_args)
+        {
+          wanted_auth_types: @wanted_auth_types,
+          wanted: @wanted
+        }
+      end
+
+      def self.builder
+        DynamicPolicyBuilder.new
+      end
+    end
+
+    # Builder for DynamicPolicy
+    class DynamicPolicyBuilder
+      def initialize
+        @policy = DynamicPolicy.new
+        @wanted_auth_types = {}
+        @wanted_attributes = {}
+      end
+
+      def build
+        @policy.instance_variable_set(
+          :@wanted_auth_types,
+          @wanted_auth_types
+            .select { |_, wanted| wanted }
+            .keys
+        )
+        @policy.instance_variable_set(:@wanted, @wanted_attributes.values)
+        Marshal.load Marshal.dump @policy
+      end
+
+      #
+      # @param [Bool] wanted
+      #
+      def with_wanted_remember_me(wanted = true)
+        @policy.instance_variable_set(:@wanted_remember_me, wanted)
+        self
+      end
+
+      #
+      # @param [Integer] auth
+      # @param [Bool] wanted
+      #
+      def with_wanted_auth_type(auth, wanted = true)
+        @wanted_auth_types[auth] = wanted
+        self
+      end
+
+      #
+      # @param [Bool] wanted
+      #
+      def with_selfie_auth(wanted = true)
+        with_wanted_auth_type(DynamicPolicy::SELFIE_AUTH_TYPE, wanted)
+      end
+
+      #
+      # @param [Bool] wanted
+      #
+      def with_pin_auth(wanted = true)
+        with_wanted_auth_type(DynamicPolicy::PIN_AUTH_TYPE, wanted)
+      end
+
+      #
+      # @param [Yoti::DynamicSharingService::WantedAttribute] attribute
+      #
+      def with_wanted_attribute(attribute)
+        key = attribute.derivation || attribute.name
+        @wanted_attributes[key] = attribute
+        self
+      end
+
+      #
+      # @param [String] name
+      # @param [Hash] constraints
+      #
+      def with_wanted_attribute_by_name(name, constraints: nil)
+        attribute_builder = WantedAttribute.builder.with_name(name)
+        constraints&.each do |constraint|
+          attribute_builder.with_constraint constraint
+        end
+        attribute = attribute_builder.build
+        with_wanted_attribute attribute
+      end
+
+      def with_family_name(options = {})
+        with_wanted_attribute_by_name Attribute::FAMILY_NAME, options
+      end
+
+      def with_given_names(options = {})
+        with_wanted_attribute_by_name Attribute::GIVEN_NAMES, options
+      end
+
+      def with_full_name(options = {})
+        with_wanted_attribute_by_name Attribute::FULL_NAME, options
+      end
+
+      def with_date_of_birth(options = {})
+        with_wanted_attribute_by_name Attribute::DATE_OF_BIRTH, options
+      end
+
+      #
+      # @param [String] derivation
+      # @param [Hash] constraints
+      #
+      def with_age_derived_attribute(derivation, constraints: nil)
+        attribute_builder = WantedAttribute.builder
+        attribute_builder.with_name(Attribute::DATE_OF_BIRTH)
+        attribute_builder.with_derivation(derivation)
+        constraints&.each do |constraint|
+          attribute_builder.with_constraint constraint
+        end
+        with_wanted_attribute(attribute_builder.build)
+      end
+
+      #
+      # @param [Integer] derivation
+      #
+      def with_age_over(age, options = {})
+        with_age_derived_attribute(Attribute::AGE_OVER + age.to_s, options)
+      end
+
+      #
+      # @param [Integer] derivation
+      #
+      def with_age_under(age, options = {})
+        with_age_derived_attribute(Attribute::AGE_UNDER + age.to_s, options)
+      end
+
+      def with_gender(options = {})
+        with_wanted_attribute_by_name Attribute::GENDER, options
+      end
+
+      def with_postal_address(options = {})
+        with_wanted_attribute_by_name(Attribute::POSTAL_ADDRESS, options)
+      end
+
+      def with_structured_postal_address(options = {})
+        with_wanted_attribute_by_name(Attribute::STRUCTURED_POSTAL_ADDRESS, options)
+      end
+
+      def with_nationality(options = {})
+        with_wanted_attribute_by_name(Attribute::NATIONALITY, options)
+      end
+
+      def with_phone_number(options = {})
+        with_wanted_attribute_by_name(Attribute::PHONE_NUMBER, options)
+      end
+
+      def with_selfie(options = {})
+        with_wanted_attribute_by_name(Attribute::SELFIE, options)
+      end
+
+      def with_email(options = {})
+        with_wanted_attribute_by_name(Attribute::EMAIL_ADDRESS, options)
+      end
+
+      def with_document_details
+        with_wanted_attribute_by_name(Attribute::DOCUMENT_DETAILS)
+      end
+    end
+  end
+end

data/lib/yoti/dynamic_share_service/policy/source_constraint.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Yoti
+  module DynamicSharingService
+    # A list of anchors to require for a dynamic share
+    class SourceConstraint
+      DRIVING_LICENCE = 'DRIVING_LICENCE'
+      PASSPORT = 'PASSPORT'
+      NATIONAL_ID = 'NATIONAL_ID'
+      PASS_CARD = 'PASS_CARD'
+
+      SOURCE_CONSTRAINT = 'SOURCE'
+
+      attr_reader :anchors
+
+      def soft_preference
+        return @soft_preference if @soft_preference
+
+        false
+      end
+
+      def to_json(*_args)
+        as_json.to_json
+      end
+
+      def as_json(*_args)
+        obj = {
+          type: SOURCE_CONSTRAINT,
+          preferred_sources: {
+            anchors: @anchors.map(&:as_json)
+          }
+        }
+        obj[:preferred_sources][:soft_preference] = @soft_preference unless @soft_preference.nil?
+        obj
+      end
+
+      def initialize
+        @anchors = []
+      end
+
+      def self.builder
+        SourceConstraintBuilder.new
+      end
+    end
+
+    # Builder for SourceConstraint
+    class SourceConstraintBuilder
+      def initialize
+        @constraint = SourceConstraint.new
+      end
+
+      def with_anchor_by_value(value, sub_type)
+        anchor = WantedAnchor.builder.with_value(value).with_sub_type(sub_type).build
+        with_anchor(anchor)
+      end
+
+      def with_anchor(anchor)
+        @constraint.anchors.push(anchor)
+        self
+      end
+
+      def with_passport(sub_type = nil)
+        with_anchor_by_value(SourceConstraint::PASSPORT, sub_type)
+      end
+
+      def with_driving_licence(sub_type = nil)
+        with_anchor_by_value(SourceConstraint::DRIVING_LICENCE, sub_type)
+      end
+
+      def with_national_id(sub_type = nil)
+        with_anchor_by_value(SourceConstraint::NATIONAL_ID, sub_type)
+      end
+
+      def with_passcard(sub_type = nil)
+        with_anchor_by_value(SourceConstraint::PASS_CARD, sub_type)
+      end
+
+      def with_soft_preference(preference = true)
+        @constraint.instance_variable_set(:@soft_preference, preference)
+        self
+      end
+
+      def build
+        Marshal.load Marshal.dump @constraint
+      end
+    end
+  end
+end