forest_liana 7.8.0 → 7.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f94463ae1662d3d4eeac62d1b68b5c3a6895adfce97c87e99eb7312d8b0966
-  data.tar.gz: fa9f1794cde3218d3c7aa27231549493203a49876957c170fb26ee7c1b4baf73
+  metadata.gz: c535f5719b2f62c0ff1e2bde402a0c57b099f4120b5c6b3232d8ea0343c84eaf
+  data.tar.gz: b609b22af960f63d0b03e8a99597cf6d202da15414826d6dca1b836b7a672676
 SHA512:
-  metadata.gz: 9f30218cb8f5df0e921c754fa1d0b08f79194da46ebe7dac74bffb5343fdf8dd0797ef2542bd41d4bd240aff04821ac0bdd6bdf307375ef3c9a8d978ef07d6f9
-  data.tar.gz: 7192187737dfb2a67f724bb5c444072f707b3ed02f8c69dc216f4504e2e249ffebe683dff9719f405dca9960f4a44b196e1bb1ccbe021cd62bec4cc36b687621
+  metadata.gz: 502270b809bf91474ce0bd977a767ee93325c70cfb7aa2ccc0b807ec54fb70a2c447e58eac44a9beca1b9bde7720e214c855f794834c9ec46eb871c60b259a7a
+  data.tar.gz: 581fe22c160e4f10a2ed8a866261b2362a31ffb03b5817433794d19f4c1a3a55878a9350e81b95088aeaf4f2b8d6c58a69ad4c1179b8252f6070afb077d52f85

data/app/services/forest_liana/stat_getter.rb

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

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[:aggregate].downcase == 'count'
+    def aggregate(value)
+      aggregator = @params[:aggregate].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[:aggregate].downcase, aggregate_field)
+        value.send(aggregator, aggregate_field)
       else
-        value.send(@params[:aggregate].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 = "7.8.0"
+  VERSION = "7.8.2"
 end

data/spec/services/forest_liana/line_stat_getter_spec.rb

@@ -10,6 +10,19 @@ module ForestLiana
       Owner.delete_all
     end
 
+    describe 'with not allowed aggregator' do
+      it 'should raise an error' do
+        expect {
+          LineStatGetter.new(Owner, {
+            timezone: "Europe/Paris",
+            aggregate: "eval",
+            time_range: "Week",
+            group_by_date_field: "`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',
-        collection: collection,
-        timezone: 'Europe/Paris',
-        aggregate: 'Count',
-        group_by_field: group_by_field
+    describe 'with not allowed aggregator' do
+      let(:scopes) { { } }
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:params) {
+        {
+          type: 'Pie',
+          collection: collection,
+          timezone: 'Europe/Paris',
+          aggregate: 'eval',
+          group_by_field: '`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',
+          collection: collection,
+          timezone: 'Europe/Paris',
+          aggregate: 'Count',
+          group_by_field: group_by_field
+        }
+      }
 
-      describe 'with an aggregate on the name field' do
-        let(:group_by_field) { '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(:group_by_field) { '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(:group_by_field) { 'age' }
+        describe 'with an aggregate on the age field' do
+          let(:group_by_field) { '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(:group_by_field) { '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(:group_by_field) { '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(:group_by_field) { 'age' }
+        describe 'with an aggregate on the age field' do
+          let(:group_by_field) { '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",
-        collection: collection,
-        timezone: "Europe/Paris",
-        aggregate: "Count",
-        filters: filters
+    describe 'with not allowed aggregator' do
+      let(:model) { User }
+      let(:collection) { 'users' }
+      let(:scopes) { { } }
+      let(:params) {
+        {
+          type: "Value",
+          collection: collection,
+          timezone: "Europe/Paris",
+          aggregate: "eval",
+          aggregate_field: "`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",
+          collection: collection,
+          timezone: "Europe/Paris",
+          aggregate: "Count",
+          filters: filters
+        }
+      }
+
+      subject { ValueStatGetter.new(model, params, user) }
 
-      describe 'with a simple filter matching no entries' do
-        let(:model) { User }
-        let(:collection) { 'users' }
-        let(:filters) { { 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(:collection) { 'users' }
+          let(:filters) { { 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(:collection) { 'trees' }
-        let(:filters) { { field: 'owner:name', operator: 'equal', value: 'Aragorn' }.to_json }
+        describe 'with a filter on a belongs_to string field' do
+          let(:model) { Tree }
+          let(:collection) { 'trees' }
+          let(:filters) { { 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(:collection) { 'trees' }
-        let(:filters) { { field: 'owner:title', operator: 'equal', value: 'villager' }.to_json }
+        describe 'with a filter on a belongs_to enum field' do
+          let(:model) { Tree }
+          let(:collection) { 'trees' }
+          let(:filters) { { 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(:collection) { 'users' }
-        let(:filters) { { field: 'title', operator: 'equal', value: 'villager' }.to_json }
+        describe 'with a filter on a belongs_to enum field' do
+          let(:model) { User }
+          let(:collection) { 'users' }
+          let(:filters) { { 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: 7.8.0
+  version: 7.8.2
 platform: ruby
 authors:
 - Sandro Munda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-24 00:00:00.000000000 Z
+date: 2023-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails