forest_liana 7.0.0.beta.2 → 7.0.0.beta.6

data/app/services/forest_liana/stat_getter.rb

@@ -2,9 +2,10 @@ module ForestLiana
   class StatGetter < BaseGetter
     attr_accessor :record
 
-    def initialize(resource, params)
+    def initialize(resource, params, forest_user)
       @resource = resource
       @params = params
+      @user = forest_user
       compute_includes()
     end
   end

data/app/services/forest_liana/token.rb

@@ -19,6 +19,7 @@ module ForestLiana
         first_name: user['first_name'],
         last_name: user['last_name'],
         team: user['teams'][0],
+        role: user['role'],
         rendering_id: rendering_id,
         exp: expiration_in_seconds()
       }, ForestLiana.auth_secret, 'HS256')

data/app/services/forest_liana/utils/beta_schema_utils.rb

@@ -6,7 +6,7 @@ module ForestLiana
 
         return nil unless collection
 
-        collection.actions.find { |action| action.endpoint == endpoint && action.http_method == http_method }
+        collection.actions.find { |action| (action.endpoint == endpoint || "/#{action.endpoint}" == endpoint) && action.http_method == http_method }
       end
     end
   end

data/app/services/forest_liana/value_stat_getter.rb

@@ -6,8 +6,10 @@ module ForestLiana
       return if @params[:aggregate].blank?
       resource = get_resource().eager_load(@includes)
 
-      unless @params[:filters].blank?
-        filter_parser = FiltersParser.new(@params[:filters], resource, @params[:timezone])
+      filters = ForestLiana::ScopeManager.append_scope_for_user(@params[:filters], @user, @resource.name)
+
+      unless filters.blank?
+        filter_parser = FiltersParser.new(filters, resource, @params[:timezone])
         resource = filter_parser.apply_filters
         raw_previous_interval = filter_parser.get_previous_interval_condition
 

data/config/routes.rb

@@ -20,6 +20,9 @@ ForestLiana::Engine.routes.draw do
   post '/stats/:collection' => 'stats#get'
   post '/stats' => 'stats#get_with_live_query'
 
+  # Scopes
+  post '/scope-cache-invalidation' => 'scopes#invalidate_scope_cache'
+
   # Stripe Integration
   get '(*collection)_stripe_payments' => 'stripe#payments'
   get ':collection/:id/stripe_payments' => 'stripe#payments'
@@ -57,7 +60,6 @@ ForestLiana::Engine.routes.draw do
   delete ':collection', to: router
 
   # Smart Actions forms value
-  post 'actions/:action_name/values' => 'actions#values'
   post 'actions/:action_name/hooks/load' => 'actions#load'
   post 'actions/:action_name/hooks/change' => 'actions#change'
 end

data/lib/forest_liana/bootstrapper.rb

@@ -203,10 +203,12 @@ module ForestLiana
 
     def setup_forest_liana_meta
       ForestLiana.meta = {
-        database_type: database_type,
         liana: 'forest-rails',
         liana_version: ForestLiana::VERSION,
-        orm_version: Gem.loaded_specs["activerecord"].version.version
+        stack: {
+           database_type: database_type,
+           orm_version: Gem.loaded_specs["activerecord"].version.version,
+        }
       }
     end
 

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "7.0.0.beta.2"
+  VERSION = "7.0.0.beta.6"
 end

data/spec/dummy/app/controllers/forest/islands_controller.rb

@@ -0,0 +1,5 @@
+class Forest::IslandsController < ForestLiana::SmartActionsController
+  def test
+    render json: { success: 'You are OK.' }
+  end
+end

data/spec/dummy/config/routes.rb

@@ -1,3 +1,7 @@
 Rails.application.routes.draw do
+  namespace :forest do
+    post '/actions/test' => 'islands#test'
+  end
+
   mount ForestLiana::Engine => "/forest"
 end

data/spec/dummy/lib/forest_liana/collections/island.rb

