mainej-activewarehouse 0.3.0

data/activewarehouse/lib/active_warehouse/report/data_column.rb

@@ -0,0 +1,19 @@
+module ActiveWarehouse
+	module Report
+
+		class DataColumn
+			
+			attr_accessor :dimension_value, :fact_attribute, :label
+			
+			def initialize(label, dimension_value, fact_attribute)
+				@label = label
+				@dimension_value = dimension_value
+				@fact_attribute = fact_attribute
+			end
+			
+			def key
+				"#{dimension_value}_#{fact_attribute.label}".gsub(' ', '_').downcase
+			end
+		end
+	end
+end

data/activewarehouse/lib/active_warehouse/report/data_row.rb

@@ -0,0 +1,15 @@
+module ActiveWarehouse
+	module Report
+
+		class DataRow
+			
+			attr_accessor :cells, :dimension_value
+			
+			def initialize(dimension_value, cells)
+				@dimension_value = dimension_value
+				@cells = cells
+			end
+			
+		end
+	end
+end

data/activewarehouse/lib/active_warehouse/report/dimension.rb

@@ -0,0 +1,58 @@
+module ActiveWarehouse
+	module Report
+
+		class Dimension
+			
+			attr_reader :dimension_class, :name, :hierarchy, :hierarchy_name, :filters, :stage, :hierarchy_length, :hierarchy_level, :param_prefix
+			
+			def initialize(dimension_type, report, params = {})
+				
+				@dimension_class = report.send("#{dimension_type}_dimension_class")
+				@name = report.send("#{dimension_type}_dimension_name")
+				@hierarchy_name = report.send("#{dimension_type}_hierarchy")
+				@filters = report.send("#{dimension_type}_filters")
+				@param_prefix = report.send("#{dimension_type}_param_prefix")
+				@stage = (params[:stage] || report.send("#{dimension_type}_stage")).to_i
+				
+				@hierarchy = @dimension_class.hierarchy(@hierarchy_name)
+				@hierarchy_length = @hierarchy.length
+				@hierarchy_level = @hierarchy[@stage]
+				@params = params
+			end
+			
+			def self.column(report, params = {})
+				Dimension.new(:column, report, params)
+			end
+
+			def self.row(report, params = {})
+				Dimension.new(:row, report, params)
+			end
+
+			def query_filters
+				param_filters = {}
+		    @params[:ancestors].each do |key, value|
+	        param_filters["#{name}.#{key}"] = value
+		    end		
+				param_filters
+			end
+			
+			def values
+				filters[hierarchy_level].blank? ? available_values : available_values & filters[hierarchy_level]
+			end
+			
+			def ancestors
+		    (0..stage-1).map do |s| 
+		      @params[:ancestors][hierarchy[s].to_s]
+		    end.compact
+			end
+
+			def has_children?
+				stage < hierarchy_length - 1
+			end
+
+		  def available_values
+		    dimension_class.available_child_values(hierarchy_name, ancestors).map(&:to_s)
+		  end
+		end
+	end
+end

data/activewarehouse/lib/active_warehouse/report/table_report.rb

@@ -0,0 +1,38 @@
+module ActiveWarehouse #:nodoc:
+  module Report #:nodoc:
+    # A report which is used to represent a tabular report.
+    class TableReport < ActiveRecord::Base
+      include AbstractReport
+      before_save :to_storage
+      after_save :from_storage
+      attr_accessor :format
+      attr_accessor :link_cell
+      attr_accessor :html_params
+      
+      # Get any format options
+      def format
+        @format ||= {}
+      end
+      
+      # Set to true if cells should be linked
+      def link_cell
+        @link_cell ||= false
+      end
+      
+      # Hash of HTML parameters
+      def html_params
+        @html_params ||= {}
+      end
+
+			def view(params, options = {})
+				if options.has_key?(:sortable_with_totals)
+					options[:sortable] = true
+					options[:with_totals] = true
+					options.delete(:sortable_with_totals)
+				end
+				
+				ActiveWarehouse::View::TableView.new(self, params, options)
+			end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/version.rb

@@ -0,0 +1,9 @@
+module ActiveWarehouse #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/activewarehouse/lib/active_warehouse/view.rb

@@ -0,0 +1,9 @@
+require 'active_warehouse/view/report_helper'
+require 'active_warehouse/view/abstract_view'
+require 'active_warehouse/view/table_view'
+require 'active_warehouse/view/sql_view'
+require 'active_warehouse/view/crumb'
+require 'active_warehouse/view/yui_adapter'
+ActionView::Base.send :include, ReportHelper # TODO scope by ActiveWarehouse
+ActionView::Base.send :include, ActiveWarehouse::View::YuiAdapter
+

data/activewarehouse/lib/active_warehouse/view/crumb.rb

