forest_liana 5.3.0 → 6.0.0.pre.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e035848d2e7346973187338d78579301dcf062b2b6192ba383cd1f50dcccf584
-  data.tar.gz: 5f8a3ecdea7a8f4643922c27626397bfa3d497c14302f77f377153a22f064b0f
+  metadata.gz: f2f88ccbd15c18a78b06d08ad2a17dfa2075d2b586728033cbe03564c95dd92e
+  data.tar.gz: e78f4892dc9ea07b8dbabb67d3183920f8ef41b6cb7ebe1edd8cb3d0c3b7ee2b
 SHA512:
-  metadata.gz: a30b760625155ae65acf9c8d6941e1e8ddd408b98cd377fdd6f6385c943ceef74e72cf3318d1373f966f8eda48dd9c35c4198bdaeecba2c9c6ffd52f2285e465
-  data.tar.gz: 52b468bfea30b0c115c318ab60eefd2caf382c94df171ea53ec0e203d6869d823f0deb23b20f66939f2560a8611d55b2c6b64f1dcb0b5ffb3d461de3471db8a5
+  metadata.gz: 2a1dfc618f2723448b2fea3b39a48be64fad619c87a3b7d9257e3be8292f1ae86632c38563a7c9d938fd9699a0d78bac50e521d390bb40077ab824996b987ed2
+  data.tar.gz: d1a6401e8e236b718f488e1a1b5641fb953a912c719a5ea1010f7f307c99e7b96fd9f153fc483ebd7dbef5861a5daf9c12e2bdc03f846b62850662ee1837209a

data/app/controllers/forest_liana/actions_controller.rb

@@ -1,89 +1,7 @@
 module ForestLiana
   class ActionsController < ForestLiana::BaseController
-
     def values
       render serializer: nil, json: {}, status: :ok
     end
-
-    def get_collection(collection_name)
-      ForestLiana.apimap.find { |collection| collection.name.to_s == collection_name }
-    end
-
-    def get_action(collection_name)
-      collection = get_collection(collection_name)
-      begin
-         collection.actions.find {|action| ActiveSupport::Inflector.parameterize(action.name) == params[:action_name]}
-      rescue => error
-        FOREST_LOGGER.error "Smart Action get action retrieval error: #{error}"
-        nil
-      end
-    end
-    
-    def get_record
-      model = ForestLiana::SchemaUtils.find_model_from_collection_name(params[:collectionName])
-      redord_getter = ForestLiana::ResourceGetter.new(model, {:id => params[:recordIds][0]})
-      redord_getter.perform
-      redord_getter.record
-    end
-
-    def get_smart_action_load_ctx(fields)
-      fields = fields.reduce({}) {|p, c| p.update(c[:field] => c.merge!(value: nil))}
-      {:record => get_record, :fields => fields}
-    end
-
-    def get_smart_action_change_ctx(fields)
-      fields = fields.reduce({}) {|p, c| p.update(c[:field] => c.permit!.to_h)}
-      {:record => get_record, :fields => fields}
-    end
-
-    def handle_result(result, formatted_fields, action)
-      if result.nil? || !result.is_a?(Hash)
-        return render status: 500, json: { error: 'Error in smart action load hook: hook must return an object' }
-      end
-      is_same_data_structure = ForestLiana::IsSameDataStructureHelper::Analyser.new(formatted_fields, result, 1)
-      unless is_same_data_structure.perform
-        return render status: 500, json: { error: 'Error in smart action hook: fields must be unchanged (no addition nor deletion allowed)' }
-      end
-
-      # Apply result on fields (transform the object back to an array), preserve order.
-      fields = action.fields.map { |field| result[field[:field]] }
-
-      render serializer: nil, json: { fields: fields}, status: :ok
-    end
-
-    def load
-      action = get_action(params[:collectionName])
-
-      if !action
-        render status: 500, json: {error: 'Error in smart action load hook: cannot retrieve action from collection'}
-      else
-        # Transform fields from array to an object to ease usage in hook, adds null value.
-        context = get_smart_action_load_ctx(action.fields)
-        formatted_fields = context[:fields].clone # clone for following test on is_same_data_structure
-
-        # Call the user-defined load hook.
-        result = action.hooks[:load].(context)
-
-        handle_result(result, formatted_fields, action)
-      end
-    end
-
-    def change
-      action = get_action(params[:collectionName])
-
-      if !action
-        render status: 500, json: {error: 'Error in smart action change hook: cannot retrieve action from collection'}
-      else
-        # Transform fields from array to an object to ease usage in hook.
-        context = get_smart_action_change_ctx(params[:fields])
-        formatted_fields = context[:fields].clone # clone for following test on is_same_data_structure
-
-        # Call the user-defined change hook.
-        field_name = params[:fields].select { |field| field[:value] != field[:previousValue] }[0][:field]
-        result = action.hooks[:change][field_name].(context)
-
-        handle_result(result, formatted_fields, action)
-      end
-    end
   end
 end

