forest_liana 9.11.0 → 9.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 850c5fe6679c01ceeebc7cf3bd4035a1d69845c434be482d1aec4e1a1e7cb509
-  data.tar.gz: d019665e403093766fa60323ed45df69c75e9ba6fb297fcdb4ce7099fee57ceb
+  metadata.gz: ef87edd50271f66059b83ec7b2b46ca943f65bba9e434ce559a41178922ffa93
+  data.tar.gz: 5f861a043a5674e29e985ded21a24e91c1e83dc83b43b152284739391fb1a9cb
 SHA512:
-  metadata.gz: 5d3190446adab7cebf81af3881bfd959f040b3e106250d3cd562b74cffb002528bb0fe0e0e0b986fcf631e8b3bdaf01937f607f1c86fbb1f5b32b8c3d998f807
-  data.tar.gz: 6a751f7b7e2ec02c3b09447d593bc390a05a1fb7ffe0c08cf3ab28fbfeae3dac5ea67039275e96d79f63ea1748b39b0133a98df36859b8ddd3f8d64651df2872
+  metadata.gz: 8b2eb6642cbdaf89e8ac091a0a7550728788ebc536e77d7a93e0d166cabaa7d1e25c5d4b911318d32cf92368d78fbab44be9836d0df1b23a50e86e2190089692
+  data.tar.gz: 22ee84aff57cb385a776de3485e880769dcaf25861fd5cbf1046cd6836ed9aaee877b5ae58f1335dfb15fb96206452e7972a6b1941c3b19c488448ee36666533

data/app/services/forest_liana/filters_parser.rb

@@ -84,7 +84,8 @@ module ForestLiana
       field_name = condition['field']
 
       if @operator_date_parser.is_date_operator?(operator)
-        condition = @operator_date_parser.get_date_filter(operator, value)
+        field_schema = SchemaUtils.find_column_schema_by_name(@resource.name, field_name)
+        condition = @operator_date_parser.get_date_filter(operator, value, field_schema)
         return "#{parse_field_name(field_name)} #{condition}"
       end
 
@@ -259,10 +260,12 @@ module ForestLiana
 
     def parse_previous_interval_condition(condition)
       raise_empty_condition_in_filter_error unless condition
+      field_schema = SchemaUtils.find_column_schema_by_name(@resource.name, condition['field'])
 
       parsed_condition = @operator_date_parser.get_date_filter_for_previous_interval(
         condition['operator'],
-        condition['value']
+        condition['value'],
+        field_schema
       )
 
       "#{parse_field_name(condition['field'])} #{parsed_condition}"

data/app/services/forest_liana/line_stat_getter.rb

@@ -14,7 +14,7 @@ module ForestLiana
         when 'day'
           '%d/%m/%Y'
         when 'week'
-          'W%V-%Y'
+          'W%V-%G'
         when 'month'
           '%b %Y'
         when 'year'

data/app/services/forest_liana/operator_date_interval_parser.rb

@@ -70,7 +70,16 @@ module ForestLiana
       date - @timezone_offset.hours
     end
 
-    def get_date_filter(operator, value)
+
+    def format_date(field_type, value)
+      if field_type == 'Dateonly'
+        return value.strftime('%Y-%m-%d')
+      end
+
+      value
+    end
+
+    def get_date_filter(operator, value, field_schema)
       return nil unless is_date_operator? operator
 
       filter = case operator
@@ -79,18 +88,18 @@ module ForestLiana
         when OPERATOR_PAST
           "<= '#{Time.now}'"
         when OPERATOR_TODAY
-          "BETWEEN '#{to_client_timezone(Time.now.beginning_of_day)}' " +
-            "AND '#{to_client_timezone(Time.now.end_of_day)}'"
+          "BETWEEN '#{format_date(field_schema[:type], to_client_timezone(Time.now.beginning_of_day))}' " +
+            "AND '#{format_date(field_schema[:type], to_client_timezone(Time.now.end_of_day))}'"
         when OPERATOR_PREVIOUS_X_DAYS
           ensure_integer_value(value)
           "BETWEEN '" +
-            "#{to_client_timezone(Integer(value).day.ago.beginning_of_day)}'" +
-            " AND '#{to_client_timezone(1.day.ago.end_of_day)}'"
+            "#{format_date(field_schema[:type], to_client_timezone(Integer(value).day.ago.beginning_of_day))}'" +
+            " AND '#{format_date(field_schema[:type], to_client_timezone(1.day.ago.end_of_day))}'"
         when OPERATOR_PREVIOUS_X_DAYS_TO_DATE
           ensure_integer_value(value)
           "BETWEEN '" +
