mints 0.0.25 → 0.0.27

data/lib/errors.rb

@@ -0,0 +1,98 @@
+module Mints
+
+  module Errors
+
+    class NonSupportedRubyVersionError < RuntimeError; end
+
+    class DynamicError < RuntimeError
+      ERRORS = {
+        '401' => 'AccessDeniedException',
+        '404' => 'ResourceNotFoundException',
+        '422' => 'ValidationException',
+        '405' => 'MethodNotAllowed',
+        'default' => 'InternalServerException',
+      }
+
+      def initialize(client, title, detail, http_status, response)
+        @http_status = http_status
+        @error = error_class.constantize&.new(client, title, detail, http_status, response)
+      end
+
+      attr_reader :error, :http_status
+
+      def to_s
+        error_class
+      end
+
+      private
+
+      def error_class
+        "Mints::Errors::#{ERRORS[http_status.to_s] || ERRORS['default']}"
+      end
+    end
+
+    class ServiceError < RuntimeError
+      # @param [Client] client
+      # @param [String] title
+      # @param [String] detail
+      # @param [Integer] http_status
+      # @param [String Object Array] response
+      def initialize(client, title, detail, http_status, response)
+        @title = title
+        @client = client
+        @response = response
+        @http_status = http_status
+        @detail = detail && !detail.empty? ? detail : self.class.to_s
+
+        super(@detail)
+      end
+
+      # @return [String]
+      def detail
+        @detail
+      end
+
+      def to_h(extra_fields = {})
+        default_fields = {
+          client: client,
+          title: title,
+          detail: detail,
+          http_status: http_status,
+          response: response
+        }
+
+        default_fields.merge(extra_fields)
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      attr_reader :client, :detail, :title, :http_status, :response
+    end
+
+    class AccessDeniedException < ServiceError; end
+
+    class ResourceNotFoundException < ServiceError; end
+
+    class MethodNotAllowed < ServiceError; end
+
+    class ValidationException < ServiceError
+
+      def to_h
+        super(errors_hash)
+      end
+
+      def errors_hash
+        {
+          errors: response.keys.reduce([]) {|carry, error_key| carry + response[error_key]}
+        }
+      end
+
+      attr_reader :failed_validations
+    end
+
+    class InternalServerException < ServiceError; end
+
+  end
+end

data/lib/mints/controllers/admin_base_controller.rb

@@ -1,73 +1,15 @@
+require_relative "./concerns/mints_clients.rb"
+require_relative "../helpers/user_auth_helper.rb"
+
 module Mints
   class AdminBaseController < ActionController::Base
-    before_action :set_mints_user_client
-
-    def mints_user_signed_in?
-        # Check status in mints
-        response = @mints_user.me
-        status = response['data'] ? true : false
-        unless status
-          # if mints response is negative delete the session cookie
-          #cookies.delete(:mints_user_session_token)
-        end
-        return status
-    end
-
-    ##
-    # === Mints user Login.
-    # Starts a user session in mints.cloud and set a session cookie
-    def mints_user_login(email, password)
-        # Login in mints
-        response = @mints_user.login(email, password)
-        # Get session token from response
-        session_token = response['api_token']
-        # Set a permanent cookie with the session token
-        cookies[:mints_user_session_token] = { value: session_token, secure: true, httponly: true, expires: 1.day }
-    end
-
-    ##
-    # === Mints user Login.
-    # Starts a user session in mints.cloud and set a session cookie
-    def mints_user_magic_link_login(hash)
-      # Login in mints
-      response = @mints_user.magic_link_login(hash)
-      if response['data'] && response['data']['redirect_url']
-        # Set a cookie with the session token
-        cookies[:mints_user_session_token] = { value: response['data']['api_token'], expires: 1.day, secure: true, httponly: true }
-        redirect_to response['data']['redirect_url']
-      else
-        redirect_to '/'
-      end
-    end
 
-    ##
-    # === Mints user Logout.
-    # Destroy session from mints.cloud and delete local session cookie
-    def mints_user_logout
-        # Logout from mints
-        # @mints_user.logout
-        # Delete local cookie
-        cookies.delete(:mints_user_session_token)
-    end
-    
-    private
+    include MintsClients
+    include UserAuthHelper
 
-    ##
-    # === Set Mints user client.
-    # Initialize the public client and set the user token
-    def set_mints_user_client
-      if File.exists?("#{Rails.root}/mints_config.yml.erb")
-        template = ERB.new File.new("#{Rails.root}/mints_config.yml.erb").read
-        config = YAML.load template.result(binding)
-        @host = config["mints"]["host"]
-        @api_key = config["mints"]["api_key"]
-        @debug = config["sdk"]["debug"] ? config["sdk"]["debug"] : false
-      else
-        raise 'MintsBadCredentialsError'
-      end
-      # Initialize mints user client
-      session_token = cookies[:mints_user_session_token] ? cookies[:mints_user_session_token] : nil
-      @mints_user = Mints::User.new(@host, @api_key, session_token, @debug)
+    # Override default values for mints clients concern
+    def define_mints_clients
+      %w[ user service_account ]
     end
   end
 end

data/lib/mints/controllers/base_api_controller.rb

@@ -1,144 +1,26 @@
+require_relative "./concerns/mints_clients.rb"
+require_relative "../helpers/user_auth_helper.rb"
+require_relative "../helpers/contact_auth_helper.rb"
+
 module Mints
   class BaseApiController < ActionController::Base
-    before_action :set_mints_clients
-
-    ##
-    # === Mints Contact Login.
-    # Starts a contact session in mints.cloud and set a session cookie
-    def mints_contact_login(email, password)
-        # Login in mints
-        response = @mints_contact.login(email, password)
-        # Get session token from response
-        session_token = response['session_token']
-        id_token = response['contact']['contact_token'] ? response['contact']['contact_token'] : response['contact']['id_token']
-        # Set a permanent cookie with the session token
-        cookies.permanent[:mints_contact_session_token] = { value: session_token, secure: true, httponly: true }
-        cookies.permanent[:mints_contact_id] = { value: id_token, secure: true, httponly: true }
-        @contact_token = id_token
-      end
-      
-    ##
-    # === Mints contact Login.
-    # Starts a contact session in mints.cloud and set a session cookie
-    def mints_contact_magic_link_login(hash)
-      # Login in mints
-      response = @mints_contact.magic_link_login(hash)
-      if response['data']
-        # Get session token from response
-        session_token = response['data']['session_token']
-        id_token = response['data']['contact']['contact_token'] ? response['data']['contact']['contact_token'] : response['data']['contact']['id_token']
-        # Set a permanent cookie with the session token
-        cookies.permanent[:mints_contact_session_token] = { value: session_token, secure: true, httponly: true }
-        cookies.permanent[:mints_contact_id] = { value: id_token, secure: true, httponly: true }
-        @contact_token = id_token
-        redirect_to response['data']['redirect_url'] ? response['data']['redirect_url'] : '/'
-      else
-        redirect_to '/'
-      end
-    end
+    # Concerns
+    include MintsClients
 
-    ##
-    # === Mints Contact Logout.
-    # Destroy session from mints.cloud and delete local session cookie
-    def mints_contact_logout
-        # Logout from mints
-        @mints_contact.logout
-        # Delete local cookie
-        cookies.delete(:mints_contact_session_token)
-        cookies.delete(:mints_contact_id)
-        @contact_token = nil
-    end
+    # Helpers
+    include ContactAuthHelper
+    include UserAuthHelper
 
-    ##
-    # === Mints user Login.
-    # Starts a user session in mints.cloud and set a session cookie
-    def mints_user_login(email, password)
-      # Login in mints
-      response = @mints_user.login(email, password)
-      # Get session token from response
-      session_token = response['api_token']
-      # Set a permanent cookie with the session token
-      cookies[:mints_user_session_token] = { value: session_token, secure: true, httponly: true, expires: 1.day }
+    def define_mints_clients
+      %w[ contact pub ]
     end
 
     ##
-    # === Mints user Login.
-    # Starts a user session in mints.cloud and set a session cookie
-    def mints_user_magic_link_login(hash)
-      # Login in mints
-      response = @mints_user.magic_link_login(hash)
-      if response['data']
-        # Set a cookie with the session token
-        cookies[:mints_user_session_token] = { value: response['data']['api_token'], secure: true, httponly: true,  expires: 1.day }
-        redirect_to response['data']['redirect_url'] ? response['data']['redirect_url'] : '/'
-      else
-        redirect_to '/'
-      end
-    end
-
-    ##
-    # === Mints user Logout.
-    # Destroy session from mints.cloud and delete local session cookie
-    def mints_user_logout
-      # Logout from mints
-      # @mints_user.logout
-      # Delete local cookie
-      cookies.delete(:mints_user_session_token)
-    end
-    
-    private
-
-    ##
-    # === Set mints clients (pub, user and contact)
-    # Initialize all clients from mitns
-    def set_mints_clients
-      if File.exists?("#{Rails.root}/mints_config.yml.erb")
-        template = ERB.new File.new("#{Rails.root}/mints_config.yml.erb").read
-        config = YAML.load template.result(binding)
-        @host = config["mints"]["host"]
-        @api_key = config["mints"]["api_key"]
-        @debug = config["sdk"]["debug"] ? config["sdk"]["debug"] : false
-
-        #public client
-        set_mints_pub_client
-        #contact client
-        set_mints_contact_client
-        #user client
-        set_mints_user_client
-      else
-        raise 'MintsBadCredentialsError'
-      end
-    end
-
-    ##
-    # === Set mints pub.
-    # Initialize the public client and set the contact token
-    def set_mints_pub_client
-      
-      # Initialize mints pub client, credentials taken from mints_config.yml.erb file
-      @visit_id = cookies[:mints_visit_id] ? cookies[:mints_visit_id] : nil
-      @mints_pub = Mints::Pub.new(@host, @api_key, nil, @visit_id, @debug)
-      # Set contact token from cookie
-      @mints_pub.client.session_token = @contact_token
-    end
-
-    ##
-    # === Set mints contact client.
-    # Initialize the public client and set the contact token
-    def set_mints_contact_client
-      # Initialize mints clontact client
-      session_token = cookies[:mints_contact_session_token] ? cookies[:mints_contact_session_token] : nil
-      contact_token_id = cookies[:mints_contact_id] ? cookies[:mints_contact_id] : nil
-      @mints_contact = Mints::Contact.new(@host, @api_key, session_token, contact_token_id, @debug)
-    end
-    
-    ##
-    # === Set Mints user client.
-    # Initialize the public client and set the user token
-    def set_mints_user_client
-      # Initialize mints user client
-      session_token = cookies[:mints_user_session_token] ? cookies[:mints_user_session_token] : nil
-      @mints_user = Mints::User.new(@host, @api_key, session_token, @debug)
+    # === Mints contact Login.
+    # This method works to override the base to add the redirect parameter
+    # The main method is located in contact_auth_helper.rb
+    def mints_contact_magic_link_login(hash)
+      super(hash, true)
     end
   end
 end

data/lib/mints/controllers/base_controller.rb

@@ -1,63 +1,21 @@
+require_relative "./concerns/mints_clients.rb"
+require_relative "../helpers/contact_auth_helper.rb"
+
 module Mints
   class BaseController < ActionController::Base
-    before_action :set_contact_token
-    before_action :set_mints_pub_client
-    before_action :register_visit
-    before_action :set_mints_contact_client
-
-    def mints_contact_signed_in?
-        # Check status in mints
-        response = @mints_contact.status
-        status = response['success'] ? response['success'] : false
-        unless status
-          # if mints response is negative delete the session cookie
-          cookies.delete(:mints_contact_session_token)
-        end
-        return status
-    end
+    # Concerns
+    include MintsClients
 