@@ -0,0 +1,64 @@
+class	Crumb
+	def initialize(stage, dimension, params)
+		@params = params.dup
+		@stage = stage
+		@hierarchy = dimension.hierarchy
+		@name = dimension.ancestors[@stage-1] if @stage > 0
+	end
+	
+	def link_to_params
+		invalid_params = @hierarchy[@stage..-1].map {|h| hierarchy_param(h) }.flatten
+		@params.delete_if { |k, v| invalid_params.include?(k) }
+	end
+	
+	def link_to_name
+		@name || 'Top'
+	end
+end
+
+class RowCrumb < Crumb
+	def initialize(stage, dimension, params)
+		super
+		@params[:rstage] = @stage.to_s
+	end
+	
+	#TODO - brittle, drive off of report's prefix param
+	def hierarchy_param(name)
+		"r_#{name}"
+	end
+	
+	def crumb_type
+		"Row"
+	end
+
+	def self.gather(dimension, params)
+		crumbs = []
+		(0..dimension.stage).each do |stage|
+			crumbs << RowCrumb.new(stage, dimension, params)
+		end
+		crumbs
+	end
+end
+
+class ColumnCrumb < Crumb
+	def initialize(stage, dimension, params)
+		super
+		@params[:cstage] = @stage.to_s
+	end
+
+	def hierarchy_param(name)
+		"c_#{name}"
+	end
+
+	def crumb_type
+		"Column"
+	end
+
+	def self.gather(dimension, params)
+		crumbs = []
+		(0..dimension.stage).each do |stage|
+			crumbs << ColumnCrumb.new(stage, dimension, params)
+		end
+		crumbs
+	end
+end

data/activewarehouse/lib/active_warehouse/view/report_helper.rb

@@ -0,0 +1,98 @@
+# Helper module for rendering reports.
+module ReportHelper
+  # include ActiveWarehouse::Report::YuiAdapter
+  
+  # UNSUPPORTED METHOD. Please use render_report_from instead.
+  # * <tt>report</tt>: The report instance
+  # * <tt>html_options</tt>: HTML options
+  def render_report(report, html_options={})
+		raise "Unsupported Render Method.  Please use render_report_from instead."
+  end
+  
+  def render_report_from(table_view, html_options = {})
+		
+		# must use YUI if sorting is desired
+		if table_view.sortable? 
+			raise "Sortable requires Yui4Rails plugin." unless defined? Yui4Rails 
+    	data_table = Yui4Rails::Widgets::DataTable.new("yui_table", yui_column_definitions(table_view), yui_data_rows(table_view), 
+				table_view.with_totals? ? yui_totals_row(table_view) : "")
+				
+			return data_table.render
+		end
+		
+		# ... else render in html
+		report = table_view.report
+		column_dimension = table_view.column_dimension
+		row_dimension = table_view.row_dimension
+
+    table_attributes = {}
+    table_attributes[:class] = html_options[:report_class] ||= 'report'
+
+    # build the XHTML
+    x = ::Builder::XmlMarkup.new(:indent => 2)
+    x.table(table_attributes) do |x|
+	
+      x.tr do |x| # column dimension
+        x.th
+        column_dimension.values.each do |col_dim_value|
+          x.th({:colspan => report.fact_attributes.length}) do |x|
+            x << link_to_if(column_dimension.has_children?, col_dim_value, table_view.column_link(col_dim_value))
+          end
+        end
+      end
+
+      x.tr do |x| # aggregated fact headers
+				# Generate the row dimension's header
+        x.th {|x| x << "#{row_dimension.hierarchy_level.to_s.humanize.titleize}"}
+				table_view.data_columns.each do |column|
+            x.th(column.label)
+        end
+      end
+
+      table_view.data_rows.each do |data_row|
+        x.tr do |x|
+          x.td do |x| # row dimension label
+            x << link_to_if(row_dimension.has_children?, data_row.dimension_value, table_view.row_link(data_row.dimension_value))
+          end
+
+          data_row.cells.each_with_index do |cell, index| # aggregated facts
+          	x.td do |x|
+							x << link_to_if((report.link_cell && column_dimension.has_children? && row_dimension.has_children?), cell.value, 
+								table_view.cell_link(cell.column_dimension_value,data_row.dimension_value)
+							)
+            end
+          end
+        end
+      end
+			
+			if table_view.with_totals?
+			# Add summary row at the bottom of the report
+				x.tr({:class => 'total'}) do |x|
+					x.td { |x| x << "Grand Totals"}
+				
+					table_view.data_columns.each_with_index do |column, index|
+		      	x.td do |x|
+							x << table_view.column_total(index)
+						end
+					end		
+				end
+			end
+    end
+  end
+
+	def render_crumbs(crumbs)
+		breadcrumb_html = []
+		return if crumbs.size == 1
+		
+		crumbs.each do |crumb|
+			if crumb != crumbs.last
+				breadcrumb_html << link_to(crumb.link_to_name, crumb.link_to_params)
+			else
+				breadcrumb_html << crumb.link_to_name 
+			end
+		end
+		result = breadcrumb_html.join(' &#187; ')
+		result.blank? ? "" : "#{crumbs.last.crumb_type}: #{result}"
+	end
+	
+end

