reports_kits 0.7.5 → 0.7.7

data/lib/reports_kits/reports/data/generate.rb

@@ -0,0 +1,156 @@
+module ReportsKits
+  module Reports
+    module Data
+      class Generate
+        ROUND_PRECISION = 3
+
+        attr_accessor :properties, :context_record
+
+        def initialize(properties, context_record: nil, context_params: nil)
+          self.properties = properties.deep_symbolize_keys
+          self.properties = ReportsKits.configuration.default_properties.deep_merge(self.properties) if ReportsKits.configuration.default_properties
+          self.properties[:context_params] = context_params if context_params
+          self.properties = NormalizeProperties.new(self.properties).perform
+          self.context_record = context_record
+        end
+
+        def perform
+          data = ReportsKits::Cache.get(properties, context_record)
+          return data.deep_symbolize_keys if data
+
+          data_method_data = ChartDataForDataMethod.new(properties).perform if has_data_method?
+          chart_data = data_method_data ? data_method_data[:formatted_data] : properties_to_chart_data
+          data = { chart_data: chart_data }
+          data = ChartOptions.new(data, options: properties[:chart], inferred_options: inferred_options).perform
+          data[:report_options] = report_options if report_options
+          data = format_table_data(data, data_method_data) if table_or_csv?
+          ReportsKits::Cache.set(properties, context_record, data)
+          data
+        end
+
+        private
+
+        def has_data_method?
+          properties[:data_method].present?
+        end
+
+        def properties_to_chart_data
+          if two_dimensions?
+            raw_data = Data::FormatTwoDimensions.new(serieses.first, serieses_results.first.last, order: order, limit: limit).perform
+          else
+            raw_data = Data::FormatOneDimension.new(serieses_results, order: order, limit: limit).perform
+          end
+          raw_data = format_csv_times(raw_data) if format == 'csv'
+          raw_data = Data::AddTableAggregations.new(raw_data, report_options: report_options).perform if table_or_csv?
+          raw_data = data_format_method.call(data: raw_data, properties: properties, context_record: context_record) if data_format_method
+          raw_data = csv_data_format_method.call(data: raw_data, properties: properties, context_record: context_record) if csv_data_format_method && format == 'csv'
+          format_chart_data(raw_data)
+        end
+
+        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 format_table_data(data, data_method_data)
+          data[:type] = format
+          if has_data_method?
+            data[:table_data] = data_method_data[:raw_data]
+            return data
+          end
+          data[:table_data] = Data::FormatTable.new(
+            data.delete(:chart_data),
+            format: format,
+            first_column_label: primary_dimension.try(:label),
+            report_options: report_options
+          ).perform
+          data
+        end
+
+        def serieses_results
+          @serieses_results ||= GenerateForProperties.new(properties, context_record: context_record).perform
+        end
+
+        def two_dimensions?
+          dimension_keys = serieses_results.first.last.keys
+          dimension_keys.first.is_a?(Array)
+        end
+
+        def order
+          @order ||= begin
+            return Order.parse(properties[:order]) if properties[:order].present?
+            inferred_order
+          end
+        end
+
+        def limit
+          properties[:limit]
+        end
+
+        def inferred_order
+          return Order.new('dimension1', nil, 'asc') if primary_dimension.configured_by_time?
+          Order.new('count', nil, 'desc')
+        end
+
+        def serieses
+          @serieses ||= Series.new_from_properties!(properties, context_record: context_record)
+        end
+
+        def report_options
+          report_options = properties[:report_options] || {}
+          head_rows_count = report_options[:head_rows_count]
+          foot_rows_count = report_options[:foot_rows_count]
+          foot_rows_count ||= report_options[:aggregations].count { |config| config[:from] == 'rows' } if report_options[:aggregations]
+
+          report_options[:head_rows_count] = head_rows_count if head_rows_count && head_rows_count > 0
+          report_options[:foot_rows_count] = foot_rows_count if foot_rows_count && foot_rows_count > 0
+          report_options.presence
+        end
+
+        def data_format_method
+          ReportsKits.configuration.custom_method(report_options.try(:[], :data_format_method))
+        end
+
+        def csv_data_format_method
+          ReportsKits.configuration.custom_method(report_options.try(:[], :csv_data_format_method))
+        end
+
+        def format
+          properties[:format]
+        end
+
+        def format_csv_times(raw_data)
+          return raw_data unless primary_dimension.configured_by_time?
+          raw_data[:entities] = raw_data[:entities].map do |entity|
+            entity.label = Utils.format_csv_time(entity.instance)
+            entity
+          end
+          raw_data
+        end
+
+        def primary_dimension
+          serieses.first.dimensions.first
+        end
+
+        def table_or_csv?
+          format.in?(%w(table csv))
+        end
+
+        def inferred_options
+          return {} if has_data_method?
+          {
+            x_axis_label: primary_dimension.label,
+            y_axis_label: serieses.length == 1 ? serieses.first.label : nil
+          }
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/generate_for_properties.rb

@@ -0,0 +1,97 @@
+module ReportsKits
+  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 series') if all_serieses.length == 0
+            dimension_keys_values = Data::AggregateComposite.new(properties, context_record: context_record).perform
+            serieses_dimension_keys_values = { CompositeSeries.new(properties, context_record: context_record) => dimension_keys_values }
+          elsif all_serieses.length == 1 && composite_serieses.length == 1
+            dimension_keys_values = Data::AggregateComposite.new(composite_serieses.first.properties, context_record: context_record).perform
+            serieses_dimension_keys_values = { all_serieses.first => dimension_keys_values }
+          elsif all_serieses.length == 1 && all_serieses.first.dimensions.length == 2
+            dimension_keys_values = Data::AggregateTwoDimensions.new(all_serieses.first).perform
+            serieses_dimension_keys_values = { all_serieses.first => dimension_keys_values }
+            serieses_dimension_keys_values = Data::PopulateTwoDimensions.new(serieses_dimension_keys_values).perform
+          elsif all_serieses.length > 0
+            serieses_dimension_keys_values = serieses_dimension_keys_values_for_one_dimension
+          else
+            raise ArgumentError.new('The configuration of measurse and dimensions is invalid')
+          end
+
+          serieses_dimension_keys_values
+        end
+
+        private
+
+        def composite_operator
+          properties[:composite_operator]
+        end
+
+        def name
+          properties[:name]
+        end
+
+        def serieses_dimension_keys_values_for_one_dimension
+          multi_dimension_serieses_exist = all_serieses.any? { |series| series.dimensions.length > 1 }
+          raise ArgumentError.new('When more than one series are configured, only one dimension may be used per series') if multi_dimension_serieses_exist
+
+          if all_serieses.length > 1 && ReportsKits.configuration.use_concurrent_queries
+            serieses_dimension_keys_values = multithreaded_serieses_dimension_keys_values
+          else
+            serieses_dimension_keys_values = all_serieses.map do |series|
+              [series, dimension_keys_values_for_series(series)]
+            end
+          end
+          serieses_dimension_keys_values = Hash[serieses_dimension_keys_values]
+          Data::PopulateOneDimension.new(serieses_dimension_keys_values, context_record: context_record, properties: properties).perform
+        end
+
+        def multithreaded_serieses_dimension_keys_values
+          threads = all_serieses.map do |series|
+            Thread.new do
+              ActiveRecord::Base.connection_pool.with_connection do
+                begin
+                  [series, dimension_keys_values_for_series(series)]
+                ensure
+                  ActiveRecord::Base.connection.close if ActiveRecord::Base.connection
+                end
+              end
+            end
+          end
+          threads.map(&:join).map(&:value)
+        end
+
+        def dimension_keys_values_for_series(series)
+          if series.is_a?(CompositeSeries)
+            Data::AggregateComposite.new(series.properties, context_record: context_record).perform
+          else
+            Data::AggregateOneDimension.new(series).perform
+          end
+        end
+
+        def all_serieses
+          @all_serieses ||= Series.new_from_properties!(properties, context_record: context_record)
+        end
+
+        def composite_serieses
+          @composite_serieses ||= all_serieses.grep(CompositeSeries)
+        end
+
+        def serieses
+          @serieses ||= all_serieses.grep(Series)
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/normalize_properties.rb

@@ -0,0 +1,62 @@
+module ReportsKits
+  module Reports
+    module Data
+      class NormalizeProperties
+        attr_accessor :raw_properties
+
+        def initialize(raw_properties)
+          self.raw_properties = raw_properties.dup
+        end
+
+        def perform
+          context_properties = raw_properties.slice(:context_params, :contextual_filters)
+          properties = recursively_normalize_properties(raw_properties)
+          populate_context_properties(properties, context_properties: context_properties)
+        end
+
+        private
+
+        def normalize_filters(series_properties, ui_filters)
+          series_properties[:filters] = series_properties[:filters].map do |filter_properties|
+            filter_properties = { key: filter_properties } if filter_properties.is_a?(String)
+            key = filter_properties[:key]
+            ui_key = filter_properties[:ui_key]
+            value = ui_filters[key.to_sym]
+            value ||= ui_filters[ui_key.to_sym] if ui_key
+            if value
+              filter_properties[:criteria] ||= {}
+              filter_properties[:criteria][:value] = value
+            end
+            filter_properties
+          end
+          series_properties
+        end
+
+        def recursively_normalize_properties(properties, ui_filters: nil)
+          can_have_nesting = properties[:composite_operator].present? || properties[:series].is_a?(Array)
+          ui_filters ||= properties[:ui_filters]
+          properties[:series] ||= properties.slice(*Series::VALID_KEYS).presence
+          properties[:series] = [properties[:series]] if properties[:series].is_a?(Hash) && properties[:series].present?
+          return properties if ui_filters.blank? || properties[:series].blank?
+          properties[:series] = properties[:series].map do |series_properties|
+            series_properties = recursively_normalize_properties(series_properties, ui_filters: ui_filters) if can_have_nesting
+            next(series_properties) if series_properties[:filters].blank?
+            normalize_filters(series_properties, ui_filters)
+          end
+          properties
+        end
+
+        def populate_context_properties(properties, context_properties: nil)
+          return properties if context_properties.blank? || properties.blank? || properties[:series].blank?
+          can_have_nesting = properties[:composite_operator].present? || properties[:series].is_a?(Array)
+          properties[:series] = properties[:series].map do |series_properties|
+            series_properties = series_properties.merge(context_properties)
+            series_properties = populate_context_properties(series_properties, context_properties: context_properties) if can_have_nesting
+            series_properties
+          end
+          properties
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/populate_one_dimension.rb

@@ -0,0 +1,54 @@
+module ReportsKits
+  module Reports
+    module Data
+      class PopulateOneDimension
+        attr_accessor :sparse_serieses_dimension_keys_values, :context_record, :properties
+
+        def initialize(sparse_serieses_dimension_keys_values, context_record: nil, properties: nil)
+          self.sparse_serieses_dimension_keys_values = sparse_serieses_dimension_keys_values
+          self.context_record = context_record
+          self.properties = properties
+        end
+
+        def perform
+          return sparse_serieses_dimension_keys_values if sparse_serieses_dimension_keys_values.length == 1
+          serieses_dimension_keys_values
+        end
+
+        private
+
+        def serieses_dimension_keys_values
+          serieses_dimension_keys_values = sparse_serieses_dimension_keys_values.map do |series, dimension_keys_values|
+            dimension_keys.each do |key|
+              dimension_keys_values[key] ||= 0
+            end
+            [series, dimension_keys_values]
+          end
+          Hash[serieses_dimension_keys_values]
+        end
+
+        def dimension_keys
+          dimension_keys_from_edit_dimension_keys_method || dimension_keys_from_results
+        end
+
+        def dimension_keys_from_edit_dimension_keys_method
+          return unless edit_dimension_keys_method
+          edit_dimension_keys_method.call(dimension_keys: dimension_keys_from_results, properties: properties, context_record: context_record)
+        end
+
+        def dimension_keys_from_results
+          @dimension_keys_from_results ||= begin
+            sparse_serieses_dimension_keys_values.map do |series, dimension_keys_values|
+              dimension_keys_values.keys
+            end.reduce(&:+).uniq
+          end
+        end
+
+        def edit_dimension_keys_method
+          return unless properties
+          ReportsKits.configuration.custom_method(properties[:report_options].try(:[], :edit_dimension_keys_method))
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/populate_two_dimensions.rb

@@ -0,0 +1,104 @@
+module ReportsKits
+  module Reports
+    module Data
+      class PopulateTwoDimensions
+        attr_accessor :serieses, :dimension, :second_dimension, :sparse_serieses_dimension_keys_values
+
+        def initialize(sparse_serieses_dimension_keys_values)
+          self.serieses = sparse_serieses_dimension_keys_values.keys
+          self.dimension = serieses.first.dimensions[0]
+          self.second_dimension = serieses.first.dimensions[1]
+          self.sparse_serieses_dimension_keys_values = sparse_serieses_dimension_keys_values
+        end
+
+        def perform
+          serieses_populated_dimension_keys_values
+        end
+
+        private
+
+        def serieses_populated_dimension_keys_values
+          serieses_dimension_keys_values = {}
+          secondary_keys_sums = Hash.new(0)
+          serieses_populated_primary_keys_secondary_keys_values.each do |series, 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)
+          serieses_populated_primary_keys_secondary_keys_values.each do |series, primary_key_secondary_keys_values|
+            serieses_dimension_keys_values[series] = {}
+            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]
+                serieses_dimension_keys_values[series][dimension_key] = value
+                secondary_keys_sums[secondary_key] += value
+              end
+            end
+          end
+          serieses_dimension_keys_values
+        end
+
+        def serieses_populated_primary_keys_secondary_keys_values
+          @populated_dimension_keys_values ||= begin
+            serieses_populated_primary_keys_secondary_keys_values = {}
+            serieses.each do |series|
+              serieses_populated_primary_keys_secondary_keys_values[series] = {}
+              primary_keys.each do |primary_key|
+                serieses_populated_primary_keys_secondary_keys_values[series][primary_key] = {}
+                secondary_keys.each do |secondary_key|
+                  value = serieses_primary_keys_secondary_keys_values[series][primary_key].try(:[], secondary_key) || 0
+                  serieses_populated_primary_keys_secondary_keys_values[series][primary_key][secondary_key] = value
+                end
+              end
+            end
+            serieses_populated_primary_keys_secondary_keys_values
+          end
+        end
+
+        def serieses_primary_keys_secondary_keys_values
+          @serieses_primary_keys_secondary_keys_values ||= begin
+            serieses_primary_keys_secondary_keys_values = {}
+            sparse_serieses_dimension_keys_values.each do |series, dimension_keys_values|
+              serieses_primary_keys_secondary_keys_values[series] = {}
+              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)
+                serieses_primary_keys_secondary_keys_values[series][primary_key] ||= {}
+                serieses_primary_keys_secondary_keys_values[series][primary_key][secondary_key] = value
+              end
+            end
+            serieses_primary_keys_secondary_keys_values
+          end
+        end
+
+        def dimension_keys
+          @dimension_keys ||= sparse_serieses_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_kits/reports/data/utils.rb

