smile-identity-core 1.2.1 → 2.1.0

data/lib/smile-identity-core/id_api.rb

@@ -1,82 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'validations'
+
 module SmileIdentityCore
+  # Allows you to query the Identity Information for an individual using their ID number
   class IDApi
+    include Validations
+
+    REQUIRED_ID_INFO_FIELD = %i[country id_type id_number].freeze
 
     def initialize(partner_id, api_key, sid_server)
       @partner_id = partner_id.to_s
       @api_key = api_key
 
-      @sid_server = sid_server
-      if !(sid_server =~ URI::regexp)
-        sid_server_mapping = {
-          0 => 'https://testapi.smileidentity.com/v1',
-          1 => 'https://api.smileidentity.com/v1',
-        }
-        @url = sid_server_mapping[sid_server.to_i]
-      else
-        @url = sid_server
-      end
+      @url = if sid_server !~ URI::DEFAULT_PARSER.make_regexp
+               SmileIdentityCore::ENV::SID_SERVER_MAPPING[sid_server.to_s]
+             else
+               sid_server
+             end
     end
 
     def submit_job(partner_params, id_info, options = {})
-      self.partner_params = symbolize_keys partner_params
-      self.id_info = symbolize_keys id_info
-      @use_new_signature = symbolize_keys(options || {}).fetch(:signature, false)
+      @partner_params = validate_partner_params(symbolize_keys(partner_params))
+      @id_info = validate_id_info(symbolize_keys(id_info), REQUIRED_ID_INFO_FIELD)
 
-      if @partner_params[:job_type].to_i != 5
-        raise ArgumentError, 'Please ensure that you are setting your job_type to 5 to query ID Api'
+      unless [JobType::ENHANCED_KYC, JobType::BUSINESS_VERIFICATION].include?(@partner_params[:job_type].to_i)
+        raise ArgumentError, 'Please ensure that you are setting your job_type to 5 or 7 to query ID Api'
       end
 
-      setup_requests
-    end
-
-    def partner_params=(partner_params)
-      if partner_params == nil
-        raise ArgumentError, 'Please ensure that you send through partner params'
+      if partner_params[:job_type] == JobType::BUSINESS_VERIFICATION
+        return SmileIdentityCore::BusinessVerification
+               .new(@partner_id, @api_key, @url)
+               .submit_job(partner_params, id_info)
       end
 
-      if !partner_params.is_a?(Hash)
-        raise ArgumentError, 'Partner params needs to be a hash'
-      end
+      options = symbolize_keys(options || {})
+      @use_async_endpoint = options.fetch(:async, false)
 
-      [:user_id, :job_id, :job_type].each do |key|
-        unless partner_params[key] && !partner_params[key].nil? && !(partner_params[key].empty? if partner_params[key].is_a?(String))
-          raise ArgumentError, "Please make sure that #{key} is included in the partner params"
-        end
-      end
-
-      @partner_params = partner_params
-    end
-
-    def id_info=(id_info)
-
-      updated_id_info = id_info
-
-      if updated_id_info.nil? ||  updated_id_info.keys.length == 0
-        raise ArgumentError, 'Please make sure that id_info not empty or nil'
-      end
-
-      [:country, :id_type, :id_number].each do |key|
-        unless updated_id_info[key] && !updated_id_info[key].nil? && !updated_id_info[key].empty?
-          raise ArgumentError, "Please make sure that #{key} is included in the id_info"
-        end
-      end
-
-      @id_info = updated_id_info
+      setup_requests
     end
 
     private
 
-    def symbolize_keys params
-      (params.is_a?(Hash)) ? Hash[params.map{ |k, v| [k.to_sym, v] }] : params
+    def symbolize_keys(params)
+      params.is_a?(Hash) ? params.transform_keys(&:to_sym) : params
     end
 
     def setup_requests
-      url = "#{@url}/id_verification"
-
       request = Typhoeus::Request.new(
-        url,
+        "#{@url}/#{endpoint}",
         method: 'POST',
-        headers: {'Content-Type'=> "application/json"},
+        headers: { 'Content-Type' => 'application/json' },
         body: configure_json
       )
 
@@ -88,39 +62,24 @@ module SmileIdentityCore
       request.run
     end
 
+    def endpoint
+      @use_async_endpoint ? 'async_id_verification' : 'id_verification'
+    end
+
     def configure_json
