forest_liana 5.3.3 → 5.4.4

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/resource_creator.rb

@@ -53,7 +53,7 @@ module ForestLiana
     end
 
     def has_strong_parameter
-      Rails::VERSION::MAJOR > 5 || @resource.instance_method(:update_attributes!).arity == 1
+      Rails::VERSION::MAJOR > 5 || @resource.instance_method(:update!).arity == 1
     end
   end
 end

data/app/services/forest_liana/resource_updater.rb

@@ -14,9 +14,9 @@ module ForestLiana
         @record = @resource.find(@params[:id])
 
         if has_strong_parameter
-          @record.update_attributes(resource_params)
+          @record.update(resource_params)
         else
-          @record.update_attributes(resource_params, without_protection: true)
+          @record.update(resource_params, without_protection: true)
         end
       rescue ActiveRecord::StatementInvalid => exception
         # NOTICE: SQL request cannot be executed properly
@@ -33,7 +33,7 @@ module ForestLiana
     end
 
     def has_strong_parameter
-      Rails::VERSION::MAJOR > 5 || @resource.instance_method(:update_attributes!).arity == 1
+      Rails::VERSION::MAJOR > 5 || @resource.instance_method(:update!).arity == 1
     end
   end
 end

data/app/services/forest_liana/schema_utils.rb

@@ -2,9 +2,14 @@ module ForestLiana
   class SchemaUtils
 
     def self.associations(active_record_class)
-      active_record_class
-        .reflect_on_all_associations
-        .select { |association| !polymorphic?(association) && !is_active_type?(association.klass) }
+      active_record_class.reflect_on_all_associations.select do |association|
+        begin
+          !polymorphic?(association) && !is_active_type?(association.klass)
+        rescue
+          FOREST_LOGGER.warn "Unknown association #{association.name} on class #{active_record_class.name}"
+          false
+        end
+      end
     end
 
     def self.one_associations(active_record_class)

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/stripe_invoice_getter.rb

@@ -11,7 +11,7 @@ module ForestLiana
       query = {}
       @record = ::Stripe::Invoice.retrieve(@params[:invoice_id])
 
-      @record.date = Time.at(@record.date).to_datetime
+      @record.due_date = Time.at(@record.due_date).to_datetime unless @record.due_date.nil?
       @record.period_start = Time.at(@record.period_start).to_datetime
       @record.period_end = Time.at(@record.period_end).to_datetime
       @record.subtotal /= 100.00

data/app/services/forest_liana/stripe_invoices_getter.rb

@@ -32,7 +32,7 @@ module ForestLiana
         end
 
         @records = @invoices.data.map do |d|
-          d.date = Time.at(d.date).to_datetime
+          d.date = Time.at(d.created).to_datetime
           d.period_start = Time.at(d.period_start).to_datetime
           d.period_end = Time.at(d.period_end).to_datetime
           d.subtotal /= 100.00

data/app/services/forest_liana/stripe_source_getter.rb

@@ -12,7 +12,7 @@ module ForestLiana
       customer = resource[field]
 
       @record = ::Stripe::Customer
-        .retrieve(customer)
+        .retrieve({ id: customer, expand: ['sources'] })
         .sources.retrieve(@params[:objectId])
 
       query = {}

data/app/services/forest_liana/stripe_sources_getter.rb

@@ -32,7 +32,7 @@ module ForestLiana
 
     def fetch_bank_accounts(customer, params)
       begin
-        @cards = ::Stripe::Customer.retrieve(customer).sources.list(params)
+        @cards = ::Stripe::Customer.retrieve({ id: customer, expand: ['sources'] }).sources.list(params)
         if @cards.blank?
           @records = []
           return

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/lib/forest_liana/bootstrapper.rb

