cxf 0.0.1

data/lib/cxf/helpers/cxf_helper.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CxfHelper
+  # === Get query results.
+  # Method used to give the options to make a 'post' or 'get' request.
+  #
+  # ==== Parameters
+  # url:: (String) -- Url to make the request.
+  # options:: (Hash) -- List of {Resource collection Options}[#class-Cxf::User-label-Resource+collections+options+] shown above can be used as parameter.
+  # use_post:: (Boolean) -- Variable to determine if the request is by 'post' or 'get' functions.
+  #
+  def get_query_results(url, options = nil, use_post = true)
+    if use_post
+      @client.raw('post', "#{url}/query", options)
+    else
+      @client.raw('get', url, options)
+    end
+  end
+
+  # === Data transform.
+  # Transform a 'data' variable to a standardized 'data' variable.
+  #
+  # ==== Parameters
+  # data:: (Hash) -- Data to be submitted.
+  #
+  def data_transform(data)
+    return data if data.nil?
+
+    data = correct_json(data)
+
+    unless data[:data]
+      data = { data: data }
+    end
+
+    data.to_json
+  end
+
+  # === Correct json.
+  # Receives a json data and convert it to a symbolized object.
+  #
+  # ==== Parameters
+  # data:: (Hash) -- Data to be submitted.
+  #
+  def correct_json(data)
+    if data.is_a? String
+      data = JSON.parse(data)
+    end
+
+    data.symbolize_keys
+  end
+
+end

data/lib/cxf/helpers/proxy_controllers_methods.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+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_cxf_request
+  #
+  def index(controller_type = nil)
+    host = @host.gsub('http://', '').gsub('https://', '')
+    host = host[0...-1] if host.end_with? '/'
+
+    headers = {
+      'host' => host,
+      'ApiKey' => @api_key.to_s,
+      'Content-Type' => 'application/json',
+      'Accept' => 'application/json',
+      'SDK' => 'true',
+    }
+
+    if %w[contact user].include? controller_type
+      session_token = cookies["cxf_#{controller_type}_session_token".to_sym]
+      refresh_token = cookies["cxf_#{controller_type}_refresh_token".to_sym]
+      headers['Access-Token'] = session_token
+      headers['Refresh-Token'] = refresh_token
+    end
+
+    headers['ContactToken'] = cookies[:cxf_contact_id] if controller_type == 'contact' && cookies[:cxf_contact_id]
+
+    full_url = request.original_url
+    url_need_cache, time = url_need_cache?(full_url)
+
+    if @debug
+      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_cxf_request(full_url, headers, controller_type, true, time: time)
+    else
+      send_cxf_request(full_url, headers, controller_type)
+    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 && @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
+
+    [url_need_cache, time]
+  end
+
+  # === Send cxf 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_cxf_request(full_url, headers, controller_type, 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 |_status_code, response|
+          @redis_server.setex(
+            full_url,
+            time || 30,
+            response.body
+          )
+        end
+      end
+
+      # set Cookies from response headers
+      if %w[contact user].include? controller_type
+        config.on_response do |_status_code, response|
+          session_token_expires_at = Time.parse(response.header['Access-Token-Expires-At']) if response.header['Access-Token-Expires-At']
+          refresh_token_expires_at = Time.parse(response.header['Refresh-Token-Expires-At']) if response.header['Refresh-Token-Expires-At']
+
+          # add expires to cookies
+          cookies["cxf_#{controller_type}_session_token".to_sym] = { value: response.header['Access-Token'], secure: true, httponly: true, expires: Time.at(session_token_expires_at) } if response.header['Access-Token']
+          cookies["cxf_#{controller_type}_refresh_token".to_sym] = { value: response.header['Refresh-Token'], secure: true, httponly: true, expires: Time.at(refresh_token_expires_at) } if response.header['Refresh-Token']
+        end
+      end
+
+      # Request failed!
+      config.on_missing do |status_code, _response|
+        # We got a 404!
+        raise ActionController::RoutingError.new('Not Found') if status_code == 404
+      end
+    end
+  end
+end

data/lib/cxf/helpers/threads_helper.rb