-      request_security(use_new_signature: @use_new_signature)
-        .merge(@id_info)
-        .merge(
-          partner_id: @partner_id,
-          partner_params: @partner_params)
-        .to_json
+      signature_generator.generate_signature(Time.now.to_s)
+                         .merge(@id_info)
+                         .merge(
+                           partner_id: @partner_id,
+                           partner_params: @partner_params,
+                           source_sdk: SmileIdentityCore::SOURCE_SDK,
+                           source_sdk_version: SmileIdentityCore::VERSION
+                         )
+                         .to_json
     end
 
     def signature_generator
       SmileIdentityCore::Signature.new(@partner_id, @api_key)
     end
-
-    def signature(timestamp: Time.now.to_s)
-      signature = signature_generator.generate_signature(timestamp)[:signature]
-      {
-        signature: signature,
-        timestamp: timestamp
-      }
-    end
-
-    def sec_key(timestamp: Time.now.to_s)
-      sec_key = signature_generator.generate_sec_key(timestamp)[:sec_key]
-      {
-        sec_key: sec_key,
-        timestamp: timestamp
-      }
-    end
-
-    def request_security(use_new_signature: true)
-      return signature if use_new_signature
-
-      sec_key
-    end
   end
 end

data/lib/smile-identity-core/signature.rb

@@ -1,54 +1,33 @@
+# frozen_string_literal: true
+
 module SmileIdentityCore
+  # Contains handy methods to generate and confirm signature for authentication
   class Signature
-
     def initialize(partner_id, api_key)
       @api_key = api_key
       @partner_id = partner_id
     end
 
-    def generate_sec_key(timestamp=Time.now.to_i)
-      begin
-        @timestamp = timestamp
-
-        hash_signature = Digest::SHA256.hexdigest([@partner_id.to_i, @timestamp].join(":"))
-        public_key = OpenSSL::PKey::RSA.new(Base64.decode64(@api_key))
-        @sec_key = [Base64.encode64(public_key.public_encrypt(hash_signature)), hash_signature].join('|')
-
-        {
-          sec_key: @sec_key,
-          timestamp: @timestamp
-        }
-      rescue => e
-        raise e
-      end
-    end
-
-    def confirm_sec_key(timestamp, sec_key)
-      begin
-        hash_signature = Digest::SHA256.hexdigest([@partner_id.to_i, timestamp].join(":"))
-        encrypted = sec_key.split('|')[0]
-
-        public_key = OpenSSL::PKey::RSA.new(Base64.decode64(@api_key))
-        decrypted = public_key.public_decrypt(Base64.decode64(encrypted))
-
-        decrypted == hash_signature
-      rescue => e
-        raise e
-      end
-    end
-
-    def generate_signature(timestamp=Time.now.to_s)
+    # Generates a signature based on the specified timestamp (uses the current time by default)
+    #
+    # @return [Hash] containing both the signature and related timestamp
+    def generate_signature(timestamp = Time.now.to_s)
       hmac = OpenSSL::HMAC.new(@api_key, 'sha256')
       hmac.update(timestamp.to_s)
       hmac.update(@partner_id)
-      hmac.update("sid_request")
-      signature = Base64.strict_encode64(hmac.digest())
+      hmac.update('sid_request')
+      @signature = Base64.strict_encode64(hmac.digest)
       {
-        signature: signature,
+        signature: @signature,
         timestamp: timestamp.to_s
       }
     end
 
+    # Confirms the signature against a newly generated signature based on the same timestamp
+    #
+    # @param [String] timestamp the timestamp to generate the signature from
+    # @param [String] msg_signature a previously generated signature, to be confirmed
+    # @return [Boolean] TRUE or FALSE
     def confirm_signature(timestamp, msg_signature)
       generate_signature(timestamp)[:signature] == msg_signature
     end

data/lib/smile-identity-core/utilities.rb

@@ -1,22 +1,19 @@
+# frozen_string_literal: true
+
 module SmileIdentityCore
+  # A utility class to query job status
   class Utilities
-
     def initialize(partner_id, api_key, sid_server)
       @partner_id = partner_id.to_s
       @api_key = api_key
 
-      if !(sid_server =~ URI::regexp)
-        sid_server_mapping = {
-          0 => 'https://testapi.smileidentity.com/v1',
-          1 => 'https://api.smileidentity.com/v1',
-        }
-        @url = sid_server_mapping[sid_server.to_i]
-      else
-        @url = sid_server
-      end
+      @url = if sid_server !~ URI::DEFAULT_PARSER.make_regexp
+               SmileIdentityCore::ENV::SID_SERVER_MAPPING[sid_server.to_s]
+             else
+               sid_server
+             end
 
       @signature_connection = SmileIdentityCore::Signature.new(@partner_id, @api_key)