data/app/controllers/forest_liana/application_controller.rb

@@ -3,8 +3,6 @@ require 'csv'
 
 module ForestLiana
   class ApplicationController < ForestLiana::BaseController
-    REGEX_COOKIE_SESSION_TOKEN = /forest_session_token=([^;]*)/;
-
     def self.papertrail?
       Object.const_get('PaperTrail::Version').is_a?(Class) rescue false
     end
@@ -64,7 +62,7 @@ module ForestLiana
             token = request.headers['Authorization'].split.second
           # NOTICE: Necessary for downloads authentication.
           elsif request.headers['cookie']
-            match = REGEX_COOKIE_SESSION_TOKEN.match(request.headers['cookie'])
+            match = ForestLiana::Token::REGEX_COOKIE_SESSION_TOKEN.match(request.headers['cookie'])
             token = match[1] if match && match[1]
           end
 
@@ -97,10 +95,6 @@ module ForestLiana
       end
     end
 
-    def route_not_found
-      head :not_found
-    end
-
     def internal_server_error
       head :internal_server_error
     end

data/app/controllers/forest_liana/authentication_controller.rb

@@ -0,0 +1,122 @@
+require 'uri'
+require 'json'
+
+module ForestLiana
+  class AuthenticationController < ForestLiana::BaseController
+    START_AUTHENTICATION_ROUTE = 'authentication'
+    CALLBACK_AUTHENTICATION_ROUTE = 'authentication/callback'
+    LOGOUT_ROUTE = 'authentication/logout';
+    PUBLIC_ROUTES = [
+      "/#{START_AUTHENTICATION_ROUTE}",
+      "/#{CALLBACK_AUTHENTICATION_ROUTE}",
+      "/#{LOGOUT_ROUTE}",
+    ]
+
+    def initialize
+      @authentication_service = ForestLiana::Authentication.new()
+    end
+  
+    def get_callback_url
+        URI.join(ForestLiana.application_url, "/forest/#{CALLBACK_AUTHENTICATION_ROUTE}").to_s
+    rescue => error
+      raise "application_url is not valid or not defined" if error.is_a?(ArgumentError)
+    end
+
+    def get_and_check_rendering_id
+      if !params.has_key?('renderingId')
+        raise ForestLiana::MESSAGES[:SERVER_TRANSACTION][:MISSING_RENDERING_ID]
+      end
+
+      rendering_id = params[:renderingId]
+      
+      if !(rendering_id.instance_of?(String) || rendering_id.instance_of?(Numeric)) || (rendering_id.instance_of?(Numeric) && rendering_id.nan?)
+        raise ForestLiana::MESSAGES[:SERVER_TRANSACTION][:INVALID_RENDERING_ID]
+      end
+
+      return rendering_id.to_i
+    end
+
+    def start_authentication 
+      begin
+        rendering_id = get_and_check_rendering_id()
+        callback_url = get_callback_url()
+
+        result = @authentication_service.start_authentication(
+          callback_url,
+          { 'renderingId' => rendering_id },
+        )
+
+        redirect_to(result['authorization_url'])
+      rescue => error
+        render json: { errors: [{ status: 500, detail: error.message }] },
+          status: :internal_server_error, serializer: nil
+      end
+    end
+
+    def authentication_callback
+      begin
+        callback_url = get_callback_url()
+
+        token = @authentication_service.verify_code_and_generate_token(
+          callback_url,
+          params,
+        )
+    
+        response.set_cookie(
+          'forest_session_token',
+          {
+            value: token,
+            httponly: true,
+            secure: true,
+            expires: ForestLiana::Token.expiration_in_days,
+            samesite: 'none',
+            path: '/'
+          },
+        )
+
+        response_body = {
+          tokenData: JWT.decode(token, ForestLiana.auth_secret, true, { algorithm: 'HS256' })[0]
+        }
+
+        # The token is sent decoded, because we don't want to share the whole, signed token
+        # that is used to authenticate people
+        # but the token itself contains interesting values, such as its expiration date
+        response_body[:token] = token if !ForestLiana.application_url.start_with?('https://')
+
+        render json: response_body, status: 200
+
+      rescue => error
+        render json: { errors: [{ status: 500, detail: error.message }] },
+          status: :internal_server_error, serializer: nil
+      end
+    end
+
+    def logout
+      begin
+        if cookies.has_key?(:forest_session_token)
+          forest_session_token = cookies[:forest_session_token]
+          
+          if forest_session_token
+            response.set_cookie(
+              'forest_session_token',
+              {
+                value: forest_session_token,
+                httponly: true,
+                secure: true,
+                expires: Time.at(0),
+                samesite: 'none',
+                path: '/'
+              },
+            )
+          end
+        end
+
+        render json: {}, status: 204
+      rescue => error
+        render json: { errors: [{ status: 500, detail: error.message }] },
+        status: :internal_server_error, serializer: nil
+      end
+    end
+
+  end
+end

