reports_kits 0.7.5 → 0.7.7

data/lib/reports_kits/reports/data/aggregate_one_dimension.rb

@@ -0,0 +1,39 @@
+module ReportsKits
+  module Reports
+    module Data
+      class AggregateOneDimension
+        attr_accessor :series, :dimension
+
+        def initialize(series)
+          self.series = series
+          self.dimension = series.dimensions[0]
+        end
+
+        def perform
+          dimension_keys_values
+        end
+
+        private
+
+        def dimension_keys_values
+          relation = series.filtered_relation
+          relation = relation.group(dimension.group_expression)
+          relation = relation.joins(dimension.joins) if dimension.joins
+          relation = relation.limit(dimension.dimension_instances_limit) if dimension.dimension_instances_limit
+          relation = relation.order(order)
+          relation = series.edit_relation_method.call(relation) if series.edit_relation_method
+          dimension_keys_values = relation.distinct.public_send(*series.aggregate_function)
+          dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
+          dimension_keys_values.delete(nil)
+          dimension_keys_values.delete('')
+          dimension_keys_values = dimension_keys_values.take(series.limit) if series.limit
+          Hash[dimension_keys_values]
+        end
+
+        def order
+          dimension.configured_by_time? ? '2' : '1 DESC'
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/aggregate_two_dimensions.rb

@@ -0,0 +1,39 @@
+module ReportsKits
+  module Reports
+    module Data
+      class AggregateTwoDimensions
+        attr_accessor :series, :dimension, :second_dimension
+
+        def initialize(series)
+          self.series = series
+          self.dimension = series.dimensions[0]
+          self.second_dimension = series.dimensions[1]
+        end
+
+        def perform
+          dimension_keys_values
+        end
+
+        private
+
+        def dimension_keys_values
+          relation = series.filtered_relation
+          relation = relation.group(dimension.group_expression, second_dimension.group_expression)
+          relation = relation.joins(dimension.joins) if dimension.joins
+          relation = relation.joins(second_dimension.joins) if second_dimension.joins
+          relation = relation.order(order)
+          relation = series.edit_relation_method.call(relation) if series.edit_relation_method
+          dimension_keys_values = relation.distinct.public_send(*series.aggregate_function)
+          dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
+          dimension_keys_values.delete(nil)
+          dimension_keys_values.delete('')
+          Hash[dimension_keys_values]
+        end
+
+        def order
+          dimension.configured_by_time? ? '2' : '1 DESC'
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/chart_data_for_data_method.rb

@@ -0,0 +1,62 @@
+module ReportsKits
+  class ChartDataForDataMethod
+    attr_accessor :properties
+
+    def initialize(properties)
+      self.properties = properties
+    end
+
+    def perform
+      klass, method_name = ReportsKits::Utils.string_to_class_method(properties[:data_method], 'data_method')
+      raw_data = klass.public_send(method_name, properties)
+      {
+        raw_data: raw_data,
+        formatted_data: format_returned_data(raw_data)
+      }
+    end
+
+    private
+
+    def format_returned_data(returned_data)
+      return [] if returned_data.blank?
+      returned_data = returned_data.to_a
+
+      first_key = returned_data.first.first
+      if first_key.is_a?(Array) && first_key.length == 2
+        format_two_dimensional_returned_data(returned_data)
+      else
+        {
+          labels: returned_data.map(&:first),
+          datasets: [
+            {
+              data: returned_data.map(&:last)
+            }
+          ]
+        }
+      end
+    end
+
+    def format_two_dimensional_returned_data(returned_data)
+      primary_keys_secondary_keys_values = {}
+      secondary_keys_primary_keys_values = {}
+      secondary_keys = []
+      returned_data.each do |(primary_key, secondary_key), value|
+        secondary_keys_primary_keys_values[secondary_key] ||= {}
+        secondary_keys_primary_keys_values[secondary_key][primary_key] = value
+        primary_keys_secondary_keys_values[primary_key] ||= {}
+        primary_keys_secondary_keys_values[primary_key][secondary_key] = value
+      end
+      primary_keys = primary_keys_secondary_keys_values.keys
+      datasets = secondary_keys_primary_keys_values.map do |secondary_key, primary_keys_values|
+        {
+          label: secondary_key,
+          data: primary_keys.map { |primary_key| primary_keys_values[primary_key] || 0 }
+        }
+      end
+      {
+        labels: primary_keys,
+        datasets: datasets
+      }
+    end
+  end
+end