-    ##
-    # === Mints Contact Login.
-    # Starts a contact session in mints.cloud and set a session cookie
-    def mints_contact_login(email, password)
-        # Login in mints
-        response = @mints_contact.login(email, password)
-        # Get session token from response
-        session_token = response['session_token']
-        id_token = response['contact']['contact_token'] ? response['contact']['contact_token'] : response['contact']['id_token']
-        # Set a permanent cookie with the session token
-        cookies.permanent[:mints_contact_session_token] = { value: session_token, secure: true, httponly: true }
-        cookies.permanent[:mints_contact_id] = { value: id_token, secure: true, httponly: true }
-        @contact_token = id_token
-    end
+    # Helpers
+    include ContactAuthHelper
 
-    ##
-    # === Mints Contact Magic Link Login.
-    # Starts a contact session in mints.cloud and set a session cookie
-    def mints_contact_magic_link_login(token)
-      # Login in mints
-      response = @mints_contact.login(email, password)
-      # Get session token from response
-      session_token = response['session_token']
-      id_token = response['contact']['contact_token'] ? response['contact']['contact_token'] : response['contact']['id_token']
-      # Set a permanent cookie with the session token
-      cookies.permanent[:mints_contact_session_token] = { value: session_token, secure: true, httponly: true }
-      cookies.permanent[:mints_contact_id] = { value: id_token, secure: true, httponly: true }
-      @contact_token = id_token
-  end
+    before_action :register_visit
 
-    ##
-    # === Mints Contact Logout.
-    # Destroy session from mints.cloud and delete local session cookie
-    def mints_contact_logout
-        # Logout from mints
-        @mints_contact.logout
-        # Delete local cookie
-        cookies.delete(:mints_contact_session_token)
-        cookies.delete(:mints_contact_id)
-        @contact_token = nil
+    # Override default values for mints clients concern
+    def define_mints_clients
+      %w[ contact pub ]
     end
-    
+
     private
 
     ##
@@ -76,63 +34,19 @@ module Mints
         puts "REQUEST IP ADDRESS: #{request['ip_address']}"
         puts "REQUEST REMOTE IP: #{request['remote_ip']}"
       end
+
       response = @mints_pub.register_visit(request)
-      if @debug
-        puts "RESPONSE IN REGISTER VISIT: #{response}"
-      end
-      @contact_token = response['contact_token'] ? response['contact_token'] : response['user_token']
+
+      puts "RESPONSE IN REGISTER VISIT: #{response}" if @debug
+
+      @contact_token = response['contact_token'] || response['user_token']
       @visit_id = response['visit_id']
-      if @debug
-        puts "VISIT ID: #{@visit_id}"
-      end
-      cookies.permanent[:mints_contact_id] = { value: @contact_token, secure: true, httponly: true }
-      cookies.permanent[:mints_visit_id] = { value: @visit_id, secure: true, httponly: true }
-    end
 
-    ##
-    # === Set mints pub.
-    # Initialize the public client and set the contact token
-    def set_mints_pub_client
-      if File.exists?("#{Rails.root}/mints_config.yml.erb")
-        template = ERB.new File.new("#{Rails.root}/mints_config.yml.erb").read
-        config = YAML.load template.result(binding)
-        @host = config["mints"]["host"]
-        @api_key = config["mints"]["api_key"]
-        @debug = config["sdk"]["debug"] ? config["sdk"]["debug"] : false
-      else
-        raise 'MintsBadCredentialsError'
-      end
-      # Initialize mints pub client, credentials taken from mints_config.yml.erb file
-      @visit_id = cookies[:mints_visit_id] ? cookies[:mints_visit_id] : nil
-      @mints_pub = Mints::Pub.new(@host, @api_key, @contact_token, @visit_id, @debug)
-      # Set contact token from cookie
-      @mints_pub.client.session_token = @contact_token
-    end
+      puts "VISIT ID: #{@visit_id}" if @debug
 
-    ##
-    # === Set contact token.
-    # Set contact token variable from the mints_contact_id cookie value
-    def set_contact_token
-      @contact_token = cookies[:mints_contact_id]
+      cookies.permanent[:mints_contact_id] = { value: @contact_token, secure: true, httponly: true }
+      cookies.permanent[:mints_visit_id] = { value: @visit_id, secure: true, httponly: true }
     end
 
-    ##
-    # === Set mints contact client.
-    # Initialize the public client and set the contact token
-    def set_mints_contact_client
-      if File.exists?("#{Rails.root}/mints_config.yml.erb")
-        template = ERB.new File.new("#{Rails.root}/mints_config.yml.erb").read
-        config = YAML.load template.result(binding)
-        @host = config["mints"]["host"]
-        @api_key = config["mints"]["api_key"]
-        @debug = config["sdk"]["debug"] ? config["sdk"]["debug"] : false
-      else
-        raise 'MintsBadCredentialsError'
-      end
-      # Initialize mints clontact client
-      session_token = cookies[:mints_contact_session_token] ? cookies[:mints_contact_session_token] : nil
-      contact_token_id = cookies[:mints_contact_id] ? cookies[:mints_contact_id] : nil
-      @mints_contact = Mints::Contact.new(@host, @api_key, session_token, contact_token_id, @debug)
-    end
   end
 end

data/lib/mints/controllers/concerns/mints_clients.rb

@@ -0,0 +1,74 @@
+require_relative "./read_config_file.rb"
+
+module MintsClients
+  extend ActiveSupport::Concern
+
+  included do
+    include ReadConfigFile
+    before_action :set_mints_clients
+  end
+
+  # Define the clients that will have
+  # Override in the controller if you dont wanna all clients
+  def define_mints_clients
+    %w[ contact user pub service_account ]
+  end
+
+  private
+
+  ##
+  # === Set mints clients (pub, user and contact)
+  # Initialize all clients from mints
+  def set_mints_clients
+    clients = define_mints_clients
+
+    if @debug
+      puts "Clients to initialize:", clients
+      puts "Host:", @host
+    end
+
+    if clients.kind_of?(Array) and @host
+      clients.each do |client|
+        send("set_mints_#{client}_client")
+      end
+    end
+  end
+
+  ##
+  # === Set mints pub.
+  # Initialize the public client and set the contact token
+  def set_mints_pub_client
+    # Initialize mints pub client, credentials taken from mints_config.yml.erb file
+    visit_id = cookies[:mints_visit_id]
+    contact_token_id = cookies[:mints_contact_id]
+
+    @mints_pub = Mints::Pub.new(@host, @api_key, contact_token_id, visit_id, @debug)
+  end
+
+  ##
+  # === Set mints contact client.
+  # Initialize the contact client and set the contact token
+  def set_mints_contact_client
+    # Initialize mints contact client
+    contact_session_token = cookies[:mints_contact_session_token]
+    contact_token_id = cookies[:mints_contact_id]
+    @mints_contact = Mints::Contact.new(@host, @api_key, contact_session_token, contact_token_id, @debug)
+  end
+
+  ##
+  # === Set Mints user client.
+  # Initialize the user client
+  def set_mints_user_client
+    # Initialize mints user client
+    user_session_token = cookies[:mints_user_session_token]
+    @mints_user = Mints::User.new(@host, @api_key, user_session_token, @debug)
+  end
+
+  ##
+  # === Set Mints service account
+  # Initialize the service account client
+  def set_mints_service_account_client
+    # Initialize service account client
+    @mints_service_account = Mints::User.new(@host, @api_key, @api_key, @debug)
+  end
+end

data/lib/mints/controllers/concerns/read_config_file.rb

@@ -0,0 +1,28 @@
+module ReadConfigFile
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_config_variables
+  end
+
+  def set_config_variables
+    if File.exists?("#{Rails.root}/mints_config.yml.erb")
+
+      template = ERB.new File.new("#{Rails.root}/mints_config.yml.erb").read
+      config = YAML.safe_load template.result(binding)
+      @host = config["mints"]["host"]
+      @api_key = config["mints"]["api_key"]
+      @debug = !!config["sdk"]["debug"]
+      @redis_config = config['redis_cache']
+      @use_cache = config['redis_cache']['use_cache']
+
+      if config['redis_cache']['use_cache']
+        @redis_server = Redis.new(
+          host: config['redis_cache']['redis_host'],
+          port: config['redis_cache']['redis_port'] || 6379,
+          db: config['redis_cache']['redis_db'] || 1
+        )
+      end
+    end
+  end
+end