data/app/controllers/forest_liana/base_controller.rb

@@ -4,6 +4,10 @@ module ForestLiana
     wrap_parameters false
     before_action :reject_unauthorized_ip
 
+    def route_not_found
+      head :not_found
+    end
+
     private
 
     def reject_unauthorized_ip

data/app/controllers/forest_liana/router.rb

@@ -7,7 +7,7 @@ class ForestLiana::Router
     if resource.nil?
       FOREST_LOGGER.error "Routing error: Resource not found for collection #{collection_name}."
       FOREST_LOGGER.error "If this is a Smart Collection, please ensure your Smart Collection routes are defined before the mounted ForestLiana::Engine?"
-      ForestLiana::ApplicationController.action(:route_not_found).call(env)
+      ForestLiana::BaseController.action(:route_not_found).call(env)
     else
       begin
         component_prefix = ForestLiana.component_prefix(resource)
@@ -40,7 +40,7 @@ class ForestLiana::Router
         controller.action(action.to_sym).call(env)
       rescue NoMethodError => exception
         FOREST_LOGGER.error "Routing error: #{exception}\n#{exception.backtrace.join("\n\t")}"
-        ForestLiana::ApplicationController.action(:route_not_found).call(env)
+        ForestLiana::BaseController.action(:route_not_found).call(env)
       end
     end
   end

data/app/controllers/forest_liana/sessions_controller.rb

@@ -85,7 +85,7 @@ module ForestLiana
         # NOTICE: Set a cookie to ensure secure authentication using export feature.
         # NOTICE: The token is empty at first authentication step if the 2FA option is active.
         if reponse_data[:token]
-          response.set_cookie("forest_session_token", { value: reponse_data[:token], expires: (Time.current + 14.days) })
+          response.set_cookie("forest_session_token", { value: reponse_data[:token], expires: (ForestLiana::Token.expiration_in_days) })
         end
 
         render(json: reponse_data, serializer: nil)

data/app/controllers/forest_liana/stats_controller.rb

@@ -6,11 +6,11 @@ module ForestLiana
       before_action :find_resource, except: [:get_with_live_query]
     end
 
-    CHART_TYPE_VALUE = 'Value';
-    CHART_TYPE_PIE = 'Pie';
-    CHART_TYPE_LINE = 'Line';
-    CHART_TYPE_LEADERBOARD = 'Leaderboard';
-    CHART_TYPE_OBJECTIVE = 'Objective';
+    CHART_TYPE_VALUE = 'Value'
+    CHART_TYPE_PIE = 'Pie'
+    CHART_TYPE_LINE = 'Line'
+    CHART_TYPE_LEADERBOARD = 'Leaderboard'
+    CHART_TYPE_OBJECTIVE = 'Objective'
 
     def get
       case params[:type]

data/app/helpers/forest_liana/adapter_helper.rb

@@ -10,7 +10,7 @@ module ForestLiana
 
     def self.cast_boolean(value)
       if ['MySQL', 'SQLite'].include?(ActiveRecord::Base.connection.adapter_name)
-        value === 'true' ? 1 : 0;
+        value === 'true' ? 1 : 0
       else
         value
       end

data/app/models/forest_liana/model/action.rb

@@ -5,7 +5,7 @@ class ForestLiana::Model::Action
   extend ActiveModel::Naming
 
   attr_accessor :id, :name, :base_url, :endpoint, :http_method, :fields, :redirect,
-    :type, :download, :hooks
+    :type, :download
 
   def initialize(attributes = {})
     if attributes.key?(:global)
@@ -66,7 +66,6 @@ class ForestLiana::Model::Action
     @base_url ||= nil
     @type ||= "bulk"
     @download ||= false
-    @hooks = !@hooks.nil? ? @hooks.symbolize_keys : nil
   end
 
   def persisted?

data/app/serializers/forest_liana/schema_serializer.rb

@@ -52,7 +52,7 @@ class ForestLiana::SchemaSerializer
           @included << format_child_content('segments', segment_id, segment)
         end
       else
-        collection_serialized[:attributes][attribute.to_sym] = value;
+        collection_serialized[:attributes][attribute.to_sym] = value
       end
     end
 
@@ -75,7 +75,7 @@ class ForestLiana::SchemaSerializer
     }
 
     object.each do |attribute, value|
-      child_serialized[:attributes][attribute.to_sym] = value;
+      child_serialized[:attributes][attribute.to_sym] = value
     end
 
     child_serialized

