reports_kit 0.0.1

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

@@ -0,0 +1,47 @@
+module ReportsKit
+  module Reports
+    module FilterTypes
+      class Base
+        attr_accessor :settings, :properties
+
+        def initialize(settings, properties)
+          self.settings = settings || {}
+          self.properties = properties
+        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
+          properties[:criteria]
+        end
+
+        def value
+          criteria[:value]
+        end
+
+        def joins
+          settings[:joins]
+        end
+
+        def column
+          settings[:column] || properties[:key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module ReportsKit
+  module Reports
+    module FilterTypes
+      class Boolean < Base
+        DEFAULT_CRITERIA = {
+          operator: nil
+        }
+
+        def apply_conditions(records)
+          case criteria[:operator]
+          when true, 'true'
+            records.where("(#{column}) = true")
+          when false, 'false'
+            records.where("(#{column}) != true")
+          else
+            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+          end
+        end
+
+        def valid?
+          criteria[:operator].present?
+        end
+
+        def column
+          settings[:conditions] || properties[:key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module ReportsKit
+  module Reports
+    module FilterTypes
+      class Datetime < Base
+        DEFAULT_CRITERIA = {
+          operator: 'between'
+        }
+
+        def apply_conditions(records)
+          case criteria[:operator]
+          when 'between'
+            start_string, end_string = value.split(' - ')
+            start_at = Date.parse(start_string)
+            end_at = Date.parse(end_string)
+            records.where("#{column} IS NOT NULL").where("#{column} BETWEEN ? AND ?", start_at, end_at)
+          else
+            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+          end
+        end
+
+        def valid?
+          value.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ReportsKit
+  module Reports
+    module FilterTypes
+      class Number < Base
+        def apply_conditions(records)
+          case criteria[:operator]
+          when '>'
+            records.where("#{column} > #{value.to_i}")
+          when '>='
+            records.where("#{column} >= #{value.to_i}")
+          when '<'
+            records.where("#{column} < #{value.to_i}")
+          when '<='
+            records.where("#{column} <= #{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_kit/reports/filter_types/records.rb

@@ -0,0 +1,26 @@
+module ReportsKit
+  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_kit/reports/filter_types/string.rb

@@ -0,0 +1,38 @@
+module ReportsKit
+  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_kit/reports/generate_autocomplete_results.rb

@@ -0,0 +1,55 @@
+module ReportsKit
+  module Reports
+    class GenerateAutocompleteResults
+      attr_accessor :params, :measure_key, :filter_key, :context_record
+
+      def initialize(params, context_record: nil)
+        self.params = params
+        self.measure_key = params[:measure_key]
+        self.filter_key = params[:filter_key]
+        self.context_record = context_record
+      end
+
+      def perform
+        raise ArgumentError.new("Could not find a model for filter_key: '#{filter_key}'") unless model
+        results = model
+        results = results.public_send(scope) if scope
+        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
+      end
+
+      private
+
+      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
+          measure = Measure.new(measure_key, context_record: context_record)
+          filter = Filter.new(filter_key, measure: measure)
+          filter.instance_class
+        end
+      end
+
+      def scope
+        @scope ||= begin
+          scope = params[:scope]
+          return unless scope.present?
+          return unless model.try(:reports_kit_configuration) && model.reports_kit_configuration.autocomplete_scopes.present?
+          unless model.reports_kit_configuration.autocomplete_scopes.include?(scope)
+            raise ArgumentError.new("Unallowed scope '#{scope}' for model #{model.name}")
+          end
+          scope
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/inferrable_configuration.rb

@@ -0,0 +1,113 @@
+module ReportsKit
+  module Reports
+    class InferrableConfiguration
+      SUPPORTED_COLUMN_TYPES = [
+        :boolean,
+        :datetime,
+        :integer,
+        :string
+      ]
+
+      attr_accessor :inferrable, :inferrable_type
+
+      delegate :key, :measure, to: :inferrable
+
+      def initialize(inferrable, inferrable_type)
+        self.inferrable = inferrable
+        self.inferrable_type = inferrable_type
+      end
+
+      def configuration_strategy
+        if settings_from_model.present?
+          :model
+        elsif reflection
+          :association
+        elsif column_type
+          :column
+        else
+          inferrable_type_string = inferrable_type.to_s.singularize
+          raise ArgumentError.new("No configuration found on the #{model_class} model for #{inferrable_type_string} with key: '#{key}'")
+        end
+      end
+
+      def configured_by_association?
+        configuration_strategy == :association
+      end
+
+      def configured_by_column?
+        configuration_strategy == :column
+      end
+
+      def configured_by_model?
+        configuration_strategy == :model
+      end
+
+      def configured_by_time?
+        column_type == :datetime
+      end
+
+      def settings_from_model
+        return {} if model_configuration.blank?
+        return {} if model_configuration.public_send(inferrable_type).blank?
+        config_hash = model_configuration.public_send(inferrable_type).find do |hash|
+          hash[:key] == key
+        end
+        config_hash || {}
+      end
+
+      def reflection
+        model_class.reflect_on_association(key.to_sym)
+      end
+
+      def instance_class
+        return reflection.class_name.constantize if reflection
+        nil
+      end
+
+      def column
+        return unless inferred_settings
+        inferred_settings[:column]
+      end
+
+      def inferred_settings
+        return { column: "#{model_class.table_name}.#{key}" } if configured_by_column?
+        if configured_by_association?
+          return { column: "#{model_class.table_name}.#{reflection.foreign_key}" } if reflection.macro == :belongs_to
+          return inferred_settings_from_has_many if inferred_settings_from_has_many
+        end
+        {}
+      end
+
+      def inferred_settings_from_has_many
+        return unless reflection.macro == :has_many
+        through_reflection = reflection.through_reflection
+        if through_reflection
+          {
+            joins: through_reflection.name,
+            column: "#{through_reflection.table_name}.#{reflection.source_reflection.foreign_key}"
+          }
+        else
+          {
+            joins: reflection.name,
+            column: "#{reflection.klass.table_name}.#{reflection.klass.primary_key}"
+          }
+        end
+      end
+
+      def column_type
+        column_type = model_class.columns_hash[key.to_s].try(:type)
+        return column_type if SUPPORTED_COLUMN_TYPES.include?(column_type)
+      end
+
+      def model_configuration
+        return unless model_class && model_class.respond_to?(:reports_kit_configuration)
+        model_class.reports_kit_configuration
+      end
+
+      def model_class
+        return unless measure
+        measure.model_class
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/measure.rb

@@ -0,0 +1,58 @@
+module ReportsKit
+  module Reports
+    class Measure
+      attr_accessor :properties, :filters, :context_record
+
+      def initialize(properties, context_record: nil)
+        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
+        filter_hashes = properties.delete(:filters) || []
+        filter_hashes = filter_hashes.values if filter_hashes.is_a?(Hash) && filter_hashes.key?(:'0')
+
+        self.properties = properties
+        self.filters = filter_hashes.map { |filter_hash| Filter.new(filter_hash, measure: self) }
+        self.context_record = context_record
+      end
+
+      def key
+        properties[:key]
+      end
+
+      def label
+        key.pluralize.titleize
+      end
+
+      def aggregate_function
+        :count
+      end
+
+      def conditions
+        nil
+      end
+
+      def base_relation
+        return context_record.public_send(key.pluralize) if context_record
+        model_class
+      end
+
+      def model_class
+        key.camelize.constantize
+      end
+
+      def filtered_relation
+        relation = base_relation
+        filters.each do |filter|
+          relation = filter.apply(relation)
+        end
+        relation
+      end
+
+      def properties_with_filters
+        all_properties = properties
+        all_properties[:filters] = filters.map(&:properties)
+        all_properties
+      end
+    end
+  end
+end

data/lib/reports_kit/reports_controller.rb

@@ -0,0 +1,15 @@
+module ReportsKit
+  class ReportsController < ReportsKit::BaseController
+    def index
+      # RubyProf.start
+      properties = ActiveSupport::JSON.decode(params[:properties])
+      report_data = Reports::Data::Generate.new(properties, context_record: context_record).perform
+      # result = RubyProf.stop
+      # printer = RubyProf::CallStackPrinter.new(result)
+      # File.open(Rails.root.join('tmp', 'out.html'), 'w') do |file|
+      #   printer.print(file, :min_percent => 2)
+      # end
+      render json: { data: report_data }
+    end
+  end
+end