forest_liana 9.14.3 → 9.14.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82aa2dffa179fa0be6398321388077e3ad04f66583969c4fbb68112983dcd5d6
-  data.tar.gz: 9e84f6554455e681cf00ca15cee8bb337c4e9ae22289e11959caa889297a0ee1
+  metadata.gz: 9ba28199210707c78a20dc527719d5a3b71e68079f6ca96f18602f978cb87f09
+  data.tar.gz: 60d8e40c7d69086c8c627f61e99bcd6612a5425285d29f3520596e01c0752103
 SHA512:
-  metadata.gz: 0cd4367dcab7b965bccf0b49e289509ce0b97b9763491b67273444c06db7a226d4c1fc019da63167567de45afcb752fb76751b4512d0c5ff0754f217679bac0d
-  data.tar.gz: 67eb9531fc902db2a9db22cffb6b53ba2f5ff9635f67ef5668db5b107102fb2ddac46b901fa56a7ac245c0fff3215c064b66cede4c37ea819985ce78539346dd
+  metadata.gz: 93ab4cf8bd8f375d38dae4ab1a337bd8a87d6fea98aff86f930468f4a293d60c2776a538916ce6816976f4dc8bf4e5823c809a44e36d684394859546be87adfc
+  data.tar.gz: 91471a98c2418ea67acdcac5e5d6539a611c7d6e717c35ee76a98189aeb71d94534c4535ca4e7c387eaa7d2997216594d4087e936c6bacb4561bd54cd7a0dbb1

data/app/serializers/forest_liana/serializer_factory.rb

@@ -146,7 +146,10 @@ module ForestLiana
                 @options[:fields][relation_class_name]&.size == 1 &&
                 @options[:fields][relation_class_name]&.include?(relation.klass.primary_key.to_sym)
 
-                attr_data[:attr_or_block] = proc {  relation.klass.new(relation.klass.primary_key => object.send(relation.foreign_key.to_sym)) }
+                attr_data[:attr_or_block] = proc {
+                  foreign_key_value = object.send(relation.foreign_key.to_sym)
+                  foreign_key_value.nil? ? nil : relation.klass.new(relation.klass.primary_key => foreign_key_value)
+                }
               end
             end
 

data/app/services/forest_liana/aggregation_helper.rb

@@ -0,0 +1,42 @@
+module ForestLiana
+  module AggregationHelper
+    def resolve_field_path(field_param, default_field = 'id')
+      if field_param.blank?
+        default_field ||= @resource.primary_key || 'id'
+        return "#{@resource.table_name}.#{default_field}"
+      end
+
+      if field_param.include?(':')
+        association, field = field_param.split ':'
+        associated_resource = @resource.reflect_on_association(association.to_sym)
+        "#{associated_resource.table_name}.#{field}"
+      else
+        "#{@resource.table_name}.#{field_param}"
+      end
+    end
+
+    def aggregation_sql(type, field)
+      field_path = resolve_field_path(field)
+
+      case type
+      when 'sum'
+        "SUM(#{field_path})"
+      when 'count'
+        "COUNT(DISTINCT #{field_path})"
+      else
+        raise "Unsupported aggregator : #{type}"
+      end
+    end
+
+    def aggregation_alias(type, field)
+      case type
+      when 'sum'
+        "sum_#{field.downcase}"
+      when 'count'
+        'count_id'
+      else
+        raise "Unsupported aggregator : #{type}"
+      end
+    end
+  end
+end

data/app/services/forest_liana/leaderboard_stat_getter.rb

@@ -1,6 +1,9 @@
 module ForestLiana
   class LeaderboardStatGetter < StatGetter
+    include AggregationHelper
+
     def initialize(parent_model, params, forest_user)
+      @resource = parent_model
       @scoped_parent_model = get_scoped_model(parent_model, forest_user, params[:timezone])
       child_model = @scoped_parent_model.reflect_on_association(params[:relationshipFieldName]).klass
       @scoped_child_model = get_scoped_model(child_model, forest_user, params[:timezone])
@@ -14,13 +17,15 @@ module ForestLiana
     def perform
       includes = ForestLiana::QueryHelper.get_one_association_names_symbol(@scoped_child_model)
 
+      alias_name = aggregation_alias(@aggregate, @aggregate_field)
+
       result = @scoped_child_model
         .joins(includes)
         .where({ @scoped_parent_model.name.downcase.to_sym => @scoped_parent_model })
         .group(@group_by)
-        .order(order)
+        .order(Arel.sql("#{alias_name} DESC"))
         .limit(@limit)
-        .send(@aggregate, @aggregate_field)
+        .pluck(@group_by, Arel.sql("#{aggregation_sql(@aggregate, @aggregate_field)} AS #{alias_name}"))
         .map { |key, value| { key: key, value: value } }
 
       @record = Model::Stat.new(value: result)
@@ -33,18 +38,5 @@ module ForestLiana
 
       FiltersParser.new(scope_filters, model, timezone, @params).apply_filters
     end
-
-    def order
-      order = 'DESC'
-
-      # NOTICE: The generated alias for a count is "count_all", for a sum the
-      #         alias looks like "sum_#{aggregate_field}"
-      if @aggregate == 'sum'
-        field = @aggregate_field.downcase
-      else
-        field = 'all'
-      end
-      "#{@aggregate}_#{field} #{order}"
-    end
   end
 end

data/app/services/forest_liana/pie_stat_getter.rb

@@ -1,5 +1,6 @@
 module ForestLiana
   class PieStatGetter < StatGetter
+    include AggregationHelper
     attr_accessor :record
 
     def perform
@@ -13,11 +14,16 @@ module ForestLiana
           resource = FiltersParser.new(filters, resource, @params[:timezone], @params).apply_filters
         end
 
-        result = resource
-          .group(groupByFieldName)
-          .order(order)
-          .send(@params[:aggregator].downcase, @params[:aggregateFieldName])
-          .map do |key, value|
+        aggregation_type = @params[:aggregator].downcase
+        aggregation_field = @params[:aggregateFieldName]
+        alias_name = aggregation_alias(aggregation_type, aggregation_field)
+
+        resource = resource
+                     .group(groupByFieldName)
+                     .order(Arel.sql("#{alias_name} DESC"))
+                     .pluck(groupByFieldName, Arel.sql("#{aggregation_sql(aggregation_type, aggregation_field)} AS #{alias_name}"))
+
+        result = resource.map do |key, value|
             # NOTICE: Display the enum name instead of an integer if it is an
             #         "Enum" field type on old Rails version (before Rails
             #         5.1.3).
@@ -38,28 +44,7 @@ module ForestLiana
     end
 
     def groupByFieldName
-      if @params[:groupByFieldName].include? ':'
-        association, field = @params[:groupByFieldName].split ':'
-        resource = @resource.reflect_on_association(association.to_sym)
-        "#{resource.table_name}.#{field}"
-      else
-        "#{@resource.table_name}.#{@params[:groupByFieldName]}"
-      end
-    end
-
-    def order
-      order = 'DESC'
-
-      # NOTICE: The generated alias for a count is "count_all", for a sum the
-      #         alias looks like "sum_#{aggregateFieldName}"
-      if @params[:aggregator].downcase == 'sum'
-        field = @params[:aggregateFieldName].downcase
-      else
-        # `count_id` is required only for rails v5
-        field = Rails::VERSION::MAJOR == 5 || @includes.size > 0 ? 'id' : 'all'
-      end
-      "#{@params[:aggregator].downcase}_#{field} #{order}"
+      resolve_field_path(@params[:groupByFieldName])
     end
-
   end
 end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.14.3"
+  VERSION = "9.14.5"
 end

data/spec/dummy/app/models/tree.rb

@@ -1,7 +1,7 @@
 class Tree < ActiveRecord::Base
   belongs_to :owner, class_name: 'User', inverse_of: :trees_owned
   belongs_to :cutter, class_name: 'User', inverse_of: :trees_cut
-  belongs_to :island
+  belongs_to :island, optional: true
   belongs_to :eponymous_island,
     ->(record) { where(name: record.name) },
     class_name: 'Island',

data/spec/services/forest_liana/pie_stat_getter_spec.rb

@@ -133,5 +133,187 @@ module ForestLiana
         end
       end
     end
