reports_kits 0.7.5 → 0.7.7

data/lib/reports_kits/reports/dimension_with_series.rb

@@ -0,0 +1,144 @@
+module ReportsKits
+  module Reports
+    class DimensionWithSeries
+      DEFAULT_GRANULARITY = 'week'
+      VALID_GRANULARITIES = %w(day week month).freeze
+      ADAPTER_NAMES_CLASSES = {
+        'mysql2' => Adapters::Mysql,
+        'postgresql' => Adapters::Postgresql
+      }.freeze
+
+      attr_accessor :dimension, :series, :configuration
+
+      delegate :key, :expression, :properties, :label, to: :dimension
+      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(dimension:, series:)
+        self.dimension = dimension
+        self.series = series
+        self.configuration = InferrableConfiguration.new(self, :dimensions)
+        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 granularity
+        @granularity ||= begin
+          return unless configured_by_time?
+          granularity = properties[:granularity] || DEFAULT_GRANULARITY
+          raise ArgumentError.new("Invalid granularity: #{granularity}") unless VALID_GRANULARITIES.include?(granularity)
+          granularity
+        end
+      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?
+          inferred_settings_from_association[:column]
+        elsif configured_by_column? && configured_by_time?
+          case granularity
+          when 'day' then day_expression
+          when 'month' then month_expression
+          else week_expression
+          end
+        elsif configured_by_column?
+          column_expression
+        else
+          raise ArgumentError.new('Invalid group_expression')
+        end
+      end
+
+      def inferred_settings_from_association
+        through_reflection = reflection.through_reflection
+        if through_reflection
+          {
+            joins: through_reflection.name,
+            column: "#{through_reflection.table_name}.#{reflection.source_reflection.foreign_key}"
+          }
+        else
+          {
+            column: "#{model_class.table_name}.#{reflection.foreign_key}"
+          }
+        end
+      end
+
+      def joins
+        return settings_from_model[:joins] if configured_by_model?
+        inferred_settings_from_association[:joins] if configured_by_association?
+      end
+
+      def dimension_instances_limit
+        if configured_by_time?
+          properties[:limit]
+        else
+          properties[:limit] || ReportsKits.configuration.default_dimension_limit
+        end
+      end
+
+      def first_key
+        return unless configured_by_time? && datetime_filters.present?
+        datetime_filters.map(&:start_at).compact.sort.first
+      end
+
+      def last_key
+        return unless configured_by_time? && datetime_filters.present?
+        datetime_filters.map(&:end_at).compact.sort.last
+      end
+
+      def key_to_label(key)
+        return unless settings[:key_to_label]
+        settings[:key_to_label].call(key)
+      end
+
+      def datetime_filters
+        return [] unless series.filters.present?
+        series.filters.map(&:filter_type).select { |filter_type| filter_type.is_a?(FilterTypes::Datetime) }
+      end
+
+      def should_be_sorted_by_count?
+        !configured_by_time?
+      end
+
+      def adapter
+        @adapter ||= begin
+          adapter_name = model_class.connection_config[:adapter]
+          adapter = ADAPTER_NAMES_CLASSES[adapter_name]
+          raise ArgumentError.new("Unsupported adapter: #{adapter_name}") unless adapter
+          adapter
+        end
+      end
+
+      def column_expression
+        "#{model_class.table_name}.#{key}"
+      end
+
+      def day_expression
+        adapter.truncate_to_day(column_expression)
+      end
+
+      def week_expression
+        adapter.truncate_to_week(column_expression)
+      end
+
+      def month_expression
+        adapter.truncate_to_month(column_expression)
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter.rb

@@ -0,0 +1,29 @@
+module ReportsKits
+  module Reports
+    class Filter
+      attr_accessor :properties
+
+      def initialize(properties)
+        properties = { key: properties } if properties.is_a?(String)
+        raise ArgumentError.new("Filter 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
+      end
+
+      def key
+        properties[:key]
+      end
+
+      def expression
+        properties[:expression] || key
+      end
+
+      def label
+        key.titleize
+      end
+
+      def normalized_properties
+        properties
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_types/base.rb

@@ -0,0 +1,48 @@
+module ReportsKits
+  module Reports
+    module FilterTypes
+      class Base
+        attr_accessor :settings, :properties, :primary_dimension
+
+        def initialize(settings, properties, primary_dimension:)
+          self.settings = settings || {}
+          self.properties = properties
+          self.primary_dimension = primary_dimension
+        end
+
+        def apply_filter(records)
+          return records unless valid?
+          records = records.joins(joins) if joins.present?
+          return records if value.blank? && !is_a?(FilterTypes::Boolean)
+          apply_conditions(records)
+        end
+
+        def default_criteria
+          self.class::DEFAULT_CRITERIA
+        end
+
+        private
+
+        def apply_conditions(_records)
+          raise NotImplementedError
+        end
+
+        def criteria
+          @criteria ||= default_criteria.merge(properties[:criteria])
+        end
+
+        def value
+          criteria[:value]
+        end
+
+        def joins
+          settings[:joins]
+        end
+
+        def column
+          settings[:column] || Data::Utils.quote_column_name(properties[:key])
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_types/boolean.rb

@@ -0,0 +1,47 @@
+module ReportsKits
+  module Reports
+    module FilterTypes
+      class Boolean < Base
+        DEFAULT_CRITERIA = {
+          value: nil
+        }
+
+        def apply_conditions(records)
+          case conditions
+          when ::String
+            records.where("(#{conditions}) #{sql_operator} true")
+          when ::Hash
+            boolean_value ? records.where(conditions) : records.not.where(conditions)
+          when ::Proc
+            conditions.call(records)
+          else
+            raise ArgumentError.new("Unsupported conditions type: '#{conditions}'")
+          end
+        end
+
+        def boolean_value
+          case value
+          when true, 'true'
+            true
+          when false, 'false'
+            false
+          else
+            raise ArgumentError.new("Unsupported value: '#{value}'")
+          end
+        end
+
+        def sql_operator
+          boolean_value ? '=' : '!='
+        end
+
+        def valid?
+          value.present?
+        end
+
+        def conditions
+          settings[:conditions] || Data::Utils.quote_column_name(properties[:key])
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_types/datetime.rb

@@ -0,0 +1,51 @@
+module ReportsKits
+  module Reports
+    module FilterTypes
+      class Datetime < Base
+        DEFAULT_CRITERIA = {
+          operator: 'between'
+        }
+        SEPARATOR = ' - '
+
+        def apply_conditions(records)
+          case criteria[:operator]
+          when 'between'
+            records.where.not(column => nil).where(column => start_at..end_at)
+          else
+            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+          end
+        end
+
+        def start_at_end_at
+          @start_at_end_at ||= valid? ? adjust_range_to_dimension(*Reports::Data::Utils.parse_date_range(value, type: Array)) : nil
+        end
+
+        def start_at
+          start_at_end_at.try(:[], 0)
+        end
+
+        def end_at
+          start_at_end_at.try(:[], 1)
+        end
+
+        def adjust_range_to_dimension(start_at, end_at)
+          return [start_at.beginning_of_day, end_at.end_of_day] unless primary_dimension.configured_by_time?
+          return [start_at.beginning_of_day, end_at.end_of_day] if primary_dimension.granularity == 'day'
+          return [
+            start_at.beginning_of_week(ReportsKits.configuration.first_day_of_week),
+            end_at.end_of_week(ReportsKits.configuration.first_day_of_week)
+          ] if primary_dimension.granularity == 'week'
+          return [
+            start_at.beginning_of_month,
+            end_at.end_of_month
+          ] if primary_dimension.granularity == 'month'
+          [start_at, end_at]
+        end
+
+        def valid?
+          value.present?
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_types/number.rb

@@ -0,0 +1,30 @@
+module ReportsKits
+  module Reports
+    module FilterTypes
+      class Number < Base
+        DEFAULT_CRITERIA = {}
+
+        def apply_conditions(records)
+          case criteria[:operator]
+          when '>'
+            records.where(column => (value.to_i...Float::INFINITY))
+          when '>='
+            records.where(column => (value.to_i..Float::INFINITY))
+          when '<'
+            records.where(column => (-Float::INFINITY...value.to_i))
+          when '<='
+            records.where(column => (-Float::INFINITY..value.to_i))
+          when '='
+            records.where(column => value.to_i)
+          else
+            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+          end
+        end
+
+        def valid?
+          value.present?
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_types/records.rb

@@ -0,0 +1,26 @@
+module ReportsKits
+  module Reports
+    module FilterTypes
+      class Records < Base
+        DEFAULT_CRITERIA = {
+          operator: 'include'
+        }
+
+        def apply_conditions(records)
+          case criteria[:operator]
+          when 'include'
+            records.where(column => value)
+          when 'does_not_include'
+            records.where.not(column => value)
+          else
+            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+          end
+        end
+
+        def valid?
+          value.present?
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_types/string.rb

@@ -0,0 +1,38 @@
+module ReportsKits
+  module Reports
+    module FilterTypes
+      class String < Base
+        DEFAULT_CRITERIA = {
+          operator: 'contains'
+        }
+
+        def apply_conditions(records)
+          case criteria[:operator]
+          when 'equals'
+            records.where("#{column} = ?", value)
+          when 'contains'
+            records.where("#{column} ILIKE ?", "%#{value}%")
+          when 'starts_with'
+            records.where("#{column} ILIKE ?", "#{value}%")
+          when 'ends_with'
+            records.where("#{column} ILIKE ?", "%#{value}")
+          when 'does_not_equal'
+            records.where("#{column} != ?", value)
+          when 'does_not_contain'
+            records.where("#{column} NOT ILIKE ?", "%#{value}%")
+          when 'does_not_start_with'
+            records.where("#{column} NOT ILIKE ?", "#{value}%")
+          when 'does_not_end_with'
+            records.where("#{column} NOT ILIKE ?", "%#{value}")
+          else
+            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+          end
+        end
+
+        def valid?
+          value.present?
+        end
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/filter_with_series.rb

@@ -0,0 +1,97 @@
+module ReportsKits
+  module Reports
+    class FilterWithSeries
+      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 :filter, :series, :configuration
+
+      delegate :key, :expression, :properties, :label, to: :filter
+      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(filter:, series:)
+        self.filter = filter
+        self.series = series
+        self.configuration = InferrableConfiguration.new(self, :filters)
+
+        properties[:criteria] = filter_type.default_criteria unless properties[:criteria]
+      end
+
+      def normalized_properties
+        return properties unless configured_by_time?
+        criteria = properties[:criteria]
+        return properties if criteria.blank? || criteria[:value].blank?
+        values = criteria[:value].split(ReportsKits::Reports::FilterTypes::Datetime::SEPARATOR)
+        values = values.map { |value| ReportsKits::Reports::Data::Utils.format_time_value(value) }
+        properties[:criteria][:value] = values.join(ReportsKits::Reports::FilterTypes::Datetime::SEPARATOR)
+        properties
+      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 context_record_association
+        properties[:context_record_association] || instance_class.name.tableize
+      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, primary_dimension: series.dimensions.first)
+      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_contextual_filters(relation, context_params)
+        return relation if properties[:contextual_filters].blank? || context_params.blank?
+        contextual_filters = properties[:contextual_filters].map { |key| ContextualFilter.new(key, relation.base_class) }
+        contextual_filters.each do |contextual_filter|
+          relation = contextual_filter.apply(relation, context_params)
+        end
+        relation
+      end
+
+      def apply(relation)
+        filter_type.apply_filter(relation)
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/generate_autocomplete_method_results.rb

@@ -0,0 +1,29 @@
+module ReportsKits
+  module Reports
+    class GenerateAutocompleteMethodResults
+      attr_accessor :filter_key, :params, :properties
+
+      def initialize(filter_key, properties, params)
+        self.filter_key = filter_key
+        self.params = params
+        self.properties = properties
+      end
+
+      def perform
+        return unless properties[:ui_filters]
+        klass, method_name = ReportsKits::Utils.string_to_class_method(autocomplete_method, 'autocomplete_method')
+        klass.public_send(method_name, params, properties)
+      end
+
+      private
+
+      def filter_hash
+        properties[:ui_filters].find { |filter_params| filter_params.is_a?(Hash) && filter_params[:key] == filter_key }
+      end
+
+      def autocomplete_method
+        filter_hash[:autocomplete_method]
+      end
+    end
+  end
+end

data/lib/reports_kits/reports/generate_autocomplete_results.rb

@@ -0,0 +1,57 @@
+module ReportsKits
+  module Reports
+    class GenerateAutocompleteResults
+      attr_accessor :params, :properties, :filter_key, :filter, :context_params, :context_record
+
+      def initialize(params, properties, context_record: nil)
+        self.params = params
+        self.properties = properties
+        self.context_params = params[:context_params]
+        self.filter_key = params[:key]
+        self.filter = Reports::PropertiesToFilter.new(properties, context_record: context_record).perform(filter_key)
+        self.context_record = context_record
+      end
+
+      def perform
+        autocomplete_method_results = Reports::GenerateAutocompleteMethodResults.new(filter_key, properties, params).perform
+        return autocomplete_method_results if autocomplete_method_results
+        raise ArgumentError.new("Could not find a model for filter_key: '#{filter_key}'") unless model
+        return autocomplete_results_method.call(params: params, context_record: context_record, relation: relation) if autocomplete_results_method
+        results = filter.apply_contextual_filters(relation, context_params)
+        results = results.limit(10_000)
+        results = results.map { |result| { id: result.id, text: result.to_s } }
+        results = results.sort_by { |result| result[:text].downcase }
+        results = filter_results(results)
+        results.first(100)
+      end
+
+      private
+
+      def autocomplete_results_method
+        ReportsKits.configuration.autocomplete_results_method
+      end
+
+      def relation
+        if context_record
+          context_record.public_send(filter.context_record_association)
+        else
+          model
+        end
+      end
+
+      def filter_results(results)
+        query = params[:q].try(:downcase)
+        if query.present?
+          results = results.to_a.select { |r| r[:text].downcase.include?(query) }
+        end
+        results
+      end
+
+      def model
+        @model ||= begin
+          filter.instance_class
+        end
+      end
+    end
+  end
+end