ecertic 0.1.0

data/lib/ecertic/api/documents_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module API
+    class DocumentsService < Service
+      def pdf(document_id, options = {})
+        client.get("/pdf/#{document_id}/0", options)
+      end
+
+      def html(document_id, options = {})
+        client.get("/html/#{document_id}/0", options)
+      end
+
+      def signed(document_id, options = {})
+        client.get("/signed/#{document_id}/0", options)
+      end
+    end
+  end
+end

data/lib/ecertic/api/otps_service.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module API
+    class OTPsService < Service
+      def create(attributes, options = {})
+        Ecertic::Utils.validate_mandatory_attributes(attributes, [:movil, :pdf_files])
+        attributes[:pdf_files] = Utils.encode_files(attributes[:pdf_files])
+        response = client.post("/sms", attributes, options)
+        Resource::OTP::Request.new(response.body)
+      end
+
+      def status(token, options = {})
+        attributes = { token: token }
+        response = client.post("/status", attributes, options)
+        Resource::OTP::Status.new(response.body)
+      end
+    end
+  end
+end

data/lib/ecertic/api/service.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module API
+    class Service
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+    end
+  end
+end

data/lib/ecertic/api/tokens_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module API
+    class TokensService < Service
+      def retrieve(token, options = {})
+        attributes = { token: token }
+        response = client.post("/token", attributes, options)
+        Resource::Token::Instance.new(response.body)
+      end
+
+      def validate(token, otp, options = {})
+        attributes = { token: token, otp: otp }
+        response = client.post("/validate", attributes, options)
+        Resource::Token::Validation.new(response.body)
+      end
+    end
+  end
+end

data/lib/ecertic/callback.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Callback
+    def self.parse(payload)
+      raise "IMPLEMENT THIS"
+    end
+  end
+  module Signature
+    def self.decrypt(payload)
+      raise "IMPLEMENT THIS"
+    end
+  end
+end

data/lib/ecertic/client.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Ecertic
+  class Client
+    include Ecertic::API
+    attr_accessor :apikey, :secret, :user_agent, :connection
+
+    def initialize(options = {})
+      defaults = Ecertic::Default.options
+      Ecertic::Default.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || defaults[key])
+      end
+      @connection = connection || self.class.default_connection
+      @services = {}
+    end
+
+    def self.default_connection
+      Thread.current[:ecertic_client_default_connection] ||= begin
+        Faraday.new do |builder|
+          builder.use Faraday::Response::RaiseError
+          builder.response :json,
+                           content_type: /\bjson$/,
+                           preserve_raw: true, parser_options: { symbolize_names: true }
+          builder.adapter :net_http_persistent
+        end
+      end
+    end
+
+    def base_url
+      @base_url.chomp("/")
+    end
+
+    def get(path, options = {})
+      execute :get, path, nil, options.to_h
+    end
+
+    def post(path, data = nil, options = {})
+      execute :post, path, data, options
+    end
+
+    def execute(method, path, data = nil, options = {})
+      request(method, path, data, options)
+    end
+
+    def request(method, path, data = nil, options = {})
+      request_options = request_options(method, options, data)
+      uri = "#{base_url}#{path}"
+
+      begin
+        request_start = Time.now
+        log_request(method, path, request_options[:body], request_options[:headers])
+        response = connection.run_request(method, uri, request_options[:body], request_options[:headers]) do |req|
+          # req.options.open_timeout = Ecertic.open_timeout
+          # req.options.timeout =  Ecertic.read_timeout
+        end
+        log_response(request_start, method, path, response.status, response.body)
+        response
+      rescue StandardError => e
+        log_response_error(request_start, e, method, path)
+        case e
+        when Faraday::ClientError
+          if e.response
+            handle_error_response(e.response)
+          else
+            handle_network_error(e)
+          end
+        else
+          raise
+        end
+      end
+      Ecertic::Response.from_faraday_response(response)
+    end
+
+    private def handle_network_error(error)
+      Ecertic::Utils.log_error("Ecertic network error", error_message: error.message)
+
+      message = case error
+                when Faraday::ConnectionFailed
+                  "Unexpected error communicating when trying to connect to " \
+                  "Ecertic. You may be seeing this message because your DNS is not " \
+                  "working. To check, try running `host http://api.otpsecure.net` from the " \
+                  "command line."
+
+                when Faraday::SSLError
+                  "Could not establish a secure connection to Ecertic, you " \
+                  "may need to upgrade your OpenSSL version. To check, try running " \
+                  "`openssl s_client -connect api.otpsecure.net:443` from the command " \
+                  "line."
+
+                when Faraday::TimeoutError
+                  "Could not connect to Ecertic (#{ Ecertic.api_base}). " \
+                  "Please check your internet connection and try again."
+
+                else
+                  "Unexpected error communicating with Ecertic."
+                end
+      raise APIConnectionError, message + "\n\n(Network error: #{error.message})"
+    end
+
+    private def handle_error_response(http_response)
+      begin
+        response = Ecertic::Response.new(http_response)
+      rescue JSON::ParserError
+        raise general_api_error(http_response[:status], http_response[:body])
+      end
+
+      raise specific_api_error(response)
+    end
+
+    private def general_api_error(status, body)
+      APIError.new("Invalid response object from API: #{body.inspect} " \
+                   "(HTTP response code was #{status})",
+                   http_status: status, http_body: body)
+    end
+
+    private def specific_api_error(response)
+      Ecertic::Utils.log_error("Ecertic API error", status: response.status)
+
+      error = case response.status
+              when 400, 404
+                InvalidRequestError
+              when 401
+                AuthenticationError
+              else
+                APIError
+              end
+      error.new(response.body, response: response)
+    end
+
+    private def base_options
+      {
+        headers: {
+          "Accept" => "application/json",
+          "User-Agent" => format_user_agent,
+        },
+      }
+    end
+
+    private def request_options(method, options = {}, data = nil)
+      base_options.tap do |options|
+        add_body!(options, data) if data
+        add_auth_options!(method, options, data) if data
+      end
+    end
+
+    private def add_body!(options, data)
+      options[:headers]["Content-Type"] = content_type(options[:headers])
+      options[:body] = content_data(options[:headers], data)
+    end
+
+    private def add_auth_options!(method, options, data)
+      timestamp = (Time.now.to_f * 1000).to_i.to_s
+      hmac = hmac(method, timestamp, options[:body], options[:headers]["Content-Type"])
+      options[:headers]["Date"] = timestamp
+      options[:headers]["Authorization"] = "Hmac #{apikey}:#{hmac}"
+    end
+
+    private def hmac(method, timestamp, data, content_type)
+      md5 = Digest::MD5.hexdigest(data)
+      signature = "#{method.upcase}\n#{md5}\n#{content_type}\n#{timestamp}"
+      OpenSSL::HMAC.hexdigest("SHA1", secret, signature)
+    end
+
+    private def format_user_agent
+      if user_agent.to_s.empty?
+        Ecertic::Default::USER_AGENT
+      else
+        "#{Ecertic::Default::USER_AGENT} #{user_agent}"
+      end
+    end
+
+    private def content_type(headers)
+      headers["Content-Type"] || "application/json"
+    end
+
+    private def content_data(headers, data)
+      headers["Content-Type"] == "application/json" ? data.to_json : data
+    end
+
+    private def log_request(method, path, body, headers)
+      Ecertic::Utils.log_info("Request to Ecertic API", method: method, path: path)
+      Ecertic::Utils.log_debug("Request details", body: body, headers: headers)
+    end
+
+    private def log_response(request_start, method, path, status, body)
+      Ecertic::Utils.log_info("Response from Ecertic API",
+                              elapsed: Time.now - request_start,
+                              method: method,
+                              path: path,
+                              status: status)
+      Ecertic::Utils.log_debug("Response details", body: body)
+    end
+
+    private def log_response_error(request_start, error, method, path)
+      Ecertic::Utils.log_error("Request error",
+                               elapsed: Time.now - request_start,
+                               error_message: error.message,
+                               method: method,
+                               path: path)
+    end
+  end
+end

