feat: add support for workspace context in charts (#649)

Author: matthv

app/services/forest_liana/ability/permission/smart_action_checker.rb

@@ -49,7 +49,7 @@ def match_conditions(condition_name)
           begin
             attributes = @parameters[:data][:attributes]
             records = FiltersParser.new(
-              @smart_action[condition_name][0]['filter'].to_json,
+              @smart_action[condition_name][0]['filter'],
               @collection,
               @parameters[:timezone],
               @parameters

app/services/forest_liana/filters_parser.rb

@@ -3,7 +3,7 @@ class FiltersParser
     AGGREGATOR_OPERATOR = %w(and or)
 
     def initialize(filters, resource, timezone, params = nil)
-      @filters = filters.instance_of?(ActionController::Parameters) ? filters.to_h : JSON.parse(filters)
+      @filters = filters
       @params = params
       @resource = resource
       @operator_date_parser = OperatorDateIntervalParser.new(timezone)
@@ -87,10 +87,6 @@ def parse_condition_without_smart_field(condition)
       value = condition['value']
       field_name = condition['field']
 
-      if value.is_a?(String) && value.start_with?('{{')
-        value = @params[:contextVariables][value.gsub(/[{}]/, '')]
-      end
-
       if @operator_date_parser.is_date_operator?(operator)
         condition = @operator_date_parser.get_date_filter(operator, value)
         return "#{parse_field_name(field_name)} #{condition}"

app/services/forest_liana/leaderboard_stat_getter.rb

@@ -27,7 +27,7 @@ def perform
     end
 
     def get_scoped_model(model, forest_user, timezone)
-      scope_filters = ForestLiana::ScopeManager.get_scope_for_user(forest_user, model.name, as_string: true)
+      scope_filters = ForestLiana::ScopeManager.get_scope(model.name, forest_user)
 
       return model.unscoped if scope_filters.blank?
 

app/services/forest_liana/line_stat_getter.rb

@@ -25,7 +25,7 @@ def get_format
     def perform
       value = get_resource()
 
-      filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filter], @user, @resource.name)
+      filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filter], @user, @resource.name, @params['contextVariables'])
 
       unless filters.blank?
         value = FiltersParser.new(filters, @resource, @params[:timezone], @params).apply_filters

app/services/forest_liana/pie_stat_getter.rb

@@ -7,7 +7,7 @@ def perform
         timezone_offset = @params[:timezone].to_i
         resource = optimize_record_loading(@resource, get_resource)
 
-        filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filter], @user, @resource.name)
+        filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filter], @user, @resource.name, @params['contextVariables'])
 
         unless filters.blank?
           resource = FiltersParser.new(filters, resource, @params[:timezone], @params).apply_filters

app/services/forest_liana/scope_manager.rb

@@ -1,20 +1,19 @@
 module ForestLiana
   class ScopeManager
-    @@scopes_cache = Hash.new
-    # 5 minutes exipration cache
+    # 5 minutes expiration cache
     @@scope_cache_expiration_delta = 300
 
-    def self.apply_scopes_on_records(records, forest_user, collection_name, timezone)
-      scope_filters = get_scope_for_user(forest_user, collection_name, as_string: true)
+    def self.apply_scopes_on_records(records, user, collection_name, timezone)
+      scope_filters = get_scope(collection_name, user)
 
       return records if scope_filters.blank?
 
       FiltersParser.new(scope_filters, records, timezone).apply_filters
     end
 
-    def self.append_scope_for_user(existing_filter, user, collection_name)
-      existing_filter = existing_filter.to_json if existing_filter.is_a?(ActionController::Parameters)
-      scope_filter = get_scope_for_user(user, collection_name, as_string: true)
+    def self.append_scope_for_user(existing_filter, user, collection_name, request_context_variables = nil)
+      existing_filter = inject_context_variables(existing_filter, user, request_context_variables) if existing_filter
+      scope_filter = get_scope(collection_name, user, request_context_variables)
       filters = [existing_filter, scope_filter].compact
 
       case filters.length
@@ -23,80 +22,57 @@ def self.append_scope_for_user(existing_filter, user, collection_name)
       when 1
         filters[0]
       else
-        "{\"aggregator\":\"and\",\"conditions\":[#{existing_filter},#{scope_filter}]}"
+        { 'aggregator' => 'and', 'conditions' => [existing_filter, scope_filter] }
       end
     end
 
-    def self.get_scope_for_user(user, collection_name, as_string: false)
-      raise 'Missing required rendering_id' unless user['rendering_id']
-      raise 'Missing required collection_name' unless collection_name
+    def self.get_scope(collection_name, user, request_context_variables = nil)
+      retrieve = fetch_scopes(user['rendering_id'])
+      scope = retrieve['scopes'][collection_name]
 
-      collection_scope = get_collection_scope(user['rendering_id'], collection_name)
+      return nil if scope.nil?
 
-      return nil unless collection_scope
-
-      filters = format_dynamic_values(user['id'], collection_scope)
-
-      as_string && filters ? JSON.generate(filters) : filters
+      inject_context_variables(scope, user, request_context_variables)
     end
 
-    def self.get_collection_scope(rendering_id, collection_name)
-      if !@@scopes_cache[rendering_id]
-        # when scope cache is unset wait for the refresh
-        refresh_scopes_cache(rendering_id)
-      elsif has_cache_expired?(rendering_id)
-        # when cache expired refresh the scopes without waiting for it
-        Thread.new { refresh_scopes_cache(rendering_id) }
-      end
+    def self.inject_context_variables(filter, user, request_context_variables = nil)
+      filter = JSON.parse(filter) if filter.is_a? String
 
-      @@scopes_cache[rendering_id][:scopes][collection_name].deep_dup
-    end
+      retrieve = fetch_scopes(user['rendering_id'])
+      context_variables = Utils::ContextVariables.new(retrieve['team'], user, request_context_variables)
 
-    def self.has_cache_expired?(rendering_id)
-      rendering_scopes = @@scopes_cache[rendering_id]
-      return true unless rendering_scopes
-
-      second_since_last_fetch = Time.now - rendering_scopes[:fetched_at]
-      second_since_last_fetch >= @@scope_cache_expiration_delta
+      Utils::ContextVariablesInjector.inject_context_in_filter(filter, context_variables)
     end
 
-    def self.refresh_scopes_cache(rendering_id)
-      scopes = fetch_scopes(rendering_id)
-      @@scopes_cache[rendering_id] = {
-        :fetched_at => Time.now,
-        :scopes => scopes
-      }
+    def self.invalidate_scope_cache(rendering_id)
+      Rails.cache.delete('forest.scopes.' + rendering_id.to_s)
     end
 
     def self.fetch_scopes(rendering_id)
-      query_parameters = { 'renderingId' => rendering_id }
-      response = ForestLiana::ForestApiRequester.get('/liana/scopes', query: query_parameters)
+      response = ForestLiana::ForestApiRequester.get("/liana/v4/permissions/renderings/#{rendering_id}")
 
       if response.is_a?(Net::HTTPOK)
-        JSON.parse(response.body)
+        Rails.cache.fetch('forest.scopes.' + rendering_id.to_s, expires_in: @@scope_cache_expiration_delta) do
+          data = {}
+          parse_response = JSON.parse(response.body)
+
+          data['scopes'] = decode_scope(parse_response['collections'])
+          data['team'] = parse_response['team']
+
+          data
+        end
       else
         raise 'Unable to fetch scopes'
       end
     end
 
-    def self.format_dynamic_values(user_id, collection_scope)
-      filter = collection_scope.dig('scope', 'filter')
-      return nil unless filter
-
-      dynamic_scopes_values = collection_scope.dig('scope', 'dynamicScopesValues')
-
-      # Only goes one level deep as required for now
-      filter['conditions'].map do |condition|
-        value = condition['value']
-        if value.is_a?(String) && value.start_with?('$currentUser')
-          condition['value'] = dynamic_scopes_values.dig('users', user_id, value)
-        end
+    def self.decode_scope(raw_scopes)
+      scopes = {}
+      raw_scopes.each do |collection_name, value|
+        scopes[collection_name] = value['scope'] unless value['scope'].nil?
       end
-      filter
-    end
 
-    def self.invalidate_scope_cache(rendering_id)
-      @@scopes_cache.delete(rendering_id)
+      scopes
     end
   end
 end

app/services/forest_liana/utils/context_variables.rb

@@ -0,0 +1,41 @@
+module ForestLiana
+  module Utils
+    class ContextVariables
+      attr_reader :team, :user, :request_context_variables
+
+      USER_VALUE_PREFIX = 'currentUser.'.freeze
+
+      USER_VALUE_TAG_PREFIX = 'currentUser.tags.'.freeze
+
+      USER_VALUE_TEAM_PREFIX = 'currentUser.team.'.freeze
+
+      def initialize(team, user, request_context_variables = nil)
+        @team = team
+        @user = user
+        @request_context_variables = request_context_variables
+      end
+
+      def get_value(context_variable_key)
+        return get_current_user_data(context_variable_key) if context_variable_key.start_with?(USER_VALUE_PREFIX)
+
+        request_context_variables[context_variable_key] if request_context_variables
+      end
+
+      private
+
+      def get_current_user_data(context_variable_key)
+        if context_variable_key.start_with?(USER_VALUE_TEAM_PREFIX)
+          return team[context_variable_key[USER_VALUE_TEAM_PREFIX.length..]]
+        end
+
+        if context_variable_key.start_with?(USER_VALUE_TAG_PREFIX)
+          user['tags'].each do |tag|
+            return tag[context_variable_key[USER_VALUE_TAG_PREFIX.length..]] if tag.key?(context_variable_key[USER_VALUE_TAG_PREFIX.length..])
+          end
+        end
+
+        user[context_variable_key[USER_VALUE_PREFIX.length..]]
+      end
+    end
+  end
+end