@@ -0,0 +1,109 @@
+require 'concurrent/executor/thread_pool_executor'
+
+module ThreadsHelper
+
+  def make_multiple_request(calls)
+    set_threads_config
+    payload_to_return = []
+    now = Time.now
+    calls = [calls] if !calls.kind_of?(Array) || (calls.kind_of?(Array) && calls.first.kind_of?(String))
+
+    if @debug
+      puts "min_threads_per_pool: #{@min_threads_per_pool}"
+      puts "max_threads_per_pool: #{@max_threads_per_pool}"
+      puts "max_threads_queue: #{@max_threads_queue}"
+    end
+
+    pool = Concurrent::ThreadPoolExecutor.new(
+      min_threads: @min_threads_per_pool,
+      max_threads: @max_threads_per_pool,
+      max_queue: @max_threads_queue,
+      fallback_policy: :caller_runs
+    )
+
+    calls.each_with_index do |call_data, index|
+      pool.post do
+        begin
+          payload_to_return[index] = make_call(call_data)
+        rescue => e
+          payload_to_return[index] = e
+        end
+      end
+    end
+
+    # tell the pool to shutdown in an orderly fashion, allowing in progress work to complete
+    pool.shutdown
+    # now wait for all work to complete, wait as long as it takes
+    pool.wait_for_termination
+
+    if @debug
+      end_time = Time.now
+      puts "Time to make all calls: #{end_time - now}"
+    end
+
+    payload_to_return
+  end
+
+  private
+
+  def set_threads_config
+    if File.exists?("#{Rails.root}/cxf_config.yml.erb")
+      template = ERB.new File.new("#{Rails.root}/cxf_config.yml.erb").read
+      config = YAML.safe_load template.result(binding)
+      cxf_config = get_cxf_config(config)
+      @debug = !!config['sdk']['debug']
+
+      # All threads config
+      @min_threads_per_pool = cxf_config['min_threads_per_pool'] || 2
+      @max_threads_per_pool = cxf_config['max_threads_per_pool'] || 2
+      @max_threads_queue = cxf_config['max_threads_queue'] || 10
+    end
+  end
+
+  def get_cxf_config(config)
+    config['cxf'].kind_of?(Hash) ? config['cxf'] : {}
+  end
+
+  def make_call(call_data)
+    action, *all_options = generate_raw_data(call_data)
+
+    if if_is_raw_action(action)
+      self.client.raw(action, *all_options)
+    else
+      self.send(action, *all_options.compact)
+    end
+  end
+
+  def if_is_raw_action(action)
+    http_actions = %w[get create post update put patch delete destroy]
+    http_actions.include?(action.downcase)
+  end
+
+  def generate_raw_data(payload)
+    action = raw_attribute_data(payload, 'action')
+    url = raw_attribute_data(payload, 'url', 1)
+    options = raw_attribute_data(payload, 'options', 2)
+    data = raw_attribute_data(payload, 'data', 3)
+    base_url = raw_attribute_data(payload, 'base_url', 4)
+    compatibility_options = raw_attribute_data(payload, 'compatibility_options', 5)
+    only_tracking = raw_attribute_data(payload, 'only_tracking', 6)
+
+    [action, url, options, data, base_url, compatibility_options, only_tracking]
+  end
+
+  def raw_attribute_data(payload, attribute, array_index = 0)
+    attribute_data = nil
+
+    if payload.kind_of? Array
+      attribute_data = payload[array_index]
+    elsif payload.kind_of? Hash
+      if payload.key? attribute
+        attribute_data = payload[attribute]
+      elsif payload.key? attribute.to_sym
+        attribute_data = payload[attribute.to_sym]
+      end
+    end
+
+    attribute_data
+  end
+end

