reports_kit 0.1.0 → 0.2.0

data/lib/reports_kit/reports/data/generate.rb

@@ -8,55 +8,102 @@ module ReportsKit
 
         def initialize(properties, context_record: nil)
           self.properties = properties.deep_symbolize_keys
+          self.properties = Utils.normalize_properties(self.properties)
           self.context_record = context_record
         end
 
         def perform
-          if second_dimension
-            data = Data::TwoDimensions.new(measure, dimension, second_dimension).perform
+          data = ReportsKit::Cache.get(properties, context_record)
+          return data if data
+
+          if two_dimensions?
+            raw_data = Data::FormatTwoDimensions.new(measures.first, measures_results.first.last, order: order).perform
           else
-            data = Data::OneDimension.new(measure, dimension).perform
+            raw_data = Data::FormatOneDimension.new(measures_results, order: order).perform
           end
+          raw_data = data_format_method.call(raw_data) if data_format_method
+          chart_data = format_chart_data(raw_data)
 
-          ChartOptions.new(data, options: properties[:chart], inferred_options: inferred_options).perform
+          data = { chart_data: chart_data }
+          data = ChartOptions.new(data, options: properties[:chart], inferred_options: inferred_options).perform
+          if format == 'table'
+            data[:table_data] = format_table(data.delete(:chart_data))
+            data[:type] = format
+          end
+          ReportsKit::Cache.set(properties, context_record, data)
+          data
         end
 
         private
 
-        def measure
-          @measure ||= begin
-            measure_hash = properties[:measure]
-            raise ArgumentError.new('The number of measures must be exactly one') if measure_hash.blank?
-            Measure.new(measure_hash, context_record: context_record)
+        def format_chart_data(raw_data)
+          chart_data = {}
+          chart_data[:labels] = raw_data[:entities].map(&:label)
+          chart_data[:datasets] = raw_data[:datasets].map do |raw_dataset|
+            {
+              label: raw_dataset[:entity].label,
+              data: raw_dataset[:values].map(&:formatted)
+            }
           end
+          chart_data
         end
 
-        def dimension
-          @dimension ||= begin
-            Dimension.new(dimension_hashes[0], measure: measure)
-          end
+        def measures_results
+          @measures_results ||= GenerateForProperties.new(properties, context_record: context_record).perform
+        end
+
+        def two_dimensions?
+          dimension_keys = measures_results.first.last.keys
+          dimension_keys.first.is_a?(Array)
         end
 
-        def second_dimension
-          @second_dimension ||= begin
-            Dimension.new(dimension_hashes[1], measure: measure) if dimension_hashes[1]
+        def order
+          @order ||= begin
+            return Order.parse(properties[:order]) if properties[:order].present?
+            inferred_order
           end
         end
 
-        def dimension_hashes
-          @dimension_hashes ||= begin
-            dimension_hashes = properties[:dimensions]
-            raise ArgumentError.new('Blank dimensions') if dimension_hashes.blank?
-            raise ArgumentError.new('The number of dimensions must be 1-2') unless dimension_hashes.length.in?([1, 2])
-            dimension_hashes = dimension_hashes.values if dimension_hashes.is_a?(Hash) && dimension_hashes.key?(:'0')
-            dimension_hashes
+        def inferred_order
+          return Order.new('dimension1', nil, 'asc') if primary_dimension.configured_by_time?
+          Order.new('count', nil, 'desc')
+        end
+
+        def measures
+          @measures ||= Measure.new_from_properties!(properties, context_record: context_record)
+        end
+
+        def data_format_method
+          ReportsKit.configuration.custom_method(properties[:data_format_method])
+        end
+
+        def format
+          properties[:format]
+        end
+
+        def format_table(data)
+          column_names = [primary_dimension.label]
+          column_values = []
+          data[:datasets].each do |dataset|
+            column_names << dataset[:label]
+            column_values << dataset[:data]
+          end
+          rows = column_values.transpose
+          rows = rows.map.with_index do |row, index|
+            label = data[:labels][index]
+            row.unshift(label)
           end
+          [column_names] + rows
+        end
+
+        def primary_dimension
+          measures.first.dimensions.first
         end
 
         def inferred_options
           {
-            x_axis_label: dimension.label,
-            y_axis_label: measure.label
+            x_axis_label: primary_dimension.label,
+            y_axis_label: measures.length == 1 ? measures.first.label : nil
           }
         end
       end

data/lib/reports_kit/reports/data/generate_for_properties.rb

@@ -0,0 +1,75 @@
+module ReportsKit
+  module Reports
+    module Data
+      class GenerateForProperties
+        ROUND_PRECISION = 3
+
+        attr_accessor :properties, :context_record
+
+        def initialize(properties, context_record: nil)
+          self.properties = properties.deep_symbolize_keys
+          self.context_record = context_record
+        end
+
+        def perform
+          if composite_operator
+            raise ArgumentError.new('Aggregations require at least one measure') if all_measures.length == 0
+            dimension_keys_values = Data::CompositeAggregation.new(properties, context_record: context_record).perform
+            measures_dimension_keys_values = { CompositeMeasure.new(properties) => dimension_keys_values }
+          elsif all_measures.length == 1 && composite_measures.length == 1
+            dimension_keys_values = Data::CompositeAggregation.new(composite_measures.first.properties, context_record: context_record).perform
+            measures_dimension_keys_values = { all_measures.first => dimension_keys_values }
+          elsif all_measures.length == 1 && all_measures.first.dimensions.length == 2
+            dimension_keys_values = Data::TwoDimensions.new(all_measures.first).perform
+            measures_dimension_keys_values = { all_measures.first => dimension_keys_values }
+            measures_dimension_keys_values = Data::PopulateTwoDimensions.new(measures_dimension_keys_values).perform
+          elsif all_measures.length > 0
+            measures_dimension_keys_values = measures_dimension_keys_values_for_one_dimension
+          else
+            raise ArgumentError.new('The configuration of measurse and dimensions is invalid')
+          end
+
+          measures_dimension_keys_values
+        end
+
+        private
+
+        def composite_operator
+          properties[:composite_operator]
+        end
+
+        def name
+          properties[:name]
+        end
+
+        def measures_dimension_keys_values_for_one_dimension
+          multi_dimension_measures_exist = all_measures.any? { |measure| measure.dimensions.length > 1 }
+          raise ArgumentError.new('When more than one measures are configured, only one dimension may be used per measure') if multi_dimension_measures_exist
+
+          measures_dimension_keys_values = all_measures.map do |measure|
+            if measure.is_a?(CompositeMeasure)
+              dimension_keys_values = Data::CompositeAggregation.new(measure.properties, context_record: context_record).perform
+            else
+              dimension_keys_values = Data::OneDimension.new(measure).perform
+            end
+            [measure, dimension_keys_values]
+          end
+          measures_dimension_keys_values = Hash[measures_dimension_keys_values]
+          Data::PopulateOneDimension.new(measures_dimension_keys_values).perform
+        end
+
+        def all_measures
+          @all_measures ||= Measure.new_from_properties!(properties, context_record: context_record)
+        end
+
+        def composite_measures
+          @composite_measures ||= all_measures.grep(CompositeMeasure)
+        end
+
+        def measures
+          @measures ||= all_measures.grep(Measure)
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/one_dimension.rb

@@ -4,66 +4,32 @@ module ReportsKit
       class OneDimension
         attr_accessor :measure, :dimension
 
-        def initialize(measure, dimension)
+        def initialize(measure)
           self.measure = measure
-          self.dimension = dimension
+          self.dimension = measure.dimensions[0]
         end
 
         def perform
-          {
-            chart_data: {
-              labels: labels,
-              datasets: datasets
-            }
-          }
+          dimension_keys_values
         end
 
         private
 
         def dimension_keys_values
