prawn_report 1.9.18

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 242507f2c7f5d85e05fe01212b988cb15610b95d
+  data.tar.gz: 9476a352688d8adeb402050c9708475184ba751b
+SHA512:
+  metadata.gz: 511e79d5163022e0d3f592402cf6b642941f8583c6f63d3af3d9db77ef9a643e370e10e5000abc6ee3168672fd71322e283a5f07df4d2c72fe918034ee4e5da1
+  data.tar.gz: 9a95c4394ff843c53ae3af12365deccd932e9c3991e69303d6b6f6fc6b62faad605f17581ef8a4882caccbb7c289c81ab39e0f0cbd7b4dfc3fa480e13ebde67b

data/app/controllers/ac_filter_defs_controller.rb

@@ -0,0 +1,17 @@
+class AcFilterDefsController < ApplicationController
+  
+  unloadable
+  
+  def index
+    @ac_filter_defs = AcFilterDef.find(:all)
+    
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @ac_filter_defs }
+      format.fxml { render :fxml => @ac_filter_defs.to_fxml(
+        {:include => {:ac_filters => {:include => { :ac_filter_options => {}}}}} )}
+    end
+    
+  end
+  
+end

data/app/controllers/custom_generate_report_controller.rb

@@ -0,0 +1,18 @@
+require "custom_report_controller"
+
+class CustomGenerateReportController < ApplicationController
+
+  unloadable
+  
+  include PrawnReportController
+  
+  def get_system_criteria
+    {}
+  end
+  
+  def get_pr_suggested_filename
+    @report_template = ReportTemplate.find(params["report_template_id"])    
+    @report_template.report_class.underscore + '_' + Date.today.to_s + '.pdf'
+  end  
+  
+end

data/app/controllers/generate_report_controller.rb

@@ -0,0 +1,24 @@
+class GenerateReportController < PrawnReport.parent_controller.constantize
+  
+  unloadable
+
+  def get_pr_report_class
+    @report_template = ReportTemplate.find(params["report_template_id"])    
+    Kernel.const_get(@report_template.report_class)
+  end  
+
+  def get_pr_report_params; end
+
+  def get_pr_report_data
+    @report_template = ReportTemplate.find(params["report_template_id"])
+    mc=Kernel
+    @report_template.ac_filter_def.model_class.split('::').each {|c| mc=mc.const_get(c)}
+    mc.apply_ac_filter(parse_ac_filters(params), get_system_criteria)
+  end
+  
+  def get_pr_filters
+    @report_template = ReportTemplate.find(params["report_template_id"])
+    get_ac_filters_applied(params, @report_template.ac_filter_def)
+  end
+
+end

data/app/controllers/report_templates_controller.rb

@@ -0,0 +1,40 @@
+class ReportTemplatesController < ApplicationController
+ 
+  unloadable
+  
+  def index
+    conditions = []
+    conditions = ['report_type in (?)', parse_array(params['report_type'])] unless params['report_type'].blank?
+    
+    @templates = ReportTemplate.find(:all, 
+      :conditions => conditions)
+    
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @templates }
+      format.fxml do
+        render :fxml => @templates.to_fxml(
+        { :include => {
+          :ac_filter_def => { :include => {
+            :ac_filters => { :include => :ac_filter_options}
+            }}
+         }
+        }
+      )
+      end
+    end
+    
+  end
+  
+  
+  private
+
+  def parse_array(s_array)
+    retorno = []
+    s_array.split(',').each{|s|
+      retorno << s
+    }
+    retorno
+  end
+      
+end

data/app/models/ac_filter.rb

@@ -0,0 +1,15 @@
+class AcFilter < ActiveRecord::Base
+  belongs_to :ac_filter_def
+  
+  has_many :ac_filter_options, :dependent => :destroy
+  accepts_nested_attributes_for :ac_filter_options
+  
+  def has_filled_criteria?
+    !self.filled_criteria.nil?
+  end
+  
+  def has_unfilled_criteria?
+    !self.unfilled_criteria.nil?
+  end
+  
+end

data/app/models/ac_filter_def.rb

@@ -0,0 +1,38 @@
+class AcFilterDef < ActiveRecord::Base
+  
+  has_many :ac_filters, :dependent => :destroy
+  accepts_nested_attributes_for :ac_filters
+
+  def joins_param=(value)
+    write_marshal_attribute(:joins_param, value)
+  end
+  
+  def joins_param
+    read_marshal_attribute(:joins_param)
+  end
+
+  def include_param=(value)
+    write_marshal_attribute(:include_param, value)
+  end
+  
+  def include_param
+    read_marshal_attribute(:include_param)
+  end
+
+  def has_sql_query?
+    sql_query.to_s != ''
+  end
+
+  protected
+  
+  def write_marshal_attribute(name, value)
+    write_attribute name, Marshal.dump(value)
+  end
+  
+  def read_marshal_attribute(name)
+    value = read_attribute name
+    value.nil? ? nil : Marshal.load(value)
+  end
+
+
+end

