reports_kits 0.7.5 → 0.7.7

data/lib/reports_kits/form_builder.rb

@@ -0,0 +1,66 @@
+module ReportsKits
+  class FormBuilder
+    include ActionView::Helpers
+
+    DEFAULT_DATE_RANGE_VALUE = ['-2M', 'now']
+
+    attr_accessor :properties, :additional_params, :context_record, :properties_to_filter
+
+    def initialize(properties, additional_params: nil, context_record: nil)
+      self.properties = properties.deep_symbolize_keys
+      self.additional_params = additional_params
+      self.context_record = context_record
+      self.properties_to_filter = Reports::PropertiesToFilter.new(properties, context_record: context_record)
+    end
+
+    def check_box(filter_key, options = {})
+      filter = properties_to_filter.perform(filter_key)
+      checked = options.key?(:value) ? options[:value] : filter.normalized_properties[:criteria].try(:[], :value) == 'true'
+      check_box_tag(filter_key, '1', checked, options)
+    end
+
+    def date_range(filter_key, options = {})
+      filter = properties_to_filter.perform(filter_key)
+      defaults = { class: 'form-control input-sm date_range_picker' }
+      options = defaults.deep_merge(options)
+      value = options[:value].presence || filter.normalized_properties[:criteria].try(:[], :value).presence
+      value ||= default_date_range_value
+      text_field_tag(filter_key, value, options)
+    end
+
+    def multi_autocomplete(filter_key, options = {})
+      filter = properties_to_filter.perform(filter_key)
+      reports_kit_path = Rails.application.routes.url_helpers.reports_kit_path
+      path = "#{reports_kit_path}reports_kit/filters/#{filter_key}/autocomplete?"
+      path += additional_params.to_query if additional_params.present?
+
+      defaults = {
+        class: 'form-control input-sm select2',
+        multiple: 'multiple',
+        data: {
+          placeholder: options[:placeholder],
+          path: path
+        }
+      }
+      options = defaults.deep_merge(options)
+      select_tag(filter_key, nil, options)
+    end
+
+    def string_filter(filter_key, options = {})
+      filter = properties_to_filter.perform(filter_key)
+      defaults = { class: 'form-control input-sm' }
+      options = defaults.deep_merge(options)
+      text_field_tag(filter_key, filter.normalized_properties[:criteria].try(:[], :value), options)
+    end
+
+    private
+
+    def default_date_range_value
+      @default_date_range_value ||= begin
+        start_date = Reports::Data::Utils.format_time_value(DEFAULT_DATE_RANGE_VALUE[0])
+        end_date = Reports::Data::Utils.format_time_value(DEFAULT_DATE_RANGE_VALUE[1])
+        [start_date, Reports::FilterTypes::Datetime::SEPARATOR, end_date].join(' ')
+      end
+    end
+  end
+end

data/lib/reports_kits/helper.rb

@@ -0,0 +1,24 @@
+module ReportsKits
+  module Helper
+    include ReportsKits::NormalizedParams
+
+    def render_report(report_params, context_params: {}, actions: %w(export_csv export_xls), js_report_class: 'Report', &block)
+      report_params = { key: report_params } if report_params.is_a?(String)
+      params.merge!(context_params: context_params, report_params: report_params)
+      properties = Reports::Properties.generate(self)
+      builder = ReportBuilder.new(
+        report_params: report_params,
+        context_params: context_params,
+        actions: actions,
+        js_report_class: js_report_class,
+        properties: properties,
+        view_context: self,
+        block: block
+      )
+      capture do
+        capture(builder, &block) if block
+        builder.render
+      end
+    end
+  end
+end

data/lib/reports_kits/model.rb

@@ -0,0 +1,16 @@
+module ReportsKits
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :reports_kit_configuration
+      end
+
+      def self.reports_kit(&block)
+        self.reports_kit_configuration = ModelConfiguration.new
+        reports_kit_configuration.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/reports_kits/model_configuration.rb

@@ -0,0 +1,28 @@
+module ReportsKits
+  class ModelConfiguration
+    attr_accessor :aggregations, :contextual_filters, :dimensions, :filters
+
+    def initialize
+      self.aggregations = []
+      self.contextual_filters = []
+      self.dimensions = []
+      self.filters = []
+    end
+
+    def aggregation(key, expression, properties = {})
+      aggregations << { key: key.to_s, expression: expression }.merge(properties).symbolize_keys
+    end
+
+    def contextual_filter(key, method)
+      contextual_filters << { key: key, method: method }
+    end
+
+    def dimension(key, properties)
+      dimensions << { key: key.to_s }.merge(properties).symbolize_keys
+    end
+
+    def filter(key, type_key, properties)
+      filters << { key: key.to_s, type_key: type_key }.merge(properties).symbolize_keys
+    end
+  end
+end