-          @dimension_keys_values ||= begin
-            relation = measure.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
-            if dimension.should_be_sorted_by_count?
-              relation = relation.order('1 DESC')
-            else
-              relation = relation.order('2')
-            end
-            dimension_keys_values = relation.distinct.public_send(*measure.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
-          end
+          relation = measure.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)
+          dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
+          dimension_keys_values.delete(nil)
+          dimension_keys_values.delete('')
+          Hash[dimension_keys_values]
         end
 
-        def datasets
-          [
-            {
-              label: measure.label,
-              data: values
-            }
-          ]
-        end
-
-        def values
-          dimension_keys_values.values.map { |value| value.round(Generate::ROUND_PRECISION) }
-        end
-
-        def labels
-          keys = dimension_keys_values.keys
-          keys.map do |key|
-            Utils.dimension_key_to_label(key, dimension, dimension_ids_dimension_instances)
-          end
-        end
-
-        def dimension_ids_dimension_instances
-          @dimension_ids_dimension_instances ||= begin
-            dimension_ids = dimension_keys_values.keys
-            Utils.dimension_to_dimension_ids_dimension_instances(dimension, dimension_ids)
-          end
+        def order
+          dimension.configured_by_time? ? '2' : '1 DESC'
         end
       end
     end

data/lib/reports_kit/reports/data/populate_one_dimension.rb

@@ -0,0 +1,36 @@
+module ReportsKit
+  module Reports
+    module Data
+      class PopulateOneDimension
+        attr_accessor :sparse_measures_dimension_keys_values
+
+        def initialize(sparse_measures_dimension_keys_values)
+          self.sparse_measures_dimension_keys_values = sparse_measures_dimension_keys_values
+        end
+
+        def perform
+          return sparse_measures_dimension_keys_values if sparse_measures_dimension_keys_values.length == 1
+          measures_dimension_keys_values
+        end
+
+        private
+
+        def measures_dimension_keys_values
+          measures_dimension_keys_values = sparse_measures_dimension_keys_values.map do |measure, dimension_keys_values|
+            dimension_keys.each do |key|
+              dimension_keys_values[key] ||= 0
+            end
+            [measure, dimension_keys_values]
+          end
+          Hash[measures_dimension_keys_values]
+        end
+
+        def dimension_keys
+          sparse_measures_dimension_keys_values.map do |measure, dimension_keys_values|
+            dimension_keys_values.keys
+          end.reduce(&:+).uniq
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/populate_two_dimensions.rb

@@ -0,0 +1,104 @@
+module ReportsKit
+  module Reports
+    module Data
+      class PopulateTwoDimensions
+        attr_accessor :measures, :dimension, :second_dimension, :sparse_measures_dimension_keys_values
+
+        def initialize(sparse_measures_dimension_keys_values)
+          self.measures = sparse_measures_dimension_keys_values.keys
+          self.dimension = measures.first.dimensions[0]
+          self.second_dimension = measures.first.dimensions[1]
+          self.sparse_measures_dimension_keys_values = sparse_measures_dimension_keys_values
+        end
+
+        def perform
+          measures_populated_dimension_keys_values
+        end
+
+        private
+
+        def measures_populated_dimension_keys_values
+          measures_dimension_keys_values = {}
+          secondary_keys_sums = Hash.new(0)
+          measures_populated_primary_keys_secondary_keys_values.each do |measure, primary_keys_secondary_keys_values|
+            primary_keys_secondary_keys_values.each do |primary_key, secondary_keys_values|
+              secondary_keys_values.each do |secondary_key, value|
+                secondary_keys_sums[secondary_key] += value
+              end
+            end
+          end
+          sorted_secondary_keys = secondary_keys_sums.sort_by(&:last).reverse.map(&:first)
+          measures_populated_primary_keys_secondary_keys_values.each do |measure, primary_key_secondary_keys_values|
+            measures_dimension_keys_values[measure] = {}
+            primary_key_secondary_keys_values.each do |primary_key, secondary_keys_values|
+              secondary_keys_values = secondary_keys_values.sort_by { |key, _| sorted_secondary_keys.index(key) }
+              secondary_keys_values.each do |secondary_key, value|
+                dimension_key = [primary_key, secondary_key]
+                measures_dimension_keys_values[measure][dimension_key] = value
+                secondary_keys_sums[secondary_key] += value
+              end
+            end
+          end
+          measures_dimension_keys_values
+        end
+
+        def measures_populated_primary_keys_secondary_keys_values
+          @populated_dimension_keys_values ||= begin
+            measures_populated_primary_keys_secondary_keys_values = {}
+            measures.each do |measure|
+              measures_populated_primary_keys_secondary_keys_values[measure] = {}
+              primary_keys.each do |primary_key|
+                measures_populated_primary_keys_secondary_keys_values[measure][primary_key] = {}
+                secondary_keys.each do |secondary_key|
+                  value = measures_primary_keys_secondary_keys_values[measure][primary_key].try(:[], secondary_key) || 0
+                  measures_populated_primary_keys_secondary_keys_values[measure][primary_key][secondary_key] = value
+                end
+              end
+            end
+            measures_populated_primary_keys_secondary_keys_values
+          end
+        end
+
+        def measures_primary_keys_secondary_keys_values
+          @measures_primary_keys_secondary_keys_values ||= begin
+            measures_primary_keys_secondary_keys_values = {}
+            sparse_measures_dimension_keys_values.each do |measure, dimension_keys_values|
+              measures_primary_keys_secondary_keys_values[measure] = {}
+              dimension_keys_values.each do |(primary_key, secondary_key), value|
+                primary_key = primary_key.to_date if primary_key.is_a?(Time)
+                secondary_key = secondary_key.to_date if secondary_key.is_a?(Time)
+                measures_primary_keys_secondary_keys_values[measure][primary_key] ||= {}
+                measures_primary_keys_secondary_keys_values[measure][primary_key][secondary_key] = value
+              end
+            end
+            measures_primary_keys_secondary_keys_values
+          end
+        end
+
+        def dimension_keys
+          @dimension_keys ||= sparse_measures_dimension_keys_values.values.map(&:keys).reduce(&:+).uniq
+        end
+
+        def primary_keys
+          @primary_keys ||= begin
+            keys = Utils.populate_sparse_keys(dimension_keys.map(&:first).uniq, dimension: dimension)
+            unless dimension.configured_by_time?
+              limit = dimension.dimension_instances_limit
+              keys = keys.first(limit) if limit
+            end
+            keys
+          end
+        end
+
+        def secondary_keys
+          @secondary_keys ||= begin
+            keys = Utils.populate_sparse_keys(dimension_keys.map(&:last).uniq, dimension: second_dimension)
+            limit = second_dimension.dimension_instances_limit
+            keys = keys.first(limit) if limit
+            keys
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/two_dimensions.rb

@@ -4,128 +4,33 @@ module ReportsKit
       class TwoDimensions
         attr_accessor :measure, :dimension, :second_dimension
 
-        def initialize(measure, dimension, second_dimension)
+        def initialize(measure)
           self.measure = measure
-          self.dimension = dimension
-          self.second_dimension = second_dimension
+          self.dimension = measure.dimensions[0]
+          self.second_dimension = measure.dimensions[1]
         end
 
         def perform
-          {
-            chart_data: {
-              labels: labels,
-              datasets: datasets
-            }
-          }
+          dimension_keys_values
         end
 
         private
 
         def dimension_keys_values
