reports_kit 0.0.4 → 0.1.0

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

@@ -0,0 +1,15 @@
+module ReportsKit
+  module Reports
+    module Adapters
+      class Postgresql
+        def self.truncate_to_day(column)
+          "#{column}::date"
+        end
+
+        def self.truncate_to_week(column)
+          "DATE_TRUNC('week', #{column}::timestamp)"
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/data/chart_options.rb

@@ -44,6 +44,7 @@ module ReportsKit
               usePointStyle: true
             }
           },
+          maintainAspectRatio: false,
           tooltips: {
             xPadding: 8,
             yPadding: 7
@@ -73,6 +74,22 @@ module ReportsKit
         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
+          self.data[:chart_data][:datasets] = self.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
           self.data[:chart_data][:datasets] = data[:chart_data][:datasets].map.with_index do |dataset, index|
             color = DEFAULT_COLORS[index % DEFAULT_COLORS.length]
             dataset[:backgroundColor] = color
@@ -83,6 +100,8 @@ module ReportsKit
 
         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]
@@ -126,6 +145,10 @@ module ReportsKit
           return if type.blank?
           self.data[:type] = type
         end
+
+        def donut_or_pie_chart?
+          type.in?(%w(donut pie))
+        end
       end
     end
   end

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

@@ -32,7 +32,7 @@ module ReportsKit
               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 = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
             dimension_keys_values.delete(nil)
             dimension_keys_values.delete('')
             dimension_keys_values

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

@@ -35,11 +35,12 @@ module ReportsKit
             else
               relation = relation.order('2')
             end
-            dimension_keys_values = relation.count
+            dimension_keys_values = relation.distinct.public_send(*measure.aggregate_function)
 
             if dimension.should_be_sorted_by_count?
               dimension_keys_values = sort_dimension_keys_values_by_count(dimension_keys_values)
             end
+            dimension_keys_values = Utils.populate_sparse_hash(dimension_keys_values, dimension: dimension)
             Hash[dimension_keys_values]
           end
         end
@@ -48,6 +49,8 @@ module ReportsKit
           @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
@@ -91,16 +94,17 @@ module ReportsKit
           end
           secondary_keys_values = secondary_keys_values.sort_by { |_, values| values.sum }.reverse
           secondary_keys_values.map do |secondary_key, values|
+            next if secondary_key.blank?
             {
               label: Utils.dimension_key_to_label(secondary_key, second_dimension, second_dimension_ids_dimension_instances),
               data: values
             }
-          end
+          end.compact
         end
 
         def primary_keys
           @primary_keys ||= begin
-            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:first).uniq)
+            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:first).uniq, dimension: dimension)
             if dimension.should_be_sorted_by_count?
               limit = dimension.dimension_instances_limit
               keys = keys.first(limit) if limit
@@ -111,7 +115,7 @@ module ReportsKit
 
         def secondary_keys
           @secondary_keys ||= begin
-            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:last).uniq)
+            keys = Utils.populate_sparse_keys(dimension_keys_values.keys.map(&:last).uniq, dimension: second_dimension)
             limit = second_dimension.dimension_instances_limit
             keys = keys.first(limit) if limit
             keys

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

@@ -6,50 +6,85 @@ module ReportsKit
           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 }
+        def self.populate_sparse_hash(hash, dimension:)
+          return hash if hash.blank?
+          keys = hash.keys
+          is_nested = false
+          if keys.first.is_a?(Array)
+            is_nested = true
+            keys_values = arrays_values_to_nested_hash(hash)
+            keys = keys_values.keys
           else
-            blank_value = 0
+            keys_values = hash
           end
-          loop do
-            full_dimension_instances_values << [time, dimension_keys_values[time] || blank_value]
-            break if time >= last_key
-            time += 1.week
+
+          first_key = dimension.first_key || keys.first
+          return hash unless first_key.is_a?(Time) || first_key.is_a?(Date)
+          keys_values = keys_values.map do |key, value|
+            key = key.to_date if key.is_a?(Time)
+            [key, value]
+          end.to_h
+
+          keys = populate_sparse_keys(keys, dimension: dimension)
+          populated_keys_values = {}
+          default_value = is_nested ? {} : 0
+          keys.each do |key|
+            populated_keys_values[key] = keys_values[key] || default_value
           end
-          Hash[full_dimension_instances_values]
+          return nested_hash_to_arrays_values(populated_keys_values) if is_nested
+          populated_keys_values
         end
 
-        def self.populate_sparse_keys(keys)
+        def self.populate_sparse_keys(keys, dimension:)
           return keys if keys.blank?
-          first_key = keys.first
-          return keys unless first_key.is_a?(Time)
+          first_key = dimension.first_key || keys.first
+          return keys unless first_key.is_a?(Time) || first_key.is_a?(Date)
+          granularity = dimension.granularity
+
+          first_key = first_key.beginning_of_week if granularity == 'week'
           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
+          last_key = dimension.last_key || keys.last
+          last_key = last_key.beginning_of_week if granularity == 'week'
+
+          if granularity == 'week'
+            beginning_of_current_week = Time.now.utc.beginning_of_week(ReportsKit.configuration.first_day_of_week)
+            last_key = [beginning_of_current_week, last_key].compact.max
+          end
 
-          time = first_key
+          date = first_key.to_date
           populated_keys = []
+          interval = granularity == 'week' ? 1.week : 1.day
           loop do
-            populated_keys << time
-            break if time >= last_key
-            time += 1.week
+            populated_keys << date
+            break if date >= last_key
+            date += interval
           end
           populated_keys
         end
 
+        def self.arrays_values_to_nested_hash(arrays_values)
+          nested_hash = {}
+          arrays_values.each do |(key1, key2), value|
+            nested_hash[key1] ||= {}
+            nested_hash[key1][key2] ||= value
+          end
+          nested_hash
+        end
+
+        def self.nested_hash_to_arrays_values(nested_hash)
+          arrays_values = {}
+          nested_hash.each do |key1, key2s_values|
+            if key2s_values.blank?
+              arrays_values[[key1, nil]] = 0
+              next
+            end
+            key2s_values.each do |key2, value|
+              arrays_values[[key1, key2]] = value
+            end
+          end
+          arrays_values
+        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)
@@ -62,12 +97,12 @@ module ReportsKit
         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
+          when Time, Date
             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
+            return unless instance
             instance.to_s
           else
             dimension_instance.to_s.gsub(/\.0$/, '')

data/lib/reports_kit/reports/dimension.rb

@@ -2,6 +2,12 @@ module ReportsKit
   module Reports
     class Dimension
       DEFAULT_DIMENSION_INSTANCES_LIMIT = 30
+      DEFAULT_GRANULARITY = 'week'
+      VALID_GRANULARITIES = %w(day week).freeze
+      ADAPTER_NAMES_CLASSES = {
+        'mysql2' => Adapters::Mysql,
+        'postgresql' => Adapters::Postgresql
+      }.freeze
 
       attr_accessor :properties, :measure, :configuration
 
@@ -26,6 +32,15 @@ module ReportsKit
         properties[:key]
       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 label
         key.titleize
       end
@@ -50,9 +65,9 @@ module ReportsKit
         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)"
+          granularity == 'day' ? day_expression : week_expression
         elsif configured_by_column?
-          "#{model_class.table_name}.#{key}"
+          column_expression
         else
           raise ArgumentError.new('Invalid group_expression')
         end
@@ -70,9 +85,45 @@ module ReportsKit
         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 datetime_filters
+        return [] unless measure.filters.present?
+        measure.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
     end
   end
 end

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

@@ -7,21 +7,36 @@ module ReportsKit
         }
 
         def apply_conditions(records)
+          case conditions
+          when ::String
+            records.where("(#{conditions}) #{sql_operator} true")
+          when ::Hash
+            boolean_operator ? records.where(conditions) : records.not.where(conditions)
+          else
+            raise ArgumentError.new("Unsupported conditions type: '#{conditions}'")
+          end
+        end
+
+        def boolean_operator
           case criteria[:operator]
           when true, 'true'
-            records.where("(#{column}) = true")
+            true
           when false, 'false'
-            records.where("(#{column}) != true")
+            false
           else
             raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
           end
         end
 
+        def sql_operator
+          boolean_operator ? '=' : '!='
+        end
+
         def valid?
           criteria[:operator].present?
         end
 
-        def column
+        def conditions
           settings[:conditions] || properties[:key]
         end
       end

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

@@ -9,15 +9,29 @@ module ReportsKit
         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 start_at_end_at
+          @start_at_end_at ||= begin
+            start_string, end_string = value.split(' - ')
+            start_at = Date.parse(start_string)
+            end_at = Date.parse(end_string)
+            [start_at, end_at]
+          end
+        end
+
+        def start_at
+          start_at_end_at[0]
+        end
+
+        def end_at
+          start_at_end_at[1]
+        end
+
         def valid?
           value.present?
         end

data/lib/reports_kit/reports/generate_autocomplete_results.rb

@@ -12,17 +12,25 @@ module ReportsKit
 
       def perform
         raise ArgumentError.new("Could not find a model for filter_key: '#{filter_key}'") unless model
-        results = model
+        results = relation
         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
+        results.first(100)
       end
 
       private
 
+      def relation
+        if context_record
+          context_record.public_send(model.name.tableize)
+        else
+          model
+        end
+      end
+
       def filter_results(results)
         query = params[:q].try(:downcase)
         if query.present?

data/lib/reports_kit/reports/inferrable_configuration.rb

@@ -5,7 +5,8 @@ module ReportsKit
         :boolean,
         :datetime,
         :integer,
-        :string
+        :string,
+        :text
       ]
 
       attr_accessor :inferrable, :inferrable_type