trusona 0.16.0

data/lib/trusona/resources/tru_code.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Resources
+    #
+    ## A TruCode used for magic logins
+    class TruCode < BaseResource
+      include Trusona::Resources::Validators
+      include Trusona::Helpers::KeyNormalizer
+
+      attr_reader :relying_party_id, :payload, :id
+
+      def initialize(params = {})
+        normalized_params = normalize_keys(params)
+        @id = normalized_params[:id]
+        @payload = normalized_params[:payload]
+        @relying_party_id = normalized_params[:relying_party_id] ||
+                            Trusona::TruCodeConfig.new.relying_party_id
+        raise ArgumentError unless validate
+      end
+
+      def to_json
+        JSON(to_h)
+      end
+
+      def to_h
+        {
+          id: @id,
+          relying_party_id: @relying_party_id,
+          payload: @payload
+        }
+      end
+
+      private
+
+      def validate
+        return false unless present?(@relying_party_id)
+        true
+      end
+    end
+  end
+end

data/lib/trusona/resources/trusonafication.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Resources
+    ##
+    # Represents a Trusonafication resource
+    class Trusonafication < BaseResource
+      include Trusona::Helpers::KeyNormalizer
+      include Trusona::Helpers::TimeNormalizer
+
+      attr_accessor :device_identifier, :user_identifier, :trucode_id,
+                    :resource, :action, :level, :id,
+                    :accepted_level, :trusona_id, :expires_at,
+                    :user_presence, :callback_url, :prompt
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def initialize(params = {})
+        @params = normalize_keys(params)
+        return if @params.nil?
+        self.accepted_level    = determine_accepted_level(@params)
+        self.action            = @params[:action]
+        self.device_identifier = @params[:device_identifier]
+        self.user_identifier   = @params[:user_identifier]
+        self.trucode_id        = @params[:trucode_id]
+        self.expires_at        = normalize_time(@params[:expires_at])
+        self.id                = @params[:id]
+        self.level             = @params[:level]
+        self.resource          = @params[:resource]
+        self.trusona_id        = @params[:trusona_id]
+        self.prompt            = defaulting_to(true, @params[:prompt])
+        self.user_presence     = defaulting_to(true, @params[:user_presence])
+        self.callback_url      = @params[:callback_url]
+
+        @status = @params[:status]
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def to_h
+        @params
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def to_json
+        JSON(device_identifier: device_identifier,
+             user_identifier: user_identifier,
+             trucode_id: trucode_id,
+             trusona_id: trusona_id,
+             resource: resource,
+             action: action,
+             desired_level: level,
+             id: id,
+             status: @status,
+             prompt: prompt,
+             user_presence: user_presence,
+             callback_url: callback_url,
+             expires_at: expires_at&.iso8601)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def accepted?
+        return true if status == :accepted
+        return true if status == :accepted_at_higher_level
+        false
+      end
+
+      def rejected?
+        !accepted?
+      end
+
+      def valid?
+        attributes_present && attributes_filled
+      end
+
+      # rubocop:disable MethodLength
+      # rubocop:disable CyclomaticComplexity
+      def status
+        case @status
+        when 'INVALID_TRUSONA_ID'
+          :invalid_trusona_id
+        when 'IN_PROGRESS'
+          :in_progress
+        when 'REJECTED'
+          :rejected
+        when 'ACCEPTED'
+          :accepted
+        when 'INVALID_EMAIL'
+          :invalid_email
+        when 'ACCEPTED_AT_LOWER_LEVEL'
+          :accepted_at_lower_level
+        when 'ACCEPTED_AT_HIGHER_LEVEL'
+          :accepted_at_higher_level
+        when 'EXPIRED'
+          :expired
+        else
+          :invalid
+        end
+      end
+      # rubocop:enable CyclomaticComplexity
+      # rubocop:enable MethodLength
+
+      private
+
+      def defaulting_to(value, param)
+        return value if param.nil?
+        return value if param.respond_to?(:empty?) && param.empty?
+        param
+      end
+
+      def determine_accepted_level(params)
+        params[:result][:accepted_level] unless params[:result].nil?
+      end
+
+      def attributes_present
+        return false if identifier.nil?
+        return false if resource.nil?
+        return false if action.nil?
+        return false if level.nil?
+
+        true
+      end
+
+      def attributes_filled
+        return false if identifier.empty?
+        return false if resource.empty?
+        return false if action.empty?
+
+        true
+      end
+
+      def identifier
+        device_identifier || user_identifier || trucode_id || trusona_id
+      end
+    end
+  end
+end

