forest_liana 8.0.16 → 8.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d66f322c9f51d6beebaa2eb338b8f568f7d12bc781d71c4b47a8c2c3e6503c73
-  data.tar.gz: 37db17c392bac96b35c43595c03ef702e840ae40e420538151d36edc2a347c68
+  metadata.gz: ac43c231df7ce45742201f1824fc1733cf94dd2ccfc1f8ffaa214273f6f2f9c3
+  data.tar.gz: 5208918a6d4dde8b08e54077060f3a822c7b8126ec15838b7dd47bb0ebcb3464
 SHA512:
-  metadata.gz: 9466f6b82dc0ffbfae007bfc0024e5b831172dacdffcf00e51c58a8ca2333dbbefb165227a3d36b704954b1cdb75ecdfb9a5f2605840572220e612226e6cb39d
-  data.tar.gz: 5c313811aead7c0617d1e5d5d9c424f66e56b0482a46dc8354a1714b59f61490a728cc1cacb9224553110b0577b68712ba62366e8b214d6c7bddb2daffde4c7d
+  metadata.gz: 33843161d1f741d9a1786c19d21607f1c2e2bcd6c64994fafefd979c8f4268d1d6ea24261d59b89ed98f3ac14563472991a1a9bb631c612a8a87ab58b744d18a
+  data.tar.gz: f50308426ddf53f9e1599c94ed71f1d2458d281b094335e361f6570aad2657406a3c44bbb117084503304b35f8a70f3e197f491b2c4596757c831b0849cf340b

data/app/services/forest_liana/stat_getter.rb

@@ -6,9 +6,17 @@ module ForestLiana
       @resource = resource
       @params = params
       @user = forest_user
+
+      validate_params
       compute_includes
     end
 
+    def validate_params
+      if @params.key?(:aggregator) && !%w[count sum avg max min].include?(@params[:aggregator].downcase)
+        raise ForestLiana::Errors::HTTP422Error.new('Invalid aggregate function')
+      end
+    end
+
     def get_resource
       super
       @resource.reorder('')

data/app/services/forest_liana/value_stat_getter.rb

@@ -19,24 +19,25 @@ module ForestLiana
       end
 
       @record = Model::Stat.new(value: {
-        countCurrent: count(resource),
-        countPrevious: previous_value ? count(previous_value) : nil
+        countCurrent: aggregate(resource),
+        countPrevious: previous_value ? aggregate(previous_value) : nil
       })
     end
 
     private
 
-    def count(value)
-      uniq = @params[:aggregator].downcase == 'count'
+    def aggregate(value)
+      aggregator = @params[:aggregator].downcase
+      uniq = aggregator == 'count'
 
       if Rails::VERSION::MAJOR >= 4
         if uniq
           # NOTICE: uniq is deprecated since Rails 5.0
           value = Rails::VERSION::MAJOR >= 5 ? value.distinct : value.uniq
         end
-        value.send(@params[:aggregator].downcase, aggregate_field)
+        value.send(aggregator, aggregate_field)
       else
-        value.send(@params[:aggregator].downcase, aggregate_field, distinct: uniq)
+        value.send(aggregator, aggregate_field, distinct: uniq)
       end
     end
 

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "8.0.16"
+  VERSION = "8.0.17"
 end

data/spec/services/forest_liana/line_stat_getter_spec.rb

@@ -9,6 +9,19 @@ module ForestLiana
       allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
     end
 
+    describe 'with not allowed aggregator' do
+      it 'should raise an error' do
+        expect {
+          LineStatGetter.new(Owner, {
+            timezone: "Europe/Paris",
+            aggregator: "eval",
+            timeRange: "Week",
+            groupByFieldName: "`ls`",
+          }, user)
+        }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid aggregate function')
+      end
+    end
+
     describe 'Check client_timezone function' do
       describe 'with a SQLite database' do
         it 'should return false' do

data/spec/services/forest_liana/pie_stat_getter_spec.rb

@@ -23,90 +23,113 @@ module ForestLiana
       }
     end
 
-    let(:model) { Tree }
-    let(:collection) { 'trees' }
-    let(:params) {
-      {
-        type: 'Pie',
-        sourceCollectionName: collection,
-        timezone: 'Europe/Paris',
-        aggregator: 'Count',
-        groupByFieldName: groupByFieldName
+    describe 'with not allowed aggregator' do
+      let(:scopes) { { } }
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:params) {
+        {
+          type: 'Pie',
+          sourceCollectionName: collection,
+          timezone: 'Europe/Paris',
+          aggregator: 'eval',
+          groupByFieldName: '`ls`'
+        }
       }
-    }
 
-    subject { PieStatGetter.new(model, params, user) }
+      it 'should raise an error' do
+        expect {
+          PieStatGetter.new(model, params, user)
+        }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid aggregate function')
+      end
+    end
 