@@ -0,0 +1,7 @@
+class Forest::Island
+  include ForestLiana::Collection
+
+  collection :Island
+
+  action 'Test'
+end

data/spec/lib/forest_liana/bootstrapper_spec.rb

@@ -0,0 +1,12 @@
+module ForestLiana
+  describe Bootstrapper do
+    describe 'setup_forest_liana_meta' do
+      it "should put statistic data related to user stack on a dedicated object" do
+        expect(ForestLiana.meta[:stack])
+          .to include(:orm_version)
+        expect(ForestLiana.meta[:stack])
+          .to include(:database_type)
+      end
+    end
+  end
+end

data/spec/requests/actions_controller_spec.rb

@@ -1,23 +1,41 @@
 require 'rails_helper'
 
 describe 'Requesting Actions routes', :type => :request  do
+  let(:rendering_id) { 13 }
+  let(:scope_filters) { nil }
+
   before(:each) do
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
-    Island.create(name: 'Corsica')
+    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)
   end
 
   after(:each) do
     Island.destroy_all
   end
 
-  describe 'call /values' do
-    it 'should respond 200' do
-      post '/forest/actions/foo/values', {}
-      expect(response.status).to eq(200)
-      expect(response.body).to be {}
-    end
-  end
+  let(:token) {
+    JWT.encode({
+      id: 38,
+      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
+    }, ForestLiana.auth_secret, 'HS256')
+  }
+
+  let(:headers) {
+    {
+      'Accept' => 'application/json',
+      'Content-Type' => 'application/json',
+      'Authorization' => "Bearer #{token}"
+    }
+  }
 
   describe 'hooks' do
     foo = {
@@ -127,28 +145,32 @@ describe 'Requesting Actions routes', :type => :request  do
     island.actions = [action, fail_action, cheat_action, enums_action, multiple_enums_action]
 
     describe 'call /load' do
-      params = {recordIds: [1], collectionName: 'Island'}
+      params = {
+        data: {
+          attributes: { ids: [1], collection_name: 'Island' }
+        }
+      }
 
       it 'should respond 200' do
-        post '/forest/actions/my_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
+        post '/forest/actions/my_action/hooks/load', params: JSON.dump(params), headers: headers
         expect(response.status).to eq(200)
         expect(JSON.parse(response.body)).to eq({'fields' => [foo.merge({:value => nil}).stringify_keys]})
       end
 
       it 'should respond 500 with bad params' do
-        post '/forest/actions/my_action/hooks/load', params: {}
+        post '/forest/actions/my_action/hooks/load', params: {}, headers: headers
         expect(response.status).to eq(500)
         expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: cannot retrieve action from collection'})
       end
 
       it 'should respond 500 with bad hook result type' do
-        post '/forest/actions/fail_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
+        post '/forest/actions/fail_action/hooks/load', params: JSON.dump(params), headers: headers
         expect(response.status).to eq(500)
         expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
 
       it 'should respond 500 with bad hook result data structure' do
-        post '/forest/actions/cheat_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
+        post '/forest/actions/cheat_action/hooks/load', params: JSON.dump(params), headers: headers
         expect(response.status).to eq(500)
         expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
@@ -156,10 +178,19 @@ describe 'Requesting Actions routes', :type => :request  do
 
     describe 'call /change' do
       updated_foo = foo.clone.merge({:previousValue => nil, :value => 'bar'})
-      params = {recordIds: [1], fields: [updated_foo], collectionName: 'Island', changedField: 'foo'}
+      params = {
+        data: {
+          attributes: {
+            ids: [1],
+            fields: [updated_foo],
+            collection_name: 'Island',
+            changed_field: 'foo'
+          }
+        }
+      }
 
       it 'should respond 200' do
-        post '/forest/actions/my_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
+        post '/forest/actions/my_action/hooks/change', params: JSON.dump(params), headers: headers
         expect(response.status).to eq(200)
         expected = updated_foo.clone.merge({:value => 'baz'})
         expected[:widgetEdit] = nil
@@ -168,21 +199,30 @@ describe 'Requesting Actions routes', :type => :request  do
       end
 
       it 'should respond 500 with bad params' do
-        post '/forest/actions/my_action/hooks/change', params: JSON.dump({collectionName: 'Island'}), headers: { 'CONTENT_TYPE' => 'application/json' }
+        post '/forest/actions/my_action/hooks/change', params: JSON.dump({ data: { attributes: { collection_name: 'Island' }}}), headers: headers
         expect(response.status).to eq(500)
         expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action change hook: fields params is mandatory'})
       end
 
       it 'should respond 500 with bad hook result type' do
-        post '/forest/actions/fail_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
+        post '/forest/actions/fail_action/hooks/change', params: JSON.dump(params), headers: headers
         expect(response.status).to eq(500)
         expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
 
       it 'should reset value when enums has changed' do
         updated_enum = enum.clone.merge({:previousValue => nil, :value => 'a'}) # set value to a
-        p = {recordIds: [1], fields: [updated_foo, updated_enum], collectionName: 'Island', changedField: 'foo'}
-        post '/forest/actions/enums_action/hooks/change', params: JSON.dump(p), headers: { 'CONTENT_TYPE' => 'application/json' }
+        p = {
+          data: {
+            attributes: {
+              ids: [1],
+              fields: [updated_foo, updated_enum],
+              collection_name: 'Island',
+              changed_field: 'foo'
+            }
+          }
+        }
+        post '/forest/actions/enums_action/hooks/change', params: JSON.dump(p), headers: headers
         expect(response.status).to eq(200)
 
         expected_enum = updated_enum.clone.merge({ :enums => %w[c d e], :value => nil, :widgetEdit => nil})
@@ -195,8 +235,17 @@ describe 'Requesting Actions routes', :type => :request  do
 
       it 'should not reset value when every enum values are in the enums definition' do
         updated_multiple_enum = multiple_enum.clone.merge({:previousValue => nil, :value => %w[c]})
-        p = {recordIds: [1], fields: [foo, updated_multiple_enum], collectionName: 'Island', changedField: 'foo'}
-        post '/forest/actions/multiple_enums_action/hooks/change', params: JSON.dump(p), headers: { 'CONTENT_TYPE' => 'application/json' }
+        p = {
+          data: {
+            attributes: {
+              ids: [1],
+              fields: [foo, updated_multiple_enum],
+              collection_name: 'Island',
+              changed_field: 'foo'
+            }
+          }
+        }
+        post '/forest/actions/multiple_enums_action/hooks/change', params: JSON.dump(p), headers: headers
         expect(response.status).to eq(200)
 
         expected_multiple_enum = updated_multiple_enum.clone.merge({ :enums => %w[c d z], :widgetEdit => nil, :value => %w[c]})
@@ -209,8 +258,18 @@ describe 'Requesting Actions routes', :type => :request  do
 
       it 'should reset value when one of the enum values is not in the enums definition' do
         wrongly_updated_multiple_enum = multiple_enum.clone.merge({:previousValue => nil, :value => %w[a b]})
-        p = {recordIds: [1], fields: [foo, wrongly_updated_multiple_enum], collectionName: 'Island', changedField: 'foo'}
-        post '/forest/actions/multiple_enums_action/hooks/change', params: JSON.dump(p), headers: { 'CONTENT_TYPE' => 'application/json' }
+        p = {
+          data: {
+            attributes: {
+              ids: [1],
+              fields: [foo, wrongly_updated_multiple_enum],
+              collection_name: 'Island',
+              changed_field: 'foo'
+            }
+          }
+        }
+
+        post '/forest/actions/multiple_enums_action/hooks/change', params: JSON.dump(p), headers: headers
         expect(response.status).to eq(200)
 
         expected_multiple_enum = wrongly_updated_multiple_enum.clone.merge({ :enums => %w[c d z], :widgetEdit => nil, :value => nil })
@@ -222,4 +281,66 @@ describe 'Requesting Actions routes', :type => :request  do
       end
     end
   end
+
+  describe 'calling the action' do
+    before(:each) do
+      allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { true }
+    end
+
+    let(:all_records) { false }
+    let(:params) {
+      {
+        data: {
+          attributes: {
+            collection_name: 'Island',
+            ids: ['1'],
+            all_records: all_records,
+            smart_action_id: 'Island-Test'
+          },
+          type: 'custom-action-requests'
+        },
+        timezone: 'Europe/Paris'
+      }
+    }
+
+    describe 'without scopes' do
+      it 'should respond 200 and perform the action' do
+        post '/forest/actions/test', params: JSON.dump(params), headers: headers
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)).to eq({'success' => 'You are OK.'})
+      end
+    end
+
+    describe 'with scopes' do
+      describe 'when record is in scope' do
+        let(:scope_filters) { JSON.generate({ field: 'name', operator: 'equal', value: 'Corsica' }) }
+
+        it 'should respond 200 and perform the action' do
+          post '/forest/actions/test', params: JSON.dump(params), headers: headers
+          expect(response.status).to eq(200)
+          expect(JSON.parse(response.body)).to eq({'success' => 'You are OK.'})
+        end
+      end
+
+      describe 'when record is out of scope' do
+        let(:scope_filters) { JSON.generate({ field: 'name', operator: 'equal', value: 'Ré' }) }
+
+        it 'should respond 400 and NOT perform the action' do
+          post '/forest/actions/test', params: JSON.dump(params), headers: headers
+          expect(response.status).to eq(400)
+          expect(JSON.parse(response.body)).to eq({ 'error' => 'Smart Action: target record not found' })
+        end
+
+        describe 'and all_records are targeted' do
+          let(:all_records) { true }
+
+          it 'should respond 200 and perform the action' do
+            post '/forest/actions/test', params: JSON.dump(params), headers: headers
+            expect(response.status).to eq(200)
+            expect(JSON.parse(response.body)).to eq({'success' => 'You are OK.'})
+          end
+        end
+      end
+    end
+  end
 end

