<?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_DIR.'/owa_lib.php');

/**
 * OWA Core API
 * 
 * @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.0.0
 */

class owa_coreAPI {
		
	public static function &singleton($params = array()) {
		
		static $api;
		
		if(!isset($api)):
			$api = new owa_coreAPI();
		endif;
		
		if(!empty($params)):
			$api->params = $params;
		endif;
		
		return $api;
	}
	
	public static function setupStorageEngine($type) {
	
		if (!class_exists('owa_db')) {
			require_once(OWA_BASE_CLASSES_DIR.'owa_db.php');
		}
		
		if ($type) {
			
		$connection_class = "owa_db_" . $type;
		
			if (!class_exists($connection_class)) {
				$connection_class_path = OWA_PLUGINS_DIR.'/db/' . $connection_class . ".php";
		
			 	if (!require_once($connection_class_path)) {
			 		owa_coreAPI::error(sprintf('Cannot locate proper db class at %s.', $connection_class_path));
			 		return false;
				}
			}
		
		}
		
	 	return true;

	}
	
	public static function &dbSingleton() {
		
		static $db;
	
		if (!isset($db)) {
			
			$db_type = owa_coreAPI::getSetting('base', 'db_type');
			$ret = owa_coreAPI::setupStorageEngine($db_type);
	
		 	if (!$ret) {
		 		owa_coreAPI::error(sprintf('Cannot locate proper db class at %s. Exiting.', $connection_class_path));
		 		return;
			} else { 	
				$connection_class = 'owa_db_'.$db_type;
				$db = new $connection_class(
					owa_coreAPI::getSetting('base','db_host'), 
					owa_coreAPI::getSetting('base','db_name'),
					owa_coreAPI::getSetting('base','db_user'),
					owa_coreAPI::getSetting('base','db_password'),
					owa_coreAPI::getSetting('base','db_force_new_connections'),
					owa_coreAPI::getSetting('base','db_make_persistant_connections')
				);	
			}
		}
		
		return $db;
	}
		
	public static function &configSingleton($params = array()) {
		
		static $config;
		
		if(!isset($config)):
			
			if (!class_exists('owa_settings')):
				require_once(OWA_BASE_CLASS_DIR.'settings.php');
			endif;
			
			$config = owa_coreAPI::supportClassFactory('base', 'settings');
			
		endif;
		
		return $config;
	}
	
	public static function &errorSingleton() {
		
		static $e;
		
		if(!$e) {
			
			if (!class_exists('owa_error')):
				require_once(OWA_BASE_CLASS_DIR.'error.php');
			endif;
			
			$e = owa_coreAPI::supportClassFactory('base', 'error');
			
		}
		
		return $e;
	}
	
	public static function getSetting($module, $name) {
		
		$s = &owa_coreAPI::configSingleton();
		return $s->get($module, $name);
	}
	
	public static function setSetting($module, $name, $value, $persist = false) {
		
		$s = &owa_coreAPI::configSingleton();
		
		if ($persist === true) {
			$s->persistSetting($module, $name, $value);
		} else {
			$s->setSetting($module, $name, $value);
		}
		
	}
	
	public static function persistSetting($module, $name, $value) {
		
		$s = &owa_coreAPI::configSingleton();
		$s->persistSetting($module, $name, $value);
		
	}
	
	public static function getSiteSetting($site_id, $name) {
		
		$site = owa_coreAPI::entityFactory('base.site');
		$site->load( $site->generateId( $site_id ) );
		if ( $site->wasPersisted() ) {
		
			$settings = $site->get('settings');
			if (!empty($settings)) {
				if ( array_key_exists($name, $settings) ) {
					return $settings[$name];
				}
			}			
		}
	}
	
	public static function persistSiteSetting($site_id, $name, $value) {
		
		$site = owa_coreAPI::entityFactory('base.site');
		$site->load( $site->generateId( $site_id ) );
		if ( $site->wasPersisted() ) {
			$settings = $site->get('settings');
			if ( ! $settings ) {
				$settings = array();
			}
			$settings[$name] = $value;
			$site->set('settings', $settings);	
			$site->update();
		}
	}
	
	public static function getSiteSettings($site_id) {
		
		$site = owa_coreAPI::entityFactory('base.site');
		$site->load( $site->generateId( $site_id ) );
		if ( $site->wasPersisted() ) {
		
			$settings = $site->get('settings');
			
			if ( $settings ) {
				return $settings;
			} else {
				return array();
			}
		}
		
	}
	
	public static function getAllRoles() {
		
		$caps = owa_coreAPI::getSetting('base', 'capabilities');
		return array_keys($caps);
	}
	
	public static function &getCurrentUser() {
		
		$s = &owa_coreAPI::serviceSingleton();
		return $s->getCurrentUser();
	}
	
	/**
	 * check to see if the current user has a capability
	 * always returns a bool
	 */
	public static function isCurrentUserCapable($capability) {
		
		$cu = &owa_coreAPI::getCurrentUser();
		owa_coreAPI::debug("Current User Role: ".$cu->getRole());
		owa_coreAPI::debug("Current User Authentication: ".$cu->isAuthenticated());
		$ret = $cu->isCapable($capability);
		owa_coreAPI::debug("Is current User capable: ".$ret);
		return $ret;
	}
	
	public static function isCurrentUserAuthenticated() {
		
		$cu = &owa_coreAPI::getCurrentUser();
		return $cu->isAuthenticated();
	}
	
	public static function &serviceSingleton() {
		
		static $s;
		
		if(empty($s)) {
			
			if (!class_exists('owa_service')) {
				require_once(OWA_BASE_CLASS_DIR.'service.php');
			}
			
			$s = owa_coreAPI::supportClassFactory('base', 'service');
			
		}
		
		return $s;
	}
	
	public static function &cacheSingleton($params = array()) {
		
		static $cache;
		
		if ( !isset ( $cache ) ) {
			$cache_type = owa_coreAPI::getSetting('base', 'cacheType');
			
			switch ($cache_type) {
				
				case "memcached":
					$implementation = array('owa_memcachedCache', OWA_BASE_CLASS_DIR.'memcachedCache.php');
					break;
				default:
					$implementation = array('owa_fileCache', OWA_BASE_CLASS_DIR.'fileCache.php');
					
			}
			
			if ( ! class_exists( $implementation[0] ) ) {
				require_once( $implementation[1] );
			}
			// make this plugable
			$cache = new $implementation[0];		
		}
		
		return $cache;
	}
	
	public static function requestContainerSingleton() {
	
		static $request;
		
		if(!isset($request)):
			
			if (!class_exists('owa_requestContainer')):
				require_once(OWA_DIR.'owa_requestContainer.php');
			endif;
			
			$request = owa_lib::factory(OWA_DIR, '', 'owa_requestContainer');
			
		endif;
		
		return $request;
	
	}
		
	public static function moduleRequireOnce($module, $class_dir, $file) {
		
		if (!empty($class_dir)) {
		
			$class_dir .= DIRECTORY_SEPARATOR;
			
		}
		
		$full_file_path = OWA_BASE_DIR.'/modules/'.$module.DIRECTORY_SEPARATOR.$class_dir.$file.'.php';
		
		if (file_exists($full_file_path)) {
			return require_once($full_file_path);
		} else {
			owa_coreAPI::debug("moduleRequireOnce says no file found at: $full_file_path");
			return false;
		}
	}
	
	public static function moduleFactory($modulefile, $class_suffix = null, $params = '', $class_ns = 'owa_') {
		
		list($module, $file) = explode(".", $modulefile);
		$class = $class_ns.$file.$class_suffix;
		//print $class;
		// Require class file if class does not already exist
		if(!class_exists($class)):	
			owa_coreAPI::moduleRequireOnce($module, '', $file);
		endif;
			
		$obj = owa_lib::factory(OWA_BASE_DIR.'/modules/'.$module, '', $class, $params);
		
		//if (isset($obj->module)):
			$obj->module = $module;
		//endif;
		
		return $obj;
	}
	
	public static function moduleGenericFactory($module, $sub_directory, $file, $class_suffix = null, $params = '', $class_ns = 'owa_') {
		
		$class = $class_ns.$file.$class_suffix;
	
		// Require class file if class does not already exist
		if(!class_exists($class)):	
			owa_coreAPI::moduleRequireOnce($module, $sub_directory, $file);
		endif;
			
		$obj = owa_lib::factory(OWA_DIR.'modules'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$sub_directory, '', $class, $params);
		
		return $obj;
	}
	