app/services/forest_liana/utils/context_variables_injector.rb

@@ -0,0 +1,53 @@
+module ForestLiana
+  module Utils
+    class ContextVariablesInjector
+
+      def self.inject_context_in_value(value, context_variables)
+        inject_context_in_value_custom(value) do |context_variable_key|
+          context_variables.get_value(context_variable_key).to_s
+        end
+      end
+
+      def self.inject_context_in_value_custom(value)
+        return value unless value.is_a?(String)
+
+        value_with_context_variables_injected = value
+        regex = /{{([^}]+)}}/
+        encountered_variables = []
+
+        while (match = regex.match(value_with_context_variables_injected))
+          context_variable_key = match[1]
+
+          unless encountered_variables.include?(context_variable_key)
+            value_with_context_variables_injected.gsub!(
+              /{{#{context_variable_key}}}/,
+              yield(context_variable_key)
+            )
+          end
+
+          encountered_variables.push(context_variable_key)
+        end
+
+        value_with_context_variables_injected
+      end
+
+      def self.inject_context_in_filter(filter, context_variables)
+        return nil unless filter
+
+        if filter.key? 'aggregator'
+          return {
+            'aggregator' => filter['aggregator'],
+            'conditions' => filter['conditions'].map { |condition| inject_context_in_filter(condition, context_variables) }
+          }
+        end
+
+        {
+          'field' => filter['field'],
+          'operator' => filter['operator'],
+          'value' => inject_context_in_value(filter['value'], context_variables)
+        }
+
+      end
+    end
+  end
+end

app/services/forest_liana/value_stat_getter.rb

@@ -6,7 +6,7 @@ def perform
       return if @params[:aggregator].blank?
       resource = optimize_record_loading(@resource, get_resource)
 
-      filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filter], @user, @resource.name)
+      filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filter], @user, @resource.name, @params['contextVariables'])
 
       unless filters.blank?
         filter_parser = FiltersParser.new(filters, resource, @params[:timezone], @params)

spec/requests/actions_controller_spec.rb

@@ -2,15 +2,15 @@
 
 describe 'Requesting Actions routes', :type => :request  do
   let(:rendering_id) { 13 }
-  let(:scope_filters) { nil }
+  let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
 
   before(:each) do
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
     Island.create(id: 1, name: 'Corsica')
 
     ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
-    allow(ForestLiana::ScopeManager).to receive(:get_scope_for_user).and_return(scope_filters)
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scope_filters)
   end
 
   after(:each) do
@@ -291,7 +291,21 @@
 
     describe 'with scopes' do
       describe 'when record is in scope' do
-        let(:scope_filters) { JSON.generate({ field: 'name', operator: 'equal', value: 'Corsica' }) }
+        let(:scope_filters) {
+          {
+            'scopes' =>
+              {
+                'Island' => {
+                  'aggregator' => 'and',
+                  'conditions' => [{'field' => 'name', 'operator' => 'equal', 'value' => 'Corsica'}]
+                }
+              },
+            'team' => {
+              'id' => 43,
+              'name' => 'Operations'
+            }
+          }
+        }
 
         it 'should respond 200 and perform the action' do
           post '/forest/actions/test', params: JSON.dump(params), headers: headers
@@ -301,7 +315,21 @@
       end
 
       describe 'when record is out of scope' do
-        let(:scope_filters) { JSON.generate({ field: 'name', operator: 'equal', value: 'Ré' }) }
+        let(:scope_filters) {
+          {
+            'scopes' =>
+              {
+                'Island' => {
+                  'aggregator' => 'and',
+                  'conditions' => [{'field' => 'name', 'operator' => 'equal', 'value' => 'Ré'}]
+                }
+              },
+            'team' => {
+              'id' => 43,
+              'name' => 'Operations'
+            }
+          }
+        }
 
         it 'should respond 400 and NOT perform the action' do
           post '/forest/actions/test', params: JSON.dump(params), headers: headers