data/lib/trusona/resources/user_account.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Resources
+    #
+    ## a potentially scanned and or paired TruCode
+    class UserAccount < BaseResource
+      module Status
+        ACTIVE   = 'active'
+        INACTIVE = 'inactive'
+        UNKNOWN  = 'unknown'
+      end
+
+      module Level
+        ENTRY     = 'entry'
+        ESSENTIAL = 'essential'
+        EXECUTIVE = 'executive'
+      end
+
+      include Trusona::Resources::Validators
+      include Trusona::Helpers::KeyNormalizer
+
+      attr_reader :id, :trusona_id, :email, :status, :first_name, :last_name,
+                  :nickname, :handle, :emails, :max_level
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def initialize(params = {})
+        params_with_symbol_keys = normalize_keys(params)
+        @trusona_id = params_with_symbol_keys[:trusona_id]
+        @id         = @trusona_id
+        @email      = params_with_symbol_keys[:email]
+        @status     = determine_status(params_with_symbol_keys[:status])
+        @first_name = params_with_symbol_keys[:first_name]
+        @last_name  = params_with_symbol_keys[:last_name]
+        @nickname   = params_with_symbol_keys[:nickname]
+        @handle     = params_with_symbol_keys[:handle]
+        @emails     = parse_emails(params_with_symbol_keys[:emails])
+        @max_level  = parse_max_level(params_with_symbol_keys[:metadata])
+
+        @params     = params_with_symbol_keys
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def to_json
+        JSON(to_h)
+      end
+
+      private
+
+      def determine_status(status)
+        return Status::INACTIVE if status == 'inactive'
+        return Status::ACTIVE if status == 'active'
+        Status::UNKNOWN
+      end
+
+      def parse_emails(emails)
+        return [] if emails.nil? || emails.empty?
+        emails.map { |e| UserAccountEmail.new(e) }
+      end
+
+      def parse_max_level(metadata)
+        return Level::ENTRY unless metadata
+        level = metadata['max_level'] || metadata[:max_level]
+
+        return Level::ESSENTIAL if level == 'essential'
+        return Level::EXECUTIVE if level == 'executive'
+        Level::ENTRY
+      end
+
+      #
+      ## An email associated with a user account
+      class UserAccountEmail
+        attr_reader :email, :id, :verified
+        def initialize(email = {})
+          @email    = email[:email] || email['email']
+          @id       = email[:id] || email['id']
+          @verified = email[:verified] || email['verified'] || false
+        end
+      end
+    end
+  end
+end

data/lib/trusona/resources/user_identifier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Resources
+    #
+    ## a relying party specific user identifier
+    class UserIdentifier < BaseResource
+      include Trusona::Resources::Validators
+      attr_reader :identifier, :trusona_id
+
+      def initialize(params = {})
+        @params     = params
+        @identifier = params[:identifier]
+        @trusona_id = params[:trusona_id]
+        @id         = @identifier
+      end
+
+      def to_h
+        @params
+      end
+
+      def to_json
+        JSON(to_h)
+      end
+
+      def valid?
+        validate
+      end
+
+      def validate
+        attributes_present && attributes_filled
+      end
+
+      private
+
+      def attributes_present
+        return false unless @params.key?(:identifier)
+        return false unless @params.key?(:trusona_id)
+        true
+      end
+
+      def attributes_filled
+        return false if @params.fetch(:identifier).empty?
+        return false if @params.fetch(:trusona_id).empty?
+        true
+      end
+    end
+  end
+end

