reports_kit 0.0.1

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

@@ -0,0 +1,65 @@
+module ReportsKit
+  module Reports
+    module Data
+      class Generate
+        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 second_dimension
+            data = Data::TwoDimensions.new(measure, dimension, second_dimension).perform
+          else
+            data = Data::OneDimension.new(measure, dimension).perform
+          end
+
+          ChartOptions.new(data, options: properties[:chart], inferred_options: inferred_options).perform
+        end
+
+        private
+
+        def measure
+          @measure ||= begin
+            measure_hash = properties[:measure]
+            raise ArgumentError.new('The number of measures must be exactly one') if measure_hash.blank?
+            Measure.new(measure_hash, context_record: context_record)
+          end
+        end
+
+        def dimension
+          @dimension ||= begin
+            Dimension.new(dimension_hashes[0], measure: measure)
+          end
+        end
+
+        def second_dimension
+          @second_dimension ||= begin
+            Dimension.new(dimension_hashes[1], measure: measure) if dimension_hashes[1]
+          end
+        end
+
+        def dimension_hashes
+          @dimension_hashes ||= begin
+            dimension_hashes = properties[:dimensions]
+            raise ArgumentError.new('Blank dimensions') if dimension_hashes.blank?
+            raise ArgumentError.new('The number of dimensions must be 1-2') unless dimension_hashes.length.in?([1, 2])
+            dimension_hashes = dimension_hashes.values if dimension_hashes.is_a?(Hash) && dimension_hashes.key?(:'0')
+            dimension_hashes
+          end
+        end
+
+        def inferred_options
+          {
+            x_axis_label: dimension.label,
+            y_axis_label: measure.label
+          }
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/one_dimension.rb

@@ -0,0 +1,71 @@
+module ReportsKit
+  module Reports
+    module Data
+      class OneDimension
+        attr_accessor :measure, :dimension
+
+        def initialize(measure, dimension)
+          self.measure = measure
+          self.dimension = dimension
+        end
+
+        def perform
+          {
+            chart_data: {
+              labels: labels,
+              datasets: datasets
+            }
+          }
+        end
+
+        private
+
+        def dimension_keys_values
+          @dimension_keys_values ||= begin
+            relation = measure.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
+            if dimension.should_be_sorted_by_count?
+              relation = relation.order('1 DESC')
+            else
+              relation = relation.order('2')
+            end
+            dimension_keys_values = relation.distinct.public_send(*measure.aggregate_function)
+            dimension_keys_values = Utils.populate_sparse_values(dimension_keys_values)
+            dimension_keys_values.delete(nil)
+            dimension_keys_values.delete('')
+            dimension_keys_values
+          end
+        end
+
+        def datasets
+          [
+            {
+              label: measure.label,
+              data: values
+            }
+          ]
+        end
+
+        def values
+          dimension_keys_values.values.map { |value| value.round(Generate::ROUND_PRECISION) }
+        end
+
+        def labels
+          keys = dimension_keys_values.keys
+          keys.map do |key|
+            Utils.dimension_key_to_label(key, dimension, dimension_ids_dimension_instances)
+          end
+        end
+
+        def dimension_ids_dimension_instances
+          @dimension_ids_dimension_instances ||= begin
+            dimension_ids = dimension_keys_values.keys
+            Utils.dimension_to_dimension_ids_dimension_instances(dimension, dimension_ids)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/two_dimensions.rb

@@ -0,0 +1,129 @@
+module ReportsKit
+  module Reports
+    module Data
+      class TwoDimensions
+        attr_accessor :measure, :dimension, :second_dimension
+
+        def initialize(measure, dimension, second_dimension)
+          self.measure = measure
+          self.dimension = dimension
+          self.second_dimension = second_dimension
+        end
+
+        def perform
+          {
+            chart_data: {
+              labels: labels,
+              datasets: datasets
+            }
+          }
+        end
+
+        private
+
+        def dimension_keys_values
+          @dimension_keys_values ||= begin
+            relation = measure.filtered_relation
+            relation = measure.conditions.call(relation) if measure.conditions
+            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
+
+            if dimension.should_be_sorted_by_count?
+              relation = relation.order('1 DESC')
+            else
+              relation = relation.order('2')
+            end
+            dimension_keys_values = relation.count
+
+            if dimension.should_be_sorted_by_count?
+              dimension_keys_values = sort_dimension_keys_values_by_count(dimension_keys_values)
+            end
+            Hash[dimension_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_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 sort_dimension_keys_values_by_count(dimension_keys_values)
+          primary_keys_counts = Hash.new(0)
+          dimension_keys_values.each do |(primary_key, secondary_key), count|
+            primary_keys_counts[primary_key] += count
+          end
+          primary_keys_counts = primary_keys_counts.to_a
+          sorted_primary_keys = primary_keys_counts.sort_by { |primary_key, count| count }.reverse.map(&:first)
+          dimension_keys_values = dimension_keys_values.sort_by { |(primary_key, secondary_key), count| sorted_primary_keys.index(primary_key) }
+          Hash[dimension_keys_values]
+        end
+
+        def dimension_ids
+          dimension_keys_values.keys.map(&:first)
+        end
+
+        def dimension_ids_dimension_instances
+          @dimension_ids_dimension_instances ||= begin
+            Utils.dimension_to_dimension_ids_dimension_instances(dimension, dimension_keys_values.keys.map(&:first))
+          end
+        end
+
+        def second_dimension_ids_dimension_instances
+          @second_dimension_ids_dimension_instances ||= begin
+            Utils.dimension_to_dimension_ids_dimension_instances(second_dimension, dimension_keys_values.keys.map(&:last))
+          end
+        end
+
+        def datasets
+          secondary_keys_values = secondary_keys.map do |secondary_key|
+            values = primary_keys.map do |primary_key|
+              primary_keys_secondary_keys_values[primary_key].try(:[], secondary_key) || 0
+            end
+            [secondary_key, values]
+          end
+          secondary_keys_values = secondary_keys_values.sort_by { |_, values| values.sum }.reverse
+          secondary_keys_values.map do |secondary_key, values|
+            {
+              label: Utils.dimension_key_to_label(secondary_key, second_dimension, second_dimension_ids_dimension_instances),
+              data: values
+            }
+          end
+        end
+
+        def primary_keys
+          @primary_keys ||= begin
+            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:first).uniq)
+            if dimension.should_be_sorted_by_count?
+              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_values.keys.map(&:last).uniq)
+            limit = second_dimension.dimension_instances_limit
+            keys = keys.first(limit) if limit
+            keys
+          end
+        end
+
+        def labels
+          primary_keys.map do |primary_key|
+            Utils.dimension_key_to_label(primary_key, dimension, dimension_ids_dimension_instances)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/utils.rb

@@ -0,0 +1,79 @@
+module ReportsKit
+  module Reports
+    module Data
+      class Utils
+        def self.format_time(time)
+          time.strftime('%b %-d, \'%y')
+        end
+
+        def self.populate_sparse_values(dimension_keys_values, use_first_value_key: false)
+          return dimension_keys_values if dimension_keys_values.blank?
+          first_key = dimension_keys_values.first.first
+          return dimension_keys_values unless first_key.is_a?(Time)
+
+          beginning_of_current_week = Time.now.utc.beginning_of_week(ReportsKit.configuration.first_day_of_week)
+          last_key = dimension_keys_values.to_a.last.first
+          last_key = [beginning_of_current_week, last_key].compact.max
+
+          time = first_key
+          full_dimension_instances_values = []
+          if use_first_value_key
+            first_value_key = dimension_keys_values.first.last.keys.first
+            blank_value = { first_value_key => 0 }
+          else
+            blank_value = 0
+          end
+          loop do
+            full_dimension_instances_values << [time, dimension_keys_values[time] || blank_value]
+            break if time >= last_key
+            time += 1.week
+          end
+          Hash[full_dimension_instances_values]
+        end
+
+        def self.populate_sparse_keys(keys)
+          return keys if keys.blank?
+          first_key = keys.first
+          return keys unless first_key.is_a?(Time)
+          keys = keys.sort
+          beginning_of_current_week = Time.now.utc.beginning_of_week(ReportsKit.configuration.first_day_of_week)
+          last_key = keys.last
+          last_key = [beginning_of_current_week, last_key].compact.max
+
+          time = first_key
+          populated_keys = []
+          loop do
+            populated_keys << time
+            break if time >= last_key
+            time += 1.week
+          end
+          populated_keys
+        end
+
+        def self.dimension_to_dimension_ids_dimension_instances(dimension, dimension_ids)
+          return nil unless dimension.instance_class
+          dimension_instances = dimension.instance_class.where(id: dimension_ids.uniq)
+          dimension_ids_dimension_instances = dimension_instances.map do |dimension_instance|
+            [dimension_instance.id, dimension_instance]
+          end
+          Hash[dimension_ids_dimension_instances]
+        end
+
+        def self.dimension_key_to_label(dimension_instance, dimension, ids_dimension_instances)
+          return dimension_instance.to_s if dimension.configured_by_column? && dimension.column_type == :integer
+          case dimension_instance
+          when Time
+            Utils.format_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]
+            raise ArgumentError.new("instance could not be found for Dimension with identifier: #{dimension_instance}") unless instance
+            instance.to_s
+          else
+            dimension_instance.to_s.gsub(/\.0$/, '')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/dimension.rb

