in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Apr 20, 5:46 PM

in-portal
View Options

	Index: branches/5.2.x/core/kernel/managers/rewrite_url_processor.php
	===================================================================
	--- branches/5.2.x/core/kernel/managers/rewrite_url_processor.php (revision 16482)
	+++ branches/5.2.x/core/kernel/managers/rewrite_url_processor.php (revision 16483)
	@@ -1,1090 +1,1097 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2011 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	class kRewriteUrlProcessor extends kUrlProcessor {

	/**
	* Holds a reference to httpquery
	*
	* @var kHttpQuery
	* @access protected
	*/
	protected $HTTPQuery = null;

	/**
	* Urls parts, that needs to be matched by rewrite listeners
	*
	* @var Array
	* @access protected
	*/
	protected $_partsToParse = Array ();

	/**
	* Category item prefix, that was found
	*
	* @var string\|boolean
	* @access protected
	*/
	protected $modulePrefix = false;

	/**
	* Template aliases for current theme
	*
	* @var Array
	* @access protected
	*/
	protected $_templateAliases = null;

	/**
	* Domain-based primary language id
	*
	* @var int
	* @access public
	*/
	public $primaryLanguageId = false;

	/**
	* Domain-based primary theme id
	*
	* @var int
	* @access public
	*/
	public $primaryThemeId = false;

	/**
	* Possible url endings from ModRewriteUrlEnding configuration variable
	*
	* @var Array
	* @access protected
	*/
	protected $_urlEndings = Array ('.html', '/', '');

	/**
	* Factory storage sub-set, containing mod-rewrite listeners, used during url building and parsing
	*
	* @var Array
	* @access protected
	*/
	protected $rewriteListeners = Array ();

	/**
	* Constructor of kRewriteUrlProcessor class
	*
	* @param $manager
	* @return kRewriteUrlProcessor
	*/
	public function __construct(&$manager)
	{
	parent::__construct($manager);

	$this->HTTPQuery = $this->Application->recallObject('HTTPQuery');

	// domain based primary language
	$this->primaryLanguageId = $this->Application->siteDomainField('PrimaryLanguageId');

	if (!$this->primaryLanguageId) {
	// when domain-based language not found -> use site-wide language
	$this->primaryLanguageId = $this->Application->GetDefaultLanguageId();
	}

	// domain based primary theme
	$this->primaryThemeId = $this->Application->siteDomainField('PrimaryThemeId');

	if (!$this->primaryThemeId) {
	// when domain-based theme not found -> use site-wide theme
	$this->primaryThemeId = $this->Application->GetDefaultThemeId(true);
	}

	$this->_initRewriteListeners();
	}

	/**
	* Sets module prefix.
	*
	* @param string $prefix Unit config prefix.
	*
	* @return void
	*/
	public function setModulePrefix($prefix)
	{
	$this->modulePrefix = $prefix;
	}

	/**
	* Parses url
	*
	* @return void
	*/
	public function parseRewriteURL()
	{
	$url = $this->Application->GetVar('_mod_rw_url_');

	if ( $url ) {
	$this->_redirectToDefaultUrlEnding($url);
	$url = $this->_removeUrlEnding($url);
	}

	$cached = $this->_getCachedUrl($url);

	if ( $cached !== false ) {
	$vars = $cached['vars'];
	$passed = $cached['passed'];
	}
	else {
	$vars = $this->parse($url);
	$passed = $vars['pass']; // also used in bottom of this method
	unset($vars['pass']);

	if ( !$this->_partsToParse ) {
	// don't cache 404 Not Found
	$this->_setCachedUrl($url, Array ('vars' => $vars, 'passed' => $passed));
	}
	else {
	header('HTTP/1.0 404 Not Found');
	}

	if ( $this->Application->GetVarDirect('t', 'Post') ) {
	// template from POST overrides template from URL.
	$vars['t'] = $this->Application->GetVarDirect('t', 'Post');

	if ( isset($vars['is_virtual']) && $vars['is_virtual'] ) {
	$vars['m_cat_id'] = 0; // this is virtual template category (for Proj-CMS)
	}
	}

	unset($vars['is_virtual']);
	}

	foreach ($vars as $name => $value) {
	$this->HTTPQuery->Set($name, $value);
	}

	$this->_initAll(); // also will use parsed language to load phrases from it

	$this->HTTPQuery->finalizeParsing($passed);
	}

	/**
	* Detects url ending of given url
	*
	* @param string $url
	* @return string
	* @access protected
	*/
	protected function _findUrlEnding($url)
	{
	if ( !$url ) {
	return '';
	}

	foreach ($this->_urlEndings as $url_ending) {
	if ( mb_substr($url, mb_strlen($url) - mb_strlen($url_ending)) == $url_ending ) {
	return $url_ending;
	}
	}

	return '';
	}

	/**
	* Removes url ending from url
	*
	* @param string $url
	* @return string
	* @access protected
	*/
	protected function _removeUrlEnding($url)
	{
	$url_ending = $this->_findUrlEnding($url);

	if ( !$url_ending ) {
	return $url;
	}

	return mb_substr($url, 0, mb_strlen($url) - mb_strlen($url_ending));
	}

	/**
	* Redirects user to page with default url ending, where needed
	*
	* @param string $url
	* @return void
	* @access protected
	*/
	protected function _redirectToDefaultUrlEnding($url)
	{
	$default_ending = $this->Application->ConfigValue('ModRewriteUrlEnding');

	if ( $this->_findUrlEnding($url) == $default_ending \|\| !$this->Application->ConfigValue('ForceModRewriteUrlEnding') ) {
	return;
	}

	// user manually typed url with different url ending -> redirect to same url with default url ending
	$target_url = $this->Application->BaseURL() . $this->_removeUrlEnding($url) . $default_ending;

	trigger_error('Mod-rewrite url "<strong>' . $_SERVER['REQUEST_URI'] . '</strong>" without "<strong>' . $default_ending . '</strong>" line ending used', E_USER_NOTICE);
	$this->Application->Redirect('external:' . $target_url, Array ('response_code' => 301));
	}

	/**
	* Returns url parsing result from cache or false, when not yet parsed
	*
	* @param $url
	* @return Array\|bool
	* @access protected
	*/
	protected function _getCachedUrl($url)
	{
	if ( !$url \|\| (defined('DBG_CACHE_URLS') && !DBG_CACHE_URLS) ) {
	return false;
	}

	$sql = 'SELECT *
	FROM ' . TABLE_PREFIX . 'CachedUrls
	WHERE Hash = ' . kUtil::crc32($url) . ' AND DomainId = ' . (int)$this->Application->siteDomainField('DomainId');
	$data = $this->Conn->GetRow($sql);

	if ( $data ) {
	$lifetime = (int)$data['LifeTime']; // in seconds
	if ( ($lifetime > 0) && ($data['Cached'] + $lifetime < TIMENOW) ) {
	// delete expired
	$sql = 'DELETE FROM ' . TABLE_PREFIX . 'CachedUrls
	WHERE UrlId = ' . $data['UrlId'];
	$this->Conn->Query($sql);

	return false;
	}

	return unserialize($data['ParsedVars']);
	}

	return false;
	}

	/**
	* Caches url
	*
	* @param string $url
	* @param Array $data
	* @return void
	* @access protected
	*/
	protected function _setCachedUrl($url, $data)
	{
	if ( !$url \|\| (defined('DBG_CACHE_URLS') && !DBG_CACHE_URLS) ) {
	return;
	}

	$vars = $data['vars'];
	$passed = $data['passed'];
	sort($passed);

	// get expiration
	if ( $vars['m_cat_id'] > 0 ) {
	$sql = 'SELECT PageExpiration
	FROM ' . TABLE_PREFIX . 'Categories
	WHERE CategoryId = ' . $vars['m_cat_id'];
	$expiration = $this->Conn->GetOne($sql);
	}

	// get prefixes
	$prefixes = Array ();
	$m_index = array_search('m', $passed);

	if ( $m_index !== false ) {
	unset($passed[$m_index]);

	if ( $vars['m_cat_id'] > 0 ) {
	$prefixes[] = 'c:' . $vars['m_cat_id'];
	}

	$prefixes[] = 'lang:' . $vars['m_lang'];
	$prefixes[] = 'theme:' . $vars['m_theme'];
	}

	foreach ($passed as $prefix) {
	if ( array_key_exists($prefix . '_id', $vars) && is_numeric($vars[$prefix . '_id']) ) {
	$prefixes[] = $prefix . ':' . $vars[$prefix . '_id'];
	}
	else {
	$prefixes[] = $prefix;
	}
	}

	$fields_hash = Array (
	'Url' => $url,
	'Hash' => kUtil::crc32($url),
	'DomainId' => (int)$this->Application->siteDomainField('DomainId'),
	'Prefixes' => $prefixes ? '\|' . implode('\|', $prefixes) . '\|' : '',
	'ParsedVars' => serialize($data),
	'Cached' => adodb_mktime(),
	'LifeTime' => isset($expiration) && is_numeric($expiration) ? $expiration : -1
	);

	$this->Conn->doInsert($fields_hash, TABLE_PREFIX . 'CachedUrls');
	}

	/**
	* Loads all registered rewrite listeners, so they could be quickly accessed later
	*
	* @access protected
	*/
	protected function _initRewriteListeners()
	{
	static $init_done = false;

	if ($init_done \|\| count($this->Application->RewriteListeners) == 0) {
	// not initialized OR mod-rewrite url with missing config cache
	return ;
	}

	foreach ($this->Application->RewriteListeners as $prefix => $listener_data) {
	foreach ($listener_data['listener'] as $index => $rewrite_listener) {
	list ($listener_prefix, $listener_method) = explode(':', $rewrite_listener);

	// don't use temp variable, since it will swap objects in Factory in PHP5
	$this->rewriteListeners[$prefix][$index] = Array ();
	$this->rewriteListeners[$prefix][$index][0] = $this->Application->recallObject($listener_prefix);
	$this->rewriteListeners[$prefix][$index][1] = $listener_method;
	}
	}

	define('MOD_REWRITE_URL_ENDING', $this->Application->ConfigValue('ModRewriteUrlEnding'));

	$init_done = true;
	}

	/**
	* Parses given string into a set of variables (url in this case)
	*
	* @param string $string
	* @param string $pass_name
	* @return Array
	* @access public
	*/
	public function parse($string, $pass_name = 'pass')
	{
	// external url (could be back this website as well)
	if ( preg_match('/external:(.*)/', $string, $regs) ) {
	$string = $regs[1];
	}

	$vars = Array ();
	$url_components = parse_url($string);

	if ( isset($url_components['query']) ) {
	parse_str(html_entity_decode($url_components['query']), $url_params);

	if ( isset($url_params[ENV_VAR_NAME]) ) {
	$url_params = array_merge($url_params, $this->manager->plain->parse($url_params[ENV_VAR_NAME], $pass_name));
	unset($url_params[ENV_VAR_NAME]);
	}

	$vars = array_merge($vars, $url_params);
	}

	$this->_fixPass($vars, $pass_name);

	if ( isset($url_components['path']) ) {
	if ( BASE_PATH ) {
	$string = preg_replace('/^' . preg_quote(BASE_PATH, '/') . '/', '', $url_components['path'], 1);
	}
	else {
	$string = $url_components['path'];
	}

	$string = $this->_removeUrlEnding(trim($string, '/'));
	}
	else {
	$string = '';
	}

	$url_parts = $string ? explode('/', mb_strtolower($string)) : Array ();

	$this->setModulePrefix(false);
	$this->_partsToParse = $url_parts;

	if ( ($this->HTTPQuery->Get('rewrite') == 'on') \|\| !$url_parts ) {
	$this->_setDefaultValues($vars);
	}

	if ( !$url_parts ) {
	$this->_initAll();
	$vars['t'] = $this->Application->UrlManager->getTemplateName();

	return $vars;
	}

	$this->_parseLanguage($url_parts, $vars);
	$this->_parseTheme($url_parts, $vars);

	// http://site-url/<language>/<theme>/<category>[_<category_page>]/<template>/<module_page>
	// http://site-url/<language>/<theme>/<category>[_<category_page>]/<module_page> (category-based section template)
	// http://site-url/<language>/<theme>/<category>[_<category_page>]/<template>/<module_item>
	// http://site-url/<language>/<theme>/<category>[_<category_page>]/<module_item> (category-based detail template)
	// http://site-url/<language>/<theme>/<rl_injections>/<category>[_<category_page>]/<rl_part> (customized url)

	if ( !$this->_processRewriteListeners($url_parts, $vars) ) {
	// rewrite listener wasn't able to determine template
	$this->_parsePhysicalTemplate($url_parts, $vars);

	if ( ($this->modulePrefix === false) && $vars['m_cat_id'] && !$this->_partsToParse ) {
	// no category item found, but category found and all url matched -> module index page
	return $vars;
	}
	}

	if ( $this->_partsToParse ) {
	/** @var kThemesHelper $themes_helper */
	$themes_helper = $this->Application->recallObject('ThemesHelper');

	$not_found = $this->Application->ConfigValue('ErrorTemplate');
	$vars['t'] = $not_found ? $not_found : 'error_notfound';
	$vars['m_cat_id'] = $themes_helper->getPageByTemplate($vars['t'], $vars['m_theme']);
	$vars['pass'] = array('m');
	}

	return $vars;
	}

	/**
	* Ensures, that "m" is always in "pass" variable
	*
	* @param Array $vars
	* @param string $pass_name
	* @return void
	* @access protected
	*/
	protected function _fixPass(&$vars, $pass_name)
	{
	if ( isset($vars[$pass_name]) ) {
	$vars[$pass_name] = array_unique(explode(',', 'm,' . $vars[$pass_name]));
	}
	else {
	$vars[$pass_name] = Array ('m');
	}
	}

	/**
	* Initializes theme & language based on parse results
	*
	* @return void
	* @access protected
	*/
	protected function _initAll()
	{
	$this->Application->VerifyThemeId();
	$this->Application->VerifyLanguageId();

	// no need, since we don't have any cached phrase IDs + nobody will use PhrasesCache::LanguageId soon
	// $this->Application->Phrases->Init('phrases');
	}

	/**
	* Sets default parsed values before actual url parsing (only, for empty url)
	*
	* @param Array $vars
	* @access protected
	*/
	protected function _setDefaultValues(&$vars)
	{
	$defaults = Array (
	'm_cat_id' => 0, // no category
	'm_cat_page' => 1, // first category page
	'm_opener' => 's', // stay on same page
	't' => 'index' // main site page
	);

	if ($this->primaryLanguageId) {
	// domain-based primary language
	$defaults['m_lang'] = $this->primaryLanguageId;
	}

	if ($this->primaryThemeId) {
	// domain-based primary theme
	$defaults['m_theme'] = $this->primaryThemeId;
	}

	foreach ($defaults as $default_key => $default_value) {
	if ($this->HTTPQuery->Get($default_key) === false) {
	$vars[$default_key] = $default_value;
	}
	}
	}

	/**
	* Processes url using rewrite listeners
	*
	* Pattern: Chain of Command
	*
	* @param Array $url_parts
	* @param Array $vars
	* @return bool
	* @access protected
	*/
	protected function _processRewriteListeners(&$url_parts, &$vars)
	{
	$this->_initRewriteListeners();
	$page_number = $this->_parsePage($url_parts, $vars);

	foreach ($this->rewriteListeners as $prefix => $listeners) {
	// set default page
	// $vars[$prefix . '_Page'] = 1; // will override page in session in case, when none is given in url

	if ($page_number) {
	// page given in url - use it
	$vars[$prefix . '_id'] = 0;
	$vars[$prefix . '_Page'] = $page_number;
	}

	// $listeners[1] - listener, used for parsing
	- $listener_result = $listeners[1][0]->$listeners[1][1](REWRITE_MODE_PARSE, $prefix, $vars, $url_parts);
	+ $listener_result = call_user_func_array(
	+ $listeners[1],
	+ array(REWRITE_MODE_PARSE, $prefix, &$vars, &$url_parts)
	+ );
	+
	if ($listener_result === false) {
	// will not proceed to other methods
	return true;
	}
	}

	// will proceed to other methods
	return false;
	}

	/**
	* Set's page (when found) to all modules
	*
	* @param Array $url_parts
	* @param Array $vars
	* @return string
	* @access protected
	*
	* @todo Should find a way, how to determine what rewrite listener page is it
	*/
	protected function _parsePage(&$url_parts, &$vars)
	{
	if (!$url_parts) {
	return false;
	}

	$page_number = end($url_parts);
	if (!is_numeric($page_number)) {
	return false;
	}

	array_pop($url_parts);
	$this->partParsed($page_number, 'rtl');

	return $page_number;
	}

	/**
	* Gets language part from url
	*
	* @param Array $url_parts
	* @param Array $vars
	* @return bool
	* @access protected
	*/
	protected function _parseLanguage(&$url_parts, &$vars)
	{
	if (!$url_parts) {
	return false;
	}

	$url_part = reset($url_parts);

	$sql = 'SELECT LanguageId, IF(LOWER(PackName) = ' . $this->Conn->qstr($url_part) . ', 2, PrimaryLang) AS SortKey
	FROM ' . TABLE_PREFIX . 'Languages
	WHERE Enabled = 1
	ORDER BY SortKey DESC';
	$language_info = $this->Conn->GetRow($sql);

	if ($language_info && $language_info['LanguageId'] && $language_info['SortKey']) {
	// primary language will be selected in case, when $url_part doesn't match to other's language pack name
	// don't use next enabled language, when primary language is disabled
	$vars['m_lang'] = $language_info['LanguageId'];

	if ($language_info['SortKey'] == 2) {
	// language was found by pack name
	array_shift($url_parts);
	$this->partParsed($url_part);
	}
	elseif ($this->primaryLanguageId) {
	// use domain-based primary language instead of site-wide primary language
	$vars['m_lang'] = $this->primaryLanguageId;
	}

	return true;
	}

	return false;
	}

	/**
	* Gets theme part from url
	*
	* @param Array $url_parts
	* @param Array $vars
	* @return bool
	*/
	protected function _parseTheme(&$url_parts, &$vars)
	{
	if (!$url_parts) {
	return false;
	}

	$url_part = reset($url_parts);

	$sql = 'SELECT ThemeId, IF(LOWER(Name) = ' . $this->Conn->qstr($url_part) . ', 2, PrimaryTheme) AS SortKey, TemplateAliases
	FROM ' . TABLE_PREFIX . 'Themes
	WHERE Enabled = 1
	ORDER BY SortKey DESC';
	$theme_info = $this->Conn->GetRow($sql);

	if ($theme_info && $theme_info['ThemeId'] && $theme_info['SortKey']) {
	// primary theme will be selected in case, when $url_part doesn't match to other's theme name
	// don't use next enabled theme, when primary theme is disabled
	$vars['m_theme'] = $theme_info['ThemeId'];

	if ($theme_info['TemplateAliases']) {
	$this->_templateAliases = unserialize($theme_info['TemplateAliases']);
	}
	else {
	$this->_templateAliases = Array ();
	}

	if ($theme_info['SortKey'] == 2) {
	// theme was found by name
	array_shift($url_parts);
	$this->partParsed($url_part);
	}
	elseif ($this->primaryThemeId) {
	// use domain-based primary theme instead of site-wide primary theme
	$vars['m_theme'] = $this->primaryThemeId;
	}

	return true;
	}

	$vars['m_theme'] = 0; // required, because used later for category/template detection

	return false;
	}

	/**
	* Parses real template name from url
	*
	* @param Array $url_parts
	* @param Array $vars
	* @return bool
	*/
	protected function _parsePhysicalTemplate($url_parts, &$vars)
	{
	if ( !$url_parts ) {
	return false;
	}

	$themes_helper = $this->Application->recallObject('ThemesHelper');
	/* @var $themes_helper kThemesHelper */

	do {
	$index_added = false;
	$template_path = implode('/', $url_parts);
	$template_found = $themes_helper->getTemplateId($template_path, $vars['m_theme']);

	if ( !$template_found ) {
	$index_added = true;
	$template_found = $themes_helper->getTemplateId($template_path . '/index', $vars['m_theme']);
	}

	if ( !$template_found ) {
	array_shift($url_parts);
	}
	} while ( !$template_found && $url_parts );

	if ( $template_found ) {
	$template_parts = explode('/', $template_path);
	$vars['t'] = $template_path . ($index_added ? '/index' : '');

	while ( $template_parts ) {
	$this->partParsed(array_pop($template_parts), 'rtl');
	}

	// 1. will damage actual category during category item review add process
	// 2. will use "use_section" parameter of "m_Link" tag to gain same effect
	// $vars['m_cat_id'] = $themes_helper->getPageByTemplate($template_path, $vars['m_theme']);

	return true;
	}

	return false;
	}

	/**
	* Returns environment variable values for given prefix (uses directly given params, when available)
	*
	* @param string $prefix_special
	* @param Array $params
	* @param bool $keep_events
	* @return Array
	* @access public
	*/
	public function getProcessedParams($prefix_special, &$params, $keep_events)
	{
	list ($prefix) = explode('.', $prefix_special);

	$query_vars = $this->Application->getUnitOption($prefix, 'QueryString', Array ());
	/* @var $query_vars Array */

	if ( !$query_vars ) {
	// given prefix doesn't use "env" variable to pass it's data
	return false;
	}

	$event_key = array_search('event', $query_vars);
	if ( $event_key ) {
	// pass through event of this prefix
	unset($query_vars[$event_key]);
	}

	if ( array_key_exists($prefix_special . '_event', $params) && !$params[$prefix_special . '_event'] ) {
	// if empty event, then remove it from url
	unset($params[$prefix_special . '_event']);
	}

	// if pass events is off and event is not implicity passed
	if ( !$keep_events && !array_key_exists($prefix_special . '_event', $params) ) {
	unset($params[$prefix_special . '_event']); // remove event from url if requested
	//otherwise it will use value from get_var
	}

	$processed_params = Array ();
	foreach ($query_vars as $var_name) {
	// if value passed in params use it, otherwise use current from application
	$var_name = $prefix_special . '_' . $var_name;
	$processed_params[$var_name] = array_key_exists($var_name, $params) ? $params[$var_name] : $this->Application->GetVar($var_name);

	if ( array_key_exists($var_name, $params) ) {
	unset($params[$var_name]);
	}
	}

	return $processed_params;
	}

	/**
	* Returns module item details template specified in given category custom field for given module prefix
	*
	* @param int\|Array $category
	* @param string $module_prefix
	* @param int $theme_id
	* @return string
	* @access public
	* @todo Move to kPlainUrlProcessor
	*/
	public function GetItemTemplate($category, $module_prefix, $theme_id = null)
	{
	if ( !isset($theme_id) ) {
	$theme_id = $this->Application->GetVar('m_theme');
	}

	$category_id = is_array($category) ? $category['CategoryId'] : $category;
	$cache_key = __CLASS__ . '::' . __FUNCTION__ . '[%CIDSerial:' . $category_id . '%][%ThemeIDSerial:' . $theme_id . '%]' . $module_prefix;

	$cached_value = $this->Application->getCache($cache_key);
	if ( $cached_value !== false ) {
	return $cached_value;
	}

	if ( !is_array($category) ) {
	if ( $category == 0 ) {
	$category = $this->Application->findModule('Var', $module_prefix, 'RootCat');
	}
	$sql = 'SELECT c.ParentPath, c.CategoryId
	FROM ' . TABLE_PREFIX . 'Categories AS c
	WHERE c.CategoryId = ' . $category;
	$category = $this->Conn->GetRow($sql);
	}
	$parent_path = implode(',', explode('\|', substr($category['ParentPath'], 1, -1)));

	// item template is stored in module' system custom field - need to get that field Id
	$primary_lang = $this->Application->GetDefaultLanguageId();
	$item_template_field_id = $this->getItemTemplateCustomField($module_prefix);

	// looking for item template through cats hierarchy sorted by parent path
	$query = ' SELECT ccd.l' . $primary_lang . '_cust_' . $item_template_field_id . ',
	FIND_IN_SET(c.CategoryId, ' . $this->Conn->qstr($parent_path) . ') AS Ord1,
	c.CategoryId, c.Name, ccd.l' . $primary_lang . '_cust_' . $item_template_field_id . '
	FROM ' . TABLE_PREFIX . 'Categories AS c
	LEFT JOIN ' . TABLE_PREFIX . 'CategoryCustomData AS ccd
	ON ccd.ResourceId = c.ResourceId
	WHERE c.CategoryId IN (' . $parent_path . ') AND ccd.l' . $primary_lang . '_cust_' . $item_template_field_id . ' != \'\'
	ORDER BY FIND_IN_SET(c.CategoryId, ' . $this->Conn->qstr($parent_path) . ') DESC';
	$item_template = $this->Conn->GetOne($query);

	if ( !isset($this->_templateAliases) ) {
	// when empty url OR mod-rewrite disabled

	$themes_helper = $this->Application->recallObject('ThemesHelper');
	/* @var $themes_helper kThemesHelper */

	$sql = 'SELECT TemplateAliases
	FROM ' . TABLE_PREFIX . 'Themes
	WHERE ThemeId = ' . (int)$themes_helper->getCurrentThemeId();
	$template_aliases = $this->Conn->GetOne($sql);

	$this->_templateAliases = $template_aliases ? unserialize($template_aliases) : Array ();
	}

	if ( substr($item_template, 0, 1) == '#' ) {
	// it's template alias + "#" isn't allowed in filenames
	$item_template = (string)getArrayValue($this->_templateAliases, $item_template);
	}

	$this->Application->setCache($cache_key, $item_template);

	return $item_template;
	}

	/**
	* Returns category custom field id, where given module prefix item template name is stored
	*
	* @param string $module_prefix
	* @return int
	* @access public
	* @todo Move to kPlainUrlProcessor; decrease visibility, since used only during upgrade
	*/
	public function getItemTemplateCustomField($module_prefix)
	{
	$cache_key = __CLASS__ . '::' . __FUNCTION__ . '[%CfSerial%]:' . $module_prefix;
	$cached_value = $this->Application->getCache($cache_key);

	if ($cached_value !== false) {
	return $cached_value;
	}

	$sql = 'SELECT CustomFieldId
	FROM ' . TABLE_PREFIX . 'CustomFields
	WHERE FieldName = ' . $this->Conn->qstr($module_prefix . '_ItemTemplate');
	$item_template_field_id = $this->Conn->GetOne($sql);

	$this->Application->setCache($cache_key, $item_template_field_id);

	return $item_template_field_id;
	}

	/**
	* Marks url part as parsed
	*
	* @param string $url_part
	* @param string $parse_direction
	* @access public
	*/
	public function partParsed($url_part, $parse_direction = 'ltr')
	{
	if ( !$this->_partsToParse ) {
	return ;
	}

	if ( $parse_direction == 'ltr' ) {
	$expected_url_part = reset($this->_partsToParse);

	if ( $url_part == $expected_url_part ) {
	array_shift($this->_partsToParse);
	}
	}
	else {
	$expected_url_part = end($this->_partsToParse);

	if ( $url_part == $expected_url_part ) {
	array_pop($this->_partsToParse);
	}
	}

	if ( $url_part != $expected_url_part ) {
	trigger_error('partParsed: expected URL part "<strong>' . $expected_url_part . '</strong>", received URL part "<strong>' . $url_part . '</strong>"', E_USER_NOTICE);
	}
	}

	/**
	* Determines if there is more to parse in url
	*
	* @return bool
	* @access public
	*/
	public function moreToParse()
	{
	return count($this->_partsToParse) > 0;
	}

	/**
	* Builds url
	*
	* @param string $t
	* @param Array $params
	* @param string $pass
	* @param bool $pass_events
	* @param bool $env_var
	* @return string
	* @access public
	*/
	public function build($t, $params, $pass = 'all', $pass_events = false, $env_var = false)
	{
	if ( $this->Application->GetVar('admin') \|\| (array_key_exists('admin', $params) && $params['admin']) ) {
	$params['admin'] = 1;

	if ( !array_key_exists('editing_mode', $params) ) {
	$params['editing_mode'] = EDITING_MODE;
	}
	}

	$ret = '';
	$env = '';

	if ( isset($params['__SSL__']) ) {
	unset($params['__SSL__']);
	}

	$catalog_item_found = false;
	$pass_info = $this->getPassInfo($pass);

	if ( $pass_info ) {
	if ( $pass_info[0] == 'm' ) {
	array_shift($pass_info);
	}

	$inject_parts = Array (); // url parts for beginning of url
	$params['t'] = $t; // make template available for rewrite listeners
	$params['pass_template'] = true; // by default we keep given template in resulting url

	if ( !array_key_exists('pass_category', $params) ) {
	$params['pass_category'] = false; // by default we don't keep categories in url
	}

	foreach ($pass_info as $pass_index => $pass_element) {
	list ($prefix) = explode('.', $pass_element);
	$catalog_item = $this->Application->findModule('Var', $prefix) && $this->Application->getUnitOption($prefix, 'CatalogItem');

	if ( array_key_exists($prefix, $this->rewriteListeners) ) {
	// if next prefix is same as current, but with special => exclude current prefix from url
	$next_prefix = array_key_exists($pass_index + 1, $pass_info) ? $pass_info[$pass_index + 1] : false;
	if ( $next_prefix ) {
	$next_prefix = substr($next_prefix, 0, strlen($prefix) + 1);
	if ( $prefix . '.' == $next_prefix ) {
	continue;
	}
	}

	// rewritten url part
	$url_part = $this->BuildModuleEnv($pass_element, $params, $pass_events);

	if ( is_string($url_part) && $url_part ) {
	$ret .= $url_part . '/';

	if ( $catalog_item ) {
	// pass category later only for catalog items
	$catalog_item_found = true;
	}
	}
	elseif ( is_array($url_part) ) {
	// rewrite listener want to insert something at the beginning of url too
	if ( $url_part[0] ) {
	$inject_parts[] = $url_part[0];
	}

	if ( $url_part[1] ) {
	$ret .= $url_part[1] . '/';
	}

	if ( $catalog_item ) {
	// pass category later only for catalog items
	$catalog_item_found = true;
	}
	}
	elseif ( $url_part === false ) {
	// rewrite listener decided not to rewrite given $pass_element
	$env .= ':' . $this->manager->plain->BuildModuleEnv($pass_element, $params, $pass_events);
	}
	}
	else {
	$env .= ':' . $this->manager->plain->BuildModuleEnv($pass_element, $params, $pass_events);
	}
	}

	if ( $catalog_item_found \|\| preg_match('/c\.[-\d]*/', implode(',', $pass_info)) ) {
	// "c" prefix is present -> keep category
	$params['pass_category'] = true;
	}

	$params['inject_parts'] = $inject_parts;

	$ret = $this->BuildModuleEnv('m', $params, $pass_events) . '/' . $ret;
	$cat_processed = array_key_exists('category_processed', $params) && $params['category_processed'];

	// remove temporary parameters used by listeners
	unset($params['t'], $params['inject_parts'], $params['pass_template'], $params['pass_category'], $params['category_processed']);

	$ret = trim($ret, '/');

	if ( isset($params['url_ending']) ) {
	if ( $ret ) {
	$ret .= $params['url_ending'];
	}

	unset($params['url_ending']);
	}
	elseif ( $ret ) {
	$ret .= MOD_REWRITE_URL_ENDING;
	}

	if ( $env ) {
	$params[ENV_VAR_NAME] = ltrim($env, ':');
	}
	}

	unset($params['pass'], $params['opener'], $params['m_event']);

	// TODO: why?
	// $ret = str_replace('%2F', '/', urlencode($ret));

	if ( $params ) {
	$params_str = http_build_query($params);
	$ret .= '?' . str_replace('%23', '#', $params_str);
	}

	return $ret;
	}

	/**
	* Builds env part that corresponds prefix passed
	*
	* @param string $prefix_special item's prefix & [special]
	* @param Array $params url params
	* @param bool $pass_events
	* @return string
	* @access protected
	*/
	protected function BuildModuleEnv($prefix_special, &$params, $pass_events = false)
	{
	list ($prefix) = explode('.', $prefix_special);

	$url_parts = Array ();
	$listener = $this->rewriteListeners[$prefix][0];

	- $ret = $listener[0]->$listener[1](REWRITE_MODE_BUILD, $prefix_special, $params, $url_parts, $pass_events);
	+ $ret = call_user_func_array(
	+ $listener,
	+ array(REWRITE_MODE_BUILD, $prefix_special, &$params, &$url_parts, $pass_events)
	+ );

	return $ret;
	}
	}
	Index: branches/5.2.x/core/kernel/utility/unit_config_reader.php
	===================================================================
	--- branches/5.2.x/core/kernel/utility/unit_config_reader.php (revision 16482)
	+++ branches/5.2.x/core/kernel/utility/unit_config_reader.php (revision 16483)
	@@ -1,1041 +1,1044 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	class kUnitConfigReader extends kBase implements kiCacheable {

	/**
	* Configs reader
	*
	* @var Array
	* @access private
	*/
	var $configData = Array();
	var $configFiles = Array();

	var $CacheExpired = false;

	var $prefixFiles = array();

	var $ProcessAllConfigs = false;
	var $FinalStage = false;
	var $StoreCache = false;
	var $AfterConfigProcessed = array();

	/**
	* Escaped directory separator for using in regular expressions
	*
	* @var string
	*/
	var $_directorySeparator = '';

	/**
	* Regular expression for detecting module folder
	*
	* @var string
	*/
	var $_moduleFolderRegExp = '';

	/**
	* Folders to skip during unit config search
	*
	* @var Array
	*/
	var $_skipFolders = Array ('CVS', '.svn', '.git', 'admin_templates', 'libchart', 'install');

	/**
	* Creates instance of unit config reader
	*
	*/
	public function __construct()
	{
	parent::__construct();

	$this->_directorySeparator = preg_quote(DIRECTORY_SEPARATOR);

	$this->_skipFolders[] = basename(EDITOR_PATH);

	$this->_moduleFolderRegExp = '#' . $this->_directorySeparator . '(core\|modules' . $this->_directorySeparator . '.*?)' . $this->_directorySeparator . '#';
	}

	/**
	* Sets data from cache to object
	*
	* @param Array $data
	* @access public
	*/
	public function setFromCache(&$data)
	{
	$this->prefixFiles = $data['ConfigReader.prefixFiles'];
	}

	/**
	* Gets object data for caching
	*
	* @access public
	* @return Array
	*/
	public function getToCache()
	{
	return Array (
	'ConfigReader.prefixFiles' => $this->prefixFiles,
	);
	}

	function scanModules($folderPath, $cache = true)
	{
	if (defined('IS_INSTALL') && IS_INSTALL && !defined('FORCE_CONFIG_CACHE')) {
	// disable config caching during installation
	$cache = false;
	}

	if ($cache) {
	$restored = $this->Application->cacheManager->LoadUnitCache();

	if ($restored) {
	if ( defined('DEBUG_MODE') && DEBUG_MODE && $this->Application->isDebugMode() ) {
	$this->Application->Debugger->appendHTML('UnitConfigReader: Restoring Cache');
	}

	return;
	}
	}

	if ( defined('DEBUG_MODE') && DEBUG_MODE && $this->Application->isDebugMode() ) {
	$this->Application->Debugger->appendHTML('UnitConfigReader: Generating Cache');
	}

	$this->ProcessAllConfigs = true;

	$this->includeConfigFiles($folderPath, $cache);
	$this->ParseConfigs();

	// tell AfterConfigRead to store cache if needed
	// can't store it here because AfterConfigRead needs ability to change config data
	$this->StoreCache = $cache;

	if ( !$this->Application->InitDone ) {
	// scanModules is called multiple times during installation process
	$this->Application->InitManagers();

	// get build-in rewrite listeners ONLY to be able to parse mod-rewrite url when unit config cache is missing
	$this->retrieveCollections();
	$this->_sortRewriteListeners();
	}

	$this->Application->cacheManager->applyDelayedUnitProcessing();

	if ( !$this->Application->InitDone && $cache ) {
	// Allow hooks to modify "m:QueryString" before URL parsing is started during cold start.
	$this->runAfterConfigRead('m');
	}
	}

	function findConfigFiles($folderPath, $level = 0)
	{
	// If FULL_PATH = "/" ensure, that all "/" in $folderPath are not deleted.
	$reg_exp = '/^' . preg_quote(FULL_PATH, '/') . '/';

	// This make sense, since $folder_path may NOT contain FULL_PATH.
	$folderPath = preg_replace($reg_exp, '', $folderPath, 1);

	$base_folder = FULL_PATH . $folderPath . DIRECTORY_SEPARATOR;
	$sub_folders = glob($base_folder . '*', GLOB_ONLYDIR);
	if (!$sub_folders) {
	return ;
	}

	foreach ($sub_folders as $full_path) {
	$sub_folder = substr($full_path, strlen($base_folder));

	if (in_array($sub_folder, $this->_skipFolders)) {
	continue;
	}

	if (substr($sub_folder, 0, 1) == '.') {
	// Don't scan ".folders".
	continue;
	}

	$config_name = $this->getConfigName($folderPath . DIRECTORY_SEPARATOR . $sub_folder);

	if (file_exists(FULL_PATH . $config_name)) {
	$this->configFiles[] = $config_name;
	}

	$this->findConfigFiles($full_path, $level + 1);
	}
	}

	function includeConfigFiles($folderPath, $cache = true)
	{
	$data = false;
	$this->Application->refreshModuleInfo();

	if ( $cache ) {
	if ( $this->Application->isCachingType(CACHING_TYPE_MEMORY) ) {
	$data = $this->Application->getCache(
	'master:config_files',
	false,
	CacheSettings::$unitCacheRebuildTime
	);
	}
	else {
	$data = $this->Application->getDBCache(
	'config_files',
	CacheSettings::$unitCacheRebuildTime
	);
	}
	}

	if ( $data ) {
	$this->configFiles = unserialize($data);

	if ( !(defined('DBG_VALIDATE_CONFIGS') && DBG_VALIDATE_CONFIGS) ) {
	shuffle($this->configFiles);
	}
	}
	else {
	/*if ( $this->Application->isDebugMode() ) {
	$this->Application->Debugger->profileStart('fcf');
	}*/

	$this->findConfigFiles(FULL_PATH . DIRECTORY_SEPARATOR . 'core'); // Search from core directory.
	$this->findConfigFiles($folderPath); // Search from modules directory.

	/*if ( $this->Application->isDebugMode() ) {
	$this->Application->Debugger->profileFinish(
	'fcf',
	'findConfigFiles [' . count($this->configFiles) . ']'
	);
	}*/

	if ( $cache ) {
	if ( $this->Application->isCachingType(CACHING_TYPE_MEMORY) ) {
	$this->Application->setCache('master:config_files', serialize($this->configFiles));
	}
	else {
	$this->Application->setDBCache('config_files', serialize($this->configFiles));
	}
	}
	}

	foreach ($this->configFiles as $filename) {
	$prefix = $this->PreloadConfigFile($filename);

	if (!$prefix) {
	throw new Exception('Prefix not defined in config file <strong>' . $filename . '</strong>');
	}
	}

	if ($cache) {
	unset($this->configFiles);
	}
	}

	/**
	* Process all read config files - called ONLY when there is no cache!
	*
	*/
	function ParseConfigs()
	{
	// 1. process normal configs
	$prioritized_configs = array();
	foreach ($this->configData as $prefix => $config) {
	if (isset($config['ConfigPriority'])) {
	$prioritized_configs[$prefix] = $config['ConfigPriority'];
	continue;
	}
	$this->parseConfig($prefix);
	}

	foreach ($this->configData as $prefix => $config) {
	$this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');
	}

	// 2. process prioritized configs
	asort($prioritized_configs);
	foreach ($prioritized_configs as $prefix => $priority) {
	$this->parseConfig($prefix);
	}
	}

	function AfterConfigRead($store_cache = null)
	{
	// if (!$this->ProcessAllConfigs) return ;
	$this->FinalStage = true;
	foreach ($this->configData as $prefix => $config) {
	$this->runAfterConfigRead($prefix);
	}

	if ( !isset($store_cache) ) {
	// $store_cache not overridden -> use global setting
	$store_cache = $this->StoreCache;
	}

	if ($store_cache \|\| (defined('IS_INSTALL') && IS_INSTALL)) {
	// cache is not stored during install, but dynamic clones should be processed in any case
	$this->processDynamicClones();
	$this->retrieveCollections();
	}

	if ($store_cache) {
	$this->_sortRewriteListeners();

	$this->Application->HandleEvent(new kEvent('adm:OnAfterCacheRebuild'));

	$this->Application->cacheManager->UpdateUnitCache();

	if (defined('DEBUG_MODE') && DEBUG_MODE && defined('DBG_VALIDATE_CONFIGS') && DBG_VALIDATE_CONFIGS) {
	// validate configs here to have changes from OnAfterConfigRead hooks to prefixes
	foreach ($this->configData as $prefix => $config) {
	if (!isset($config['TableName'])) continue;
	$this->ValidateConfig($prefix);
	}
	}
	}
	}

	/**
	* Sort rewrite listeners according to RewritePriority (non-prioritized listeners goes first)
	*
	*/
	function _sortRewriteListeners()
	{
	$listeners = Array ();
	$prioritized_listeners = Array ();

	// process non-prioritized listeners
	foreach ($this->Application->RewriteListeners as $prefix => $listener_data) {
	if ($listener_data['priority'] === false) {
	$listeners[$prefix] = $listener_data;
	}
	else {
	$prioritized_listeners[$prefix] = $listener_data['priority'];
	}
	}

	// process prioritized listeners
	asort($prioritized_listeners, SORT_NUMERIC);
	foreach ($prioritized_listeners as $prefix => $priority) {
	$listeners[$prefix] = $this->Application->RewriteListeners[$prefix];
	}

	$this->Application->RewriteListeners = $listeners;
	}

	/**
	* Re-reads all configs
	*
	*/
	function ReReadConfigs()
	{
	// don't reset prefix file, since file scanning could slow down the process
	$prefix_files_backup = $this->prefixFiles;
	$this->Application->cacheManager->EmptyUnitCache();
	$this->prefixFiles = $prefix_files_backup;

	// parse all configs
	$this->ProcessAllConfigs = true;
	$this->AfterConfigProcessed = Array ();
	$this->includeConfigFiles(MODULES_PATH, false);
	$this->ParseConfigs();
	$this->AfterConfigRead(false);
	$this->processDynamicClones();

	// don't call kUnitConfigReader::retrieveCollections since it
	// will overwrite what we already have in kApplication class instance
	}

	/**
	* Process clones, that were defined via OnAfterConfigRead event
	*
	*/
	function processDynamicClones()
	{
	$new_clones = Array();
	foreach ($this->configData as $prefix => $config) {
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');

	if ($clones) {
	$new_clones = array_merge($new_clones, $clones);
	}
	}

	// execute delayed methods for cloned unit configs
	$this->Application->cacheManager->applyDelayedUnitProcessing();

	// call OnAfterConfigRead for cloned configs
	$new_clones = array_unique($new_clones);
	foreach ($new_clones as $prefix) {
	$this->runAfterConfigRead($prefix);
	}
	}

	/**
	* Process all collectible unit config options here to also catch ones, defined from OnAfterConfigRead events
	*
	*/
	function retrieveCollections()
	{
	foreach ($this->configData as $prefix => $config) {
	// collect replacement templates
	if (array_key_exists('ReplacementTemplates', $config) && $config['ReplacementTemplates']) {
	$this->Application->ReplacementTemplates = array_merge($this->Application->ReplacementTemplates, $config['ReplacementTemplates']);
	}

	// collect rewrite listeners
	if (array_key_exists('RewriteListener', $config) && $config['RewriteListener']) {
	$rewrite_listeners = $config['RewriteListener'];

	if (!is_array($rewrite_listeners)) {
	// when one method is used to build and parse url
	$rewrite_listeners = Array ($rewrite_listeners, $rewrite_listeners);
	}

	foreach ($rewrite_listeners as $index => $rewrite_listener) {
	if (strpos($rewrite_listener, ':') === false) {
	$rewrite_listeners[$index] = $prefix . '_EventHandler:' . $rewrite_listener;
	}
	}

	$rewrite_priority = array_key_exists('RewritePriority', $config) ? $config['RewritePriority'] : false;

	$this->Application->RewriteListeners[$prefix] = Array ('listener' => $rewrite_listeners, 'priority' => $rewrite_priority);
	}
	}
	}

	/**
	* Register nessasary classes
	* This method should only process the data which is cached!
	*
	* @param string $prefix
	* @access private
	*/
	function parseConfig($prefix)
	{
	$this->parseClasses($prefix);
	$this->parseScheduledTasks($prefix);
	$this->parseHooks($prefix);
	$this->parseAggregatedTags($prefix);
	}

	protected function parseClasses($prefix)
	{
	$config =& $this->configData[$prefix];
	$register_classes = $this->getClasses($prefix);

	foreach ($register_classes as $class_info) {
	$this->Application->registerClass(
	$class_info['class'],
	$config['BasePath'] . DIRECTORY_SEPARATOR . $class_info['file'],
	$class_info['pseudo']
	);

	if ( isset($class_info['build_event']) && $class_info['build_event'] ) {
	$this->Application->delayUnitProcessing('registerBuildEvent', Array ($class_info['pseudo'], $class_info['build_event']));
	}
	}
	}

	protected function parseScheduledTasks($prefix)
	{
	$config =& $this->configData[$prefix];

	if ( !isset($config['ScheduledTasks']) \|\| !$config['ScheduledTasks'] ) {
	return ;
	}

	$scheduled_tasks = $config['ScheduledTasks'];

	foreach ($scheduled_tasks as $short_name => $scheduled_task_info) {
	$event_status = array_key_exists('Status', $scheduled_task_info) ? $scheduled_task_info['Status'] : STATUS_ACTIVE;
	$this->Application->delayUnitProcessing('registerScheduledTask', Array ( $short_name, $config['Prefix'] . ':' . $scheduled_task_info['EventName'], $scheduled_task_info['RunSchedule'], $event_status ));
	}
	}

	protected function parseHooks($prefix)
	{
	$config =& $this->configData[$prefix];

	if ( !isset($config['Hooks']) \|\| !$config['Hooks'] ) {
	return ;
	}

	$hooks = $config['Hooks'];

	foreach ($hooks as $hook) {
	if ( isset($config['ParentPrefix']) && ($hook['HookToPrefix'] == $config['ParentPrefix']) ) {
	trigger_error('Depricated Hook Usage [prefix: <strong>' . $config['Prefix'] . '</strong>; do_prefix: <strong>' . $hook['DoPrefix'] . '</strong>] use <strong>#PARENT#</strong> as <strong>HookToPrefix</strong> value, where HookToPrefix is same as ParentPrefix', defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_NOTICE);
	}

	if ($hook['HookToPrefix'] == '') {
	// new: set hooktoprefix to current prefix if not set
	$hook['HookToPrefix'] = $config['Prefix'];
	}

	if ( isset($config['ParentPrefix']) ) {
	// new: allow to set hook to parent prefix what ever it is
	if ($hook['HookToPrefix'] == '#PARENT#') {
	$hook['HookToPrefix'] = $config['ParentPrefix'];
	}

	if ($hook['DoPrefix'] == '#PARENT#') {
	$hook['DoPrefix'] = $config['ParentPrefix'];
	}
	}
	elseif ($hook['HookToPrefix'] == '#PARENT#' \|\| $hook['DoPrefix'] == '#PARENT#') {
	// we need parent prefix but it's not set !
	continue;
	}

	$hook_events = (array)$hook['HookToEvent'];
	$do_prefix = $hook['DoPrefix'] == '' ? $config['Prefix'] : $hook['DoPrefix'];

	foreach ($hook_events as $hook_event) {
	$hook_event = $hook['HookToPrefix'] . '.' . $hook['HookToSpecial'] . ':' . $hook_event;
	$do_event = $do_prefix . '.' . $hook['DoSpecial'] . ':' . $hook['DoEvent'];

	$this->Application->delayUnitProcessing('registerHook', Array ($hook_event, $do_event, $hook['Mode'], $hook['Conditional']));
	}
	}
	}

	protected function parseAggregatedTags($prefix)
	{
	$config =& $this->configData[$prefix];
	$aggregated_tags = isset($config['AggregateTags']) ? $config['AggregateTags'] : Array ();

	foreach ($aggregated_tags as $aggregate_tag) {
	if ( isset($config['ParentPrefix']) ) {
	if ($aggregate_tag['AggregateTo'] == $config['ParentPrefix']) {
	trigger_error('Depricated Aggregate Tag Usage [prefix: <b>'.$config['Prefix'].'</b>; AggregateTo: <b>'.$aggregate_tag['AggregateTo'].'</b>] use <b>#PARENT#</b> as <b>AggregateTo</b> value, where AggregateTo is same as ParentPrefix', defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_NOTICE);
	}

	if ($aggregate_tag['AggregateTo'] == '#PARENT#') {
	$aggregate_tag['AggregateTo'] = $config['ParentPrefix'];
	}
	}

	$aggregate_tag['LocalPrefix'] = $config['Prefix'];
	$this->Application->delayUnitProcessing('registerAggregateTag', Array ($aggregate_tag));
	}
	}

	function ValidateConfig($prefix)
	{
	global $debugger;

	$config =& $this->configData[$prefix];

	$tablename = $config['TableName'];
	$float_types = Array ('float', 'double', 'numeric');

	$table_found = $this->Conn->Query('SHOW TABLES LIKE "'.$tablename.'"');
	if (!$table_found) {
	// config present, but table missing, strange
	kUtil::safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	$debugger->appendHTML("<b class='debug_error'>Config Warning: </b>Table <strong>$tablename</strong> missing, but prefix <b>".$config['Prefix']."</b> requires it!");
	$debugger->WarningCount++;

	return ;
	}

	$res = $this->Conn->Query('DESCRIBE '.$tablename);
	$config_link = $debugger->getFileLink(FULL_PATH.$this->prefixFiles[$config['Prefix']], 1, $config['Prefix']);

	$error_messages = Array (
	'field_not_found' => 'Field <strong>%s</strong> exists in the database, but <strong>is not defined</strong> in config',
	'default_missing' => 'Default value for field <strong>%s</strong> not set in config',
	'not_null_error1' => 'Field <strong>%s</strong> is NOT NULL in the database, but is not configured as not_null', // or required',
	'not_null_error2' => 'Field <strong>%s</strong> is described as NOT NULL in config, but <strong>does not have DEFAULT value</strong>',
	'not_null_error3' => 'Field <strong>%s</strong> is described as <strong>NOT NULL in config</strong>, but is <strong>NULL in db</strong>',
	'invalid_default' => '<strong>Default value</strong> for field %s<strong>%s</strong> not sync. to db (in config = %s, in db = %s)',
	'date_column_not_null_error' => 'Field <strong>%s</strong> must be NULL in config and database, since it contains date',
	'user_column_default_error' => 'Field <strong>%s</strong> must be have NULL as default value, since it holds user id',
	'type_missing' => '<strong>Type definition</strong> for field <strong>%s</strong> missing in config',
	'virtual_type_missing' => '<strong>Type definition</strong> for virtual field <strong>%s</strong> missing in config',
	'virtual_default_missing' => 'Default value for virtual field <strong>%s</strong> not set in config',
	'virtual_not_null_error' => 'Virtual field <strong>%s</strong> cannot be not null, since it doesn\'t exist in database',
	'invalid_calculated_field' => 'Calculated field <strong>%s</strong> is missing corresponding virtual field',
	);

	$config_errors = Array ();
	$tablename = preg_replace('/^'.preg_quote(TABLE_PREFIX, '/').'(.*)/', '\\1', $tablename); // remove table prefix

	// validate unit config field declaration in relation to database table structure
	foreach ($res as $field) {
	$f_name = $field['Field'];

	if (getArrayValue($config, 'Fields')) {
	if (preg_match('/l[\d]+_[\w]/', $f_name)) {
	// skip multilingual fields
	continue;
	}

	if (!array_key_exists ($f_name, $config['Fields'])) {
	$config_errors[] = sprintf($error_messages['field_not_found'], $f_name);
	}
	else {
	$db_default = $field['Default'];

	if (is_numeric($db_default)) {
	$db_default = preg_match('/[\.,]/', $db_default) ? (float)$db_default : (int)$db_default;
	}

	$default_missing = false;
	$options = $config['Fields'][$f_name];
	$not_null = isset($options['not_null']) && $options['not_null'];
	$formatter = array_key_exists('formatter', $options) ? $options['formatter'] : false;

	if (!array_key_exists('default', $options)) {
	$config_errors[] = sprintf($error_messages['default_missing'], $f_name);
	$default_missing = true;
	}

	if ($field['Null'] != 'YES') {
	// field is NOT NULL in database (MySQL5 for null returns "NO", but MySQL4 returns "")
	if ( $f_name != $config['IDField'] && !isset($options['not_null']) /&& !isset($options['required'])/ ) {
	$config_errors[] = sprintf($error_messages['not_null_error1'], $f_name);
	}
	if ($not_null && !isset($options['default']) ) {
	$config_errors[] = sprintf($error_messages['not_null_error2'], $f_name);
	}
	}
	elseif ($not_null) {
	$config_errors[] = sprintf($error_messages['not_null_error3'], $f_name);
	}

	if (($formatter == 'kDateFormatter') && $not_null) {
	$config_errors[] = sprintf($error_messages['date_column_not_null_error'], $f_name);
	}

	// columns, holding userid should have NULL as default value
	if (array_key_exists('type', $options) && !$default_missing) {
	// both type and default value set

	if (preg_match('/ById$/', $f_name) && $options['default'] !== null) {
	$config_errors[] = sprintf($error_messages['user_column_default_error'], $f_name);
	}
	}

	if (!array_key_exists('type', $options)) {
	$config_errors[] = sprintf($error_messages['type_missing'], $f_name);
	}

	if (!$default_missing && ($field['Type'] != 'text')) {
	if ( is_null($db_default) && $not_null ) {
	$db_default = $options['type'] == 'string' ? '' : 0;
	}

	if ($f_name == $config['IDField'] && $options['type'] != 'string' && $options['default'] !== 0) {
	$config_errors[] = sprintf($error_messages['invalid_default'], '<span class="debug_error">IDField</span> ', $f_name, $this->varDump($options['default']), $this->varDump($field['Default']));
	}
	else if (((string)$options['default'] != '#NOW#') && ($db_default !== $options['default']) && !in_array($options['type'], $float_types)) {
	$config_errors[] = sprintf($error_messages['invalid_default'], '', $f_name, $this->varDump($options['default']), $this->varDump($db_default));
	}
	}
	}
	}
	}

	// validate virtual fields
	if ( array_key_exists('VirtualFields', $config) ) {
	foreach ($config['VirtualFields'] as $f_name => $options) {
	if (!array_key_exists('type', $options)) {
	$config_errors[] = sprintf($error_messages['virtual_type_missing'], $f_name);
	}

	if (array_key_exists('not_null', $options)) {
	$config_errors[] = sprintf($error_messages['virtual_not_null_error'], $f_name);
	}

	if (!array_key_exists('default', $options)) {
	$config_errors[] = sprintf($error_messages['virtual_default_missing'], $f_name);
	}
	}
	}

	// validate calculated fields
	if ( array_key_exists('CalculatedFields', $config) ) {
	foreach ($config['CalculatedFields'] as $special => $calculated_fields) {
	foreach ($calculated_fields as $calculated_field => $calculated_field_expr) {
	if ( !isset($config['VirtualFields'][$calculated_field]) ) {
	$config_errors[] = sprintf($error_messages['invalid_calculated_field'], $calculated_field);
	}
	}
	}

	$config_errors = array_unique($config_errors);
	}

	if ($config_errors) {
	$error_prefix = '<strong class="debug_error">Config Error'.(count($config_errors) > 1 ? 's' : '').': </strong> for prefix <strong>'.$config_link.'</strong> ('.$tablename.') in unit config:<br />';
	$config_errors = $error_prefix.'   '.implode('<br />   ', $config_errors);

	kUtil::safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	$debugger->appendHTML($config_errors);
	$debugger->WarningCount++;
	}
	}

	function varDump($value)
	{
	return '<strong>'.var_export($value, true).'</strong> of '.gettype($value);
	}

	function postProcessConfig($prefix, $config_key, $dst_prefix_var)
	{
	$main_config =& $this->configData[$prefix];
	$sub_configs = isset($main_config[$config_key]) && $main_config[$config_key] ? $main_config[$config_key] : Array ();
	if ( !$sub_configs ) {
	return Array ();
	}
	unset($main_config[$config_key]);

	$processed = array();
	foreach ($sub_configs as $sub_prefix => $sub_config) {
	if ($config_key == 'AggregateConfigs' && !isset($this->configData[$sub_prefix])) {
	$this->loadConfig($sub_prefix);
	}
	$sub_config['Prefix'] = $sub_prefix;
	$this->configData[$sub_prefix] = kUtil::array_merge_recursive($this->configData[$$dst_prefix_var], $sub_config);

	// when merging empty array to non-empty results non-empty array, but empty is required
	foreach ($sub_config as $sub_key => $sub_value) {
	if (!$sub_value) {
	unset($this->configData[$sub_prefix][$sub_key]);
	}
	}
	if ($config_key == 'Clones') {
	$this->prefixFiles[$sub_prefix] = $this->prefixFiles[$prefix];
	}

	$this->postProcessConfig($sub_prefix, $config_key, $dst_prefix_var);
	if ($config_key == 'AggregateConfigs') {
	$processed = array_merge($this->postProcessConfig($sub_prefix, 'Clones', 'prefix'), $processed);
	}
	elseif ($this->ProcessAllConfigs) {
	$this->parseConfig($sub_prefix);
	}
	array_push($processed, $sub_prefix);
	}

	if (!$prefix) {
	// configs, that used only for cloning & not used ifself
	unset($this->configData[$prefix]);
	}
	return array_unique($processed);
	}

	function PreloadConfigFile($filename)
	{
	$config_found = file_exists(FULL_PATH . $filename) && $this->configAllowed($filename);

	if (defined('DEBUG_MODE') && DEBUG_MODE && defined('DBG_PROFILE_INCLUDES') && DBG_PROFILE_INCLUDES) {
	if ( in_array($filename, get_included_files()) ) {
	return '';
	}

	global $debugger;

	if ($config_found) {
	$file = FULL_PATH . $filename;
	$file_crc = crc32($file);

	$debugger->ProfileStart('inc_' . $file_crc, $file);
	include_once($file);
	$debugger->ProfileFinish('inc_' . $file_crc);
	$debugger->profilerAddTotal('includes', 'inc_' . $file_crc);
	}
	}
	elseif ($config_found) {
	include_once(FULL_PATH . $filename);
	}

	if ($config_found) {
	if (isset($config) && $config) {
	// config file is included for 1st time -> save it's content for future processing
	$prefix = array_key_exists('Prefix', $config) ? $config['Prefix'] : '';

	preg_match($this->_moduleFolderRegExp, $filename, $rets);
	$config['ModuleFolder'] = str_replace(DIRECTORY_SEPARATOR, '/', $rets[1]);
	$config['BasePath'] = dirname(FULL_PATH . $filename);

	if (array_key_exists('AdminTemplatePath', $config)) {
	// append template base folder for admin templates path of this prefix
	$module_templates = $rets[1] == 'core' ? '' : substr($rets[1], 8) . '/';
	$config['AdminTemplatePath'] = $module_templates . $config['AdminTemplatePath'];
	}

	if (array_key_exists($prefix, $this->prefixFiles) && ($this->prefixFiles[$prefix] != $filename)) {
	trigger_error(
	'Single unit config prefix "<strong>' . $prefix . '</strong>" ' .
	'is used in multiple unit config files: ' .
	'"<strong>' . $this->prefixFiles[$prefix] . '</strong>", "<strong>' . $filename . '</strong>"',
	E_USER_WARNING
	);
	}

	$this->configData[$prefix] = $config;
	$this->prefixFiles[$prefix] = $filename;

	return $prefix;
	}
	else {
	$prefix = array_search($filename, $this->prefixFiles);

	if ( $prefix ) {
	// attempt is made to include config file twice or more, but include_once prevents that,
	// but file exists on hdd, then it is already saved to all required arrays, just return it's prefix
	return $prefix;
	}
	}
	}

	return 'dummy';
	}

	function loadConfig($prefix)
	{
	if ( !isset($this->prefixFiles[$prefix]) ) {
	throw new Exception('Configuration file for prefix "<strong>' . $prefix . '</strong>" is unknown');

	return ;
	}

	$file = $this->prefixFiles[$prefix];
	$prefix = $this->PreloadConfigFile($file);

	if ( $this->FinalStage \|\| $prefix == 'm' ) {
	// Run prefix OnAfterConfigRead so all hooks to it can define their clones.
	// Allow hooks to modify "m:QueryString" before URL parsing is started during warm start.
	$this->runAfterConfigRead($prefix);
	}

	$clones = $this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = array_merge($this->postProcessConfig($prefix, 'Clones', 'prefix'), $clones);

	if ($this->FinalStage) {
	$clones = array_unique($clones);

	foreach ($clones as $a_prefix) {
	$this->runAfterConfigRead($a_prefix);
	}
	}
	}

	function runAfterConfigRead($prefix)
	{
	if (in_array($prefix, $this->AfterConfigProcessed)) {
	return ;
	}

	$this->Application->HandleEvent( new kEvent($prefix . ':OnAfterConfigRead') );

	if (!(defined('IS_INSTALL') && IS_INSTALL)) {
	// allow to call OnAfterConfigRead multiple times during install
	array_push($this->AfterConfigProcessed, $prefix);
	}
	}

	/**
	* Reads unit (specified by $prefix)
	* option specified by $option
	*
	* @param string $prefix
	* @param string $name
	* @param mixed $default
	* @return string
	* @access public
	*/
	function getUnitOption($prefix, $name, $default = false)
	{
	if (preg_match('/(.)\.(.)/', $prefix, $rets)) {
	if (!isset($this->configData[$rets[1]])) {
	$this->loadConfig($rets[1]);
	}
	$ret = isset($this->configData[$rets[1]][$name][$rets[2]]) ? $this->configData[$rets[1]][$name][$rets[2]] : false;
	// $ret = getArrayValue($this->configData, $rets[1], $name, $rets[2]);
	}
	else {
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}
	$ret = isset($this->configData[$prefix][$name]) ? $this->configData[$prefix][$name] : false;
	// $ret = getArrayValue($this->configData, $prefix, $name);
	}
	return $ret === false ? $default : $ret;
	}

	/**
	* Read all unit with $prefix options
	*
	* @param string $prefix
	* @return Array
	* @access public
	*/
	function getUnitOptions($prefix)
	{
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}

	return $this->configData[$prefix];
	}

	/**
	* Set's new unit option value
	*
	* @param string $prefix
	* @param string $name
	* @param string $value
	* @access public
	*/
	function setUnitOption($prefix, $name, $value)
	{
	if ( preg_match('/(.)\.(.)/', $prefix, $rets) ) {
	if ( !isset($this->configData[$rets[1]]) ) {
	$this->loadConfig($rets[1]);
	}

	$this->configData[$rets[1]][$name][$rets[2]] = $value;
	}
	else {
	if ( !isset($this->configData[$prefix]) ) {
	$this->loadConfig($prefix);
	}

	$this->configData[$prefix][$name] = $value;
	}
	}

	protected function getClasses($prefix)
	{
	$config =& $this->configData[$prefix];
	$class_params = Array ('ItemClass', 'ListClass', 'EventHandlerClass', 'TagProcessorClass');
	$register_classes = isset($config['RegisterClasses']) ? $config['RegisterClasses'] : Array ();

	foreach ($class_params as $param_name) {
	if ( !isset($config[$param_name]) ) {
	continue;
	}

	$config[$param_name]['pseudo'] = $this->getPseudoByOptionName($param_name, $prefix);
	$register_classes[] = $config[$param_name];
	}

	return $register_classes;
	}

	protected function getPseudoByOptionName($option_name, $prefix)
	{
	$pseudo_class_map = Array (
	'ItemClass' => '%s',
	'ListClass' => '%s_List',
	'EventHandlerClass' => '%s_EventHandler',
	'TagProcessorClass' => '%s_TagProcessor'
	);

	return sprintf($pseudo_class_map[$option_name], $prefix);
	}

	/**
	* Get's config file name based
	* on folder name supplied
	*
	* @param string $folderPath
	* @return string
	* @access private
	*/
	function getConfigName($folderPath)
	{
	return $folderPath . DIRECTORY_SEPARATOR . basename($folderPath) . '_config.php';
	}

	/**
	* Checks if config file is allowed for includion (if module of config is installed)
	*
	* @param string $config_path relative path from in-portal directory
	*/
	function configAllowed($config_path)
	{
	static $module_paths = null;

	if (defined('IS_INSTALL') && IS_INSTALL) {
	// at installation start no modules in db and kernel configs could not be read
	return true;
	}

	if (preg_match('#^' . $this->_directorySeparator . 'core#', $config_path)) {
	// always allow to include configs from "core" module's folder
	return true;
	}

	if (!$this->Application->ModuleInfo) {
	return false;
	}

	if (!isset($module_paths)) {
	$module_paths = Array ();

	foreach ($this->Application->ModuleInfo as $module_name => $module_info) {
	$module_paths[] = str_replace('/', DIRECTORY_SEPARATOR, rtrim($module_info['Path'], '/'));
	}

	$module_paths = array_unique($module_paths);
	}

	preg_match($this->_moduleFolderRegExp, $config_path, $rets);

	// config file path starts with module folder path
	return in_array($rets[1], $module_paths);
	}

	/**
	* Returns true if config exists and is allowed for reading
	*
	* @param string $prefix
	* @return bool
	*/
	function prefixRegistred($prefix)
	{
	return isset($this->prefixFiles[$prefix]) ? true : false;
	}

	/**
	* Returns config file for given prefix
	*
	* @param string $prefix
	* @return string
	*/
	function getPrefixFile($prefix)
	{
	return array_key_exists($prefix, $this->prefixFiles) ? $this->prefixFiles[$prefix] : false;
	}

	function iterateConfigs($callback_function, $params)
	{
	$this->includeConfigFiles(MODULES_PATH); //make sure to re-read all configs
	$this->AfterConfigRead();

	foreach ($this->configData as $prefix => $config_data) {
	- $callback_function[0]->$callback_function[1]($prefix, $config_data, $params);
	+ call_user_func_array(
	+ $callback_function,
	+ array($prefix, &$config_data, $params)
	+ );
	}
	}

	}

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options