-            "#{to_client_timezone((Integer(value) - 1).day.ago.beginning_of_day)}'" +
-            " AND '#{Time.now}'"
+            "#{format_date(field_schema[:type], to_client_timezone((Integer(value) - 1).day.ago.beginning_of_day))}'" +
+            " AND '#{format_date(field_schema[:type], Time.now)}'"
         when OPERATOR_BEFORE_X_HOURS_AGO
           ensure_integer_value(value)
           "< '#{(Integer(value)).hour.ago}'"
@@ -109,35 +118,35 @@ module ForestLiana
       to_date = PERIODS[operator][:to_date]
 
       if to_date
-        from = to_client_timezone(Time.now.send("beginning_of_#{period_of_time}"))
-        to = Time.now
+        from = format_date(field_schema[:type], to_client_timezone(Time.now.send("beginning_of_#{period_of_time}")))
+        to = format_date(field_schema[:type], Time.now)
       else
-        from = to_client_timezone(duration.send(period).ago
-          .send("beginning_of_#{period_of_time}"))
-        to = to_client_timezone(duration.send(period).ago
-          .send("end_of_#{period_of_time}"))
+        from = format_date(field_schema[:type], to_client_timezone(duration.send(period).ago
+          .send("beginning_of_#{period_of_time}")))
+        to = format_date(field_schema[:type], to_client_timezone(duration.send(period).ago
+          .send("end_of_#{period_of_time}")))
       end
 
       "BETWEEN '#{from}' AND '#{to}'"
     end
 
-    def get_date_filter_for_previous_interval(operator, value)
+    def get_date_filter_for_previous_interval(operator, value, field_schema)
       return nil unless has_previous_interval? operator
 
       case operator
       when OPERATOR_TODAY
-        return "BETWEEN '#{to_client_timezone(1.day.ago.beginning_of_day)}' AND " +
-          "'#{to_client_timezone(1.day.ago.end_of_day)}'"
+        return "BETWEEN '#{format_date(field_schema[:type], to_client_timezone(1.day.ago.beginning_of_day))}' AND " +
+          "'#{format_date(field_schema[:type], to_client_timezone(1.day.ago.end_of_day))}'"
       when OPERATOR_PREVIOUS_X_DAYS
         ensure_integer_value(value)
         return "BETWEEN '" +
-          "#{to_client_timezone((Integer(value) * 2).day.ago.beginning_of_day)}'" +
-          " AND '#{to_client_timezone((Integer(value) + 1).day.ago.end_of_day)}'"
+          "#{format_date(field_schema[:type], to_client_timezone((Integer(value) * 2).day.ago.beginning_of_day))}'" +
+          " AND '#{format_date(field_schema[:type], to_client_timezone((Integer(value) + 1).day.ago.end_of_day))}'"
       when OPERATOR_PREVIOUS_X_DAYS_TO_DATE
         ensure_integer_value(value)
         return "BETWEEN '" +
-          "#{to_client_timezone(((Integer(value) * 2) - 1).day.ago.beginning_of_day)}'" +
-          " AND '#{to_client_timezone(Integer(value).day.ago)}'"
+          "#{format_date(field_schema[:type], to_client_timezone(((Integer(value) * 2) - 1).day.ago.beginning_of_day))}'" +
+          " AND '#{format_date(field_schema[:type], to_client_timezone(Integer(value).day.ago))}'"
       end
 
       duration = PERIODS[operator][:duration]
@@ -146,14 +155,14 @@ module ForestLiana
       to_date = PERIODS[operator][:to_date]
 
       if to_date
-        from = to_client_timezone((duration)
-          .send(period).ago.send("beginning_of_#{period_of_time}"))
-        to = to_client_timezone((duration).send(period).ago)
+        from = format_date(field_schema[:type], to_client_timezone((duration)
+          .send(period).ago.send("beginning_of_#{period_of_time}")))
+        to = format_date(field_schema[:type], to_client_timezone((duration).send(period).ago))
       else
-        from = to_client_timezone((duration * 2).send(period).ago
-          .send("beginning_of_#{period_of_time}"))
-        to = to_client_timezone((duration * 2).send(period).ago
-          .send("end_of_#{period_of_time}"))
+        from = format_date(field_schema[:type], to_client_timezone((duration * 2).send(period).ago
+          .send("beginning_of_#{period_of_time}")))
+        to = format_date(field_schema[:type], to_client_timezone((duration * 2).send(period).ago
+          .send("end_of_#{period_of_time}")))
       end
 
       "BETWEEN '#{from}' AND '#{to}'"

