forest_liana 9.1.9 → 9.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3862ddc61c276a741d24fa5abb2702b44a8fbee31046ad33eca60d9ad43f084
-  data.tar.gz: 775b29d9b6d45da178dfdcf83dd7c4ae1ae4d05f4485053bfc3864eff7058d6f
+  metadata.gz: b721a5f9e7e41711b05b4e34c607d8e23e7030646eb8896629b1170e55466869
+  data.tar.gz: 999494458850509c7698b2d00a77f2e8d41d767419b0e5b652ac8114b4fcbb9a
 SHA512:
-  metadata.gz: add3d6d36eb1c4fc96b82e8cbfaf9067cdd1c8b0c735c6bf6857c8a1592c810cffd9044a96edddd95ba912cc4512a8e2523915b144e871002ff2420091cf5611
-  data.tar.gz: c8c328ac81482846d8a9d0144319a9e9e17e64d01fb1ab84e155a68096b95b3174b8fae7cee7513d4c3b532d38085a3caacd4af06f19f52af53d2e6264d668ba
+  metadata.gz: 4fdc7007c031c6377f6d1281dad2ca82e1966d4692995ab592d149d6afe5c8b1a78bbc202ff5b558b3ee770f864a4caacb84c67ffc4aa79f1416ccaeb38c214d
+  data.tar.gz: e3dd0966176770f7b301a888480b72499025c2e0e1f727677a315f880397fa9903786eb2cb547cbdb6612b545c7a382d17c1ec5eeb95ab5496680bcde0bd8977

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

@@ -49,7 +49,7 @@ module ForestLiana
           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

data/app/services/forest_liana/filters_parser.rb

@@ -3,7 +3,7 @@ module ForestLiana
     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 @@ module ForestLiana
       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}"

data/app/services/forest_liana/leaderboard_stat_getter.rb

@@ -27,7 +27,7 @@ module ForestLiana
     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?
 

data/app/services/forest_liana/line_stat_getter.rb

@@ -25,7 +25,7 @@ module ForestLiana
     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

data/app/services/forest_liana/pie_stat_getter.rb

@@ -7,7 +7,7 @@ module ForestLiana
         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

data/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 @@ module ForestLiana
       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

data/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

data/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

data/app/services/forest_liana/value_stat_getter.rb

@@ -6,7 +6,7 @@ module ForestLiana
       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)

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.1.9"
+  VERSION = "9.2.0"
 end

data/spec/requests/actions_controller_spec.rb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 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 }
@@ -10,7 +10,7 @@ describe 'Requesting Actions routes', :type => :request  do
     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 'Requesting Actions routes', :type => :request  do
 
     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 @@ describe 'Requesting Actions routes', :type => :request  do
       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

data/spec/requests/count_spec.rb

@@ -15,7 +15,7 @@ describe 'Requesting Owner', :type => :request  do
 
     allow_any_instance_of(ForestLiana::Ability).to receive(:forest_authorize!) { true }
 
-    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({})
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}})
   end
 
   token = JWT.encode({

data/spec/requests/resources_spec.rb

@@ -1,10 +1,10 @@
 require 'rails_helper'
 
 describe 'Requesting Tree resources', :type => :request  do
-
+  let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
   before do
     user = User.create(name: 'Michel')
-    tree = Tree.create(name: 'Lemon Tree', owner: user, cutter: user)
+    Tree.create(name: 'Lemon Tree', owner: user, cutter: user)
 
     Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
     Rails.cache.write('forest.has_permission', true)
@@ -26,8 +26,7 @@ describe 'Requesting Tree resources', :type => :request  do
     allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
-    # allow_any_instance_of(ForestLiana::Ability).to receive(:forest_authorize!) { true }
-    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({})
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scope_filters)
   end
 
   after do
@@ -156,10 +155,10 @@ describe 'Requesting Tree resources', :type => :request  do
 end
 
 describe 'Requesting Address resources', :type => :request  do
-
+  let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
   before do
     user = User.create(name: 'Michel')
-    address = Address.create(line1: '10 Downing Street', city: 'London', zipcode: '2AB', addressable: user)
+    Address.create(line1: '10 Downing Street', city: 'London', zipcode: '2AB', addressable: user)
 
     Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
     Rails.cache.write('forest.has_permission', true)
@@ -181,7 +180,7 @@ describe 'Requesting Address resources', :type => :request  do
     allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
-    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({})
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scope_filters)
   end
 
   after do

data/spec/requests/stats_spec.rb

@@ -2,34 +2,39 @@ require 'rails_helper'
 require 'json'
 
 describe "Stats", type: :request do
-
-  token = JWT.encode({
-    id: 1,
-    email: 'michael.kelso@that70.show',
-    first_name: 'Michael',
-    last_name: 'Kelso',
-    team: 'Operations',
-    rendering_id: '1',
-    exp: Time.now.to_i + 2.weeks.to_i,
-    permission_level: 'admin'
-  }, ForestLiana.auth_secret, 'HS256')
-
-  headers = {
-    'Accept' => 'application/json',
-    'Content-Type' => 'application/json',
-    'Authorization' => "Bearer #{token}"
-  }
-
+  let(:rendering_id) { 13 }
+  let(:scopes) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
   let(:schema) {
     [
       ForestLiana::Model::Collection.new({
-        name: 'Product',
-        fields: [],
-        actions: []
-      })
+                                           name: 'Product',
+                                           fields: [],
+                                           actions: []
+                                         })
     ]
   }
 
+  let(:token) {
+      JWT.encode({
+      id: 1,
+      email: 'michael.kelso@that70.show',
+      first_name: 'Michael',
+      last_name: 'Kelso',
+      team: 'Operations',
+      rendering_id: rendering_id,
+      exp: Time.now.to_i + 2.weeks.to_i,
+      permission_level: 'admin'
+    }, ForestLiana.auth_secret, 'HS256')
+  }
+
+  let(:headers) {
+    {
+      'Accept' => 'application/json',
+      'Content-Type' => 'application/json',
+      'Authorization' => "Bearer #{token}"
+    }
+  }
+
   before do
     Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
     Rails.cache.write('forest.has_permission', true)
@@ -53,12 +58,8 @@ describe "Stats", type: :request do
           }
         )
 
-    ForestLiana::ScopeManager.class_variable_set(:@@scopes_cache, {
-      '1' => {
-        :fetched_at => Time.now,
-        :scopes => {}
-      }
-    })
+    ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
 
     allow(ForestLiana).to receive(:apimap).and_return(schema)
     allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }