reports_kit 0.1.0 → 0.2.0

data/lib/reports_kit/reports/abstract_measure.rb

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

data/lib/reports_kit/reports/adapters/mysql.rb

@@ -7,7 +7,14 @@ module ReportsKit
         end
 
         def self.truncate_to_week(column)
-          "DATE_SUB(DATE(#{column}), INTERVAL DAYOFWEEK(#{column}) - 2 DAY)"
+          case ReportsKit.configuration.first_day_of_week
+          when :sunday
+            "DATE_SUB(DATE(#{column}), INTERVAL DAYOFWEEK(#{column}) - 1 DAY)"
+          when :monday
+            "DATE_SUB(DATE(#{column}), INTERVAL DAYOFWEEK(#{column}) - 2 DAY)"
+          else
+            raise ArgumentError.new("Unsupported first_day_of_week: #{ReportsKit.configuration.first_day_of_week}")
+          end
         end
       end
     end

data/lib/reports_kit/reports/adapters/postgresql.rb

@@ -7,7 +7,14 @@ module ReportsKit
         end
 
         def self.truncate_to_week(column)
-          "DATE_TRUNC('week', #{column}::timestamp)"
+          case ReportsKit.configuration.first_day_of_week
+          when :sunday
+            "DATE_TRUNC('week', #{column}::timestamp + '1 day'::interval) - '1 day'::interval"
+          when :monday
+            "DATE_TRUNC('week', #{column}::timestamp)"
+          else
+            raise ArgumentError.new("Unsupported first_day_of_week: #{ReportsKit.configuration.first_day_of_week}")
+          end
         end
       end
     end

data/lib/reports_kit/reports/composite_measure.rb

@@ -0,0 +1,43 @@
+module ReportsKit
+  module Reports
+    class CompositeMeasure < AbstractMeasure
+      attr_accessor :properties
+
+      def initialize(properties)
+        self.properties = properties.dup
+      end
+
+      def label
+        name
+      end
+
+      def name
+        properties[:name]
+      end
+
+      def composite_operator
+        properties[:composite_operator]
+      end
+
+      def measures
+        @measures ||= Reports::Measure.new_from_properties!(properties, context_record: nil)
+      end
+
+      def filters
+        measures.map(&:filters).flatten
+      end
+
+      def primary_measure
+        measures.first
+      end
+
+      def dimensions
+        primary_measure.dimensions
+      end
+
+      def model_class
+        primary_measure.model_class
+      end
+    end
+  end
+end

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

@@ -67,6 +67,7 @@ module ReportsKit
           set_colors
           set_chart_options
           set_dataset_options
+          set_standard_options
           set_type
           data
         end
@@ -141,6 +142,10 @@ module ReportsKit
           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/lib/reports_kit/reports/data/composite_aggregation.rb

@@ -0,0 +1,96 @@
+module ReportsKit
+  module Reports
+    module Data
+      class CompositeAggregation
+        attr_accessor :composite_operator, :properties, :context_record
+
+        OPERATORS_METHODS = {
+          '+' => :+,
+          '-' => :-,
+          '*' => :*,
+          '/' => :/,
+          '%' => -> (values) {
+            raise ArgumentError.new("Percentage composite aggregations must have exactly two measures") if values.length != 2
+            numerator, denominator = values
+            return 0 if denominator == 0
+            ((numerator.to_f / denominator) * 100).round(1)
+          }
+        }
+
+        def initialize(properties, context_record:)
+          self.properties = properties
+          self.composite_operator = properties[:composite_operator]
+          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")
+        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)
+          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
+        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)
+          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
+        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
+          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)
+              is_boolean ? (dimension_key ? 0 : 1) : dimension_key
+            end
+            Hash[dimension_keys_values]
+          end
+          sorted_dimension_keys_values
+        end
+
+        def reduce(values)
+          if composite_method.is_a?(Symbol)
+            values.reduce(&composite_method)
+          elsif composite_method.is_a?(Proc)
+            values = composite_method.call(values)
+          else
+            raise ArgumentError.new("Invalid composite method type: #{composite_method.class}")
+          end
+        end
+
+        def composite_method
+          composite_method = OPERATORS_METHODS[composite_operator]
+          raise ArgumentError.new("Invalid composite_operator: #{composite_operator}") unless composite_method
+          composite_method
+        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.first
+        end
+
+        def measures
+          @measures ||= Measure.new_from_properties!(properties, context_record: context_record)
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/entity.rb

@@ -0,0 +1,7 @@
+module ReportsKit
+  module Reports
+    module Data
+      Entity = Struct.new(:key, :label, :instance)
+    end
+  end
+end

data/lib/reports_kit/reports/data/format_one_dimension.rb

