reports_kit 0.2.0 → 0.3.0

data/lib/reports_kit/report_builder.rb

@@ -11,13 +11,13 @@ module ReportsKit
       self.additional_params = additional_params
     end
 
-    def check_box(filter_key, options={})
+    def check_box(filter_key, options = {})
       filter = validate_filter!(filter_key)
       checked = filter.normalized_properties[:criteria][:value] == 'true'
       check_box_tag(filter_key, '1', checked, options)
     end
 
-    def date_range(filter_key, options={})
+    def date_range(filter_key, options = {})
       filter = validate_filter!(filter_key)
       defaults = { class: 'form-control input-sm date_range_picker' }
       options = defaults.deep_merge(options)
@@ -26,11 +26,11 @@ module ReportsKit
       text_field_tag(filter_key, value, options)
     end
 
-    def multi_autocomplete(filter_key, options={})
+    def multi_autocomplete(filter_key, options = {})
       validate_filter!(filter_key)
-      filter = measure_filters.find { |f| f.key == filter_key.to_s }
+      filter = series_filters.find { |f| f.key == filter_key.to_s }
       reports_kit_path = Rails.application.routes.url_helpers.reports_kit_path
-      path = "#{reports_kit_path}reports_kit/resources/measures/#{filter.measure.key}/filters/#{filter_key}/autocomplete?"
+      path = "#{reports_kit_path}reports_kit/resources/measures/#{filter.series.key}/filters/#{filter_key}/autocomplete?"
       path += additional_params.to_query if additional_params.present?
       scope = options.delete(:scope)
       params = {}
@@ -49,7 +49,7 @@ module ReportsKit
       select_tag(filter_key, nil, options)
     end
 
-    def string_filter(filter_key, options={})
+    def string_filter(filter_key, options = {})
       filter = validate_filter!(filter_key)
       defaults = { class: 'form-control input-sm' }
       options = defaults.deep_merge(options)
@@ -66,11 +66,11 @@ module ReportsKit
     end
 
     def filters
-      ui_filters + measure_filters
+      ui_filters + series_filters
     end
 
-    def measure_filters
-      measures.map(&:filters).flatten
+    def series_filters
+      serieses.map(&:filters).flatten
     end
 
     def ui_filters
@@ -80,8 +80,8 @@ module ReportsKit
       end
     end
 
-    def measures
-      Reports::Measure.new_from_properties!(properties, context_record: nil)
+    def serieses
+      Reports::Series.new_from_properties!(properties, context_record: nil)
     end
 
     def default_date_range_value

data/lib/reports_kit/reports/{abstract_measure.rb → abstract_series.rb}

@@ -1,6 +1,6 @@
 module ReportsKit
   module Reports
-    class AbstractMeasure
+    class AbstractSeries
       def value_format_method
         ReportsKit.configuration.custom_method(properties[:value_format_method])
       end

data/lib/reports_kit/reports/{composite_measure.rb → composite_series.rb}

@@ -1,6 +1,6 @@
 module ReportsKit
   module Reports
-    class CompositeMeasure < AbstractMeasure
+    class CompositeSeries < AbstractSeries
       attr_accessor :properties
 
       def initialize(properties)
@@ -19,24 +19,28 @@ module ReportsKit
         properties[:composite_operator]
       end
 
-      def measures
-        @measures ||= Reports::Measure.new_from_properties!(properties, context_record: nil)
+      def limit
+        properties[:limit]
+      end
+
+      def serieses
+        @serieses ||= Reports::Series.new_from_properties!(properties, context_record: nil)
       end
 
       def filters
-        measures.map(&:filters).flatten
+        serieses.map(&:filters).flatten
       end
 
-      def primary_measure
-        measures.first
+      def primary_series
+        serieses.first
       end
 
       def dimensions
-        primary_measure.dimensions
+        primary_series.dimensions
       end
 
       def model_class
-        primary_measure.model_class
+        primary_series.model_class
       end
     end
   end

data/lib/reports_kit/reports/data/add_table_aggregations.rb

@@ -0,0 +1,105 @@
+module ReportsKit
+  module Reports
+    module Data
+      class AddTableAggregations
+        attr_accessor :data, :report_options
+
+        VALID_AGGREGATION_OPERATORS = [:sum]
+
+        def initialize(data, report_options:)
+          self.data = data
+          self.report_options = report_options || {}
+        end
+
+        def perform
+          data_with_aggregations
+        end
+
+        private
+
+        def data_with_aggregations
+          return data if row_aggregation_configs.blank? && column_aggregation_configs.blank?
+          {
+            entities: entities,
+            datasets: datasets
+          }
+        end
+
+        def entities
+          column_aggregation_entities = column_aggregation_configs.map do |config|
+            ReportsKit::Entity.new(config[:label], config[:label], config[:label])
+          end
+          entities_with_row_aggregations + column_aggregation_entities
+        end
+
+        def datasets
+          datasets_with_row_aggregations.map do |dataset|
+            column_aggregation_configs.each do |config|
+              value = aggregate_array(dataset[:values].map(&:formatted), config[:operator])
+              dataset[:values] << ReportsKit::Value.new(value, value)
+            end
+            dataset
+          end
+        end
+
+        def entities_with_row_aggregations
+          @entities_with_row_aggregations ||= begin
+            return original_entities if row_aggregation_configs.blank?
+            row_aggregation_entities = row_aggregation_configs.map do |config|
+              ReportsKit::Entity.new(config[:label], config[:label], config[:label])
+            end
+            original_entities + row_aggregation_entities
+          end
+        end
+
+        def datasets_with_row_aggregations
+          @datasets_with_row_aggregations ||= begin
+            return original_datasets if row_aggregation_configs.blank?
+            row_aggregation_datasets = row_aggregation_configs.map do |config|
+              values = original_datasets.map { |dataset| dataset[:values].map(&:formatted) }.transpose
+              aggregated_values = aggregate_array_of_arrays(values, config[:operator])
+              values = aggregated_values.map { |value| ReportsKit::Value.new(value, value) }
+              {
+                entity: ReportsKit::Entity.new(config[:label], config[:label], config[:label]),
+                values: values
+              }
+            end
+            original_datasets + row_aggregation_datasets
+          end
+        end
+
+        def original_entities
+          data[:entities]
+        end
+
+        def original_datasets
+          data[:datasets]
+        end
+
+        def row_aggregation_configs
+          return [] if report_options[:aggregations].blank?
+          report_options[:aggregations].select { |config| config[:from] == 'rows' }
+        end
+
+        def column_aggregation_configs
+          return [] if report_options[:aggregations].blank?
+          report_options[:aggregations].select { |config| config[:from] == 'columns' }
+        end
+
+        def aggregate_array(values, operator)
+          operator = operator.try(:to_sym)
+          raise ArgumentError.new("Invalid aggregation operator: #{operator}") unless operator.in?(VALID_AGGREGATION_OPERATORS)
+          if values.first.is_a?(Numeric)
+            values.public_send(operator)
+          else
+            nil
+          end
+        end
+
+        def aggregate_array_of_arrays(array_of_arrays, operator)
+          array_of_arrays.map { |values| aggregate_array(values, operator) }
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/{composite_aggregation.rb → aggregate_composite.rb}

@@ -1,8 +1,10 @@
 module ReportsKit
   module Reports
     module Data