data/activewarehouse/lib/active_warehouse/view/table_view.rb

@@ -0,0 +1,134 @@
+module ActiveWarehouse
+	module View
+
+		class TableView
+			
+      include AbstractView
+
+			attr_reader :query_result, :fact_attributes,
+									:data_columns, :row_crumbs, :column_crumbs, :with_totals, :sortable
+									
+			attr_accessor :ignore_columns
+			
+			def initialize(report, params, options = {})
+				super
+				@with_totals = options.has_key?(:with_totals)
+				@sortable = options.has_key?(:sortable)
+				@ignore_columns = options.has_key?(:ignore_columns) ? options[:ignore_columns] : []
+				@column_crumbs = ColumnCrumb.gather(@column_dimension, @current_params)
+        @row_crumbs = RowCrumb.gather(@row_dimension, @current_params)
+				@query_result = execute_query
+				
+				@fact_attributes = report.fact_attributes.map	do |fact_attribute_name|
+          case fact_attribute_name
+          when Symbol, String
+            fact_attribute = report.fact_class.field_for_name(fact_attribute_name.to_s.dup)
+            raise "Field name #{fact_attribute_name} not defined in the fact #{report.fact_class}" if fact_attribute.nil?
+          end			
+					fact_attribute
+				end
+			end
+			
+			def execute_query
+        report.cube.query_row_and_column(row_dimension, column_dimension,
+          :conditions => report.conditions )
+			end
+
+			def column_total(column_index)
+				column = data_columns[column_index]
+				return "" unless column
+				column_attribute_key = column.fact_attribute.name.to_sym				
+				return "" if ignore_columns.include?(column_attribute_key)
+				total = 0
+				data_rows.each do |row|
+					value = row.cells[column_index].raw_value
+					if value.is_a? Numeric
+						total += value
+					end	
+				end
+					
+				formatted_value = format_data(column_attribute_key,total)
+				# formatted_value = format_data(column.fact_attribute.name.to_sym,total)
+			end
+			
+			def data_columns
+				@data_columns ||= []
+				return @data_columns unless @data_columns.empty?
+				if column_dimension
+					column_dimension.values.each do |dimension_value|
+						@fact_attributes.each do |fact_attribute|
+	            @data_columns << ActiveWarehouse::Report::DataColumn.new(fact_attribute.label.humanize.titleize, dimension_value, fact_attribute)
+	          end					
+					end
+				end
+				@data_columns
+			end
+				
+			def data_rows
+				@data_rows ||= []
+				return @data_rows unless @data_rows.empty?
+				if row_dimension
+					columns = self.data_columns
+					row_dimension.values.each do |row_dimension_value|
+						cells = []
+						columns.each do |column|
+							cells << data_cell(column.fact_attribute, column.dimension_value, row_dimension_value)
+	          end					
+						@data_rows << ActiveWarehouse::Report::DataRow.new(row_dimension_value, cells)
+					end
+				end
+				@data_rows
+			end
+		
+			def data_cell(fact_attribute, column_dimension_value, row_dimension_value)
+        value = ''
+        raw_value = nil
+        case fact_attribute
+        when ActiveWarehouse::AggregateField
+          raw_value = query_result.value(row_dimension_value, column_dimension_value, fact_attribute.label)
+        when ActiveWarehouse::CalculatedField
+          raw_value = fact_attribute.calculate(query_result.values(row_dimension_value, column_dimension_value))
+        end
+        
+        formatted_value = format_data(fact_attribute.name.to_sym,raw_value)
+				ActiveWarehouse::Report::DataCell.new(column_dimension_value, row_dimension_value, fact_attribute, raw_value, formatted_value)	
+			end
+		
+			def column_link(column_dimension_value)
+				current_params.merge({:cstage => column_dimension.stage + 1, 
+        	"#{column_dimension.param_prefix}_#{column_dimension.hierarchy_level}" => column_dimension_value})
+			end		
+			
+			def row_link(row_dimension_value)
+				current_params.merge({:rstage => row_dimension.stage + 1, 
+        	"#{row_dimension.param_prefix}_#{row_dimension.hierarchy_level}" => row_dimension_value})
+			end
+			
+			def cell_link(column_dimension_value,row_dimension_value)
+				current_params.merge({:rstage => row_dimension.stage + 1, :cstage => column_dimension.stage + 1, 
+        	"#{column_dimension.param_prefix}_#{column_dimension.hierarchy_level}" => column_dimension_value,
+        	"#{row_dimension.param_prefix}_#{row_dimension.hierarchy_level}" => row_dimension_value})
+			end
+			
+			def sortable?
+				@sortable
+			end
+			
+			def with_totals?
+				@with_totals
+			end
+			
+			def format_data(field, raw_value)
+		    format = report.format[field]
+        if format && format.is_a?(Proc)
+          	value = format.call(raw_value)
+				elsif	format == :currency	
+						value = sprintf("$%.2f", raw_value)
+        else
+          value = raw_value.to_s
+        end		
+			end
+		end
+		
+	end
+end