forest_admin_agent 1.12.14 → 1.12.16

data/lib/forest_admin_agent/routes/resources/count.rb

@@ -15,24 +15,24 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:browse, @collection)
+          context = build(args)
+          context.permissions.can?(:browse, context.collection)
 
-          if @collection.is_countable?
+          if context.collection.is_countable?
             filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
               condition_tree: ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@collection),
-                  parse_query_segment(@collection, args, @permissions, @caller),
-                  ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(@collection, args)
+                  context.permissions.get_scope(context.collection),
+                  parse_query_segment(context.collection, args, context.permissions, context.caller),
+                  ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(context.collection, args)
                 ]
               ),
-              search: QueryStringParser.parse_search(@collection, args),
+              search: QueryStringParser.parse_search(context.collection, args),
               search_extended: QueryStringParser.parse_search_extended(args),
-              segment: QueryStringParser.parse_segment(@collection, args)
+              segment: QueryStringParser.parse_segment(context.collection, args)
             )
             aggregation = ForestAdminDatasourceToolkit::Components::Query::Aggregation.new(operation: 'Count')
-            result = @collection.aggregate(@caller, filter, aggregation)
+            result = context.collection.aggregate(context.caller, filter, aggregation)
 
             return {
               name: args[:params]['collection_name'],

data/lib/forest_admin_agent/routes/resources/csv.rb

@@ -19,25 +19,25 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:browse, @collection)
-          @permissions.can?(:export, @collection)
+          context = build(args)
+          context.permissions.can?(:browse, context.collection)
+          context.permissions.can?(:export, context.collection)
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTreeFactory.intersect(
               [
-                @permissions.get_scope(@collection),
-                parse_query_segment(@collection, args, @permissions, @caller),
+                context.permissions.get_scope(context.collection),
+                parse_query_segment(context.collection, args, context.permissions, context.caller),
                 QueryStringParser.parse_condition_tree(
-                  @collection, args
+                  context.collection, args
                 )
               ]
             ),
-            search: QueryStringParser.parse_search(@collection, args),
+            search: QueryStringParser.parse_search(context.collection, args),
             search_extended: QueryStringParser.parse_search_extended(args),
-            sort: QueryStringParser.parse_sort(@collection, args),
-            segment: QueryStringParser.parse_segment(@collection, args)
+            sort: QueryStringParser.parse_sort(context.collection, args),
+            segment: QueryStringParser.parse_segment(context.collection, args)
           )
-          projection = QueryStringParser.parse_projection(@collection, args)
+          projection = QueryStringParser.parse_projection(context.collection, args)
           filename = args[:params][:filename] || args[:params]['collection_name']
           filename += '.csv' unless /\.csv$/i.match?(filename)
           header = args[:params][:header]
@@ -47,7 +47,7 @@ module ForestAdminAgent
           filename_with_timestamp = filename.gsub('.csv', "_export_#{now}.csv")
 
           # Return streaming enumerator instead of full CSV string
