mints 0.0.26 → 0.0.28

data/lib/mints/controllers/user_api_controller.rb

@@ -1,89 +1,14 @@
-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 UserAPIController < ActionController::API
         include AbstractController::Helpers
-        include ActionController::Cookies
-        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'
-            }
-            if cookies[:mints_user_session_token]
-                session_token = cookies[:mints_user_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 url_need_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
+        include ReadConfigFile
+        include ProxyControllersMethods
 
-            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'] if config['redis_cache']['use_cache']
-            end
+        def index
+            super('user')
         end
     end
 end

data/lib/mints/helpers/contact_auth_helper.rb

@@ -0,0 +1,67 @@
+module ContactAuthHelper
+  ##
+  # === 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, redirect_in_error = false)
+    # 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'] : '/' if redirect_in_error
+    else
+      redirect_to '/' if redirect_in_error
+    end
+  end
+
+  ##
+  # === 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
+
+  def mints_contact_signed_in?
+
+    begin
+      # Check status in mints
+      # Check status in mints
+      response = @mints_contact.status
+      status = response['success'] || false
+    rescue => e
+      # Handle the client Unauthorized error
+      # if mints response is negative delete the session cookie
+      cookies.delete(:mints_contact_session_token)
+
+      status = false
+    end
+
+    status
+  end
+end

data/lib/{mints_helper.rb → mints/helpers/mints_helper.rb}

@@ -10,9 +10,9 @@ module MintsHelper
     #
     def get_query_results(url, options = nil, use_post = true)
         if use_post
-            return @client.raw("post", "#{url}/query", options)
+            @client.raw('post', "#{url}/query", options)
         else
-            return @client.raw("get", url, options)
+            @client.raw('get', url, options)
         end
     end
 
@@ -24,10 +24,12 @@ module MintsHelper
     #
     def data_transform(data)
         data = correct_json(data)
+
         unless data[:data]
             data = {data: data}
         end
-        return data.to_json
+
+        data.to_json
     end
 
     # === Correct json.
@@ -40,8 +42,8 @@ module MintsHelper
         if data.is_a? String
             data = JSON.parse(data)
         end
-        data = data.symbolize_keys
-        return data
+
+        data.symbolize_keys
     end
 
 end

data/lib/mints/helpers/proxy_controllers_methods.rb

@@ -0,0 +1,126 @@
+require 'redis'
+require 'reverse_proxy/controller'
+require 'reverse_proxy/client'
+
+module ProxyControllersMethods
+  include ActionController::Cookies
+  include ReverseProxy::Controller
+
+  # === Index
+  # Is the base index method for all controllers, manage the headers depending
+  # on the controller type (Contact or User)
+  #
+  # ==== Parameters
+  # controller_type:: (String) -- Controller type that be called, this manages the headers to send (contact, user, pub).
+  # ==== Return
+  # Returns the response returned by send_mints_request
+  #
+  def index(controller_type = nil)
+    headers = {
+      'host' => "#{@host.gsub('http://', '').gsub('https://', '')}",
+      'ApiKey' => "#{@api_key}",
+      'Content-Type'=> 'application/json',
+      'Accept'=> 'application/json'
+    }
+
+    if %w[contact user].include? controller_type
+      session_token = cookies["mints_#{controller_type}_session_token".to_sym]
+      headers["Authorization"] = session_token ? "Bearer #{session_token}" : request.headers["Authorization"]
+    end
+
+    headers['ContactToken'] = cookies[:mints_contact_id] if controller_type === 'contact' and cookies[:mints_contact_id]
+
+    full_url = request.original_url
+    url_need_cache, time = url_need_cache?(full_url)
+
+    if @debug or true
+      puts "URL: #{full_url}"
+      puts "URL need cache: #{url_need_cache}"
+      puts "URL time cache: #{time}"
+      puts "Headers: #{headers}"
+    end
+
+    if url_need_cache
+      cached_response = @redis_server.get(full_url)
+
+      if cached_response
+        puts "RESPONSE FROM CACHE" if @debug
+        return render json: cached_response
+      end
+
+      send_mints_request(full_url, headers, true, time)
+    else
+      send_mints_request(full_url, headers)
+    end
+  end
+
+  # === Url need cache?
+  # Method used to check if the given URL should be cached and for how long
+  #
+  # ==== Parameters
+  # full_url:: (String) -- URL to check if has cache.
+  # ==== Return
+  # Returns if the URL has cache and the time to be cached
+
+  def url_need_cache?(full_url)
+    url_need_cache = false
+    time = 0
+    methods_with_cache = %w[GET]
+
+    if methods_with_cache.include? request.method
+      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
+
+    [url_need_cache, time]
+  end
+
+  # === Send mints request
+  # Method used to make each request to CXF, in addition to verifying and saving
+  # the response in cache for cases where it requires cache
+  #
+  # ==== Parameters
+  # full_url:: (String) -- URL to make the request.
+  # headers::  (Hash|Object) -- Headers to send in the request.
+  # cache_result:: (Boolean) -- This parameter controls whether the response will be cached..
+  # time:: (Integer) -- It is the time that the response will be stored in cache.
+  # ==== Return
+  # Returns the response given by CXF or Redis
+
+  def send_mints_request(full_url, headers, cache_result = false, time = 30)
+    puts "RESPONSE FROM MINTS.CLOUD" if @debug
+
+    reverse_proxy "#{@host}", headers: headers, verify_ssl: false do |config|
+
+      if cache_result
+        # Request succeeded!
+        config.on_response do |code, response|
+          @redis_server.setex(
+            full_url,
+            time || 30,
+            response.body
+          )
+        end
+      end
+
+      # Request failed!
+      config.on_missing do |code, response|
+        # We got a 404!
+        raise ActionController::RoutingError.new('Not Found') if code == 404
+      end
+    end
+  end
+end

data/lib/mints/helpers/user_auth_helper.rb

@@ -0,0 +1,53 @@
+module UserAuthHelper
+
+  def mints_user_signed_in?
+    begin
+      # Check status in mints
+      response = @mints_user.me['data']
+    rescue => e
+      # Handle the client Unauthorized error
+      # if mints response is negative delete the session cookie
+      cookies.delete(:mints_user_session_token)
+      response = nil
+    end
+
+    response
+  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']
+      # 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
+end

data/lib/mints.rb

@@ -7,5 +7,7 @@ require_relative "./mints/controllers/admin_base_controller.rb"
 require_relative "./mints/controllers/public_api_controller.rb"
 require_relative "./mints/controllers/contact_api_controller.rb"
 require_relative "./mints/controllers/user_api_controller.rb"
+require_relative './errors.rb'
+
 module Mints
 end