@@ -0,0 +1,120 @@
+module ReportsKit
+  module Reports
+    module Data
+      class FormatOneDimension
+        attr_accessor :measures_results, :measures, :order
+
+        def initialize(measures_results, order:)
+          self.measures_results = measures_results
+          self.measures = measures_results.keys
+          self.order = order
+        end
+
+        def perform
+          {
+            entities: entities,
+            datasets: datasets
+          }
+        end
+
+        private
+
+        def entities
+          sorted_dimension_keys.map do |key|
+            Utils.dimension_key_to_entity(key, primary_dimension_with_measure, dimension_ids_dimension_instances)
+          end
+        end
+
+        def datasets
+          sorted_measures_results.map do |measure, result|
+            values = result.values.map do |raw_value|
+              Utils.raw_value_to_value(raw_value, measure.value_format_method)
+            end
+            {
+              entity: measure,
+              values: values
+            }
+          end
+        end
+
+        def dimension_summaries
+          @dimension_summaries ||= dimension_keys.map do |dimension_key|
+            label = Utils.dimension_key_to_label(dimension_key, primary_dimension_with_measure, dimension_ids_dimension_instances)
+            [dimension_key, label]
+          end
+        end
+
+        def sorted_dimension_keys
+          sorted_measures_results.first.last.keys
+        end
+
+        def dimension_keys_sorted_by_label
+          @dimension_keys_sorted_by_label ||= dimension_summaries.sort_by(&:last).map(&:first)
+        end
+
+        def dimension_keys
+          measures_results.first.last.keys
+        end
+
+        def dimension_ids_dimension_instances
+          @dimension_ids_dimension_instances ||= begin
+            dimension_ids = dimension_keys
+            Utils.dimension_to_dimension_ids_dimension_instances(primary_dimension_with_measure, dimension_ids)
+          end
+        end
+
+        def primary_dimension_with_measure
+          @primary_dimension_with_measure ||= DimensionWithMeasure.new(dimension: primary_measure.dimensions.first, measure: primary_measure)
+        end
+
+        def primary_measure
+          measures.first
+        end
+
+        def sorted_measures_results
+          @sorted_measures_results ||= begin
+            if order.relation == 'dimension1' && order.field == 'label'
+              sorted_measures_results = measures_results.map do |measure, dimension_keys_values|
+                sorted_dimension_keys_values = dimension_keys_values.sort_by { |key, _| dimension_keys_sorted_by_label.index(key) }
+                sorted_dimension_keys_values = sorted_dimension_keys_values.reverse if order.direction == 'desc'
+                [measure, Hash[sorted_dimension_keys_values]]
+              end
+            elsif (order.relation == 'dimension1' && order.field.nil?) || (order.relation == 0)
+              sorted_measures_results = measures_results.map do |measure, dimension_keys_values|
+                sorted_dimension_keys_values = dimension_keys_values.sort_by(&:first)
+                sorted_dimension_keys_values = sorted_dimension_keys_values.reverse if order.direction == 'desc'
+                [measure, Hash[sorted_dimension_keys_values]]
+              end
+            elsif order.relation.is_a?(Fixnum)
+              measure_index = order.relation - 1
+              raise ArgumentError.new("Invalid order column: #{order.relation}") unless measure_index.in?((0..(measures_results.length - 1)))
+              dimension_keys_values = measures_results.values.to_a[measure_index]
+              sorted_dimension_keys = dimension_keys_values.sort_by(&:last).map(&:first)
+              sorted_dimension_keys = sorted_dimension_keys.reverse if order.direction == 'desc'
+              sorted_measures_results = measures_results.map do |measure, dimension_keys_values|
+                dimension_keys_values = dimension_keys_values.sort_by { |dimension_key, _| sorted_dimension_keys.index(dimension_key) }
+                [measure, Hash[dimension_keys_values]]
+              end
+            elsif order.relation == 'count'
+              dimension_keys_sums = Hash.new(0)
+              measures_results.values.each do |dimension_keys_values|
+                dimension_keys_values.each do |dimension_key, value|
+                  dimension_keys_sums[dimension_key] += value
+                end
+              end
+              sorted_dimension_keys = dimension_keys_sums.sort_by(&:last).map(&:first)
+              sorted_dimension_keys = sorted_dimension_keys.reverse if order.direction == 'desc'
+              sorted_measures_results = measures_results.map do |measure, dimension_keys_values|
+                dimension_keys_values = dimension_keys_values.sort_by { |dimension_key, _| sorted_dimension_keys.index(dimension_key) }
+                [measure, Hash[dimension_keys_values]]
+              end
+            else
+              sorted_measures_results = measures_results
+            end
+            Hash[sorted_measures_results]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/format_two_dimensions.rb

@@ -0,0 +1,141 @@
+module ReportsKit
+  module Reports
+    module Data
+      class FormatTwoDimensions
+        attr_accessor :measure, :dimension, :second_dimension, :dimension_keys_values, :order
+
+        def initialize(measure, dimension_keys_values, order:)
+          self.measure = measure
+          self.dimension = measure.dimensions[0]
+          self.second_dimension = measure.dimensions[1]
+          self.dimension_keys_values = dimension_keys_values
+          self.order = order
+        end
+
+        def perform
+          {
+            entities: entities,
+            datasets: datasets
+          }
+        end
+
+        private
+
+        def entities
+          sorted_primary_keys.map do |primary_key|
+            Utils.dimension_key_to_entity(primary_key, dimension, dimension_ids_dimension_instances)
+          end
+        end
+
+        def datasets
+          secondary_keys_values = sorted_secondary_keys.map do |secondary_key|
+            raw_values = sorted_primary_keys.map do |primary_key|
+              primary_keys_secondary_keys_values[primary_key][secondary_key]
+            end
+            values = raw_values.map do |raw_value|
+              Utils.raw_value_to_value(raw_value, measure.value_format_method)
+            end
+            [secondary_key, values]
+          end
+          secondary_keys_values.map do |secondary_key, values|
+            next if secondary_key.blank?
+            {
+              entity: Utils.dimension_key_to_entity(secondary_key, second_dimension, second_dimension_ids_dimension_instances),
+              values: values
+            }
+          end.compact
+        end
+
+        def sorted_primary_keys_secondary_keys_values
+          @sorted_primary_keys_secondary_keys_values ||= begin
+            if order.relation == 'dimension1' && order.field == 'label'
+              primary_keys_secondary_keys_values
+              sorted_primary_keys_secondary_keys_values = primary_keys_secondary_keys_values.sort_by do |primary_key, _|
+                primary_dimension_keys_sorted_by_label.index(primary_key)
+              end
+            elsif order.relation == 'dimension1' && order.field.nil?
+              sorted_primary_keys_secondary_keys_values = primary_keys_secondary_keys_values.sort_by do |primary_key, _|
+                primary_key
+              end
+            elsif order.relation == 'count'
+              primary_keys_sums = Hash.new(0)
+              primary_keys_secondary_keys_values.each do |primary_key, secondary_keys_values|
+                primary_keys_sums[primary_key] += secondary_keys_values.values.sum
+              end
+              sorted_primary_keys = primary_keys_sums.sort_by(&:last).map(&:first)
+              sorted_primary_keys_secondary_keys_values = primary_keys_secondary_keys_values.sort_by do |primary_key, _|
+                sorted_primary_keys.index(primary_key)
+              end
+            else
+              dimension_keys_values
+            end
+            sorted_primary_keys_secondary_keys_values = sorted_primary_keys_secondary_keys_values.reverse if order.direction == 'desc'
+            Hash[sorted_primary_keys_secondary_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 dimension_ids_dimension_instances
+          @dimension_ids_dimension_instances ||= begin
+            Utils.dimension_to_dimension_ids_dimension_instances(dimension, primary_keys)
+          end
+        end
+
+        def second_dimension_ids_dimension_instances
+          @second_dimension_ids_dimension_instances ||= begin
+            Utils.dimension_to_dimension_ids_dimension_instances(second_dimension, secondary_keys)
+          end
+        end
+
+        def sorted_primary_keys
+          @sorted_primary_keys ||= begin
+            keys = sorted_primary_keys_secondary_keys_values.keys
+            limit = dimension.dimension_instances_limit
+            keys = keys.first(limit) if limit
+            keys
+          end
+        end
+
+        def sorted_secondary_keys
+          @sorted_secondary_keys ||= begin
+            keys = sorted_primary_keys_secondary_keys_values.values.first.keys
+            limit = second_dimension.dimension_instances_limit
+            keys = keys.first(limit) if limit
+            keys
+          end
+        end
+
+        def primary_summaries
+          primary_keys.map do |key|
+            label = Utils.dimension_key_to_label(key, dimension, dimension_ids_dimension_instances)
+            [key, label]
+          end
+        end
+
+        def primary_dimension_keys_sorted_by_label
+          @primary_dimension_keys_sorted_by_label ||= primary_summaries.sort_by(&:last).map(&:first)
+        end
+
+        def primary_keys
+          @primary_keys ||= dimension_keys_values.keys.map(&:first).uniq
+        end
+
+        def secondary_keys
+          @secondary_keys ||= dimension_keys_values.keys.map(&:last).uniq
+        end
+      end
+    end
+  end
+end