mints 0.0.26 → 0.0.28

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

data/lib/mints/controllers/contact_api_controller.rb

@@ -1,94 +1,15 @@
-require 'reverse_proxy/controller'
-require 'reverse_proxy/client'
+require_relative "./concerns/read_config_file.rb"
+require_relative "../helpers/proxy_controllers_methods.rb"
+
 module Mints
     class ContactAPIController < ActionController::API
         include AbstractController::Helpers
-        include ActionController::Cookies
         include ReverseProxy::Controller
-        before_action :set_config_variables
+        include ReadConfigFile
+        include ProxyControllersMethods
 
         def index
-            headers = {
-                'host' => "#{@host.gsub('http://', '').gsub('https://', '')}",
-                'ApiKey' => "#{@api_key}", 
-                'Content-Type'=> 'application/json', 
-                'Accept'=> 'application/json'
-            }
-            # Set contact token id as header
-            if cookies[:mints_contact_id]
-                headers['ContactToken'] = cookies[:mints_contact_id]
-            end
-            # Set contact session token as header
-            if cookies[:mints_contact_session_token]
-                session_token = cookies[:mints_contact_session_token]
-                headers["Authorization"] = "Bearer #{session_token}"
-            end            
-            
-            url_need_cache = false
-            result_from_cache = false
-            time = 0
-            full_url = request.original_url
-
-            if request.method == "GET"                
-                if @use_cache
-                    @redis_config['groups'].each do |group|
-                        group['urls'].each do |url|
-                            if full_url.match url
-                                time = group['time']
-                                url_need_cache = true
-                                break
-                            end
-                        end
-                        break if url_need_cache  
-                    end
-                end
-            end
-
-            if url_need_cache
-                if @redis_server.get(full_url)
-                    response = @redis_server.get(full_url)
-                    result_from_cache = true
-                    render json: response
-                else
-                    reverse_proxy "#{@host}", headers: headers, verify_ssl: false do |config|
-                        # Request succeded!
-                        config.on_response do |code, response|
-                            @redis_server.setex(full_url,time,response.body)
-                        end
-                        # Request failed!
-                        config.on_missing do |code, response|
-                            # We got a 404!
-                            if code == 404
-                                raise ActionController::RoutingError.new('Not Found')
-                            end
-                        end
-                    end
-                end
-            else
-                reverse_proxy "#{@host}", headers: headers, verify_ssl: false do |config|
-                    # Request failed!
-                    config.on_missing do |code, response|
-                        # We got a 404!
-                        if code == 404
-                            raise ActionController::RoutingError.new('Not Found')
-                        end
-                    end
-                end
-            end
-        end    
-        
-        private
-
-        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.load template.result(binding)
-                @host = config["mints"]["host"]
-                @api_key = config["mints"]["api_key"]     
-                @redis_server = Redis.new(host: config['redis_cache']['redis_host'], port: config['redis_cache']['redis_port'] ? config['redis_cache']['redis_port'] : 6379, db: config['redis_cache']['redis_db'] ? config['redis_cache']['redis_db'] : 1) if config['redis_cache']['use_cache']
-                @redis_config = config['redis_cache']
-                @use_cache = config['redis_cache']['use_cache'] 
-            end
+            super('contact')
         end
     end
 end

data/lib/mints/controllers/public_api_controller.rb

@@ -1,85 +1,12 @@
-require 'reverse_proxy/controller'
-require 'reverse_proxy/client'
-require 'redis'
+require_relative "./concerns/read_config_file.rb"
+require_relative "../helpers/proxy_controllers_methods.rb"
+
 module Mints
     class PublicAPIController < ActionController::API
         include ReverseProxy::Controller
-        before_action :set_config_variables
-
-        def index
-            headers = {
-                'host' => "#{@host.gsub('http://', '').gsub('https://', '')}",
-                'ApiKey' => "#{@api_key}", 
-                'Content-Type'=> 'application/json', 
-                'Accept'=> 'application/json' 
-            }
-            
-            url_need_cache = false
-            result_from_cache = false
-            time = 0
-            full_url = request.original_url
-
-            if request.method == "GET"
-                if @use_cache
-                    @redis_config['groups'].each do |group|
-                        group['urls'].each do |url|
-                            if full_url.match url
-                                time = group['time']
-                                url_need_cache = true
-                                break
-                            end
-                        end
-                        break if url_need_cache  
-                    end
-                end                
-            end
-
-            if url_need_cache
-                if @redis_server.get(full_url)
-                    response = @redis_server.get(full_url)
-                    result_from_cache = true
-                    render json: response
-                else 
-                    reverse_proxy "#{@host}", headers: headers, verify_ssl: false do |config|
-                        # Request succeded!
-                        config.on_response do |code, response|
-                            @redis_server.setex(full_url,time,response.body)
-                        end
-                        # Request failed!
-                        config.on_missing do |code, response|
-                            # We got a 404!
-                            if code == 404
-                                raise ActionController::RoutingError.new('Not Found')
-                            end
-                        end
-                    end
-                end
-            else
-                reverse_proxy "#{@host}", headers: headers, verify_ssl: false do |config|
-                    # Request failed!
-                    config.on_missing do |code, response|
-                        # We got a 404!
-                        if code == 404
-                            raise ActionController::RoutingError.new('Not Found')
-                        end
-                    end
-                end
-            end
-            
-        end    
-        
-        private
+        include AbstractController::Helpers
+        include ReadConfigFile
+        include ProxyControllersMethods
 
-        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.load template.result(binding)
-                @host = config["mints"]["host"]
-                @api_key = config["mints"]["api_key"]                
-                @redis_server = Redis.new(host: config['redis_cache']['redis_host'], port: config['redis_cache']['redis_port'] ? config['redis_cache']['redis_port'] : 6379, db: config['redis_cache']['redis_db'] ? config['redis_cache']['redis_db'] : 1) if config['redis_cache']['use_cache']
-                @redis_config = config['redis_cache']
-                @use_cache = config['redis_cache']['use_cache'] 
-            end
-        end
     end
 end