-    describe 'with empty scopes' do
-      let(:scopes) { { } }
+    describe 'with valid aggregate function' do
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:params) {
+        {
+          type: 'Pie',
+          sourceCollectionName: collection,
+          timezone: 'Europe/Paris',
+          aggregator: 'Count',
+          groupByFieldName: groupByFieldName
+        }
+      }
 
-      describe 'with an aggregate on the name field' do
-        let(:groupByFieldName) { 'name' }
-
-        it 'should be as many categories as records count' do
-          subject.perform
-          expect(subject.record.value).to match_array([
-            {:key => "Old Tree n1", :value => 1},
-            {:key => "Old Tree n2", :value => 1},
-            {:key => "Old Tree n3", :value => 1},
-            {:key => "Old Tree n4", :value => 1},
-            {:key => "Young Tree n1", :value => 1},
-            {:key => "Young Tree n2", :value => 1},
-            {:key => "Young Tree n3", :value => 1},
-            {:key => "Young Tree n4", :value => 1},
-            {:key => "Young Tree n5", :value => 1}
-          ])
+      subject { PieStatGetter.new(model, params, user) }
+
+      describe 'with empty scopes' do
+        let(:scopes) { { } }
+
+        describe 'with an aggregate on the name field' do
+          let(:groupByFieldName) { 'name' }
+
+          it 'should be as many categories as records count' do
+            subject.perform
+            expect(subject.record.value).to match_array([
+              {:key => "Old Tree n1", :value => 1},
+              {:key => "Old Tree n2", :value => 1},
+              {:key => "Old Tree n3", :value => 1},
+              {:key => "Old Tree n4", :value => 1},
+              {:key => "Young Tree n1", :value => 1},
+              {:key => "Young Tree n2", :value => 1},
+              {:key => "Young Tree n3", :value => 1},
+              {:key => "Young Tree n4", :value => 1},
+              {:key => "Young Tree n5", :value => 1}
+            ])
+          end
         end
-      end
 
-      describe 'with an aggregate on the age field' do
-        let(:groupByFieldName) { 'age' }
+        describe 'with an aggregate on the age field' do
+          let(:groupByFieldName) { 'age' }
 
-        it 'should be as many categories as different ages among records' do
-          subject.perform
-          expect(subject.record.value).to eq [{ :key => 3, :value => 5}, { :key => 15, :value => 4 }]
+          it 'should be as many categories as different ages among records' do
+            subject.perform
+            expect(subject.record.value).to eq [{ :key => 3, :value => 5}, { :key => 15, :value => 4 }]
+          end
         end
       end
-    end
 