@@ -0,0 +1,178 @@
+module ReportsKits
+  module Reports
+    module Data
+      class Utils
+        def self.format_configuration_time(time)
+          time.strftime('%b %-d, %Y')
+        end
+
+        def self.format_csv_time(time)
+          time.strftime('%Y-%m-%d')
+        end
+
+        def self.format_display_time(time)
+          time.strftime('%b %-d, \'%y')
+        end
+
+        def self.format_date_range(string)
+          start_at, end_at = parse_date_range(string, type: Array)
+          [format_display_time(start_at), FilterTypes::Datetime::SEPARATOR, format_display_time(end_at)].join(' ')
+        end
+
+        def self.format_time_value(value)
+          time = RelativeTime.parse(value, prevent_exceptions: true)
+          return value unless time
+          Utils.format_configuration_time(time)
+        end
+
+        def self.format_number(number)
+          number_i = number.to_i
+          return number_i if number == number_i
+          number.round(Generate::ROUND_PRECISION)
+        end
+
+        def self.quote_column_name(string)
+          ActiveRecord::Base.connection.quote_column_name(string)
+        end
+
+        def self.parse_date_string(string)
+          Date.parse(string)
+        rescue ArgumentError
+          RelativeTime.parse(string)
+        end
+
+        def self.parse_date_range(string, type: nil)
+          return if string.blank?
+          start_string, end_string = string.split(FilterTypes::Datetime::SEPARATOR)
+          start_at = parse_date_string(start_string)
+          end_at = parse_date_string(end_string)
+          if type == Array
+            [start_at, end_at]
+          else
+            (start_at..end_at)
+          end
+        end
+
+        def self.populate_sparse_hash(hash, dimension:)
+          keys = hash.keys
+          is_nested = dimension.series.has_two_dimensions?
+          if is_nested
+            keys_values = arrays_values_to_nested_hash(hash)
+            keys = keys_values.keys
+          else
+            keys_values = hash
+          end
+
+          first_key = dimension.first_key || keys.first
+          return hash unless first_key.is_a?(Time) || first_key.is_a?(Date)
+          keys_values = keys_values.map do |key, value|
+            key = key.to_date if key.is_a?(Time)
+            [key, value]
+          end.to_h
+
+          keys = populate_sparse_keys(keys, dimension: dimension)
+          populated_keys_values = {}
+          default_value = is_nested ? {} : 0
+          keys.each do |key|
+            populated_keys_values[key] = keys_values[key] || default_value
+          end
+          return nested_hash_to_arrays_values(populated_keys_values) if is_nested
+          populated_keys_values
+        end
+
+        def self.populate_sparse_keys(keys, dimension:)
+          first_key = dimension.first_key || keys.first
+          return keys unless first_key.is_a?(Time) || first_key.is_a?(Date)
+          first_key = first_key.to_date
+          granularity = dimension.granularity
+
+          keys = keys.sort
+          last_key = (dimension.last_key || keys.last).to_date
+          if granularity == 'week'
+            first_key = first_key.beginning_of_week(ReportsKits.configuration.first_day_of_week)
+            last_key = last_key.beginning_of_week(ReportsKits.configuration.first_day_of_week)
+          elsif granularity == 'month'
+            first_key = first_key.beginning_of_month
+            last_key = last_key.beginning_of_month
+          end
+
+          date = first_key
+          populated_keys = []
+          interval = case granularity
+                     when 'day' then 1.day
+                     when 'month' then 1.month
+                     else 1.week
+                     end
+          loop do
+            populated_keys << date
+            break if date >= last_key
+            date += interval
+          end
+          populated_keys
+        end
+
+        def self.arrays_values_to_nested_hash(arrays_values)
+          nested_hash = {}
+          arrays_values.each do |(key1, key2), value|
+            nested_hash[key1] ||= {}
+            nested_hash[key1][key2] ||= value
+          end
+          nested_hash
+        end
+
+        def self.nested_hash_to_arrays_values(nested_hash)
+          arrays_values = {}
+          nested_hash.each do |key1, key2s_values|
+            if key2s_values.blank?
+              arrays_values[[key1, nil]] = 0
+              next
+            end
+            key2s_values.each do |key2, value|
+              arrays_values[[key1, key2]] = value
+            end
+          end
+          arrays_values
+        end
+
+        def self.dimension_to_dimension_ids_dimension_instances(dimension, dimension_ids)
+          return nil unless dimension.instance_class
+          primary_key = dimension.instance_class.primary_key
+          dimension_instances = dimension.instance_class.where(primary_key => dimension_ids.uniq)
+          dimension_ids_dimension_instances = dimension_instances.map do |dimension_instance|
+            [dimension_instance.send(primary_key), dimension_instance]
+          end
+          Hash[dimension_ids_dimension_instances]
+        end
+
+        def self.dimension_key_to_entity(dimension_key, dimension, dimension_ids_dimension_instances)
+          instance = dimension_ids_dimension_instances ? dimension_ids_dimension_instances[dimension_key] : dimension_key
+          label = dimension_key_to_label(dimension_key, dimension, dimension_ids_dimension_instances)
+          Entity.new(dimension_key, label, instance)
+        end
+
+        def self.dimension_key_to_label(dimension_instance, dimension, ids_dimension_instances)
+          label = dimension.key_to_label(dimension_instance)
+          return label if label
+          return dimension_instance.to_s if dimension.configured_by_column? && dimension.column_type == :integer
+          case dimension_instance
+          when Time, Date
+            Utils.format_display_time(dimension_instance)
+          when Fixnum
+            raise ArgumentError.new("ids_dimension_instances must be present for Dimension with identifier: #{dimension_instance}") unless ids_dimension_instances
+            instance = ids_dimension_instances[dimension_instance.to_i]
+            return unless instance
+            instance.to_s
+          else
+            dimension_instance.to_s.gsub(/\.0$/, '')
+          end
+        end
+
+        def self.raw_value_to_value(raw_value, value_format_method)
+          formatted_value = format_number(raw_value)
+          formatted_value = value_format_method.call(raw_value) if value_format_method
+          Value.new(raw_value, formatted_value)
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/dimension.rb

@@ -0,0 +1,27 @@
+module ReportsKits
+  module Reports
+    class Dimension
+      attr_accessor :properties
+
+      def initialize(properties)
+        raise ArgumentError.new('Blank properties') if properties.blank?
+        properties = { key: properties } if properties.is_a?(String)
+        raise ArgumentError.new("Dimension properties must be a String or Hash, not a #{properties.class.name}: #{properties.inspect}") unless properties.is_a?(Hash)
+        properties = properties.deep_symbolize_keys
+        self.properties = properties
+      end
+
+      def key
+        properties[:key]
+      end
+
+      def expression
+        properties[:expression] || key
+      end
+
+      def label
+        properties.key?(:label) ? properties[:label] : key.titleize
+      end
+    end
+  end
+end