data/lib/reports_kits/normalized_params.rb

@@ -0,0 +1,16 @@
+module ReportsKits
+  module NormalizedParams
+    def report_params
+      params[:report_params]
+    end
+
+    def context_params
+      params[:context_params]
+    end
+
+    def report_key
+      raise ArgumentError.new('Blank report_params') if report_params.blank?
+      report_params[:key]
+    end
+  end
+end

data/lib/reports_kits/order.rb

@@ -0,0 +1,33 @@
+module ReportsKits
+  class Order
+    attr_accessor :relation, :field, :direction
+
+    VALID_RELATIONS = %w(count dimension1 dimension2)
+    VALID_FIELDS = [nil, 'label']
+    VALID_DIRECTIONS = %w(asc desc)
+
+    def initialize(relation, field, direction)
+      self.relation = relation
+      self.field = field
+      self.direction = direction
+    end
+
+    def self.parse(string)
+      string ||= ''
+      field_expression, direction = string.to_s.split(/\s+/)
+      relation, field = (field_expression || '').split('.')
+
+      relation = relation.presence
+      field = field.presence
+      direction = direction.presence || 'asc'
+
+      relation = relation.to_i if relation =~ /^\d+$/
+
+      raise ArgumentError.new("Invalid relation: #{relation}") unless VALID_RELATIONS.include?(relation) || relation.is_a?(Fixnum)
+      raise ArgumentError.new("Invalid field: #{field}") unless VALID_FIELDS.include?(field)
+      raise ArgumentError.new("Invalid direction: #{direction}") unless VALID_DIRECTIONS.include?(direction)
+
+      new(relation, field, direction)
+    end
+  end
+end

data/lib/reports_kits/relative_time.rb