-      class CompositeAggregation
-        attr_accessor :composite_operator, :properties, :context_record
+      class AggregateComposite
+        attr_accessor :composite_series, :context_record
+
+        delegate :composite_operator, :properties, to: :composite_series
 
         OPERATORS_METHODS = {
           '+' => :+,
@@ -10,7 +12,7 @@ module ReportsKit
           '*' => :*,
           '/' => :/,
           '%' => -> (values) {
-            raise ArgumentError.new("Percentage composite aggregations must have exactly two measures") if values.length != 2
+            raise ArgumentError.new('Percentage composite aggregations must have exactly two series') if values.length != 2
             numerator, denominator = values
             return 0 if denominator == 0
             ((numerator.to_f / denominator) * 100).round(1)
@@ -18,43 +20,42 @@ module ReportsKit
         }
 
         def initialize(properties, context_record:)
-          self.properties = properties
-          self.composite_operator = properties[:composite_operator]
+          self.composite_series = CompositeSeries.new(properties)
           self.context_record = context_record
         end
 
         def perform
-          return measures_results_for_one_dimension if dimension_count == 1
-          return measures_results_for_two_dimensions if dimension_count == 2
-          raise ArgumentError.new("Composite aggregations' measures can only have 1-2 dimensions")
+          return serieses_results_for_one_dimension if dimension_count == 1
+          return serieses_results_for_two_dimensions if dimension_count == 2
+          raise ArgumentError.new("Composite aggregations' series can only have 1-2 dimensions")
         end
 
         private
 
-        def measures_results_for_one_dimension
-          measures_results = Hash[measures.map { |measure| [measure, OneDimension.new(measure).perform] }]
-          measures_results = Data::PopulateOneDimension.new(measures_results).perform
-          sorted_dimension_keys_values = sort_dimension_keys_values(measures_results)
+        def serieses_results_for_one_dimension
+          serieses_results = Hash[serieses.map { |series| [series, AggregateOneDimension.new(series).perform] }]
+          serieses_results = Data::PopulateOneDimension.new(serieses_results, context_record: context_record, properties: properties).perform
+          sorted_dimension_keys_values = sort_dimension_keys_values(serieses_results)
           value_lists = sorted_dimension_keys_values.map(&:values)
           composited_values = value_lists.transpose.map { |data| reduce(data) }
           dimension_keys = sorted_dimension_keys_values.first.keys
-          composited_keys_values = Hash[dimension_keys.zip(composited_values)]
-          composited_keys_values
+          composited_keys_values = dimension_keys.zip(composited_values)
+          Hash[composited_keys_values]
         end
 
-        def measures_results_for_two_dimensions
-          measures_results = Hash[measures.map { |measure| [measure, TwoDimensions.new(measure).perform] }]
-          measures_results = Data::PopulateTwoDimensions.new(measures_results).perform
-          value_lists = measures_results.values.map(&:values)
+        def serieses_results_for_two_dimensions
+          serieses_results = Hash[serieses.map { |series| [series, AggregateTwoDimensions.new(series).perform] }]
+          serieses_results = Data::PopulateTwoDimensions.new(serieses_results).perform
+          value_lists = serieses_results.values.map(&:values)
           composited_values = value_lists.transpose.map { |data| reduce(data) }
-          dimension_keys = measures_results.values.first.keys
-          composited_keys_values = Hash[dimension_keys.zip(composited_values)]
-          composited_keys_values
+          dimension_keys = serieses_results.values.first.keys
+          composited_keys_values = dimension_keys.zip(composited_values)
+          Hash[composited_keys_values]
         end
 
         # Before performing a composition of values, we need to make sure that the values are sorted by the same dimension key.
-        def sort_dimension_keys_values(measures_results)
-          dimension_keys_values_list = measures_results.values
+        def sort_dimension_keys_values(serieses_results)
+          dimension_keys_values_list = serieses_results.values
           sorted_dimension_keys_values = dimension_keys_values_list.map do |dimension_keys_values|
             dimension_keys_values = dimension_keys_values.sort_by do |dimension_key, value|
               is_boolean = dimension_key.is_a?(TrueClass) || dimension_key.is_a?(FalseClass)
@@ -82,13 +83,13 @@ module ReportsKit
         end
 
         def dimension_count
-          unique_dimension_counts = measures.map { |measure| measure.dimensions.length }.uniq
-          raise ArgumentError.new('All measures must have the same number of dimensions') if unique_dimension_counts.length > 1
+          unique_dimension_counts = serieses.map { |series| series.dimensions.length }.uniq
+          raise ArgumentError.new('All series must have the same number of dimensions') if unique_dimension_counts.length > 1
           unique_dimension_counts.first
         end
 
-        def measures
-          @measures ||= Measure.new_from_properties!(properties, context_record: context_record)
+        def serieses
+          @serieses ||= Series.new_from_properties!(properties, context_record: context_record)
         end
       end
     end

data/lib/reports_kit/reports/data/{one_dimension.rb → aggregate_one_dimension.rb}

@@ -1,12 +1,12 @@
 module ReportsKit
   module Reports
     module Data
-      class OneDimension
-        attr_accessor :measure, :dimension
+      class AggregateOneDimension
+        attr_accessor :series, :dimension
 
-        def initialize(measure)
-          self.measure = measure
-          self.dimension = measure.dimensions[0]
+        def initialize(series)
+          self.series = series
+          self.dimension = series.dimensions[0]
         end
 
         def perform
@@ -16,15 +16,17 @@ module ReportsKit
         private
 
         def dimension_keys_values
-          relation = measure.filtered_relation
+          relation = series.filtered_relation
           relation = relation.group(dimension.group_expression)
           relation = relation.joins(dimension.joins) if dimension.joins
           relation = relation.limit(dimension.dimension_instances_limit) if dimension.dimension_instances_limit
           relation = relation.order(order)
-          dimension_keys_values = relation.distinct.public_send(*measure.aggregate_function)
+          relation = series.edit_relation_method.call(relation) if series.edit_relation_method
+          dimension_keys_values = relation.distinct.public_send(*series.aggregate_function)
           dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
           dimension_keys_values.delete(nil)
           dimension_keys_values.delete('')
+          dimension_keys_values = dimension_keys_values.take(series.limit) if series.limit
           Hash[dimension_keys_values]
         end
 

data/lib/reports_kit/reports/data/{two_dimensions.rb → aggregate_two_dimensions.rb}

@@ -1,13 +1,13 @@
 module ReportsKit
   module Reports
     module Data
-      class TwoDimensions
-        attr_accessor :measure, :dimension, :second_dimension
+      class AggregateTwoDimensions
+        attr_accessor :series, :dimension, :second_dimension
 
-        def initialize(measure)
-          self.measure = measure
-          self.dimension = measure.dimensions[0]
-          self.second_dimension = measure.dimensions[1]
+        def initialize(series)
+          self.series = series
+          self.dimension = series.dimensions[0]
+          self.second_dimension = series.dimensions[1]
         end
 
         def perform
@@ -17,12 +17,13 @@ module ReportsKit
         private
 
         def dimension_keys_values
-          relation = measure.filtered_relation
+          relation = series.filtered_relation
           relation = relation.group(dimension.group_expression, second_dimension.group_expression)
           relation = relation.joins(dimension.joins) if dimension.joins
           relation = relation.joins(second_dimension.joins) if second_dimension.joins
           relation = relation.order(order)
-          dimension_keys_values = relation.distinct.public_send(*measure.aggregate_function)
+          relation = series.edit_relation_method.call(relation) if series.edit_relation_method
+          dimension_keys_values = relation.distinct.public_send(*series.aggregate_function)
           dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
           dimension_keys_values.delete(nil)
           dimension_keys_values.delete('')

data/lib/reports_kit/reports/data/chart_options.rb

@@ -67,7 +67,6 @@ module ReportsKit
           set_colors
           set_chart_options
           set_dataset_options
-          set_standard_options
           set_type
           data
         end
@@ -83,7 +82,7 @@ module ReportsKit
         end
 
         def set_record_scoped_colors
-          self.data[:chart_data][:datasets] = self.data[:chart_data][:datasets].map do |dataset|
+          data[:chart_data][:datasets] = data[:chart_data][:datasets].map do |dataset|
             length = dataset[:data].length
             dataset[:backgroundColor] = DEFAULT_COLORS * (length.to_f / DEFAULT_COLORS.length).ceil
             dataset
@@ -91,7 +90,7 @@ module ReportsKit
         end
 
         def set_dataset_scoped_colors
-          self.data[:chart_data][:datasets] = data[:chart_data][:datasets].map.with_index do |dataset, index|
+          data[:chart_data][:datasets] = data[:chart_data][:datasets].map.with_index do |dataset, index|
             color = DEFAULT_COLORS[index % DEFAULT_COLORS.length]
             dataset[:backgroundColor] = color
             dataset[:borderColor] = color
@@ -132,23 +131,19 @@ module ReportsKit
         def set_chart_options
           merged_options = default_options
           merged_options = merged_options.deep_merge(chart_options) if chart_options
-          self.data[:chart_data][:options] = merged_options
+          data[:chart_data][:options] = merged_options
         end
 
         def set_dataset_options
-          return if self.data[:chart_data][:datasets].blank? || dataset_options.blank?
-          self.data[:chart_data][:datasets] = self.data[:chart_data][:datasets].map do |dataset|
+          return if data[:chart_data][:datasets].blank? || dataset_options.blank?
+          data[:chart_data][:datasets] = data[:chart_data][:datasets].map do |dataset|
             dataset.merge(dataset_options)
           end
         end
 
-        def set_standard_options
-          self.data[:chart_data][:standard_options] = options[:standard_options] if options[:standard_options].present?
-        end
-
         def set_type
           return if type.blank?
-          self.data[:type] = type
+          data[:type] = type
         end
 
         def donut_or_pie_chart?