reports_kit 0.2.0 → 0.3.0

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

@@ -2,12 +2,13 @@ module ReportsKit
   module Reports
     module Data
       class FormatOneDimension
-        attr_accessor :measures_results, :measures, :order
+        attr_accessor :serieses_results, :serieses, :order, :limit
 
-        def initialize(measures_results, order:)
-          self.measures_results = measures_results
-          self.measures = measures_results.keys
+        def initialize(serieses_results, order:, limit:)
+          self.serieses_results = serieses_results
+          self.serieses = serieses_results.keys
           self.order = order
+          self.limit = limit
         end
 
         def perform
@@ -21,99 +22,118 @@ module ReportsKit
 
         def entities
           sorted_dimension_keys.map do |key|
-            Utils.dimension_key_to_entity(key, primary_dimension_with_measure, dimension_ids_dimension_instances)
+            Utils.dimension_key_to_entity(key, primary_dimension_with_series, dimension_ids_dimension_instances)
           end
         end
 
         def datasets
-          sorted_measures_results.map do |measure, result|
+          sorted_serieses_results.map do |series, result|
             values = result.values.map do |raw_value|
-              Utils.raw_value_to_value(raw_value, measure.value_format_method)
+              Utils.raw_value_to_value(raw_value, series.value_format_method)
             end
             {
-              entity: measure,
+              entity: series,
               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_summaries ||= raw_dimension_keys.map do |dimension_key|
+            label = Utils.dimension_key_to_label(dimension_key, primary_dimension_with_series, dimension_ids_dimension_instances)
+            next if label.blank?
             [dimension_key, label]
-          end
+          end.compact
         end
 
         def sorted_dimension_keys
-          sorted_measures_results.first.last.keys
+          sorted_serieses_results.first.last.keys
         end
 
         def dimension_keys_sorted_by_label
-          @dimension_keys_sorted_by_label ||= dimension_summaries.sort_by(&:last).map(&:first)
+          dimension_summaries.sort_by { |key, label| label.is_a?(String) ? label.downcase : label }.map(&:first)
         end
 
         def dimension_keys
-          measures_results.first.last.keys
+          dimension_summaries.map(&:first)
+        end
+
+        def raw_dimension_keys
+          serieses_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)
+            dimension_ids = raw_dimension_keys
+            Utils.dimension_to_dimension_ids_dimension_instances(primary_dimension_with_series, dimension_ids)
           end
         end
 
-        def primary_dimension_with_measure
-          @primary_dimension_with_measure ||= DimensionWithMeasure.new(dimension: primary_measure.dimensions.first, measure: primary_measure)
+        def primary_dimension_with_series
+          @primary_dimension_with_series ||= DimensionWithSeries.new(dimension: primary_series.dimensions.first, series: primary_series)
         end
 
-        def primary_measure
-          measures.first
+        def primary_series
+          serieses.first
         end
 
-        def sorted_measures_results
-          @sorted_measures_results ||= begin
+        def sorted_serieses_results
+          @sorted_serieses_results ||= begin
             if order.relation == 'dimension1' && order.field == 'label'