data/app/models/ac_filter_option.rb

@@ -0,0 +1,5 @@
+class AcFilterOption < ActiveRecord::Base
+  
+  belongs_to :ac_filter_def
+  
+end

data/app/models/report_template.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+
+class ReportTemplate < ActiveRecord::Base
+  belongs_to :ac_filter_def
+  
+  def serialization_params=(value)
+    if value.is_a? Hash
+      value = Marshal.dump(value)
+    end
+    write_attribute :serialization_params, value
+  end
+  
+  def serialization_params
+    value = read_attribute :serialization_params
+    begin
+      value.nil? ? {} : Marshal.load(value)
+    rescue TypeError
+      
+    end
+  end
+  
+end

data/lib/ac_filters_utils.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+def parse_ac_filters(params)
+  parsed_filters = {}
+  parsed_filters['filter_def_id'] = params['filter_def_id'].to_i
+  params.each_pair do |k,v|  
+    md = /^ac_filter_(\d+)_(.+)/.match(k)
+    if md
+      filter_id = md[1]
+      filter_result_name = md[2].underscore
+      filter_value = v
+      parsed_filters[filter_id.to_i] = {} unless parsed_filters[filter_id.to_i]
+      parsed_filters[filter_id.to_i][filter_result_name] = filter_value
+    end
+  end
+  parsed_filters
+end
+
+def get_ac_filters_applied(params, ac_filter_def)
+  parsed_filter = parse_ac_filters(params)
+  r = []
+  ac_filter_def.ac_filters.each do |f|
+    if f.query_user? && (parsed_filter[f.id]['is_filled'] == 'true')
+      pf = parsed_filter[f.id]
+      val = ''
+      if ['text', 'options'].include? f.data_type
+        val = pf['filter_value']
+      elsif ['period', 'timezone_period'].include?(f.data_type)
+        if (!pf['from_date'].empty?) && (!pf['to_date'].empty?) 
+          val = "#{Date.parse(pf['from_date']).strftime('%d/%m/%Y')} até #{Date.parse(pf['to_date']).strftime('%d/%m/%Y')}"
+        elsif !pf['from_date'].empty?
+          val = "Desde #{Date.parse(pf['from_date']).strftime('%d/%m/%Y')}"
+        elsif
+          val = "Até #{Date.parse(pf['to_date']).strftime('%d/%m/%Y')}"
+        end
+      elsif f.data_type == 'autocomplete'
+        val = Kernel.const_get(f.target_model).find(pf['filter_value']).send(f.target_field)
+      end
+      r << [f.label, val]
+    end
+  end
+  r
+end
+
+def is_filled?(parsed_params, filter)
+  !parsed_params[filter.id].nil?
+end
+
+def fill_params(f, fillings)
+  if ['period', 'timezone_period'].include?(f.data_type)
+    [fillings['from_date'], fillings['to_date']]
+  elsif f.data_type == 'text'
+    '%' + fillings['filter_value'] + '%'
+  elsif f.data_type == 'options'
+    fillings['filter_value']
+  else
+    fillings['filter_value']
+  end
+end
+
+def parse_conditions(parsed_filter, system_params)
+  system_params.symbolize_keys!
+  filter_def = AcFilterDef.find(parsed_filter['filter_def_id'])
+  conditions = []
+  conditions[0] = ['1=1']
+  
+  filter_def.ac_filters.each do |f|
+    if f.query_user?
+      parse_condition(conditions, parsed_filter, f)
+    elsif f.system_criteria.to_s != ''
+      conditions[0] << f.filled_criteria
+      conditions << system_params[f.system_criteria.to_sym]
+    else
+      conditions[0] << f.filled_criteria
+    end
+  end
+  
+  conditions[0] = conditions[0].join(' and ')
+  conditions
+end 
+
+def parse_condition(conditions, parsed_filter, filter)
+  filled = parsed_filter[filter.id]['is_filled'] == 'true'
+  
+  if filter.data_type == 'checkbox'
+    fill_with_checkbox(conditions, filled, parsed_filter, filter)
+  elsif filter.data_type == 'options'
+    fill_with_options(conditions, filled, parsed_filter, filter)
+  elsif filter.data_type == 'period'
+    fill_with_period(conditions, filled, parsed_filter, filter)
+  elsif filter.data_type == 'timezone_period'
+    fill_with_timezone_period(conditions, filled, parsed_filter, filter)
+  else
+    fill_with_others(conditions, filled, parsed_filter, filter)
+  end
+end
+
+def fill_with_checkbox(conditions, filled, parsed_filter, filter)
+  if filled && filter.has_filled_criteria?
+    conditions[0] << filter.filled_criteria
+  elsif filter.has_unfilled_criteria?
+    conditions[0] << filter.unfilled_criteria
+  end
+end
+
+def fill_with_options(conditions, filled, parsed_filter, filter)
+  if !filled && filter.has_unfilled_criteria?
+    conditions[0] << c.unfilled_criteria
+  elsif filled
+    fo = AcFilterOption.find_by_ac_filter_id_and_value(filter.id, parsed_filter[filter.id]['filter_value'])
+    if fo && fo.filled_criteria.to_s != ''
+      conditions[0] << fo.filled_criteria
+      conditions << fill_params(filter, parsed_filter[filter.id])
+    elsif filter.has_filled_criteria?
+      conditions[0] << filter.filled_criteria
+      conditions << fill_params(filter, parsed_filter[filter.id])
+    end
+  end
+end
+
+def fill_with_period(conditions, filled, parsed_filter, filter)
+  if !filled && filter.has_unfilled_criteria?
+    conditions[0] << c.unfilled_criteria
+  elsif filled
+    fp = fill_params(filter, parsed_filter[filter.id])
+    if fp[0].to_s != ''
+      conditions[0] << filter.filled_criteria_from
+      conditions << fp[0]
+    end
+    if fp[1].to_s != ''
+      conditions[0] << filter.filled_criteria_to
+      conditions << fp[1]
+    end
+  end
+end
+
+def fill_with_timezone_period(conditions, filled, parsed_filter, filter)
+  if !filled && filter.has_unfilled_criteria?
+    conditions[0] << c.unfilled_criteria
+  elsif filled
+    fp = fill_params(filter, parsed_filter[filter.id])
+    if fp[0].to_s != ''
+      conditions[0] << filter.filled_criteria_from
+      conditions << Time.zone.parse(fp[0])
+    end
+    if fp[1].to_s != ''
+      conditions[0] << filter.filled_criteria_to
+      conditions << Time.zone.parse(fp[1])+1.day
+    end
+  end
+end
+
+def fill_with_others(conditions, filled, parsed_filter, filter)
+  if filled && filter.has_filled_criteria?
+    fp = fill_params(filter, parsed_filter[filter.id])
+    conditions[0] << filter.filled_criteria
+    conditions << fp
+  elsif filter.has_unfilled_criteria?
+    conditions[0] << filter.unfilled_criteria
+  end
+end
+
+def get_param_by_label(params, label)
+  filter = AcFilter.find(:first, :conditions => ['ac_filter_def_id = ? and label = ?',params['filter_def_id'], label])   
+  'ac_filter_'+filter.id.to_s
+end
+
+module AcFilters  
+  def apply_ac_filter(parsed_filter, system_params)
+    conditions = parse_conditions(parsed_filter, system_params)
+    find_params = {:conditions => conditions}
+    filter_def = AcFilterDef.find(parsed_filter['filter_def_id'])
+    if filter_def.has_sql_query?
+      sql_to_execute = ActiveRecord::Base.send(:sanitize_sql_array, conditions)
+      r = []
+      ActiveRecord::Base.connection.instance_exec(sql_to_execute).each(as :hash) {|i| r << i}
+    else
+      find_params[:select] = filter_def.select_sql.to_s unless filter_def.select_sql.nil?
+      find_params[:order] = filter_def.order_sql.to_s unless filter_def.order_sql.nil?
+      find_params[:joins] = filter_def.joins_param unless filter_def.joins_param.nil?
+      find_params[:include] = filter_def.include_param unless filter_def.include_param.nil?
+      find_params[:group] = filter_def.group_param unless filter_def.group_param.nil?
+      r = find(:all, find_params)
+    end
+    r
+  end  
+end

data/lib/active_record_helpers.rb

@@ -0,0 +1,218 @@
+#coding: utf-8
+
+require 'yaml'
+
+class ActiveRecordYAMLSerializer
+
+  def initialize(obj, params)
+    @obj = obj
+    @params = params.symbolize_keys!
+    @contents = ''
+    @indent_level = 0
+  end
+  
+  def serialize
+    @contents = ''
+    @contents += serialize_root_values(@params)
+    
+    if @obj.is_a? ActiveRecord::Base
+      @contents += serialize_record(@obj, false, @params) #asnotarray
+    elsif @obj.is_a? Array
+      @contents += "items:\n"
+      @obj.each do |item|
+        reset_indent
+        indent
+        @contents += serialize_record(item, true, @params)  #asarray
+      end
+    end
+    
+    
+  end
+  
+  def get_yaml
+    YAML::load( @contents )
+  end
+  
+  def save_as(file_name)
+    File.open(file_name, 'w') do |f|
+      f.write @contents
+    end
+  end
+
+  private
+  
+  def indent
+    @indent_level += 1
+  end
+  
+  def unindent
+    @indent_level -= 1
+  end
+
+  def reset_indent(level = 0)
+    @indent_level = level
+  end
+  
+  def serialize_root_values(params)
+    r = ''
+    params[:root_values] ||= {}
+    params[:root_values].each_pair { |k,v| r += serialize_key_value(k,v) }
+    r
+  end
+  
+  def serialize_record(rec, as_array, params = {})
+    r = ''
+    first_line = true
+    to_serialize = (rec.is_a? ActiveRecord::Base) ? rec.attributes : rec
+
+    to_serialize.each_pair do |k, v|
+      r += render_indent_first_line(as_array) if first_line
+      r += '  ' * @indent_level unless first_line
+      r += serialize_key_value(k,v)
+      first_line = false
+    end
+      
+    if rec.is_a? ActiveRecord::Base
+      r += serialize_belongs_tos(rec, first_line, params)
+      r += serialize_has_manys(rec, first_line, params)
+      r += serialize_methods(rec, first_line, params)
+    end
+    
+    r
+  end
+  
+  def serialize_key_value(k, v)
+    k.to_s + ': ' + serialize_value(v)
+  end
+  
+  def serialize_value(v)
+    if v.is_a? String
+      serialize_string(v)
+    else
+      v.to_s + "\n"
+    end
+  end
+  
+  def serialize_string(s)
+    s.strip!
+    r = ''
+    if s.lines.count > 1
+      r += "|-\n"
+      s.lines.each do |l|
+        r += '  ' * (@indent_level + 1)
+        r += l
+      end
+    else
+      r += '"' + s.to_s.gsub('"', '\"') + '"'
+    end
+    r + "\n"
+  end
+  
+  def render_indent_first_line(as_array)
+    r = ''
+    if @indent_level != 0
+      r = '  ' * (@indent_level - 1)
+      if (as_array)
+        r += '- '
+      else
+        r += '  '
+      end
+    end
+    r
+  end
+  
+  def render_indent(first_line)
+    r = ''
+    #r += render_indent_first_line(@indent_level) if first_line
+    r += '  ' * @indent_level unless first_line
+  end
+  
+  def serialize_belongs_tos(rec, first_line, params)
+    r = ''
+    if params[:include_all_belongs_to] == true
+      rec.class.reflect_on_all_associations(:belongs_to).collect do |a|
+        r += render_indent(first_line)
+        r += a.name.to_s + ":\n"
+        indent
+        r += serialize_record(rec.send(a.name), false, 
+          {:include_all_belongs_to => params[:include_all_belongs_to]}) if rec.send(a.name)
+        unindent
+      end
+    else
+      params[:included_belongs_to] ||= {}
+      params[:included_belongs_to].each_pair do |k,v| 
+        v.symbolize_keys!
+        serialization_params = v
+        type = v[:type].to_sym || :fields
+        master_rec = rec.send(k)
+        if type == :fields
+          v[:fields].each do |f|
+            r += render_indent(first_line)
+            val = master_rec ? master_rec.send(f) : nil
+            r += serialize_key_value(k.to_s + '_' + f.to_s, val)
+            first_line = false
+          end
+        elsif type == :record
+          r += render_indent(first_line)
+          r += k.to_s + ":\n"
+          indent
+          r += serialize_record(master_rec, false, v[:params]) if master_rec #as_not_array
+          unindent
+        end
+      end
+    end
+    r
+  end
+
+  def serialize_has_manys(rec, first_line, params)
+    r = ''
+    params[:included_has_many] ||= {}
+    params[:included_has_many].each_pair do |k,v|
+      r += render_indent(first_line)
+      r += k.to_s + ":"
+      r += serialize_has_many(rec.send(k), v)
+      first_line = false
+    end
+    r
+  end
+  
+  def serialize_methods(rec, first_line, params)
+    r = ''
+    params[:included_methods] ||= {}
+    params[:included_methods].each do |v|       
+      r += render_indent(first_line)
+      val = rec.send(v)
+      r += serialize_key_value(v, val)
+      first_line = false
+    end
+    r
+  end  
+  
+  def serialize_has_many(hm, params)
+    original_indent = @indent_level
+    r = ''
+    if hm.count == 0
+      r += " []\n"
+    else
+      r += "\n"
+      hm.each do |det|
+        reset_indent(original_indent)
+        indent
+        r += serialize_record(det, true, params || {}) #asarray
+      end
+    end
+    r
+  end
+  
+end
+
+module PrawnReportActiveRecord
+
+  def pr_serialize(params = {})
+    a = ActiveRecordYAMLSerializer.new(self, params)
+    a.serialize
+    a
+  end
+  
+end
+