forest_liana 5.2.3 → 5.4.0

data/app/services/forest_liana/permissions_formatter.rb

@@ -0,0 +1,52 @@
+module ForestLiana
+  class PermissionsFormatter
+    class << PermissionsFormatter
+      # Convert old format permissions to unify PermissionsGetter code
+      def convert_to_new_format(permissions, rendering_id)
+        permissions_new_format = Hash.new
+        permissions_new_format['collections'] = Hash.new
+        permissions_new_format['renderings'] = Hash.new
+        permissions_new_format['renderings'][rendering_id] = Hash.new
+        permissions.keys.each { |collection_name|
+          permissions_new_format['collections'][collection_name] = {
+            'collection' => convert_collection_permissions_to_new_format(permissions[collection_name]['collection']),
+            'actions' => convert_actions_permissions_to_new_format(permissions[collection_name]['actions'])
+          }
+
+          permissions_new_format['renderings'][rendering_id][collection_name] = { 'scope' => permissions[collection_name]['scope'] }
+        }
+
+        permissions_new_format
+      end
+
+      def convert_collection_permissions_to_new_format(collection_permissions)
+        {
+          'browseEnabled' => collection_permissions['list'] || collection_permissions['searchToEdit'],
+          'readEnabled' => collection_permissions['show'],
+          'addEnabled' => collection_permissions['create'],
+          'editEnabled' => collection_permissions['update'],
+          'deleteEnabled' => collection_permissions['delete'],
+          'exportEnabled' => collection_permissions['export']
+        }
+      end
+
+      def convert_actions_permissions_to_new_format(actions_permissions)
+        return nil unless actions_permissions
+
+        actions_permissions_new_format = Hash.new
+
+        actions_permissions.keys.each { |action_name|
+          allowed = actions_permissions[action_name]['allowed']
+          users = actions_permissions[action_name]['users']
+
+          actions_permissions_new_format[action_name] = Hash.new
+          actions_permissions_new_format[action_name] = {
+            'triggerEnabled' => allowed && (users.nil? || users)
+          }
+        }
+
+        actions_permissions_new_format
+      end
+    end
+  end
+end

data/app/services/forest_liana/permissions_getter.rb

@@ -1,25 +1,60 @@
 module ForestLiana
   class PermissionsGetter
-    def initialize(rendering_id)
-      @route = "/liana/v2/permissions"
-      @rendering_id = rendering_id
-    end
+    class << PermissionsGetter
+      def get_permissions_api_route
+        '/liana/v3/permissions'
+      end
+
+      # Permission format example:
+      # collections => {
+      #   {model_name} => {
+      #     collection => {
+      #       browseEnabled => true,
+      #       readEnabled => true,
+      #       editEnabled => true,
+      #       addEnabled => true,
+      #       deleteEnabled => true,
+      #       exportEnabled => true,
+      #     },
+      #     actions => {
+      #       {action_name} => {
+      #         triggerEnabled => true,
+      #       },
+      #     },
+      #   },
+      # },
+      # rederings => {
+      #   {rendering_id} => {
+      #       {collection_id} => {
+      #         scope => {
+      #           dynamicScopesValues => {},
+      #           filter => {}
+      #         }
+      #       }
+      #     }
+      #   }
+      # }
+      # With `rendering_specific_only` this returns only the permissions related data specific to the provided rendering
+      # For now this only includes scopes
+      def get_permissions_for_rendering(rendering_id, rendering_specific_only: false)
+        begin
+          query_parameters = { 'renderingId' => rendering_id }
+          query_parameters['renderingSpecificOnly'] = rendering_specific_only if rendering_specific_only
 
-    def perform
-      begin
-        query_parameters = { 'renderingId' => @rendering_id }
-        response = ForestLiana::ForestApiRequester.get(@route, query: query_parameters)
+          api_route = get_permissions_api_route
+          response = ForestLiana::ForestApiRequester.get(api_route, query: query_parameters)
 