	/**
	 * Produces Module Classes (module.php)
	 *  
	 * @return Object module class object
	 */
	public static function moduleClassFactory($module) {
		
		if (!class_exists('owa_module')):
			require_once(OWA_BASE_CLASSES_DIR.'owa_module.php');
		endif;
			
		require_once(OWA_BASE_DIR.'/modules/'.$module.'/module.php');
			
		return owa_lib::factory(OWA_BASE_CLASSES_DIR.$module, 'owa_', $module.'Module');
		
	}

	
	public static function updateFactory($module, $filename, $class_ns = 'owa_') {
	
		require_once(OWA_BASE_CLASS_DIR.'update.php');
		
		//$obj = owa_coreAPI::moduleGenericFactory($module, 'updates', $filename, '_update');
		$class = $class_ns.$module.'_'.$filename.'_update';
	
		// Require class file if class does not already exist
		if(!class_exists($class)):	
			owa_coreAPI::moduleRequireOnce($module, 'updates', $filename);
		endif;
			
		$obj = owa_lib::factory(OWA_DIR.'modules'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.'updates', '', $class);

		$obj->module_name = $module;
		if (!$obj->schema_version) {
			$obj->schema_version = $filename;
		}
		return $obj;
	}
		
	public static function subViewFactory($subview, $params = array()) {
		
		list($module, $class) = explode(".", $subview);
		//print_r($module.' ' . $class);
		//owa_lib::moduleRequireOnce($module, $class);
	
		$subview =  owa_lib::moduleFactory($subview, 'View', $params);
		$subview->is_subview = true;
		
		return $subview;
	}
	
	public static function &supportClassFactory($module, $class, $params = array(),$class_ns = 'owa_') {
		
		$obj = &owa_lib::factory(OWA_BASE_DIR.DIRECTORY_SEPARATOR.'modules'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.'classes'.DIRECTORY_SEPARATOR, $class_ns, $class, $params);
		$obj->module = $module;
		
		return $obj;
		
		
	}
	
	/**
	 * Convienence method for generating entities
	 *
	 * @param unknown_type $entity_name
	 * @return unknown
	 */
	public static function entityFactory($entity_name) {
		
		/* SETUP STORAGE ENGINE */
		
		// Must be called before any entities are created
		
		if (!defined('OWA_DTD_INT')) {
			if (defined('OWA_DB_TYPE')) {
				owa_coreAPI::setupStorageEngine(OWA_DB_TYPE);
			} else {
				owa_coreAPI::setupStorageEngine('mysql');
			}
				
		}
		
		
			
		if (!class_exists('owa_entity')):
			require_once(OWA_BASE_CLASSES_DIR.'owa_entity.php');	
		endif;
			
		$entity = owa_coreAPI::moduleSpecificFactory($entity_name, 'entities', '', '', false);
		$entity->name = $entity_name;
		return $entity;
		//return owa_coreAPI::supportClassFactory('base', 'entityManager', $entity_name);
		
	}
	
	/**
	 * Convienence method for generating entities
	 *
	 * @param unknown_type $entity_name
	 * @return unknown
	 * @depricated
	 * @todo REMOVE
	 */
	public static function rawEntityFactory($entity_name) {
			
		return owa_coreAPI::entityFactory($entity_name);
				
	}
	
	/**
	 * Factory for generating module specific classes
	 *
	 * @param string $modulefile
	 * @param string $class_dir
	 * @param string $class_suffix
	 * @param array $params
	 * @return unknown
	 */
	public static function moduleSpecificFactory($modulefile, $class_dir, $class_suffix = null, $params = '', $add_module_name = true, $class_ns = 'owa_') {
		
		list($module, $file) = explode(".", $modulefile);
		$class = $class_ns.$file.$class_suffix;
		
		// Require class file if class does not already exist
		if(!class_exists($class)):	
			owa_coreAPI::moduleRequireOnce($module, $class_dir, $file);
		endif;
			
		$obj = owa_lib::factory(OWA_BASE_DIR.DIRECTORY_SEPARATOR.'modules'.DIRECTORY_SEPARATOR.$class_dir.DIRECTORY_SEPARATOR.$module, '', $class, $params);
		
		if ($add_module_name == true):
			$obj->module = $module;
		endif;
		
		return $obj;
		
		
	}
	