-
     end
 
     def get_job_status(user_id, job_id, options = {})
@@ -24,77 +21,53 @@ module SmileIdentityCore
       options[:return_history] ||= false
       options[:return_image_links] ||= false
 
-      security = request_security(use_new_signature: options.fetch(:signature, false))
-      query_job_status(configure_job_query(user_id, job_id, options).merge(security))
+      query_job_status(configure_job_query(user_id, job_id,
+                                           options).merge(@signature_connection.generate_signature(Time.now.to_s)))
     end
 
     private
 
-    def symbolize_keys params
-      (params.is_a?(Hash)) ? Hash[params.map{ |k, v| [k.to_sym, v] }] : params
+    def symbolize_keys(params)
+      params.is_a?(Hash) ? params.transform_keys(&:to_sym) : params
     end
 
     def query_job_status(request_json_data)
-      url = "#{@url}/job_status"
-
       request = Typhoeus::Request.new(
-        url,
-        headers: {'Content-Type': 'application/json', 'Accept': 'application/json'},
+        "#{@url}/job_status",
+        headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
         method: :post,
         body: request_json_data.to_json
       )
 
       request.on_complete do |response|
-        begin
-          body = JSON.parse(response.body)
+        body = JSON.parse(response.body)
 
-          # NB: we have to trust that the server will return the right kind of
-          # timestamp (integer or string) for the signature, and the right kind
-          # of signature in the "signature" field. The best way to know what
-          # kind of validation to perform is by remembering which kind of
-          # security we started with.
-          if request_json_data.has_key?(:sec_key)
-            valid = @signature_connection.confirm_sec_key(body['timestamp'], body['signature'])
-          else
-            valid = @signature_connection.confirm_signature(body['timestamp'], body['signature'])
-          end
+        # NB: we have to trust that the server will return the right kind of
+        # timestamp (integer or string) for the signature, and the right kind
+        # of signature in the "signature" field. The best way to know what
+        # kind of validation to perform is by remembering which kind of
+        # security we started with.
+        valid = @signature_connection.confirm_signature(body['timestamp'], body['signature'])
 
-          if(!valid)
-            raise "Unable to confirm validity of the job_status response"
-          end
+        raise 'Unable to confirm validity of the job_status response' unless valid
 
-          return body
-        rescue => e
-          raise e
-        end
+        return body
+      rescue StandardError => e
+        raise e
       end
 
       request.run
     end
 
-    def request_security(use_new_signature: false)
-      if use_new_signature
-        @timestamp = Time.now.to_s
-        {
-          signature: @signature_connection.generate_signature(@timestamp)[:signature],
-          timestamp: @timestamp,
-        }
-      else
-        @timestamp = Time.now.to_i
-        {
-          sec_key: @signature_connection.generate_sec_key(@timestamp)[:sec_key],
-          timestamp: @timestamp,
-        }
-      end
-    end
-
     def configure_job_query(user_id, job_id, options)
       {
         user_id: user_id,
         job_id: job_id,
         partner_id: @partner_id,
         image_links: options[:return_image_links],
-        history:  options[:return_history]
+        history: options[:return_history],
+        source_sdk: SmileIdentityCore::SOURCE_SDK,
+        source_sdk_version: SmileIdentityCore::VERSION
       }
     end
   end

data/lib/smile-identity-core/validations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SmileIdentityCore
+  module Validations   # :nodoc:
+    def validate_partner_params(partner_params)
+      raise ArgumentError, 'Please ensure that you send through partner params' if partner_params.nil?
+
+      raise ArgumentError, 'Partner params needs to be a hash' unless partner_params.is_a?(Hash)
+
+      %i[user_id job_id job_type].each do |key|
+        if partner_params[key].to_s.empty?
+          raise ArgumentError,
+                "Please make sure that #{key} is included in the partner params"
+        end
+      end
+
+      partner_params
+    end
+
+    def validate_id_info(id_info, required_id_info_fields)
+      raise ArgumentError, 'Please make sure that id_info is not empty or nil' if id_info.nil? || id_info.empty?
+
+      raise ArgumentError, 'Id info needs to be a hash' unless id_info.is_a?(Hash)
+
+      required_id_info_fields.each do |key|
+        raise ArgumentError, "Please make sure that #{key} is included in the id_info" if id_info[key].to_s.empty?
+      end
+
+      id_info
+    end
+  end
+end

data/lib/smile-identity-core/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module SmileIdentityCore
-  VERSION = "1.2.1"
+  VERSION = '2.1.0'
+  SOURCE_SDK = 'Ruby'
 end