-        if response.is_a?(Net::HTTPOK)
-          JSON.parse(response.body)
-        else
-          raise "Forest API returned an #{ForestLiana::Errors::HTTPErrorHelper.format(response)}"
+          if response.is_a?(Net::HTTPOK)
+            JSON.parse(response.body)
+          else
+            raise "Forest API returned an #{ForestLiana::Errors::HTTPErrorHelper.format(response)}"
+          end
+        rescue => exception
+          FOREST_LOGGER.error 'Cannot retrieve the permissions from the Forest server.'
+          FOREST_LOGGER.error 'Which was caused by:'
+          ForestLiana::Errors::ExceptionHelper.recursively_print(exception, margin: ' ', is_error: true)
+          nil
         end
-      rescue => exception
-        FOREST_LOGGER.error 'Cannot retrieve the permissions from the Forest server.'
-        FOREST_LOGGER.error 'Which was caused by:'
-        ForestLiana::Errors::ExceptionHelper.recursively_print(exception, margin: ' ', is_error: true)
-        nil
       end
     end
   end

data/app/services/forest_liana/resources_getter.rb

@@ -12,11 +12,11 @@ module ForestLiana
       @collection = get_collection(@collection_name)
       @fields_to_serialize = get_fields_to_serialize
       @field_names_requested = field_names_requested
-      get_segment()
-      compute_includes()
+      get_segment
+      compute_includes
       @search_query_builder = SearchQueryBuilder.new(@params, @includes, @collection)
 
-      prepare_query()
+      prepare_query
     end
 
     def self.get_ids_from_request(params)

data/app/services/forest_liana/scope_validator.rb

@@ -32,9 +32,10 @@ module ForestLiana
     def compute_condition_filters_from_scope(user_id)
       computed_condition_filters = @scope_filters.clone
       computed_condition_filters['conditions'].each do |condition|
-        if condition.include?('value') && 
-          !condition['value'].nil? && 
-          condition['value'].start_with?('$') && 
+        if condition.include?('value') &&
+          !condition['value'].nil? &&
+          condition['value'].instance_of?(String) &&
+          condition['value'].start_with?('$') &&
           @users_variable_values.include?(user_id)
           condition['value'] = @users_variable_values[user_id][condition['value']]
         end
@@ -51,9 +52,9 @@ module ForestLiana
       ensure_valid_aggregation(node)
 
       return is_scope_condition?(node) unless node['aggregator']
-  
+
       # NOTICE: Remove conditions that are not from the scope