	public static function executeApiCommand($map) {
		
		if (!array_key_exists('do', $map)) {
			echo ("API Command missing from request.");
			owa_coreAPI::debug('API Command missing from request. Aborting.');
			exit;
		} else {
			// load service
			$s = owa_coreAPI::serviceSingleton();
			// lookup method class
			$do = $s->getApiMethodClass($map['do']);
				
		}
		
		// if exists, pass to OWA as a request
		if ($do) {
				
			if (array_key_exists('args', $do)) {
				
				$passed_args = array();
				
				foreach ($do['args'] as $arg) {
					
					if (isset($map[$arg])) {
						$passed_args[] = $map[$arg];
					} else {
						$passed_args[] = '';
					}
				}
				
				if (!empty($do['file'])) {
					
					if (!class_exists($do['callback'][0])) {
						require_once($file);
					}
				}
				
				$something = call_user_func_array($do['callback'], $passed_args);
			}	
			
			return $something;
		} else {
			echo "No API Method Found.";
		}

	}
	
	/**
	 * Convienence method for generating metrics
	 *
	 * @param unknown_type $entity_name
	 * @return unknown
	 */
	public static function metricFactory($metric_name, $params = array()) {
		
		if (!strpos($metric_name, '.')) {
			$s = owa_coreAPI::serviceSingleton();
			$metric_name = $s->getMetricClasses($metric_name);
		}
		
		if (!class_exists('owa_metric')) {
			require_once(OWA_BASE_CLASSES_DIR.'owa_metric.php');	
		}
		
		return owa_coreAPI::moduleSpecificFactory($metric_name, 'metrics', '', $params, false);
	}
	
	/**
	 * Returns a consolidated list of admin/options panels from all active modules 
	 *
	 * @return array
	 */
	public static function getAdminPanels() {
		
		$panels = array();
		
		$service = owa_coreAPI::serviceSingleton();
		
		foreach ($service->modules as $k => $v) {
			$v->registerAdminPanels();
			$module_panels = $v->getAdminPanels();
			if ($module_panels) {
				foreach ($module_panels as $key => $value) {
					
					$panels[$value['group']][] = $value;
				}
			}			
		}
		
		return $panels;
	}
	
	/**
	 * Returns a consolidated list of nav links from all active modules for a particular view
	 * and named navigation element.
	 *
	 * @param string nav_name the name of the navigation element that you want links for
	 * @param string sortby the array value to sort the navigation array by
	 * @return array
	 */
	public static function getNavigation($view, $nav_name, $sortby ='order') {
		
		$links = array();
		
		$service = owa_coreAPI::serviceSingleton();
		
		foreach ($service->modules as $k => $v) {
			
			// If the module does not have nav links, register them. needed in case this function is called twice on
			// same view.
			if (empty($v->nav_links)):
				$v->registerNavigation();
			endif;		
			
			$module_nav = $v->getNavigationLinks();
			
	
			if (!empty($module_nav)) {
				// assemble the navigation for a specific view's named navigation element'	
				foreach ($module_nav as $key => $value) {
					
					$links[$value['view']][$value['nav_name']][] = $value;
				}
			}
			
		}
		
		//print_r($links[$view][$nav_name]);
		if (!empty($links[$view][$nav_name])):
			// anonymous sorting function, takes sort by variable.
			$code = "return strnatcmp(\$a['$sortby'], \$b['$sortby']);";
	   		
	   		// sort the array
	   		$ret = usort($links[$view][$nav_name], create_function('$a,$b', $code));
			
			return $links[$view][$nav_name];
		else: 
			return false;
		endif;
		 
	}
	
	public static function getGroupNavigation($group, $sortby ='order') {
	
		$links = array();
		
		$service = owa_coreAPI::serviceSingleton();
		
		foreach ($service->modules as $k => $v) {
			
			// If the module does not have nav links, register them. needed in case this function is called twice on
			// same view.
			if (empty($v->nav_links)):
				$v->registerNavigation();
			endif;		
			
			$module_nav = $v->getNavigationLinks();
			
			if (!empty($module_nav)):
				//loop through returned nav array
				foreach ($module_nav as $group => $nav_links) {
					
					foreach ($nav_links as $link) {	
									
						if (array_key_exists($group, $links)):
							
							// check to see if link is already present in the main array
							if (array_key_exists($link['anchortext'], $links[$group])):
								// merge various elements?? not now.
								//check to see if there is an existing subgroup
								
								if (array_key_exists('subgroup', $links[$group][$link['anchortext']])):
									// if so, merge the subgroups
									$links[$group][$link['anchortext']]['subgroup'] = array_merge($links[$group][$link['anchortext']]['subgroup'], $link['subgroup']);
								endif;	
							else:
								// else populate the link
								$links[$group][$link['anchortext']] = $link;	
							endif;
							
						else:
							$links[$group][$link['anchortext']] = $link;
						endif;
					}					
					
				}
			endif;
			
		}
		
		return $links[$group];	
	}
	
	/**
	 * @Todo REMOVE
	 */
	public static function getNavSort($a, $b) {
		
		return strnatcmp($a['order'], $b['order']);
	}
	
		
	public static function getActiveModules() {
	
		$c = owa_coreAPI::configSingleton();
		$config = $c->config->get('settings');
		
		//print_r($config);
		$active_modules = array();
		
		foreach ($config as $k => $module) {
			
			if ($module['is_active'] == true):
				$active_modules[] = $k;
			endif;
		}

		return $active_modules;
	
	}
	
	public static function getModulesNeedingUpdates() {
	
		$service = owa_coreAPI::serviceSingleton();
		
		return $service->getModulesNeedingUpdates();
	}
	
	/**
	 * Invokes controller to perform controller
	 *
	 * @param $action string
	 * 
	 */
	public static function performAction($action, $params = array()) {
		
		// Load 
		$controller = owa_coreAPI::moduleFactory($action, 'Controller', $params);
		
		if (!$controller || !method_exists($controller, 'doAction')) {
			owa_coreAPI::debug("No controller is associated with $action.");
			return;
		}
		
		$data = $controller->doAction();
						
		// Display view if controller calls for one.
		if (!empty($data['view']) || !empty($data['action'])):
		
			// 
			if ($data['view_method'] == 'delegate'):
				return owa_coreAPI::displayView($data);
			
			// Redirect to a view	
			elseif ($data['view_method'] == 'redirect'):
				owa_lib::redirectToView($data);
				return;
				
			// return an image . Will output headers and binary data.
			elseif ($data['view_method'] == 'image'):
				return owa_coreAPI::displayImage($data);
			
			else:
				return owa_coreAPI::displayView($data);
				
			endif;
		
		elseif(!empty($data['do'])):
			//print_r($data);
			owa_lib::redirectToView($data);
			return;
			
		endif;
	}
	
	/**
	 * Logs an event to the event queue
	 *
	 * take an owa_event object as a message.
	 *
	 * @param string $event_type
	 * @param object $message
	 * @return boolean
	 */
	public static function logEvent($event_type, $message = '') {
		
		// debug
		owa_coreAPI::debug("logging event $event_type");
		
		if (owa_coreAPI::getSetting('base', 'error_log_level') > 9) {
			owa_coreAPI::debug("PHP Server Global: ".print_r($_SERVER, true));
		}
			
		// Check to see if named users should be logged		
		if (owa_coreAPI::getSetting('base', 'log_named_users') != true) {
			$cu = owa_coreAPI::getCurrentUser();	
			$cu_user_id = $cu->getUserData('user_id');
			
			if(!empty($cu_user_id)) {
				return false;
			}
		}
		
		// do not log if the request is robotic
		$service = &owa_coreAPI::serviceSingleton();
		$bcap = $service->getBrowscap();
		owa_coreAPI::profile(__CLASS__, __FUNCTION__, __LINE__);
		if (!owa_coreAPI::getSetting('base', 'log_robots')) {
			
			if ($bcap->robotCheck()) {
				owa_coreAPI::debug("ABORTING: request appears to be from a robot");
				owa_coreAPI::setRequestParam('is_robot', true);
				return;
			}
			owa_coreAPI::profile(__CLASS__, __FUNCTION__, __LINE__);
		}
		
		$service->setBrowscap($bcap);
		
		// form event if one was not passed
		$class= 'owa_event';
		if (!($message instanceof $class)) {
			$event = owa_coreAPI::supportClassFactory('base', 'event');
			$event->setProperties($message);
			$event->setEventType($event_type);
		} else {
			$event = $message;
		}
								
		// Filter XSS exploits from event properties
		$event->cleanProperties();
		
		// do not log if the do not log property is set on the event.
		if ($event->get('do_not_log')) {
			return false;
		}
		
		// lookup which event processor to use to process this event type
		$processor_action = owa_coreAPI::getEventProcessor($event->getEventType());
		
		return owa_coreAPI::handleRequest(array('event' => $event), $processor_action);
	}

	
	public static function displayImage($data) {
		
		header('Content-type: image/gif');
		header('P3P: CP="'.owa_coreAPI::getSetting('base', 'p3p_policy').'"');
		header('Expires: Sat, 22 Apr 1978 02:19:00 GMT');
		header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
		header('Cache-Control: no-store, no-cache, must-revalidate');
		header('Cache-Control: post-check=0, pre-check=0', false);
		header('Pragma: no-cache');
		
		echo owa_coreAPI::displayView($data);		
	}
	
	
	/**
	 * Displays a View without user authentication. Takes array of data as input
	 *
	 * @param array $data
	 * @param string $viewfile a specific view file to use
	 * @return string
	 * 
	 */
	public static function displayView($data, $viewfile = '') {
		
		if (empty($viewfile)):
			$viewfile = $data['view'];
		endif;
		
		$view = owa_coreAPI::moduleFactory($viewfile, 'View');
		$view->setData($data);
		return $view->assembleView($data);
		
	}
	