-              sorted_measures_results = measures_results.map do |measure, dimension_keys_values|
+              sorted_serieses_results = serieses_results.map do |series, dimension_keys_values|
+                dimension_keys_values = filter_dimension_keys_values(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]]
+                [series, 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_serieses_results = serieses_results.map do |series, dimension_keys_values|
+                dimension_keys_values = filter_dimension_keys_values(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]]
+                [series, 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]
+              series_index = order.relation - 1
+              raise ArgumentError.new("Invalid order column: #{order.relation}") unless series_index.in?((0..(serieses_results.length - 1)))
+              dimension_keys_values = serieses_results.values.to_a[series_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|
+              sorted_serieses_results = serieses_results.map do |series, dimension_keys_values|
+                dimension_keys_values = filter_dimension_keys_values(dimension_keys_values)
                 dimension_keys_values = dimension_keys_values.sort_by { |dimension_key, _| sorted_dimension_keys.index(dimension_key) }
-                [measure, Hash[dimension_keys_values]]
+                [series, Hash[dimension_keys_values]]
               end
             elsif order.relation == 'count'
               dimension_keys_sums = Hash.new(0)
-              measures_results.values.each do |dimension_keys_values|
+              serieses_results.values.each do |dimension_keys_values|
+                dimension_keys_values = filter_dimension_keys_values(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|
+              sorted_serieses_results = serieses_results.map do |series, dimension_keys_values|
+                dimension_keys_values = filter_dimension_keys_values(dimension_keys_values)
                 dimension_keys_values = dimension_keys_values.sort_by { |dimension_key, _| sorted_dimension_keys.index(dimension_key) }
-                [measure, Hash[dimension_keys_values]]
+                [series, Hash[dimension_keys_values]]
               end
             else
-              sorted_measures_results = measures_results
+              sorted_serieses_results = serieses_results
             end
-            Hash[sorted_measures_results]
+            if limit
+              sorted_serieses_results = sorted_serieses_results.map do |series, results|
+                [series, Hash[results.to_a.take(limit)]]
+              end
+            end
+            Hash[sorted_serieses_results]
           end
         end
+
+        def filter_dimension_keys_values(dimension_keys_values)
+          dimension_keys_values.select { |key, values| dimension_keys.include?(key) }
+        end
       end
     end
   end

data/lib/reports_kit/reports/data/format_table.rb

@@ -0,0 +1,65 @@
+module ReportsKit
+  module Reports
+    module Data
+      class FormatTable
+        attr_accessor :data, :format, :first_column_label, :report_options
+
+        VALID_AGGREGATION_OPERATORS = [:sum]
+
+        def initialize(data, format:, first_column_label:, report_options:)
+          self.data = data
+          self.format = format
+          self.first_column_label = first_column_label
+          self.report_options = report_options || {}
+        end
+
+        def perform
+          table_data
+        end
+
+        private
+
+        def table_data
+          data_rows_with_labels = data_rows.map.with_index do |data_row, index|
+            label = format_string(data[:labels][index])
+            [label] + data_row
+          end
+          [column_names] + data_rows_with_labels
+        end
+
+        def column_names
+          column_names_column_values[0]
+        end
+
+        def column_values
+          column_names_column_values[1]
+        end
+
+        def data_rows
+          @data_rows ||= column_values.transpose
+        end
+
+        def column_names_column_values
+          @column_names_column_values ||= begin
+            column_names = [format_string(first_column_label)]
+            column_values = []
+            data[:datasets].each do |dataset|
+              column_names << format_string(dataset[:label])
+              column_values << dataset[:data]
+            end
+            [column_names, column_values]
+          end
+        end
+
+        def format_string(string)
+          return string unless string && strip_html_tags?
+          ActionView::Base.full_sanitizer.sanitize(string)
+        end
+
+        def strip_html_tags?
+          format == 'csv'
+        end
+      end
+    end
+  end
+end

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

@@ -2,14 +2,15 @@ module ReportsKit
   module Reports
     module Data
       class FormatTwoDimensions
-        attr_accessor :measure, :dimension, :second_dimension, :dimension_keys_values, :order
+        attr_accessor :series, :dimension, :second_dimension, :dimension_keys_values, :order, :limit
 
-        def initialize(measure, dimension_keys_values, order:)
-          self.measure = measure
-          self.dimension = measure.dimensions[0]
-          self.second_dimension = measure.dimensions[1]
+        def initialize(series, dimension_keys_values, order:, limit:)
+          self.series = series
+          self.dimension = series.dimensions[0]
+          self.second_dimension = series.dimensions[1]
           self.dimension_keys_values = dimension_keys_values
           self.order = order
+          self.limit = limit
         end
 
         def perform
@@ -33,7 +34,7 @@ module ReportsKit
               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)
+              Utils.raw_value_to_value(raw_value, series.value_format_method)
             end
             [secondary_key, values]
           end
@@ -120,12 +121,13 @@ module ReportsKit
         def primary_summaries
           primary_keys.map do |key|
             label = Utils.dimension_key_to_label(key, dimension, dimension_ids_dimension_instances)
+            next if label.blank?
             [key, label]
-          end
+          end.compact
         end
 
         def primary_dimension_keys_sorted_by_label
-          @primary_dimension_keys_sorted_by_label ||= primary_summaries.sort_by(&:last).map(&:first)
+          @primary_dimension_keys_sorted_by_label ||= primary_summaries.sort_by { |key, label| label.is_a?(String) ? label.downcase : label }.map(&:first)
         end
 
         def primary_keys

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

@@ -8,28 +8,30 @@ module ReportsKit
 
         def initialize(properties, context_record: nil)
           self.properties = properties.deep_symbolize_keys
+          self.properties = ReportsKit.configuration.default_properties.deep_merge(self.properties) if ReportsKit.configuration.default_properties
           self.properties = Utils.normalize_properties(self.properties)
           self.context_record = context_record
         end
 
         def perform
           data = ReportsKit::Cache.get(properties, context_record)
-          return data if data
+          return data.deep_symbolize_keys if data
 
           if two_dimensions?
-            raw_data = Data::FormatTwoDimensions.new(measures.first, measures_results.first.last, order: order).perform
+            raw_data = Data::FormatTwoDimensions.new(serieses.first, serieses_results.first.last, order: order, limit: limit).perform
           else
-            raw_data = Data::FormatOneDimension.new(measures_results, order: order).perform
+            raw_data = Data::FormatOneDimension.new(serieses_results, order: order, limit: limit).perform
           end
-          raw_data = data_format_method.call(raw_data) if data_format_method
+          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'
           chart_data = format_chart_data(raw_data)
 
           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
+          data[:report_options] = report_options if report_options
+          data = format_table_data(data) if table_or_csv?
           ReportsKit::Cache.set(properties, context_record, data)
           data
         end
@@ -48,12 +50,23 @@ module ReportsKit
           chart_data
         end
 
-        def measures_results
-          @measures_results ||= GenerateForProperties.new(properties, context_record: context_record).perform
+        def format_table_data(data)
+          data[:table_data] = Data::FormatTable.new(
+            data.delete(:chart_data),
+            format: format,
+            first_column_label: primary_dimension.label,
+            report_options: report_options
+          ).perform
+          data[:type] = format
+          data
+        end
+
+        def serieses_results
+          @serieses_results ||= GenerateForProperties.new(properties, context_record: context_record).perform
         end
 
         def two_dimensions?
-          dimension_keys = measures_results.first.last.keys
+          dimension_keys = serieses_results.first.last.keys
           dimension_keys.first.is_a?(Array)
         end
 
@@ -64,46 +77,56 @@ module ReportsKit
           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 measures
-          @measures ||= Measure.new_from_properties!(properties, context_record: context_record)
+        def serieses
+          @serieses ||= Series.new_from_properties!(properties, context_record: context_record)
+        end
+
+        def report_options
+          properties[:report_options]
         end
 
         def data_format_method
-          ReportsKit.configuration.custom_method(properties[:data_format_method])
+          ReportsKit.configuration.custom_method(report_options.try(:[], :data_format_method))
+        end
+
+        def csv_data_format_method
+          ReportsKit.configuration.custom_method(report_options.try(:[], :csv_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]
+        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
-          rows = column_values.transpose
-          rows = rows.map.with_index do |row, index|
-            label = data[:labels][index]
-            row.unshift(label)
-          end
-          [column_names] + rows
+          raw_data
         end
 
         def primary_dimension
-          measures.first.dimensions.first
+          serieses.first.dimensions.first
+        end
+
+        def table_or_csv?
+          format.in?(%w(table csv))
         end
 
         def inferred_options
           {
             x_axis_label: primary_dimension.label,
-            y_axis_label: measures.length == 1 ? measures.first.label : nil
+            y_axis_label: serieses.length == 1 ? serieses.first.label : nil
           }
         end
       end

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

@@ -13,23 +13,23 @@ module ReportsKit
 
         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
+            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) => 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
 
-          measures_dimension_keys_values
+          serieses_dimension_keys_values
         end
 
         private
@@ -42,32 +42,54 @@ module ReportsKit
           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
+        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
 
-          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
+          if all_serieses.length > 1 && ReportsKit.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
-            [measure, dimension_keys_values]
           end
-          measures_dimension_keys_values = Hash[measures_dimension_keys_values]
-          Data::PopulateOneDimension.new(measures_dimension_keys_values).perform
+          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_measures
-          @all_measures ||= Measure.new_from_properties!(properties, context_record: context_record)
+        def all_serieses
+          @all_serieses ||= Series.new_from_properties!(properties, context_record: context_record)
         end
 
-        def composite_measures
-          @composite_measures ||= all_measures.grep(CompositeMeasure)
+        def composite_serieses
+          @composite_serieses ||= all_serieses.grep(CompositeSeries)
         end
 
-        def measures
-          @measures ||= all_measures.grep(Measure)
+        def serieses
+          @serieses ||= all_serieses.grep(Series)
         end
       end
     end