data/lib/cxf/helpers/user_auth_helper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module UserAuthHelper
+  def cxf_user_signed_in?
+    begin
+      # Check status in cxf
+      response = @cxf_user.me['data']
+    rescue => e
+      # Handle the client Unauthorized error
+      # if cxf response is negative delete the session cookie
+      cookies.delete(:cxf_user_session_token)
+      cookies.delete(:cxf_user_refresh_token)
+      response = nil
+    end
+
+    response
+  end
+
+  ##
+  # === Cxf user Login.
+  # Starts a user session in cxf.cloud and set a session cookie
+  def cxf_user_login(email, password)
+    # Login in cxf
+    response = @cxf_user.login(email, password)
+    # Get session token from response
+    if response.key? 'data'
+      session_token = response['data']['access_token']
+      refresh_token = response['data']['refresh_token']
+      session_token_expires_at = Time.parse(response['data']['access_token_expires_at'])
+      refresh_token_expires_at = Time.parse(response['data']['refresh_token_expires_at'])
+    end
+
+    # Set a permanent cookie with the session token
+    cookies[:cxf_user_session_token] = { value: session_token, secure: true, httponly: true, expires: Time.at(session_token_expires_at) }
+    cookies[:cxf_user_refresh_token] = { value: refresh_token, secure: true, httponly: true, expires: Time.at(refresh_token_expires_at) }
+  end
+
+  ##
+  # === Cxf user Login.
+  # Starts a user session in cxf.cloud and set a session cookie
+  def cxf_user_magic_link_login(hash)
+    # Login in cxf
+    response = @cxf_user.magic_link_login(hash)
+    if response['data']
+      # Set a cookie with the session token
+      cookies[:cxf_user_session_token] = { value: response['data']['access_token'], secure: true, httponly: true }
+      cookies[:cxf_user_refresh_token] = { value: response['data']['refresh_token'], secure: true, httponly: true }
+      redirect_to response['data']['redirect_url'] || '/'
+    else
+      redirect_to '/'
+    end
+  end
+
+  ##
+  # === Cxf user Logout.
+  # Destroy session from cxf.cloud and delete local session cookie
+  def cxf_user_logout
+    # Logout from cxf
+    # @cxf_user.logout
+    # Delete local cookie
+    cookies.delete(:cxf_user_session_token)
+    cookies.delete(:cxf_user_refresh_token)
+  end
+
+  def update_user_tokens
+    access_token = @cxf_user.get_client.session_token
+    refresh_token = @cxf_user.get_client.refresh_token
+    access_token_expires_at = @cxf_user.get_client.session_token_expires_at
+    refresh_token_expires_at = @cxf_user.get_client.refresh_token_expires_at
+
+    cookies[:cxf_user_session_token] = { value: access_token, secure: true, httponly: true, expires: Time.at(access_token_expires_at) } if access_token && access_token_expires_at
+    cookies[:cxf_user_refresh_token] = { value: refresh_token, secure: true, httponly: true, expires: Time.at(refresh_token_expires_at) } if refresh_token && refresh_token_expires_at
+  end
+end

data/lib/cxf.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative './pub'
+require_relative './contact'
+require_relative './user'
+require_relative './cxf/controllers/base_controller'
+require_relative './cxf/controllers/base_api_controller'
+require_relative './cxf/controllers/admin_base_controller'
+require_relative './cxf/controllers/public_api_controller'
+require_relative './cxf/controllers/contact_api_controller'
+require_relative './cxf/controllers/user_api_controller'
+require_relative './errors'
+
+module Cxf
+end