	public static function displaySubView($data, $viewfile = '') {
		
		if (empty($viewfile)):
			$viewfile = $data['view'];
		endif;
		
		$view =  owa_coreAPI::subViewFactory($viewfile);
		
		return $view->assembleView($data);
		
	}
	
	/**
	 * Strip a URL of certain GET params
	 * @depricated
	 * @return string
	 * @todo REMOVE
	 */
	function stripDocumentUrl($url) {
		
		if (owa_coreAPI::getSetting('base', 'clean_query_string')):
		
			if (owa_coreAPI::getSetting('base', 'query_string_filters')):
				$filters = str_replace(' ', '', owa_coreAPI::getSetting('base', 'query_string_filters'));
				$filters = explode(',', $filters);
			else:
				$filters = array();
			endif;
			
			// OWA specific params to filter
			array_push($filters, owa_coreAPI::getSetting('base', 'source_param'));
			array_push($filters, owa_coreAPI::getSetting('base', 'ns').owa_coreAPI::getSetting('base', 'feed_subscription_param'));
			
			//print_r($filters);
			
			foreach ($filters as $filter => $value) {
				
	          $url = preg_replace(
	            '#\?' .
	            $value .
	            '=.*$|&' .
	            $value .
	            '=.*$|' .
	            $value .
	            '=.*&#msiU',
	            '',
	            $url
	          );
	          
	        }
		
	    endif;
     	//print $url;
     	
     	return $url;
		
	}
	
	public static function getRequestParam($name) {
		
		$service = &owa_coreAPI::serviceSingleton();
		return $service->request->getParam($name);
		
	}
	
	public static function getRequest() {
		$service = &owa_coreAPI::serviceSingleton();
		return $service->request;
	}
	
	public static function setRequestParam($name, $value) {
		
		$service = &owa_coreAPI::serviceSingleton();
		return $service->request->setParam($name, $value);
		
	}
	
	public static function makeTimePeriod($time_period, $params = array()) {
		
		$period = owa_coreAPI::supportClassFactory('base', 'timePeriod');
		$map = array();
		
		if (array_key_exists('startDate', $params)) {
			$map['startDate'] = $params['startDate'];			
		}
		
		if (array_key_exists('endDate', $params)) {
			$map['endDate'] = $params['endDate'];
		}
		
		if (array_key_exists('startTime', $params)) {
			$map['startTime'] = $params['startTime'];			
		}
		
		if (array_key_exists('endTime', $params)) {
			$map['endTime'] = $params['endTime'];
		}
		
		$period->set($time_period, $map);
		
		return $period;
	}

	/**
	 * Factory method for producing validation objects
	 * 
	 * @return Object
	 */
	public static function validationFactory($class_file) {
		
		if (!class_exists('owa_validation')):
			require_once(OWA_BASE_CLASS_DIR.'validation.php');
		endif;
		
		return owa_lib::factory(OWA_PLUGINS_DIR.'/validations', 'owa_', $class_file, array(), 'Validation');
		
	}
	
	public static function debug($msg) {
		
		$e = owa_coreAPI::errorSingleton();
		$e->debug($msg);
		return;
	}
	
	public static function error($msg) {
		
		$e = owa_coreAPI::errorSingleton();
		$e->err($msg);
		return;
	}
	
	public static function notice($msg) {
		
		$e = owa_coreAPI::errorSingleton();
		$e->notice($msg);
		return;
	}
	
