in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Mar 11, 3:08 AM

in-portal
View Options

	Index: branches/RC/core/kernel/event_manager.php
	===================================================================
	--- branches/RC/core/kernel/event_manager.php (revision 9273)
	+++ branches/RC/core/kernel/event_manager.php (revision 9274)
	@@ -1,556 +1,563 @@
	<?php

	define('hBEFORE', 1);
	define('hAFTER', 2);

	define('reBEFORE', 1);
	define('reAFTER', 2);

	class kEventManager extends kBase {

	/**
	* Connection to database
	*
	* @var kDBConnection
	* @access public
	*/
	var $Conn;

	/**
	* Cache of QueryString parameters
	* from config, that are represented
	* in enviroment variable
	*
	* @var Array
	*/
	var $queryMaps = Array();

	/**
	* Build events registred for
	* pseudo classes. key - pseudo class
	* value - event name
	*
	* @var Array
	* @access private
	*/
	var $buildEvents=Array();


	/**
	* Events, that should be run before parser initialization
	*
	* @var Array
	*/
	var $beforeRegularEvents = Array();

	/**
	* Events, that should be run after parser initialization
	*
	* @var Array
	*/
	var $afterRegularEvents = Array();

	/**
	* Holds before hooks
	* key - prefix.event (to link to)
	* value - hooked event info
	*
	* @var Array
	* @access private
	*/
	var $beforeHooks=Array();

	/**
	* Holds after hooks
	* key - prefix.event (to link to)
	* value - hooked event info
	*
	* @var Array
	* @access private
	*/
	var $afterHooks = Array();


	var $recursionStack = Array();

	function kEventManager()
	{
	parent::kBase();
	$this->Conn =& $this->Application->GetADODBConnection();
	}

	/**
	* Set's new enviroment parameter mappings
	* between their names as application vars
	*
	* @param Array $new_query_maps
	* @access public
	*/
	/*function setQueryMaps($new_query_maps)
	{
	$this->queryMaps = $new_query_maps;
	}*/

	/**
	* Adds new query map to already parsed query maps
	*
	* @param string $prefix
	*/
	function setQueryMap($prefix_special)
	{
	list($prefix) = explode('.', $prefix_special);
	$query_map = $this->Application->getUnitOption($prefix, 'QueryString');
	if ($query_map) {
	$this->queryMaps[$prefix_special] = $query_map;
	}
	else {
	unset($this->queryMaps[$prefix]);
	}

	// 'passed' is set later in ProcessRequest - do we really need it here? (it breakes HTTPQuery initialization...)
	// $this->Application->SetVar('passed', implode(',', array_keys($this->queryMaps)) );
	return $query_map;
	}

	/**
	* Registers new regular event
	*
	* @param string $short_name name to be used to store last maintenace run info
	* @param string $event_name
	* @param int $run_interval run interval in seconds
	* @param int $type before or after regular event
	*/
	function registerRegularEvent($short_name, $event_name, $run_interval, $type = reBEFORE)
	{
	if($type == reBEFORE)
	{
	$this->beforeRegularEvents[$short_name] = Array('EventName' => $event_name, 'RunInterval' => $run_interval);
	}
	else
	{
	$this->afterRegularEvents[$short_name] = Array('EventName' => $event_name, 'RunInterval' => $run_interval);
	}
	}

	function registerBuildEvent($pseudo_class,$build_event_name)
	{
	$this->buildEvents[$pseudo_class]=$build_event_name;
	}

	/**
	* Returns build event by pseudo class
	* name if any defined in config
	*
	* @param string $pseudo_class
	* @return kEvent
	* @access public
	*/
	function &getBuildEvent($pseudo_class)
	{
	$false = false;
	if( !isset($this->buildEvents[$pseudo_class]) ) return $false;

	$event = new kEvent();
	$event->Name=$this->buildEvents[$pseudo_class];
	$event->MasterEvent=null;
	return $event;
	}

	/**
	* Check if event is called twice, that causes recursion
	*
	* @param kEvent $event
	*/
	function isRecursion(&$event)
	{
	$event_key = $event->getPrefixSpecial().':'.$event->Name;
	return in_array($event_key, $this->recursionStack) ? true : false;
	}

	function pushEvent(&$event)
	{
	$event_key = $event->getPrefixSpecial().':'.$event->Name;
	array_push($this->recursionStack, $event_key);
	}

	function popEvent()
	{
	array_pop($this->recursionStack);
	}

	/**
	* Allows to process any type of event
	*
	* @param kEvent $event
	* @access public
	*/
	function HandleEvent(&$event)
	{
	if ($this->isRecursion($event)) {
	return true;
	}

	$this->pushEvent($event);

	if( !$this->Application->prefixRegistred($event->Prefix) )
	{
	$unit_config_reader =& $this->Application->recallObject('kUnitConfigReader');
	$unit_config_reader->loadConfig($event->Prefix);
	if( !$this->Application->prefixRegistred($event->Prefix) )
	{
	trigger_error('Prefix <b>'.$event->Prefix.'</b> not registred (requested event <b>'.$event->Name.'</b>)', E_USER_NOTICE);
	return false;
	}
	}

	if (!$event->SkipBeforeHooks) {
	$this->processHooks($event, hBEFORE);
	if ($event->status == erFATAL) return true;
	}

	$event_handler =& $this->Application->recallObject($event->Prefix.'_EventHandler');
	/* @var $event_handler kEventHandler */
	$event_handler->processEvent($event);

	if ($event->status == erFATAL) return true;
	if (!$event->SkipAfterHooks) {
	$this->processHooks($event, hAFTER);
	}

	$this->popEvent();
	return true;
	}

	function ProcessRequest()
	{
	$this->processOpener();

	// 1. get events from $_POST
	$events = $this->Application->GetVar('events');
	if ($events === false) $events = Array();
	// 2. if nothing there, then try to find them in $_GET
	if ($this->queryMaps && !$events) {
	// if we got $_GET type submit (links, not javascript)
	foreach ($this->queryMaps as $prefix_special => $query_map) {
	$query_map = array_flip($query_map);
	if (isset($query_map['event'])) {
	$event_name = $this->Application->GetVar($prefix_special.'_event');
	if ($event_name) {
	$events[$prefix_special] = $event_name;
	}
	}
	}
	$actions = $this->Application->GetVar('do');
	if ($actions) {
	list($prefix, $event_name) = explode('_', $actions);
	$events[$prefix] = $event_name;
	}
	}

	// 3. store all prefixes passed before event processing, because they are used by GetTopmostPrefix
	$all_passed = explode(',', $this->Application->GetVar('passed'));
	foreach ($events as $prefix_special => $event_name) {
	if (!$event_name) continue;
	$prefix_special = explode('.',$prefix_special);
	array_push($all_passed, $prefix_special[0]);
	}
	$this->Application->SetVar('all_passed', implode(',', $all_passed));

	foreach ($events as $prefix_special => $event_name) {
	if (!$event_name) continue;
	if (is_array($event_name)) {
	$event_name = key($event_name);
	$events[$prefix_special] = $event_name;
	$this->Application->SetVar($prefix_special.'_event', $event_name);
	}

	$event = new kEvent();
	$event->Name = $event_name;
	$event->Prefix_Special = $prefix_special;

	$prefix_special = explode('.',$prefix_special);
	$event->Prefix = $prefix_special[0];
	// array_push($passed, $prefix_special[0]);
	$event->Special = isset($prefix_special[1]) ? $prefix_special[1] : '';

	$event->redirect_params = Array('opener' => 's', 'pass' => 'all');
	$event->redirect = true;

	$event_handler =& $this->Application->recallObject($event->Prefix.'_EventHandler');
	/* @var $event_handler kEventHandler */
	$event->setEventParam('top_prefix', $this->Application->GetTopmostPrefix($event->Prefix, true));
	if (($this->Application->RecallVar('user_id') == -1) \|\| $event_handler->CheckPermission($event)) {
	$this->HandleEvent($event);
	}

	if ($event->status == erSTOP) {
	// event requested to stop processing at this point
	safeDefine('DBG_SKIP_REPORTING', 1);
	$this->Application->Session->SaveData();
	exit;
	}
	-
	+
	if ($event->status == erPERM_FAIL) {
	// should do redirect but to no_permissions template
	$event->redirect = $this->Application->IsAdmin() ? 'no_permission' : $this->Application->ConfigValue('NoPermissionTemplate');
	$event->redirect_params['pass'] = 'm';
	$event->redirect_params['m_cat_id'] = 0;

	// restore stuff, that processOpener() changed
	$wid = $this->Application->GetVar('m_wid');
	$this->Application->RestoreVar(rtrim('opener_stack_'.$wid, '_'));
	// don't save last_template, because no_permission template does js history.back and could cause invalid opener_stack content
	$this->Application->SetVar('skip_last_template', 1);
	}
	-
	+
	if ( ($event->status == erSUCCESS \|\| $event->status == erPERM_FAIL) && ($event->redirect === true \|\| strlen($event->redirect) > 0)) {
	// we need to pass category if the action was submitted to self-template, with the category passed
	// and it has not explicly set redirect template or pass_cateogry param
	if ($event->redirect === true && !isset($event->redirect_params['pass_category']) && $this->Application->GetVar('m_cat_id')) {
	$event->redirect_params['pass_category'] = 1;
	}

	$wid = $this->Application->GetVar('m_wid');
	if ($wid && $event->redirect_params['opener'] == 'u') {
	$event->redirect_params['opener'] = 's'; // because Application->HREF will react differently when 'opener' = 'u'
	$event->redirect = defined('CLOSE_POPUP_TPL') ? CLOSE_POPUP_TPL : 'incs/close_popup';
	}

	$this->Application->Redirect($event->redirect, $event->redirect_params, null, $event->redirect_script);
	}
	}

	$this->Application->SetVar('events', $events);
	$this->Application->SetVar('passed', implode(',', $all_passed));
	}

	function processOpener()
	{
	$wid = $this->Application->GetVar('m_wid');

	$opener_stack = $this->Application->RecallVar(rtrim('opener_stack_'.$wid, '_'));
	$opener_stack = $opener_stack ? unserialize($opener_stack) : Array();

	$opener_action = $this->Application->GetVar('m_opener');
	switch ($opener_action) {
	case 'r': // "reset" opener stack
	$opener_stack = Array();
	break;

	case 'd': // "down/push" new template to opener stack, deeplevel++
	if ($this->Application->GetVar('front')) {
	$front_session =& $this->Application->recallObject('Session.front');
	array_push($opener_stack, '../'.$front_session->RecallVar('last_template') );
	}
	else {
	array_push($opener_stack, $this->Application->RecallVar('last_template') );
	}
	break;

	case 'u': // "up/pop" last template from opener stack, deeplevel--
	array_pop($opener_stack);
	break;

	case 'p': // pop-up - generate new wid
	$parent_wid = $this->Application->GetVar('m_wid'); // window_id of popup's parent window
	$popup_wid = (int)$this->Application->RecallVar('last_wid') + 1;
	$this->Application->StoreVar('last_wid', $popup_wid);
	$this->Application->SetVar('m_wid', $popup_wid);

	if ($this->Application->GetVar('front')) {
	$front_session =& $this->Application->recallObject('Session.front');

	$last_template = $front_session->RecallVar(rtrim('last_template_popup_'.$parent_wid, '_'));
	$last_template = '../'.$last_template;
	}
	else {
	$last_template = $this->Application->RecallVar(rtrim('last_template_popup_'.$parent_wid, '_'));
	}

	$opener_stack = Array ( $last_template );
	$this->Application->SetVar('m_opener', 's');
	$wid = $popup_wid;
	break;

	default: // "s/0," stay on same deep level
	break;
	}


	$this->Application->SetVar('m_opener', 's');
	$this->Application->StoreVar(rtrim('opener_stack_'.$wid, '_'), serialize($opener_stack));
	}

	/**
	* Used from relationship event handler
	*
	* @param string $t
	* @param Array $params
	* @param string $pass
	*/
	function openerStackPush($t, $params, $pass = 'all', $wid=null)
	{
	if (!isset($wid)) $wid = $this->Application->GetVar('m_wid');
	$stack_name = rtrim('opener_stack_'.$wid, '_');

	$opener_stack = $this->Application->RecallVar($stack_name);
	$opener_stack = $opener_stack ? unserialize($opener_stack) : Array();

	$redirect_params = array_merge_recursive2(Array('m_opener' => 'u', '__URLENCODE__' => 1), $params);
	$new_level = $this->Application->BuildEnv($t, $redirect_params, $pass, true);
	array_push($opener_stack, 'index.php\|'.ltrim($new_level, ENV_VAR_NAME.'=') );
	$this->Application->StoreVar($stack_name, serialize($opener_stack));
	}

	function registerHook($hookto_prefix, $hookto_special, $hookto_event, $mode, $do_prefix, $do_special, $do_event, $conditional)
	{
	if( !$this->Application->prefixRegistred($hookto_prefix) )
	{
	if ($this->Application->isDebugMode()) {
	trigger_error('Prefix <b>'.$hookto_prefix.'</b> doesn\'t exist when trying to hook from <b>'.$do_prefix.':'.$do_event.'</b>', E_USER_WARNING);
	}
	return;
	}
	$hookto_prefix_special = rtrim($hookto_prefix.'.'.$hookto_special, '.');
	if ($mode == hBEFORE) {
	$this->beforeHooks[strtolower($hookto_prefix_special.'.'.$hookto_event)][] = Array(
	'DoPrefix' => $do_prefix,
	'DoSpecial' => $do_special,
	'DoEvent' => $do_event,
	'Conditional' => $conditional,
	);
	}
	elseif ($mode == hAFTER) {
	$this->afterHooks[strtolower($hookto_prefix_special.'.'.$hookto_event)][] = Array(
	'DoPrefix' => $do_prefix,
	'DoSpecial' => $do_special,
	'DoEvent' => $do_event,
	'Conditional' => $conditional,
	);
	}
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	* @param int $mode hBEFORE or hAFTER
	* @return Array
	*/
	function &getHooks(&$event, $mode, $special = null)
	{
	$event_key = !isset($special) ? $event->Prefix_Special : $event->Prefix.'.'.$special;

	if ($mode == hBEFORE) {
	$mode_hooks =& $this->beforeHooks;
	}
	else {
	$mode_hooks =& $this->afterHooks;
	}

	if (!isset($mode_hooks[strtolower($event_key.'.'.$event->Name)])) {
	$hooks = array();
	return $hooks;
	}
	return $mode_hooks[strtolower($event_key.'.'.$event->Name)];
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	* @param int $mode hBEFORE or hAFTER
	*/
	function processHooks(&$event, $mode)
	{
	// * - get hooks that are valid with any special of given prefix
	$hooks = array_merge($this->getHooks($event, $mode, '*'), $this->getHooks($event, $mode));

	if ($hooks) {
	foreach ($hooks as $hook) {
	if ($hook['DoSpecial'] == '*') {
	// use same special as master event
	$hook['DoSpecial'] = $event->Special;
	}

	$prefix_special = rtrim($hook['DoPrefix'].'_'.$hook['DoSpecial'], '_');
	if ( $hook['Conditional'] && !$this->Application->GetVar($prefix_special) ) {
	continue;
	}

	$hook_event = new kEvent( Array('name'=>$hook['DoEvent'],'prefix'=>$hook['DoPrefix'],'special'=>$hook['DoSpecial']) );
	$hook_event->MasterEvent =& $event;
	$this->HandleEvent($hook_event);
	}
	}
	}

	/**
	* Set's new event for $prefix_special
	* passed
	*
	* @param string $prefix_special
	* @param string $event_name
	* @access public
	*/
	function setEvent($prefix_special,$event_name)
	{
	$actions =& $this->Application->recallObject('kActions');
	$actions->Set('events['.$prefix_special.']',$event_name);
	}

	/**
	* Run registred regular events with specified event type
	*
	* @param int $event_type
	*/
	function RunRegularEvents($event_type = reBEFORE, $from_cron=false)
	{
	if (defined('IS_INSTALL')) return ;
	// if RegularEvents are set to run from cron
	if (!$from_cron && $this->Application->ConfigValue('UseCronForRegularEvent')) return ;
	$events_source = ($event_type == reBEFORE) ? $this->beforeRegularEvents : $this->afterRegularEvents;

	/*if(rand(0, 100) < 90)
	{
	return;
	}*/

	- $sql = 'SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = %s';
	- $event_last_runs = $this->Conn->GetOne( sprintf($sql, $this->Conn->qstr('RegularEventRuns') ) );
	+ $sql = 'SELECT Data
	+ FROM '.TABLE_PREFIX.'Cache
	+ WHERE VarName = "RegularEventRuns"';
	+ $event_last_runs = $this->Conn->GetOne($sql);
	$event_last_runs = $event_last_runs ? unserialize($event_last_runs) : Array();

	- foreach($events_source as $short_name => $event_data)
	- {
	+ $user_id = $this->Application->RecallVar('user_id');
	+ $this->Application->StoreVar('user_id', -1); // to prevent permission checking inside events
	+
	+ foreach ($events_source as $short_name => $event_data) {
	$event_last_run = getArrayValue($event_last_runs, $short_name);
	- if($event_last_run && $event_last_run > adodb_mktime() - $event_data['RunInterval'])
	- {
	+ if ($event_last_run && $event_last_run > adodb_mktime() - $event_data['RunInterval']) {
	continue;
	}
	- else
	- {
	+ else {
	$event = new kEvent($event_data['EventName']);
	$event->redirect = false;
	$this->Application->HandleEvent($event);
	$event_last_runs[$short_name] = adodb_mktime();
	}
	}

	- $sql = 'REPLACE INTO '.TABLE_PREFIX.'Cache (VarName,Data,Cached) VALUES (%s,%s,%s)';
	- $this->Conn->Query( sprintf($sql, $this->Conn->qstr('RegularEventRuns'), $this->Conn->qstr(serialize($event_last_runs)), adodb_mktime() ) );
	+ $this->Application->StoreVar('user_id', $user_id);
	+ $fields_hash = Array (
	+ 'VarName' => 'RegularEventRuns',
	+ 'Data' => serialize($event_last_runs),
	+ 'Cached' => adodb_mktime(),
	+ );
	+ $this->Conn->doInsert($fields_hash, TABLE_PREFIX.'Cache', 'REPLACE');
	}

	/**
	* Allows to determine, that required event is beeing processed right now
	*
	* @param string $event_key Event name in format prefix[.special]:event_name
	* @return bool
	*/
	function eventRunning($event_key)
	{
	return array_search($event_key, $this->recursionStack) !== false;
	}
	}


	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/event_manager.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.44
	\ No newline at end of property
	+1.44.18.1
	\ No newline at end of property
	Index: branches/RC/core/kernel/processors/main_processor.php
	===================================================================
	--- branches/RC/core/kernel/processors/main_processor.php (revision 9273)
	+++ branches/RC/core/kernel/processors/main_processor.php (revision 9274)
	@@ -1,1101 +1,1105 @@
	<?php

	class kMainTagProcessor extends TagProcessor {

	function Init($prefix, $special, $event_params = null)
	{
	parent::Init($prefix, $special, $event_params);

	$actions =& $this->Application->recallObject('kActions');
	$actions->Set('t', $this->Application->GetVar('t'));
	$actions->Set('sid', $this->Application->GetSID());
	$actions->Set('m_opener', $this->Application->GetVar('m_opener') );
	}

	/**
	* Used to handle calls where tag name
	* match with existing php function name
	*
	* @param Tag $tag
	* @return string
	*/
	function ProcessTag(&$tag)
	{
	if ($tag->Tag=='include') $tag->Tag='MyInclude';
	return parent::ProcessTag($tag);
	}

	/**
	* Base folder for all template includes
	*
	* @param Array $params
	* @return string
	*/
	function TemplatesBase($params)
	{
	if ($this->Application->IsAdmin()) {
	$module = isset($params['module']) ? $params['module'] : 'core';
	if ($module == 'in-portal') {
	$module = 'kernel';
	}
	$path = preg_replace('/\/(.?)\/(.)/', $module.'/\\2', THEMES_PATH); // remove leading slash + substitute module
	}
	else {
	$path = substr(THEMES_PATH, 1);
	$module = isset($params['module']) ? $params['module'] : 'core';

	if (strtolower($module) == 'in-portal') {
	$module_folder = 'platform';
	}
	else {
	$module_folder = $this->Application->findModule('Name', $module, 'TemplatePath');
	}
	$path .= '/'.trim($module_folder, '/').'/';
	}
	return $this->Application->BaseURL().$path;
	}

	/**
	* Creates <base href ..> HTML tag for all templates
	* affects future css, js files and href params of links
	*
	* @return string
	* @access public
	*/
	function Base_Ref($params)
	{
	return '<base href="'.$this->TemplatesBase($params).'/" />';
	}

	/**
	* Returns base url for web-site
	*
	* @return string
	* @access public
	*/
	function BaseURL()
	{
	return $this->Application->BaseURL();
	}

	//for compatability with K3 tags
	function Base($params)
	{
	return $this->TemplatesBase($params).'/';
	}

	function ProjectBase($params)
	{
	return $this->Application->BaseURL();
	}

	/*function Base($params)
	{
	return $this->Application->BaseURL().$params['add'];
	}*/

	/**
	* Used to create link to any template.
	* use "pass" paramter if "t" tag to specify
	* prefix & special of object to be represented
	* in resulting url
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function T($params)
	{
	//by default link to current template
	$t = $this->SelectParam($params, 't,template');
	unset($params['t']);
	unset($params['template']);
	$prefix=isset($params['prefix']) ? $params['prefix'] : ''; unset($params['prefix']);
	$index_file = isset($params['index_file']) ? $params['index_file'] : null; unset($params['index_file']);

	return $this->Application->HREF($t, $prefix, $params, $index_file);
	}

	function Link($params)
	{
	if (isset($params['template'])) {
	$params['t'] = $params['template'];
	unset($params['template']);
	}
	if (!isset($params['pass']) && !isset($params['no_pass'])) $params['pass'] = 'm';
	if (isset($params['no_pass'])) unset($params['no_pass']);

	if( $this->Application->GetVar('admin') ) $params['admin'] = 1;

	return $this->T($params);
	}

	function Env($params)
	{
	$t = $params['template'];
	unset($params['template']);
	return $this->Application->BuildEnv($t, $params, 'm', null, false);
	}

	function FormAction($params)
	{
	$params['pass'] = 'all,m';
	$params['pass_category'] = 1;

	return $this->Application->HREF('', '', $params);
	}

	/*// NEEDS TEST
	function Config($params)
	{
	return $this->Application->ConfigOption($params['var']);
	}

	function Object($params)
	{
	$name = $params['name'];
	$method = $params['method'];

	$tmp =& $this->Application->recallObject($name);
	if ($tmp != null) {
	if (method_exists($tmp, $method))
	return $tmp->$method($params);
	else
	echo "Method $method does not exist in object ".get_class($tmp)." named $name<br>";
	}
	else
	echo "Object $name does not exist in the appliaction<br>";
	}*/

	/**
	* Tag, that always returns true.
	* For parser testing purposes
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function True($params)
	{
	return true;
	}

	/**
	* Tag, that always returns false.
	* For parser testing purposes
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function False($params)
	{
	return false;
	}

	/**
	* Returns block parameter by name
	*
	* @param Array $params
	* @return stirng
	* @access public
	*/
	function Param($params)
	{
	//$parser =& $this->Application->recallObject('TemplateParser');
	$name = $params['name'];
	if (isset($this->Application->LateParsed[$name])) {
	$f = $this->Application->PreParsedBlocks['capture_'.$name.$this->Application->LateParsed[$name]];
	$this->Application->Parser->SetParam($name, $f(array()));
	}

	$res = $this->Application->Parser->GetParam($params['name']);
	if ($res === false) $res = '';
	if (isset($params['plus']))
	$res += $params['plus'];
	return $res;
	}

	function DefaultParam($params)
	{
	foreach ($params as $key => $val) {
	if ($this->Application->Parser->GetParam($key) === false) {
	$this->Application->Parser->SetParam($key, $val);
	}
	}
	}

	/**
	* Gets value of specified field from specified prefix_special and set it as parser param
	*
	* @param Array $params
	*/
	/*function SetParam($params)
	{
	// <inp2:m_SetParam param="custom_name" src="cf:FieldName"/>
	list($prefix_special, $field_name) = explode(':', $params['src']);

	$object =& $this->Application->recallObject($prefix_special);
	$name = $this->SelectParam($params, 'param,name,var');

	$this->Application->Parser->SetParam($name, $object->GetField($field_name) );
	}*/

	/**
	* Compares block parameter with value specified
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function ParamEquals($params)
	{
	//$parser =& $this->Application->recallObject('TemplateParser');
	$name = $this->SelectParam($params, 'name,var,param');
	$value = $params['value'];
	return ($this->Application->Parser->GetParam($name) == $value);
	}

	/*function PHP_Self($params)
	{
	return $HTTP_SERVER_VARS['PHP_SELF'];
	}
	*/

	/**
	* Returns session variable value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Recall($params)
	{
	$var_name = $this->SelectParam($params,'name,var,param');

	if (isset($params['persistent']) && $params['persistent']) {
	$ret = $this->Application->RecallPersistentVar($var_name);
	}
	else {
	$ret = $this->Application->RecallVar($var_name);
	}

	$ret = ($ret === false && isset($params['no_null'])) ? '' : $ret;
	if (getArrayValue($params, 'special') \|\| getArrayValue($params, 'htmlchars')) {
	$ret = htmlspecialchars($ret);
	}

	if (getArrayValue($params, 'urlencode')) {
	$ret = urlencode($ret);
	}

	return $ret;
	}

	function RemoveVar($params)
	{
	$this->Application->RemoveVar( $this->SelectParam($params,'name,var,param') );
	}

	// bad style to store something from template to session !!! (by Alex)
	// Used here only to test how session works, nothing more
	function Store($params)
	{
	//echo"Store $params[name]<br>";
	$name = $params['name'];
	$value = $params['value'];
	$this->Application->StoreVar($name,$value);
	}

	/**
	* Sets application variable value(-s)
	*
	* @param Array $params
	* @access public
	*/
	function Set($params)
	{
	foreach ($params as $param => $value) {
	$this->Application->SetVar($param, $value);
	}
	}

	/**
	* Increment application variable
	* specified by number specified
	*
	* @param Array $params
	* @access public
	*/
	function Inc($params)
	{
	$this->Application->SetVar($params['param'], $this->Application->GetVar($params['param']) + $params['by']);
	}

	/**
	* Retrieves application variable
	* value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Get($params)
	{
	$ret = $this->Application->GetVar($this->SelectParam($params, 'name,var,param'), '');
	return getArrayValue($params, 'htmlchars') ? htmlspecialchars($ret) : $ret;
	}

	/**
	* Retrieves application constant
	* value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function GetConst($params)
	{
	return defined($this->SelectParam($params, 'name,const')) ? constant($this->SelectParam($params, 'name,const,param')) : '';
	}

	/**
	* Retrieves configuration variable value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function GetConfig($params)
	{
	$config_name = $this->SelectParam($params, 'name,var');
	$ret = $this->Application->ConfigValue($config_name);
	if( getArrayValue($params, 'escape') ) $ret = addslashes($ret);
	return $ret;
	}

	function ConfigEquals($params)
	{
	$option = $this->SelectParam($params, 'name,option,var');
	return $this->Application->ConfigValue($option) == getArrayValue($params, 'value');
	}

	/**
	* Creates all hidden fields
	* needed for kernel_form
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function DumpSystemInfo($params)
	{
	$actions =& $this->Application->recallObject('kActions');
	$actions->Set('t', $this->Application->GetVar('t') );

	$params = $actions->GetParams();
	$o='';
	foreach ($params AS $name => $val)
	{
	$o .= "<input type='hidden' name='$name' id='$name' value='$val'>\n";
	}
	return $o;
	}

	/**
	* Used for search sidebox on front-end only
	*
	* @param Array $params
	* @return string
	* @author Alex
	*/
	function GetFormHiddens($params)
	{
	$t = $this->SelectParam($params, 'template,t');
	unset($params['template']);

	$form_fields = Array ();
	if ($this->Application->RewriteURLs()) {
	$session =& $this->Application->recallObject('Session');
	if ($session->NeedQueryString()) {
	$form_fields['sid'] = $this->Application->GetSID();
	}
	}
	else {
	$form_fields['env'] = $this->Application->BuildEnv($t, $params, 'm', null, false);
	}

	if ($this->Application->GetVar('admin') == 1) {
	$form_fields['admin'] = 1;
	}

	$ret = '';
	$field_tpl = '<input type="hidden" name="%1$s" id="%1$s" value="%2$s"/>'."\n";
	foreach ($form_fields as $form_field => $field_value) {
	$ret .= sprintf($field_tpl, $form_field, $field_value);
	}

	return $ret;
	}

	function Odd_Even($params)
	{
	$odd = $params['odd'];
	$even = $params['even'];
	if (!isset($params['var'])) {
	$var = 'odd_even';
	}
	else {
	$var = $params['var'];
	}

	if ($this->Application->GetVar($var) == 'even') {
	if (!isset($params['readonly']) \|\| !$params['readonly']) {
	$this->Application->SetVar($var, 'odd');
	}
	return $even;
	}
	else {
	if (!isset($params['readonly']) \|\| !$params['readonly']) {
	$this->Application->SetVar($var, 'even');
	}
	return $odd;
	}
	}

	/**
	* Returns phrase translation by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Phrase($params)
	{
	// m:phrase name="phrase_name" default="Tr-alala" updated="2004-01-29 12:49"
	if (array_key_exists('default', $params)) return $params['default']; //backward compatibility
	$translation = $this->Application->Phrase($this->SelectParam($params, 'label,name,title'));

	if (isset($params['escape']) && $params['escape']) {
	$translation = htmlspecialchars($translation, ENT_QUOTES);
	$translation = addslashes($translation);
	}
	return $translation;
	}

	// for tabs
	function is_active($params)
	{
	$test_templ = $this->SelectParam($params, 'templ,template,t');
	if ( !getArrayValue($params,'allow_empty') )
	{
	$if_true=getArrayValue($params,'true') ? $params['true'] : 1;
	$if_false=getArrayValue($params,'false') ? $params['false'] : 0;
	}
	else
	{
	$if_true=$params['true'];
	$if_false=$params['false'];
	}

	if ( preg_match("/^".str_replace('/', '\/', $test_templ)."/i", $this->Application->GetVar('t'))) {
	return $if_true;
	}
	else {
	return $if_false;
	}
	}

	function IsNotActive($params)
	{
	return !$this->is_active($params);
	}

	function IsActive($params)
	{
	return $this->is_active($params);
	}

	function is_t_active($params)
	{
	return $this->is_active($params);
	}

	function CurrentTemplate($params)
	{
	return $this->is_active($params);
	}

	/**
	* Checks if session variable
	* specified by name value match
	* value passed as parameter
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function RecallEquals($params)
	{
	$name = $this->SelectParam($params, 'name,var');
	$value = $params['value'];

	if (isset($params['persistent']) && $params['persistent']) {
	return $this->Application->RecallPersistentVar($name) == $value;
	}

	return ($this->Application->RecallVar($name) == $value);
	}

	/**
	* Checks if application variable
	* specified by name value match
	* value passed as parameter
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function GetEquals($params)
	{
	$name = $this->SelectParam($params, 'var,name,param');
	$value = $params['value'];
	if ($this->Application->GetVar($name) == $value) {
	return 1;
	}
	}

	/**
	* Includes template
	* and returns it's
	* parsed version
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function MyInclude($params)
	{
	if (defined('NPARSER') && NPARSER) {
	return $this->Application->Parser->IncludeTemplate($params, isset($params['is_silent']) ? 1 : 0);
	}

	$BlockParser =& $this->Application->makeClass('TemplateParser');
	/* @var $BlockParser TemplateParser */

	// $BlockParser->SetParams($params);
	$parser =& $this->Application->Parser;
	$this->Application->Parser =& $BlockParser;

	// this is for the parser to know the master template in case an error occurs,
	// ParseTemplate will reset it anyway, but this will allow error handler to display the tempalte
	// which tries to include missing template for example
	$this->Application->Parser->TemplateName = $parser->TemplateName;

	$t = $this->SelectParam($params, 't,template,block,name');
	$t = eregi_replace("\.tpl$", '', $t);

	if (!$t) {
	trigger_error('Template name not specified in <b><inp2:m_include .../></b> tag', E_USER_ERROR);
	}

	if (isset($this->Application->PreParsedBlocks[$t]) ) {
	$params['name'] = $t;
	$res = $this->Application->ParseBlock($params);
	}
	else {
	$res = $BlockParser->ParseTemplate($t, 1, $params, isset($params['is_silent']) ? 1 : 0 );
	}

	if (!$BlockParser->DataExists && ((isset($params['data_exists']) && $params['data_exists']) \|\| isset($params['block_no_data']))) {
	if ($block_no_data = getArrayValue($params, 'block_no_data')) {
	if (isset($this->Application->PreParsedBlocks[$block_no_data]) ) {
	// block_no_data is another block name
	$res = $this->Application->ParseBlock(Array('name' => $block_no_data));
	}
	else {
	// block_no_data is template name (only looks through real templates)
	$res = $BlockParser->ParseTemplate($block_no_data, 1, Array(), getArrayValue($params, 'is_silent'));
	}
	}
	else {
	$res = '';
	}
	}

	$this->Application->Parser =& $parser;
	$this->Application->Parser->DataExists = $this->Application->Parser->DataExists \|\| $BlockParser->DataExists;

	if (isset($params['return_params']) && $params['return_params']) {
	$new_params = array_merge($this->Application->Parser->Params, $BlockParser->ParamsStack[0]);
	$this->Application->Parser->SetParams($new_params, false);
	}

	return $res;
	}

	function ModuleInclude($params)
	{
	$ret = '';
	$block_params = array_merge($params, Array('is_silent' => 2)); // don't make fatal errors in case if template is missing
	$current_template = $this->Application->GetVar('t');
	$skip_prefixes = isset($params['skip_prefixes']) ? explode(',', $params['skip_prefixes']) : Array();
	foreach ($this->Application->ModuleInfo as $module_name => $module_data) {
	$module_key = strtolower($module_name);

	if ($module_name == 'In-Portal') {
	$module_prefix = $this->Application->IsAdmin() ? 'in-portal/' : $module_data['TemplatePath'];
	}
	else {
	$module_prefix = $this->Application->IsAdmin() ? $module_key.'/' : rtrim($module_data['TemplatePath'], '/').'/';
	}

	$block_params['t'] = $module_prefix.$this->SelectParam($params, $module_key.'_template,'.$module_key.'_t,template,t');
	if ($block_params['t'] == $current_template \|\| in_array($module_data['Var'], $skip_prefixes)) continue;

	$no_data = $this->SelectParam($params, $module_key.'_block_no_data,block_no_data');
	if ($no_data) {
	$block_params['block_no_data'] = $module_prefix.'/'.$no_data;
	}
	$ret .= $this->MyInclude($block_params);
	}
	return $ret;
	}

	function ModuleEnabled($params)
	{
	return $this->Application->isModuleEnabled( $params['module'] );
	}

	/*function Kernel_Scripts($params)
	{
	return '<script type="text/javascript" src="'.PROTOCOL.SERVER_NAME.BASE_PATH.'/kernel3/js/grid.js"></script>';
	}*/


	/*function GetUserPermission($params)
	{
	// echo"GetUserPermission $params[name]";
	if ($this->Application->RecallVar('user_type') == 1)
	return 1;
	else {
	$perm_name = $params[name];
	$aPermissions = unserialize($this->Application->RecallVar('user_permissions'));
	if ($aPermissions)
	return $aPermissions[$perm_name];
	}
	}*/


	/**
	* Set's parser block param value
	*
	* @param Array $params
	* @access public
	*/
	function AddParam($params)
	{
	$parser =& $this->Application->Parser; // recallObject('TemplateParser');
	foreach ($params as $param => $value) {
	$this->Application->SetVar($param, $value);
	$parser->SetParam($param, $value);
	$parser->AddParam('/\$'.$param.'/', $value);
	}
	}

	/*function ParseToVar($params)
	{
	$var = $params['var'];
	$tagdata = $params['tag'];
	$parser =& $this->Application->Parser; //recallObject('TemplateParser');
	$res = $this->Application->ProcessTag($tagdata);

	$parser->SetParam($var, $res);
	$parser->AddParam('/\$'.$var.'/', $res);
	return '';
	}*/

	/*function TagNotEmpty($params)
	{
	$tagdata = $params['tag'];
	$res = $this->Application->ProcessTag($tagdata);
	return $res != '';
	}*/

	/*function TagEmpty($params)
	{
	return !$this->TagNotEmpty($params);
	}*/

	/**
	* Parses block and returns result
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function ParseBlock($params)
	{
	$parser =& $this->Application->Parser; // recallObject('TemplateParser');
	return $parser->ParseBlock($params);
	}

	function RenderElement($params)
	{
	if (isset($params['design']) && $params['design']) {
	$block_name = $params['name'];
	if ($block_name != '__this__') {
	// prepare content
	$block_params = $params;
	$block_params['template'] = $block_name;
	$block_params['return_params'] = 1;
	$block_params['strip_nl'] = 2;
	$block_content = $this->MyInclude($block_params);

	if (isset($params['data_exists']) && $params['data_exists'] && !$block_content) {
	return '';
	}

	// prepare design
	$block_params = Array (
	'content' => $block_content,
	);
	}

	$block_params['name'] = $params['design'];
	return $this->Application->ParseBlock($block_params, 1);
	}

	return $this->ParseBlock($params);
	}

	function RenderElements($params)
	{
	if (!isset($params['elements']) \|\| !$params['elements']) return;
	$elements = explode(',', $params['elements']);
	if (isset($params['skip']) && $params['skip']) {
	$tmp_skip = explode(',', $params['skip']);
	foreach ($tmp_skip as $elem) {
	$skip[] = trim($elem);
	}
	}
	else {
	$skip = array();
	}
	unset($params['elements']);
	$o = '';
	foreach ($elements as $an_element)
	{
	$cur = trim($an_element);
	if (in_array($cur,$skip) \|\| !$cur) continue;
	$pass_params = $params;
	$pass_params['name'] = $cur;
	$o .= $this->RenderElement($pass_params);
	}
	return $o;

	}

	/**
	* Checks if debug mode is on
	*
	* @return bool
	* @access public
	*/
	function IsDebugMode()
	{
	return $this->Application->isDebugMode();
	}

	function MassParse($params)
	{
	$qty = $params['qty'];
	$block = $params['block'];
	$mode = $params['mode'];

	$o = '';
	if ($mode == 'func') {
	$func = create_function('$params', '
	$o = \'<tr>\';
	$o.= \'<td>a\'.$params[\'param1\'].\'</td>\';
	$o.= \'<td>a\'.$params[\'param2\'].\'</td>\';
	$o.= \'<td>a\'.$params[\'param3\'].\'</td>\';
	$o.= \'<td>a\'.$params[\'param4\'].\'</td>\';
	$o.= \'</tr>\';
	return $o;
	');
	for ($i=1; $i<$qty; $i++) {
	$block_params['param1'] = rand(1, 10000);
	$block_params['param2'] = rand(1, 10000);
	$block_params['param3'] = rand(1, 10000);
	$block_params['param4'] = rand(1, 10000);
	$o .= $func($block_params);
	}
	return $o;
	}

	$block_params['name'] = $block;

	for ($i=0; $i<$qty; $i++) {
	$block_params['param1'] = rand(1, 10000);
	$block_params['param2'] = rand(1, 10000);
	$block_params['param3'] = rand(1, 10000);
	$block_params['param4'] = rand(1, 10000);
	$block_params['passed'] = $params['passed'];
	$block_params['prefix'] = 'm';

	$o.= $this->Application->ParseBlock($block_params, 1);
	}
	return $o;
	}

	function LoggedIn($params)
	{
	return $this->Application->LoggedIn();
	}

	/**
	* Allows to check if permission exists directly in template and perform additional actions if required
	*
	* @param Array $params
	* @return bool
	*/
	function CheckPermission($params)
	{
	$perm_helper =& $this->Application->recallObject('PermissionsHelper');
	return $perm_helper->TagPermissionCheck($params);
	}

	/**
	* Checks if user is logged in and if not redirects it to template passed
	*
	* @param Array $params
	*/
	function RequireLogin($params)
	{
	$t = $this->Application->GetVar('t');
	if ($next_t = getArrayValue($params, 'next_template')) {
	$t = $next_t;
	}

	// check by permissions: begin
	if ((isset($params['perm_event']) && $params['perm_event']) \|\|
	(isset($params['perm_prefix']) && $params['perm_prefix']) \|\|
	(isset($params['permissions']) && $params['permissions'])) {

	$perm_helper =& $this->Application->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	$perm_status = $perm_helper->TagPermissionCheck($params);
	if (!$perm_status) {
	list($redirect_template, $redirect_params) = $perm_helper->getPermissionTemplate($params);
	$this->Application->Redirect($redirect_template, $redirect_params);
	}
	else {
	return ;
	}
	}
	// check by permissions: end

	// check by configuration value: begin
	$condition = getArrayValue($params, 'condition');
	if (!$condition) {
	$condition = true;
	}
	else {
	if (substr($condition, 0, 1) == '!') {
	$condition = !$this->Application->ConfigValue(substr($condition, 1));
	}
	else {
	$condition = $this->Application->ConfigValue($condition);
	}
	}
	// check by configuration value: end

	// check by belonging to group: begin
	$group = $this->SelectParam($params, 'group');
	$group_access = true;
	if ($group) {
	$conn =& $this->Application->GetADODBConnection();
	$group_id = $conn->GetOne('SELECT GroupId FROM '.TABLE_PREFIX.'PortalGroup WHERE Name = '.$conn->qstr($group));
	if ($group_id) {
	$groups = explode(',', $this->Application->RecallVar('UserGroups'));
	$group_access = in_array($group_id, $groups);
	}
	}
	// check by belonging to group: end

	if ((!$this->Application->LoggedIn() \|\| !$group_access) && $condition) {
	if ( $this->Application->LoggedIn() && !$group_access) {
	$this->Application->Redirect( $params['no_group_perm_template'], Array('next_template'=>$t) );
	}

	$redirect_params = $this->Application->HttpQuery->getRedirectParams();
	$redirect_params['next_template'] = $t;
	$this->Application->Redirect($params['login_template'], $redirect_params);
	}
	}

	function IsMember($params)
	{
	$group = getArrayValue($params, 'group');
	$conn =& $this->Application->DB;
	$group_id = $conn->GetOne('SELECT GroupId FROM '.TABLE_PREFIX.'PortalGroup WHERE Name = '.$conn->qstr($group));
	if ($group_id) {
	$groups = explode(',', $this->Application->RecallVar('UserGroups'));
	$group_access = in_array($group_id, $groups);
	}
	return $group_access;
	}

	/**
	* Checks if SSL is on and redirects to SSL URL if needed
	* If SSL_URL is not defined in config - the tag does not do anything
	* If for_logged_in_only="1" exits if user is not logged in.
	* If called without params forces https right away. If called with by_config="1" checks the
	* Require SSL setting from General Config and if it is ON forces https
	*
	* @param unknown_type $params
	*/
	function CheckSSL($params)
	{
	$ssl = $this->Application->ConfigValue('SSL_URL');
	if (!$ssl) return; //SSL URL is not set - no way to require SSL

	$require = false;

	if (isset($params['mode']) && $params['mode'] == 'required') {
	$require = true;
	if (isset($params['for_logged_in_only']) && $params['for_logged_in_only'] && !$this->Application->LoggedIn()) {
	$require = false;
	}

	if (isset($params['condition'])) {
	if (!$this->Application->ConfigValue($params['condition'])) {
	$require = false;
	}
	}
	}

	$http_query =& $this->Application->recallObject('HTTPQuery');
	$pass = $http_query->getRedirectParams();

	if ($require) {
	if (PROTOCOL == 'https://') {
	$this->Application->SetVar('__KEEP_SSL__', 1);
	return;
	}
	$this->Application->Redirect('', array_merge_recursive2($pass, Array('__SSL__' => 1)));
	}
	else {
	if (PROTOCOL == 'https://' && $this->Application->ConfigValue('Force_HTTP_When_SSL_Not_Required')) {
	if ($this->Application->GetVar('__KEEP_SSL__')) return;
	$pass = array('pass'=>'m', 'm_cat_id'=>0);
	$this->Application->Redirect('', array_merge_recursive2($pass, Array('__SSL__' => 0)));
	}
	}
	}

	function ConstOn($params)
	{
	$name = $this->SelectParam($params,'name,const');
	return constOn($name);
	}

	function SetDefaultCategory($params)
	{
	$category_id = $this->Application->findModule('Name', $params['module'], 'RootCat');
	$this->Application->SetVar('m_cat_id', $category_id);
	}

	function XMLTemplate($params)
	{
	safeDefine('DBG_SKIP_REPORTING', 1);
	$lang =& $this->Application->recallObject('lang.current');

	if (isset($params['cache']) && $params['cache']) {
	$nextyear = intval(date('Y') + 1);

	$format = "D, d M Y H:i:s";
	$expiration = gmdate($format, mktime() + $params['cache']).' GMT';
	$last_modified = mktime();

	header ('Cache-Control: public, cache, max-age='.$params['cache']);
	header ("Expires: $expiration");
	header ('Pragma: public');

	// Getting headers sent by the client.
	$headers = request_headers();

	// Checking if the client is validating his cache and if it is current.
	if (isset($headers['If-Modified-Since']) && (strtotime($headers['If-Modified-Since']) > $last_modified-$params['cache'])) {
	// Client's cache IS current, so we just respond '304 Not Modified'.
	header('Last-Modified: '.date($format, strtotime($headers['If-Modified-Since'])).' GMT', true, 304);
	exit();
	} else {
	// Image not cached or cache outdated, we respond '200 OK' and output the image.
	header('Last-Modified: '.gmdate($format, $last_modified).' GMT', true, 200);
	}
	}

	header('Content-type: text/xml; charset='.$lang->GetDBField('Charset'));
	+
	+ if (isset($params['xml_version']) && $params['xml_version']) {
	+ return '<?xml version="'.$params['xml_version'].'" encoding="'.$lang->GetDBField('Charset').'"?>';
	+ }
	}

	function Header($params)
	{
	header($params['data']);
	}

	function NoDebug($params)
	{
	define('DBG_SKIP_REPORTING', 1);
	}

	function RootCategoryName($params)
	{
	$root_phrase = $this->Application->ConfigValue('Root_Name');
	return $this->Application->Phrase($root_phrase);
	}

	/**
	* Allows to attach file directly from email event template
	*
	* @param Array $params
	*/
	function AttachFile($params)
	{
	$esender =& $application->recallObject('EmailSender'.(isset($params['special']) ? '.'.$params['special'] : ''));
	/* @var $esender kEmailSendingHelper */

	$path = FULL_PATH.'/'.$params['path'];
	if (file_exists($path)) {
	$esender->AddAttachment($path);
	}
	}

	function CaptchaImage($params){
	$captcha_helper =& $this->Application->recallObject('CaptchaHelper');
	/* @var $captcha_helper kCaptchaHelper */
	$captcha_helper->GenerateCaptchaImage(
	$this->Application->RecallVar($this->Application->GetVar('var')),
	$this->Application->GetVar('w'),
	$this->Application->GetVar('h'),
	true
	);
	}

	function SID($params)
	{
	return $this->Application->GetSID();
	}

	function ModuleInfo($params)
	{
	return $this->Application->findModule($params['key'], $params['value'], $params['return']);
	}

	function Random($params)
	{
	return rand(1, 100000000);
	}
	}

	Property changes on: branches/RC/core/kernel/processors/main_processor.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.80.2.1
	\ No newline at end of property
	+1.80.2.2
	\ No newline at end of property

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options