feat(filter): add the possibility to filter on a smart field (#410)

Author: VincentMolinie

app/helpers/forest_liana/schema_helper.rb

@@ -4,5 +4,11 @@ def self.find_collection_from_model(active_record_class)
       collection_name = ForestLiana.name_for(active_record_class)
       ForestLiana.apimap.find { |collection| collection.name.to_s == collection_name }
     end
+
+    def self.is_smart_field?(model, field_name)
+      collection = self.find_collection_from_model(model)
+      field_found = collection.fields.find { |collection_field| collection_field[:field].to_s == field_name } if collection
+      field_found && field_found[:is_virtual]
+    end
   end
 end

app/services/forest_liana/filters_parser.rb

@@ -47,38 +47,64 @@ def parse_aggregation(node)
     end
 
     def parse_condition(condition)
-      ensure_valid_condition(condition)
+      where = parse_condition_without_smart_field(condition)
 
-      operator = condition['operator']
-      value = condition['value']
-      field = condition['field']
+      field_name = condition['field']
 
-      if @operator_date_parser.is_date_operator?(operator)
-        condition = @operator_date_parser.get_date_filter(operator, value)
-        return "#{parse_field_name(field)} #{condition}"
+      if ForestLiana::SchemaHelper.is_smart_field?(@resource, field_name)
+        schema = ForestLiana.schema_for_resource(@resource)
+        field_schema = schema.fields.find do |field|
+          field[:field].to_s == field_name
+        end
+
+        unless field_schema.try(:[], :filter)
+          raise ForestLiana::Errors::NotImplementedMethodError.new("method filter on smart field '#{field_name}' not found")
+        end
+
+        return field_schema[:filter].call(condition, where)
       end
 
-      if is_belongs_to(field)
-        association = field.partition(':').first.to_sym
-        association_field = field.partition(':').last
+      where
+    end
+
+    def get_association_field_and_resource(field_name)
+      if is_belongs_to(field_name)
+        association = field_name.partition(':').first.to_sym
+        association_field = field_name.partition(':').last
 
         unless @resource.reflect_on_association(association)
           raise ForestLiana::Errors::HTTP422Error.new("Association '#{association}' not found")
         end
 
         current_resource = @resource.reflect_on_association(association).klass
+
+        return association_field, current_resource
       else
-        association_field = field
-        current_resource = @resource
+        return field_name, @resource
       end
+    end
+
+    def parse_condition_without_smart_field(condition)
+      ensure_valid_condition(condition)
+
+      operator = condition['operator']
+      value = condition['value']
+      field_name = condition['field']
+
+      if @operator_date_parser.is_date_operator?(operator)
+        condition = @operator_date_parser.get_date_filter(operator, value)
+        return "#{parse_field_name(field_name)} #{condition}"
+      end
+
+      association_field, current_resource = get_association_field_and_resource(field_name)
 
       # NOTICE: Set the integer value instead of a string if "enum" type
       # NOTICE: Rails 3 do not have a defined_enums method
       if current_resource.respond_to?(:defined_enums) && current_resource.defined_enums.has_key?(association_field)
         value = current_resource.defined_enums[association_field][value]
       end
 
-      parsed_field = parse_field_name(field)
+      parsed_field = parse_field_name(field_name)
       parsed_operator = parse_operator(operator)
       parsed_value = parse_value(operator, value)
       field_and_operator = "#{parsed_field} #{parsed_operator}"
@@ -149,16 +175,16 @@ def parse_field_name(field)
 
         association = get_association_name_for_condition(field)
         quoted_table_name = ActiveRecord::Base.connection.quote_column_name(association)
-        quoted_field_name = ActiveRecord::Base.connection.quote_column_name(field.split(':')[1])
+        field_name = field.split(':')[1]
       else
         quoted_table_name = @resource.quoted_table_name
-        quoted_field_name = ActiveRecord::Base.connection.quote_column_name(field)
         current_resource = @resource
+        field_name = field
       end
+      quoted_field_name = ActiveRecord::Base.connection.quote_column_name(field_name)
 
       column_found = current_resource.columns.find { |column| column.name == field.split(':').last }
-
-      if column_found.nil?
+      if column_found.nil? && !ForestLiana::SchemaHelper.is_smart_field?(current_resource, field_name)
         raise ForestLiana::Errors::HTTP422Error.new("Field '#{field}' not found")
       end
 

config/initializers/errors.rb

@@ -46,6 +46,12 @@ def initialize(message = "Unprocessable Entity")
       end
     end
 
+    class NotImplementedMethodError < ExpectedError
+      def initialize(message = "Method not implemented")
+        super(501, :internal_server_error, message, 'MethodNotImplementedError')
+      end
+    end
+
     class InconsistentSecretAndRenderingError < ExpectedError
       def initialize(message=ForestLiana::MESSAGES[:SERVER_TRANSACTION][:SECRET_AND_RENDERINGID_INCONSISTENT])
         super(500, :internal_server_error, message, 'InconsistentSecretAndRenderingError')

spec/dummy/app/models/island.rb

@@ -2,4 +2,5 @@ class Island < ActiveRecord::Base
   self.table_name = 'isle'
 
   has_many :trees
+  has_one :location
 end

spec/dummy/app/models/location.rb

@@ -0,0 +1,3 @@
+class Location < ActiveRecord::Base
+  belongs_to :island
+end

spec/dummy/app/models/reference.rb

@@ -0,0 +1,2 @@
+class Reference < ActiveRecord::Base
+end

spec/dummy/db/migrate/20210326110524_create_references.rb

@@ -0,0 +1,8 @@
+class CreateReferences < ActiveRecord::Migration[6.0]
+  def change
+    create_table :references do |t|
+
+      t.timestamps
+    end
+  end
+end

spec/dummy/db/migrate/20210326140855_create_locations.rb

@@ -0,0 +1,10 @@
+class CreateLocations < ActiveRecord::Migration[6.0]
+  def change
+    create_table :locations do |t|
+      t.string :coordinates
+      t.references :island, index: true
+
+      t.timestamps
+    end
+  end
+end

spec/dummy/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 2019_07_16_135241) do
+ActiveRecord::Schema.define(version: 2021_03_26_140855) do
 
   create_table "isle", force: :cascade do |t|
     t.string "name"
@@ -19,6 +19,19 @@
     t.datetime "updated_at"
   end
 
+  create_table "locations", force: :cascade do |t|
+    t.string "coordinates"
+    t.integer "island_id"
+    t.datetime "created_at", precision: 6, null: false
+    t.datetime "updated_at", precision: 6, null: false
+    t.index ["island_id"], name: "index_locations_on_island_id"
+  end
+
+  create_table "references", force: :cascade do |t|
+    t.datetime "created_at", precision: 6, null: false
+    t.datetime "updated_at", precision: 6, null: false
+  end
+
   create_table "trees", force: :cascade do |t|
     t.string "name"
     t.integer "owner_id"

spec/dummy/lib/forest_liana/collections/location.rb

@@ -0,0 +1,10 @@
+class Forest::Location
+  include ForestLiana::Collection
+
+  collection :Location
+
+  field :alter_coordinates, type: 'String' do
+    object.name + 'XYZ'
+  end
+
+end