-      filtered_conditions = node['conditions'].map { |condition| 
+      filtered_conditions = node['conditions'].map { |condition|
         search_scope_aggregation(condition)
       }.select { |condition|
         condition
@@ -61,7 +62,7 @@ module ForestLiana
 
       # NOTICE: If there is only one condition filter left and its current aggregator is
       #         an "and", this condition filter is the searched scope
-      if (filtered_conditions.length == 1 && 
+      if (filtered_conditions.length == 1 &&
         filtered_conditions.first.is_a?(Hash) &&
         filtered_conditions.first.include?(:aggregator) &&
         node['aggregator'] == 'and')
@@ -70,7 +71,7 @@ module ForestLiana
 
       # NOTICE: Otherwise, validate if the current node is the scope and return nil
       #         if it's not
-      return (filtered_conditions.length == @scope_filters['conditions'].length && 
+      return (filtered_conditions.length == @scope_filters['conditions'].length &&
         node['aggregator'] == @scope_filters['aggregator']) ?
         { aggregator: node['aggregator'], conditions: filtered_conditions } :
         nil

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

@@ -0,0 +1,13 @@
+module ForestLiana
+  module Utils
+    class BetaSchemaUtils
+      def self.find_action_from_endpoint(collection_name, endpoint, http_method)
+        collection = ForestLiana.apimap.find { |collection| collection.name.to_s == collection_name }
+
+        return nil unless collection
+
+        collection.actions.find { |action| action.endpoint == endpoint && action.http_method == http_method }
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -57,4 +57,6 @@ ForestLiana::Engine.routes.draw do
 
   # 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

@@ -38,6 +38,14 @@ module ForestLiana
 
     private
 
+    def get_collection(collection_name)
+      ForestLiana.apimap.find { |collection| collection.name.to_s == collection_name }
+    end
+
+    def get_action(collection, action_name)
+      collection.actions.find {|action| action.name == action_name}
+    end
+
     def generate_apimap
       create_apimap
       require_lib_forest_liana
@@ -45,6 +53,17 @@ module ForestLiana
 
       if Rails.env.development?
         @collections_sent = ForestLiana.apimap.as_json
+
+        @collections_sent.each do |collection|
+          collection['actions'].each do |action|
+            c = get_collection(collection['name'])
+            a = get_action(c, action['name'])
+            load = !a.hooks.nil? && a.hooks.key?(:load) && a.hooks[:load].is_a?(Proc)
+            change = !a.hooks.nil? && a.hooks.key?(:change) && a.hooks[:change].is_a?(Hash) ? a.hooks[:change].keys : []
+            action['hooks'] = {:load => load, :change => change}
+          end
+        end
+
         @meta_sent = ForestLiana.meta
         SchemaFileUpdater.new(SCHEMA_FILENAME, @collections_sent, @meta_sent).perform()
       else

data/lib/forest_liana/schema_file_updater.rb

@@ -50,6 +50,7 @@ module ForestLiana
       'redirect',
       'download',
       'fields',
+      'hooks',
     ]
     KEYS_ACTION_FIELD = [
       'field',

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "5.2.3"
+  VERSION = "5.4.0"
 end

data/spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb

@@ -0,0 +1,87 @@
+module ForestLiana
+  context 'IsSameDataStructure class' do
+    it 'should: be valid with simple data' do
+      object = {:a => 'a', :b => 'b'}
+      other = {:a => 'a', :b => 'b'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be true
+    end
+
+    it 'should: be invalid with simple data' do
+      object = {:a => 'a', :b => 'b'}
+      other = {:a => 'a', :c => 'c'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with not same hash' do
+      object = {:a => 'a', :b => 'b'}
+      other = {:a => 'a', :b => 'b', :c => 'c'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with nil' do
+      object = nil
+      other = {:a => 'a', :b => 'b', :c => 'c'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with not hash' do
+      object = nil
+      other = {:a => 'a', :b => 'b', :c => 'c'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with integer' do
+      object = 1
+      other = {:a => 'a', :b => 'b', :c => 'c'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with string' do
+      object = 'a'
+      other = {:a => 'a', :b => 'b', :c => 'c'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
+      expect(result).to be false
+    end
+
+    it 'should: be valid with depth 1' do
+      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
+      other = {:a => {:c => 'c'}, :b => {:d => 'd'}}
+      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
+      expect(result).to be true
+    end
+
+    it 'should: be invalid with depth 1' do
+      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
+      other = {:a => {:c => 'c'}, :b => {:e => 'e'}}
+      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with depth 1 and nil' do
+      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
+      other = {:a => {:c => 'c'}, :b => nil}
+      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with depth 1 and integer' do
+      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
+      other = {:a => {:c => 'c'}, :b => 1}
+      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
+      expect(result).to be false
+    end
+
+    it 'should: be invalid with depth 1 and string' do
+      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
+      other = {:a => {:c => 'c'}, :b => 'b'}
+      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
+      expect(result).to be false
+    end
+  end
+end

data/spec/requests/actions_controller_spec.rb

@@ -0,0 +1,174 @@
+require 'rails_helper'
+
+describe 'Requesting Actions routes', :type => :request  do
+  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')
+  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
+
+  describe 'hooks' do
+    foo = {
+        field: 'foo',
+        type: 'String',
+        default_value: nil,
+        enums: nil,
+        is_required: false,
+        reference: nil,
+        description: nil,
+        widget: nil,
+    }
+    enum = {
+        field: 'enum',
+        type: 'Enum',
+        enums: %w[a b c],
+    }
+
+    action_definition = {
+        name: 'my_action',
+        fields: [foo],
+        hooks: {
+            :load => -> (context) {
+              context[:fields]
+            },
+            :change => {
+              'foo' => -> (context) {
+                fields = context[:fields]
+                fields['foo'][:value] = 'baz'
+                return fields
+              }
+            }
+        }
+    }
+    fail_action_definition = {
+        name: 'fail_action',
+        fields: [foo],
+        hooks: {
+            :load => -> (context) {
+              1
+            },
+            :change => {
+                'foo' => -> (context) {
+                  1
+                }
+            }
+        }
+    }
+    cheat_action_definition = {
+        name: 'cheat_action',
+        fields: [foo],
+        hooks: {
+            :load => -> (context) {
+              context[:fields]['baz'] = foo.clone.update({field: 'baz'})
+              context[:fields]
+            },
+            :change => {
+                'foo' => -> (context) {
+                  context[:fields]['baz'] = foo.clone.update({field: 'baz'})
+                  context[:fields]
+                }
+            }
+        }
+    }
+    enums_action_definition = {
+      name: 'enums_action',
+      fields: [foo, enum],
+      hooks: {
+        :change => {
+          'foo' => -> (context) {
+            fields = context[:fields]
+            fields['enum'][:enums] = %w[c d e]
+            return fields
+          }
+        }
+      }
+    }
+    action = ForestLiana::Model::Action.new(action_definition)
+    fail_action = ForestLiana::Model::Action.new(fail_action_definition)
+    cheat_action = ForestLiana::Model::Action.new(cheat_action_definition)
+    enums_action = ForestLiana::Model::Action.new(enums_action_definition)
+    island = ForestLiana.apimap.find {|collection| collection.name.to_s == ForestLiana.name_for(Island)}
+    island.actions = [action, fail_action, cheat_action, enums_action]
+
+    describe 'call /load' do
+      params = {recordIds: [1], collectionName: 'Island'}
+
+      it 'should respond 200' do
+        post '/forest/actions/my_action/hooks/load', JSON.dump(params), 'CONTENT_TYPE' => 'application/json'
+        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', {}
+        expect(response.status).to eq(500)
+      end
+
+      it 'should respond 500 with bad hook result type' do
+        post '/forest/actions/fail_action/hooks/load', JSON.dump(params), 'CONTENT_TYPE' => 'application/json'
+        expect(response.status).to eq(500)
+      end
+
+      it 'should respond 500 with bad hook result data structure' do
+        post '/forest/actions/cheat_action/hooks/load', JSON.dump(params), 'CONTENT_TYPE' => 'application/json'
+        expect(response.status).to eq(500)
+      end
+    end
+
+    describe 'call /change' do
+      updated_foo = foo.clone.merge({:previousValue => nil, :value => 'bar'})
+      params = {recordIds: [1], fields: [updated_foo], collectionName: 'Island', changedField: 'foo'}
+
+      it 'should respond 200' do
+        post '/forest/actions/my_action/hooks/change', JSON.dump(params), 'CONTENT_TYPE' => 'application/json'
+        expect(response.status).to eq(200)
+        expected = updated_foo.clone.merge({:value => 'baz'})
+        expected[:widgetEdit] = nil
+        expected.delete(:widget)
+        expect(JSON.parse(response.body)).to eq({'fields' => [expected.stringify_keys]})
+      end
+
+      it 'should respond 500 with bad params' do
+        post '/forest/actions/my_action/hooks/change', {}
+        expect(response.status).to eq(500)
+      end
+
+      it 'should respond 500 with bad hook result type' do
+        post '/forest/actions/fail_action/hooks/change', JSON.dump(params), 'CONTENT_TYPE' => 'application/json'
+        expect(response.status).to eq(500)
+      end
+
+      it 'should respond 500 with bad hook result data structure' do
+        post '/forest/actions/cheat_action/hooks/change', JSON.dump(params), 'CONTENT_TYPE' => 'application/json'
+        expect(response.status).to eq(500)
+      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', JSON.dump(p), 'CONTENT_TYPE' => 'application/json'
+        expect(response.status).to eq(200)
+
+        expected_enum = updated_enum.clone.merge({ :enums => %w[c d e], :value => nil, :widgetEdit => nil})
+        expected_enum.delete(:widget)
+        expected_foo = updated_foo.clone.merge({ :widgetEdit => nil})
+        expected_foo.delete(:widget)
+
+        expect(JSON.parse(response.body)).to eq({'fields' => [expected_foo.stringify_keys, expected_enum.stringify_keys]})
+      end
+
+    end
+  end
+end