data/spec/requests/authentications_spec.rb

@@ -45,7 +45,7 @@ describe "Authentications", type: :request do
 
   describe "GET /authentication/callback" do
     before() do 
-      response = '{"data":{"id":666,"attributes":{"first_name":"Alice","last_name":"Doe","email":"alice@forestadmin.com","teams":[1,2,3]}}}'
+      response = '{"data":{"id":666,"attributes":{"first_name":"Alice","last_name":"Doe","email":"alice@forestadmin.com","teams":[1,2,3],"role":"Test"}}}'
       allow(ForestLiana::ForestApiRequester).to receive(:get).with(
         "/liana/v2/renderings/42/authorization", { :headers => { "forest-token" => "THE-ACCESS-TOKEN" }, :query=> {} }
       ).and_return(
@@ -72,6 +72,7 @@ describe "Authentications", type: :request do
         "first_name" => 'Alice',
         "last_name" => 'Doe',
         "team" => 1,
+        "role" => "Test",
       }
 
       expect(decoded).to include(expected_token_data)

data/spec/requests/resources_spec.rb

@@ -17,6 +17,8 @@ describe 'Requesting Tree resources', :type => :request  do
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
 
     allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { true }
+
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({})
   end
 
   token = JWT.encode({

data/spec/services/forest_liana/apimap_sorter_spec.rb

@@ -4,9 +4,11 @@ module ForestLiana
       context 'on a disordered apimap' do
         apimap = {
           'meta': {
-            'orm_version': '4.34.9',
+            stack: {
+              'orm_version': '4.34.9',
+              'database_type': 'postgresql',
+            },
             'liana_version': '1.5.24',
-            'database_type': 'postgresql',
             liana: 'forest-rails',
           },
           'data': [{
@@ -165,8 +167,8 @@ module ForestLiana
         end
 
         it 'should sort the meta values' do
-          expect(apimap_sorted['meta'].keys).to eq(
-            ['database_type', 'liana', 'liana_version', 'orm_version'])
+          expect(apimap_sorted['meta'].keys).to eq(['liana', 'liana_version', 'stack'])
+          expect(apimap_sorted['meta']['stack'].keys).to eq(['database_type', 'orm_version'])
         end
       end
     end

data/spec/services/forest_liana/filters_parser_spec.rb

@@ -281,7 +281,7 @@ module ForestLiana
       let(:result) { filter_parser.parse_condition(condition) }
 
       context 'on valid condition' do
-        it { expect(result).to eq "\"trees\".\"name\" LIKE '%3'" }
+        it { expect(result).to eq "\"trees\".\"name\" LIKE ('%3')" }
       end
 
       context 'on belongs_to condition' do

data/spec/services/forest_liana/has_many_getter_spec.rb

@@ -0,0 +1,116 @@
+module ForestLiana
+  describe HasManyGetter do
+    describe 'when retrieving has many relationship related records' do
+      let(:rendering_id) { 13 }
+      let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+      let(:scopes) { { } }
+      let(:association) { Island.reflect_on_association(:trees) }
+      let(:params) {
+        {
+          id: Island.first.id,
+          association_name: 'trees',
+          page: { size: 15, number: 1 },
+          timezone: 'America/Nome'
+        }
+      }
+
+      subject {
+        described_class.new(Island, association, params, user)
+      }
+
+      before(:each) do
+        madagascar = Island.create(name: 'madagascar')
+        re = Island.create(name: 'ré')
+        Tree.create(name: 'lemon tree', island: madagascar)
+        Tree.create(name: 'banana tree', island: madagascar)
+        Tree.create(name: 'papaya tree', island: madagascar)
+        Tree.create(name: 'apple tree', island: re)
+        Tree.create(name: 'banana tree', island: re)
+        ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+        allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+      end
+
+      after(:each) do
+        Island.destroy_all
+        Tree.destroy_all
+      end
+
+      describe 'with empty scopes' do
+        describe 'with page 1 size 15' do
+          it 'should return the 3 trees matching madagascar' do
+            subject.perform
+
+            expect(subject.records.count).to eq 3
+            expect(subject.count).to eq 3
+          end
+        end
+
+        describe 'when sorting by decreasing id' do
+          let(:params) {
+            {
+              id: Island.first.id,
+              association_name: 'trees',
+              sort: '-id',
+              page: { size: 15, number: 1 },
+              timezone: 'America/Nome'
+            }
+          }
+
+          it 'should order records properly' do
+            subject.perform
+
+            expect(subject.records.count).to eq 3
+            expect(subject.count).to eq 3
+            expect(subject.records.first.id).to be > subject.records.last.id
+          end
+        end
+
+        describe 'when searching for banana tree' do
+          let(:params) {
+            {
+              id: Island.first.id,
+              association_name: 'trees',
+              search: 'banana',
+              page: { size: 15, number: 1 },
+              timezone: 'America/Nome'
+            }
+          }
+
+          it 'should return only the banana tree linked to madagascar' do
+            subject.perform
+
+            expect(subject.records.count).to eq 1
+            expect(subject.count).to eq 1
+            expect(subject.records.first.island.name).to eq 'madagascar'
+          end
+        end
+      end
+
+      describe 'with scopes' do
+        let(:scopes) { {
+          'Tree' => {
+            'scope'=> {
+              'filter'=> {
+                'aggregator' => 'and',
+                'conditions' => [
+                  { 'field' => 'name', 'operator' => 'contains', 'value' => 'a' }
+                ]
+              },
+              'dynamicScopesValues' => { }
+            }
+          }
+        } }
+
+        describe 'when asking for all trees related to madagascar' do
+          it 'should return trees belonging to madagascar and matching the scopes' do
+            subject.perform
+
+            # Only `papaya` and `banana` contain an `a`
+            expect(subject.records.count).to eq 2
+            expect(subject.count).to eq 2
+          end
+        end
+      end
+    end
+  end
+end