-          list_records = ->(batch_filter) { @collection.list(@caller, batch_filter, projection) }
+          list_records = ->(batch_filter) { context.collection.list(context.caller, batch_filter, projection) }
 
           {
             content: {

data/lib/forest_admin_agent/routes/resources/delete.rb

@@ -17,35 +17,36 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:delete, @collection)
-          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-          delete_records(args, { ids: [primary_key_values], are_excluded: false })
+          context = build(args)
+          context.permissions.can?(:delete, context.collection)
+          primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
+          delete_records(args, { ids: [primary_key_values], are_excluded: false }, context)
 
           { content: nil, status: 204 }
         end
 
         def handle_request_bulk(args = {})
-          build(args)
-          @permissions.can?(:delete, @collection)
-          selection_ids = Utils::Id.parse_selection_ids(@collection, args[:params], with_key: true)
-          delete_records(args, selection_ids)
+          context = build(args)
+          context.permissions.can?(:delete, context.collection)
+          selection_ids = Utils::Id.parse_selection_ids(context.collection, args[:params], with_key: true)
+          delete_records(args, selection_ids, context)
 
           { content: nil, status: 204 }
         end
 
-        def delete_records(args, selection_ids)
-          condition_tree_ids = ConditionTree::ConditionTreeFactory.match_records(@collection, selection_ids[:ids])
+        def delete_records(args, selection_ids, context)
+          condition_tree_ids = ConditionTree::ConditionTreeFactory.match_records(context.collection,
+                                                                                 selection_ids[:ids])
           condition_tree_ids = condition_tree_ids.inverse if selection_ids[:are_excluded]
 
-          @collection.schema[:fields].each_value do |field_schema|
+          context.collection.schema[:fields].each_value do |field_schema|
             next unless ['PolymorphicOneToOne', 'PolymorphicOneToMany'].include?(field_schema.type)
 
             origin_values = selection_ids[:ids].map do |pk_hash|
               if pk_hash.is_a?(Hash)
                 pk_hash[field_schema.origin_key_target]
               else
-                pk_names = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(@collection)
+                pk_names = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(context.collection)
                 index = pk_names.index(field_schema.origin_key_target)
                 pk_hash[index] if index
               end
@@ -56,26 +57,26 @@ module ForestAdminAgent
               [
                 Nodes::ConditionTreeLeaf.new(field_schema.origin_key, Operators::IN, origin_values),
                 Nodes::ConditionTreeLeaf.new(field_schema.origin_type_field, Operators::EQUAL,
-                                             @collection.name.gsub('__', '::'))
+                                             context.collection.name.gsub('__', '::'))
               ]
             )
             filter = Filter.new(condition_tree: condition_tree)
-            @datasource.get_collection(field_schema.foreign_collection)
-                       .update(@caller, filter, { field_schema.origin_key => nil,
-                                                  field_schema.origin_type_field => nil })
+            context.datasource.get_collection(field_schema.foreign_collection)
+                   .update(context.caller, filter, { field_schema.origin_key => nil,
+                                                     field_schema.origin_type_field => nil })
           end
 
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect(
               [
-                Utils::QueryStringParser.parse_condition_tree(@collection, args),
+                Utils::QueryStringParser.parse_condition_tree(context.collection, args),
                 condition_tree_ids,
-                @permissions.get_scope(@collection)
+                context.permissions.get_scope(context.collection)
               ]
             )
           )
 
-          @collection.delete(@caller, filter)
+          context.collection.delete(context.caller, filter)
         end
       end
     end

data/lib/forest_admin_agent/routes/resources/list.rb

@@ -15,45 +15,45 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:browse, @collection)
+          context = build(args)
+          context.permissions.can?(:browse, context.collection)
 
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTreeFactory.intersect(
               [
-                @permissions.get_scope(@collection),
-                QueryStringParser.parse_condition_tree(@collection, args),
-                parse_query_segment(@collection, args, @permissions, @caller)
+                context.permissions.get_scope(context.collection),
+                QueryStringParser.parse_condition_tree(context.collection, args),
+                parse_query_segment(context.collection, args, context.permissions, context.caller)
               ]
             ),
             page: QueryStringParser.parse_pagination(args),
-            search: QueryStringParser.parse_search(@collection, args),
+            search: QueryStringParser.parse_search(context.collection, args),
             search_extended: QueryStringParser.parse_search_extended(args),
-            sort: QueryStringParser.parse_sort(@collection, args),
-            segment: QueryStringParser.parse_segment(@collection, args)
+            sort: QueryStringParser.parse_sort(context.collection, args),
+            segment: QueryStringParser.parse_segment(context.collection, args)
           )
 