@@ -0,0 +1,42 @@
+module ReportsKits
+  class RelativeTime
+    LETTERS_DURATION_METHODS = {
+      'y' => :years,
+      'M' => :months,
+      'w' => :weeks,
+      'd' => :days,
+      'h' => :hours,
+      'm' => :minutes,
+      's' => :seconds
+    }
+    LETTERS = LETTERS_DURATION_METHODS.keys.join
+
+    def self.parse(string, prevent_exceptions: false)
+      return Time.zone.now if string == 'now'
+      original_string = string
+      string = string.to_s.strip
+      is_negative = string[0, 1] == '-'
+      string = string[1..-1] if is_negative
+
+      result_string = is_negative ? '-' : ''
+      result_durations = []
+
+      string.scan(/(\d+)([#{LETTERS}]?)/) do |number, letter|
+        result_string += "#{number}#{letter}"
+        duration_method = LETTERS_DURATION_METHODS[letter]
+        unless duration_method
+          return if prevent_exceptions
+          raise ArgumentError.new("Invalid duration letter: #{letter.inspect}")
+        end
+        result_durations << number.to_i.public_send(duration_method)
+      end
+
+      if result_string == '-' || result_string != original_string.to_s.strip
+        return if prevent_exceptions
+        raise ArgumentError.new("Invalid time duration: #{original_string.inspect}")
+      end
+      duration = result_durations.reduce(&:+)
+      is_negative ? duration.ago : duration.from_now
+    end
+  end
+end

data/lib/reports_kits/report_builder.rb

@@ -0,0 +1,88 @@
+module ReportsKits
+  class ReportBuilder
+    include ActionView::Helpers
+
+    attr_accessor :report_params, :context_params, :additional_params, :actions, :js_report_class, :properties, :view_context, :block, :form_builder
+
+    ACTION_KEYS_METHODS = {
+      'export_csv' => :export_csv_button,
+      'export_xls' => :export_xls_button
+    }
+
+    def initialize(report_params:, context_params: {}, actions: %w(export_csv export_xls), js_report_class: 'Report', properties:, view_context:, block: nil)
+      self.report_params = report_params.is_a?(String) ? { key: report_params } : report_params
+      self.context_params = context_params
+      self.additional_params = { context_params: context_params, report_params: self.report_params }
+      self.actions = actions
+      self.js_report_class = js_report_class
+      self.view_context = view_context
+      self.block = block
+      self.properties = properties
+      context_record = ReportsKits.configuration.context_record(view_context)
+      self.form_builder = ReportsKits::FormBuilder.new(properties, additional_params: additional_params, context_record: context_record)
+    end
+
+    def render
+      data = { properties: properties.slice(:format), path: reports_data_path, report_class: js_report_class }
+      view_context.content_tag :div, nil, class: 'reports_kit_report form-inline', data: data do
+        elements = []
+        elements << view_context.capture(self, &block) if block
+        elements << view_context.content_tag(:div, nil, class: 'reports_kit_visualization')
+        elements << action_elements_container
+        elements.compact.join.html_safe
+      end
+    end
+
+    def form(&block)
+      raise ArgumentError.new('No block given for ReportBuilder#form') unless block
+      view_context.form_tag(reports_data_path, method: 'get', class: 'reports_kit_report_form') do
+        view_context.capture(form_builder, &block)
+      end
+    end
+
+    def export_csv_button(text = 'Download CSV', options = {}, &block)
+      export_button(text, 'csv', options, &block)
+    end
+
+    def export_xls_button(text = 'Download Excel', options = {}, &block)
+      export_button(text, 'xls', options, &block)
+    end
+
+    def export_button(text, format, options, &block)
+      data = {
+        role: 'reports_kit_export_button',
+        path: view_context.reports_kit.reports_kit_reports_path({ format: format }.merge(additional_params))
+      }
+      options = { class: 'btn btn-primary', data: data }.merge(options)
+      if block_given?
+        view_context.link_to('#', options, &block)
+      else
+        view_context.link_to(text, '#', options)
+      end
+    end
+
+    private
+
+    def reports_data_path
+      @reports_data_path ||= view_context.reports_kit.reports_kit_reports_path({ format: 'json' }.merge(additional_params))
+    end
+
+    def action_elements_container
+      return if action_elements.blank?
+      view_context.content_tag(:div, nil, class: 'reports_kit_actions') do
+        action_elements.map { |element| view_context.concat(element) }
+      end
+    end
+
+    def action_elements
+      @action_elements ||= begin
+        return if actions.blank?
+        actions.map do |action|
+          element_method = ACTION_KEYS_METHODS[action]
+          raise ArgumentError.new("Invalid action: #{action}") unless element_method
+          send(element_method)
+        end.compact
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/abstract_series.rb

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

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

@@ -0,0 +1,26 @@
+module ReportsKits
+  module Reports
+    module Adapters
+      class Mysql
+        def self.truncate_to_day(column)
+          "DATE(#{column})"
+        end
+
+        def self.truncate_to_week(column)
+          case ReportsKits.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: #{ReportsKits.configuration.first_day_of_week}")
+          end
+        end
+
+        def self.truncate_to_month(column)
+          "DATE_SUB(DATE(#{column}), INTERVAL DAY(#{column}) - 1 DAY)"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ReportsKits
+  module Reports
+    module Adapters
+      class Postgresql
+        def self.truncate_to_day(column)
+          "#{column}::date"
+        end
+
+        def self.truncate_to_week(column)
+          case ReportsKits.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: #{ReportsKits.configuration.first_day_of_week}")
+          end
+        end
+
+        def self.truncate_to_month(column)
+          "DATE_TRUNC('month', #{column}::date)"
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/composite_series.rb

@@ -0,0 +1,48 @@
+module ReportsKits
+  module Reports
+    class CompositeSeries < AbstractSeries
+      attr_accessor :properties, :context_record
+
+      def initialize(properties, context_record:)
+        self.properties = properties.dup
+        self.context_record = context_record
+      end
+
+      def label
+        name
+      end
+
+      def name
+        properties[:name]
+      end
+
+      def composite_operator
+        properties[:composite_operator]
+      end
+
+      def limit
+        properties[:limit]
+      end
+
+      def serieses
+        @serieses ||= Reports::Series.new_from_properties!(properties, context_record: context_record)
+      end
+
+      def filters
+        serieses.map(&:filters).flatten
+      end
+
+      def primary_series
+        serieses.first
+      end
+
+      def dimensions
+        primary_series.dimensions
+      end
+
+      def model_class
+        primary_series.model_class
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/contextual_filter.rb

@@ -0,0 +1,19 @@
+module ReportsKits
+  module Reports
+    class ContextualFilter
+      attr_accessor :key, :model_settings
+
+      delegate :settings_from_model, to: :model_settings
+
+      def initialize(key, model_class)
+        self.key = key.to_sym
+        self.model_settings = ModelSettings.new(model_class, :contextual_filters, self.key)
+      end
+
+      def apply(relation, context_params)
+        raise ArgumentError.new("contextual_filter with key :#{key} not defined in #{model_class}") if settings_from_model.blank?
+        settings_from_model[:method].call(relation, context_params)
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/add_table_aggregations.rb

@@ -0,0 +1,105 @@
+module ReportsKits
+  module Reports
+    module Data
+      class AddTableAggregations
+        attr_accessor :data, :report_options
+
+        VALID_AGGREGATION_OPERATORS = [:sum]
+
+        def initialize(data, report_options:)
+          self.data = data
+          self.report_options = report_options || {}
+        end
+
+        def perform
+          data_with_aggregations
+        end
+
+        private
+
+        def data_with_aggregations
+          return data if row_aggregation_configs.blank? && column_aggregation_configs.blank?
+          {
+            entities: entities,
+            datasets: datasets
+          }
+        end
+
+        def entities
+          column_aggregation_entities = column_aggregation_configs.map do |config|
+            ReportsKits::Entity.new(config[:label], config[:label], config[:label])
+          end
+          entities_with_row_aggregations + column_aggregation_entities
+        end
+
+        def datasets
+          datasets_with_row_aggregations.map do |dataset|
+            column_aggregation_configs.each do |config|
+              value = aggregate_array(dataset[:values].map(&:formatted), config[:operator])
+              dataset[:values] << ReportsKits::Value.new(value, value)
+            end
+            dataset
+          end
+        end
+
+        def entities_with_row_aggregations
+          @entities_with_row_aggregations ||= begin
+            return original_entities if row_aggregation_configs.blank?
+            row_aggregation_entities = row_aggregation_configs.map do |config|
+              ReportsKits::Entity.new(config[:label], config[:label], config[:label])
+            end
+            original_entities + row_aggregation_entities
+          end
+        end
+
+        def datasets_with_row_aggregations
+          @datasets_with_row_aggregations ||= begin
+            return original_datasets if row_aggregation_configs.blank?
+            row_aggregation_datasets = row_aggregation_configs.map do |config|
+              values = original_datasets.map { |dataset| dataset[:values].map(&:formatted) }.transpose
+              aggregated_values = aggregate_array_of_arrays(values, config[:operator])
+              values = aggregated_values.map { |value| ReportsKits::Value.new(value, value) }
+              {
+                entity: ReportsKits::Entity.new(config[:label], config[:label], config[:label]),
+                values: values
+              }
+            end
+            original_datasets + row_aggregation_datasets
+          end
+        end
+
+        def original_entities
+          data[:entities]
+        end
+
+        def original_datasets
+          data[:datasets]
+        end
+
+        def row_aggregation_configs
+          return [] if report_options[:aggregations].blank?
+          report_options[:aggregations].select { |config| config[:from] == 'rows' }
+        end
+
+        def column_aggregation_configs
+          return [] if report_options[:aggregations].blank?
+          report_options[:aggregations].select { |config| config[:from] == 'columns' }
+        end
+
+        def aggregate_array(values, operator)
+          operator = operator.try(:to_sym)
+          raise ArgumentError.new("Invalid aggregation operator: #{operator}") unless operator.in?(VALID_AGGREGATION_OPERATORS)
+          if values.first.is_a?(Numeric)
+            values.public_send(operator)
+          else
+            nil
+          end
+        end
+
+        def aggregate_array_of_arrays(array_of_arrays, operator)
+          array_of_arrays.map { |values| aggregate_array(values, operator) }
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/data/aggregate_composite.rb

@@ -0,0 +1,97 @@
+module ReportsKits
+  module Reports
+    module Data
+      class AggregateComposite
+        attr_accessor :composite_series, :context_record
+
+        delegate :composite_operator, :properties, to: :composite_series
+
+        OPERATORS_METHODS = {
+          '+' => :+,
+          '-' => :-,
+          '*' => :*,
+          '/' => :/,
+          '%' => -> (values) {
+            raise ArgumentError.new('Percentage composite aggregations must have exactly two series') 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.composite_series = CompositeSeries.new(properties, context_record: context_record)
+          self.context_record = context_record
+        end
+
+        def perform
+          return serieses_results_for_one_dimension if dimension_count == 1
+          return serieses_results_for_two_dimensions if dimension_count == 2
+          raise ArgumentError.new("Composite aggregations' series can only have 1-2 dimensions")
+        end
+
+        private
+
+        def serieses_results_for_one_dimension
+          serieses_results = Hash[serieses.map { |series| [series, AggregateOneDimension.new(series).perform] }]
+          serieses_results = Data::PopulateOneDimension.new(serieses_results, context_record: context_record, properties: properties).perform
+          sorted_dimension_keys_values = sort_dimension_keys_values(serieses_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 = dimension_keys.zip(composited_values)
+          Hash[composited_keys_values]
+        end
+
+        def serieses_results_for_two_dimensions
+          serieses_results = Hash[serieses.map { |series| [series, AggregateTwoDimensions.new(series).perform] }]
+          serieses_results = Data::PopulateTwoDimensions.new(serieses_results).perform
+          value_lists = serieses_results.values.map(&:values)
+          composited_values = value_lists.transpose.map { |data| reduce(data) }
+          dimension_keys = serieses_results.values.first.keys
+          composited_keys_values = dimension_keys.zip(composited_values)
+          Hash[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(serieses_results)
+          dimension_keys_values_list = serieses_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 = serieses.map { |series| series.dimensions.length }.uniq
+          raise ArgumentError.new('All series must have the same number of dimensions') if unique_dimension_counts.length > 1
+          unique_dimension_counts.first
+        end
+
+        def serieses
+          @serieses ||= Series.new_from_properties!(properties, context_record: context_record)
+        end
+      end
+    end
+  end
+end