+
+    describe 'aggregation methods behavior' do
+      let(:scopes) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:groupByFieldName) { 'age' }
+
+      describe 'aggregation_sql method' do
+        subject { PieStatGetter.new(model, params, user) }
+
+        context 'with COUNT aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should generate correct COUNT SQL' do
+            sql = subject.send(:aggregation_sql, 'count', nil)
+            expect(sql).to eq 'COUNT(DISTINCT trees.id)'
+          end
+
+          it 'should generate correct COUNT SQL with specific field' do
+            sql = subject.send(:aggregation_sql, 'count', 'age')
+            expect(sql).to eq 'COUNT(DISTINCT trees.age)'
+          end
+        end
+
+        context 'with SUM aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Sum',
+              aggregateFieldName: 'age',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should generate correct SUM SQL' do
+            sql = subject.send(:aggregation_sql, 'sum', 'age')
+            expect(sql).to eq 'SUM(trees.age)'
+          end
+        end
+
+        context 'with association field' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: 'owner:name'
+            }
+          }
+
+          it 'should handle association fields correctly' do
+            # Assuming Tree belongs_to :owner
+            allow(model).to receive(:reflect_on_association).with(:owner).and_return(
+              double(table_name: 'owners')
+            )
+
+            sql = subject.send(:aggregation_sql, 'count', 'owner:id')
+            expect(sql).to eq 'COUNT(DISTINCT owners.id)'
+          end
+        end
+
+        context 'with unsupported aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Invalid',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should raise an error for unsupported aggregator' do
+            expect {
+              subject.send(:aggregation_sql, 'invalid', 'age')
+            }.to raise_error(ForestLiana::Errors::HTTP422Error)
+          end
+        end
+      end
+
+      describe 'aggregation_alias method' do
+        subject { PieStatGetter.new(model, params, user) }
+
+        context 'with COUNT aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return correct alias for count' do
+            alias_name = subject.send(:aggregation_alias, 'count', nil)
+            expect(alias_name).to eq 'count_id'
+          end
+        end
+
+        context 'with SUM aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Sum',
+              aggregateFieldName: 'age',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return correct alias for sum' do
+            alias_name = subject.send(:aggregation_alias, 'sum', 'age')
+            expect(alias_name).to eq 'sum_age'
+          end
+
+          it 'should handle field names with mixed case' do
+            alias_name = subject.send(:aggregation_alias, 'sum', 'TreeAge')
+            expect(alias_name).to eq 'sum_treeage'
+          end
+        end
+      end
+
+      describe 'results ordering' do
+        subject { PieStatGetter.new(model, params, user) }
+
+        context 'with COUNT aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return results ordered by count descending' do
+            subject.perform
+
+            expect(subject.record.value).to eq [
+                                                 { :key => 3, :value => 5},
+                                                 { :key => 15, :value => 4 }
+                                               ]
+          end
+        end
+
+        context 'with SUM aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Sum',
+              aggregateFieldName: 'age',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return results ordered by sum descending' do
+            subject.perform
+
+            expect(subject.record.value).to eq [
+                                                 { :key => 15, :value => 60 },
+                                                 { :key => 3, :value => 15 }
+                                               ]
+          end
+        end
+      end
+    end
   end
 end

data/spec/services/forest_liana/serializer_factory_spec.rb

@@ -0,0 +1,53 @@
+module ForestLiana
+  describe SerializerFactory do
+    describe '#serializer_for has_one_relationships patch' do
+      let(:user) { User.create!(name: 'PatchTest') }
+      let(:island) { Island.create!(name: 'TestIsland') }
+      let(:tree) { Tree.create!(name: 'TestTree', island: island, owner: user) }
+
+      it 'simulates has_one relation with only primary key' do
+        factory = described_class.new
+        serializer_class = factory.serializer_for(Tree)
+
+        serializer_class.send(:has_one, :island) { }
+
+        instance = serializer_class.new(tree, fields: {
+          'Island' => [:id],
+          'Tree' => [:island]
+        })
+
+        relationships = instance.send(:has_one_relationships)
+        expect(relationships).to have_key(:island)
+        relation_data = relationships[:island]
+        expect(relation_data[:attr_or_block]).to be_a(Proc)
+        model = relation_data[:attr_or_block].call
+
+        expect(model).to be_a(Island)
+        expect(model.id).to eq(island.id)
+      end
+
+      it 'returns nil if foreign key is nil' do
+        tree_without_island = Tree.create!(name: 'NoIslandTree', island_id: nil, owner: user)
+
+        factory = described_class.new
+        serializer_class = factory.serializer_for(Tree)
+
+        serializer_class.send(:has_one, :island) { }
+
+        instance = serializer_class.new(tree_without_island, fields: {
+          'Island' => [:id],
+          'Tree' => [:island]
+        })
+
+        relationships = instance.send(:has_one_relationships)
+        expect(relationships).to have_key(:island)
+        relation_data = relationships[:island]
+        expect(relation_data[:attr_or_block]).to be_a(Proc)
+        model = relation_data[:attr_or_block].call
+
+        expect(model).to be_nil
+      end
+
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.14.3
+  version: 9.14.5
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-19 00:00:00.000000000 Z
+date: 2025-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -254,6 +254,7 @@ files:
 - app/services/forest_liana/ability/permission.rb
 - app/services/forest_liana/ability/permission/request_permission.rb
 - app/services/forest_liana/ability/permission/smart_action_checker.rb
+- app/services/forest_liana/aggregation_helper.rb
 - app/services/forest_liana/apimap_sorter.rb
 - app/services/forest_liana/authentication.rb
 - app/services/forest_liana/authorization_getter.rb
@@ -431,6 +432,7 @@ files:
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
 - spec/services/forest_liana/scope_manager_spec.rb
+- spec/services/forest_liana/serializer_factory_spec.rb
 - spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/services/forest_liana/smart_action_form_parser_spec.rb
 - spec/services/forest_liana/utils/context_variables_injector_spec.rb
@@ -736,6 +738,7 @@ test_files:
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
 - spec/services/forest_liana/scope_manager_spec.rb
+- spec/services/forest_liana/serializer_factory_spec.rb
 - spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/services/forest_liana/smart_action_form_parser_spec.rb
 - spec/services/forest_liana/utils/context_variables_injector_spec.rb