data/app/services/forest_liana/apimap_sorter.rb

@@ -39,7 +39,6 @@ module ForestLiana
       'redirect',
       'download',
       'fields',
-      'hooks',
     ]
     KEYS_ACTION_FIELD = [
       'field',
@@ -61,7 +60,7 @@ module ForestLiana
     def perform
       begin
         @apimap = reorder_keys_basic(@apimap)
-        sort_array_of_objects(@apimap['data']);
+        sort_array_of_objects(@apimap['data'])
         @apimap['data'].map! do |collection|
           collection = reorder_keys_child(collection)
           collection['attributes'] = reorder_collection_attributes(collection['attributes'])

data/app/services/forest_liana/authentication.rb

@@ -0,0 +1,59 @@
+module ForestLiana
+  class Authentication
+    def start_authentication(redirect_url, state)
+      client = ForestLiana::OidcClientManager.get_client_for_callback_url(redirect_url)
+
+      authorization_url = client.authorization_uri({
+        scope: 'openid email profile',
+        state: state.to_s,
+      })
+  
+      { 'authorization_url' => authorization_url }
+    end
+
+    def verify_code_and_generate_token(redirect_url, params) 
+      client = ForestLiana::OidcClientManager.get_client_for_callback_url(redirect_url)
+
+      rendering_id = parse_state(params['state'])
+      client.authorization_code = params['code']
+
+      if Rails.env.development? || Rails.env.test?
+        OpenIDConnect.http_config do |config|
+          config.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+      access_token_instance = client.access_token! 'none'
+
+      user = ForestLiana::AuthorizationGetter.authenticate(
+        rendering_id,
+        true,
+        { :forest_token => access_token_instance.instance_variable_get(:@access_token) },
+        nil,
+      )
+
+      return ForestLiana::Token.create_token(user, rendering_id)
+    end
+
+    private
+    def parse_state(state)
+      unless state
+        raise ForestLiana::MESSAGES[:SERVER_TRANSACTION][:INVALID_STATE_MISSING]
+      end
+
+      rendering_id = nil
+
+      begin
+        parsed_state = JSON.parse(state.gsub("'",'"').gsub('=>',':'))
+        rendering_id = parsed_state["renderingId"].to_s
+      rescue
+        raise ForestLiana::MESSAGES[:SERVER_TRANSACTION][:INVALID_STATE_FORMAT]
+      end
+
+      if rendering_id.nil?
+        raise ForestLiana::MESSAGES[:SERVER_TRANSACTION][:INVALID_STATE_RENDERING_ID]
+      end
+
+      return rendering_id
+    end
+  end
+end

data/app/services/forest_liana/authorization_getter.rb

@@ -1,39 +1,31 @@
 module ForestLiana
   class AuthorizationGetter
-    def initialize(rendering_id, use_google_authentication, auth_data, two_factor_registration)
-      @rendering_id = rendering_id
-      @use_google_authentication = use_google_authentication
-      @auth_data = auth_data
-      @two_factor_registration = two_factor_registration
-
-      @route = "/liana/v2/renderings/#{rendering_id}"
-      @route += use_google_authentication ? "/google-authorization" : "/authorization"
-    end
-
-    def perform
+    def self.authenticate(rendering_id, use_google_authentication, auth_data, two_factor_registration)
       begin
-        if @use_google_authentication
-          headers = { 'forest-token' => @auth_data[:forest_token] }
-        else
-          headers = { 'email' => @auth_data[:email], 'password' => @auth_data[:password] }
+        route = "/liana/v2/renderings/#{rendering_id.to_s}/authorization"
+
+        if !use_google_authentication.nil?
+          headers = { 'forest-token' => auth_data[:forest_token] }
+        elsif !auth_data[:email].nil?
+          headers = { 'email' => auth_data[:email], 'password' => auth_data[:password] }
         end
 
         query_parameters = {}
 
-        if @two_factor_registration
+        unless two_factor_registration.nil?
           query_parameters['two-factor-registration'] = true
         end
 
         response = ForestLiana::ForestApiRequester
-          .get(@route, query: query_parameters, headers: headers)
+          .get(route, query: query_parameters, headers: headers)
 
-        if response.is_a?(Net::HTTPOK)
-          body = JSON.parse(response.body)
+        if response.code.to_i == 200
+          body = JSON.parse(response.body, :symbolize_names => false)
           user = body['data']['attributes']
           user['id'] = body['data']['id']
           user
         else
-          if @use_google_authentication
+          unless use_google_authentication.nil?
             raise "Cannot authorize the user using this google account. Forest API returned an #{Errors::HTTPErrorHelper.format(response)}"
           else
             raise "Cannot authorize the user using this email/password. Forest API returned an #{Errors::HTTPErrorHelper.format(response)}"