google_data_source 0.7.6

data/lib/reporting/helper.rb

@@ -0,0 +1,110 @@
+module GoogleDataSource
+  module Reporting
+    module Helper
+      # Shows a reporting consisting of a visualization and a form for configuration
+      # +type+ can be either
+      # * 'Table'
+      # * 'TimeLine'
+      # +reporting+ is the +Reporting+ object to be displayed
+      # Have a look at +google_visualization+ helper for +url+ and +options+ parameter
+      def google_reporting(type, reporting, url = nil, options = {})
+        # no form
+        return google_visualization(type, url, options) unless options.delete(:form)
+
+        # form
+        # default options
+        options = {
+          :form          => reporting_form_id(reporting),
+          :autosubmit    => true,
+          :form_position => :bottom
+        }.update(options)
+        
+        visualization_html = google_visualization(type, url, options)
+
+        form_html = content_tag("form", :id => reporting_form_id(reporting), :class => 'formtastic') do
+          render options[:form_partial] || reporting_form_partial(reporting)
+        end
+        
+        options[:form_position] == :bottom ? visualization_html << form_html : form_html << visualization_html
+      end
+
+      # Shows a timeline reporting
+      def google_reporting_timeline(reporting, url = nil, options = {})
+        google_reporting('TimeLine', reporting, url, options)
+      end
+
+      # Shows a table reporting
+      def google_reporting_table(reporting, url = nil, options = {})
+        google_reporting('Table', reporting, url, options)
+      end
+      
+      # Shows a combo table reporting
+      def google_reporting_combo_table(reporting, url = nil, options = {})
+        google_reporting('ComboTable', reporting, url, options)
+      end
+
+      # Returns callback JS code that sends the rendered form partial
+      # So validation errors can be displayed
+      def form_render_callback(reporting, options = {})
+        out = "$('##{reporting_form_id(reporting)}').html(#{render(options[:form_partial] || reporting_form_partial(reporting), :reporting => reporting).to_json});"
+        out << '$(document).trigger("formRendered");'
+        out
+      end
+
+      # Shows a select tag for grouping selection on a given reporting
+      # TODO more docu
+      # TODO really take namespace from classname?
+      def reporting_group_by_select(reporting, select_options, i = 1, options = {})
+       select_options = reporting_options_for_select(reporting, select_options, options)
+
+       tag_name = "#{reporting.class.name.underscore}[groupby(#{i}i)]"
+       current_option = (reporting.group_by.size < i) ? nil : reporting.group_by[i-1]
+       option_tags = options_for_select(select_options, current_option)
+       select_tag(tag_name, option_tags, options)
+      end
+
+      # Shows a Multiselect box for the columns to 'select'
+      def reporting_select_select(reporting, select_options, options = {})
+        select_options = reporting_options_for_select(reporting, select_options, options)
+
+        tag_name = "#{reporting.class.name.underscore}[select]"
+        option_tags = options_for_select(select_options, reporting.select)
+        select_tag(tag_name, option_tags, :multiple => true)
+      end
+
+      # Adds labels to the select options when columns are passed in
+      def reporting_options_for_select(reporting, select_options, options = {})
+       if (select_options.is_a?(Array))
+         select_options = select_options.collect { |column| [reporting.column_label(column), column] }
+         select_options.unshift('') if options.delete(:include_blank)
+       end
+       select_options
+      end
+
+      # Registers form subit hooks
+      # This way the standard form serialization can be overwritten
+      def reporting_form_hooks(reporting)
+        hooks = OpenStruct.new
+        yield(hooks)
+
+        json = []
+        %w(select).each do |hook|
+          next if hooks.send(hook).nil?
+          json << "#{hook}: function(){#{hooks.send hook}}"
+        end
+        js = "DataSource.FilterForm.setHooks(#{reporting_form_id(reporting).to_json}, {#{json.join(', ')}});"
+        javascript_tag(js)
+      end
+
+      # Returns the standard DOM id for reporting forms
+      def reporting_form_id(reporting)
+        "#{reporting.id}_form"
+      end
+
+      # Returns the standard partial for reporting forms
+      def reporting_form_partial(reporting)
+        "#{reporting.id}_form.html"
+      end
+    end
+  end
+end

data/lib/reporting/reporting.rb