-          projection = QueryStringParser.parse_projection_with_pks(@collection, args)
-          records = @collection.list(@caller, filter, projection)
+          projection = QueryStringParser.parse_projection_with_pks(context.collection, args)
+          records = context.collection.list(context.caller, filter, projection)
 
           {
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records,
-              class_name: @collection.name,
+              class_name: context.collection.name,
               is_collection: true,
               serializer: Serializer::ForestSerializer,
               include: projection.relations(only_keys: true),
-              meta: handle_search_decorator(args[:params]['search'], records)
+              meta: handle_search_decorator(args[:params]['search'], records, context.collection)
             )
           }
         end
 
-        def handle_search_decorator(search_value, records)
+        def handle_search_decorator(search_value, records, collection)
           decorator = { decorators: [] }
           unless search_value.nil?
             records.each_with_index do |entry, index|
-              decorator[:decorators][index] = { id: Utils::Id.pack_id(@collection, entry), search: [] }
+              decorator[:decorators][index] = { id: Utils::Id.pack_id(collection, entry), search: [] }
               # attributes method is defined on ActiveRecord::Base model
               attributes = entry.respond_to?(:attributes) ? entry.attributes : entry
 

data/lib/forest_admin_agent/routes/resources/native_query.rb

@@ -26,7 +26,7 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
+          context = build(args)
           query = args[:params][:query].strip
 
           QueryValidator.valid?(query)
@@ -34,31 +34,31 @@ module ForestAdminAgent
             raise ForestAdminAgent::Http::Exceptions::UnprocessableError, 'Missing native query connection attribute'
           end
 
-          @permissions.can_chart?(args[:params])
+          context.permissions.can_chart?(args[:params])
 
           query.gsub!('?', args[:params][:record_id].to_s) if args[:params][:record_id]
-          self.type = args[:params][:type]
+          type = validate_and_get_type(args[:params][:type])
           result = execute_query(
-            @datasource,
+            context.datasource,
             query,
             args[:params][:connectionName],
-            @permissions,
-            @caller,
+            context.permissions,
+            context.caller,
             args[:params][:contextVariables]
           )
 
-          { content: Serializer::ForestChartSerializer.serialize(send(:"make_#{@type}", result)) }
+          { content: Serializer::ForestChartSerializer.serialize(send(:"make_#{type}", result)) }
         end
 
         private
 
-        def type=(type)
+        def validate_and_get_type(type)
           chart_types = %w[Value Objective Pie Line Leaderboard]
           unless chart_types.include?(type)
             raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "Invalid Chart type #{type}"
           end
 
-          @type = type.downcase
+          type.downcase
         end
 
         def raise_error(result, key_names)

data/lib/forest_admin_agent/routes/resources/related/associate_related.rb

@@ -21,21 +21,21 @@ module ForestAdminAgent
           end
 
           def handle_request(args = {})
-            build(args)
-            @permissions.can?(:edit, @collection)
+            context = build(args)
+            context.permissions.can?(:edit, context.collection)
 
-            parent_primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-            target_primary_key_values = Utils::Id.unpack_id(@child_collection, args[:params]['data'][0]['id'],
+            parent_primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
+            target_primary_key_values = Utils::Id.unpack_id(context.child_collection, args[:params]['data'][0]['id'],
                                                             with_key: true)
-            relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
+            relation = Schema.get_to_many_relation(context.collection, args[:params]['relation_name'])
 
             case relation.type
             when 'OneToMany'
-              associate_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
+              associate_one_to_many(relation, parent_primary_key_values, target_primary_key_values, context)
             when 'ManyToMany'
-              associate_many_to_many(relation, parent_primary_key_values, target_primary_key_values)
+              associate_many_to_many(relation, parent_primary_key_values, target_primary_key_values, context)
             when 'PolymorphicOneToMany'
-              associate_polymorphic_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
+              associate_polymorphic_one_to_many(relation, parent_primary_key_values, target_primary_key_values, context)
             end
 
             { content: nil, status: 204 }
@@ -43,52 +43,55 @@ module ForestAdminAgent
 
           private
 
-          def associate_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
-            id = Schema.primary_keys(@child_collection)[0]
-            value = Collection.get_value(@child_collection, @caller, target_primary_key_values, id)
+          def associate_one_to_many(relation, parent_primary_key_values, target_primary_key_values, context)
+            id = Schema.primary_keys(context.child_collection)[0]
+            value = Collection.get_value(context.child_collection, context.caller, target_primary_key_values, id)
             filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
                   ConditionTree::Nodes::ConditionTreeLeaf.new(id, 'Equal', value),
-                  @permissions.get_scope(@collection)
+                  context.permissions.get_scope(context.collection)
                 ]
               )
             )