-          @dimension_keys_values ||= begin
-            relation = measure.filtered_relation
-            relation = measure.conditions.call(relation) if measure.conditions
-            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
-
-            if dimension.should_be_sorted_by_count?
-              relation = relation.order('1 DESC')
-            else
-              relation = relation.order('2')
-            end
-            dimension_keys_values = relation.distinct.public_send(*measure.aggregate_function)
-
-            if dimension.should_be_sorted_by_count?
-              dimension_keys_values = sort_dimension_keys_values_by_count(dimension_keys_values)
-            end
-            dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
-            Hash[dimension_keys_values]
-          end
-        end
-
-        def primary_keys_secondary_keys_values
-          @primary_keys_secondary_keys_values ||= begin
-            primary_keys_secondary_keys_values = {}
-            dimension_keys_values.each do |(primary_key, secondary_key), value|
-              primary_key = primary_key.to_date if primary_key.is_a?(Time)
-              secondary_key = secondary_key.to_date if secondary_key.is_a?(Time)
-              primary_keys_secondary_keys_values[primary_key] ||= {}
-              primary_keys_secondary_keys_values[primary_key][secondary_key] = value
-            end
-            primary_keys_secondary_keys_values
-          end
-        end
-
-        def sort_dimension_keys_values_by_count(dimension_keys_values)
-          primary_keys_counts = Hash.new(0)
-          dimension_keys_values.each do |(primary_key, secondary_key), count|
-            primary_keys_counts[primary_key] += count
-          end
-          primary_keys_counts = primary_keys_counts.to_a
-          sorted_primary_keys = primary_keys_counts.sort_by { |primary_key, count| count }.reverse.map(&:first)
-          dimension_keys_values = dimension_keys_values.sort_by { |(primary_key, secondary_key), count| sorted_primary_keys.index(primary_key) }
+          relation = measure.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)
+          dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
+          dimension_keys_values.delete(nil)
+          dimension_keys_values.delete('')
           Hash[dimension_keys_values]
         end
 
-        def dimension_ids
-          dimension_keys_values.keys.map(&:first)
-        end
-
-        def dimension_ids_dimension_instances
-          @dimension_ids_dimension_instances ||= begin
-            Utils.dimension_to_dimension_ids_dimension_instances(dimension, dimension_keys_values.keys.map(&:first))
-          end
-        end
-
-        def second_dimension_ids_dimension_instances
-          @second_dimension_ids_dimension_instances ||= begin
-            Utils.dimension_to_dimension_ids_dimension_instances(second_dimension, dimension_keys_values.keys.map(&:last))
-          end
-        end
-
-        def datasets
-          secondary_keys_values = secondary_keys.map do |secondary_key|
-            values = primary_keys.map do |primary_key|
-              primary_keys_secondary_keys_values[primary_key].try(:[], secondary_key) || 0
-            end
-            [secondary_key, values]
-          end
-          secondary_keys_values = secondary_keys_values.sort_by { |_, values| values.sum }.reverse
-          secondary_keys_values.map do |secondary_key, values|
-            next if secondary_key.blank?
-            {
-              label: Utils.dimension_key_to_label(secondary_key, second_dimension, second_dimension_ids_dimension_instances),
-              data: values
-            }
-          end.compact
-        end
-
-        def primary_keys
-          @primary_keys ||= begin
-            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:first).uniq, dimension: dimension)
-            if dimension.should_be_sorted_by_count?
-              limit = dimension.dimension_instances_limit
-              keys = keys.first(limit) if limit
-            end
-            keys
-          end
-        end
-
-        def secondary_keys
-          @secondary_keys ||= begin
-            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:last).uniq, dimension: second_dimension)
-            limit = second_dimension.dimension_instances_limit
-            keys = keys.first(limit) if limit
-            keys
-          end
-        end
-
-        def labels
-          primary_keys.map do |primary_key|
-            Utils.dimension_key_to_label(primary_key, dimension, dimension_ids_dimension_instances)
-          end
+        def order
+          dimension.configured_by_time? ? '2' : '1 DESC'
         end
       end
     end