@@ -0,0 +1,352 @@
+class CircularDependencyException < Exception; end
+
+# Super class for reportings to be rendered with Google visualizations
+# Encapsulates the aggregation of the reporting data based on a configuration.
+#
+# The configuration is implemented by inherting from +ActiveRecord+ and switching off
+# the database stuff. Thus the regular +ActiveRecord+ validators and parameter assignments
+# including type casting cab be used
+#
+# The ActiveRecord extension is copied from the ActiveForm plugin (http://github.com/remvee/active_form)
+class Reporting  < ActiveRecord::Base
+  attr_accessor :query, :group_by, :select, :order_by, :limit, :offset
+  attr_reader :virtual_columns #, :required_columns
+  attr_writer :id
+  
+  class_attribute :datasource_filters, 
+                  :datasource_columns, 
+                  :datasource_defaults, 
+                  {:instance_reader => false, :instance_writer => false} 
+  
+  def initialize(*args)
+    @required_columns = []
+    @virtual_columns = {}
+    super(*args)
+  end
+  
+  # Returns an instance of our own connection adapter
+  # 
+  def self.connection
+    @adapter ||= ActiveRecord::ConnectionAdapters::ReportingAdapter.new
+  end
+
+  # Returns an ID which is used by frontend components to generate unique dom ids 
+  # Defaults to the underscoreized classname
+  def id
+    @id || self.class.name.underscore.split('/').last #gsub('/', '_')
+  end
+
+  # helper method used by required_columns
+  # Returns all columns required by a certain column resolving the dependencies recursively
+  def required_columns_for(column, start = nil)
+    return [] unless self.datasource_columns.has_key?(column)
+    raise CircularDependencyException.new("Column #{start} has a circular dependency") if column.to_sym == start
+    columns = [ self.datasource_columns[column][:requires] ].flatten.compact.collect(&:to_s)
+    columns.collect { |c| [c, required_columns_for(c, start || column.to_sym)] }.flatten
+  end
+
+  # Returns the columns that have to be selected
+  def required_columns
+    (select + group_by + @required_columns).inject([]) do |columns, column|
+      columns << required_columns_for(column)
+      columns << column
+    end.flatten.map(&:to_s).uniq
+  end
+
+  # Adds required columns
+  def add_required_columns(*columns)
+    @required_columns = (@required_columns + columns.flatten.collect(&:to_s)).uniq
+  end
+
+  # 'Abstract' method that has to be overridden by subclasses
+  # Returns an array of rows written to #rows and accessible in DataSource compatible format in #rows_as_datasource
+  # 
+  def aggregate
+    []
+  end
+
+  # Returns the data rows
+  # Calls the aggregate method first if rows do not exist
+  #
+  def data(options = {})
+    add_required_columns(options[:required_columns])
+    @rows ||= aggregate
+  end
+
+  # Lazy getter for the columns object
+  def columns
+    select.inject([]) do |columns, column|
+      columns << {
+        :type => all_columns[column][:type]
+      }.merge({
+        :id    => column.to_s,
+        :label => column_label(column)
+      }) if all_columns.key?(column)
+      
+      columns
+    end
+  end
+
+  # Retrieves the I18n translation of the column label
+  def column_label(column, default = nil)
+    return '' if column.blank?
+    defaults = ['reportings.{{model}}.{{column}}', 'models.attributes.{{model}}.{{column}}'].collect do |scope|
+      scope.gsub!('{{model}}', self.class.name.underscore.gsub('/', '.'))
+      scope.gsub('{{column}}', column.to_s)
+    end.collect(&:to_sym)
+    defaults << column.to_s.humanize
+    I18n.t(defaults.shift, :default => defaults)
+  end
+
+  # Returns the select columns as array
+  def select
+    (@select ||= (defaults[:select] || [])).collect { |c| c == '*' ? all_columns.keys : c }.flatten
+  end
+
+  # Returns the grouping columns as array
+  def group_by
+    @group_by ||= (defaults[:group_by] || [])
+  end
+
+  # add a virtual column
+  def add_virtual_column(name, type = :string)
+    virtual_columns[name.to_s] = {
+      :type => type
+    }
+  end
+
+  # Returns a list of all columns (real and virtual)
+  def all_columns
+    datasource_columns.merge(virtual_columns)
+  end
+  
+  # Returns an array of columns which are allowed for grouping
+  #
+  def groupable_columns
+    datasource_columns.collect do |key, options|
+      key.to_sym if options[:grouping]
+    end.compact
+  end
+
+  # Returns the +defaults+ Hash
+  # Convenience wrapper for instance access
+  def defaults
+    self.class.defaults #.merge(@defaults || {})
+  end
+
+  # Attribute reader for datasource_columns
+  def datasource_columns
+    self.class.datasource_columns || { }.freeze
+  end
+
+  # Returns a serialized representation of the reporting
+  def serialize
+    to_param.to_json
+  end
+
+  def to_param # :nodoc:
+    attributes.merge({
+      :select   => select,
+      :group_by => group_by,
+      :order_by => order_by,
+      :limit => limit,
+      :offset => offset
+    })
+  end
+
+  def limit
+    (@limit || 1000).to_i
+  end
+
+  # Returns the serialized Reporting in a Hash that can be used for links
+  # and which is deserialized by from_params
+  def to_params(key = self.class.name.underscore.gsub('/', '_'))
+    HashWithIndifferentAccess.new( key => to_param )
+  end
+
+  # Returns true if the given column is available for filtering
+  #
+  def filterable_by?(column_name)
+    self.class.datasource_filters.key?(column_name.to_s)
+  end
+  
+  class << self
+    # Defines a displayable column of the datasource
+    # Type defaults to string
+    def column(name, options = {})
+      self.datasource_columns ||= Hash.new.freeze
+      self.datasource_columns = column_or_filter(name, options, self.datasource_columns)
+    end
+        
+    # Marks a column as filterable / adds it in the background    
+    #
+    #
+    def filter(name, options = {})
+      self.datasource_filters ||= Hash.new.freeze
+      
+      # update the column options
+      self.datasource_filters = column_or_filter(name, options, self.datasource_filters)
+    end
+    
+    # Returns the defaults class variable
+    def defaults
+      self.datasource_defaults ||= Hash.new.freeze
+    end
+
+    # Sets the default value for select
+    def select_default(select)
+      self.datasource_defaults = defaults.merge({:select => select})
+    end
+
+    # Sets the default value for group_by
+    def group_by_default(group_by)
+      self.datasource_defaults = defaults.merge({:group_by => group_by})
+    end
+
+    # Returns a reporting from a serialized representation
+    def deserialize(value)
+      self.new(JSON.parse(value))
+    end
+
+    # Uses the +simple_parse+ method of the SqlParser to setup a reporting
+    # from a query. The where clause is intepreted as reporting configuration (activerecord attributes)
+    def from_params(params, key = self.name.underscore.gsub('/', '_'))
+      return self.deserialize(params[key]) if params.has_key?(key) && params[key].is_a?(String)
+
+      reporting = self.new(params[key])
+      reporting = from_query_params(params["query"]) if params.has_key?("query")
+      return reporting unless params.has_key?(:tq)
+
+      query = GoogleDataSource::DataSource::SqlParser.simple_parse(params[:tq])
+      attributes = Hash.new
+      query.conditions.each do |k, v|
+        if v.is_a?(Array)
+          v.each do |condition|
+            case condition.op
+            when '<='
+              attributes["to_#{k}"] = condition.value
+            when '>='
+              attributes["from_#{k}"] = condition.value
+            when 'in'
+              attributes["in_#{k}"] = condition.value
+            else
+              # raise exception for unsupported operator?
+            end
+          end
+        else
+          attributes[k] = v
+        end
+      end
+      attributes[:group_by] = query.groupby 
+      attributes[:select]   = query.select
+      attributes[:order_by] = query.orderby
+      attributes[:limit]    = query.limit
+      attributes[:offset]   = query.offset
+      attributes.merge!(params[key]) if params.has_key?(key)
+      #reporting.update_attributes(attributes)
+      reporting.attributes = attributes
+      reporting.query = params[:tq]
+      reporting
+    end
+
+    ############################
+    # ActiveRecord overrides
+    ############################
+    # Needed to build column accessors
+    #
+    def columns_hash
+      @columns_hash ||= begin
+        ret = { }
+        data = { }
+        data.update(self.datasource_columns) if self.datasource_columns
+        data.update(self.datasource_filters) if self.datasource_filters
+        
+        data.each do |k, v|
+          ret[k.to_s] = ActiveRecord::ConnectionAdapters::Column.new(k.to_s, 
+            v[:default], 
+            v[:type].to_s,
+            v.key?(:null) ? v[:null] : true)
+          
+          # define a humanize method which returns the human name
+          if v.key?(:human_name)
+            ret[k.to_s].define_singleton_method(:humanize) do
+              v[:human_name]
+            end
+          end
+        end
+        
+        ret
+      end
+    end
+    
+    # Returns a hash with column name as key and default value as value
+    #
+    def column_defaults(*args)
+      columns_hash.keys.inject({}) do |mem, var|
+        mem[var] = columns_hash[var].default
+        mem
+      end
+    end
+    
+    # TODO: merge with columns hash
+    def columns
+      columns_hash.values
+    end
+    
+    def primary_key
+      'id'
+    end
+
+    def abstract_class # :nodoc:
+      true
+    end
+
+    protected
+      # Used to decorate a filter or column
+      # used by #column and #filter internally
+      #
+      def column_or_filter(name, options, registry)
+        name = name.to_s
+
+        # whatever this is.
+        # options.each { |k,v| options[k] = v.to_s if Symbol === v }
+
+        default_options = { :type  => :string }
+
+        new_entry = { name => (registry[name] || {}) }
+        new_entry[name].reverse_merge!(default_options.merge(options))
+        new_entry.freeze
+
+        # frozen, to prevent modifications on class_attribute
+        registry.merge(new_entry).freeze
+      end
+      
+      def from_query_params(query)
+        page = query.delete('page')
+        reporting = self.new(query)
+        reporting.limit = query['limit']
+        if page
+          reporting.offset =  reporting.limit * (page.to_i - 1)
+        else
+          reporting.offset = query['offset'].to_i
+        end
+        
+        reporting
+      end
+  end
+
+  ############################
+  # ActiveRecord overrides
+  ############################
+
+  def save # :nodoc:
+    if result = valid?
+    end
+    
+    result
+  end
+  
+  def save! # :nodoc:
+    save or raise ActiveRecord::RecordInvalid.new(self)
+  end
+end