google_data_source 0.7.6

data/lib/assets/javascripts/google_data_source/google_visualization/table.js

@@ -0,0 +1,116 @@
+
+/**
+ * Google DataTable
+ */
+DataSource.Table = function(query, container, options) {
+  DataSource.Visualization.call(this, query, container, options);
+};
+
+
+DataSource.Table.prototype = new DataSource.Visualization();
+
+DataSource.Table.prototype.initialize = function(){
+  this.initialized = true;
+  this.visualization = new google.visualization.Table(this.container);
+
+  this.options['allowHtml'] = true;
+
+  var self = this;
+  
+  this.csvSize = (this.options['csvSize'] > 0) ? this.options['csvSize'] : 1000;
+  if (this.options['serverPaging']) {
+    this.options['pageSize'] = (this.options['pageSize'] > 0) ? this.options['pageSize'] : 10;
+    this.pageSize = this.options['pageSize'];
+
+    var addListener = google.visualization.events.addListener;
+    addListener(this.visualization, 'page', function(e) {self.handlePage(e)});
+    addListener(this.visualization, 'sort', function(e) {self.handleSort(e)});
+
+    this.options['sort'] = 'event';
+    this.options['page'] = 'event';
+
+    var buttonConfig = 'pagingButtonsConfiguration';
+    this.options[buttonConfig] = this.options[buttonConfig] || 'both';
+
+    this.currentPageIndex = 0;
+    this.setPageQueryClause(0);
+    // TODO default sorting???
+  }
+  else {
+    this.options['sortColumn'] = 0;
+  }
+}
+
+DataSource.Table.prototype.beforeSendAndDraw = function() {
+  if (typeof this.initialized == 'undefined') {
+    this.initialize();
+  }
+  
+  this.visualization.setSelection([]);
+};
+
+DataSource.Table.prototype.beforeSubmit = function() {
+  if (typeof this.initialized == 'undefined') {
+    this.initialize();
+  }
+  
+  if (this.options['serverPaging']) this.setPageQueryClause(0);
+};
+
+/** Handles a sort event with the given properties. Will page to page=0. */
+DataSource.Table.prototype.handleSort = function(properties) {
+  var columnIndex = properties['column'];
+  var isAscending = properties['ascending'];
+  this.options['sortColumn'] = columnIndex;
+  this.options['sortAscending'] = isAscending;
+
+  // dataTable exists since the user clicked the table.
+  var colID = this.currentDataTable.getColumnId(columnIndex);
+  this.queryClauses.orderby = 'order by `' + colID + (!isAscending ? '` desc' : '`');
+
+  // Calls sendAndDraw internally.
+  this.handlePage({'page': 0});
+};
+
+
+/** Handles a page event with the given properties. */
+DataSource.Table.prototype.handlePage = function(properties) {
+  var localTableNewPage = properties['page']; // 1, -1 or 0
+  var newPage = 0;
+  if (localTableNewPage != 0) {
+    newPage = this.currentPageIndex + localTableNewPage;
+  }
+  if (this.setPageQueryClause(newPage)) {
+    this.sendAndDraw();
+  }
+};
+
+/**
+ * Sets the pageQueryClause and table options for a new page request.
+ * In case the next page is requested - checks that another page exists
+ * based on the previous request.
+ * Returns true if a new page query clause was set, false otherwise.
+ */
+DataSource.Table.prototype.setPageQueryClause = function(pageIndex) {
+  var pageSize = this.pageSize;
+
+  if (pageIndex < 0) {
+    return false;
+  }
+  var dataTable = this.currentDataTable;
+  if ((pageIndex == this.currentPageIndex + 1) && dataTable) {
+    if (dataTable.getNumberOfRows() <= pageSize) {
+      return false;
+    }
+  }
+  this.currentPageIndex = pageIndex;
+  var newStartRow = this.currentPageIndex * pageSize;
+
+  // Get the pageSize + 1 so that we can know when the last page is reached.
+  this.queryClauses.limit  = 'limit ' + (pageSize + 1);
+  this.queryClauses.offset = 'offset ' + newStartRow;
+
+  // Note: row numbers are 1-based yet dataTable rows are 0-based.
+  this.options['firstRowNumber'] = newStartRow + 1;
+  return true;
+};

data/lib/assets/javascripts/google_data_source/google_visualization/timeline.js

@@ -0,0 +1,13 @@
+/**
+ * TimeLine Chart
+ */
+//google.load("visualization", "1", {packages:["corechart"]});
+
+
+DataSource.TimeLine = function(query, container, options) {
+  DataSource.Visualization.call(this, query, container, options);
+  //this.visualization = new google.visualization.LineChart(this.container);
+  this.visualization = new google.visualization.AnnotatedTimeLine(this.container);
+}
+
+DataSource.TimeLine.prototype = new DataSource.Visualization();

data/lib/assets/javascripts/google_data_source/google_visualization/visualization.js.erb

@@ -0,0 +1,141 @@
+
+/**
+ * Google DataSource Visualization
+ * SuperClass for all Google Visualizations
+ * */
+DataSource.Visualization = function(query, container, options) {
+  // TODO throw exception rename query to url and restrict to strings
+  this.query = (typeof query == 'string') ? new google.visualization.Query(query) : query;
+  this.baseurl = query;
+  this.container = (typeof container == 'string') ? document.getElementById(container) : container;
+  this.currentDataTable = null;
+  this.options = options;
+  this.queryClauses = {};
+}
+DataSource.Visualization.prototype = {
+  draw: function() {
+    this.visualization.draw(this.currentDataTable, this.options);
+  },
+   
+  // TODO make configurable
+  showBusyStatus: function() {
+     $(this.container).prepend('<img src="<%= asset_path('google_data_source/loader.gif') %>" class="loader" />');
+  },
+
+  hideBusyStatus: function() {
+    $(this.container).children('.loader').remove();
+  },
+
+  addParamsToUrl: function(url, params) {
+    var separator = '?';
+    if (url.match(/\?/)) separator = '&';
+    return url + separator + params;
+  },
+
+  download: function(format) {
+    format = format || 'csv';
+    var self = this;
+    this.queryClauses.limit = 'limit ' + this.csvSize;
+    // prepare query
+    var queryClause = '';
+    $.each(['select', 'where', 'groupby', 'orderby', 'limit'], function(i, key) {
+      if (self.queryClauses[key]) queryClause += self.queryClauses[key] + ' ';
+    });
+    var url = this.addParamsToUrl(this.baseurl, $.param({tqx: "out:csv", tq: queryClause}));
+    location.href = url;
+  },
+
+  sendAndDraw: function(params) {
+    var self = this;
+    this.query.abort();
+    
+    this.query = params ? new google.visualization.Query(this.addParamsToUrl(this.baseurl, params)) : this.query;
+    this.showBusyStatus();
+    
+    // prepare query
+    var queryClause = '';
+    $.each(['select', 'where', 'groupby', 'orderby', 'limit', 'offset'], function(i, key) {
+      if (self.queryClauses[key]) queryClause += self.queryClauses[key] + ' ';
+    });
+    this.lastQueryClause = queryClause;
+    this.query.setQuery(queryClause);
+
+    this.beforeSendAndDraw();
+    this.query.send(function(response) {self.handleResponse(response)});
+  },
+
+  handleResponse: function(response) {
+    this.hideBusyStatus();
+    this.currentDataTable = null;
+    if (response.isError()) {
+      google.visualization.errors.addError(this.container, response.getMessage(),
+          response.getDetailedMessage(), {'showInTooltip': false});
+    } else {
+      this.setDataTableFromResponse(response);
+      
+      this.draw();
+    }
+  },
+
+  beforeSendAndDraw: function() {
+    // called by sendAndDraw.
+    // Can be overridden to preare a query etc.
+  },
+
+  beforeSubmit: function() {
+    // called before form submission
+  },
+
+  // Sets the instances datatable from a query response
+  setDataTableFromResponse: function(response) {
+    // Set rows in a data view.
+    this.currentDataTable = new ExtendedDataTable(response.getDataTable(), this.options);
+  }
+};
+
+DataSource.Visualization.create = function(type, query, container, options) {
+  if(!options['asyncLoading'])
+    google.setOnLoadCallback(DataSource.Visualization.onloadsetup(type, query, container, options));
+  else
+    DataSource.Visualization.onloadsetup(type, query, container, options);
+};
+
+DataSource.Visualization.onloadsetup = function(type, query, container, options) {
+    var klass = eval("DataSource." + type);
+    var visualization = new klass(query, container, options);
+    // store visualization in container data
+    $('#' + container).data('visualization', visualization);
+    
+    // TODO: Fix this dirty issue
+    window.setTimeout(function(){
+      $('#' + container + '_controls a.export_as_csv').click(function() {
+        visualization.download();
+        return false;
+      });
+    }, 500);
+
+    var onSubmit = function() {
+      var form = new DataSource.FilterForm(this);
+
+      visualization.queryClauses['select']  = form.toSelectClause();
+      visualization.queryClauses['where']   = form.toWhereClause();
+      visualization.queryClauses['groupby'] = form.toGroupByClause();
+
+      visualization.beforeSubmit();
+
+      visualization.sendAndDraw(form.getNoQueryValues());
+      return false;
+    };
+
+    // Submit form to display results
+    if (options['form']) {
+      $('#' + options['form']).submit(onSubmit);
+
+      if (options['autosubmit']) {
+        onSubmit.call($('#' + options['form']));
+      }
+    } else {
+      // If no form is defined, just get the redular results
+      visualization.sendAndDraw();
+    }
+}

data/lib/assets/javascripts/google_data_source/index.js

@@ -0,0 +1,7 @@
+//= require './data_source_init'
+//= require './extended_data_table'
+//= require './filter_form'
+//= require './google_visualization/visualization'
+//= require './google_visualization/table'
+//= require './google_visualization/combo_table'
+//= require './google_visualization/timeline'

data/lib/dummy_engine.rb

@@ -0,0 +1,5 @@
+module GoogleDataSource
+  class DummyEngine < ::Rails::Engine
+    # just a marker to make Rails include our assets in searchpath
+  end
+end

data/lib/google_data_source.rb

@@ -0,0 +1,33 @@
+require 'ostruct'
+require 'rparsec'
+require 'active_support/all'
+require 'action_controller'
+require 'active_record'
+
+require 'google_data_source/base'
+require 'google_data_source/version'
+require 'google_data_source/json_data'
+require 'google_data_source/csv_data'
+require 'google_data_source/xml_data'
+require 'google_data_source/html_data'
+require 'google_data_source/invalid_data'
+require 'google_data_source/column'
+require 'google_data_source/data_date'
+require 'google_data_source/data_date_time'
+require 'google_data_source/template_handler'
+
+require 'google_data_source/sql/models'
+require 'google_data_source/sql/parser'
+require 'google_data_source/sql_parser'
+
+# the reporting models
+require 'reporting/reporting'
+require 'reporting/reporting_adapter'
+require 'reporting/sql_reporting'
+require 'reporting/reporting_entry'
+require 'reporting/grouped_set'
+
+if defined?(::Rails::Railtie)
+  require File.join(File.dirname(__FILE__), *%w[google_data_source railtie])
+  require 'dummy_engine'
+end

data/lib/google_data_source/base.rb

@@ -0,0 +1,281 @@
+module GoogleDataSource
+  module DataSource
+    # Superclass for all data source implementations
+    # Offers methods for getting and setting the data and column definitions of
+    # the data source
+    class Base
+      # Callback defines a JavaScript snippet that is appended to the regular
+      # data-source reponse. This is currently used to refresh the form in
+      # reportings (validation)
+      attr_accessor :callback, :reporting, :column_labels, :formatters, :virtual_columns, :export_filename, :xml_class
+
+      # Define accessors for the data source data, columns and errors
+      attr_reader :errors
+      
+      # Creates a new instance and validates it. 
+      # Protected method so it can be used from the subclasses
+      def initialize(gdata_params)
+        @virtual_columns  = HashWithIndifferentAccess.new
+        @formatters       = HashWithIndifferentAccess.new
+        @column_labels    = HashWithIndifferentAccess.new
+        @required_columns = {}
+
+        @raw_data = []
+        @columns  = []
+
+        @params = gdata_params
+        @errors = {}
+        @version = "0.6"
+      
+        validate
+      end
+      protected :initialize
+      
+
+      # Returns true if formatter formatter for a certain column is defined
+      def has_formatter?(column_name)
+        @formatters.has_key?(column_name.to_sym)
+      end
+
+      # Convenience method for formatter definition
+      def formatter(column, options = {}, &block)
+        set_required_columns(column.to_sym, options[:requires]) if options.has_key?(:requires)
+        formatters[column.to_sym] = block
+      end
+
+      # Return true if virtual column with name exists
+      def is_virtual_column?(name)
+        virtual_columns.has_key?(name)
+      end
+
+      # Sets up a virtual column with name and block with is called with a row
+      # and returns a string or a hash like {v: "real value", f: "formatted value"}
+      def virtual_column(name, options = {},  &block)
+        @raw_data.add_virtual_column(name.to_sym, options[:type] || :string) if @raw_data.respond_to?(:add_virtual_column)
+        set_required_columns(name.to_sym, options[:requires]) if options.has_key?(:requires)
+        virtual_columns[name.to_sym] = {
+          :type => options[:type] || :string,
+          :proc => block
+        }
+      end
+
+      # Getter with empty array default
+      def required_columns
+        required = column_ids.inject([]) { |columns, column| columns << @required_columns[column.to_sym] }.flatten.compact
+        (required + column_ids).map(&:to_s).uniq
+      end
+
+      # Add a list of columns to the list of required columns (columns that have to be fetched)
+      def set_required_columns(column, requires = [])
+        @required_columns[column.to_sym] = requires
+      end
+
+      # Returns the filename for export without extension.
+      # Defaults to "export"
+      def export_filename
+        @export_filename || 'export'
+      end
+
+      def xml_class
+        @xml_class || 'item'
+      end
+
+      # Creates a new data source object from the get parameters of the data-source
+      # request.
+      def self.from_params(params)
+        # Exract GDataSource params from the request.
+        gdata_params = {}
+        tqx = params[:tqx]
+        unless tqx.blank?
+          gdata_params[:tqx] = true
+          tqx.split(';').each do |kv|
+            key, value = kv.split(':')
+            gdata_params[key.to_sym] = value
+          end
+        end
+      
+        # Create the appropriate GDataSource instance from the gdata-specific parameters
+        gdata_params[:out] ||= "json"    
+        gdata = from_gdata_params(gdata_params)
+      end
+      
+      # Factory method to create a GDataSource instance from a serie of valid GData
+      # parameters, as described in the official documentation (see above links).
+      # 
+      # +gdata_params+ can be any map-like object that maps keys (like +:out+, +:reqId+
+      # and so forth) to their values. Keys must be symbols.
+      def self.from_gdata_params(gdata_params)
+        case gdata_params[:out]
+        when "json"
+          JsonData.new(gdata_params)
+        when "html"
+          HtmlData.new(gdata_params)
+        when "csv"
+          CsvData.new(gdata_params)
+        when "xml"
+          XmlData.new(gdata_params)
+        else
+          InvalidData.new(gdata_params)
+        end
+      end
+      
+      # Access a GData parameter. +k+ must be symbols, like +:out+, +:reqId+.
+      def [](k)
+        @params[k]
+      end
+    
+      # Sets a GData parameter. +k+ must be symbols, like +:out+, +:reqId+.
+      # The instance is re-validated afterward.
+      def []=(k, v)
+        @params[k] = v
+        validate
+      end
+    
+      # Checks whether this instance is valid (in terms of configuration parameters)
+      # or not.
+      def valid?
+        @errors.size == 0
+      end
+    
+      # Manually adds a new validation error. +key+ should be a symbol pointing
+      # to the invalid parameter or element.
+      def add_error(key, message)
+        @errors[key] = message
+        return self
+      end
+      
+      # Sets the unformatted data of the datasource
+      # +data+ is an array either of Hash objects or arbitrary objects 
+      # * Hashes must have keys as column ids
+      # * Arbitrary object must repond to column id named methods
+      #
+      def data=(data)
+        # reset formatted data
+        @data     = nil
+
+        # set unformatted data
+        @raw_data = data
+        validate
+
+        # register virtual columns
+        if data.respond_to?(:add_virtual_column)
+          @virtual_columns.each { |k, v| data.add_virtual_column(k.to_sym, v[:type]) }
+        end
+      end
+
+      # Returns the formatted data in the datasource format
+      #
+      def data
+        @data unless @data.nil?
+
+        # get data from object (eg. Reporting)
+        data = @raw_data.respond_to?(:data) ?
+          @raw_data.data(:required_columns => required_columns) :
+          @raw_data
+
+        # Run formatters and virtual columns
+        @data = data.collect do |row|
+          row = OpenStruct.new(row) if row.is_a?(Hash)
+
+          column_ids.inject([]) do |columns, column|
+            if is_virtual_column?(column)
+              columns << virtual_columns[column][:proc].call(row)
+            elsif has_formatter?(column)
+              columns << {
+                :f => formatters[column.to_sym].call(row),
+                :v => row.send(column)
+              }
+            else
+              columns << row.send(column)
+            end
+          end
+        end
+      end
+
+      # Returns the ids of the columns
+      #
+      def column_ids
+        columns.collect(&:id)
+      end
+
+      # Sets the columns which should be sent by the datasource
+      # +columns+ is an array of either Hashes with keys (:id, :type, :label)
+      # or +Column+ objects
+      #
+      def columns=(columns)
+        @columns = columns.map { |c| c.is_a?(Column) ? c : Column.new(c) }
+        @columns.each do |col|
+          raise ArgumentError, "Invalid column type: #{col.type}" unless col.valid?
+        end
+      end
+
+      # Returns the columns in a datasource compatible format
+      # Applies all labels set
+      def columns
+        @columns.each { |c| c.label = column_labels.delete(c.id) if column_labels.has_key?(c.id) }
+        @columns
+      end
+
+      # Make cols alias for json ... classes
+      alias_method :cols, :columns
+      deprecate :cols
+
+      # Sets the raw data and the columns simultaniously and tries to guess the
+      # columns if not set.
+      # +data+ may be an array of rows or an object of a class that support a data(options)
+      # and a columns method
+      #
+      def set(data, columns = nil)
+        self.data     = data
+        self.columns  = columns || guess_columns(@raw_data)
+      end
+
+      # Tries to get a clever column selection from the items collection.
+      # Currently only accounts for ActiveRecord objects
+      # +items+ is an arbitrary collection of items as passed to the +set+ method
+      def guess_columns(data)
+        return data.columns if data.respond_to? :columns
+
+        columns = []
+        klass = data.first.class
+        klass.columns.each do |column|
+          columns << Column.new({
+            :id => column.name,
+            :label => column.name.humanize,
+            :type => 'string' # TODO get the right type
+          })
+        end
+        columns
+      end
+
+      # Validates this instance by checking that the configuration parameters
+      # conform to the official specs.
+      def validate
+        @errors.clear
+
+        # check validity
+        if @raw_data.respond_to?(:valid?) && ! @raw_data.valid?
+          add_error(:reqId, "Form validation failed")
+        end
+
+        if @params[:tqx]
+          add_error(:reqId, "Missing required parameter reqId") unless @params[:reqId]
+        
+          if @params[:version] && @params[:version] != @version
+            add_error(:version, "Unsupported version #{@params[:version]}")
+          end
+        end
+      end
+    
+      # Empty method. This is a placeholder implemented by subclasses that
+      # produce the response according to a given format.
+      def response
+      end
+      
+      # Empty method. This is a placeholder implemented by subclasses that return the correct format
+      def format
+        self[:out]
+      end
+    end
+  end
+end