-            value = Collection.get_value(@collection, @caller, parent_primary_key_values, relation.origin_key_target)
+            value = Collection.get_value(context.collection, context.caller, parent_primary_key_values,
+                                         relation.origin_key_target)
 
-            @child_collection.update(@caller, filter, { relation.origin_key => value })
+            context.child_collection.update(context.caller, filter, { relation.origin_key => value })
           end
 
-          def associate_polymorphic_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
-            id = Schema.primary_keys(@child_collection)[0]
-            value = Collection.get_value(@child_collection, @caller, target_primary_key_values, id)
+          def associate_polymorphic_one_to_many(relation, parent_primary_key_values, target_primary_key_values, context)
+            id = Schema.primary_keys(context.child_collection)[0]
+            value = Collection.get_value(context.child_collection, context.caller, target_primary_key_values, id)
             filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
                   ConditionTree::Nodes::ConditionTreeLeaf.new(id, 'Equal', value),
-                  @permissions.get_scope(@collection)
+                  context.permissions.get_scope(context.collection)
                 ]
               )
             )
 
-            value = Collection.get_value(@collection, @caller, parent_primary_key_values, relation.origin_key_target)
+            value = Collection.get_value(context.collection, context.caller, parent_primary_key_values,
+                                         relation.origin_key_target)
 
-            @child_collection.update(
-              @caller,
+            context.child_collection.update(
+              context.caller,
               filter,
-              { relation.origin_key => value, relation.origin_type_field => @collection.name.gsub('__', '::') }
+              { relation.origin_key => value, relation.origin_type_field => context.collection.name.gsub('__', '::') }
             )
           end
 
-          def associate_many_to_many(relation, parent_primary_key_values, target_primary_key_values)
-            id = Schema.primary_keys(@child_collection)[0]
-            foreign_value = Collection.get_value(@child_collection, @caller, target_primary_key_values, id)
-            id = Schema.primary_keys(@collection)[0]
-            origin_value = Collection.get_value(@collection, @caller, parent_primary_key_values, id)
+          def associate_many_to_many(relation, parent_primary_key_values, target_primary_key_values, context)
+            id = Schema.primary_keys(context.child_collection)[0]
+            foreign_value = Collection.get_value(context.child_collection, context.caller, target_primary_key_values,
+                                                 id)
+            id = Schema.primary_keys(context.collection)[0]
+            origin_value = Collection.get_value(context.collection, context.caller, parent_primary_key_values, id)
             record = { relation.origin_key => origin_value, relation.foreign_key => foreign_value }
 
-            through_collection = @datasource.get_collection(relation.through_collection)
-            through_collection.create(@caller, record)
+            through_collection = context.datasource.get_collection(relation.through_collection)
+            through_collection.create(context.caller, record)
           end
         end
       end

data/lib/forest_admin_agent/routes/resources/related/count_related.rb

@@ -20,23 +20,23 @@ module ForestAdminAgent
           end
 
           def handle_request(args = {})
-            build(args)
-            @permissions.can?(:browse, @collection)
+            context = build(args)
+            context.permissions.can?(:browse, context.collection)
 
-            if @child_collection.is_countable?
-              filter = Filter.new(condition_tree: @permissions.get_scope(@collection))
-              primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            if context.child_collection.is_countable?
+              filter = Filter.new(condition_tree: context.permissions.get_scope(context.collection))
+              primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
               result = Collection.aggregate_relation(
-                @collection,
+                context.collection,
                 primary_key_values,
                 args[:params]['relation_name'],
-                @caller,
+                context.caller,
                 filter,
                 Aggregation.new(operation: 'Count')
               )
 
               return {
-                name: @child_collection.name,
+                name: context.child_collection.name,
                 content: {
                   count: result.empty? ? 0 : result[0]['value']
                 }
@@ -44,7 +44,7 @@ module ForestAdminAgent
             end
 
             {
-              name: @child_collection.name,
+              name: context.child_collection.name,
               content: {
                 count: 'deactivated'
               }

data/lib/forest_admin_agent/routes/resources/related/csv_related.rb

@@ -20,22 +20,23 @@ module ForestAdminAgent
           end
 
           def handle_request(args = {})
-            build(args)
-            @permissions.can?(:browse, @collection)
-            @permissions.can?(:export, @collection)
+            context = build(args)
+            context.permissions.can?(:browse, context.collection)
+            context.permissions.can?(:export, context.collection)
 
             filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
               condition_tree: ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@collection),
-                  ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(@child_collection, args)
+                  context.permissions.get_scope(context.collection),
+                  ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(context.child_collection, args)
                 ]
               )
             )