@@ -0,0 +1,78 @@
+module ReportsKit
+  module Reports
+    class Dimension
+      DEFAULT_DIMENSION_INSTANCES_LIMIT = 30
+
+      attr_accessor :properties, :measure, :configuration
+
+      delegate :configured_by_association?, :configured_by_column?, :configured_by_model?, :configured_by_time?,
+        :settings_from_model, :reflection, :instance_class, :model_class, :column_type,
+        to: :configuration
+
+      def initialize(properties, measure:)
+        self.configuration = InferrableConfiguration.new(self, :dimensions)
+        self.measure = measure
+
+        raise ArgumentError.new('Blank properties') if properties.blank?
+        properties = { key: properties } if properties.is_a?(String)
+        raise ArgumentError.new("Measure 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
+        missing_group_setting = settings && !settings.key?(:group)
+        raise ArgumentError.new("Dimension settings for dimension '#{key}' of #{model_class} must include :group") if missing_group_setting
+      end
+
+      def key
+        properties[:key]
+      end
+
+      def label
+        key.titleize
+      end
+
+      def settings
+        inferred_settings.merge(settings_from_model)
+      end
+
+      def inferred_settings
+        configuration.inferred_settings.merge(inferred_dimension_settings)
+      end
+
+      def inferred_dimension_settings
+        {
+          group: group_expression
+        }
+      end
+
+      def group_expression
+        if configured_by_model?
+          settings_from_model[:group]
+        elsif configured_by_association?
+          "#{model_class.table_name}.#{reflection.foreign_key}"
+        elsif configured_by_column? && configured_by_time?
+          "date_trunc('week', #{model_class.table_name}.#{key}::timestamp)"
+        elsif configured_by_column?
+          "#{model_class.table_name}.#{key}"
+        else
+          raise ArgumentError.new('Invalid group_expression')
+        end
+      end
+
+      def joins
+        settings_from_model[:joins] if configured_by_model?
+      end
+
+      def dimension_instances_limit
+        if configured_by_time?
+          properties[:limit]
+        else
+          properties[:limit] || DEFAULT_DIMENSION_INSTANCES_LIMIT
+        end
+      end
+
+      def should_be_sorted_by_count?
+        !configured_by_time?
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/filter.rb

@@ -0,0 +1,84 @@
+module ReportsKit
+  module Reports
+    class Filter
+      CONFIGURATION_STRATEGIES_FILTER_TYPE_CLASSES = {
+        association: FilterTypes::Records,
+        boolean: FilterTypes::Boolean,
+        datetime: FilterTypes::Datetime,
+        integer: FilterTypes::Number,
+        string: FilterTypes::String
+      }
+      COLUMN_TYPES_FILTER_TYPE_CLASSES = {
+        boolean: FilterTypes::Boolean,
+        datetime: FilterTypes::Datetime,
+        integer: FilterTypes::Number,
+        string: FilterTypes::String
+      }
+
+      attr_accessor :properties, :measure, :configuration
+
+      delegate :configured_by_association?, :configured_by_column?, :configured_by_model?, :configured_by_time?,
+        :settings_from_model, :configuration_strategy, :instance_class, :column_type, :column,
+        to: :configuration
+
+      def initialize(properties, measure:)
+        self.configuration = InferrableConfiguration.new(self, :filters)
+        self.measure = measure
+
+        properties = { key: properties } if properties.is_a?(String)
+        raise ArgumentError.new("Measure properties must be a String or Hash, not a #{properties.class.name}: #{properties.inspect}") unless properties.is_a?(Hash)
+        self.properties = properties.deep_symbolize_keys
+        self.properties[:criteria] = filter_type.default_criteria unless self.properties[:criteria]
+        self.properties = self.properties
+      end
+
+      def key
+        properties[:key]
+      end
+
+      def label
+        key.titleize
+      end
+
+      def settings
+        inferred_settings.merge(settings_from_model)
+      end
+
+      def inferred_settings
+        configuration.inferred_settings.merge(inferred_filter_settings)
+      end
+
+      def inferred_filter_settings
+        {
+          column: column
+        }
+      end
+
+      def type_klass
+        type_klass_for_configuration_strategy = CONFIGURATION_STRATEGIES_FILTER_TYPE_CLASSES[configuration_strategy]
+        return type_klass_for_configuration_strategy if type_klass_for_configuration_strategy
+        type_klass_for_column_type = COLUMN_TYPES_FILTER_TYPE_CLASSES[column_type]
+        return type_klass_for_column_type if type_klass_for_column_type
+        return filter_type_class_from_model if configured_by_model?
+        raise ArgumentError.new("No configuration found for filter with key: '#{key}'")
+      end
+
+      def filter_type
+        type_klass.new(settings, properties)
+      end
+
+      def filter_type_class_from_model
+        return unless settings
+        type_key = settings[:type_key]
+        raise ArgumentError.new("No type specified for filter with key: '#{key}'") unless type_key
+        type_class = CONFIGURATION_STRATEGIES_FILTER_TYPE_CLASSES[type_key]
+        raise ArgumentError.new("Invalid type ('#{type_key}') specified for filter with key: '#{key}'") unless type_class
+        type_class
+      end
+
+      def apply(relation)
+        filter_type.apply_filter(relation)
+      end
+    end
+  end
+end