query_report 0.1.2 → 1.0.0

data/lib/query_report/chart/chart_column.rb

@@ -0,0 +1,12 @@
+module QueryReport
+  module Chart
+    class Column
+      attr_reader :title, :type
+
+      def initialize(title, type)
+        @title = title
+        @type = type
+      end
+    end
+  end
+end

data/lib/query_report/chart/column_chart.rb

@@ -0,0 +1,40 @@
+require 'query_report/chart/themes'
+require 'query_report/chart/chart_base'
+
+module QueryReport
+  module ColumnChartModule
+    def column_chart(title, &block)
+      chart = QueryReport::Chart::ColumnChart.new(title, self.filtered_query)
+      chart.instance_eval &block if block_given?
+      @charts ||= []
+      @charts << chart
+    end
+  end
+
+  module Chart
+    class ColumnChart < QueryReport::Chart::ChartBase
+      def initialize(title, query, options={})
+        super(title, query, options)
+      end
+
+      def prepare_visualr
+        @data_table = GoogleVisualr::DataTable.new
+
+        ##### Adding column header #####
+        @data_table.new_column('string', '')
+        @columns.each do |col|
+          @data_table.new_column(col.type.to_s, col.title)
+        end
+        ##### Adding column header #####
+
+        @data_table.add_row([''] + @data)
+        options = {:title => title, backgroundColor: 'transparent'}.merge(@options)
+        GoogleVisualr::Interactive::ColumnChart.new(@data_table, options)
+      end
+
+      def to_blob
+        super(:bar)
+      end
+    end
+  end
+end

data/lib/query_report/chart/pie_chart.rb

@@ -1,43 +1,40 @@
 require 'query_report/chart/themes'
+require 'query_report/chart/chart_base'
 
 module QueryReport
-  module Chart
-    class PieChart
-      attr_reader :title, :options, :data_table, :query, :rows
+  module PieChartModule
+    def pie_chart(title, &block)
+      chart = QueryReport::Chart::PieChart.new(title, self.filtered_query)
+      chart.instance_eval &block if block_given?
+      @charts ||= []
+      @charts << chart
+    end
+  end
 
+  module Chart
+    class PieChart < QueryReport::Chart::ChartBase
       def initialize(title, query, options={})
-        @title = title
-        @options = options
-        @rows = []
-        @query = query
+        super(title, query, options)
       end
 
-      def add(column_title, &block)
-        val = block.call(@query)
-        @rows << [column_title, val]
-      end
-
-      def prepare
+      def prepare_visualr
         @data_table = GoogleVisualr::DataTable.new
+
+        ##### Adding column header #####
         @data_table.new_column('string', 'Item')
         @data_table.new_column('number', 'Value')
-        @data_table.add_rows(@rows)
-        opts = {:width => 500, :height => 240, :title => @title, :is3D => true, backgroundColor: 'transparent'}.merge(options)
-        GoogleVisualr::Interactive::PieChart.new(@data_table, opts)
-      end
+        ##### Adding column header #####
 
-      def prepare_gruff
-        @gruff = Gruff::Pie.new(options[:width] || 600)
-        @gruff.title = title
-        @gruff.theme = Gruff::Themes::GOOGLE_CHART
-        @rows.each do |row|
-          @gruff.data(row[0], row[1])
+        @columns.each_with_index do |column, i|
+          @data_table.add_row([column.title, @data[i]])
         end
+
+        options = {:title => title, backgroundColor: 'transparent'}.merge(@options)
+        GoogleVisualr::Interactive::PieChart.new(@data_table, options)
       end
 
       def to_blob
-        prepare_gruff
-        @gruff.to_blob
+        super(:pie)
       end
     end
   end

data/lib/query_report/chart/themes.rb

@@ -1,116 +1,20 @@
-module Gruff
-  module Themes
-    # A color scheme similar to the popular presentation software.
-    KEYNOTE = {
-        :colors => [
-            '#FDD84E', # yellow
-            '#6886B4', # blue
-            '#72AE6E', # green
-            '#D1695E', # red
-            '#8A6EAF', # purple
-            '#EFAA43', # orange
-            'white'
-        ],
-        :marker_color => 'white',
-        :font_color => 'white',
-        :background_colors => ['black', '#4a465a']
-    }
-
-    # A color scheme plucked from the colors on the popular usability blog.
-    THIRTYSEVEN_SIGNALS = {
-        :colors => [
-            '#FFF804', # yellow
-            '#336699', # blue
-            '#339933', # green
-            '#ff0000', # red
-            '#cc99cc', # purple
-            '#cf5910', # orange
-            'black'
-        ],
-        :marker_color => 'black',
-        :font_color => 'black',
-        :background_colors => ['#d1edf5', 'white']
-    }
-
-    # A color scheme from the colors used on the 2005 Rails keynote
-    # presentation at RubyConf.
-    RAILS_KEYNOTE = {
-        :colors => [
-            '#00ff00', # green
-            '#333333', # grey
-            '#ff5d00', # orange
-            '#f61100', # red
-            'white',
-            '#999999', # light grey
-            'black'
-        ],
-        :marker_color => 'white',
-        :font_color => 'white',
-        :background_colors => ['#0083a3', '#0083a3']
-    }
-
-    # A color scheme similar to that used on the popular podcast site.
-    ODEO = {
-        :colors => [
-            '#202020', # grey
-            'white',
-            '#3a5b87', # dark blue
-            '#a21764', # dark pink
-            '#8ab438', # green
-            '#999999', # light grey
-            'black'
-        ],
-        :marker_color => 'white',
-        :font_color => 'white',
-        :background_colors => ['#ff47a4', '#ff1f81']
-    }
-
-    # A pastel theme
-    PASTEL = {
-        :colors => [
-            '#a9dada', # blue
-            '#aedaa9', # green
-            '#daaea9', # peach
-            '#dadaa9', # yellow
-            '#a9a9da', # dk purple
-            '#daaeda', # purple
-            '#dadada' # grey
-        ],
-        :marker_color => '#aea9a9', # Grey
-        :font_color => 'black',
-        :background_colors => 'white'
-    }
-
-    # A greyscale theme
-    GREYSCALE = {
-        :colors => [
-            '#282828', #
-            '#383838', #
-            '#686868', #
-            '#989898', #
-            '#c8c8c8', #
-            '#e8e8e8', #
-        ],
-        :marker_color => '#aea9a9', # Grey
-        :font_color => 'black',
-        :background_colors => 'white'
-    }
-
-    # A pastel theme
-    GOOGLE_CHART = {
-        :colors => [
-            '#3366CC', # blue
-            '#DC3912', # red
-            '#FF9900', # yellow
-            '#109618', # green
-            '#990099', # dk purple
-            '#0099C6', # sky
-            '#DD4477'  # grey
-        ],
-        :marker_color => '#aea9a9', # Grey
-        :font_color => 'black',
-        :background_colors => 'white'
-    }
-
+module QueryReport
+  module Chart
+    module Themes
+      GOOGLE_CHART = {
+          :colors => [
+              '#3366CC', # blue
+              '#DC3912', # red
+              '#FF9900', # yellow
+              '#109618', # green
+              '#990099', # dk purple
+              '#0099C6', # sky
+              '#DD4477' # grey
+          ],
+          :marker_color => '#aea9a9', # Grey
+          :font_color => 'black',
+          :background_colors => 'white'
+      }
+    end
   end
 end

data/lib/query_report/column.rb

@@ -1,32 +1,43 @@
+# Author::    A.K.M. Ashrafuzzaman  (mailto:ashrafuzzaman.g2@gmail.com)
+# License::   MIT-LICENSE
+
+# The purpose of the column module is to define columns that are displayed in the views
+
 module QueryReport
   module ColumnModule
-    def column(name, options={}, &block)
-      options.merge!(model_name: model_name)
-      @columns << Column.new(name, options, block)
-    end
-
-    def columns
-      @columns
-    end
+    attr_accessor :columns
 
-    def column_names
-      @column_names ||= (@columns||[]).collect(&:humanize)
+    # Creates a filter and adds to the filters
+    # Params:
+    # +column+:: the column on which the filter is done on
+    # +options+:: Options can have the following,
+    #             options[:type] => date | text | whatever
+    #             options[:comp] => the comparators used for ransack search, [:gteq, :lteq]
+    #             options[:only_on_web] => the column will appear on the web and not appear in PDF or csv if set to true
+    def column(name, options={}, &block)
+      @columns << Column.new(self, name, options, block)
     end
 
     class Column
-      attr_reader :name, :options, :type, :data
+      attr_reader :report, :name, :options, :type, :data
+
+      def initialize(report, column_name, options={}, block = nil)
+        @report, @name, @options = report, column_name, options
+        @type = @report.model_class.columns_hash[column_name.to_s].try(:type) || options[:type] || :string
+        @data = block || column_name.to_sym
+      end
 
-      def initialize(name, options={}, block = nil)
-        @name = name
-        @options = options
-        @type = (options.kind_of?(Hash) ? options[:type] : options) || 'string'
-        @data = block || name.to_sym
+      def only_on_web?
+        @options[:only_on_web] == true
       end
 
       def humanize
-        options[:as] || options[:model_name].classify.constantize.human_attribute_name(name)
+        @humanize ||= options[:as] || @report.model_class.human_attribute_name(name)
       end
-    end
 
+      def value(record)
+        self.data.kind_of?(Symbol) ? record.send(self.name) : self.data.call(record)
+      end
+    end
   end
 end

data/lib/query_report/config.rb

@@ -0,0 +1,6 @@
+module QueryReport
+  class Configuration
+    include ActiveSupport::Configurable
+    config_accessor :pdf_options
+  end
+end

data/lib/query_report/engine.rb

@@ -0,0 +1,4 @@
+module QueryReport
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/query_report/errors.rb

@@ -0,0 +1,4 @@
+module QueryReport
+  class FilterNotDefined < Exception
+  end
+end

data/lib/query_report/filter.rb

@@ -1,38 +1,102 @@
+# Author::    A.K.M. Ashrafuzzaman  (mailto:ashrafuzzaman.g2@gmail.com)
+# License::   MIT-LICENSE
+
+# The purpose of the filter module is to add feature
+# to support report tool to add custom and predefined filters
+
 module QueryReport
   module FilterModule
-    def filter(column, options, &block)
+    attr_accessor :filters, :search
+
+    # Creates a filter and adds to the filters
+    # Params:
+    # +column+:: the column on which the filter is done on
+    # +options+:: Options can have the following,
+    #             options[:type] => date | text | whatever
+    #             options[:comp] => the comparators used for ransack search, [:gteq, :lteq]
+    def filter(column, options={}, &block)
+      @filters ||= []
       @filters << Filter.new(@params, column, options, &block)
     end
 
-    def filter_with_values
-      hash = {}
+    def apply_filters(query, http_params)
+      # apply default filter
+      params = load_default_values_in_param(http_params) #need for ransack filter
+
+      @search = query.search(params[:q])
+      query = @search.result
+
       @filters.each do |filter|
-        hash.merge!(filter.filter_with_values)
+        if filter.custom?
+          ordered_custom_param_values = filter.search_keys.collect do |key|
+            if filter.boolean?
+              params[:custom_search][key].present? ? params[:custom_search][key] == 'true' : nil
+            else
+              params[:custom_search][key]
+            end
+          end
+          #filter only if there is a given input
+          query = filter.block.call(query, *ordered_custom_param_values) unless ordered_custom_param_values.all? { |p| p.nil? or p == '' }
+        end
+      end
+      query
+    end
+
+    def load_default_values_in_param(http_params)
+      params = http_params.clone
+      params = params.merge(q: {}) unless params[:q]
+      params = params.merge(custom_search: {}) unless params[:custom_search]
+      @filters.each do |filter|
+        if filter.has_default?
+          filter.comparators.each do |comparator|
+            params[filter.params_key][comparator.search_key] ||= comparator.default.to_s
+          end
+        end
+      end
+      params
+    end
+
+    class Comparator
+      attr_reader :filter, :type, :name, :default
+
+      def initialize(filter, type, name, default=nil)
+        @filter, @type, @name, @default = filter, type, name, default.to_s
+      end
+
+      def search_key
+        "#{@filter.column.to_s}_#{@type}".to_sym
+      end
+
+      def search_tag_name
+        "#{@filter.params_key}[#{search_key.to_s}]"
+      end
+
+      def param_value
+        @filter.params[@filter.params_key] ? @filter.params[@filter.params_key][search_key] : default
+      end
+
+      def has_default?
+        !@default.nil?
       end
-      hash
     end
 
     class Filter
-      attr_reader :params, :column, :type, :comparators, :block, :custom
+      attr_reader :params, :column, :type, :comparators, :block, :options
 
+      # Initializes filter with the proper parameters
+      # Params:
+      # +params+:: The params from the http request
       def initialize(params, column, options, &block)
-        @params = params
-        @column = column
+        @params, @column, @options, @comparators, @block = params, column, options, [], block
         @type = options if options.kind_of? String
         if options.kind_of? Hash
           @type = options[:type]
-          @comparators = options[:comp] || detect_comparators(@type)
         end
-        @block = block
-        @custom = @block ? true : false
+        generate_comparators
       end
 
       def self.supported_types
-        [:date, :text]
-      end
-
-      def keys
-        @keys ||= (@comparators || {}).keys.map { |comp| "#{column.to_s}_#{comp}" }
+        [:date, :text, :boolean]
       end
 
       supported_types.each do |supported_type|
@@ -41,25 +105,40 @@ module QueryReport
         end
       end
 
-      def filter_with_values
-        hash = {}
-        @comparators.each do |key, filter_name|
-          [key, filter_name]
-          param_key = "#{column.to_s}_#{key.to_s}"
-          hash[filter_name] = @params['q'][param_key] || @params['custom_search'][param_key] rescue ''
-        end
-        hash
+      def custom?
+        @block ? true : false
+      end
+
+      def search_keys
+        @comparators.collect(&:search_key)
+      end
+
+      def has_default?
+        @comparators.any?(&:has_default?)
+      end
+
+      def params_key
+        custom? ? :custom_search : :q
       end
 
       private
-      def detect_comparators(type)
-        case type
-          when :date
-            return {gteq: I18n.t('query_report.filters.from'), lteq: I18n.t('query_report.filters.to')}
-          when :text
-            return {cont: @column.to_s.humanize}
+      def generate_comparators
+        @options[:comp] ||= case @type
+                              when :date
+                                {gteq: I18n.t('query_report.filters.from'), lteq: I18n.t('query_report.filters.to')}
+                              when :text
+                                {cont: I18n.t("query_report.filters.#{@column.to_s}.contains")}
+                              else
+                                {eq: I18n.t("query_report.filters.#{@column.to_s}.equals")}
+                            end
+
+        if @options[:comp]
+          @options[:comp].each_with_index do |(search_key, filter_name), i|
+            default = nil
+            default = @options[:default].kind_of?(Array) ? @options[:default][i] : @options[:default] if @options[:default]
+            @comparators << Comparator.new(self, search_key, filter_name, default)
+          end
         end
-        {eq: I18n.t('query_report.filters.equal')}
       end
     end
   end