--- a/busui/owa/modules/base/classes/resultSetManager.php
+++ b/busui/owa/modules/base/classes/resultSetManager.php
@@ -1,1 +1,1298 @@
-
+<?php
+
+//
+// Open Web Analytics - An Open Source Web Analytics Framework
+//
+// Copyright 2006 Peter Adams. All rights reserved.
+//
+// Licensed under GPL v2.0 http://www.gnu.org/copyleft/gpl.html
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// $Id$
+//
+
+require_once(OWA_BASE_CLASS_DIR.'pagination.php');
+require_once(OWA_BASE_CLASS_DIR.'timePeriod.php');
+require_once(OWA_DIR.'owa_template.php');
+
+/**
+ * Result Set Manager
+ *
+ * Responsible for creating a data result set from various metrics and dimensions
+ * 
+ * @author      Peter Adams <peter@openwebanalytics.com>
+ * @copyright   Copyright &copy; 2006 Peter Adams <peter@openwebanalytics.com>
+ * @license     http://www.gnu.org/copyleft/gpl.html GPL v2.0
+ * @category    owa
+ * @package     owa
+ * @version		$Revision$	      
+ * @since		owa 1.3.0
+ */
+
+class owa_resultSetManager extends owa_base {
+
+	/**
+	 * The params of the caller, either a report or graph
+	 *
+	 * @var array
+	 */
+	var $params = array();
+		
+	/**
+	 * The lables for calculated measures
+	 *
+	 * @var array
+	 */
+	var $labels = array();
+		
+	/**
+	 * Data Access Object
+	 *
+	 * @var object
+	 */
+	var $db;
+	
+	/**
+	 * The dimensions to groupby
+	 *
+	 * @var array
+	 */
+	var $dimensions = array();
+	
+	/**
+	 * The Number of Dimensions to groupby
+	 *
+	 * @var integer
+	 */
+	var $dimensionCount;
+	
+	/**
+	 * The table/column or denormalized dimensions 
+	 * associated with this metric
+	 *
+	 * @var array
+	 */
+	var $denormalizedDimensions = array();
+	
+	var $_default_offset = 0;
+	var $page;
+	var $limit;
+	var $order;
+	var $format;
+	var $constraint_operators = array('==','!=','>=', '<=', '>', '<', '=~', '!~', '=@','!@');
+	var $related_entities = array();
+	var $related_dimensions = array();
+	var $related_metrics = array();
+	var $resultSet;
+	var $base_table;
+	var $metrics = array();
+	var $metricsByTable = array();
+	var $childMetrics = array();
+	var $calculatedMetrics = array();
+	var $query_params = array();
+	var $baseEntity;
+	var $metricObjectsByEntityMap = array();
+	var $errors = array();
+	var $formatters = array();
+	
+	function __construct($db = '') {
+		
+		if ($db) {
+			$this->db = $db;	
+		} else {
+			$this->db = owa_coreAPI::dbSingleton();
+		}
+		
+		$this->formatters = array(
+			//'yyyymmdd' => array($this, 'dateFormatter'),
+			'timestamp'		=> array($this, 'formatSeconds'),
+			'percentage' 	=> array($this, 'formatPercentage'), 
+			'integer' 		=> array($this, 'numberFormatter'),
+			'currency'		=> array($this, 'formatCurrency')
+		);
+		
+		return parent::__construct();
+	}
+	
+		
+	function setConstraint($name, $value, $operator = '') {
+		
+		if (empty($operator)) {
+			$operator = '=';
+		}
+		
+		if (!empty($value)) {
+			$this->params['constraints'][] = array('operator' => $operator, 'value' => $value, 'name' => $name);
+		}
+	}
+	
+	function setConstraints($array) {
+		
+		if (is_array($array)) {
+			
+			if (is_array($this->params['constraints'])) {
+				$this->params['constraints'] = array_merge($array, $this->params['constraints']);
+			} else {
+				$this->params['constraints'] = $array;
+			}
+		}
+	}
+	
+	function constraintsStringToArray($string) {
+		
+		if ($string) {
+			//print_r($string);
+			// add string to query params array for use in URLs.
+			$this->query_params['constraints'] = $string;
+			
+			$constraints = explode(',', $string);
+			//print_r($constraints);
+			$constraint_array = array();
+			
+			foreach($constraints as $constraint) {
+				
+				foreach ($this->constraint_operators as $operator) {
+					
+					if (strpos($constraint, $operator)) {
+						list ($name, $value) = split($operator, $constraint);
+						
+						$constraint_array[] = array('name' => $name, 'value' => $value, 'operator' => $operator);
+					
+
+						break;
+					}
+				}
+			}
+			//print_r($constraint_array);
+			return $constraint_array;
+		}
+	}
+	
+	function getConstraints() {
+	
+		return $this->params['constraints'];
+	}
+	
+	function applyConstraints() {
+		
+		$nconstraints = array();
+		
+		foreach ($this->getConstraints() as $k => $constraint) {
+			
+			$dim = $this->lookupDimension($constraint['name'], $this->baseEntity);
+			
+			//$dimEntity = owa_coreAPI::entityFactory($dim['entity']);
+			
+			
+			$col = $dim['column'];
+			$constraint['name'] = $col;
+			$nconstraints[$col] = $constraint;
+			$this->db->multiWhere($nconstraints);
+			//print_r($nconstraints);
+		
+		}
+		
+	}
+	
+	
+	function chooseBaseEntity() {
+		
+		$metric_imps = array();
+		
+		// load metric implementations
+		foreach ($this->metrics as $metric_name) {
+			
+			$metric_imps = array_merge($this->getMetricEntities($metric_name), $metric_imps);
+			
+			
+		}
+		//print_r($metric_imps);
+		owa_coreAPI::debug('pre-reduce set of entities to choose from: '.print_r($metric_imps, true));
+		
+		$entities = array();
+		// reduce entities	
+		foreach ($metric_imps as $mimp) {
+			
+			if (empty($entities)) {
+				$entities = $mimp;
+			}
+			
+			$entities = $this->reduceTables($mimp, $entities);
+			
+			if (empty($entities)) {
+				return $this->addError('illegal metric combination');
+			}
+		}
+		
+		owa_coreAPI::debug('post-reduce set of entities to choose from: '.print_r($entities, true));
+		
+		// check summary level of entities
+		$niceness = array();
+		
+		foreach ($entities as $entity) {
+			
+			$niceness[$entity] = owa_coreAPI::entityFactory($entity)->getSummaryLevel();
+		}
+		//sort by summary level
+		arsort($niceness);
+		
+		owa_coreAPI::debug('Entities summary levels: '.print_r($niceness, true));
+		
+		$entity_count = count($niceness);
+		$i = 1;
+		//check entities for dimension relations
+		foreach ($niceness as $entity_name => $summary_level) {
+			
+			$error = false;
+			
+			//cycle through each dimension frm dim list and those found in constraints.
+			$dims = array_unique(array_merge($this->dimensions, $this->getDimensionsFromConstraints()));
+			
+			owa_coreAPI::debug(sprintf('Dimensions: %s',print_r($this->dimensions, true)));
+			
+			owa_coreAPI::debug(sprintf('Checking the following dimensions for relation to %s: %s',$entity_name, print_r($dims, true)));
+			
+			foreach ($dims as $dimension) {
+				
+				$check = $this->isDimensionRelated($dimension, $entity_name);
+				
+				// is the realtionship check fails then move onto the next entity.
+				if (!$check) {
+					$error = true;
+					owa_coreAPI::debug("$dimension is not related to $entity_name. Moving on to next entity...");
+					break;
+				} else {
+					owa_coreAPI::debug("Dimension: $dimension is related to $entity_name.");
+				}
+			}
+			
+			// is no error then everythig is related and we are good to go.
+			if (!$error) {
+				owa_coreAPI::debug('optimal base entity is: '.$entity_name);
+				$this->baseEntity = owa_coreAPI::entityFactory($entity_name);
+				return $this->baseEntity;
+			}
+			
+			if ($i === $entity_count) {
+				$this->addError('illegal dimension combination: '.$dimension);
+			} else {
+				$i++;
+			}
+		}
+	}
+	
+	function getDimensionsFromConstraints() {
+		
+		$dims = array();
+		
+		$constraints = $this->getConstraints();
+		//print_r($constraints);
+		if (!empty($constraints)) {
+				
+			foreach ($constraints as $carray) {
+				
+				$dims[] = $carray['name'];
+			}
+		}
+		
+		return $dims;
+	}
+		
+	function isDimensionRelated($dimension_name, $entity_name) {
+		
+		$entity = owa_coreAPI::entityFactory($entity_name);
+		
+		$dimension = $this->lookupDimension($dimension_name, $entity);
+		
+		if ($dimension['denormalized'] === true) {
+			$this->related_dimensions[$dimension['name']] = $dimension;
+			owa_coreAPI::debug("Dimension: $dimension_name is denormalized into $entity_name");
+			return true;
+		} else {
+		
+			$fk = $this->getDimensionForeignKey($dimension, $entity);
+			
+			if ($fk) {
+				owa_coreAPI::debug("Dimension: $dimension_name is related to $entity_name");
+				$this->related_dimensions[$dimension['name']] = $dimension;
+				return true;
+			} else {
+				owa_coreAPI::debug("Could not find a foreign key for $dimension_name in $entity_name");
+			}
+		}
+	}
+	
+	function getMetricEntities($metric_name) {
+		
+		//get the class implementations
+		$s = owa_coreAPI::serviceSingleton();
+		$classes = $s->getMetricClasses($metric_name);
+		
+		$entities = array();
+		
+		// cycles through metric classes and get their entity names
+		foreach ($classes as $name => $map) {
+			$m = owa_coreAPI::metricFactory($map['class'], $map['params']);
+			
+			// check to see if this is a calculated metric
+				if ($m->isCalculated()) {
+					
+					foreach ($m->getChildMetrics() as $cmetric_name) {
+						$this->addCalculatedMetric($m);
+						$entities = array_merge($this->getMetricEntities($cmetric_name), $entities);
+					}
+					
+				} else {
+					$this->metricObjectsByEntityMap[$m->getEntityName()][$metric_name] = $m;
+					$entities[$metric_name][] = $m->getEntityName();	
+				}
+			
+		}
+		
+		return $entities;
+	}
+	
+	function reduceTables($new, $old) {
+		
+		return array_intersect($new, $old);
+	}
+	
+	function getDimensionForeignKey($dimension, $entity) {
+
+		if ($dimension) {
+			//$entity = ;
+			$dim = $dimension;
+			$fk = array();
+			// check for foreign key column by name if dimension specifies one
+			if (array_key_exists('foreign_key_name', $dim) && !empty($dim['foreign_key_name'])) {
+				// get foreign key col by 
+				if ($entity->isForeignKeyColumn($dim['foreign_key_name'])){
+					$fk = array('col' => $dim['foreign_key_name'], 'entity' => $entity);
+				}
+				
+			} else {
+				// if not check for foreign key by entity name
+			    //check to see if the metric's entity has a foreign key to the dimenesion table.
+				$fk = array(); 
+				
+				$fkcol = $entity->getForeignKeyColumn($dim['entity']);
+				owa_coreAPI::debug("Foreign Key check: ". print_r($fkcol, true));
+				if ($fkcol) {
+					$fk['col'] = $fkcol;
+					$fk['entity'] = $entity;
+				} 
+			}
+
+			return $fk;
+		}
+	}
+		
+	function lookupDimension($name, $entity) {
+		
+		// check dimensions
+		if (array_key_exists($name, $this->related_dimensions)) {
+			//return $this->related_dimensions[$name];
+		}
+		//print_r($this->metrics[0]);
+		// check for denormalized 
+		
+		$service = owa_coreAPI::serviceSingleton();
+		$dim = $service->getDenormalizedDimension($name, $entity->getName());
+		
+		if ($dim) {
+			//apply table aliasing to dimension column
+			$dim['column'] = $entity->getTableAlias().'.'.$dim['column'];
+		} else {
+		
+			// check for normalized dim
+			if (array_key_exists($name, $this->related_dimensions)) {
+				$dim = $this->related_dimensions[$name];
+			} else {
+				
+				$dim = $service->getDimension($name);
+				
+				if ($dim) {
+					$dimEntity = owa_coreAPI::entityFactory($dim['entity']);
+					// alias needs to use fk name in case there are two joins on the
+					// same table. This is also used in addRelation method
+					$alias = $dimEntity->getTableAlias().'_via_'.$dim['foreign_key_name'];
+					//$dim['column'] = $dimEntity->getTableAlias().'.'.$dim['column'];
+					$dim['column'] = $alias.'.'.$dim['column'];
+				} else {
+					$msg = "$name is not a registered dimension.";
+					owa_coreAPI::debug($msg);
+					$this->addError($msg);
+				}
+				
+			}
+		}
+		
+		return $dim;
+	}
+	
+	function setLimit($value) {
+		
+		if (!empty($value)) {
+		
+			$this->limit = $value;
+		}
+	}
+	
+	function setOrder($value) {
+		
+		if (!empty($value)) {
+			$this->params['order'] = $value;
+		}
+	}
+	
+	function getOrder() {
+	
+		if (array_key_exists('order', $this->params)) {
+			return $this->params['order'];
+		}
+	}
+	
+	function setSort($column, $order) {
+		
+		//$this->params['orderby'][] = array($this->getColumnName($column), $order);
+	}
+	
+	function setSorts($array) {
+		
+		if (is_array($array)) {
+			
+			if (!empty($this->params['orderby'])) {
+				$this->params['orderby'] = array_merge($array, $this->params['orderby']);
+
+			} else {
+				$this->params['orderby'] = $array;
+			}
+		}
+	}
+	
+	function sortStringToArray($string) {
+		
+		if ($string) {
+		
+			// add string to query params array for use in URLs.
+			$this->query_params['sort'] = $string;
+		
+			$sorts = explode(',', $string);
+			
+			$sort_array = array();
+			
+			foreach ($sorts as $sort) {
+				
+				if (strpos($sort, '-')) {
+					$column = substr($sort, 0, -1);
+					$order = 'DESC';
+				} else {
+					$column = $sort;
+					$order = 'ASC';
+				}
+		
+				//$col_name = $this->getColumnName($column);
+				$check = $this->isSortValid($column);
+				
+				if ($check) {
+								
+					$col_name = $column;
+					
+					if ($col_name) {
+						$sort_array[$sort][0] = $col_name;
+						$sort_array[$sort][1] = $order;
+						
+					} else {
+						$this->addError("$column is not a valid column to sort on");
+					}	
+				}	
+			}
+			
+			return $sort_array;
+		}
+	}
+	
+	function isSortValid($needle) {
+		
+		$haystack = array_merge($this->metrics, $this->dimensions);
+		return in_array($needle, $haystack);
+	}
+	
+	function setPage($value) {
+		
+		if (!empty($value)) {
+		
+			$this->page = $value;
+			
+			if (!empty($this->pagination)) {
+				$this->pagination->setPage($value);
+			}			
+		}
+	}
+	
+	function setOffset($value) {
+		
+		if (!empty($value)) {
+			$this->params['offset'] = $value;
+		}
+	}
+	
+	function setFormat($value) {
+		if (!empty($value)) {
+			$this->format;
+			$this->params['result_format'] = $value;
+		}
+	}
+	
+	function setPeriod($value) {
+		if (!empty($value)) {
+			$this->params['period'] = $value;
+		}
+	}
+	
+	function setTimePeriod($period_name = '', $startDate = null, $endDate = null, $startTime = null, $endTime = null) {
+		
+		$map = false;
+		
+		if ($startDate && $endDate) {
+			$period_name = 'date_range';
+			$map = array('startDate' => $startDate, 'endDate' => $endDate);
+			$dimension_name = 'date';
+			$format = 'yyyymmdd';
+		} elseif ($startTime && $endTime) {
+			$period_name = 'time_range';
+			$map = array('startTime' => $startTime, 'endTime' => $endTime);
+			$dimension_name = 'timestamp';
+			$format = 'timestamp';
+		} else {
+			owa_coreAPI::debug('no start/end params passed to owa_metric::setTimePeriod');
+			$dimension_name = 'date';
+			$format = 'yyyymmdd';
+		}
+	
+		// add to query params array for use in URL construction		
+		if ($map) {
+			$this->query_params = array_merge($map, $this->query_params);
+		} else {
+			$this->query_params['period'] = $period_name;
+		}
+		
+		$p = owa_coreAPI::supportClassFactory('base', 'timePeriod');
+		
+		$p->set($period_name, $map);
+		
+		$this->setPeriod($p);
+		
+		$start = $p->startDate->get($format);
+		$end = $p->endDate->get($format);
+		
+		$this->setConstraint($dimension_name, array('start' => $start, 'end' => $end), 'BETWEEN');
+
+		
+	}
+	
+	function setStartDate($date) {
+	
+		if (!empty($date)) {
+			$this->params['startDate'] = $date;
+		}
+	}
+	
+	function setEndDate($date) {
+		if (!empty($date)) {
+			$this->params['endDate'] = $date;
+		}
+	}
+		
+	function applyMetaDataToResults($results) {
+		
+		$new_rows = array();
+		
+		foreach ($results as $row) {
+			
+			$new_rows[] = $this->applyMetaDataToSingleResultRow($row);
+		}
+		
+		return $new_rows;
+	}
+	
+	function applyMetaDataToSingleResultRow($row) {
+		
+		$new_row = array();
+		
+		foreach ($row as $k => $v) {
+				
+			if (in_array($k, $this->dimensions)) {
+				$type = 'dimension';
+				$dim = $this->lookupDimension($k, $this->baseEntity);
+				$data_type = $dim['data_type'];
+			} elseif (in_array($k, $this->metrics)){
+				$type = 'metric';
+				$data_type = $this->getMetric($k)->getDataType();
+			}
+			
+			
+			
+			$new_row[$k] = array(
+				'result_type' => $type, 
+				'name' 		  => $k, 
+				'value' 	  => $v,
+				'formatted_value' => $this->formatValue($data_type, $v),
+				'label' => $this->getLabel($k), 'data_type' => $data_type);	
+		}
+		
+		return $new_row;
+	}
+	
+	function formatValue($type, $value) {
+		
+		if (array_key_exists($type, $this->formatters)) {
+			
+			$formatter = $this->formatters[$type];
+			
+			if (!empty($formatter)) {
+				
+				$value = call_user_func($formatter, $value);
+			}
+		}
+		 
+		
+		return $value;
+	}
+	
+	function numberFormatter($value) {
+		
+		return number_format($value);
+	}
+	
+	function formatSeconds($value) {
+		
+		return date("G:i:s",mktime(0,0,($value)));
+	}
+	
+	function formatPercentage($value) {
+		
+		return number_format($value * 100, 2).'%';
+	}
+	
+	function formatCurrency($value) {
+	
+		return owa_lib::formatCurrency( $value, owa_coreAPI::getSetting( 'base', 'currencyLocal' ) );
+	}
+	
+	/**
+	 * Sets an individual label
+	 * return the key so that it can be nested
+	 * @return $key string
+	 */
+	function addLabel($key, $label) {
+		
+		$this->labels[$key] = $label;
+		return $key;
+	}
+	
+	function getLabel($key = '') {
+		
+		if (array_key_exists($key, $this->labels)) {
+			return $this->labels[$key];
+		} else {
+			//owa_coreAPI::debug("No label found for $key.");
+		}
+		
+	}
+	
+	/**
+	 * Retrieve the labels of the measures
+	 *
+	 */
+	function getLabels() {
+	
+		return $this->labels;
+	}
+	
+	/**
+	 * Sets an individual label
+	 * return the key so that it can be nested
+	 * @return $key string
+	 */
+	function setLabel($label) {
+		
+		$this->labels[$this->getName()] = $label;
+	}
+	
+	/**
+	 * Set the labels of the measures
+	 *
+	 */
+	function setLabels($array) {
+	
+		$this->labels = $array;
+	}
+		
+	function getPeriod() {
+	
+		return $this->params['period'];
+	}
+
+	function getLimit() {
+		
+		return $this->limit;
+	}
+	
+	/**
+	 * Adds a dimension to the dimension map
+	 * 
+	 * Retrieves dimension info from service layer and checks to see if 
+	 * dimension is denromalized or if it is a valid relation
+	 */
+	function setDimension($name) {
+		
+		if ($name) {
+			$this->dimensions[] = $name;
+		}
+	}
+	
+	function setDimensions($array) {
+		
+		if ($array) {
+		
+			foreach($array as $name) {
+				
+				$this->setDimension($name);
+			}	
+		}
+	}
+	
+	function dimensionsStringToArray($string) {
+		
+		// add string to query params array for use in URLs.
+		$this->query_params['dimensions'] = $string;
+		return explode(',', $string);
+	}
+	
+	function metricsStringToArray($string) {
+		
+		// add string to query params array for use in URLs.
+		$this->query_params['metrics'] = $string;
+		return explode(',', $string);
+	}
+
+	
+	function dimensionsArrayToString($array) {
+		
+		return implode(',', $array);
+	}
+	
+	/**
+	 * Applies dimensional sql to dao object
+	 */
+	function applyDimensions() {
+		
+		foreach ($this->dimensions as $dimension_name) {
+			$dim = $this->lookupDimension($dimension_name, $this->baseEntity);
+			// add column name to select statement
+			$this->db->selectColumn($dim['column'], $dim['name']);
+			// add groupby
+			$this->db->groupBy($dim['column']);
+			$this->addLabel($dim['name'], $dim['label']);
+		}
+	}
+	
+	function applyJoins() {
+		
+		foreach($this->related_dimensions as $dim) {
+			$this->addRelation($dim);
+		}		
+	}
+		
+	function addRelation($dim) {
+			
+			// if denomalized, skip
+			if ($dim['denormalized'] === true) {
+				return;
+			}
+			
+			// have already determined base enttiy at this point so use that.
+			$fk = $this->getDimensionForeignKey($dim, $this->baseEntity);
+			//print_r($fk);
+			//print $fk;
+			if ($fk) {
+				
+				// create dimension entity
+				$dimEntity = owa_coreAPI::entityFactory($dim['entity']);
+				// get foreign key column
+				//$bm = $this->getBaseMetric();
+				//$fpk_col = $bm->entity->getProperty($fk);
+				$fpk_col = $fk['entity']->getProperty($fk['col']);
+				//$fpk_col = $this->baseEntity->getProperty($fk['col']);
+
+				//print_r($fk['col']);
+				$fpk = $fpk_col->getForeignKey();
+				// add join
+				//print_r($fpk);
+				// needed to make joins unique in cases where there are 
+				// two joins onthe same table using different foreign keys.
+				$alias = $dimEntity->getTableAlias().'_via_'.$dim['foreign_key_name'];	
+				//$this->db->join(OWA_SQL_JOIN, $dimEntity->getTableName(), $dimEntity->getTableAlias(), $fk['entity']->getTableAlias().'.'.$fk['col'], $dimEntity->getTableAlias().'.'.$fpk[1]);
+				$this->db->join(OWA_SQL_JOIN, $dimEntity->getTableName(), $alias, $fk['entity']->getTableAlias().'.'.$fk['col'], $alias.'.'.$fpk[1]);
+				
+				//$this->addColumn($dim['name'], $dimEntity->getTableAlias().'.'.$dim['column']);
+				$this->addColumn($dim['name'], $alias.'.'.$dim['column']);
+
+			} else {
+				// add error result set
+				owa_coreAPI::debug(sprintf('%s metric does not have relation to dimension %s', $fk['entity']->getName(), $dim['name'])); 
+			}
+		
+	}
+	
+	// remove
+	function addMetric($metric_name, $child = false) {
+		
+		$ret = false;
+		
+		$m = $this->getMetric($metric_name);
+		
+		if (!$m) {
+			$m = owa_coreAPI::metricFactory($metric_name);
+		
+			if ($m) {
+			
+				
+				// necessary if the metric was first added as a child but later added as a parent.
+				if (!$child) {
+					
+					if (array_key_exists($metric_name, $this->childMetrics)) {
+						unset ($this->childMetrics[$metric_name]);
+					}
+				} else {
+					// add child metrics to child metric maps
+					// check to see if it wasn't already added as a non-child metric.
+					if (!array_key_exists($metric_name, $this->metrics)){
+						$this->childMetrics[$metric_name] = $metric_name;
+					}
+				}
+			
+				// check to see if this is a calculated metric
+				if ($m->isCalculated()) {
+					
+					return $this->addCalculatedMetric($m);
+				}
+			
+				if ($this->checkForFactTableRelation($m)) {
+			 		
+					$this->metrics[$metric_name] = $m;
+					$this->metricsByTable[$m->getTableName()] = $metric_name;
+					$this->addSelect($m->getSelect());
+					$this->addLabel($m->getName(), $m->getLabel());
+					
+					$ret = true;
+				}
+			
+			} else {
+				$this->addError("$metric_name is not a metric.");
+			}
+		} else {
+			$ret =  true;
+		}
+		
+		
+		
+		return $ret;		
+	}
+	
+	function addCalculatedMetric($calc_metric_obj) {
+		
+		// add label of calculated metric obj
+		$this->addLabel($calc_metric_obj->getName(),$calc_metric_obj->getLabel());
+		// add to calculated metric map
+		$this->calculatedMetrics[$calc_metric_obj->getName()] = $calc_metric_obj; 
+		
+	}
+	
+	function getCalculatedMetricByName($name) {
+		
+		return $this->calculatedMetrics[$name];
+	}
+	
+	function addSelect($select_array) {
+	
+		$this->params['selects'][] = $select_array; 
+	}
+	
+	function getSelects() {
+	
+		if (array_key_exists('selects', $this->params)) {
+			return $this->params['selects'];
+		}
+	}
+	
+	function applySelects() {
+		//print_r($this->metrics);
+		foreach($this->metrics as $k => $metric_name) {
+			
+			if (!array_key_exists($metric_name, $this->calculatedMetrics)) {
+			
+				$m = $this->metricObjectsByEntityMap[$this->baseEntity->getName()][$metric_name];
+						
+				$select = $m->getSelect();
+				//print_r ($select);
+				$this->db->selectColumn($select[0], $select[1]);
+			} else {
+				$m = $this->getCalculatedMetricByName($metric_name);
+			}
+			
+			$this->addLabel($m->getName(), $m->getLabel());
+		}
+		
+		// add selects for calculated metrics
+		if (!empty($this->calculatedMetrics)) {
+
+			// loop through calculated metric objects
+			foreach ($this->calculatedMetrics as $cmetric) {
+				//create child metrics
+				foreach( $cmetric->getChildMetrics() as $child_name) {
+					// check to see if the metric has already been added
+					if (!in_array($child_name, $this->metrics)) {
+					
+						$child = $this->metricObjectsByEntityMap[$this->baseEntity->getName()][$child_name];
+						$select = $child->getSelect();
+						//print_r ($select[0]);
+						$this->db->selectColumn($select[0], $select[1]);
+						// needed so we can remove this temp metric later
+						$this->childMetrics[] = $child_name;
+						owa_coreAPI::debug("Added $child_name to ChildMetrics array");
+					}
+				}
+			}
+		}
+	}
+	
+	function getFormat() {
+		
+		if (array_key_exists('result_format', $this->params)) {
+			return $this->params['result_format'];
+		}
+	}
+	
+	function getColumnName($string) {
+		
+		//$string = trim($string);
+		if (array_key_exists($string, $this->related_dimensions)) {
+			return $this->related_dimensions[$string]['column'];
+		}
+		
+		if (array_key_exists($string, $this->related_metrics)) {
+			return $string;
+		}
+		
+		
+		//return $string;
+		
+	}
+	
+	/**
+	 * Sets a metric's column name into the all_columns map
+	 *
+	 * this is needed when combining metrics so that sort and
+	 * constraint column names can be looked up fro ma single map.
+	 */
+	function addColumn($name, $col) {
+		
+		$this->all_columns[$name] = $col;
+	}
+	
+	function addError($msg) {
+		
+		$this->errors[] = $msg;
+		owa_coreAPI::debug($msg);
+	}
+	
+	/**
+	 * Generates a result set for the metric
+	 *
+	 */
+	function getResults() {
+		
+		// get paginated result set object
+		$rs = owa_coreAPI::supportClassFactory('base', 'paginatedResultSet');
+		
+		$bm = $this->chooseBaseEntity();
+				
+		if ($bm) {
+			
+			$bname = $bm->getName();
+		
+			owa_coreAPI::debug("Using $bname as base entity for making result set.");
+	
+			// set constraints
+			$this->applyJoins();
+			$this->applyConstraints();
+			$this->applySelects();
+		
+			$this->db->selectFrom($bm->getTableName(), $bm->getTableAlias());
+			// generate aggregate results
+			$results = $this->db->getOneRow();
+			// merge into result set
+			if ($results) {
+				$rs->aggregates = array_merge($this->applyMetaDataToSingleResultRow($results), $rs->aggregates);
+			}
+			
+			// setup dimensional query
+			if (!empty($this->dimensions)) {
+				$this->applyJoins();
+				// apply dimensional SQL
+				$this->applyDimensions();
+				
+				$this->applySelects();
+			
+				$this->db->selectFrom($bm->getTableName(), $bm->getTableAlias());
+				
+				// pass limit to db object if one exists
+				if (!empty($this->limit)) {
+					$rs->setLimit($this->limit);
+				}
+				// pass limit to db object if one exists
+				if (!empty($this->page)) {
+					$rs->setPage($this->page);
+				}
+				
+				$this->applyConstraints();
+				
+				if (array_key_exists('orderby', $this->params)) {
+					$sorts = $this->params['orderby'];
+					// apply sort by
+					if ($sorts) {
+						foreach ($sorts as $sort) {
+							$this->db->orderBy($sort[0], $sort[1]);
+							$rs->sortColumn = $sort[0];
+							if (isset($sort[1])){
+								$rs->sortOrder = strtolower($sort[1]);
+							} else {
+								$rs->sortOrder = 'asc';
+							}
+						}
+					}
+				}				
+				
+				// add labels
+				$rs->setLabels($this->getLabels());	
+			
+				// generate dimensonal results
+				$results = $rs->generate($this->db);
+				
+				$rs->resultsRows = $this->applyMetaDataToResults($results);
+			}
+			
+			// add labels
+			$rs->setLabels($this->getLabels());
+			
+			// add period info
+			
+			$rs->setPeriodInfo($this->params['period']->getAllInfo());
+			
+			$rs = $this->computeCalculatedMetrics($rs);
+			
+			// add urls
+			$urls = $this->makeResultSetUrls();
+			$rs->self = $urls['self'];
+			
+			if ($rs->more) {
+			
+				$rs->next = $urls['next'];
+			}
+			
+			if ($this->page >=2) {
+				$rs->previous = $urls['previous'];
+			}
+			
+			$rs->createResultSetHash();
+		}
+		
+		$rs->errors = $this->errors;
+				
+		return $rs;
+	}
+	
+	function computeCalculatedMetrics($rs) {
+		
+		foreach ($this->calculatedMetrics as $cm) {
+			
+			// add aggregate metric
+			$formula = $cm->getFormula();
+			$div_by_zero = false;
+			
+			foreach ($cm->getChildMetrics() as $metric_name) {
+				
+				$ag_value = $rs->getAggregateMetric($metric_name);
+				
+				if (empty($ag_value) || $ag_value == 0) {
+					$ag_value = 0;
+					$div_by_zero = true;
+				}
+				
+				$formula = str_replace($metric_name, $ag_value, $formula);
+			}
+			
+			if ( ! $div_by_zero ) {
+				$value = $this->evalFormula($formula);
+			} else {
+				$value = 0;
+			}
+			
+			$rs->setAggregateMetric($cm->getName(), $value, $cm->getLabel(), $cm->getDataType(), $this->formatValue($cm->getDataType(), $value));
+			
+			// add dimensional metric
+			
+			if ($rs->getRowCount() > 0) {
+				
+				foreach ($rs->resultsRows as $k => $row) {
+					
+					// add aggregate metric
+					$formula = $cm->getFormula();
+					$row_div_by_zero = false;
+					foreach ($cm->getChildMetrics() as $metric_name) {
+						
+						if (array_key_exists($metric_name, $row)) {
+							$row_value = $row[$metric_name]['value'];
+						} else {
+							$row_value = '';
+						}
+						if (empty($row_value) || $row_value == 0) {
+							$row_value = 0;
+							$row_div_by_zero = true;
+						}
+					
+						$formula = str_replace($metric_name, $row_value, $formula);	
+					
+					}
+					
+					if ( ! $row_div_by_zero ) {
+						$value = $this->evalFormula($formula);
+					} else {
+						$value = 0;
+					}
+					
+					$rs->appendRow($k, 'metric', $cm->getName(), $value, $cm->getLabel(), $cm->getDataType(), $this->formatValue($cm->getDataType(), $value));
+				}
+			}
+			
+			foreach ($this->childMetrics as $metric_name) {
+				
+				$rs->removeMetric($metric_name);
+			}
+			
+		}
+		
+		return $rs;
+	}
+	
+	function evalFormula($formula) {
+		
+		//safety first. should only be computing numbers.
+			$formula = str_replace('$','', $formula);
+			
+			// need parens and @ to handle divsion by zero errors
+			$formula = '$value = ('.$formula.');';
+			//print $formula;
+			// calc
+			@ eval($formula);
+			
+			if (!$value) {
+				$value = 0;
+			}
+			
+			return $value;
+	}
+	
+	function getMetric($name) {
+		
+		if (in_array($name, $this->metrics)) {
+			return $this->metricObjectsByEntityMap[$this->baseEntity->getName()][$name];
+		} 
+	}
+	
+	function setQueryStringParam($name, $string) {
+		
+			$this->query_params[$name] = $string;
+	}
+	
+	function makeResultSetUrls() {
+		
+		$urls = array();
+		// get api url
+		$api_url = owa_coreAPI::getSetting('base', 'api_url');
+		// get base query params
+		$query_params = $this->query_params;
+		// add api command
+		$query_params['do'] = 'getResultSet';
+		//add format
+		if ($this->format) {
+			$query_params['format'] = $this->format;
+		} else {
+			$query_params['format'] = 'json';
+		}
+		// add current page if any
+		if ($this->page) {
+			$query_params['page'] = $this->page;
+		}
+		// add limit
+		if ($this->limit) {
+			$query_params['resultsPerPage'] = $this->limit;
+		}
+		
+		// build url for this result set
+		$link_template = owa_coreAPI::getSetting('base', 'link_template');
+		$q = $this->buildQueryString($query_params);
+		$urls['self'] = sprintf($link_template, $api_url, $q);
+		
+		// build url for next page of result set
+		$next_query_params = $query_params;
+		if ($this->page) {
+			$next_query_params['page'] = $query_params['page'] + 1;
+		} else {
+			$next_query_params['page'] = 2;
+		} 
+		
+		$nq = $this->buildQueryString($next_query_params);
+		$urls['next'] = sprintf($link_template, $api_url, $nq);
+		
+		// build previous url if page is greater than 2	
+		if ($this->page >= 2) {
+			$previous_query_params = $query_params;
+			$previous_query_params['page'] = $query_params['page'] - 1;
+			$pq = $this->buildQueryString($previous_query_params);
+			$urls['previous'] = sprintf($link_template, $api_url, $pq);
+		}
+		
+		$base_query_params = $this->query_params;
+		$base_query_params['format'] = $this->format;
+		
+		// build pagination url template for use in constructing 
+		$q = $this->buildQueryString($base_query_params);
+		$url['base_url'] = sprintf($link_template, $api_url, $q);
+		
+		return $urls;
+	}
+	
+	function buildQueryString($params, $seperator = '&') {
+		
+		$new = array();
+		//get namespace
+		$ns = owa_coreAPI::getSetting('base', 'ns');
+		foreach ($params as $k => $v) {
+			
+			$new[$ns.$k] = $v;
+		}
+		
+		return http_build_query($new,'', $seperator);
+	}
+
+}
+
+?>