data/lib/ecertic/default.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Default
+    BASE_URL = "https://api.otpsecure.net"
+    USER_AGENT = "ecertic-ruby/#{VERSION}"
+
+    class << self
+      def keys
+        @keys ||= [ :base_url, :apikey, :secret, :user_agent ]
+      end
+
+      def options
+        Hash[keys.map { |key| [key, send(key)] }]
+      end
+
+      def base_url
+        ENV["ECERTIC_BASE_URL"] || BASE_URL
+      end
+
+      def apikey
+        ENV["ECERTIC_APIKEY"]
+      end
+
+      def secret
+        ENV["ECERTIC_SECRET"]
+      end
+
+      def user_agent
+        ENV["ECERTIC_USER_AGENT"]
+      end
+    end
+  end
+end

data/lib/ecertic/errors.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ecertic
+  # Error is the base error from which all other more specific Ecertic errors derive.
+  class Error < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_headers
+    attr_reader :http_body
+    attr_reader :response
+
+    def initialize(message = nil, http_status: nil, http_headers: nil, http_body: nil, response: nil)
+      @message = message
+      @http_status = http_status || response&.status
+      @http_headers = http_headers || response&.headers
+      @http_body = http_body || response&.body
+      @response = response
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+
+  # InvalidRequestError is raised when a request is initiated with invalid parameters.
+  class InvalidRequestError < Error
+  end
+
+  # AuthenticationError is raised when invalid credentials are used to connect Ecertic's servers.
+  class AuthenticationError < Error
+  end
+
+  # APIConnectionError is raised in the event that the SDK can't connect to Ecertic's servers.
+  class APIConnectionError < Error
+  end
+
+  # SignatureVerificationError is raised when the decryption for a callback fails
+  class SignatureVerificationError < Error
+  end
+
+  # APIError is a generic error that may be raised in cases where none of the ther named errors cover the problem.
+  class APIError < Error
+  end
+end

data/lib/ecertic/resources/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Resource
+    class Base
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          m = "#{key}=".to_sym
+          send(m, value) if respond_to?(m)
+        end
+      end
+    end
+  end
+end

data/lib/ecertic/resources/document.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Resource
+    class Document < Base
+    end
+  end
+end

data/lib/ecertic/resources/otp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Resource
+    class OTP < Base
+      attr_accessor :id
+      attr_accessor :customid
+      attr_accessor :clientToken
+      attr_accessor :pdf_shortUrl
+      attr_accessor :html_shortUrl
+    end
+  end
+end

data/lib/ecertic/resources/otp/request.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Resource
+    module OTP
+      class Request < Base
+        attr_accessor :id
+        attr_accessor :customid
+        attr_accessor :clientOtp
+        attr_accessor :clientToken
+        attr_accessor :pdf_shortUrl
+        attr_accessor :html_shortUrl
+        alias uuid id
+        alias otp clientOtp
+        alias token clientToken
+        alias pdf_url pdf_shortUrl
+        alias html_url html_shortUrl
+      end
+    end
+  end
+end

data/lib/ecertic/resources/otp/status.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ecertic
+  module Resource
+    module OTP
+      class Status < Base
+        include Statusable
+      end
+    end
+  end
+end