@@ -430,19 +430,19 @@ module ForestLiana
         fields: [
           { field: :id, type: 'String', is_filterable: false },
           { field: :amount_due, type: 'Number', is_filterable: false },
+          { field: :amount_paid, type: 'Number', is_filterable: false },
+          { field: :amount_remaining, type: 'Number', is_filterable: false },
+          { field: :application_fee_amount, type: 'Number', is_filterable: false },
           { field: :attempt_count, type: 'Number', is_filterable: false },
           { field: :attempted, type: 'Boolean', is_filterable: false },
-          { field: :closed, type: 'Boolean', is_filterable: false },
           { field: :currency, type: 'String', is_filterable: false },
-          { field: :date, type: 'Date', is_filterable: false },
-          { field: :forgiven, type: 'Boolean', is_filterable: false },
+          { field: :due_date, type: 'Date', is_filterable: false },
           { field: :period_start, type: 'Date', is_filterable: false },
           { field: :period_end, type: 'Date', is_filterable: false },
+          { field: :status, type: 'String', enums: ['draft', 'open', 'paid', 'uncollectible', 'void'], is_filterable: false },
           { field: :subtotal, type: 'Number', is_filterable: false },
           { field: :total, type: 'Number', is_filterable: false },
-          { field: :application_fee, type: 'Number', is_filterable: false },
           { field: :tax, type: 'Number', is_filterable: false },
-          { field: :tax_percent, type: 'Number', is_filterable: false },
           {
             field: :customer,
             type: 'String',

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "5.3.3"
+  VERSION = "5.4.4"
 end

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1 @@
+{}

data/spec/dummy/config/application.rb

@@ -20,7 +20,7 @@ module Dummy
     # config.i18n.default_locale = :de
 
     # Do not swallow errors in after_commit/after_rollback callbacks.
-    config.active_record.raise_in_transactional_callbacks = true
+    # config.active_record.raise_in_transactional_callbacks = true
   end
 end
 

data/spec/dummy/db/migrate/20190226172951_create_user.rb

@@ -1,4 +1,4 @@
-class CreateUser < ActiveRecord::Migration
+class CreateUser < ActiveRecord::Migration[4.2]
   def change
     create_table :users do |t|
       t.string :name

data/spec/dummy/db/migrate/20190226173051_create_isle.rb

@@ -1,4 +1,4 @@
-class CreateIsle < ActiveRecord::Migration
+class CreateIsle < ActiveRecord::Migration[4.2]
   def change
     create_table :isle do |t|
       t.string :name

data/spec/dummy/db/migrate/20190226174951_create_tree.rb

@@ -1,4 +1,4 @@
-class CreateTree < ActiveRecord::Migration
+class CreateTree < ActiveRecord::Migration[4.2]
   def change
     create_table :trees do |t|
       t.string :name

data/spec/dummy/db/migrate/20190716130830_add_age_to_tree.rb

@@ -1,4 +1,4 @@
-class AddAgeToTree < ActiveRecord::Migration
+class AddAgeToTree < ActiveRecord::Migration[4.2]
   def up
     add_column :trees, :age, :integer
   end

data/spec/dummy/db/migrate/20190716135241_add_type_to_user.rb

@@ -1,4 +1,4 @@
-class AddTypeToUser < ActiveRecord::Migration
+class AddTypeToUser < ActiveRecord::Migration[4.2]
   def up
     add_column :users, :title, :integer
   end

data/spec/dummy/db/schema.rb

@@ -1,44 +1,42 @@
-# encoding: UTF-8
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
 #
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
+# This file is the source Rails uses to define your schema when running `rails
+# db:schema:load`. When creating a new database, `rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20190716135241) do
+ActiveRecord::Schema.define(version: 2019_07_16_135241) do
 
   create_table "isle", force: :cascade do |t|
-    t.string   "name"
-    t.binary   "map"
+    t.string "name"
+    t.binary "map"
     t.datetime "created_at"
     t.datetime "updated_at"
   end
 
   create_table "trees", force: :cascade do |t|
-    t.string   "name"
-    t.integer  "owner_id"
-    t.integer  "cutter_id"
-    t.integer  "island_id"
+    t.string "name"
+    t.integer "owner_id"
+    t.integer "cutter_id"
+    t.integer "island_id"
     t.datetime "created_at"
     t.datetime "updated_at"
-    t.integer  "age"
+    t.integer "age"
+    t.index ["cutter_id"], name: "index_trees_on_cutter_id"
+    t.index ["island_id"], name: "index_trees_on_island_id"
+    t.index ["owner_id"], name: "index_trees_on_owner_id"
   end
 
-  add_index "trees", ["cutter_id"], name: "index_trees_on_cutter_id"
-  add_index "trees", ["island_id"], name: "index_trees_on_island_id"
-  add_index "trees", ["owner_id"], name: "index_trees_on_owner_id"
-
   create_table "users", force: :cascade do |t|
-    t.string   "name"
+    t.string "name"
     t.datetime "created_at"
     t.datetime "updated_at"
-    t.integer  "title"
+    t.integer "title"
   end
 
 end

data/spec/requests/actions_controller_spec.rb

@@ -35,6 +35,11 @@ describe 'Requesting Actions routes', :type => :request  do
         type: 'Enum',
         enums: %w[a b c],
     }
+    multiple_enum = {
+        field: 'multipleEnum',
+        type: ['Enum'],
+        enums: %w[a b c],
+    }
 
     action_definition = {
         name: 'my_action',
@@ -95,34 +100,50 @@ describe 'Requesting Actions routes', :type => :request  do
         }
       }
     }
