mints 0.0.4 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef89ee973a9cb2bf2e4b77ad15e3481f7fc02e566f47099c7c44b94bdd3cb757
-  data.tar.gz: d40cf8e0445ce333ad735403f767622cc6428b7ab4f334040a542b0340d4eb49
+  metadata.gz: 91ef0909fa4361a6a3644378c438c64341bfbf31bc6d9ef7f0ed178bd35b5dac
+  data.tar.gz: 0a4c5c14a4550ac56917259ecc822d9afbe779e95507f9607c9248ce19c53caa
 SHA512:
-  metadata.gz: d8c404e2894b99bdb95a5db340ca9f47785cfec00fa6c3648b29a9b1c00e65a4a02569ccfdd5086e1911e468c942e93db214d21d2ac11c219934c66d9d3e9478
-  data.tar.gz: 2c24fc60a2cd29d377bd445cee14fbd611ddc728155eb7e3f2c545eec203100a64254b09e981128f28849dc7a95c1bded45bd592ebe67af3ed794f6e0b786809
+  metadata.gz: 1df0f3a2b3f2ff3c27a61221fab855138508991a0ea552e1111f15df723473e5eeb3ec8c46650aa1670bc00bef8242424fd88e20d90c729d12deac15d25453a4
+  data.tar.gz: c9fb8c066bdcb38237d394bcef4d155bd8bcc29ac3f19b1f4adb905b7483b678c1dbb1625ba8b31be6cada2b565c465f3da3a1d0e6f62cae50c7cfcbc0bfcf44

data/Gemfile

@@ -2,4 +2,6 @@ source :rubygems
 
 gem 'json'
 gem 'httparty'
-gem 'addressable'
+gem 'addressable'
+gem 'rails-reverse-proxy', '~> 0.9.1'
+gem 'redis'

data/Readme.md