data/lib/reports_kits/reports/data/chart_options.rb

@@ -0,0 +1,155 @@
+module ReportsKits
+  module Reports
+    module Data
+      class ChartOptions
+        DEFAULT_COLORS = %w(
+          #1f77b4
+          #aec7e8
+          #ff7f0e
+          #ffbb78
+          #2ca02c
+          #98df8a
+          #d62728
+          #ff9896
+          #9467bd
+          #c5b0d5
+          #8c564b
+          #c49c94
+          #e377c2
+          #f7b6d2
+          #7f7f7f
+          #c7c7c7
+          #bcbd22
+          #dbdb8d
+          #17becf
+          #9edae5
+        ).freeze
+        DEFAULT_OPTIONS = {
+          scales: {
+            xAxes: [{
+              gridLines: {
+                display: false
+              },
+              barPercentage: 0.9,
+              categoryPercentage: 0.9
+            }],
+            yAxes: [{
+              ticks: {
+                beginAtZero: true
+              }
+            }]
+          },
+          legend: {
+            labels: {
+              usePointStyle: true
+            }
+          },
+          maintainAspectRatio: false,
+          tooltips: {
+            xPadding: 8,
+            yPadding: 7
+          }
+        }.freeze
+
+        attr_accessor :data, :options, :chart_options, :inferred_options, :dataset_options, :type
+
+        def initialize(data, options:, inferred_options: {})
+          self.data = data
+          self.options = options.try(:except, :options) || {}
+          self.chart_options = options.try(:[], :options) || {}
+          self.dataset_options = options.try(:[], :datasets)
+          self.type = options.try(:[], :type) || 'bar'
+
+          self.options = inferred_options.deep_merge(self.options) if inferred_options.present?
+        end
+
+        def perform
+          set_colors
+          set_chart_options
+          set_dataset_options
+          set_type
+          data
+        end
+
+        private
+
+        def set_colors
+          if donut_or_pie_chart?
+            set_record_scoped_colors
+          else
+            set_dataset_scoped_colors
+          end
+        end
+
+        def set_record_scoped_colors
+          data[:chart_data][:datasets] = data[:chart_data][:datasets].map do |dataset|
+            length = dataset[:data].length
+            dataset[:backgroundColor] = DEFAULT_COLORS * (length.to_f / DEFAULT_COLORS.length).ceil
+            dataset
+          end
+        end
+
+        def set_dataset_scoped_colors
+          data[:chart_data][:datasets] = data[:chart_data][:datasets].map.with_index do |dataset, index|
+            color = DEFAULT_COLORS[index % DEFAULT_COLORS.length]
+            dataset[:backgroundColor] = color
+            dataset[:borderColor] = color
+            dataset
+          end
+        end
+
+        def default_options
+          @default_options ||= begin
+            return {} if donut_or_pie_chart?
+
+            default_options = DEFAULT_OPTIONS.deep_dup
+
+            x_axis_label = options[:x_axis_label]
+            if x_axis_label
+              default_options[:scales] ||= {}
+              default_options[:scales][:xAxes] ||= []
+              default_options[:scales][:xAxes][0] ||= {}
+              default_options[:scales][:xAxes][0][:scaleLabel] ||= {}
+              default_options[:scales][:xAxes][0][:scaleLabel][:display] ||= true
+              default_options[:scales][:xAxes][0][:scaleLabel][:labelString] ||= x_axis_label
+            end
+
+            y_axis_label = options[:y_axis_label]
+            if y_axis_label
+              default_options[:scales] ||= {}
+              default_options[:scales][:yAxes] ||= []
+              default_options[:scales][:yAxes][0] ||= {}
+              default_options[:scales][:yAxes][0][:scaleLabel] ||= {}
+              default_options[:scales][:yAxes][0][:scaleLabel][:display] ||= true
+              default_options[:scales][:yAxes][0][:scaleLabel][:labelString] ||= y_axis_label
+            end
+
+            default_options
+          end
+        end
+
+        def set_chart_options
+          merged_options = default_options
+          merged_options = merged_options.deep_merge(chart_options) if chart_options
+          data[:chart_data][:options] = merged_options
+        end
+
+        def set_dataset_options
+          return if data[:chart_data][:datasets].blank? || dataset_options.blank?
+          data[:chart_data][:datasets] = data[:chart_data][:datasets].map do |dataset|
+            dataset.merge(dataset_options)
+          end
+        end
+
+        def set_type
+          return if type.blank?
+          data[:type] = type
+        end
+
+        def donut_or_pie_chart?
+          type.in?(%w(donut pie))
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/format_one_dimension.rb