data/app/services/forest_liana/schema_utils.rb

@@ -49,6 +49,23 @@ module ForestLiana
       model_found
     end
 
+    def self.find_column_schema_by_name(collection_name, field_name)
+      schema = ForestLiana.apimap.find { |collection| collection.name == collection_name }
+      if field_name.include?(':')
+        relation, field_name = field_name.split(':')
+        relation_schema = schema.fields.find do |field|
+          field[:field].to_s == relation
+        end
+        foreign_collection_name, = relation_schema[:reference].split('.')
+
+        return find_column_schema_by_name(foreign_collection_name, field_name)
+      else
+        return schema.fields.find do |field|
+          field[:field].to_s == field_name
+        end
+      end
+    end
+
     def self.tables_names
       ActiveRecord::Base.connection.tables
     end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.11.0"
+  VERSION = "9.11.2"
 end

data/spec/services/forest_liana/line_stat_getter_spec.rb

@@ -68,6 +68,25 @@ module ForestLiana
             expect(stat.value.find { |item| item[:label] == "W18-2021" }[:values][:value]).to eq(2)
             expect(stat.value.find { |item| item[:label] == "W19-2021" }[:values][:value]).to eq(2)
           end
+
+          it 'should return consistent data for a leap year with week transition' do
+            Owner.delete_all
+            Owner.create(name: 'Michel', hired_at: Date.parse('23-12-2024'));
+            Owner.create(name: 'Robert', hired_at: Date.parse('23-12-2024'));
+            Owner.create(name: 'José', hired_at: Date.parse('30-12-2024'));
+            Owner.create(name: 'Yves', hired_at: Date.parse('06-01-2025'));
+
+            stat = LineStatGetter.new(Owner, {
+              timezone: "Europe/Paris",
+              aggregator: "Count",
+              timeRange: "Week",
+              groupByFieldName: "hired_at",
+            }, user).perform
+
+            expect(stat.value.find { |item| item[:label] == "W52-2024" }[:values][:value]).to eq(2)
+            expect(stat.value.find { |item| item[:label] == "W01-2025" }[:values][:value]).to eq(1)
+            expect(stat.value.find { |item| item[:label] == "W02-2025" }[:values][:value]).to eq(1)
+          end
         end
       end
     end

data/test/services/forest_liana/operator_date_interval_parser_test.rb

@@ -3,12 +3,36 @@ module ForestLiana
     test 'OPERATOR_AFTER_X_HOURS_AGO and OPERATOR_BEFORE_X_HOURS_AGO should not take timezone into account' do
       # Setting a big timezone (GMT+10) on purpose, the timezone should not be applied on the result date
       operatorDateIntervalParser = OperatorDateIntervalParser.new('Australia/Sydney')
+      fake_field_schema = {
+        field: "foo",
+        type: "Dateonly",
+        is_filterable: true,
+        is_sortable: true,
+        is_read_only: false,
+        is_required: false,
+        is_virtual: false,
+        default_value: nil,
+        integration: nil,
+        reference: nil,
+        inverse_of: nil,
+        relationships: nil,
+        widget: nil,
+        validations: []
+      }
 
-      result = operatorDateIntervalParser.get_date_filter(OperatorDateIntervalParser::OPERATOR_AFTER_X_HOURS_AGO, 2)
+      result = operatorDateIntervalParser.get_date_filter(
+        OperatorDateIntervalParser::OPERATOR_AFTER_X_HOURS_AGO,
+        2,
+        fake_field_schema
+      )
       hourComputed = result.split('> ')[1].tr('\'', '').to_datetime.hour
       assert hourComputed == Time.now.utc.hour - 2
 
-      result = operatorDateIntervalParser.get_date_filter(OperatorDateIntervalParser::OPERATOR_BEFORE_X_HOURS_AGO, 2)
+      result = operatorDateIntervalParser.get_date_filter(
+        OperatorDateIntervalParser::OPERATOR_BEFORE_X_HOURS_AGO,
+        2,
+        fake_field_schema
+      )
       hourComputed = result.split('< ')[1].tr('\'', '').to_datetime.hour
       assert hourComputed == Time.now.utc.hour - 2
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.11.0
+  version: 9.11.2
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-19 00:00:00.000000000 Z
+date: 2025-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails