query_report 0.1.2 → 1.0.0

data/lib/query_report/helper.rb

@@ -1,4 +1,11 @@
+# Author::    A.K.M. Ashrafuzzaman  (mailto:ashrafuzzaman.g2@gmail.com)
+# License::   MIT-LICENSE
+
+# The purpose of the helper module is to help controllers with the responders
+
+require 'csv'
 require 'query_report/report'
+require 'query_report/report_pdf'
 
 module QueryReport
   module Helper
@@ -13,10 +20,19 @@ module QueryReport
       respond_to do |format|
         format.js { render 'query_report/list' }
         format.html { render 'query_report/list' }
-        format.json { render json: @report.records }
+        format.json { render json: @report.all_records }
         format.csv { send_data generate_csv_for_report(@report.all_records), :disposition => "attachment;" }
-        format.pdf { render_pdf(ReportPdf.new(@report).standard) }
+        format.pdf { send_data query_report_pdf_template_class.new(@report).to_pdf.render }
+      end
+    end
+
+    def query_report_pdf_template_class
+      options = QueryReport.config.pdf_options
+      if options[:template_class]
+        @template_class ||= options[:template_class].to_s.constantize
+        return @template_class
       end
+      reurn QueryReport::ReportPdf
     end
 
     def generate_csv_for_report(records)
@@ -25,7 +41,7 @@ module QueryReport
         CSV.generate do |csv|
           csv << columns
           records.each do |record|
-            csv << record.values
+            csv << record.values.collect { |val| val.kind_of?(String) ? view_context.strip_links(val) : val }
           end
         end
       else

data/lib/query_report/paginate.rb

@@ -0,0 +1,13 @@
+# Author::    A.K.M. Ashrafuzzaman  (mailto:ashrafuzzaman.g2@gmail.com)
+# License::   MIT-LICENSE
+
+# The purpose of the paginate module is to offer support for pagination
+
+module QueryReport
+  module PaginateModule
+    def apply_pagination(query, params)
+      page_method_name = Kaminari.config.page_method_name
+      query.send(page_method_name, params[:page])
+    end
+  end
+end

data/lib/query_report/record.rb

@@ -0,0 +1,46 @@
+module QueryReport
+  module Record
+    attr_accessor :query
+
+    def model_class
+      query.klass
+    end
+
+    def filtered_query
+      apply
+      @filtered_query
+    end
+
+    def paginated_query
+      apply
+      @paginated_query
+    end
+
+    def search
+      apply
+      @search
+    end
+
+    def apply
+      @filtered_query ||= apply_filters(query.clone, @params)
+      @paginated_query ||= apply_pagination(@filtered_query, @params)
+    end
+
+    def records
+      @records ||= map_record(paginated_query, true)
+    end
+
+    def all_records
+      @all_records ||= map_record(filtered_query, false)
+    end
+
+    def map_record(query, render_from_view)
+      @columns = @columns.delete_if { |col| col.only_on_web? } unless render_from_view
+
+      query.map do |record|
+        array = @columns.collect { |column| [column.humanize, column.value(record)] }
+        Hash[*array.flatten]
+      end
+    end
+  end
+end

data/lib/query_report/report.rb

@@ -1,25 +1,31 @@
-require 'query_report/filter'
-require 'query_report/column'
-
 module QueryReport
-  DEFAULT_OPTIONS = {
-      chart_on_pdf: true, paginate: true
-  }
+  autoload :ColumnModule, 'query_report/column'
+  autoload :FilterModule, 'query_report/filter'
+  autoload :PaginateModule, 'query_report/paginate'
+  autoload :Record, 'query_report/record'
+  autoload :ColumnChartModule, 'query_report/chart/column_chart'
+  autoload :PieChartModule, 'query_report/chart/pie_chart'
+
+  DEFAULT_OPTIONS = {enable_chart: true, chart_on_web: true, chart_on_pdf: true, paginate: true}
 
   class Report
     include QueryReport::ColumnModule
     include QueryReport::FilterModule
+    include QueryReport::PaginateModule
+    include QueryReport::Record
+    include QueryReport::ColumnChartModule
+    include QueryReport::PieChartModule
 
-    attr_accessor :params, :template, :chart, :charts, :filters, :scopes, :current_scope, :options
+    attr_reader :params, :template, :options, :charts
 
     def initialize(params, template, options={}, &block)
       @params, @template = params, template
-      @columns, @filters, @scopes, @charts = [], [], [], []
-      @current_scope = @params[:scope] || 'all'
+      @columns, @filters, @charts = [], [], []
       @options = QueryReport::DEFAULT_OPTIONS.merge options
       instance_eval &block if block_given?
     end
 
+    # define options methods
     QueryReport::DEFAULT_OPTIONS.each do |option_name, value|
       if value.class == TrueClass or value.class == FalseClass
         define_method "#{option_name.to_s}?" do
@@ -28,6 +34,10 @@ module QueryReport
       end
     end
 
+    def has_chart?
+      !@charts.empty?
+    end
+
     # to support the helper methods
     def method_missing(meth, *args, &block)
       if @template.respond_to?(meth)
@@ -36,98 +46,5 @@ module QueryReport
         super
       end
     end
-
-    def model_name
-      query.table.name.singularize
-    end
-
-    def query=(query)
-      @query_cache = query
-    end
-
-    def query
-      apply_filters_and_pagination
-      @query_cache
-    end
-
-    def query_without_pagination
-      apply_filters_and_pagination
-      @query_without_pagination_cache
-    end
-
-    def records
-      @cached_records ||= map_record(query)
-    end
-
-    def all_records
-      @cached_all_records ||= map_record(query_without_pagination)
-    end
-
-    def map_record(query)
-      query.clone.map do |record|
-        array = @columns.collect { |column| [column.humanize,
-                                             (column.data.kind_of?(Symbol) ? record.send(column.name) : column.data.call(record))] }
-        Hash[*array.flatten]
-      end
-    end
-
-    def scope(scope)
-      @scopes << scope
-      @scopes = @scopes.uniq
-    end
-
-    def search
-      apply_filters_and_pagination
-      @search
-    end
-
-    def compare_with_column_chart(title, x_axis='', &block)
-      @chart = QueryReport::Chart::CustomChart.new(:column, title, query_without_pagination)
-      @chart.add_column x_axis
-      @chart.instance_eval &block if block_given?
-      @charts << @chart
-    end
-
-    def pie_chart(title, &block)
-      @chart = QueryReport::Chart::PieChart.new(title, query_without_pagination)
-      @chart.instance_eval &block if block_given?
-      @charts << @chart
-    end
-
-    private
-    def apply_filters_and_pagination
-      return if @applied_filters_and_pagination
-      #apply ransack
-      @search = @query_cache.search(@params[:q])
-      @query_cache = @search.result
-
-      #apply scope
-      if @current_scope and !['all', 'delete_all', 'destroy_all'].include?(@current_scope)
-        @query_cache = @query_cache.send(@current_scope)
-      end
-
-      #apply filters
-      @filters.each do |filter|
-        if filter.custom
-          param = @params[:custom_search]
-          first_val = param[filter.keys.first] rescue nil
-          last_val = param[filter.keys.last] rescue nil
-          case filter.keys.size
-            when 1
-              @query_cache = filter.block.call(@query_cache, first_val) if first_val.present?
-              break
-            when 2
-              @query_cache = filter.block.call(@query_cache, first_val, last_val) if first_val.present? and last_val.present?
-              break
-          end
-        end
-      end
-
-      #apply pagination
-      @query_without_pagination_cache = @query_cache
-      page_method_name = Kaminari.config.page_method_name
-      @query_cache = @query_without_pagination_cache.send(page_method_name, @params[:page])
-      @applied_filters_and_pagination = true
-    end
   end
 end

data/lib/query_report/report_pdf.rb

@@ -1,113 +1,97 @@
-require "prawn"
-require "open-uri"
-
-class ReportPdf
-  attr_accessor :pdf, :default_options
+module QueryReport
+  class ReportPdf
+    attr_reader :pdf, :options, :report
+
+    def initialize(report)
+      @report = report
+      @options = QueryReport.config.pdf_options
+      @pdf = Prawn::Document.new
+    end
 
-  def initialize(report)
-    @report = report
-    self.default_options = {alternate_row_bg_color: ["DDDDDD", "FFFFFF"],
-                            header_bg_color: 'AAAAAA',
-                            color: '000000',
-                            light_color: '555555'}
-    self.pdf = Prawn::Document.new
-  end
+    #render the header from the template class
+    def render_header
+      template.try(:render_header)
+    end
 
-  def render_header(options={})
-    #pdf.font("Times-Roman", size: 10) do
-    #  pdf.text_box current_institute.address.to_s,
-    #               :at => [400, pdf.cursor+20],
-    #               :inline_format => true,
-    #               :height => 100,
-    #               :width => 100
-    #end
-  end
+    def render_footer
+      template.try(:render_footer)
+    end
 
-  def pdf_content(&code)
-    render_header
-    code.call(pdf)
-    pdf
-  end
+    def to_pdf
+      render_charts_with report
+      render_table_with report
+      pdf
+    end
 
-  def standard
-    pdf_content do
-      render_charts_with @report
-      render_table_with(@report.all_records, {font_size: 8, header_font_size: 10})
+    private
+    def render_charts_with(report)
+      return if report.charts.empty? #or !report.chart_on_pdf?
+      height = options[:chart][:height] * (report.charts.size.to_f/2).ceil
+      pdf.column_box([0, pdf.cursor], :columns => 2, :width => pdf.bounds.width, :height => height) do
+        report.charts.each do |chart|
+          render_chart(chart)
+        end
+      end
     end
-  end
 
-  private
-  def render_charts_with(report)
-    return if report.charts.nil? or !report.chart_on_pdf?
-    report.charts.each do |chart|
+    def render_chart(chart)
       if chart.respond_to?(:to_blob)
         blob = chart.to_blob
         data = StringIO.new(blob)
         pdf.pad_top(10) do
-          pdf.image(data, :width => 200)
+          pdf.image(data, :width => options[:chart][:width])
         end
       end
     end
-  end
 
-  def table_header_for(table_items, options={})
-    table_items.first.keys
-  end
+    def table_header_for(table_items)
+      table_items.first.keys
+    end
 
-  def humanized_table_header_for(table_items, options={})
-    table_items.first.keys.collect(&:humanize) rescue table_header_for(table_items, options)
-  end
+    def humanized_table_header
+      report_columns.collect(&:humanize)
+    end
 
-  def table_content_for(table_items, options)
-    table_items.map do |item|
-      item_values = []
+    def table_content_for(report)
+      table_items = report.all_records
+      table_items.map do |item|
+        item_values = []
 
-      options[:table_header].each do |header|
-        item_values << cell_for(item, header)
+        report_columns.collect(&:humanize).each do |column|
+          item_values << item[column].to_s
+        end
+        item_values
       end
-      item_values
     end
-  end
 
-  def cell_for(item, prop)
-    val = item.respond_to?(prop) ? item.send(prop) : item[prop]
-    if val.kind_of? Array
-      val.collect { |v| [v] }
-      return pdf.make_table(val)
+    def render_table_with(report)
+      items = [humanized_table_header]
+      items += table_content_for(report)
+      render_table(items)
     end
-    val
-  end
 
-  def render_table_with(table_items, options={})
-    if table_items.present?
-      options[:table_header] ||= table_header_for(table_items, options)
-      items = [humanized_table_header_for(table_items)]
-      items += table_content_for(table_items, options)
-      items += table_footer_for(table_items, options)
-      options[:bold_footer] = options[:titles_of_column_to_sum].present?
-      render_table(items, options)
+    def render_table(items)
+      header_bg_color = options[:table][:header][:bg_color]
+      alternate_row_bg_color = [options[:table][:row][:odd_bg_color], options[:table][:row][:even_bg_color]]
+      font_size = options[:font_size]
+      header_font_size = options[:table][:header][:font_size]
+      pdf.move_down 10
+      pdf.table(items, :row_colors => alternate_row_bg_color, :header => true, :cell_style => {:inline_format => true, :size => font_size}) do
+        row(0).style(:font_style => :bold, :background_color => header_bg_color, :size => header_font_size)
+      end
     end
-    pdf
-  end
 
-  def render_table(items, options={})
-    options = default_options.merge options
-    header_bg_color = options[:header_bg_color]
-    pdf.move_down 10
-    pdf.table(items, :row_colors => options[:alternate_row_bg_color], :header => true, :cell_style => {:inline_format => true, :size => options[:font_size] || 10}) do
-      row(0).style(:font_style => :bold, :background_color => header_bg_color, :size => options[:header_font_size] || 14)
-      row(items.size-1).style(:font_style => :bold) if options[:bold_footer]
+    private
+    def report_columns
+      report.columns.select { |c| !c.only_on_web? }
     end
-  end
 
-  def table_footer_for(table_items, options)
-    return [] if options[:titles_of_column_to_sum].blank?
-    total_hash = {} #for calculating total for a column
-    options[:titles_of_column_to_sum].each do |col|
-      total_hash[col] = table_items.sum { |i| (i.respond_to?(col) ? i.send(col) : i[col]) || 0 }
+    def template
+      if options[:template_class]
+        @template ||= options[:template_class].to_s.constantize.new(report, pdf)
+        return @template
+      end
+      nil
     end
-
-    render_footer_with_col_span(total_hash, options)
   end
-
 end

data/lib/query_report/version.rb

@@ -1,3 +1,3 @@
 module QueryReport
-  VERSION = "0.1.2"
+  VERSION = "1.0.0"
 end

data/lib/tasks/query_report_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :query_report do
+#   # Task goes here
+# end