@@ -0,0 +1,140 @@
+module ReportsKits
+  module Reports
+    module Data
+      class FormatOneDimension
+        attr_accessor :serieses_results, :serieses, :order, :limit
+
+        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
+          {
+            entities: entities,
+            datasets: datasets
+          }
+        end
+
+        private
+
+        def entities
+          sorted_dimension_keys.map do |key|
+            Utils.dimension_key_to_entity(key, primary_dimension_with_series, dimension_ids_dimension_instances)
+          end
+        end
+
+        def datasets
+          sorted_serieses_results.map do |series, result|
+            values = result.values.map do |raw_value|
+              Utils.raw_value_to_value(raw_value, series.value_format_method)
+            end
+            {
+              entity: series,
+              values: values
+            }
+          end
+        end
+
+        def dimension_summaries
+          @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.compact
+        end
+
+        def sorted_dimension_keys
+          sorted_serieses_results.first.last.keys
+        end
+
+        def dimension_keys_sorted_by_label
+          dimension_summaries.sort_by { |key, label| label.is_a?(String) ? label.downcase : label }.map(&:first)
+        end
+
+        def dimension_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 = raw_dimension_keys
+            Utils.dimension_to_dimension_ids_dimension_instances(primary_dimension_with_series, dimension_ids)
+          end
+        end
+
+        def primary_dimension_with_series
+          @primary_dimension_with_series ||= DimensionWithSeries.new(dimension: primary_series.dimensions.first, series: primary_series)
+        end
+
+        def primary_series
+          serieses.first
+        end
+
+        def sorted_serieses_results
+          @sorted_serieses_results ||= begin
+            if order.relation == 'dimension1' && order.field == 'label'
+              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'
+                [series, Hash[sorted_dimension_keys_values]]
+              end
+            elsif (order.relation == 'dimension1' && order.field.nil?) || (order.relation == 0)
+              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'
+                [series, Hash[sorted_dimension_keys_values]]
+              end
+            elsif order.relation.is_a?(Fixnum)
+              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_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) }
+                [series, Hash[dimension_keys_values]]
+              end
+            elsif order.relation == 'count'
+              dimension_keys_sums = Hash.new(0)
+              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_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) }
+                [series, Hash[dimension_keys_values]]
+              end
+            else
+              sorted_serieses_results = serieses_results
+            end
+            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
+end

data/lib/reports_kits/reports/data/format_table.rb

@@ -0,0 +1,63 @@
+module ReportsKits
+  module Reports
+    module Data
+      class FormatTable
+        attr_accessor :data, :format, :first_column_label, :report_options
+
+        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_kits/reports/data/format_two_dimensions.rb

@@ -0,0 +1,143 @@
+module ReportsKits
+  module Reports
+    module Data
+      class FormatTwoDimensions
+        attr_accessor :series, :dimension, :second_dimension, :dimension_keys_values, :order, :limit
+
+        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
+          {
+            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, series.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)
+            next if label.blank?
+            [key, label]
+          end.compact
+        end
+
+        def primary_dimension_keys_sorted_by_label
+          @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
+          @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