in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Jul 20, 6:32 AM

in-portal
View Options

	Index: trunk/kernel/units/custom_data/custom_data_config.php
	===================================================================
	--- trunk/kernel/units/custom_data/custom_data_config.php (revision 4801)
	+++ trunk/kernel/units/custom_data/custom_data_config.php (revision 4802)
	@@ -1,83 +1,83 @@
	<?php

	$config = Array(
	'Prefix' => 'cdata',

	'Clones' => Array(
	'u-cdata' => Array(
	'TableName' => TABLE_PREFIX.'PortalUserCustomData',
	'ParentPrefix' => 'u',
	),

	'c-cdata' => Array(
	'TableName' => TABLE_PREFIX.'CategoryCustomData',
	'ParentPrefix' => 'c',
	),
	-
	+
	'l-cdata' => Array(
	'TableName' => TABLE_PREFIX.'LinkCustomData',
	'ParentPrefix' => 'l',
	),

	'n-cdata' => Array(
	'TableName' => TABLE_PREFIX.'NewsCustomData',
	'ParentPrefix' => 'n',
	),

	'bb-cdata' => Array(
	'TableName' => TABLE_PREFIX.'TopicCustomData',
	'ParentPrefix' => 'bb',
	),
	-
	+
	'p-cdata' => Array(
	'TableName' => TABLE_PREFIX.'ProductsCustomData',
	'ParentPrefix' => 'p',
	),
	),

	'QueryString' => Array(
	1 => 'id',
	2 => 'event',
	),

	'ItemClass' => Array('class' => 'kDBItem', 'file' => '','build_event' => 'OnItemBuild'),
	'ListClass' => Array('class' => 'kDBList', 'file' => '','build_event' => 'OnListBuild'),
	'EventHandlerClass' => Array('class' => 'kDBEventHandler', 'file' => '', 'build_event' => 'OnBuild'),
	'TagProcessorClass' => Array('class' => 'kDBTagProcessor', 'file' => '', 'build_event' => 'OnBuild'),
	'AutoLoad' => true,

	'Hooks' => Array(
	Array(
	'Mode' => hAFTER,
	'Conditional' => false,
	- 'HookToPrefix' => '', //self
	+ 'HookToPrefix' => '#PARENT#', //self
	'HookToSpecial' => '*',
	'HookToEvent' => Array('OnAfterConfigRead'),
	'DoPrefix' => '',
	'DoSpecial' => '',
	'DoEvent' => 'OnCreateCustomFields',
	),
	),

	'IDField' => 'CustomDataId',

	'ParentTableKey' => 'ResourceId',
	'ForeignKey' => 'ResourceId',
	'AutoDelete' => true,
	'AutoClone' => false,

	'CalculatedFields' => Array(
	'' => Array(),
	),

	'ListSQLs' => Array('' => 'SELECT %1$s.* %2$s FROM %1$s'),
	'ItemSQLs' => Array('' => 'SELECT %1$s.* %2$s FROM %1$s'),

	'Fields' => Array(
	'CustomDataId' => Array(),
	'ResourceId' => Array('type' => 'int', 'not_null' => 1, 'default' => 0),
	),
	);


	?>
	\ No newline at end of file

	Property changes on: trunk/kernel/units/custom_data/custom_data_config.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.8
	\ No newline at end of property
	+1.9
	\ No newline at end of property
	Index: trunk/core/kernel/event_manager.php
	===================================================================
	--- trunk/core/kernel/event_manager.php (revision 4801)
	+++ trunk/core/kernel/event_manager.php (revision 4802)
	@@ -1,486 +1,486 @@
	<?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');
	$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;
	}
	}

	$passed = explode(',', $this->Application->GetVar('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');
	$event->setEventParam('top_prefix', $this->Application->GetTopmostPrefix($event->Prefix));
	if (($this->Application->GetVar('u_id') == -1) \|\| $event_handler->CheckPermission($event)) {
	$this->HandleEvent($event);
	}

	if ($event->status == erPERM_FAIL) {
	$event->redirect = $this->Application->IsAdmin() ? 'no_permission' : $this->Application->ConfigValue('NoPermissionTemplate');

	// restore stuff, that processOpener() changed
	$this->Application->RestoreVar('opener_stack');
	// 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);
	}

	// should do redirect but to no_permissions template
	if ( ($event->status == erSUCCESS \|\| $event->status == erPERM_FAIL) && ($event->redirect === true \|\| strlen($event->redirect) > 0)) {
	$this->Application->Redirect($event->redirect, $event->redirect_params, null, $event->redirect_script);
	}
	}

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

	function processOpener()
	{
	$opener_action = $this->Application->GetVar('m_opener');
	$opener_stack = $this->Application->RecallVar('opener_stack');
	$opener_stack = $opener_stack ? unserialize($opener_stack) : Array();
	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')) {
	array_push($opener_stack, '../'.$this->Application->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 - do not store last template
	$this->Application->SetVar('skip_last_template', 1);
	break;

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

	if (!$this->Application->GetVar('skip_last_template')) {
	$this->Application->SetVar('m_opener', 's');
	}
	$this->Application->StoreVar('opener_stack', serialize($opener_stack));
	}

	function registerHook($hookto_prefix, $hookto_special, $hookto_event, $mode, $do_prefix, $do_special, $do_event, $conditional)
	{
	if( !$this->Application->getUnitOptions($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;
	}

	$hooks = getArrayValue($mode_hooks, strtolower($event_key.'.'.$event->Name));
	if (!$hooks) {
	$hooks = Array();
	}
	return $hooks;
	}

	/**
	* 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 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') ) );
	$event_last_runs = $event_last_runs ? unserialize($event_last_runs) : Array();

	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'])
	{
	continue;
	}
	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() ) );
	}

	/**
	* 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: trunk/core/kernel/event_manager.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.32
	\ No newline at end of property
	+1.33
	\ No newline at end of property
	Index: trunk/core/kernel/utility/unit_config_reader.php
	===================================================================
	--- trunk/core/kernel/utility/unit_config_reader.php (revision 4801)
	+++ trunk/core/kernel/utility/unit_config_reader.php (revision 4802)
	@@ -1,574 +1,601 @@
	<?php

	class kUnitConfigReader extends kBase {

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

	var $CacheExpired = false;

	var $prefixFiles = array();

	var $ProcessAllConfigs = false;
	+ var $FinalStage = false;

	/**
	* Scan kernel and user classes
	* for available configs
	*
	* @access protected
	*/
	function Init($prefix,$special)
	{
	parent::Init($prefix,$special);
	}

	function CacheParsedData()
	{
	$event_manager =& $this->Application->recallObject('EventManager');
	$aggregator =& $this->Application->recallObject('TagsAggregator', 'kArray');

	$config_vars = Array(
	'SessionTimeout',
	'SessionCookieName',
	'SessionReferrerCheck',
	'CookieSessions',
	'UseCronForRegularEvent',
	'User_GuestGroup',
	'User_LoggedInGroup',
	'SessionTimeout',
	'UseModRewrite',
	'AdminDirectory',
	);

	foreach ($config_vars as $var) {
	$this->Application->ConfigValue($var);
	}

	$cache = Array(
	'Factory.Files' => $this->Application->Factory->Files,
	'Factory.realClasses' => $this->Application->Factory->realClasses,
	'Factory.Dependencies' => $this->Application->Factory->Dependencies,
	'ConfigReader.prefixFiles' => $this->prefixFiles,
	'EventManager.buildEvents' => $event_manager->buildEvents,
	'EventManager.beforeRegularEvents' => $event_manager->beforeRegularEvents,
	'EventManager.afterRegularEvents' => $event_manager->afterRegularEvents,
	'EventManager.beforeHooks' => $event_manager->beforeHooks,
	'EventManager.afterHooks' => $event_manager->afterHooks,
	'TagsAggregator.data' => $aggregator->_Array,

	// the following caches should be reset based on admin interaction (adjusting config, enabling modules etc)
	'Application.Caches.ConfigVariables' => $this->Application->Caches['ConfigVariables'],
	'Application.ConfigCacheIds' => $this->Application->ConfigCacheIds,
	'Application.ConfigHash' => $this->Application->ConfigHash,
	'Application.ModuleInfo' => $this->Application->ModuleInfo,
	);

	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("configs_parsed", '.$conn->qstr(serialize($cache)).', '.adodb_mktime().')');
	}

	function RestoreParsedData()
	{
	$conn =& $this->Application->GetADODBConnection();
	$data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	if ($data && $data['Cached'] > 0 ) {
	$cache = unserialize($data['Data']);
	$this->Application->Factory->Files = $cache['Factory.Files'];
	$this->Application->Factory->realClasses = $cache['Factory.realClasses'];
	$this->Application->Factory->Dependencies = $cache['Factory.Dependencies'];
	$this->prefixFiles = $cache['ConfigReader.prefixFiles'];

	$event_manager =& $this->Application->recallObject('EventManager');
	$event_manager->buildEvents = $cache['EventManager.buildEvents'];
	$event_manager->beforeRegularEvents = $cache['EventManager.beforeRegularEvents'];
	$event_manager->afterRegularEvents = $cache['EventManager.afterRegularEvents'];
	$event_manager->beforeHooks = $cache['EventManager.beforeHooks'];
	$event_manager->afterHooks = $cache['EventManager.afterHooks'];

	$aggregator =& $this->Application->recallObject('TagsAggregator', 'kArray');
	$aggregator->_Array = $cache['TagsAggregator.data'];

	$this->Application->ConfigHash = $cache['Application.ConfigHash'];

	$this->Application->Caches['ConfigVariables'] = $cache['Application.ConfigCacheIds'];
	$this->Application->ConfigCacheIds = $cache['Application.ConfigCacheIds'];

	$this->Application->ModuleInfo = $cache['Application.ModuleInfo'];

	return true;

	}
	else return false;
	}

	function ResetParsedData($include_sections = false)
	{
	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');

	if ($include_sections) {
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	}
	}

	function scanModules($folderPath, $cache = true)
	{
	if (!defined('IS_INSTALL') && $cache) {
	$restored = $this->RestoreParsedData();
	if ($restored) return;
	}

	$this->ProcessAllConfigs = true;

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

	$this->CacheParsedData();

	if ($cache) {
	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_files", '.$conn->qstr(serialize($this->configFiles)).', '.adodb_mktime().')');
	}

	unset($this->configFiles);
	}

	function findConfigFiles($folderPath)
	{
	// if FULL_PATH = "/" ensure, that all "/" in $folderPath are not deleted
	$reg_exp = '/^'.preg_quote(FULL_PATH, '/').'/';
	$folderPath = preg_replace($reg_exp, '', $folderPath, 1); // this make sense, since $folderPath may NOT contain FULL_PATH

	$fh=opendir(FULL_PATH.$folderPath);
	while(($sub_folder=readdir($fh)))
	{
	$full_path = FULL_PATH.$folderPath.'/'.$sub_folder;
	if( $this->isDir($full_path))
	{
	if ( file_exists(FULL_PATH.$this->getConfigName($folderPath.'/'.$sub_folder)) ) {
	$this->configFiles[] = $this->getConfigName($folderPath.'/'.$sub_folder);
	}
	$this->findConfigFiles($full_path);

	// if (filemtime($full_path) > $cached) { }

	}
	}
	}

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

	$conn =& $this->Application->GetADODBConnection();
	$data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files"');
	if ($cache && $data) {
	$this->configFiles = unserialize($data['Data']);
	- sort($this->configFiles);
	+ shuffle($this->configFiles);
	$files_cached = $data['Cached'];
	}
	else {
	$this->findConfigFiles($folderPath); // search from base directory
	}

	foreach ($this->configFiles as $filename)
	{
	$prefix = $this->PreloadConfigFile($filename);
	if (!$prefix) {
	trigger_error('Prefix not defined in config file '.$filename, E_USER_ERROR);
	}
	}
	}

	/**
	* Process all read config files - called ONLY when there is no cache!
	*
	*/
	function ParseConfigs()
	{
	-// $this->parseConfig('formatters'); // !TEMPORARY!, until config dependecy is created
	foreach ($this->configData as $prefix => $config) {
	$this->parseConfig($prefix);
	}

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

	function AfterConfigRead()
	{
	- if (!$this->ProcessAllConfigs) return ;
	+// if (!$this->ProcessAllConfigs) return ;
	+ $this->FinalStage = true;
	foreach ($this->configData as $prefix => $config) {
	$this->Application->HandleEvent( new kEvent($prefix.':OnAfterConfigRead') );
	}
	}

	/**
	* Register nessasary classes
	* This method should only process the data which is cached!
	*
	* @param string $prefix
	* @access private
	*/
	function parseConfig($prefix)
	{
	$config =& $this->configData[$prefix];
	$event_manager =& $this->Application->recallObject('EventManager');

	- if ($prefix == 'formatters') {
	- echo '';
	- }
	-
	$register_classes = getArrayValue($config,'RegisterClasses');
	if (!$register_classes) $register_classes = Array();
	$class_params=Array('ItemClass','ListClass','EventHandlerClass','TagProcessorClass');
	foreach($class_params as $param_name)
	{
	if ( !(isset($config[$param_name]) ) ) continue;
	$config[$param_name]['pseudo'] = $this->getPrefixByParamName($param_name,$prefix);
	$register_classes[] = $config[$param_name];
	}

	foreach($register_classes as $class_info)
	{
	+ $require_classes = getArrayValue($class_info, 'require_classes');
	+ if ($require_classes) {
	+ if (!is_array($require_classes)) {
	+ $require_classes = array($require_classes);
	+ }
	+ if (!isset($config['_Dependencies'][$class_info['class']])) {
	+ $config['_Dependencies'][$class_info['class']] = array();
	+ }
	+ $config['_Dependencies'][$class_info['class']] = array_merge($config['_Dependencies'][$class_info['class']], $require_classes);
	+ }
	$this->Application->registerClass(
	- $class_info['class'],
	- $config['BasePath'].'/'.$class_info['file'],
	- $class_info['pseudo'],
	- getArrayValue($class_info, 'require_classes')
	+ $class_info['class'],
	+ $config['BasePath'].'/'.$class_info['file'],
	+ $class_info['pseudo']/*,
	+ getArrayValue($class_info, 'require_classes')*/
	);
	if (getArrayValue($class_info, 'build_event')) {
	$event_manager->registerBuildEvent($class_info['pseudo'],$class_info['build_event']);
	}
	}

	$regular_events = getArrayValue($config, 'RegularEvents');
	if($regular_events)
	{
	foreach($regular_events as $short_name => $regular_event_info)
	{
	$event_manager->registerRegularEvent( $short_name, $config['Prefix'].':'.$regular_event_info['EventName'], $regular_event_info['RunInterval'], $regular_event_info['Type'] );
	}
	}

	$hooks = getArrayValue($config, 'Hooks');
	if (is_array($hooks) && count($hooks) > 0) {
	foreach ($hooks as $hook) {
	if (isset($config['ParentPrefix']) && $hook['HookToPrefix'] == $config['ParentPrefix']) {
	trigger_error('Depricated Hook Usage [prefix: <b>'.$config['Prefix'].'</b>; do_prefix: <b>'.$hook['DoPrefix'].'</b>] use <b>#PARENT#</b> and <b>HookToPrefix</b> value where HookToPrefix is same as ParentPrefix', E_USER_NOTICE);
	}

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

	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#') {
	+ continue; // we need parent prefix but it's not set !
	+ }

	$do_prefix = $hook['DoPrefix'] == '' ? $config['Prefix'] : $hook['DoPrefix'];

	if ( !is_array($hook['HookToEvent']) ) {
	$hook_events = Array( $hook['HookToEvent'] );
	}
	else {
	$hook_events = $hook['HookToEvent'];
	}
	foreach ($hook_events as $hook_event) {
	$this->Application->registerHook($hook['HookToPrefix'], $hook['HookToSpecial'], $hook_event, $hook['Mode'], $do_prefix, $hook['DoSpecial'], $hook['DoEvent'], $hook['Conditional']);
	}
	}
	}

	if ( is_array(getArrayValue($config, 'AggregateTags')) ) {
	foreach ($config['AggregateTags'] as $aggregate_tag) {
	$aggregate_tag['LocalPrefix'] = $config['Prefix'];
	$this->Application->registerAggregateTag($aggregate_tag);
	}
	}

	if ( $this->Application->isDebugMode() && dbg_ConstOn('DBG_VALIDATE_CONFIGS') && isset($config['TableName']) )
	{
	global $debugger;
	$tablename = $config['TableName'];

	$conn =& $this->Application->GetADODBConnection();
	$res = $conn->Query("DESCRIBE $tablename");

	foreach ($res as $field) {
	$f_name = $field['Field'];
	if (getArrayValue($config, 'Fields')) {
	if ( !array_key_exists ($f_name, $config['Fields']) ) {
	$debugger->appendHTML("<b class='debug_error'>Config Warning: </b>Field $f_name exists in the database, but is not defined in config file for prefix <b>".$config['Prefix']."</b>!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	else {
	$options = $config['Fields'][$f_name];
	if ($field['Null'] == '') {
	if ( $f_name != $config['IDField'] && !isset($options['not_null']) && !isset($options['required']) ) {
	$debugger->appendHTML("<b class='debug_error'>Config Error: </b>Field $f_name in config for prefix <b>".$config['Prefix']."</b> is NOT NULL in the database, but is not configured as not_null or required!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	if ( isset($options['not_null']) && !isset($options['default']) ) {
	$debugger->appendHTML("<b class='debug_error'>Config Error: </b>Field $f_name in config for prefix <b>".$config['Prefix']."</b> is described as NOT NULL, but does not have DEFAULT value!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	}

	}
	}
	}
	}
	}

	+ function ProcessDependencies($prefix)
	+ {
	+ $config =& $this->configData[$prefix];
	+ $deps = getArrayValue($config, '_Dependencies');
	+ if (!$deps) return ;
	+
	+ foreach ($deps as $real_class => $requires) {
	+ foreach ($requires as $class) {
	+ $this->Application->registerDependency($real_class, $class);
	+ }
	+ }
	+ unset($config['_Dependencies']);
	+ }
	+
	function postProcessConfig($prefix, $config_key, $dst_prefix_var)
	{
	$main_config =& $this->configData[$prefix];
	$sub_configs = getArrayValue($main_config, $config_key);
	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] = array_merge_recursive2($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) \|\| defined('IS_INSTALL'));

	if( defined('DEBUG_MODE') && DEBUG_MODE && constOn('DBG_PROFILE_INCLUDES') )
	{
	if ( in_array($filename, get_required_files()) ) return;
	global $debugger;
	if($config_found) {
	$file = FULL_PATH.$filename;
	$debugger->ProfileStart('inc_'.crc32($file), $file);
	include_once($file);
	$debugger->ProfileFinish('inc_'.crc32($file));
	$debugger->profilerAddTotal('includes', 'inc_'.crc32($file));
	}
	}
	else
	{
	if($config_found) include_once(FULL_PATH.$filename);
	}

	if($config_found && isset($config) && $config)
	{
	$prefix = isset($config['Prefix']) ? $config['Prefix'] : '';

	preg_match('/\/(.*)\//U', $filename, $rets);
	$config['ModuleFolder'] = $rets[1];
	$config['BasePath'] = dirname(FULL_PATH.$filename);
	$this->configData[$prefix] = $config;
	$this->prefixFiles[$prefix] = $filename;
	return $prefix;
	}
	return 'dummy';
	}

	function loadConfig($prefix)
	{
	if (!isset($this->prefixFiles[$prefix])) {
	$this->Application->Debugger->appendTrace();
	trigger_error('Configuration file for prefix <b>'.$prefix.'</b> is unknown', E_USER_ERROR);
	return ;
	}
	$file = $this->prefixFiles[$prefix];
	$prefix = $this->PreloadConfigFile($file);

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

	- array_unshift($clones, $prefix);
	- $clones = array_unique($clones);
	- foreach ($clones as $a_prefix) {
	- $this->Application->HandleEvent( new kEvent($a_prefix.':OnAfterConfigRead') );
	+ if ($this->FinalStage) {
	+ array_unshift($clones, $prefix);
	+ $clones = array_unique($clones);
	+ foreach ($clones as $a_prefix) {
	+ $this->Application->HandleEvent( new kEvent($a_prefix.':OnAfterConfigRead') );
	+ }
	}
	}

	/**
	* 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 = getArrayValue($this->configData, $rets[1], $name, $rets[2]);
	}
	else {
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}
	$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)
	{
	return $this->prefixRegistred($prefix) ? $this->configData[$prefix] : false;
	}

	/**
	* 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)) {
	$this->configData[$rets[1]][$name][$rets[2]] = $value;
	}
	else {
	$this->configData[$prefix][$name] = $value;
	}

	}

	function getPrefixByParamName($paramName,$prefix)
	{
	$pseudo_class_map=Array(
	'ItemClass'=>'%s',
	'ListClass'=>'%s_List',
	'EventHandlerClass'=>'%s_EventHandler',
	'TagProcessorClass'=>'%s_TagProcessor'
	);
	return sprintf($pseudo_class_map[$paramName],$prefix);
	}

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

	/**
	* is_dir ajustment to work with
	* directory listings too
	*
	* @param string $folderPath
	* @return bool
	* @access private
	*/
	function isDir($folderPath)
	{
	$base_name = basename($folderPath);
	$ret = !( $base_name == '.' \|\| $base_name == '..' );
	return $ret && is_dir($folderPath);
	}

	/**
	* 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)
	{
	$module_found = false;
	if (!$this->Application->ModuleInfo) return false;

	foreach($this->Application->ModuleInfo as $module_name => $module_info)
	{
	$module_path = '/'.$module_info['Path'];
	if (preg_match('/^'.preg_quote($module_path, '/').'/', $config_path)) {
	// if (substr($config_path, 0, strlen($module_path)) == $module_path) {
	// config file path starts with module folder path
	$module_found = true;
	break;
	}
	}
	return $module_found;
	}

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



	}


	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/utility/unit_config_reader.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.49
	\ No newline at end of property
	+1.50
	\ No newline at end of property
	Index: trunk/core/kernel/utility/factory.php
	===================================================================
	--- trunk/core/kernel/utility/factory.php (revision 4801)
	+++ trunk/core/kernel/utility/factory.php (revision 4802)
	@@ -1,311 +1,311 @@
	<?php

	class kFactory extends kBase {

	/**
	* Where all created objects are stored
	*
	* @var Array
	* @access private
	*/
	var $Storage=Array();

	/**
	* Map between class name and file name
	* where class definition can be found.
	* File path absolute!
	*
	* @var Array
	* @access private
	*/
	var $Files=Array();

	/**
	* Map class names to their pseudo
	* class names, e.g. key=pseudo_class,
	* value=real_class_name
	*
	* @var Array
	* @access private
	*/
	var $realClasses=Array();

	/**
	* class name vs other classnames it's require for existing
	*
	* @var Array
	*/
	var $Dependencies=Array();

	/**
	* Splits any mixing of prefix and
	* special into correct ones
	*
	* @param string $prefix_special
	* @return Array
	* @access public
	*/
	function processPrefix($prefix_special)
	{
	// l.pick, l, m.test_TagProcessor

	//preg_match("/(.)\.(.)(_)(.*)/", $prefix_special, $regs);
	//return Array('prefix'=>$regs[1].$regs[3].$regs[4], 'special'=>$regs[2]);

	$tmp=explode('_',$prefix_special,2);
	$tmp[0]=explode('.',$tmp[0]);

	$prefix=$tmp[0][0];
	$prefix_special=$prefix; // new1
	if( isset($tmp[1]) )
	{
	$prefix.='_'.$tmp[1];
	}
	$special= isset($tmp[0][1]) ? $tmp[0][1] : '';
	$prefix_special.='.'.$special; // new2

	return Array('prefix'=>$prefix,'special'=>$special,'prefix_special'=>$prefix_special);
	}


	/**
	* Returns object using params specified,
	* creates it if is required
	*
	* @param string $name
	* @param string $pseudo_class
	* @param Array $event_params
	* @return Object
	*/
	function &getObject($name,$pseudo_class='',$event_params=Array())
	{
	$name=rtrim($name,'.');
	if( isset($this->Storage[$name]) ) return $this->Storage[$name];
	$ret=$this->processPrefix($name);
	if (!$pseudo_class) $pseudo_class = $ret['prefix'];

	if (!isset($this->realClasses[$pseudo_class]))
	{
	if( $this->Application->isDebugMode() ) $this->Application->Debugger->appendTrace();
	$error_level = $this->Application->isInstalled() ? E_USER_ERROR : E_USER_WARNING;
	trigger_error('RealClass not defined for pseudo_class <b>'.$pseudo_class.'</b>', $error_level);
	$false = false;
	return $false;
	}

	if ($this->Application->isDebugMode() && dbg_ConstOn('DBG_FACTORY')) {
	global $debugger;
	$debugger->appendHTML('<b>Creating object:</b> Pseudo class: '.$pseudo_class.' Prefix: '.$name);
	$debugger->appendTrace();
	}

	$this->Storage[$name] =& $this->makeClass($pseudo_class);
	$this->Storage[$name]->Init($ret['prefix'],$ret['special'],$event_params);

	$prefix=$this->Storage[$name]->Prefix;
	$special=$this->Storage[$name]->Special;

	// $event_manager =& $this->Storage['EventManager'];
	$event =& $this->Application->EventManager->getBuildEvent($pseudo_class);
	if($event)
	{
	$event->Init($prefix,$special);
	foreach($event_params as $param_name=>$param_value)
	{
	$event->setEventParam($param_name,$param_value);
	}
	$this->Application->HandleEvent($event);
	}

	return $this->Storage[$name];
	}

	/**
	* Returns object using Variable number of params specified,
	* creates it if is required
	* all params after 4th are passed to object constructor
	*
	* @param string $name
	* @param string $pseudo_class
	* @param Array $event_params
	* @return Object
	*/
	function &getObjectP($name,$pseudo_class='',$event_params=Array())
	{
	$ret=$this->processPrefix($name);
	if (!$pseudo_class) $pseudo_class = $ret['prefix'];
	$name=rtrim($name,'.');
	if( isset($this->Storage[$name]) ) return $this->Storage[$name];

	if (!isset($this->realClasses[$pseudo_class]))
	{
	if( $this->Application->isDebugMode() ) $this->Application->Debugger->appendTrace();
	$error_level = $this->Application->isInstalled() ? E_USER_ERROR : E_USER_WARNING;
	trigger_error('RealClass not defined for pseudo_class <b>'.$pseudo_class.'</b>', $error_level);
	$false = false;
	return $false;
	}

	if ($this->Application->isDebugMode() && dbg_ConstOn('DBG_FACTORY')) {
	global $debugger;
	$debugger->appendHTML('<b>Creating object:</b> Pseudo class: '.$pseudo_class.' Prefix: '.$name);
	$debugger->appendTrace();
	}

	$funs_args = func_get_args();
	array_splice($funs_args, 0, 3, Array($pseudo_class) );

	$this->Storage[$name] =& ref_call_user_func_array( Array(&$this,'makeClass'), $funs_args);
	$this->Storage[$name]->Init($ret['prefix'],$ret['special'],$event_params);

	$prefix=$this->Storage[$name]->Prefix;
	$special=$this->Storage[$name]->Special;

	$event_manager =& $this->getObject('EventManager');
	$event =& $event_manager->getBuildEvent($pseudo_class);
	if($event)
	{
	$event->Init($prefix,$special);
	foreach($event_params as $param_name=>$param_value)
	{
	$event->setEventParam($param_name,$param_value);
	}
	$this->Application->HandleEvent($event);
	}

	return $this->Storage[$name];
	}


	/**
	* Removes object from storage, so next time it could be created from scratch
	*
	* @param string $name Object's name in the Storage
	*/
	function DestroyObject($name)
	{
	unset($this->Storage[$name]);
	}

	/**
	* Includes file containing class
	* definition for real class name
	*
	* @param string $real_class
	* @access private
	*/
	function includeClassFile($real_class)
	{
	if (class_exists($real_class)) return;
	- if(!$this->Files[$real_class]) trigger_error('Real Class <b>'.$real_class.'</b> is not registered with the Factory', E_USER_ERROR);
	- if(!file_exists($this->Files[$real_class])) trigger_error('Include file for class <b>'.$real_class.'</b> (<b>'.$this->Files[$real_class].'</b>) does not exists', E_USER_ERROR);
	+ if(!isset($this->Files[$real_class])) {
	+ trigger_error('Real Class <b>'.$real_class.'</b> is not registered with the Factory', E_USER_ERROR);
	+ }
	+ if(!file_exists($this->Files[$real_class])) {
	+ trigger_error('Include file for class <b>'.$real_class.'</b> (<b>'.$this->Files[$real_class].'</b>) does not exists', E_USER_ERROR);
	+ }

	if( isset( $this->Dependencies[$real_class] ) )
	{
	foreach($this->Dependencies[$real_class] as $dep_class_name)
	{
	$this->includeClassFile($dep_class_name);
	}
	}

	k4_include_once($this->Files[$real_class]);
	}

	/**
	* Get's real class name for pseudo class,
	* includes class file and creates class
	* instance.
	* All parameters except first one are passed to object constuctor
	* through mediator method makeClass that creates instance of class
	*
	* @param string $pseudo_class
	* @return Object
	* @access private
	*/
	function &makeClass($pseudo_class)
	{
	$real_class = $this->realClasses[$pseudo_class];
	if (!class_exists($real_class)) $this->includeClassFile($real_class);

	$mem_before = memory_get_usage();
	$time_before = getmicrotime();

	if( func_num_args() == 1 )
	{
	$class = new $real_class();
	}
	else
	{
	$func_args = func_get_args();
	$pseudo_class = array_shift($func_args);
	$class =& ref_call_user_func_array( Array($real_class,'makeClass'), $func_args );
	}
	if( defined('DEBUG_MODE') && DEBUG_MODE && dbg_ConstOn('DBG_PROFILE_MEMORY') )
	{
	$mem_after = memory_get_usage();
	$time_after = getmicrotime();
	$mem_used = $mem_after - $mem_before;
	$time_used = $time_after - $time_before;
	global $debugger;
	$debugger->appendHTML('Factroy created <b>'.$real_class.'</b> - used '.round($mem_used/1024, 3).'Kb time: '.round($time_used, 5));
	$debugger->profilerAddTotal('objects', null, $mem_used);
	}
	return $class;
	}

	/**
	* Registers new class in the factory
	*
	* @param string $real_class Real name of class as in class declaration
	* @param string $file Filename in what $real_class is declared
	* @param string $pseudo_class Name under this class object will be accessed using getObject method
	* @param Array $dependecies List of classes required for this class functioning
	* @access public
	*/
	function registerClass($real_class, $file, $pseudo_class=null, $dependecies = Array() )
	{
	if(!isset($pseudo_class)) $pseudo_class = $real_class;
	if(!isset($this->Files[$real_class])) $this->Files[$real_class]=$file;

	if (isset($this->realClasses[$pseudo_class])) {
	$this->registerDependency($real_class, $pseudo_class);
	}

	if($dependecies)
	{
	if (!is_array($dependecies)) $dependecies = array($dependecies);
	foreach ($dependecies as $required_class) {
	$this->registerDependency($real_class, $required_class);
	}
	}

	$this->realClasses[$pseudo_class]=$real_class;
	}

	/**
	* Add $class_name to required classes list for $depended_class class.
	* All required class files are included before $depended_class file is included
	*
	* @param string $depended_class
	* @param string $class_name
	* @author Alex
	*/
	function registerDependency($depended_class, $class_name)
	{
	$dependencies =& $this->Dependencies[$depended_class];

	- if ($class_name == 'kFormatter') {
	- echo '';
	- }
	-
	$conditions = Array();
	$conditions['exists'] = is_array($dependencies) && in_array($this->realClasses[$class_name], $dependencies);
	$conditions['same_class'] = $this->realClasses[$class_name] == $depended_class;

	if (!$conditions['exists'] && !$conditions['same_class']) {
	$dependencies[] = $this->realClasses[$class_name];
	}
	}
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/utility/factory.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.17
	\ No newline at end of property
	+1.18
	\ No newline at end of property
	Index: trunk/core/units/custom_data/custom_data_config.php
	===================================================================
	--- trunk/core/units/custom_data/custom_data_config.php (revision 4801)
	+++ trunk/core/units/custom_data/custom_data_config.php (revision 4802)
	@@ -1,83 +1,83 @@
	<?php

	$config = Array(
	'Prefix' => 'cdata',

	'Clones' => Array(
	'u-cdata' => Array(
	'TableName' => TABLE_PREFIX.'PortalUserCustomData',
	'ParentPrefix' => 'u',
	),

	'c-cdata' => Array(
	'TableName' => TABLE_PREFIX.'CategoryCustomData',
	'ParentPrefix' => 'c',
	),
	-
	+
	'l-cdata' => Array(
	'TableName' => TABLE_PREFIX.'LinkCustomData',
	'ParentPrefix' => 'l',
	),

	'n-cdata' => Array(
	'TableName' => TABLE_PREFIX.'NewsCustomData',
	'ParentPrefix' => 'n',
	),

	'bb-cdata' => Array(
	'TableName' => TABLE_PREFIX.'TopicCustomData',
	'ParentPrefix' => 'bb',
	),
	-
	+
	'p-cdata' => Array(
	'TableName' => TABLE_PREFIX.'ProductsCustomData',
	'ParentPrefix' => 'p',
	),
	),

	'QueryString' => Array(
	1 => 'id',
	2 => 'event',
	),

	'ItemClass' => Array('class' => 'kDBItem', 'file' => '','build_event' => 'OnItemBuild'),
	'ListClass' => Array('class' => 'kDBList', 'file' => '','build_event' => 'OnListBuild'),
	'EventHandlerClass' => Array('class' => 'kDBEventHandler', 'file' => '', 'build_event' => 'OnBuild'),
	'TagProcessorClass' => Array('class' => 'kDBTagProcessor', 'file' => '', 'build_event' => 'OnBuild'),
	'AutoLoad' => true,

	'Hooks' => Array(
	Array(
	'Mode' => hAFTER,
	'Conditional' => false,
	- 'HookToPrefix' => '', //self
	+ 'HookToPrefix' => '#PARENT#', //self
	'HookToSpecial' => '*',
	'HookToEvent' => Array('OnAfterConfigRead'),
	'DoPrefix' => '',
	'DoSpecial' => '',
	'DoEvent' => 'OnCreateCustomFields',
	),
	),

	'IDField' => 'CustomDataId',

	'ParentTableKey' => 'ResourceId',
	'ForeignKey' => 'ResourceId',
	'AutoDelete' => true,
	'AutoClone' => false,

	'CalculatedFields' => Array(
	'' => Array(),
	),

	'ListSQLs' => Array('' => 'SELECT %1$s.* %2$s FROM %1$s'),
	'ItemSQLs' => Array('' => 'SELECT %1$s.* %2$s FROM %1$s'),

	'Fields' => Array(
	'CustomDataId' => Array(),
	'ResourceId' => Array('type' => 'int', 'not_null' => 1, 'default' => 0),
	),
	);


	?>
	\ No newline at end of file

	Property changes on: trunk/core/units/custom_data/custom_data_config.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.8
	\ No newline at end of property
	+1.9
	\ 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