data/lib/trusona/resources/validators.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Resources
+    #
+    ## Basic validators for working with Resources
+    module Validators
+      def present?(item)
+        return false if item.nil? || item.to_s.empty?
+        true
+      end
+
+      def valid?
+        validate
+      end
+
+      def validate
+        true
+      end
+    end
+  end
+end

data/lib/trusona/services/account_lookups_service.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Services
+    #
+    ## User Accounts Service
+    class AccountLookupsService < BaseService
+      def initialize(client: nil, mapper: nil)
+        @client = client || Trusona::Api::HTTPClient.new(
+          Trusona.config.api_host
+        )
+        @mapper = mapper || Trusona::Mappers::UserAccountMapper.new
+        @resource_path = '/internal/v1/account_lookups'
+      end
+    end
+  end
+end

data/lib/trusona/services/base_service.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Trusona
+  module Services
+    #
+    ## The starting point for building other services that interact with the
+    ## Trusona API
+    class BaseService
+      attr_accessor :resource_path
+
+      def initialize(client: Trusona::Api::HTTPClient.new,
+                     mapper: Trusona::Mappers::BaseMapper.new)
+        @client = client
+        @mapper = mapper
+        @resource_path = '/base-service'
+      end
+
+      def index
+        handle(@client.get(collection_path))
+      end
+
+      def get(resource)
+        raise Trusona::InvalidResourceError unless resource.id
+        handle(@client.get(member_path(resource)), resource)
+      end
+
+      def create(resource)
+        puts resource.to_json
+        raise Trusona::InvalidResourceError unless resource.valid?
+        handle(@client.post(collection_path, resource.to_json), resource)
+      end
+
+      def update(resource)
+        raise Trusona::InvalidResourceError unless resource.id
+        handle(@client.patch(member_path(resource), resource.to_json), resource)
+      end
+
+      def collection_path
+        @resource_path
+      end
+
+      def member_path(resource)
+        [collection_path, resource.id].join('/')
+      end
+
+      private
+
+      def verify_response(response)
+        raise Trusona::SigningError unless response.verified?
+      end
+
+      # rubocop:disable MethodLength
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def handle(response, resource = {})
+        @response = response
+        raise if resource.nil?
+        case response.code
+        when 200..299
+          success(response, resource)
+        when 400
+          bad_request
+        when 404
+          not_found
+        when 403
+          unauthorized
+        when 424
+          failed_dependency
+        when 500..599
+          server_error
+        else
+          raise Trusona::RequestError, readable_error
+        end
+      end
+      # rubocop:enable MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def success(response, resource)
+        verify_response(response)
+        @mapper.map(response, resource)
+      end
+
+      def bad_request
+        raise Trusona::BadRequestError, readable_error
+      end
+
+      def failed_dependency
+        raise Trusona::FailedDependencyError, readable_error
+      end
+
+      def not_found
+        raise Trusona::ResourceNotFoundError, readable_error
+      end
+
+      def unauthorized
+        raise Trusona::UnauthorizedRequestError, readable_error
+      end
+
+      def server_error
+        raise Trusona::ApiError
+      end
+
+      def readable_error
+        default = '[UNKNOWN] Error - An unknown error has occurred.'
+        return default unless @response
+        body = @response.to_h
+        msg = []
+        msg << "[#{body['error']}] #{body['message']} - #{body['description']}"
+        return msg.join("\n") unless body['field_errors']
+        body['field_errors'].each do |field|
+          msg << "\t #{field.join(' => ')}"
+        end
+
+        msg.join("\n")
+      end
+    end
+  end
+end