-            projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@child_collection, args)
+            projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(context.child_collection,
+                                                                                              args)
 
             # Get the parent record primary keys
-            primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
             relation_name = args[:params]['relation_name']
 
             # Generate timestamp for filename
@@ -47,10 +48,10 @@ module ForestAdminAgent
             # Create a callable to fetch related records
             list_records = lambda do |batch_filter|
               ForestAdminDatasourceToolkit::Utils::Collection.list_relation(
-                @collection,
+                context.collection,
                 primary_key_values,
                 relation_name,
-                @caller,
+                context.caller,
                 batch_filter,
                 projection
               )

data/lib/forest_admin_agent/routes/resources/related/dissociate_related.rb

@@ -20,28 +20,33 @@ module ForestAdminAgent
           end
 
           def handle_request(args = {})
-            build(args)
+            context = build(args)
 
-            parent_primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            parent_primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
             is_delete_mode = !args.dig(:params, :delete).nil?
 
             if is_delete_mode
-              @permissions.can?(:delete, @child_collection)
+              context.permissions.can?(:delete, context.child_collection)
             else
-              @permissions.can?(:edit, @collection)
+              context.permissions.can?(:edit, context.collection)
             end
 
-            filter = get_base_foreign_filter(args)
-            relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
+            filter = get_base_foreign_filter(args, context)
+            relation = Schema.get_to_many_relation(context.collection, args[:params]['relation_name'])
+
+            relation_name = args[:params]['relation_name']
+            options = {
+              relation: relation,
+              relation_name: relation_name,
+              parent_pk_values: parent_primary_key_values,
+              is_delete_mode: is_delete_mode,
+              filter: filter
+            }
 
             if ['OneToMany', 'PolymorphicOneToMany'].include?(relation.type)
-              dissociate_or_delete_one_to_many(
-                relation, args[:params]['relation_name'], parent_primary_key_values, is_delete_mode, filter
-              )
+              dissociate_or_delete_one_to_many(options, context)
             else
-              dissociate_or_delete_many_to_many(
-                relation, args[:params]['relation_name'], parent_primary_key_values, is_delete_mode, filter
-              )
+              dissociate_or_delete_many_to_many(options, context)
             end
 
             { content: nil, status: 204 }
@@ -49,51 +54,69 @@ module ForestAdminAgent
 
           private
 