	public static function createCookie($cookie_name, $cookie_value, $expires = 0, $path = '/', $domain = '') {
		
		if ( $domain ) {
			// sanitizes the domain
			$domain = owa_lib::sanitizeCookieDomain( $domain );
		} else {
			$domain = owa_coreAPI::getSetting('base', 'cookie_domain');
		}	
		if (is_array($cookie_value)) {
			
			$cookie_value = owa_lib::implode_assoc('=>', '|||', $cookie_value);
		}
		
		// add namespace
		$cookie_name = sprintf('%s%s', owa_coreAPI::getSetting('base', 'ns'), $cookie_name);
		
		// debug
		owa_coreAPI::debug(sprintf('Setting cookie %s with values: %s under domain: %s', $cookie_name, $cookie_value, $domain));
		
		// set compact privacy header
		header(sprintf('P3P: CP="%s"', owa_coreAPI::getSetting('base', 'p3p_policy')));
		//owa_coreAPI::debug('time: '.$expires);
		setcookie($cookie_name, $cookie_value, $expires, $path, $domain);
		return;
	}
	
	public static function deleteCookie($cookie_name, $path = '/', $domain = '') {
	
		return owa_coreAPI::createCookie($cookie_name, false, time()-3600*25, $path, $domain);
	}
	
	public static function setState($store, $name = '', $value, $store_type = '', $is_perminent = '') {
		
		$service = &owa_coreAPI::serviceSingleton();
		return $service->request->state->set($store, $name, $value, $store_type, $is_perminent);
	}
	
	public static function getStateParam($store, $name = '') {
		
		$service = &owa_coreAPI::serviceSingleton();
		return $service->request->state->get($store, $name);	
	}
	
	public static function getServerParam($name = '') {
		
		$service = &owa_coreAPI::serviceSingleton();
		return $service->request->getServerParam($name);	
	}
	
	public static function clearState($store) {
		
		$service = &owa_coreAPI::serviceSingleton();
		$service->request->state->clear($store); 
				
	}
	
	public static function getEventProcessor($event_type) {
		
		$service = &owa_coreAPI::serviceSingleton();
		$processor = $service->getMapValue('event_processors', $event_type);
		
		if (empty($processor)) {
		
			$processor = 'base.processEvent';
		}
		
		return $processor;
	}
	
	/**
	 * Handles OWA internal page/action requests
	 *
	 * @return unknown
	 */
	public static function handleRequest($caller_params = null, $action = '') {
		
		static $init;
		
		$service = &owa_coreAPI::serviceSingleton();
		// Override request parsms with those passed by caller
		if (!empty($caller_params)) {
			$service->request->mergeParams($caller_params);
		};
		
		$params = $service->request->getAllOwaParams();
		
		if ($init != true) {
			owa_coreAPI::debug('Handling request with params: '. print_r($params, true));
		}
		
		// backwards compatability with old style view/controler scheme
		// still needed??
		if (array_key_exists('view', $params)) {
			// its a view request so the only data is in whats in the params
			$init = true;
			return owa_coreAPI::displayView($params);
		} 
	
		if (empty($action)) {
			$action = owa_coreAPI::getRequestParam('action');
			if (empty($action)) {
				$action = owa_coreAPI::getRequestParam('do');
				
				if (empty($action)) {
					$action = owa_coreAPI::getSetting('base', 'start_page');
				}	
			}
		}
		
		$init = true;
		owa_coreAPI::debug('About to perform action: '.$action);
		return owa_coreAPI::performAction($action, $params);
						
	}
	
	public static function isUpdateRequired() {
		
		$service = &owa_coreAPI::serviceSingleton();
		return $service->isUpdateRequired();
	}
	
	public static function getSitesList() {
		
		//$s = owa_coreAPI::entityFactory('base.site');
		$db = owa_coreAPI::dbSingleton();
		$db->selectFrom('owa_site');
		$db->selectColumn('*');
        $db->orderBy('name');
		return $db->getAllRows();
		
	}
	
	public static function profile($that = '', $function = '', $line = '', $msg = '') {
	
		if (defined('OWA_PROFILER')) {
			if (OWA_PROFILER === true) {
			
				static $profiler;
						
				if (!class_exists('PhpQuickProfiler')) {
					require_once(OWA_INCLUDE_DIR.'pqp/classes/PhpQuickProfiler.php');
				}
				
				if (empty($profiler)) {
					$profiler = new PhpQuickProfiler(PhpQuickProfiler::getMicroTime(), OWA_INCLUDE_DIR.'pqp/');
				}
				
				$class = get_class($that);
				Console::logSpeed($class."::$function - Line: $line - Msg: $msg");
				Console::logMemory($that, $class. "::$function - Line: $line");
				
				return $profiler;
			}
		}
	}
	
	public static function profileDisplay() {
		$p = owa_coreAPI::profile();
		if ($p) {
			$p->display();
		}
		
	}
	
	public static function getEventDispatch() {
		
		if (!class_exists('eventQueue')) {
			require_once(OWA_DIR.'/eventQueue.php');
		}

		$eq = &eventQueue::get_instance();
		return $eq;
	}
	
	public static function getCliCommandClass($command) {
		
		$s = owa_coreAPI::serviceSingleton();
		return $s->getCliCommandClass($command);
	}
	
	public static function getGeolocationFromIpAddress($ip_address) {
		
		$s = &owa_coreAPI::serviceSingleton();
		$s->geolocation->getGeolocationFromIp($ip_address);
		return $s->geolocation;
	}
	
	public static function getNonceTimeInterval() {
		
		return  ceil( time() / owa_coreAPI::getSetting( 'base', 'nonce_expiration_period') );
	}
	
	public static function createNonce($action) {
		
		$time = owa_coreAPI::getNonceTimeInterval();
		$cu = owa_coreAPI::getCurrentUser();
		$user_id = $cu->getUserData( 'user_id' );
		$full_nonce = $time . $action . $user_id . 'owa_nonce';
		$nonce = substr(md5($full_nonce), -12, 10);
		
		return $nonce;
	}
	
	public static function summarize($map) {
		
		$entity = owa_coreAPI::entityFactory($map['entity']);
		$db = owa_coreAPI::dbSingleton();
		$db->selectFrom($entity->getTableName(), $entity->getTableAlias());
		
		foreach ($map['columns'] as $col => $action) {
			
			switch ($action) {
				
				case 'sum':
					$col_def = sprintf("SUM(%s)", $col);
					$name = $col.'_sum';
					break;
				case 'count':
					$col_def = sprintf("COUNT(%s)", $col);
					$name = $col.'_count';
					break;
				case 'count_distinct':
					$col_def = sprintf("COUNT(distinct %s)", $col);
					$name = $col.'_dcount';
					break;
			}
			
			$db->selectColumn($col_def, $name);
		}
		
		foreach ($map['constraints'] as $con_col => $con_value) {
			
			if ( is_array( $con_value ) ) {
				$db->where($con_col, $con_value['value'], $con_value['operator']);
			} else {
				$db->where($con_col, $con_value);
			}
		}
		
		$ret = $db->getOneRow();
		return $ret;
	}
	
	public static function getJsTrackerTag( $site_id, $options = array() ) {
		
		if ( ! class_exists( 'owa_template' ) ) {
			require_once(OWA_BASE_CLASSES_DIR.'owa_template.php');
		}
		
		$t = new owa_template();
		
		//check to see if we shuld log clicks.
		if ( ! owa_coreAPI::getSetting( 'base', 'log_dom_clicks' ) ) {
			$options['do_not_log_clicks'] = true;
		}

		if ( ! owa_coreAPI::getSetting( 'base', 'log_dom_streams' ) ) {
			$options['do_not_log_domstream'] = true;
		}
		
		if (owa_coreAPI::getSetting('base', 'is_embedded')) {
			
			// needed to override the endpoint used by the js tracker
			$options['apiEndpoint'] = owa_coreAPI::getSetting('base', 'api_url');
		}
				
		$t->set( 'site_id', $site_id );
		$t->set( 'options', $options);
		
		$t->set_template('js_log_tag.tpl');
		return $t->fetch();
	}
	
	public static function activateModule( $module_name ) {
		
		if ( $module_name ) {
		
			$m = owa_coreAPI::moduleClassFactory($module_name);
			return $m->activate();
		}
	}
	
	public static function deactivateModule( $module_name ) {
		
		if ( $module_name ) {
		
			$s = owa_coreAPI::serviceSingleton();
			$m = $s->getModule($module_name);
			return $m->deactivate();
		}
	}
	
	public static function installModule( $module_name ) {
		
		if ($module_name) {
		
			$m = owa_coreAPI::moduleClassFactory($module_name);
			$status = $m->install();
			return $status;
		}
	}
	
	public static function generateInstanceSpecificHash() {
		
		if ( defined( 'OWA_SECRET' ) ) {
			$salt = OWA_SECRET;
		} else {
			$salt = '';
		}
		
		if ( defined( 'OWA_DB_USER' ) ) { 
			$salt .= OWA_DB_USER; 
		} 
		
		if ( defined( 'OWA_DB_PASSWORD' ) ) { 
			$salt .= OWA_DB_PASSWORD; 
		}	                 
		
		return md5( $salt ); 
	}
}

?>