in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Apr 30, 8:59 AM

in-portal
View Options

	Index: branches/5.1.x/core/kernel/utility/unit_config_reader.php
	===================================================================
	--- branches/5.1.x/core/kernel/utility/unit_config_reader.php (revision 13934)
	+++ branches/5.1.x/core/kernel/utility/unit_config_reader.php (revision 13935)
	@@ -1,1041 +1,1063 @@
	<?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 {

	/**
	* Configs readed
	*
	* @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', 'admin_templates', 'libchart');

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

	$this->_directorySeparator = preg_quote(DIRECTORY_SEPARATOR);

	$editor_path = explode('/', trim(EDITOR_PATH, '/'));
	$this->_skipFolders[] = array_pop($editor_path); // last of cmseditor folders

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

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

	$config_vars = Array (
	// session related
	'SessionTimeout',
	'SessionCookieName',
	'SessionCookieDomains',
	'SessionBrowserSignatureCheck',
	'SessionIPAddressCheck',
	'CookieSessions',
	'KeepSessionOnBrowserClose',
	'User_GuestGroup',
	'User_LoggedInGroup',

	// output related
	'UseModRewrite',
	'UseContentLanguageNegotiation',
	'UseOutputCompression',
	'OutputCompressionLevel',
	'Config_Site_Time',
	'SystemTagCache',

	// tracking related
	'UseChangeLog',
	'UseVisitorTracking',
	'ModRewriteUrlEnding',
	'ForceModRewriteUrlEnding',
	'UseCronForRegularEvent',
	);

	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.ReplacementTemplates' => $this->Application->ReplacementTemplates,
	'Application.RewriteListeners' => $this->Application->RewriteListeners,
	'Application.ModuleInfo' => $this->Application->ModuleInfo,
	);

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

	$cache_rebuild_by = SERVER_NAME . ' (' . getenv('REMOTE_ADDR') . ') - ' . adodb_date('d/m/Y H:i:s');
	$this->Application->setDBCache('last_cache_rebuild', $cache_rebuild_by);

	unset($this->configFiles);
	}

	function RestoreParsedData()
	{
	$conn =& $this->Application->GetADODBConnection();

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

	if ($data) {
	$cache = unserialize($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->ReplacementTemplates = $cache['Application.ReplacementTemplates'];
	$this->Application->RewriteListeners = $cache['Application.RewriteListeners'];

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

	return true;

	}
	else return false;
	}

	function ResetParsedData($include_sections = false)
	{
	$conn =& $this->Application->GetADODBConnection();

	if ($this->Application->isCachingType(CACHING_TYPE_MEMORY)) {
	$this->Application->deleteCache('master:configs_parsed');
	}
	else {
	$this->Application->deleteDBCache('configs_parsed');
	}

	if ($include_sections) {
	if ($this->Application->isCachingType(CACHING_TYPE_MEMORY)) {
	$this->Application->deleteCache('master:sections_parsed');
	}
	else {
	$this->Application->deleteDBCache('sections_parsed');
	}
	}
	}

	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->RestoreParsedData();
	if ($restored) return;
	}

	$this->ProcessAllConfigs = true;

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

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

	function findConfigFiles($folderPath, $level = 0)
	{
	/*if ($level == 0) {
	if ($this->Application->isDebugMode()) {
	$start_time = getmicrotime();
	$this->Application->Debugger->appendHTML('kUnitConfigReader::findConfigFiles("' . $folderPath . '")');
	$this->Application->Debugger->appendTrace();
	}
	}*/

	// 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

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

	if ($level == 0) {
	// don't scan Front-End themes because of extensive directory structure
	$sub_folders = array_diff($sub_folders, Array ($base_folder . 'themes', $base_folder . 'tools'));
	}

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

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

	if (preg_match('/^\./', $sub_folder)) {
	// 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);
	}

	/*if ($level == 0) {
	if ($this->Application->isDebugMode()) {
	$this->Application->Debugger->appendHTML('kUnitConfigReader::findConfigFiles("' . FULL_PATH . $folderPath . '"): ' . (getmicrotime() - $start_time));
	}
	}*/
	}

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

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

	if ($cache && $data) {
	$this->configFiles = unserialize($data);
	shuffle($this->configFiles);
	}
	else {
	$this->findConfigFiles(FULL_PATH . DIRECTORY_SEPARATOR . 'core'); // search from core directory
	$this->findConfigFiles($folderPath); // search from modules 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()
	{
	// 1. process normal configs and their dependencies
	$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->ProcessDependencies($prefix);
	$this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');
	}

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

	foreach ($prioritized_configs as $prefix => $priority) {
	$this->ProcessDependencies($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 overrided -> 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->CacheParsedData();

	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);
	}
	}

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

	/**
	* 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()
	{
	// clear restored cache (not in db)
	$this->Application->Factory->Files = Array ();
	$this->Application->Factory->realClasses = Array ();
	$this->Application->Factory->Dependencies = Array ();

	$this->Application->EventManager->beforeRegularEvents = Array ();
	$this->Application->EventManager->afterRegularEvents = Array ();
	$this->Application->EventManager->beforeHooks = Array ();
	$this->Application->EventManager->afterHooks = Array ();

	// otherwise ModulesHelper indirectly used from includeConfigFiles won't work
	$this->Application->RegisterDefaultClasses();

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

	/**
	* 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);
	}
	}

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

	/**
	* Process all collectable 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)
	{
	$config =& $this->configData[$prefix];
	$event_manager =& $this->Application->recallObject('EventManager');
	/* @var $event_manager kEventManager */

	$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'] . DIRECTORY_SEPARATOR . $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_status = array_key_exists('Status', $regular_event_info) ? $regular_event_info['Status'] : STATUS_ACTIVE;
	$event_manager->registerRegularEvent( $short_name, $config['Prefix'].':'.$regular_event_info['EventName'], $regular_event_info['RunInterval'], $regular_event_info['Type'], $event_status);
	}
	}

	$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> as <b>HookToPrefix</b> value, where HookToPrefix is same as ParentPrefix', defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : 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) {
	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->registerAggregateTag($aggregate_tag);
	}
	}
	}

	function ValidateConfig($prefix)
	{
	global $debugger;

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

	$tablename = $config['TableName'];
	$float_types = Array ('float', 'double', 'numeric');
	$conn =& $this->Application->GetADODBConnection();

	$table_found = $conn->Query('SHOW TABLES LIKE "'.$tablename.'"');
	if (!$table_found) {
	// config present, but table missing, strange
	- $debugger->appendHTML("<b class='debug_error'>Config Warning: </b>Table <strong>$tablename</strong> missing, but prefix <b>".$config['Prefix']."</b> requires it!");
	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 = $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)',
	'type_missing' => '<strong>Type definition</strong> for field <strong>%s</strong> missing in config',
	+ '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 {
	- if (is_numeric($field['Default'])) {
	- $field['Default'] = preg_match('/[\.,]/', $field['Default']) ? (float)$field['Default'] : (int)$field['Default'];
	+ $db_default = $field['Default'];
	+
	+ if (is_numeric($db_default)) {
	+ $db_default = preg_match('/[\.,]/', $db_default) ? (float)$db_default : (int)$db_default;
	}

	- $options = $config['Fields'][$f_name];
	$default_missing = false;
	+ $options = $config['Fields'][$f_name];
	+ $not_null = isset($options['not_null']) && $options['not_null'];
	+
	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 (isset($options['not_null']) && $options['not_null'] && !isset($options['default']) ) {
	+ if ($not_null && !isset($options['default']) ) {
	$config_errors[] = sprintf($error_messages['not_null_error2'], $f_name);
	}
	}
	- else {
	- if (isset($options['not_null']) && $options['not_null']) {
	- $config_errors[] = sprintf($error_messages['not_null_error3'], $f_name);
	- }
	+ elseif ($not_null) {
	+ $config_errors[] = sprintf($error_messages['not_null_error3'], $f_name);
	}

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

	if (!$default_missing) {
	+ 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 ($options['default'] != '#NOW#' && $field['Default'] !== $options['default'] && !in_array($options['type'], $float_types)) {
	- $config_errors[] = sprintf($error_messages['invalid_default'], '', $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 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);
	+ }
	+ }
	+ }
	+ }
	+
	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);

	- $debugger->appendHTML($config_errors);
	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 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 = isset($main_config[$config_key]) && $main_config[$config_key] ? $main_config[$config_key] : false; // 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);

	if (defined('DEBUG_MODE') && DEBUG_MODE && defined('DBG_PROFILE_INCLUDES') && DBG_PROFILE_INCLUDES) {
	if ( in_array($filename, get_required_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;
	}
	elseif ($prefix = array_search($filename, $this->prefixFiles)) {
	// 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])) {
	if ($this->Application->isDebugMode()) $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);

	if ($this->FinalStage) {
	// run prefix OnAfterConfigRead so all
	// hooks to it can define their clonses
	$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;
	}

	}

	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 . 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);
	}
	}

	}
	\ No newline at end of file
	Index: branches/5.1.x/core/units/helpers/multilanguage_helper.php
	===================================================================
	--- branches/5.1.x/core/units/helpers/multilanguage_helper.php (revision 13934)
	+++ branches/5.1.x/core/units/helpers/multilanguage_helper.php (revision 13935)
	@@ -1,308 +1,308 @@
	<?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!');

	/**
	* Performs action on multilingual fields
	*
	*/
	class kMultiLanguageHelper extends kHelper {

	/**
	* Maximal language id
	*
	* @var int
	*/
	var $languageCount = 0;

	/**
	* Languages created in system
	*
	* @var Array
	*/
	var $languagesIDs = Array ();

	/**
	* Structure of table, that is currently processed
	*
	* @var Array
	*/
	var $curStructure = Array();

	/**
	* Field, to get structure information from
	*
	* @var string
	*/
	var $curSourceField = false;

	/**
	* Indexes used in table of 32
	*
	* @var int
	*/
	var $curIndexCount = 0;

	/**
	* Fields from config, that are currently used
	*
	* @var Array
	*/
	var $curFields = Array();

	function kMultiLanguageHelper()
	{
	parent::kHelper();
	$this->languageCount = $this->getLanguageCount();
	}

	/**
	* Checks if language with specified id is created
	*
	* @param int $language_id
	* @return bool
	*/
	function LanguageFound($language_id)
	{
	return in_array($language_id, $this->languagesIDs) \|\| $language_id <= 5;
	}

	/**
	* Returns language count in system (always is divisible by 5)
	*
	*/
	function getLanguageCount()
	{
	if ($this->languageCount) {
	return $this->languageCount;
	}

	$id_field = $this->Application->getUnitOption('lang', 'IDField');
	$table_name = $this->Application->getUnitOption('lang', 'TableName');

	$this->languagesIDs = $this->Conn->GetCol('SELECT '.$id_field.' FROM '.$table_name);

	$languages_count = $this->Conn->GetOne('SELECT MAX('.$id_field.') FROM '.$table_name);

	return max($languages_count, 5);
	}


	function scanTable($mask)
	{
	$i = 0;
	$fields_found = 0;
	$fields = array_keys($this->curStructure);

	foreach ($fields as $field_name) {
	if (preg_match($mask, $field_name)) {
	$fields_found++;
	}
	}
	return $fields_found;
	}

	function readTableStructure($table_name, $refresh = false)
	{
	// if ($refresh \|\| !getArrayValue($structure_status, $prefix.'.'.$table_name)) {
	$this->curStructure = $this->Conn->Query('DESCRIBE '.$table_name, 'Field');
	$this->curIndexCount = count($this->Conn->Query('SHOW INDEXES FROM '.$table_name));
	// }
	}

	/**
	* Creates missing multilanguage fields in table by specified prefix
	*
	* @param string $prefix
	* @param bool $refresh Forces config field structure to be re-read from database
	*/
	function createFields($prefix, $refresh = false)
	{
	if ($refresh && preg_match('/(.*)-cdata$/', $prefix, $regs)) {
	// call main item config to clone cdata table
	$this->Application->UnitConfigReader->loadConfig($regs[1]);
	$this->Application->UnitConfigReader->runAfterConfigRead($prefix);
	}

	$table_name = $this->Application->getUnitOption($prefix, 'TableName');
	$this->curFields = $this->Application->getUnitOption($prefix, 'Fields');

	if (!($table_name && $this->curFields) \|\| ($table_name && !$this->Conn->TableFound($table_name))) {
	// invalid config found or prefix not found
	return true;
	}

	$sqls = Array();
	$this->readTableStructure($table_name, $refresh);

	foreach($this->curFields as $field_name => $field_options)
	{
	if (getArrayValue($field_options, 'formatter') == 'kMultiLanguage') {
	if (isset($field_options['master_field'])) {
	unset($this->curFields[$field_name]);
	continue;
	}

	$this->setSourceField($field_name);
	if ($this->languageCount > 0) {
	// `l77_Name` VARCHAR( 255 ) NULL DEFAULT '0';
	$field_mask = Array();
	$field_mask['name'] = 'l%s_'.$field_name;
	$field_mask['null'] = getArrayValue($field_options, 'not_null') ? 'NOT NULL' : 'NULL';

	if ($this->curSourceField) {
	$default_value = $this->getFieldParam('Default') != 'NULL' ? $this->Conn->qstr($this->getFieldParam('Default')) : $this->getFieldParam('Default');
	$field_mask['type'] = $this->getFieldParam('Type');
	}
	else {
	$default_value = is_null($field_options['default']) ? 'NULL' : $this->Conn->qstr($field_options['default']);
	$field_mask['type'] = $field_options['db_type'];
	}
	- $field_mask['default'] = 'DEFAULT '.$default_value;
	+ $field_mask['default'] = ($field_mask['null'] == 'NOT NULL' && $default_value == 'NULL') ? '' : 'DEFAULT '.$default_value;

	if (strtoupper($field_mask['type']) == 'TEXT') {
	// text fields in mysql doesn't have default value
	$field_mask = $field_mask['name'].' '.$field_mask['type'].' '.$field_mask['null'];
	}
	else {
	$field_mask = $field_mask['name'].' '.$field_mask['type'].' '.$field_mask['null'].' '.$field_mask['default'];
	}

	$alter_sqls = $this->generateAlterSQL($field_mask, 1, $this->languageCount);
	if ($alter_sqls) {
	$sqls[] = 'ALTER TABLE '.$table_name.' '.$alter_sqls;
	}
	}
	}
	}

	foreach ($sqls as $sql_query) {
	$this->Conn->Query($sql_query);
	}
	}

	function deleteField($prefix, $custom_id)
	{
	$table_name = $this->Application->getUnitOption($prefix, 'TableName');
	$sql = 'DESCRIBE '.$table_name.' "l%_cust_'.$custom_id.'"';
	$fields = $this->Conn->GetCol($sql);

	$sql = 'ALTER TABLE '.$table_name.' ';
	$sql_template = 'DROP COLUMN %s, ';

	foreach ($fields as $field_name) {
	$sql .= sprintf($sql_template, $field_name);
	}

	$this->Conn->Query( substr($sql, 0, -2) );
	}

	/**
	* Returns parameter requested of current source field
	*
	* @param string $param_name
	* @return string
	*/
	function getFieldParam($param_name)
	{
	return $this->curStructure[$this->curSourceField][$param_name];
	}

	/**
	* Detects field name to create other fields from
	*
	* @param string $field_name
	*/
	function setSourceField($field_name)
	{
	$ret = $this->scanTable('/^l[\d]+_'.preg_quote($field_name, '/').'$/');
	if (!$ret) {
	// no multilingual fields at all (but we have such field without language prefix)
	$original_found = $this->scanTable('/^'.preg_quote($field_name, '$/').'/');
	$this->curSourceField = $original_found ? $field_name : false;
	}
	else {
	$this->curSourceField = 'l1_'.$field_name;
	}
	}

	/**
	* Returns ALTER statement part for adding required fields to table
	*
	* @param string $field_mask sql mask for creating field with correct definition (type & size)
	* @param int $start_index add new fields starting from this index
	* @param int $create_count create this much new multilingual field translations
	* @return string
	*/
	function generateAlterSQL($field_mask, $start_index, $create_count)
	{
	static $single_lang = null;
	if (!isset($single_lang)) {
	// if single language mode, then create indexes only on primary columns
	$table_name = $this->Application->getUnitOption('lang', 'TableName');
	$sql = 'SELECT COUNT(*)
	FROM '.$table_name.'
	WHERE Enabled = 1';
	// if language count = 0, then assume it's multi language mode
	$single_lang = $this->Conn->GetOne($sql) == 1;
	}

	$ret = '';
	$ml_field = preg_replace('/l(.?)_(.?) (.*)/', '\\2', $field_mask);

	$i_count = $start_index + $create_count;
	while ($start_index < $i_count) {

	if (isset($this->curStructure['l'.$start_index.'_'.$ml_field]) \|\| (!$this->LanguageFound($start_index)) ) {
	$start_index++;
	continue;
	}

	$prev_index = $start_index - 1;
	do {
	list($prev_field,$type) = explode(' ', sprintf($field_mask, $prev_index) );
	} while ($prev_index > 0 && !$this->LanguageFound($prev_index--));

	if (substr($prev_field, 0, 3) == 'l0_') {
	$prev_field = substr($prev_field, 3, strlen($prev_field));
	if (!$this->curSourceField) {
	// get field name before this one
	$fields = array_keys($this->curFields);
	// $prev_field = key(end($this->curStructure));
	$prev_field = $fields[array_search($prev_field, $fields) - 1];
	if (getArrayValue($this->curFields[$prev_field], 'formatter') == 'kMultiLanguage') {
	$prev_field = 'l'.$this->languageCount.'_'.$prev_field;
	}
	}
	}

	$field_expression = sprintf($field_mask, $start_index);
	$ret .= 'ADD COLUMN '.$field_expression.' AFTER `'.$prev_field.'`, ';

	if ($this->curIndexCount < 32 && ($start_index == $this->Application->GetDefaultLanguageId() \|\| !$single_lang)) {
	// create index for primary language column + for all others (if multiple languages installed)
	list($field_name, $field_params) = explode(' ', $field_expression, 2);

	$index_type = isset($this->curFields[$ml_field]['index_type']) ? $this->curFields[$prev_field]['index_type'] : 'string';

	$ret .= $index_type == 'string' ? 'ADD INDEX (`'.$field_name.'` (5) ), ' : 'ADD INDEX (`'.$field_name.'`), ';
	$this->curIndexCount++;
	}

	$start_index++;
	}
	return preg_replace('/, $/', ';', $ret);
	}
	}
	Index: branches/5.1.x/core/units/admin/admin_events_handler.php
	===================================================================
	--- branches/5.1.x/core/units/admin/admin_events_handler.php (revision 13934)
	+++ branches/5.1.x/core/units/admin/admin_events_handler.php (revision 13935)
	@@ -1,1352 +1,1363 @@
	<?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 AdminEventsHandler extends kDBEventHandler {

	function mapPermissions()
	{
	parent::mapPermissions();
	$permissions = Array(
	'OnSaveColumns' => array('self' => true),
	'OnClosePopup' => array('self' => true),
	'OnSaveSetting' => array('self' => true),
	// export/import permissions is checked within events
	'OnExportCSV' => Array('self' => true),
	'OnGetCSV' => Array('self' => true),
	'OnCSVImportBegin' => Array('self' => true),
	'OnCSVImportStep' => Array('self' => true),
	'OnDropTempTablesByWID' => Array('self' => true),
	);
	$this->permMapping = array_merge($this->permMapping, $permissions);
	}

	/**
	* Checks permissions of user
	*
	* @param kEvent $event
	*/
	function CheckPermission(&$event)
	{
	$perm_value = null;

	$system_events = Array (
	'OnResetModRwCache', 'OnResetSections', 'OnResetConfigsCache', 'OnResetMemcache',
	'OnDeleteCompiledTemplates', 'OnCompileTemplates', 'OnGenerateTableStructure',
	'OnRebuildThemes', 'OnCheckPrefixConfig', 'OnMemoryCacheGet', 'OnMemoryCacheSet'
	);

	if (in_array($event->Name, $system_events)) {
	// events from "Tools -> System Tools" section are controlled via that section "edit" permission
	$perm_value = /$this->Application->isDebugMode() \|\|/ $this->Application->CheckPermission($event->getSection() . '.edit');
	}

	$tools_events = Array (
	'OnBackup' => 'in-portal:backup.view',
	'OnBackupProgress' => 'in-portal:backup.view',
	'OnDeleteBackup' => 'in-portal:backup.view',
	'OnBackupCancel' => 'in-portal:backup.view',

	'OnRestore' => 'in-portal:restore.view',
	'OnRestoreProgress' => 'in-portal:restore.view',
	'OnRestoreCancel' => 'in-portal:backup.view',

	'OnSqlQuery' => 'in-portal:sql_query.view',
	);

	if (array_key_exists($event->Name, $tools_events)) {
	$perm_value = $this->Application->CheckPermission($tools_events[$event->Name]);
	}

	if ($event->Name == 'OnSaveMenuFrameWidth') {
	$perm_value = $this->Application->isAdminUser;
	}

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

	return $perm_helper->finalizePermissionCheck($event, $perm_value);
	}

	return parent::CheckPermission($event);
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnResetModRwCache(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

	$this->Conn->Query('DELETE FROM ' . TABLE_PREFIX . 'CachedUrls');
	}

	function OnResetSections(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

	if ($this->Application->isCachingType(CACHING_TYPE_MEMORY)) {
	$this->Application->deleteCache('master:sections_parsed');
	}
	else {
	$this->Application->deleteDBCache('sections_parsed');
	}

	$event->SetRedirectParam('refresh_tree', 1);
	}

	function OnResetConfigsCache(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

	if ($this->Application->isCachingType(CACHING_TYPE_MEMORY)) {
	$this->Application->deleteCache('master:config_files');
	$this->Application->deleteCache('master:configs_parsed');
	$this->Application->deleteCache('master:sections_parsed');
	}
	else {
	$this->Application->deleteDBCache('config_files');
	$this->Application->deleteDBCache('configs_parsed');
	$this->Application->deleteDBCache('sections_parsed');
	}

	$skin_helper =& $this->Application->recallObject('SkinHelper');
	/* @var $skin_helper SkinHelper */

	$skin_helper->deleteCompiled();

	$event->SetRedirectParam('refresh_tree', 1);
	}

	function OnResetMemcache(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

	if ($this->Application->isCachingType(CACHING_TYPE_MEMORY)) {
	$this->Application->memoryCache->reset();
	}
	}

	function OnCompileTemplates(&$event)
	{
	$compiler =& $this->Application->recallObject('NParserCompiler');
	/* @var $compiler NParserCompiler */

	$compiler->CompileTemplatesStep();
	$event->status = erSTOP;
	}

	/**
	* Deletes all compiled templates
	*
	* @param kEvent $event
	*/
	function OnDeleteCompiledTemplates(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

	$base_path = WRITEABLE . DIRECTORY_SEPARATOR . 'cache';

	// delete debugger reports
	$debugger_reports = glob($base_path . '/debug_@*@.txt');

	foreach ($debugger_reports as $debugger_report) {
	unlink($debugger_report);
	}

	$this->_deleteCompiledTemplates($base_path);
	}

	function _deleteCompiledTemplates($folder, $unlink_folder = false)
	{
	$sub_folders = glob($folder . '/*', GLOB_ONLYDIR);

	foreach ($sub_folders as $sub_folder) {
	$this->_deleteCompiledTemplates($sub_folder, true);
	}

	$files = glob($folder . '/*.php');

	foreach ($files as $file) {
	unlink($file);
	}

	if ($unlink_folder) {
	rmdir($folder);
	}
	}

	/**
	* Generates sturcture for specified table
	*
	* @param kEvent $event
	* @author Alex
	*/
	function OnGenerateTableStructure(&$event)
	{
	$types_hash = Array(
	'string' => 'varchar\|text\|mediumtext\|longtext\|date\|datetime\|time\|timestamp\|char\|year\|enum\|set',
	'int' => 'smallint\|mediumint\|int\|bigint\|tinyint',
	'float' => 'float\|double\|decimal',
	);

	$table_name = $this->Application->GetVar('table_name');
	if (!$table_name) {
	echo 'error: no table name specified';
	return ;
	}

	if (TABLE_PREFIX && !preg_match('/^'.preg_quote(TABLE_PREFIX, '/').'(.*)/', $table_name) && (strtolower($table_name) != $table_name)) {
	// table name without prefix, then add it (don't affect K3 tables named in lowercase)
	$table_name = TABLE_PREFIX.$table_name;
	}

	if (!$this->Conn->TableFound($table_name)) {
	// table with prefix doesn't exist, assume that just config prefix passed -> resolve table name from it
	$prefix = preg_replace('/^' . preg_quote(TABLE_PREFIX, '/') . '/', '', $table_name);
	if ($this->Application->prefixRegistred($prefix)) {
	// when prefix is found -> use it's table (don't affect K3 tables named in lowecase)
	$table_name = $this->Application->getUnitOption($prefix, 'TableName');
	}
	}

	$table_info = $this->Conn->Query('DESCRIBE '.$table_name);

	// 1. prepare config keys
	$grids = Array (
	'Default' => Array (
	'Icons' => Array ('default' => 'icon16_item.png'),
	'Fields' => Array (),
	)
	);

	$grid_fields = Array();

	$id_field = '';
	$fields = Array();
	$float_types = Array ('float', 'double', 'numeric');
	foreach ($table_info as $field_info) {
	if (preg_match('/l[\d]+_.*/', $field_info['Field'])) {
	// don't put multilingual fields in config
	continue;
	}

	$field_options = Array ();
	$grid_col_options = Array(
	'title' => 'la_col_' . $field_info['Field'],
	'filter_block' => 'grid_like_filter',
	);

	// 1. get php field type by mysql field type
	foreach ($types_hash as $php_type => $db_types) {
	if (preg_match('/'.$db_types.'/', $field_info['Type'])) {
	$field_options['type'] = $php_type;
	break;
	}
	}

	+ // 2. get field default value
	$default_value = $field_info['Default'];
	- if (in_array($php_type, $float_types)) {
	+ $not_null = $field_info['Null'] != 'YES';
	+
	+ if (is_numeric($default_value)) {
	+ $default_value = preg_match('/[\.,]/', $default_value) ? (float)$default_value : (int)$default_value;
	+ }
	+
	+ if ( is_null($default_value) && $not_null ) {
	+ $default_value = $field_options['type'] == 'string' ? '' : 0;
	+ }
	+
	+ if ( in_array($php_type, $float_types) ) {
	// this is float number
	if (preg_match('/'.$db_types.'$[\d]+,([\d]+)$/i', $field_info['Type'], $regs)) {
	// size is described in structure -> add formatter
	$field_options['formatter'] = 'kFormatter';
	$field_options['format'] = '%01.'.$regs[1].'f';
	- if ($field_info['Null'] != 'YES') {
	+
	+ if ($not_null) {
	// null fields, will most likely have NULL as default value
	$default_value = 0;
	}
	}
	- else {
	+ elseif ($not_null) {
	// no size information, just convert to float
	- if ($field_info['Null'] != 'YES') {
	- // null fields, will most likely have NULL as default value
	- $default_value = (float)$default_value;
	- }
	+ // null fields, will most likely have NULL as default value
	+ $default_value = (float)$default_value;
	+
	}
	}

	if (preg_match('/varchar$([\d]+)$/i', $field_info['Type'], $regs)) {
	$field_options['max_len'] = (int)$regs[1];
	}

	if (preg_match('/tinyint$[\d]+$/i', $field_info['Type'])) {
	$field_options['formatter'] = 'kOptionsFormatter';
	$field_options['options'] = Array (1 => 'la_Yes', 0 => 'la_No');
	$field_options['use_phrases'] = 1;
	$grid_col_options['filter_block'] = 'grid_options_filter';
	}

	- if ($field_info['Null'] != 'YES') {
	+ if ($not_null) {
	$field_options['not_null'] = 1;
	}

	if ($field_info['Key'] == 'PRI') {
	$default_value = 0;
	$id_field = $field_info['Field'];
	}

	- if ($php_type == 'int' && !array_key_exists('not_null', $field_options)) {
	+ if ($php_type == 'int' && !$not_null) {
	// numeric null field
	if (preg_match('/(On\|Date)$/', $field_info['Field']) \|\| $field_info['Field'] == 'Modified') {
	$field_options['formatter'] = 'kDateFormatter';
	$grid_col_options['filter_block'] = 'grid_date_rage_filter';
	}
	}

	- if ($php_type == 'int' && ($field_info['Null'] != 'YES' \|\| is_numeric($default_value))) {
	+ if ($php_type == 'int' && ($not_null \|\| is_numeric($default_value))) {
	// is integer field AND not null
	$field_options['default'] = (int)$default_value;
	}
	else {
	$field_options['default'] = $default_value;
	}

	$fields[ $field_info['Field'] ] = $field_options;
	$grids_fields[ $field_info['Field'] ] = $grid_col_options;
	}

	$grids['Default']['Fields'] = $grids_fields;

	$ret = Array (
	'IDField' => $id_field,
	'Fields' => $fields,
	'Grids' => $grids,
	);

	$decorator = new UnitConfigDecorator();
	$ret = $decorator->decorate($ret);

	$this->Application->InitParser();
	ob_start();
	echo $this->Application->ParseBlock(Array('name' => 'incs/header', 'body_properties' => 'style="background-color: #E7E7E7; margin: 8px;"'));
	?>
	<script type="text/javascript">
	set_window_title('Table "<?php echo $table_name; ?>" Structure');
	</script>

	<a href="javascript:window_close();">Close Window</a><br /><br />
	<?php echo $GLOBALS['debugger']->highlightString($ret); ?>
	<br /><br /><a href="javascript:window_close();">Close Window</a><br />
	<?php
	echo $this->Application->ParseBlock(Array('name' => 'incs/footer'));
	echo ob_get_clean();
	$event->status = erSTOP;
	}

	/**
	* Refreshes ThemeFiles & Theme tables by actual content on HDD
	*
	* @param kEvent $event
	*/
	function OnRebuildThemes(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

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

	$themes_helper->refreshThemes();
	}

	function OnSaveColumns(&$event)
	{
	$picker_helper =& $this->Application->recallObject('ColumnPickerHelper');
	/* @var $picker_helper kColumnPickerHelper */

	$picker_helper->SetGridName($this->Application->GetLinkedVar('grid_name'));

	$picked = trim($this->Application->GetVar('picked_str'), '\|');
	$hidden = trim($this->Application->GetVar('hidden_str'), '\|');

	$main_prefix = $this->Application->GetVar('main_prefix');

	$picker_helper->SaveColumns($main_prefix, $picked, $hidden);
	$this->finalizePopup($event);
	}

	/**
	* Saves various admin settings via ajax
	*
	* @param kEvent $event
	*/
	function OnSaveSetting(&$event)
	{
	if ($this->Application->GetVar('ajax') != 'yes') {
	return ;
	}

	$var_name = $this->Application->GetVar('var_name');
	$var_value = $this->Application->GetVar('var_value');

	$this->Application->StorePersistentVar($var_name, $var_value);

	$event->status = erSTOP;
	}

	/**
	* Just closes popup & deletes last_template & opener_stack if popup, that is closing
	*
	* @param kEvent $event
	*/
	function OnClosePopup(&$event)
	{
	$event->SetRedirectParam('opener', 'u');
	}

	/**
	* Occurs right after initialization of the kernel, used mainly as hook-to event
	*
	* @param kEvent $event
	*/
	function OnStartup(&$event)
	{

	}

	/**
	* Occurs right before echoing the output, in Done method of application, used mainly as hook-to event
	*
	* @param kEvent $event
	*/
	function OnBeforeShutdown(&$event)
	{
	}

	/**
	* Is called after tree was build (when not from cache)
	*
	* @param kEvent $event
	*/
	function OnAfterBuildTree(&$event)
	{

	}

	/**
	* Called by AJAX to perform CSV export
	*
	* @param kEvent $event
	*/
	function OnExportCSV(&$event)
	{
	$export_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */

	$prefix_special = $this->Application->GetVar('PrefixSpecial');
	if(!$prefix_special) {
	$prefix_special = $export_helper->ExportData('prefix');
	}
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');

	if(!$this->Application->CheckPermission($perm_sections['main'].'.view')) {
	$event->status = erPERM_FAIL;
	return ;
	}

	$export_helper->PrefixSpecial = $prefix_special;
	$export_helper->grid = $this->Application->GetVar('grid');
	$export_helper->ExportStep();
	$event->status = erSTOP;
	}

	/**
	* Returning created by AJAX CSV file
	*
	* @param kEvent $event
	*/
	function OnGetCSV(&$event)
	{
	$export_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */

	$prefix_special = $export_helper->ExportData('prefix');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');

	if(!$this->Application->CheckPermission($perm_sections['main'].'.view')) {
	$event->status = erPERM_FAIL;
	return ;
	}

	$export_helper->GetCSV();
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnCSVImportBegin(&$event)
	{
	$prefix_special = $this->Application->GetVar('PrefixSpecial');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');

	if(!$this->Application->CheckPermission($perm_sections['main'].'.add') && !$this->Application->CheckPermission($perm_sections['main'].'.edit')) {
	$event->status = erPERM_FAIL;
	return ;
	}

	$object =& $event->getObject( Array('skip_autoload' => true) );
	/* @var $object kDBItem */
	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	$field_values = array_shift($items_info);
	$object->SetFieldsFromHash($field_values);

	$event->redirect = false;
	$result = 'required';
	if($object->GetDBField('ImportFile')) {
	$import_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $import_helper kCSVHelper */
	$import_helper->PrefixSpecial = $this->Application->GetVar('PrefixSpecial');
	$import_helper->grid = $this->Application->GetVar('grid');
	$result = $import_helper->ImportStart( $object->GetField('ImportFile', 'file_paths') );
	if($result === true) {
	$event->redirect = $this->Application->GetVar('next_template');
	$event->SetRedirectParam('PrefixSpecial', $this->Application->GetVar('PrefixSpecial'));
	$event->SetRedirectParam('grid', $this->Application->GetVar('grid'));
	}
	}

	if($event->redirect === false) {
	$object->SetError('ImportFile', $result);
	$event->status = erFAIL;
	}
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnCSVImportStep(&$event)
	{
	$import_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */

	$prefix_special = $import_helper->ImportData('prefix');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');
	if(!$this->Application->CheckPermission($perm_sections['main'].'.add') && !$this->Application->CheckPermission($perm_sections['main'].'.edit')) {
	$event->status = erPERM_FAIL;
	return ;
	}

	$import_helper->ImportStep();
	$event->status = erSTOP;
	}

	/**
	* Shows unit config filename, where requested prefix is defined
	*
	* @param kEvent $event
	*/
	function OnCheckPrefixConfig(&$event)
	{
	$prefix = $this->Application->GetVar('config_prefix');
	$config_file = $this->Application->UnitConfigReader->prefixFiles[$prefix];

	$this->Application->InitParser();

	ob_start();
	echo $this->Application->ParseBlock(Array('name' => 'incs/header', 'body_properties' => 'style="background-color: #E7E7E7; margin: 8px;"'));
	?>
	<script type="text/javascript">
	set_window_title('Unit Config of "<?php echo $prefix; ?>" prefix');
	</script>

	<a href="javascript:window_close();">Close Window</a><br /><br />
	<strong>Prefix:</strong> <?php echo $prefix; ?><br />
	<strong>Unit Config:</strong> <?php echo $GLOBALS['debugger']->highlightString($config_file); ?><br />
	<br /><a href="javascript:window_close();">Close Window</a><br />

	<?php
	echo $this->Application->ParseBlock(Array('name' => 'incs/footer'));
	echo ob_get_clean();

	$event->status = erSTOP;
	}

	function OnDropTempTablesByWID(&$event)
	{
	$sid = $this->Application->GetSID();
	$wid = $this->Application->GetVar('m_wid');
	$tables = $this->Conn->GetCol('SHOW TABLES');
	$mask_edit_table = '/'.TABLE_PREFIX.'ses_'.$sid.'_'.$wid.'_edit_(.*)$/';
	foreach($tables as $table)
	{
	if( preg_match($mask_edit_table,$table,$rets) )
	{
	$this->Conn->Query('DROP TABLE IF EXISTS '.$table);
	}
	}
	echo 'OK';
	$event->status = erSTOP;
	return ;
	}


	/**
	* Backup all data
	*
	* @param kEvent $event
	*/
	function OnBackup(&$event)
	{
	$backup_path = $this->Application->ConfigValue('Backup_Path');

	$file_helper =& $this->Application->recallObject('FileHelper');
	/* @var $file_helper FileHelper */

	if (!$file_helper->CheckFolder($backup_path) \|\| !is_writable($backup_path)) {
	$event->status = erFAIL;

	$this->Application->SetVar('error_msg', $this->Application->Phrase('la_Text_backup_access'));
	return ;
	}

	$a_tables = $this->Conn->GetCol('SHOW TABLES'); // array_keys($tables);
	$TableNames = Array();
	for($x=0;$x<count($a_tables);$x++)
	{
	if(substr($a_tables[$x],0,strlen(TABLE_PREFIX))==TABLE_PREFIX)
	{
	if (!strstr($a_tables[$x], 'ses_')) {
	$TableNames[] = $a_tables[$x];
	}
	}
	}

	$backupProgress = Array (
	'table_num' => 0,
	'table_names' => $TableNames,
	'table_count' => count($TableNames),
	'record_count' => 0,
	'file_name' => $backup_path."/dump".adodb_mktime().".txt",
	);
	$this->Application->RemoveVar('adm.backupcomplete_filename');
	$this->Application->RemoveVar('adm.backupcomplete_filesize');

	$out = array();

	for($x=0;$x<count($TableNames);$x++) {
	if (!strstr($TableNames[$x], 'ses_')) {
	$out[] = $this->GetTableCreate($TableNames[$x]);
	}
	}

	$fp = fopen($backupProgress['file_name'], 'a');

	$sql = "SELECT Name, Version FROM ".TABLE_PREFIX."Modules";
	$r = $this->Conn->Query($sql);
	foreach ($r AS $a_module) {
	$version = $a_module['Version'];
	fwrite($fp, "# ".$a_module['Name']." Version: $version;\n");
	}
	fwrite($fp, "#------------------------------------------\n\n");

	fwrite($fp,implode("\n",$out));
	fwrite($fp,"\n");

	fclose($fp);

	$this->Application->StoreVar('adm.backup_status', serialize($backupProgress));
	$event->redirect = 'tools/backup2';
	}

	/**
	* Perform next backup step
	*
	* @param kEvent $event
	*/
	function OnBackupProgress(&$event)
	{
	$done_percent = $this->performBackup();

	if ($done_percent == 100) {
	$event->redirect = 'tools/backup3';
	return ;
	}

	echo $done_percent;
	$event->status = erSTOP;
	}

	/**
	* Stops Backup & redirect to Backup template
	*
	* @param kEvent $event
	*/
	function OnBackupCancel(&$event)
	{
	$event->redirect = 'tools/backup1';
	}

	/**
	* Stops Restore & redirect to Restore template
	*
	* @param kEvent $event
	*/
	function OnRestoreCancel(&$event)
	{
	$event->redirect = 'tools/restore1';
	}

	function performBackup()
	{
	$backupProgress = unserialize($this->Application->RecallVar('adm.backup_status'));
	// echo "<pre>"; print_r($backupProgress); echo "</pre>";
	// exit;
	$CurrentTable = $backupProgress['table_names'][$backupProgress['table_num']];

	// get records
	$a_records = $this->insert_data($CurrentTable,$backupProgress['record_count'],50,"");
	// echo "<pre>"; print_r($a_records); echo "</pre>";
	// exit;

	if ($a_records['num'] < 50) {
	$backupProgress['table_num']++;
	// if ($backupProgress['table_names'][$backupProgress['table_num']] == TABLE_PREFIX.'Cache') {
	// $backupProgress['table_num']++;
	// }
	$backupProgress['record_count'] = 0;
	} else {
	$backupProgress['record_count']+=50;
	}

	if ($a_records['sql']) {
	$fp = fopen($backupProgress['file_name'], 'a');
	fwrite($fp, $a_records['sql']);
	fclose($fp);
	}
	$percent = ($backupProgress['table_num'] / $backupProgress['table_count']) * 100;
	if ($percent >= 100) {
	$percent = 100;
	$this->Application->StoreVar('adm.backupcomplete_filename', $backupProgress['file_name']);
	$this->Application->StoreVar('adm.backupcomplete_filesize', round(filesize($backupProgress['file_name'])/1024/1024, 2)); // Mbytes
	} else {
	$this->Application->StoreVar('adm.backup_status', serialize($backupProgress));
	}

	return round($percent);

	}

	//extracts the rows of data from tables using limits
	function insert_data($table, $start, $limit, $mywhere)
	{
	// global $out;

	if ($mywhere !="")
	{
	$whereclause= " WHERE ".$mywhere." ";
	}
	else
	{
	$whereclause = "";
	}

	$a_data = $this->Conn->Query("SELECT * from $table $whereclause LIMIT $start, $limit");
	// echo "SELECT * from $table $whereclause LIMIT $start, $limit";
	// echo "<pre>"; print_r($a_records); echo "</pre>";
	// exit;
	if (!$a_data) {
	return Array(
	'num' => 0,
	'sql' => '',
	);
	}
	// $prefix = GetTablePrefix();
	$rowcount = 0;
	$a_fields = array_keys($a_data[0]);
	$fields_sql = '';
	foreach ($a_fields AS $field_name) {
	$fields_sql .= '`'.$field_name.'`,';
	}
	$fields_sql = substr($fields_sql, 0, -1);
	$temp = '';
	foreach ($a_data AS $a_row)
	{
	$values_sql = '';
	foreach ($a_row as $field_name => $field_value) {
	$values_sql .= $this->Conn->qstr($field_value).',';
	}
	$values_sql = substr($values_sql, 0, -1);
	$sql = 'INSERT INTO '.$table.' ('.$fields_sql.') VALUES ('.$values_sql.');';
	$sql = str_replace("\n", "\\n", $sql);
	$sql = str_replace("\r", "\\r", $sql);
	$temp .= $sql."\n";
	}

	if(strlen(TABLE_PREFIX))
	{
	$temp = str_replace("INSERT INTO ".TABLE_PREFIX, "INSERT INTO ", $temp);
	}

	return Array(
	'num' => count($a_data),
	'sql' => $temp,
	);
	}



	function GetTableCreate($table, $crlf="\n")
	{
	$schema_create = 'DROP TABLE IF EXISTS ' . $table . ';' . $crlf;
	$schema_create .="# --------------------------------------------------------".$crlf;
	$this->Conn->Query("SET SQL_QUOTE_SHOW_CREATE = 0");
	$tmpres = $this->Conn->Query("SHOW CREATE TABLE $table");
	// echo "<pre>"; print_r($tmpres); echo "</pre>";
	// exit;
	if(is_array($tmpres) && isset($tmpres[0]))
	{
	$tmpres = $tmpres[0];
	$pos = strpos($tmpres["Create Table"], ' (');
	$pos2 = strpos($tmpres["Create Table"], '(');
	if ($pos2 != $pos + 1)
	{
	$pos = $pos2;
	$tmpres["Create Table"] = str_replace(",", ",\n ", $tmpres["Create Table"]);
	}

	$tmpres["Create Table"] = substr($tmpres["Create Table"], 0, 13)
	. (($use_backquotes) ? $tmpres["Table"] : $tmpres["Table"])
	. substr($tmpres["Create Table"], $pos);
	$tmpres["Create Table"] = str_replace("\n", $crlf, $tmpres["Create Table"]);
	if (preg_match_all('((,\r?\n[\s](CONSTRAINT\|FOREIGN[\s]KEY)[^\r\n,]+)+)', $tmpres["Create Table"], $regs)) {
	if (!isset($sql_constraints)) {
	if (isset($GLOBALS['no_constraints_comments'])) {
	$sql_constraints = '';
	} else {
	$sql_constraints = $crlf . '#' . $crlf
	. '# ' . $GLOBALS['strConstraintsForDumped'] . $crlf
	. '#' . $crlf;
	}
	}
	if (!isset($GLOBALS['no_constraints_comments'])) {
	$sql_constraints .= $crlf .'#' . $crlf .'# ' . $GLOBALS['strConstraintsForTable'] . ' ' . $table . $crlf . '#' . $crlf;
	}
	$sql_constraints .= 'ALTER TABLE $table $crlf '
	. preg_replace('/(,\r?\n\|^)([\s])(CONSTRAINT\|FOREIGN[\s]KEY)/', '\1\2ADD \3', substr($regs[0][0], 2))
	. ";\n";
	$tmpres["Create Table"] = preg_replace('((,\r?\n[\s](CONSTRAINT\|FOREIGN[\s]KEY)[^\r\n,]+)+)', '', $tmpres["Create Table"]);
	}
	$schema_create .= $tmpres["Create Table"];
	}
	if(strlen($schema_create))
	{
	$schema_create = str_replace("DROP TABLE IF EXISTS ".TABLE_PREFIX,"DROP TABLE ",$schema_create);
	$schema_create = str_replace("CREATE TABLE ".TABLE_PREFIX,"CREATE TABLE ",$schema_create);
	while(strlen($schema_create && substr($schema_create,-1)!=")"))
	{
	$schema_create = substr($schema_create,0,-1);
	}
	}
	$schema_create .= "\n# --------------------------------------------------------\n";
	return $schema_create;
	}

	/**
	* Deletes one backup file
	*
	* @param kEvent $event
	*/
	function OnDeleteBackup(&$event)
	{
	@unlink($this->get_backup_file());
	}

	function get_backup_file()
	{
	return $this->Application->ConfigValue('Backup_Path').'/dump'.$this->Application->GetVar('backupdate').'.txt';
	}

	/**
	* Starts restore process
	*
	* @param kEvent $event
	*/
	function OnRestore(&$event)
	{
	$file = $this->get_backup_file();

	$restoreProgress = Array (
	'file_pos' => 0,
	'file_name' => $file,
	'file_size' => filesize($file),
	);
	$this->Application->RemoveVar('adm.restore_success');
	$this->Application->StoreVar('adm.restore_status', serialize($restoreProgress));
	$event->redirect = 'tools/restore3';
	}

	function OnRestoreProgress(&$event)
	{
	$done_percent = $this->performRestore();

	if ($done_percent == -3) {
	$event->redirect = 'tools/restore4';
	return ;
	}

	if ($done_percent < 0) {
	$this->Application->StoreVar('adm.restore_error', 'File read error'); $event->redirect = 'tools/restore4';
	return ;
	}

	if ($done_percent == 100) {
	$this->replaceRestoredFiles();
	$this->Application->StoreVar('adm.restore_success', 1);
	$event->redirect = 'tools/restore4';
	return ;
	}

	echo $done_percent;
	$event->status = erSTOP;

	}

	function replaceRestoredFiles()
	{
	// gather restored table names
	$tables = $this->Conn->GetCol('SHOW TABLES');
	$mask_restore_table = '/^restore'.TABLE_PREFIX.'(.*)$/';
	foreach($tables as $table)
	{
	if( preg_match($mask_restore_table,$table,$rets) )
	{
	$old_table = substr($table, 7);
	$this->Conn->Query('DROP TABLE IF EXISTS '.$old_table);
	$this->Conn->Query('CREATE TABLE '.$old_table.' LIKE '.$table);
	$this->Conn->Query('INSERT INTO '.$old_table.' SELECT * FROM '.$table);
	$this->Conn->Query('DROP TABLE '.$table);
	}
	}

	}

	function performRestore()
	{
	$restoreProgress = unserialize($this->Application->RecallVar('adm.restore_status'));
	$filename = $restoreProgress['file_name'];
	$FileOffset = $restoreProgress['file_pos'];
	$MaxLines = 200;
	$size = filesize($filename);

	if($FileOffset > $size) {
	return -2;
	}

	$fp = fopen($filename,"r");
	if(!$fp) {
	return -1;
	}


	if($FileOffset>0)
	{
	fseek($fp,$FileOffset);
	}
	else
	{
	$EndOfSQL = FALSE;
	$sql = "";
	while(!feof($fp) && !$EndOfSQL)
	{
	$l = fgets($fp);
	if(substr($l,0,11)=="INSERT INTO")
	{
	$EndOfSQL = TRUE;
	}
	else
	{
	$sql .= $l;
	$FileOffset = ftell($fp) - strlen($l);
	}
	}
	if(strlen($sql))
	{
	$error = $this->runSchemaText($sql);
	if ($error != '') {

	$this->Application->StoreVar('adm.restore_error', $error);
	return -3;
	}
	}
	fseek($fp,$FileOffset);
	}

	$LinesRead = 0;
	$sql = "";
	$AllSql = array();
	while($LinesRead < $MaxLines && !feof($fp))
	{
	$sql = fgets($fp);
	if(strlen($sql))
	{
	$AllSql[] = $sql;
	$LinesRead++;
	}
	}
	if(!feof($fp))
	{
	$FileOffset = ftell($fp);
	}
	else
	{
	$FileOffset = $size;
	}
	fclose($fp);

	if(count($AllSql)>0) {
	$error = $this->runSQLText($AllSql);
	if ($error != '') {

	$this->Application->StoreVar('adm.restore_error', $error);
	return -3;
	}

	}
	$restoreProgress['file_pos'] = $FileOffset;
	$this->Application->StoreVar('adm.restore_status', serialize($restoreProgress));

	return round($FileOffset/$size * 100);
	// $this->Application->StoreVar('adm.restore_error', 'lalalal');
	// $event->redirect = 'tools/restore4';
	}


	function runSchemaText($sql)
	{
	$table_prefix = 'restore'.TABLE_PREFIX;
	// $table_prefix = TABLE_PREFIX;

	if (strlen($table_prefix) > 0) {
	$replacements = Array ('INSERT INTO ', 'UPDATE ', 'ALTER TABLE ', 'DELETE FROM ', 'REPLACE INTO ');
	foreach ($replacements as $replacement) {
	$sql = str_replace($replacement, $replacement . $table_prefix, $sql);
	}
	}

	$sql = str_replace('CREATE TABLE ', 'CREATE TABLE IF NOT EXISTS ' . $table_prefix, $sql);
	$sql = str_replace('DROP TABLE ', 'DROP TABLE IF EXISTS ' . $table_prefix, $sql);

	$commands = explode("# --------------------------------------------------------",$sql);
	if(count($commands)>0)
	{
	// $query_func = getConnectionInterface('query',$dbo_type);
	// $errorno_func = getConnectionInterface('errorno',$dbo_type);
	// $errormsg_func = getConnectionInterface('errormsg',$dbo_type);

	for($i = 0; $i < count($commands); $i++)
	{
	$cmd = $commands[$i];
	$cmd = trim($cmd);
	if(strlen($cmd)>0)
	{
	$this->Conn->Query($cmd);
	if($this->Conn->errorCode != 0)
	{
	return $this->Conn->errorMessage." COMMAND:<PRE>$cmd</PRE>";
	}
	}
	}
	}
	}

	function runSQLText($allsql)
	{
	$line = 0;
	// $query_func = getConnectionInterface('query',$dbo_type);
	// $errorno_func = getConnectionInterface('errorno',$dbo_type);
	// $errormsg_func = getConnectionInterface('errormsg',$dbo_type);

	while($line<count($allsql))
	{
	$sql = $allsql[$line];
	if(strlen(trim($sql))>0 && substr($sql,0,1)!="#")
	{
	$table_prefix = 'restore'.TABLE_PREFIX;

	if (strlen($table_prefix) > 0) {
	$replacements = Array ('INSERT INTO ', 'UPDATE ', 'ALTER TABLE ', 'DELETE FROM ', 'REPLACE INTO ');
	foreach ($replacements as $replacement) {
	$sql = str_replace($replacement, $replacement . $table_prefix, $sql);
	}
	}

	$sql = str_replace('CREATE TABLE ', 'CREATE TABLE IF NOT EXISTS ' . $table_prefix, $sql);
	$sql = str_replace('DROP TABLE ', 'DROP TABLE IF EXISTS ' . $table_prefix, $sql);

	$sql = trim($sql);
	if(strlen($sql)>0)
	{
	$this->Conn->Query($sql);

	if($this->Conn->errorCode != 0)
	{
	return $this->Conn->errorMessage." COMMAND:<PRE>$sql</PRE>";
	}
	}
	}
	$line++;
	}
	}


	/**
	* Starts restore process
	*
	* @param kEvent $event
	*/
	function OnSqlQuery(&$event)
	{
	$sql = $this->Application->GetVar('sql');
	if ($sql) {
	$start = $this->getMoment();
	$result = $this->Conn->Query($sql);
	$this->Application->SetVar('sql_time', round($this->getMoment() - $start, 7));


	if ($result)
	{
	if (is_array($result))
	{
	$this->Application->SetVar('sql_has_rows', 1);
	$this->Application->SetVar('sql_rows', serialize($result));
	}
	}

	$check_sql = trim(strtolower($sql));
	if (
	(substr($check_sql, 0, 6) == 'insert')
	\|\| (substr($check_sql, 0, 6) == 'update')
	\|\| (substr($check_sql, 0, 7) == 'replace')
	\|\| (substr($check_sql, 0, 6) == 'delete')
	) {
	$this->Application->SetVar('sql_has_affected', 1);
	$this->Application->SetVar('sql_affected', $this->Conn->getAffectedRows());
	}

	}
	$this->Application->SetVar('query_status', 1);
	$event->status = erFAIL;
	}

	function getMoment()
	{
	list($usec, $sec) = explode(' ', microtime());
	return ((float)$usec + (float)$sec);
	}

	/**
	* Occurs after unit config cache was successfully rebuilt
	*
	* @param kEvent $event
	*/
	function OnAfterCacheRebuild(&$event)
	{

	}

	/**
	* Removes "Community -> Groups" section when it is not allowed
	*
	* @param kEvent $event
	*/
	function OnAfterConfigRead(&$event)
	{
	parent::OnAfterConfigRead($event);

	if (!$this->Application->ConfigValue('AdvancedUserManagement')) {
	$section_ajustments = $this->Application->getUnitOption($event->Prefix, 'SectionAdjustments');
	if (!$section_ajustments) {
	$section_ajustments = Array ();
	}

	$section_ajustments['in-portal:user_groups'] = 'remove';

	$this->Application->setUnitOption($event->Prefix, 'SectionAdjustments', $section_ajustments);
	}
	}

	/**
	* Saves menu (tree) frame width
	*
	* @param kEvent $event
	*/
	function OnSaveMenuFrameWidth(&$event)
	{
	$event->status = erSTOP;

	if (!$this->Application->ConfigValue('ResizableFrames')) {
	return ;
	}

	$sql = 'UPDATE ' . $this->Application->getUnitOption('conf', 'TableName') . '
	SET VariableValue = ' . (int)$this->Application->GetVar('width') . '
	WHERE VariableName = "MenuFrameWidth"';
	$this->Conn->Query($sql);

	if ($this->Conn->getAffectedRows()) {
	$this->Application->UnitConfigReader->ResetParsedData(false);
	}
	}

	/**
	* Retrieves data from memory cache
	*
	* @param kEvent $event
	*/
	function OnMemoryCacheGet(&$event)
	{
	$event->status = erSTOP;

	$ret = Array ('message' => '', 'code' => 0); // 0 - ok, > 0 - error
	$key = $this->Application->GetVar('key');

	if (!$key) {
	$ret['code'] = 1;
	$ret['message'] = 'Key name missing';
	}
	else {
	$value = $this->Application->getCache($key);

	$ret['value'] =& $value;
	$ret['size'] = is_string($value) ? formatSize( strlen($value) ) : '?';
	$ret['type'] = gettype($value);

	if (IsSerialized($value)) {
	$value = unserialize($value);
	}

	if (is_array($value)) {
	$ret['value'] = print_r($value, true);
	}

	if ($ret['value'] === false) {
	$ret['code'] = 2;
	$ret['message'] = 'Key "' . $key . '" doesn\'t exist';
	}
	}

	$json_helper =& $this->Application->recallObject('JSONHelper');
	/* @var $json_helper JSONHelper */

	echo $json_helper->encode($ret);
	}

	/**
	* Retrieves data from memory cache
	*
	* @param kEvent $event
	*/
	function OnMemoryCacheSet(&$event)
	{
	$event->status = erSTOP;

	$ret = Array ('message' => '', 'code' => 0); // 0 - ok, > 0 - error
	$key = $this->Application->GetVar('key');

	if (!$key) {
	$ret['code'] = 1;
	$ret['message'] = 'Key name missing';
	}
	else {
	$value = $this->Application->GetVar('value');
	$res = $this->Application->setCache($key, $value);

	$ret['result'] = $res ? 'OK' : 'FAILED';
	}

	$json_helper =& $this->Application->recallObject('JSONHelper');
	/* @var $json_helper JSONHelper */

	echo $json_helper->encode($ret);
	}
	}


	class UnitConfigDecorator {

	var $parentPath = Array ();

	function decorate($var, $level = 0)
	{
	$ret = '';

	$deep_level = count($this->parentPath);

	if ($deep_level && ($this->parentPath[0] == 'Fields')) {
	$expand = $level < 2;
	}
	elseif ($deep_level && ($this->parentPath[0] == 'Grids')) {
	if ($deep_level == 3 && $this->parentPath[2] == 'Icons') {
	$expand = false;
	}
	else {
	$expand = $level < 4;
	}
	}
	else {
	$expand = $level == 0;
	}

	if (is_array($var)) {
	$ret .= 'Array (';
	$prepend = $expand ? "\n" . str_repeat("\t", $level + 1) : '';

	foreach ($var as $key => $value) {
	array_push($this->parentPath, $key);
	$ret .= $prepend . (is_string($key) ? "'" . $key . "'" : $key) . ' => ' . $this->decorate($value, $level + 1) . ', ';
	array_pop($this->parentPath);
	}

	$prepend = $expand ? "\n" . str_repeat("\t", $level) : '';
	$ret = rtrim($ret, ', ') . $prepend . ')';
	}
	else {
	if (is_null($var)) {
	$ret = 'NULL';
	}
	elseif (is_string($var)) {
	$ret = "'" . $var . "'";
	}
	else {
	$ret = $var;
	}
	}

	return $ret;
	}
	}
	\ No newline at end of file

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options