-          def dissociate_or_delete_one_to_many(relation, relation_name, parent_primary_key_values, is_delete_mode,
-                                               filter)
-            foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_primary_key_values, relation_name,
-                                                               @caller, filter)
+          def dissociate_or_delete_one_to_many(options, context)
+            foreign_filter = FilterFactory.make_foreign_filter(
+              context.collection,
+              options[:parent_pk_values],
+              options[:relation_name],
+              context.caller,
+              options[:filter]
+            )
 
-            if is_delete_mode
-              @child_collection.delete(@caller, foreign_filter)
+            if options[:is_delete_mode]
+              context.child_collection.delete(context.caller, foreign_filter)
             else
-              patch = if relation.type == 'PolymorphicOneToMany'
-                        { relation.origin_key => nil, relation.origin_type_field => nil }
+              patch = if options[:relation].type == 'PolymorphicOneToMany'
+                        { options[:relation].origin_key => nil, options[:relation].origin_type_field => nil }
                       else
-                        { relation.origin_key => nil }
+                        { options[:relation].origin_key => nil }
                       end
-              @child_collection.update(@caller, foreign_filter, patch)
+              context.child_collection.update(context.caller, foreign_filter, patch)
             end
           end
 
-          def dissociate_or_delete_many_to_many(relation, relation_name, parent_primary_key_values, is_delete_mode,
-                                                filter)
-            through_collection = @datasource.get_collection(relation.through_collection)
+          def dissociate_or_delete_many_to_many(options, context)
+            through_collection = context.datasource.get_collection(options[:relation].through_collection)
 
-            if is_delete_mode
+            if options[:is_delete_mode]
               # Generate filters _BEFORE_ deleting stuff, otherwise things break.
-              foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_primary_key_values, relation_name,
-                                                                 @caller, filter)
-              through_filter = FilterFactory.make_through_filter(@collection, parent_primary_key_values, relation_name,
-                                                                 @caller, filter)
+              foreign_filter = FilterFactory.make_foreign_filter(
+                context.collection,
+                options[:parent_pk_values],
+                options[:relation_name],
+                context.caller,
+                options[:filter]
+              )
+              through_filter = FilterFactory.make_through_filter(
+                context.collection,
+                options[:parent_pk_values],
+                options[:relation_name],
+                context.caller,
+                options[:filter]
+              )
 
               # Delete records from through collection
-              through_collection.delete(@caller, through_filter)
+              through_collection.delete(context.caller, through_filter)
 
               # Let the datasource crash when:
               # - the records in the foreignCollection are linked to other records in the origin collection
               # - the underlying database/api is not cascading deletes
-              @child_collection.delete(@caller, foreign_filter)
+              context.child_collection.delete(context.caller, foreign_filter)
             else
-              through_filter = FilterFactory.make_through_filter(@collection, parent_primary_key_values, relation_name,
-                                                                 @caller, filter)
-              through_collection.delete(@caller, through_filter)
+              through_filter = FilterFactory.make_through_filter(
+                context.collection,
+                options[:parent_pk_values],
+                options[:relation_name],
+                context.caller,
+                options[:filter]
+              )
+              through_collection.delete(context.caller, through_filter)
             end
           end
 
-          def get_base_foreign_filter(args)
-            selection_ids = Utils::Id.parse_selection_ids(@child_collection, args[:params])
-            selected_ids = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, selection_ids[:ids])
+          def get_base_foreign_filter(args, context)
+            selection_ids = Utils::Id.parse_selection_ids(context.child_collection, args[:params])
+            selected_ids = ConditionTree::ConditionTreeFactory.match_ids(context.child_collection, selection_ids[:ids])
 
             selected_ids = selected_ids.inverse if selection_ids[:are_excluded]
 
@@ -104,8 +127,8 @@ module ForestAdminAgent
             Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@child_collection),
-                  Utils::QueryStringParser.parse_condition_tree(@child_collection, args),
+                  context.permissions.get_scope(context.child_collection),
+                  Utils::QueryStringParser.parse_condition_tree(context.child_collection, args),
                   selected_ids
                 ]
               )