data/lib/errors.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Cxf
+
+  module Errors
+
+    class NonSupportedRubyVersionError < RuntimeError; end
+
+    class DynamicError < RuntimeError
+      ERRORS = {
+        '401' => 'AccessDeniedException',
+        '404' => 'ResourceNotFoundException',
+        '422' => 'ValidationException',
+        '405' => 'MethodNotAllowedException',
+        'undefined_id' => 'UndefinedIdException',
+        '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
+        "Cxf::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 MethodNotAllowedException < ServiceError; end
+
+    class UndefinedIdException < ServiceError; end
+
+    class ValidationException < ServiceError
+
+      def to_h
+        super(errors_hash)
+      end
+
+      def errors_hash
+        {
+          errors: if response.is_a? Hash
+                    response.keys.reduce([]) do |carry, error_key|
+                      carry + (response[error_key].is_a?(Array) ? response[error_key] : [response[error_key]] )
+                    end
+                  else
+                    response
+                  end
+        }
+      end
+
+      attr_reader :failed_validations
+    end
+
+    class InternalServerException < ServiceError; end
+
+  end
+end

data/lib/generators/cxf_assets_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'reverse_proxy/client'
+require 'cxf'
+
+class CxfAssetsController < Cxf::PublicAPIController
+end

data/lib/generators/cxf_config.yml.erb

@@ -0,0 +1,27 @@
+# Cxf connection configuration
+cxf:
+    host: http://your_host_goes_here.com
+    api_key: your_cxf_api_key_goes_here
+    cxf_slug: slug_id #save id and token in redis
+redis_cache:
+  use_cache: boolean_value_to_enable_and_disable_cache
+  redis_host: your_redis_server_host
+  redis_port: your_redis_server_port
+  redis_db: your_redis_database
+  groups:
+    - urls:
+        - group_of_urls
+      time: time_that_will_be_applied_to_urls_in_seconds
+sdk:
+    debug: false
+    # Timeout is specified in seconds
+    default_http_timeout: 30 # Allows setting a default timeout for all HTTP calls.
+    get_http_timeout: 30 # Allows setting a default timeout for all GET calls.
+    post_http_timeout: 30 # Allows setting a default timeout for all POST calls.
+    put_http_timeout: 30 # Allows setting a default timeout for all PUT calls.
+    delete_http_timeout: 30 # Allows setting a default timeout for all DELETE calls.
+cookies_iframe:
+  activated: boolean_value_to_enable_and_disable_cookies_iframe
+  expire_time: expire_time_of_cookies_iframe_in_hours
+  hosts:
+    - array_of_host_to_send_cookies

data/lib/generators/cxf_contact_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'reverse_proxy/client'
+require 'cxf'
+
+class Api::V1::CxfContactController < Cxf::ContactAPIController
+end

data/lib/generators/cxf_files_generator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class CxfFilesGenerator < Rails::Generators::Base
+  source_root(File.expand_path(File.dirname(__FILE__)))
+  include Rails::Generators::Actions
+
+  def create_cxf_files
+    copy_file 'cxf_config.yml.erb', 'cxf_config.yml.erb'
+    copy_file 'cxf_user_controller.rb', './app/controllers/api/cxf_user_controller.rb'
+    copy_file 'cxf_contact_controller.rb', './app/controllers/api/v1/cxf_contact_controller.rb'
+    copy_file 'cxf_public_controller.rb', './app/controllers/api/v1/cxf_public_controller.rb'
+    copy_file 'cxf_assets_controller.rb', './app/controllers/cxf_assets_controller.rb'
+
+    route <<-eos
+        # Cxf auto-generated routes (proxy to send request to cxf.cloud)
+        match '/public-assets/*path' => 'cxf_assets#index', via: [:get, :post, :put, :patch, :delete]
+        namespace :api, defaults: { format: :json } do
+          match '/v1/*path' => 'cxf_user#index', via: [:get, :post, :put, :patch, :delete]
+          match '/user/v1/*path' => 'cxf_user#index', via: [:get, :post, :put, :patch, :delete]
+          match '/contact/v1/*path' => 'cxf_contact#index', via: [:get, :post, :put, :patch, :delete]  
+          namespace :v1 do     
+            match '/contacts/*path' => 'cxf_contact#index', via: [:get, :post, :put, :patch, :delete]              
+            match '/*path' => 'cxf_public#index', via: [:get, :post, :put, :patch, :delete]
+          end
+        end
+    eos
+  end
+end

data/lib/generators/cxf_public_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'reverse_proxy/client'
+require 'cxf'
+
+class Api::V1::CxfPublicController < Cxf::PublicAPIController
+end

data/lib/generators/cxf_user_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'reverse_proxy/client'
+require 'cxf'
+
+class Api::CxfUserController < Cxf::UserAPIController
+end

data/lib/pub/config/config.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+### V1/CONFIG ###
+
+module PublicConfig
+end

data/lib/pub/content/assets.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PublicAssets
+  ##
+  # === Get Asset Info.
+  # Get a description of an Asset.
+  #
+  # ==== Parameters
+  # slug:: (String) -- It's the string identifier of the asset.
+  #
+  # ==== Example
+  #     @data = @cxf_pub.get_asset_info("asset_slug")
+  def get_asset_info(slug)
+    @client.raw('get', "/content/asset-info/#{slug}")
+  end
+end

data/lib/pub/content/content.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+### V1/CONTENT ###
+
+require_relative './assets'
+
+module PublicContent
+  include PublicAssets
+end

data/lib/pub/ecommerce/ecommerce.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+### V1/ECOMMERCE ###
+
+module PublicEcommerce
+end