+
+    multiple_enums_action_definition = {
+        name: 'multiple_enums_action',
+        fields: [foo, multiple_enum],
+        hooks: {
+            :change => {
+                'foo' => -> (context) {
+                  fields = context[:fields]
+                  fields['multipleEnum'][:enums] = %w[c d z]
+                  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)
+    multiple_enums_action = ForestLiana::Model::Action.new(multiple_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]
+    island.actions = [action, fail_action, cheat_action, enums_action, multiple_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'
+        post '/forest/actions/my_action/hooks/load', params: JSON.dump(params), headers: { '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', {}
+        post '/forest/actions/my_action/hooks/load', params: {}
         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'
+        post '/forest/actions/fail_action/hooks/load', params: JSON.dump(params), headers: { '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'
+        post '/forest/actions/cheat_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
       end
     end
@@ -132,7 +153,7 @@ describe 'Requesting Actions routes', :type => :request  do
       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'
+        post '/forest/actions/my_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(200)
         expected = updated_foo.clone.merge({:value => 'baz'})
         expected[:widgetEdit] = nil
@@ -141,24 +162,24 @@ describe 'Requesting Actions routes', :type => :request  do
       end
 
       it 'should respond 500 with bad params' do
-        post '/forest/actions/my_action/hooks/change', {}
+        post '/forest/actions/my_action/hooks/change', params: {}
         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'
+        post '/forest/actions/fail_action/hooks/change', params: JSON.dump(params), headers: { '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'
+        post '/forest/actions/cheat_action/hooks/change', params: JSON.dump(params), headers: { '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'
+        post '/forest/actions/enums_action/hooks/change', params: JSON.dump(p), headers: { '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})
@@ -169,6 +190,33 @@ describe 'Requesting Actions routes', :type => :request  do
         expect(JSON.parse(response.body)).to eq({'fields' => [expected_foo.stringify_keys, expected_enum.stringify_keys]})
       end
 
+      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' }
+        expect(response.status).to eq(200)
+
+        expected_multiple_enum = updated_multiple_enum.clone.merge({ :enums => %w[c d z], :widgetEdit => nil, :value => %w[c]})
+        expected_multiple_enum.delete(:widget)
+        expected_foo = foo.clone.merge({ :widgetEdit => nil})
+        expected_foo.delete(:widget)
+
+        expect(JSON.parse(response.body)).to eq({'fields' => [expected_foo.stringify_keys, expected_multiple_enum.stringify_keys]})
+      end
+
+      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' }
+        expect(response.status).to eq(200)
+
+        expected_multiple_enum = wrongly_updated_multiple_enum.clone.merge({ :enums => %w[c d z], :widgetEdit => nil, :value => nil })
+        expected_multiple_enum.delete(:widget)
+        expected_foo = foo.clone.merge({ :widgetEdit => nil})
+        expected_foo.delete(:widget)
+
+        expect(JSON.parse(response.body)).to eq({'fields' => [expected_foo.stringify_keys, expected_multiple_enum.stringify_keys]})
+      end
     end
   end
-end
+end