@@ -29,18 +29,56 @@ con = Mints::User.new(mints_url, api_key)
 con.login(email, password)
 con.get_contacts
 ```
+## Generate mints files
+This command will generate the mints_config.yml file, API controlles and routes to have available the mints endpoints
+```bash
+rails generate mints_files
+```
 ## Contact tracking usage
-Your app controller need to be inherited from Mints::BaseController
+Your app controller needs to be inherited from Mints::BaseController
 ```ruby
 # application_controller.rb
 
 class ApplicationController < Mints::BaseController
 end
 ```
-This controller will make the following class variables available:
+This heritance will make the following class variables available:
+
+| Variable        | Description                                                                          |
+|   ---           |    :---:                                                                             |
+| @host           | Host defined in mints_config.yml file                                                |
+| @api_key        | API key defined in mints_config.yml file                                             |
+| @mints_pub      | An already instanced public client                                                   |
+| @contact_token  | A token used by mints to identify the contact                                        |
+| @visit_id       | An identifier of the visit registered                                                |
+| @mints_contact  | An already instanced contact client (not usable until call the contact login method) |
+
+And the following controller methods:
+| Method                    | Parameters     | Return value | Description                                    |
+|   ---                     |   :---:        |   :---:      | :---:                                          |
+| mints_contact_signed_in?  | none           | boolean      | Indicates if the contact has an active session |
+| mints_contact_login       | email, password| void         | Starts a contact session                       |
+| mints_contact_logout      | none           | void         | Ends a contact session                         |
+
+## Admin controller usage
+If want to have a private section where only a mints user can acces and use the private user api is needed to inherit from the AdminBaseController.
+
+```ruby
+# admin_controller.rb
+
+class AdminController < Mints::AdminBaseController
+end
+```
+
+This heritance will make the following class variables available:
+| Variable        | Description                                                                          |
+|   ---           |    :---:                                                                             |
+| @host           | Host defined in mints_config.yml file                                                |
+| @api_key        | API key defined in mints_config.yml file                                             |
+| @mints_user     | An already instanced user client  (not usable until call the user login method)      |
 
-| Variable        | Description                                   |
-|   ---           |    :---:                                      |
-| @mints_pub      | An already instanced public client            |
-| @contact_token  | A token used by mints to identify the contact |
-| @visit_id       | An identifier of the visit registered         |
+And the following controller methods:
+| Method                    | Parameters     | Return value | Description                                 |
+|   ---                     |   :---:        |   :---:      | :---:                                       |
+| mints_user_login          | email, password| void         | Starts a user session                       |
+| mints_user_logout         | none           | void         | Ends a user session                         |

data/lib/client.rb

@@ -1,6 +1,7 @@
 require "httparty"
 require "json"
 require "addressable"
+require "redis"
 module Mints
   class Client
       attr_reader :host
@@ -9,26 +10,56 @@ module Mints
       attr_reader :base_url
       attr_accessor :session_token      
 
-      def initialize(host, api_key, scope = nil, session_token = nil)
+      def initialize(host, api_key, scope = nil, session_token = nil, debug = false)
           @host = host
           @api_key = api_key
           @session_token = session_token
+          @debug = debug
           self.set_scope(scope)
       end
 
       def raw(action, url, options = nil, data = nil, base_url = nil)
-        base_url = @base_url if !base_url        
-        
+        base_url = @base_url if !base_url
+        uri = ""
         if (options && options.class == Hash)
           uri = Addressable::URI.new
           uri.query_values = options
-        else
-          uri = ""
         end
-
+        
         full_url = "#{@host}#{base_url}#{url}#{uri}"
-        if action === 'get'          
-          response = self.send("#{@scope}_#{action}", "#{full_url}")
+        response = nil
+        if action === 'get'
+
+          config = YAML.load_file("#{Rails.root}/mints_config.yml")
+          url_need_cache = false
+          result_from_cache = false
+          time = 0
+
+          if config['redis_cache']['use_cache']
+            config['redis_cache']['groups'].each do |group|
+              group['urls'].each do |url|
+                  if full_url.match url
+                    time = group['time']
+                    url_need_cache = true
+                    @redis_server = Redis.new(host: config['redis_cache']['redis_host'])
+                    if @redis_server.get(full_url)
+                      response = @redis_server.get(full_url)
+                      result_from_cache = true
+                    else 
+                      response = self.send("#{@scope}_#{action}", "#{full_url}")
+                      @redis_server.setex(full_url,time,response)
+                    end
+                    break
+                  end
+              end
+              break if url_need_cache    
+            end
+          end
+
+          if !url_need_cache
+            response = self.send("#{@scope}_#{action}", "#{full_url}")
+          end
+
         elsif action === 'create' or action === 'post'
           action = 'post'
           response = self.send("#{@scope}_#{action}", "#{full_url}", data)          
@@ -36,17 +67,19 @@ module Mints
           action = 'put'
           response = self.send("#{@scope}_#{action}", "#{full_url}", data)
         end
-        if (response.response.code == "404")
-          raise 'NotFoundError'
-        end
-        parsed_response = JSON.parse(response.body) 
-        if parsed_response.key?('data')
-          return parsed_response['data']
-        end
-        return parsed_response
+        if result_from_cache
+          return parsed_response = JSON.parse(response)
+        else
+          if (response.response.code == "404")
+            raise 'NotFoundError'
+          end
+          parsed_response = JSON.parse(response.body) 
+          return parsed_response
+        end        
       end
   
-      def method_missing(name, *args, &block)     
+      def method_missing(name, *args, &block)
+        puts name
         name.to_s.include?("__") ? separator = "__" : separator = "_"        
         # split the name to identify their elements
         name_spplited = name.to_s.split(separator)
@@ -144,16 +177,38 @@ module Mints
       ##### HTTTP CLIENTS ######
       # Simple HTTP GET
       def http_get(url, headers = nil)
+        if @debug
+          puts "Url:"
+          puts url
+          puts "Headers:"
+          puts headers
+        end
         return headers ? HTTParty.get(url, :headers => headers) : HTTParty.get(url)
       end    
 
       # Simple HTTP POST
       def http_post(url, headers = nil, data = nil)
+        if @debug
+          puts "Url:"
+          puts url
+          puts "Headers:"
+          puts headers
+          puts "Data:"
+          puts data
+        end
         return headers ? HTTParty.post(url, :headers=> headers, :body => data) : HTTParty.post(url, :body => data)  
       end
 
       # Simple HTTP PUT
       def http_put(url, headers = nil, data = nil)
+        if @debug
+          puts "Url:"
+          puts url
+          puts "Headers:"
+          puts headers
+          puts "Data:"
+          puts data
+        end
         return headers ? HTTParty.put(url, :headers=> headers, :body => data) : HTTParty.put(url, :body => data)
       end
 
@@ -161,7 +216,8 @@ module Mints
       def contact_get(url)
         headers = {
           "ApiKey" => @api_key,
-          "Accept" => "application/json"
+          "Accept" => "application/json",
+          "ContactToken" => @contact_token
         }
         headers["Authorization"] = "Bearer #{@session_token}" if @session_token
         return self.http_get(url, headers)
@@ -170,7 +226,8 @@ module Mints
       def contact_post(url, data)
         headers = {
           "ApiKey" => @api_key,
-          "Accept" => "application/json"
+          "Accept" => "application/json",
+          "ContactToken" => @contact_token
         }
         headers["Authorization"] = "Bearer #{@session_token}" if @session_token
         return self.http_post(url, headers, data)
@@ -179,7 +236,8 @@ module Mints
       def contact_put(url, data)
         headers = {
           "ApiKey" => @api_key,
-          "Accept" => "application/json"
+          "Accept" => "application/json",
+          "ContactToken" => @contact_token
         }
         headers["Authorization"] = "Bearer #{@session_token}" if @session_token
         return self.http_post(url, headers, data)
@@ -208,7 +266,7 @@ module Mints
         headers = {
           "ApiKey" => @api_key,
           "Accept" => "application/json",
-          "Contet-Type" => "application/json"
+          "Content-Type" => "application/json"
         }
         headers["Authorization"] = "Bearer #{@session_token}" if @session_token
         return self.http_put(url, headers, data)
@@ -218,10 +276,10 @@ module Mints
       def public_get(url, headers = nil)
         h = {
           "Accept" => "application/json",
-          "Contet-Type" => "application/json",
-          "ApiKey" => @api_key,
-          "ContactToken" => @session_token
+          "Content-Type" => "application/json",
+          "ApiKey" => @api_key
         }
+        h["ContactToken"] = @contact_token if @contact_token
         if headers
           headers.each do |k,v|
             h[k] = v
@@ -233,10 +291,10 @@ module Mints
       def public_post(url, headers = nil, data)
         h = {
           "Accept" => "application/json",
-          "Contet-Type" => "application/json",
-          "ApiKey" => @api_key,
-          "ContactToken" => @session_token
+          "Content-Type" => "application/json",
+          "ApiKey" => @api_key
         }
+        h["ContactToken"] = @session_token if @session_token
         if headers
           headers.each do |k,v|
             h[k] = v
@@ -248,10 +306,10 @@ module Mints
       def public_put(url, headers = nil, data)
         h = {
           "Accept" => "application/json", 
-          "Contet-Type" => "application/json", 
-          "ApiKey" => @api_key,
-          "ContactToken" => @session_token
+          "Content-Type" => "application/json", 
+          "ApiKey" => @api_key
         }
+        h["ContactToken"] = @contact_token if @contact_token
         if headers
           headers.each do |k,v|
             h[k] = v

data/lib/contact.rb

@@ -1,4 +1,5 @@
 require_relative "./client.rb"
+include ActionController::Cookies
 module Mints
   class Contact
     attr_reader :client
@@ -6,22 +7,8 @@ module Mints
     # === Initialize.
     # Class constructor
     #
-    def initialize(host, api_key, session_token = nil)      
-      @client = Mints::Client.new(host, api_key, "contact", session_token)
-    end
-
-    ##
-    # === Register.
-    # Register a new contact
-    #
-    def register(given_name, last_name, email, password)
-      data = {
-        given_name: given_name,
-        last_name: last_name,
-        email: email,
-        password: password
-      }
-      return @client.raw("post", "/contacts/register", nil, {data: data})
+    def initialize(host, api_key, session_token = nil, debug = false)      
+      @client = Mints::Client.new(host, api_key, "contact", session_token, debug)
     end
 
     ##

data/lib/generators/mints_config.yml

@@ -1,4 +1,13 @@
 # Mints connection configuration
 mints:
     host: http://your_host_goes_here.com
-    api_key: your_mints_api_key_goes_here
+    api_key: your_mints_api_key_goes_here
+redis_cache:
+  use_cache: boolean_value_to_enable_and_disable_cache
+  redis_host: your_redis_host
+  groups:
+    - urls:
+        - group_of_urls
+      time: time_that_will_be_applied_to_urls_in_seconds
+sdk:
+    debug: false

data/lib/generators/mints_contact_controller.rb

@@ -0,0 +1,3 @@
+require 'reverse_proxy/client'
+class Api::V1::MintsContactController <  Mints::ContactAPIController
+end

data/lib/generators/mints_files_generator.rb

@@ -1,6 +1,20 @@
 class MintsFilesGenerator < Rails::Generators::Base
     source_root(File.expand_path(File.dirname(__FILE__)))
+    include Rails::Generators::Actions
     def create_mints_files
       copy_file 'mints_config.yml', 'mints_config.yml'
+      copy_file 'mints_user_controller.rb', './app/controllers/api/mints_user_controller.rb'
+      copy_file 'mints_contact_controller.rb', './app/controllers/api/v1/mints_contact_controller.rb'
+      copy_file 'mints_public_controller.rb', './app/controllers/api/v1/mints_public_controller.rb'
+      route <<-eos
+        # Mints auto-generated routes (proxy to send request to mints.cloud)
+        namespace :api, defaults: { format: :json } do
+          match '/user/v1/*path' => 'mints_user#index', via: [:get, :post, :put, :patch, :delete]  
+          namespace :v1 do     
+            match '/contacts/*path' => 'mints_contact#index', via: [:get, :post, :put, :patch, :delete]  
+            match '/*path' => 'mints_public#index', via: [:get, :post, :put, :patch, :delete]
+          end
+        end
+      eos
     end
 end

data/lib/generators/mints_public_controller.rb

@@ -0,0 +1,3 @@
+require 'reverse_proxy/client'
+class Api::V1::MintsPublicController <  Mints::PublicAPIController
+end

data/lib/generators/mints_user_controller.rb

@@ -0,0 +1,3 @@
+require 'reverse_proxy/client'
+class Api::MintsUserController < Mints::UserAPIController
+end

data/lib/mints.rb

@@ -1,6 +1,10 @@
 require_relative "./pub.rb"
 require_relative "./contact.rb"
 require_relative "./user.rb"
-require_relative "./mints/controllers/mints_base_controller.rb"
+require_relative "./mints/controllers/base_controller.rb"
+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"
 module Mints
 end

data/lib/mints/controllers/admin_base_controller.rb

@@ -0,0 +1,56 @@
+module Mints
+  class AdminBaseController < ActionController::Base
+    before_action :set_mints_user_client
+
+    # def mints_user_signed_in?
+    #     # Check status in mints
+    #     response = @mints_user.status
+    #     status = response['success'] ? response['success'] : 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.permanent[:mints_user_session_token] = session_token
+    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 user client.
+    # Initialize the public client and set the user token
+    def set_mints_user_client
+      if File.exists?("#{Rails.root}/mints_config.yml")
+        config = YAML.load_file("#{Rails.root}/mints_config.yml")
+        @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
+      @mints_user = Mints::User.new(@host, @api_key, nil, @debug)
+    end
+  end
+end

data/lib/mints/controllers/base_controller.rb

@@ -0,0 +1,91 @@
+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
+
+    ##
+    # === 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']['id_token']
+        # Set a permanent cookie with the session token
+        cookies.permanent[:mints_contact_session_token] = session_token
+        cookies.permanent[:mints_contact_id] = id_token
+        @contact_token = id_token
+    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
+    
+    private
+
+    ##
+    # === Register visit.
+    # Call register visit method from the public client and set/renew the cookie mints_contact_id
+    def register_visit
+      response = @mints_pub.register_visit(request)
+      @contact_token = response['user_token']
+      @visit_id = response['visit_id']
+      cookies.permanent[:mints_contact_id] = @contact_token
+    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")
+        config = YAML.load_file("#{Rails.root}/mints_config.yml")
+        @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 file
+      @mints_pub = Mints::Pub.new(@host, @api_key, nil, @debug)
+      # Set contact token from cookie
+      @mints_pub.client.session_token = @contact_token
+    end
+
+    ##
+    # === Set contact token.
+    # Set contact token variable from the mints_contact_id cookie value
+    def set_contact_token
+      @contact_token = cookies[:mints_contact_id]
+    end
+
+    ##
+    # === Set mints contact client.
+    # Initialize the public client and set the contact token
+    def set_mints_contact_client
+      # Initialize mints clontact client
+      @mints_contact = Mints::Contact.new(@host, @api_key, nil, @debug)
+    end
+  end
+end

data/lib/mints/controllers/contact_api_controller.rb

@@ -0,0 +1,88 @@
+require 'reverse_proxy/controller'
+require 'reverse_proxy/client'
+module Mints
+    class ContactAPIController < 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_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")
+                config = YAML.load_file("#{Rails.root}/mints_config.yml")
+                @host = config["mints"]["host"]
+                @api_key = config["mints"]["api_key"]     
+                @redis_server = Redis.new(host: config['redis_cache']['redis_host']) if config['redis_cache']['use_cache']
+                @redis_config = config['redis_cache']
+                @use_cache = config['redis_cache']['use_cache'] 
+            end
+        end
+    end
+end

data/lib/mints/controllers/public_api_controller.rb

@@ -0,0 +1,84 @@
+require 'reverse_proxy/controller'
+require 'reverse_proxy/client'
+require 'redis'
+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
+
+        def set_config_variables
+            if File.exists?("#{Rails.root}/mints_config.yml")
+                config = YAML.load_file("#{Rails.root}/mints_config.yml")
+                @host = config["mints"]["host"]
+                @api_key = config["mints"]["api_key"]                
+                @redis_server = Redis.new(host: config['redis_cache']['redis_host']) if config['redis_cache']['use_cache']
+                @redis_config = config['redis_cache']
+                @use_cache = config['redis_cache']['use_cache'] 
+            end
+        end
+    end
+end

data/lib/mints/controllers/user_api_controller.rb

@@ -0,0 +1,88 @@
+require 'reverse_proxy/controller'
+require 'reverse_proxy/client'
+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_contact_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
+
+            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")
+                config = YAML.load_file("#{Rails.root}/mints_config.yml")
+                @host = config["mints"]["host"]
+                @api_key = config["mints"]["api_key"]
+                @redis_server = Redis.new(host: config['redis_cache']['redis_host'])
+                @redis_config = config['redis_cache']
+                @use_cache = config['redis_cache']['use_cache'] if config['redis_cache']['use_cache']
+            end
+        end
+    end
+end

data/lib/pub.rb

@@ -42,17 +42,8 @@ module Mints
     # * +contact_token+ - [String] Cookie 'mints_contact_id' value (mints_contact_token)
     # ==== Return
     # Returns a Client object
-    def initialize(host=nil, api_key=nil, contact_token=nil)
-      if host === nil and api_key === nil
-        if File.exists?("#{Rails.root}/mints_config.yml")
-          config = YAML.load_file("#{Rails.root}/mints_config.yml")
-          host = config["mints"]["host"]
-          api_key = config["mints"]["api_key"]
-        else
-          raise 'MintsBadCredentialsError'
-        end
-      end
-      @client = Mints::Client.new(host, api_key, contact_token)
+    def initialize(host, api_key, contact_token = nil, debug = false)
+      @client = Mints::Client.new(host, api_key, contact_token, debug)
     end
     
     ##
@@ -64,13 +55,13 @@ module Mints
     # * +ip+ - [String] It's the visitor IP
     # * +user_agent+ - The visitor's browser user agent
     # * +url+ - [String] URL visited
-    def register_visit(request, ip=nil, user_agent=nil, url=nil)
+    def register_visit(request, ip = nil, user_agent = nil, url = nil)
       data = {
         ip_address: ip || request.remote_ip,
         user_agent: user_agent || request.user_agent,
         url: url || request.fullpath
       }
-      response = @client.raw("post", "/register-visit", nil, data)
+      response = @client.raw("post", "/register-visit", nil, data.to_json)
       return response
     end
 
@@ -103,7 +94,7 @@ module Mints
     # ==== Parameters
     # * +options+ - [Hash] List of {Resource collection Options}[#class-Mints::Pub-label-Resource+collections+options+] shown above can be used as parameter
     def get_content_templates(options = nil)
-      return @client.raw("get", "/content/content-templates")
+      return @client.raw("get", "/content/content-templates", options)
     end
 
     ##
@@ -123,7 +114,7 @@ module Mints
     #
     # ==== Parameters
     # * +options+ - [Hash] List of {Resource collection Options}[#class-Mints::Pub-label-Resource+collections+options+] shown above can be used as parameter
-    def content_instances(options) 
+    def get_content_instances(options) 
       return @client.raw("get", "/content/content-instances", options)
     end
 
@@ -134,7 +125,7 @@ module Mints
     # ==== Parameters
     # * +slug+ - [String] It's the string identifier generated by Mints
     # * +options+ - [Hash] List of {Single Resource Options}[#class-Mints::Pub-label-Single+resource+options] shown above can be used as parameter
-    def content_instance(slug, options = nil)
+    def get_content_instance(slug, options = nil)
       return @client.raw("get", "/content/content-instances/#{slug}", options)
     end
 
@@ -161,13 +152,12 @@ module Mints
 
     ##
     # === Get Forms.
-    # Get a collection of forms.
+    # Get a collection of forms
     #
     # ==== Parameters
-    # * +slug+ - [String] It's the string identifier generated by Mints
     # * +options+ - [Hash] List of {Resource collection Options}[#class-Mints::Pub-label-Resource+collections+options+] shown above can be used as parameter
     def get_forms(options = nil)
-      return @client.raw("get", "/content/forms/{slug}", options)
+      return @client.raw("get", "/content/forms", options)
     end
 
     ##
@@ -178,7 +168,7 @@ module Mints
     # * +slug+ - [String] It's the string identifier generated by Mints
     # * +options+ - [Hash] List of {Single Resource Options}[#class-Mints::Pub-label-Single+resource+options] shown above can be used as parameter
     def get_form(slug, options = nil)
-      return @client.raw("get", "/content/forms/{slug}", options)
+      return @client.raw("get", "/content/forms/#{slug}", options)
     end
 
     ##
@@ -281,7 +271,7 @@ module Mints
     #
     # ==== Parameters
     # * +options+ - [Hash] List of {Resource collection Options}[#class-Mints::Pub-label-Resource+collections+options+] shown above can be used as parameter
-    def get_tags(options)
+    def get_tags(options = nil)
       return @client.raw("get", "/config/tags", options)
     end
 

data/lib/user.rb

@@ -28,8 +28,8 @@ module Mints
   # * +tags+ - [Boolean] attach tags to response
   class User
     attr_reader :client
-    def initialize(host, api_key, session_token = nil)
-      @client = Mints::Client.new(host, api_key, 'user', session_token)
+    def initialize(host, api_key, session_token = nil, debug = false)
+      @client = Mints::Client.new(host, api_key, 'user', session_token, debug)
     end
 
     def login(email, password)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mints
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.9
 platform: ruby
 authors:
-- Ruben Gomez Garcia, Omar Mora
+- Ruben Gomez Garcia, Omar Mora, Luis Payan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-12 00:00:00.000000000 Z
+date: 2020-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -50,6 +50,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.2
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +90,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.7.0
+- !ruby/object:Gem::Dependency
+  name: rails-reverse-proxy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
 description: 
 email: 
 executables: []
@@ -81,9 +121,16 @@ files:
 - lib/client.rb
 - lib/contact.rb
 - lib/generators/mints_config.yml
+- lib/generators/mints_contact_controller.rb
 - lib/generators/mints_files_generator.rb
+- lib/generators/mints_public_controller.rb
+- lib/generators/mints_user_controller.rb
 - lib/mints.rb
-- lib/mints/controllers/mints_base_controller.rb
+- lib/mints/controllers/admin_base_controller.rb
+- lib/mints/controllers/base_controller.rb
+- lib/mints/controllers/contact_api_controller.rb
+- lib/mints/controllers/public_api_controller.rb
+- lib/mints/controllers/user_api_controller.rb
 - lib/pub.rb
 - lib/user.rb
 homepage: https://github.com/rubengomez/mints-ruby-sdk

data/lib/mints/controllers/mints_base_controller.rb

@@ -1,35 +0,0 @@
-module Mints
-  class BaseController < ActionController::Base
-    before_action :set_contact_token
-    before_action :set_mints_pub
-    before_action :register_visit
-    
-    private
-    ##
-    # === Register visit.
-    # Call register visit method from the public client and set/renew the cookie mints_contact_id
-    def register_visit
-      response = @mints_pub.register_visit(request)
-      @contact_token = response['user_token']
-      @visit_id = response['visit_id']
-      cookies.permanent[:mints_contact_id] = @contact_token
-    end
-
-    ##
-    # === Set mints pub.
-    # Initialize the public client and set the contact token
-    def set_mints_pub
-      # Initialize mints pub client, credentials taken from mints_config.yml file
-      @mints_pub = Mints::Pub.new
-      # Set contact token from cookie
-      @mints_pub.client.session_token = @contact_token
-    end
-
-    ##
-    # === Set contact token.
-    # Set contact token variable from the mints_contact_id cookie value
-    def set_contact_token
-        @contact_token = cookies[:mints_contact_id]
-    end
-  end
-end