-    describe 'with scopes' do
-      let(:scopes) {
-        {
-          'Tree' => {
-            'scope'=> {
-              'filter'=> {
-                'aggregator' => 'and',
-                'conditions' => [
-                  { 'field' => 'age', 'operator' => 'less_than', 'value' => 10 }
-                ]
-              },
-              'dynamicScopesValues' => { }
+      describe 'with scopes' do
+        let(:scopes) {
+          {
+            'Tree' => {
+              'scope'=> {
+                'filter'=> {
+                  'aggregator' => 'and',
+                  'conditions' => [
+                    { 'field' => 'age', 'operator' => 'less_than', 'value' => 10 }
+                  ]
+                },
+                'dynamicScopesValues' => { }
+              }
             }
           }
         }
-      }
 
-      describe 'with an aggregate on the name field' do
-        let(:groupByFieldName) { 'name' }
-
-        it 'should be as many categories as records inside the scope' do
-          subject.perform
-          expect(subject.record.value).to match_array([
-            {:key => "Young Tree n1", :value => 1},
-            {:key => "Young Tree n2", :value => 1},
-            {:key => "Young Tree n3", :value => 1},
-            {:key => "Young Tree n4", :value => 1},
-            {:key => "Young Tree n5", :value => 1}
-          ])
+        describe 'with an aggregate on the name field' do
+          let(:groupByFieldName) { 'name' }
+
+          it 'should be as many categories as records inside the scope' do
+            subject.perform
+            expect(subject.record.value).to match_array([
+              {:key => "Young Tree n1", :value => 1},
+              {:key => "Young Tree n2", :value => 1},
+              {:key => "Young Tree n3", :value => 1},
+              {:key => "Young Tree n4", :value => 1},
+              {:key => "Young Tree n5", :value => 1}
+            ])
+          end
         end
-      end
 
-      describe 'with an aggregate on the age field' do
-        let(:groupByFieldName) { 'age' }
+        describe 'with an aggregate on the age field' do
+          let(:groupByFieldName) { 'age' }
 
-        it 'should be only one category' do
-          subject.perform
-          expect(subject.record.value).to eq [{ :key => 3, :value => 5}]
+          it 'should be only one category' do
+            subject.perform
+            expect(subject.record.value).to eq [{ :key => 3, :value => 5}]
+          end
         end
       end
     end

data/spec/services/forest_liana/value_stat_getter_spec.rb

@@ -15,80 +15,103 @@ module ForestLiana
       Tree.create!(name: 'Tree n3', age: 4, island: island, owner: king, cutter: villager)
     end
 
-    let(:params) {
-      {
-        type: "Value",
-        sourceCollectionName: sourceCollectionName,
-        timezone: "Europe/Paris",
-        aggregator: "Count",
-        filter: filter
+    describe 'with not allowed aggregator' do
+      let(:model) { User }
+      let(:collection) { 'users' }
+      let(:scopes) { { } }
+      let(:params) {
+        {
+          type: "Value",
+          sourceCollectionName: collection,
+          timezone: "Europe/Paris",
+          aggregator: "eval",
+          aggregateFieldName: "`ls`"
+        }
       }
-    }
 
-    subject { ValueStatGetter.new(model, params, user) }
+      it 'should raise an error' do
+        expect {
+          ValueStatGetter.new(model, params, user)
+        }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid aggregate function')
+      end
+    end
 
-    describe 'with empty scopes' do
-      let(:scopes) { { } }
+    describe 'with valid aggregate function' do
+      let(:params) {
+        {
+          type: "Value",
+          sourceCollectionName: sourceCollectionName,
+          timezone: "Europe/Paris",
+          aggregator: "Count",
+          filter: filter
+        }
+      }
+
+      subject { ValueStatGetter.new(model, params, user) }
 
-      describe 'with a simple filter matching no entries' do
-        let(:model) { User }
-        let(:sourceCollectionName) { 'users' }
-        let(:filter) { { field: 'name', operator: 'in', value: ['Merry', 'Pippin'] }.to_json }
+      describe 'with empty scopes' do
+        let(:scopes) { { } }
 
-        it 'should have a countCurrent of 0' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 0
+        describe 'with a simple filter matching no entries' do
+          let(:model) { User }
+          let(:sourceCollectionName) { 'users' }
+          let(:filter) { { field: 'name', operator: 'in', value: ['Merry', 'Pippin'] }.to_json }
+
+          it 'should have a countCurrent of 0' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 0
+          end
         end
-      end
 
-      describe 'with a filter on a belongs_to string field' do
-        let(:model) { Tree }
-        let(:sourceCollectionName) { 'trees' }
-        let(:filter) { { field: 'owner:name', operator: 'equal', value: 'Aragorn' }.to_json }
+        describe 'with a filter on a belongs_to string field' do
+          let(:model) { Tree }
+          let(:sourceCollectionName) { 'trees' }
+          let(:filter) { { field: 'owner:name', operator: 'equal', value: 'Aragorn' }.to_json }
 
-        it 'should have a countCurrent of 2' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 2
+          it 'should have a countCurrent of 2' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 2
+          end
         end
-      end
 
-      describe 'with a filter on a belongs_to enum field' do
-        let(:model) { Tree }
-        let(:sourceCollectionName) { 'trees' }
-        let(:filter) { { field: 'owner:title', operator: 'equal', value: 'villager' }.to_json }
+        describe 'with a filter on a belongs_to enum field' do
+          let(:model) { Tree }
+          let(:sourceCollectionName) { 'trees' }
+          let(:filter) { { field: 'owner:title', operator: 'equal', value: 'villager' }.to_json }
 
-        it 'should have a countCurrent of 1' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 1
+          it 'should have a countCurrent of 1' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 1
+          end
         end
       end
-    end
 
-    describe 'with scopes' do
-      let(:scopes) {
-        {
-          'User' => {
-            'scope'=> {
-              'filter'=> {
-                'aggregator' => 'and',
-                'conditions' => [
-                  { 'field' => 'title', 'operator' => 'not_equal', 'value' => 'villager' }
-                ]
-              },
-              'dynamicScopesValues' => { }
+      describe 'with scopes' do
+        let(:scopes) {
+          {
+            'User' => {
+              'scope'=> {
+                'filter'=> {
+                  'aggregator' => 'and',
+                  'conditions' => [
+                    { 'field' => 'title', 'operator' => 'not_equal', 'value' => 'villager' }
+                  ]
+                },
+                'dynamicScopesValues' => { }
+              }
             }
           }
         }
-      }
 
-      describe 'with a filter on a belongs_to enum field' do
-        let(:model) { User }
-        let(:sourceCollectionName) { 'users' }
-        let(:filter) { { field: 'title', operator: 'equal', value: 'villager' }.to_json }
+        describe 'with a filter on a belongs_to enum field' do
+          let(:model) { User }
+          let(:sourceCollectionName) { 'users' }
+          let(:filter) { { field: 'title', operator: 'equal', value: 'villager' }.to_json }
 
-        it 'should have a countCurrent of 0' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 0
+          it 'should have a countCurrent of 0' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 0
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 8.0.16
+  version: 8.0.17
 platform: ruby
 authors:
 - Sandro Munda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2023-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails