Верстка таблиц

<?php
/******************************************************************************/
// //
// InstantCMS v1.10 //
// instantcms.ru/ //
// //
// written by InstantCMS Team, 2007-2012 //
// produced by InstantSoft, (www.instantsoft.ru) //
// //
// LICENSED BY GNU/GPL v2 //
// //
/******************************************************************************/

if(!defined('VALID_CMS')) { die('ACCESS DENIED'); }

define('CORE_VERSION', '1.10.1');
define('CORE_BUILD', '1');
define('CORE_VERSION_DATE', '2012-12-28');
define('CORE_BUILD_DATE', '2012-12-29');

if (!defined('USER_UPDATER')) { define('USER_UPDATER', -1); }
if (!defined('USER_MASSMAIL')) { define('USER_MASSMAIL', -2); }
if (!defined('ONLINE_INTERVAL')) { define('ONLINE_INTERVAL', 3); } // интервал в минутах, когда пользователь считается online

class cmsCore {

private static $instance;

private static $jevix;

private $start_time;

private $menu_item;
private $menu_id = 0;
private $menu_struct;
private $is_menu_id_strict;

private $uri;
private $real_uri;
public $component;
public $components = array();
public $plugins = array();
private static $filters;
private $url_without_com_name = false;

private $module_configs = array();
private $component_configs = array();

private $smarty = false;

private function __construct($install_mode=false) {

if ($install_mode){ return; }

//подключим базу и конфиг
self::loadClass('db');
self::loadClass('config');
self::loadClass('plugin');

self::loadLanguage('lang');

$inConf = cmsConfig::getInstance();

//проверяем был ли переопределен шаблон через сессию
//например, из модуля "выбор шаблона"
if (isset($_SESSION['template'])) { $inConf->template = $_SESSION['template']; }

define('TEMPLATE', $inConf->template);
define('TEMPLATE_DIR', PATH.'/templates/'.$inConf->template.'/');
define('DEFAULT_TEMPLATE_DIR', PATH.'/templates/_default_/');

//загрузим структуру меню в память
$this->loadMenuStruct();

//получим URI
$this->uri = $this->detectURI();

//определим компонент
$this->component = $this->detectComponent();

//загрузим все компоненты в память
$this->components = $this->getAllComponents();

//загрузим все события плагинов в память
$this->plugins = $this->getAllPlugins();

}

private function __clone() {}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public $single_run_plugins = array('wysiwyg');

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static function getInstance($install_mode=false) {
if (self::$instance === null) {
self::$instance = new self($install_mode);
}
return self::$instance;
}

public static function getHost(){

self::loadClass('idna_convert');

$IDN = new idna_convert();

$host = $IDN->decode($_SERVER['HTTP_HOST']);

return $host;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public function startGenTimer() {

$start_time = microtime();
$start_array = explode(" ",$start_time);
$this->start_time = $start_array[1] + $start_array[0];
return true;

}

public function getGenTime(){

$end_time = microtime();
$end_array = explode(" ", $end_time);
$end_time = $end_array[1] + $end_array[0];
$time = $end_time — $this->start_time;

return $time;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static function loadLanguage($file) {

global $_LANG;

$langfile = PATH.'/languages/'.cmsConfig::getConfig('lang').'/'.$file.'.php';

if (!file_exists($langfile)){ $langfile = PATH.'/languages/ru/'.$file.'.php'; }
if (!file_exists($langfile)){ return false; }

include_once($langfile);

return true;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Преобразует массив в YAML
* @param array $array
* @return string
*/
public static function arrayToYaml($input_array) {

self::includeFile('includes/spyc/spyc.php');

if($input_array){
foreach ($input_array as $key => $value) {
$array[str_replace(array('[',']'), '', $key)] = $value;
}
} else { $array = array(); }

return Spyc::YAMLDump($array,2,40);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Преобразует YAML в массив
* @param string $yaml
* @return array
*/
public static function yamlToArray($yaml) {

self::includeFile('includes/spyc/spyc.php');

return Spyc::YAMLLoad($yaml);

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Задает полный список зарегистрированных
* событий в соответствии с включенными плагинами
* @return array
*/
public function getAllPlugins() {

// если уже получали, возвращаемся
if($this->plugins && is_array($this->plugins)) { return $this->plugins; }

// Получаем список компонентов
$this->plugins = cmsDatabase::getInstance()->get_table('cms_plugins p, cms_event_hooks e', 'p.published = 1 AND e.plugin_id = p.id', 'p.id, p.plugin, p.config, e.event');
if (!$this->plugins){ $this->plugins = array(); }

return $this->plugins;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Производит событие, вызывая все назначенные на него плагины
* @param string $event
* @param mixed $item
* @return mixed
*/
public static function callEvent($event, $item){

//получаем все активные плагины, привязанные к указанному событию
$plugins = self::getInstance()->getEventPlugins($event);

//если активных плагинов нет, возвращаем элемент $item без изменений
if (!$plugins) { return $item; }

//перебираем плагины и вызываем каждый из них, передавая элемент $item
foreach($plugins as $plugin_name){

$plugin = self::getInstance()->loadPlugin($plugin_name);

if ($plugin!==false){
$item = $plugin->execute($event, $item);
self::getInstance()->unloadPlugin($plugin);

if(isset($plugin->info['type'])){
if (in_array($plugin->info['type'], self::getInstance()->single_run_plugins)) {
return $item;
}
}
}

}

//возращаем $item обратно
return $item;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Инклюдит файл плагина из папки /plugins компонента, содержимое файла выполняется
*/
public function executePluginRoute($do){

$do = preg_replace ('/[^a-z_]/iu', '', $do);
if(!$do) { return false; }

if (file_exists(PATH.'/components/'.$this->component.'/plugins/'.$do.'.php')){
include 'components/'.$this->component.'/plugins/'.$do.'.php';
}

return true;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает массив с именами плагинов, привязанных к событию $event
* @param string $event
* @return array
*/
public function getEventPlugins($event) {

$plugins_list = array();

foreach ($this->plugins as $plugin){
if($plugin['event'] == $event){
$plugins_list[] = $plugin['plugin'];
}
}

return $plugins_list;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Устанавливает плагин и делает его привязку к событиям
* Возвращает ID установленного плагина
* @param array $plugin
* @param array $events
* @param array $config
* @return int
*/
public function installPlugin($plugin, $events, $config) {

$inDB = cmsDatabase::getInstance();

if (!@$plugin['type']) { $plugin['type'] = 'plugin'; }

$config_yaml = self::arrayToYaml($config);
if (!$config_yaml) { $config_yaml = ''; }
$plugin['config'] = $inDB->escape_string($config_yaml);

//добавляем плагин в базу
$plugin_id = $inDB->insert('cms_plugins', $plugin);

//возвращаем ложь, если плагин не установился
if (!$plugin_id) { return false; }

//добавляем хуки событий для плагина
foreach($events as $event){
$inDB->insert('cms_event_hooks', array('event'=>$event, 'plugin_id'=>$plugin_id));
}

//возращаем ID установленного плагина
return $plugin_id;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Делает апгрейд установленного плагина
* @param array $plugin
* @param array $events
* @param array $config
* @return bool
*/
public function upgradePlugin($plugin, $events, $config) {

$inDB = cmsDatabase::getInstance();

//находим ID установленной версии
$plugin_id = $this->getPluginId($plugin['plugin']);

//если плагин еще не был установлен, выходим
if (!$plugin_id) { return false; }

//загружаем текущие настройки плагина
$old_config = $this->loadPluginConfig($plugin['plugin']);

//удаляем настройки, которые больше не нужны
foreach($old_config as $param=>$value){
if ( !isset($config[$param]) ){
unset($old_config[$param]);
}
}

//добавляем настройки, которых раньше не было
foreach($config as $param=>$value){
if ( !isset($old_config[$param]) ){
$old_config[$param] = $value;
}
}

//конвертируем массив настроек в YAML
$plugin['config'] = $inDB->escape_string(self::arrayToYaml($old_config));

//обновляем плагин в базе
$inDB->update('cms_plugins', $plugin, $plugin_id);

//добавляем новые хуки событий для плагина
foreach($events as $event){
if (!$this->isPluginHook($plugin_id, $event)){
$inDB->insert('cms_event_hooks', array('event'=>$event, 'plugin_id'=>$plugin_id));
}
}

//плагин успешно обновлен
return true;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Удаляет установленный плагин
* @param array $plugin
* @param array $events
* @return bool
*/
public function removePlugin($plugin_id){

$inDB = cmsDatabase::getInstance();

//если плагин не был установлен, выходим
if (!$plugin_id) { return false; }

//удаляем плагин из базы
$inDB->delete('cms_plugins', "id = '$plugin_id'");

//Удаляем хуки событий плагина
$inDB->delete('cms_event_hooks', "plugin_id = '$plugin_id'");

//плагин успешно удален
return true;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список плагинов, имеющихся на диске, но не установленных
* @return array
*/
public function getNewPlugins() {

$new_plugins = array();
$all_plugins = $this->getPluginsDirs();

if (!$all_plugins) { return false; }

foreach($all_plugins as $plugin){
$installed = cmsDatabase::getInstance()->rows_count('cms_plugins', "plugin='{$plugin}'", 1);
if (!$installed){
$new_plugins[] = $plugin;
}
}

if (!$new_plugins) { return false; }

return $new_plugins;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список плагинов, версия которых изменилась в большую сторону
* @return array
*/
public function getUpdatedPlugins() {

$upd_plugins = array();
$all_plugins = $this->getPluginsDirs();

if (!$all_plugins) { return false; }

foreach($all_plugins as $plugin){
$plugin_obj = $this->loadPlugin($plugin);
$version = $this->getPluginVersion($plugin);
if ($version){
if ($version < $plugin_obj->info['version']){
$upd_plugins[] = $plugin;
}
}
}

if (!$upd_plugins) { return false; }

return $upd_plugins;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список папок с плагинами
* @return array
*/
public static function getPluginsDirs(){

$dir = PATH. '/plugins';
$pdir = opendir($dir);

$plugins = array();

while ($nextfile = readdir($pdir)){
if (
($nextfile != '.') &&
($nextfile != '..') &&
is_dir($dir.'/'.$nextfile) &&
($nextfile!='.svn') &&
(mb_substr($nextfile, 0, 2)=='p_')
) {
$plugins[$nextfile] = $nextfile;
}
}

if (!sizeof($plugins)){ return false; }

return $plugins;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает ID плагина по названию
* @param string $plugin
* @return int
*/
public function getPluginId($plugin){

return cmsDatabase::getInstance()->get_field('cms_plugins', "plugin='{$plugin}'", 'id');

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает название плагина по ID
* @param int $plugin_id
* @return string
*/
public function getPluginById($plugin_id){

return cmsDatabase::getInstance()->get_field('cms_plugins', "id='{$plugin_id}'", 'plugin');

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает версию плагина по названию
* @param string $plugin
* @return float
*/
public function getPluginVersion($plugin){

return cmsDatabase::getInstance()->get_field('cms_plugins', "plugin='{$plugin}'", 'version');

}

/**
* Задает полный список компонентов
* @return array
*/
public function getAllComponents() {

// если уже получали, возвращаемся
if($this->components && is_array($this->components)) { return $this->components; }

// Получаем список компонентов
$this->components = cmsDatabase::getInstance()->get_table('cms_components', '1=1 ORDER BY title', 'id, title, link, config, internal, published, version, system');
if (!$this->components){ die('kernel panic'); }

return $this->components;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Устанавливает компонент
* Возвращает ID установленного плагина
* @param array $component
* @param array $config
* @return int
*/
public function installComponent($component, $config) {

$inDB = cmsDatabase::getInstance();

$config_yaml = self::arrayToYaml($config);
if (!$config_yaml) { $config_yaml = ''; }
$component['config'] = $inDB->escape_string($config_yaml);

//добавляем компонент в базу
$component_id = $inDB->insert('cms_components', $component);

//возращаем ID установленного компонента
return $component_id? $component_id: false;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Делает апгрейд установленного компонента
* @param array $component
* @param array $config
* @return bool
*/
public function upgradeComponent($component, $config){

$inDB = cmsDatabase::getInstance();

//находим ID установленной версии
$component_id = $this->getComponentId( $component['link'] );

//если компонент еще не был установлен, выходим
if (!$component_id) { return false; }

//загружаем текущие настройки компонента
$old_config = $this->loadComponentConfig( $component['link'] );

//удаляем настройки, которые больше не нужны
foreach($old_config as $param=>$value){
if ( !isset($config[$param]) ){
unset($old_config[$param]);
}
}

//добавляем настройки, которых раньше не было
foreach($config as $param=>$value){
if ( !isset($old_config[$param]) ){
$old_config[$param] = $value;
}
}

//конвертируем массив настроек в YAML
$component['config'] = $inDB->escape_string(self::arrayToYaml($old_config));

//обновляем компонент в базе
return $inDB->update('cms_components', $component, $component_id);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Удаляет установленный компонент
* @param int $component_id
* @return bool
*/
public function removeComponent($component_id) {

//если компонент не был установлен, выходим
if (!$component_id) { return false; }

//определяем название компонента по id
$component = $this->getComponentById($component_id);

//удаляем зависимые модули компонента
if (self::loadComponentInstaller($component)){
$_component = call_user_func('info_component_'.$component);
if (isset($_component['modules'])){
if (is_array($_component['modules'])){
foreach($_component['modules'] as $module=>$title){
$module_id = self::getModuleId($module);
if ($module_id) { self::removeModule($module_id); }
}
}
}
}

//удаляем компонент из базы, но только если он не системный
cmsDatabase::getInstance()->delete('cms_components', "id = '$component_id' AND system = 0");

//компонент успешно удален
return true;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список компонентов, имеющихся на диске, но не установленных
* @return array
*/
public function getNewComponents() {

$new_components = array();
$all_components = self::getComponentsDirs();

if (!$all_components) { return false; }

foreach($all_components as $component){

$installer_file = PATH. '/components/'. $component. '/install.php';

if (file_exists($installer_file)){

if (!$this->isComponentInstalled($component)){
$new_components[] = $component;
}

}

}

if (!$new_components) { return false; }

return $new_components;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список компонентов, версия которых изменилась в большую сторону
* @return array
*/
public function getUpdatedComponents() {

$upd_components = array();

foreach($this->components as $component){
if(self::loadComponentInstaller($component['link'])){
$version = $component['version'];
$_component = call_user_func('info_component_'.$component['link']);
if ($version){
if ($version < $_component['version']){
$upd_components[] = $component['link'];
}
}
}
}

if (!$upd_components) { return false; }

return $upd_components;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список папок с компонентами
* @return array
*/
public static function getComponentsDirs(){

$dir = PATH. '/components';
$pdir = opendir($dir);

$components = array();

while ($nextfile = readdir($pdir)){
if (
($nextfile != '.') &&
($nextfile != '..') &&
is_dir($dir.'/'.$nextfile) &&
($nextfile!='.svn')
) {
$components[$nextfile] = $nextfile;
}
}

if (!sizeof($components)){ return false; }

return $components;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает ID компонента по названию
* @param string $component
* @return int
*/
public function getComponentId($component){

$component_id = 0;

foreach ($this->components as $inst_component){
if($inst_component['link'] == $component){
$component_id = $inst_component['id']; break;
}
}

return $component_id;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает название компонента по ID
* @param int $component_id
* @return string
*/
public function getComponentById($component_id){

$link = '';

foreach ($this->components as $inst_component){
if($inst_component['id'] == $component_id){
$link = $inst_component['link']; break;
}
}

return $link;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает массив компонента по ID
* @param int $component_id
* @return array
*/
public function getComponent($component_id){

$c = array();

foreach ($this->components as $inst_component){
if($inst_component['id'] == $component_id){
$c = $inst_component; break;
}
}

return $c;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает версию компонента по названию
* @param string $component
* @return float
*/
public function getComponentVersion($component){

$version = '';

foreach ($this->components as $inst_component){
if($inst_component['link'] == $component){
$version = $inst_component['version']; break;
}
}

return $version;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public static function loadComponentInstaller($component){

return self::includeFile('components/'.$component.'/install.php');;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Устанавливает модуль
* Возвращает ID установленного модуля
* @param array $module
* @param array $config
* @return int
*/
public function installModule($module, $config) {

$inDB = cmsDatabase::getInstance();

$config_yaml = self::arrayToYaml($config);
if (!$config_yaml) { $config_yaml = ''; }
$module['config'] = $inDB->escape_string($config_yaml);
// Помечаем, что модуль внешний
$module['is_external'] = 1;
// переходной костыль
// в модулях теперь нужно вместо, например
// $_module['link'] = 'mod_actions';
// писать
// $_module['content'] = 'mod_actions';
if (isset($module['link'])) {
$module['content'] = $module['link'];
}

//возращаем ID установленного модуля
return $inDB->insert('cms_modules', $module);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Делает апгрейд установленного модуля
* @param array $component
* @param array $config
* @return bool
*/
public function upgradeModule($module, $config) {

$inDB = cmsDatabase::getInstance();

// удалить в следующем обновлении
if (isset($module['link'])) {
$module['content'] = $module['link'];
}

//находим ID установленной версии
$module_id = self::getModuleId($module['content']);

//если модуль еще не был установлен, выходим
if (!$module_id) { return false; }

//загружаем текущие настройки модуля
$old_config = $this->loadModuleConfig( $module_id );

//удаляем настройки, которые больше не нужны
foreach($old_config as $param=>$value){
if ( !isset($config[$param]) ){
unset($old_config[$param]);
}
}

//добавляем настройки, которых раньше не было
foreach($config as $param=>$value){
if ( !isset($old_config[$param]) ){
$old_config[$param] = $value;
}
}

//конвертируем массив настроек в YAML
$module['config'] = $inDB->escape_string(self::arrayToYaml($old_config));

unset($module['position']);

//обновляем модуль в базе
$inDB->update('cms_modules', $module, $module_id);

//модуль успешно обновлен
return true;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Удаляет установленный модуль
* @param int $module_id
* @return bool
*/
public static function removeModule($module_id) {

return cmsDatabase::getInstance()->delete('cms_modules', "id = '{$module_id}'", 1);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список модулей, имеющихся на диске, но не установленных
* @return array
*/
public function getNewModules() {

$new_modules = array();
$all_modules = self::getModulesDirs();

if (!$all_modules) { return false; }

foreach($all_modules as $module){

$installer_file = PATH. '/modules/'. $module. '/install.php';

if (file_exists($installer_file)){

$installed = cmsDatabase::getInstance()->rows_count('cms_modules', "content='{$module}' AND user=0", 1);
if (!$installed){
$new_modules[] = $module;
}

}

}

if (!$new_modules) { return false; }

return $new_modules;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список модулей, версия которых изменилась в большую сторону
* @return array
*/
public function getUpdatedModules() {

$upd_modules = array();
$all_modules = cmsDatabase::getInstance()->get_table('cms_modules', 'user=0');

if (!$all_modules) { return false; }

foreach($all_modules as $module){
if($this->loadModuleInstaller($module['content'])){
$version = $module['version'];
$_module = call_user_func('info_module_'.$module['content']);
if ($version){
if ($version < $_module['version']){
$upd_modules[] = $module['content'];
}
}
}
}

if (!$upd_modules) { return false; }

return $upd_modules;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает список папок с модулями
* @return array
*/
public static function getModulesDirs() {

$dir = PATH. '/modules';
$pdir = opendir($dir);

$modules = array();

while ($nextfile = readdir($pdir)){
if (
($nextfile != '.') &&
($nextfile != '..') &&
is_dir($dir.'/'.$nextfile) &&
($nextfile!='.svn')
) {
$modules[$nextfile] = $nextfile;
}
}

if (!sizeof($modules)){ return false; }

return $modules;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает ID модуля по названию
* @param string $component
* @return int
*/
public static function getModuleId($module){

return cmsDatabase::getInstance()->get_field('cms_modules', "content='{$module}' AND user=0", 'id');

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает название модуля по ID
* @param int $component_id
* @return string
*/
public static function getModuleById($module_id){

return cmsDatabase::getInstance()->get_field('cms_modules', "id='{$module_id}' AND user=0", 'content');

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает версию модуля по названию
* @param string $component
* @return float
*/
public static function getModuleVersion($module){

return cmsDatabase::getInstance()->get_field('cms_modules', "content='{$module}' AND user=0", 'version');

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public static function loadModuleInstaller($module){

return self::includeFile('modules/'.$module.'/install.php');;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает кофигурацию плагина в виде массива
* @param string $plugin
* @return float
*/
public function loadPluginConfig($plugin_name){

$config = array();

foreach ($this->plugins as $plugin){
if($plugin['plugin'] == $plugin_name){
$config = self::yamlToArray($plugin['config']);
break;
}
}

return $config;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Сохраняет настройки плагина в базу
* @param string $plugin_name
* @param array $config
* @return bool
*/
public function savePluginConfig($plugin_name, $config) {

$inDB = cmsDatabase::getInstance();

//конвертируем массив настроек в YAML
$config_yaml = $inDB->escape_string(self::arrayToYaml($config));

//обновляем плагин в базе
$update_query = "UPDATE cms_plugins
SET config='{$config_yaml}'
WHERE plugin = '{$plugin_name}'";

$inDB->query($update_query);

//настройки успешно сохранены
return true;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Проверяет привязку плагина к событию
* @param int $plugin_id
* @param string $event
* @return bool
*/
public function isPluginHook($plugin_id, $event) {

return cmsDatabase::getInstance()->rows_count('cms_event_hooks', "plugin_id='{$plugin_id}' AND event='{$event}'");

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Загружает плагин и возвращает его объект
* @param string $plugin
* @return cmsPlugin
*/
public static function loadPlugin($plugin) {
$plugin_file = PATH.'/plugins/'.$plugin.'/plugin.php';
if (file_exists($plugin_file)){
include_once($plugin_file);
$plugin_obj = new $plugin();
return $plugin_obj;
}
return false;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Уничтожает объект плагина
* @param cmsPlugin $plugin_obj
* @return true
*/
public static function unloadPlugin($plugin_obj) {
unset($plugin_obj);
return true;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Загружает библиотеку из файла /core/lib_XXX.php, где XXX = $lib
* @param string $lib
* @return bool
*/
public static function loadLib($lib){
return self::includeFile('core/lib_'.$lib.'.php');
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Загружает класс из файла /core/classes/XXX.class.php, где XXX = $class
* @param string $class
* @return bool
*/
public static function loadClass($class){
return self::includeFile('core/classes/'.$class.'.class.php');
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Загружает модель для указанного компонента
* @param string $component
* @return bool
*/
public static function loadModel($component){
return self::includeFile('components/'.preg_replace('/[^a-z_]/iu', '', $component).'/model.php');
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Подключает внешний файл
* @param string $file
*/
public static function includeFile($file){
if (file_exists(PATH.'/'.$file)){
include_once PATH.'/'.$file;
return true;
} else {
return false;
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Подключает функции для работы с графикой
*/
public static function includeGraphics(){
include_once PATH.'/includes/graphic.inc.php';
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Подключает файл конфигурации
*/
public static function includeConfig(){
include_once PATH.'/includes/config.inc.php';
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static function insertEditor($name, $text='', $height='350', $width='500') {

$editor = self::callEvent('INSERT_WYSIWYG', array(
'name'=>$name,
'text'=>$text,
'height'=>$height,
'width'=>$width
));

if (!is_array($editor)){ echo $editor; return; }

echo '<p>
<div>Визуальный редактор не найден либо не включен.</div>
<div>Если редактор установлен, включите его в админке (меню <em>Дополнения</em> → <em>Плагины</em>).</div>
</p>';

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Устанавливает кукис посетителю
* @param string $name
* @param string $value
* @param int $time
*/
public static function setCookie($name, $value, $time){
setcookie('InstantCMS['.$name.']', $value, $time, '/', null, false, true);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Удаляет кукис пользователя
* @param string $name
*/
public static function unsetCookie($name){
setcookie('InstantCMS['.$name.']', '', time()-3600, '/');
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает значение кукиса
* @param string $name
* @return string || false
*/
public static function getCookie($name){
if (isset($_COOKIE['InstantCMS'][$name])){
return $_COOKIE['InstantCMS'][$name];
} else {
return false;
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Добавляет сообщение в сессию
* @param string $message
* @param string $class
*/
public static function addSessionMessage($message, $class='info'){
$_SESSION['core_message'][] = '<div class="message_'.$class.'">'.$message.'</div>';
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* Возвращает массив сообщений сохраненных в сессии
*/
public static function getSessionMessages(){

if (isset($_SESSION['core_message'])){
$messages = $_SESSION['core_message'];
} else {
$messages = false;
}

self::clearSessionMessages();
return $messages;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* Очищает очередь сообщений сессии
*/
public static function clearSessionMessages(){
unset($_SESSION['core_message']);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Обновляет статистику посещений сайта
*/
public function onlineStats(){

$inDB = cmsDatabase::getInstance();

$bots = array();
$bots['Aport'] ='Aport';
$bots['msnbot'] ='MSNbot';
$bots['Yandex'] ='Yandex';
$bots['Lycos.com'] ='Lucos';
$bots['Googlebot'] ='Google';
$bots['Openbot'] ='Openfind';
$bots['FAST-WebCrawler'] ='AllTheWeb';
$bots['TurtleScanner'] ='TurtleScanner';
$bots['Yahoo-MMCrawler'] ='Y!MMCrawler';
$bots['Yahoo!'] ='Yahoo!';
$bots['rambler'] ='Rambler';
$bots['W3C_Validator'] ='W3C Validator';
$bots['bingbot'] ='bingbot';
$bots['magpie-crawler'] ='magpie-crawler';

//удаляем старые записи
$sql = "DELETE FROM cms_online WHERE lastdate <= DATE_SUB(NOW(), INTERVAL ".ONLINE_INTERVAL." MINUTE) LIMIT 5";
$inDB->query($sql) ;

//собираем информацию о текущем пользователе
$sess_id = session_id();
$ip = self::strClear($_SERVER['REMOTE_ADDR']);
$useragent = self::strClear($_SERVER['HTTP_USER_AGENT']);
$page = self::strClear($_SERVER['REQUEST_URI']);
$refer = self::strClear($_SERVER['HTTP_REFERER']);

$user_id = cmsUser::getInstance()->id;

//Проверяем, пользователь это или поисковый бот
$crawler = false;
foreach($bots as $bot=>$uagent){ if (mb_strpos($useragent, $uagent)) { $crawler = true; break; } }
//Если не бот, вставляем/обновляем запись в "кто онлайн"
if (!$crawler){
// При аякс запросах не к чему записывать url
$page_sql = (@$_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest')? '': ", viewurl = '$page'";
$inDB->query("INSERT IGNORE INTO cms_online (ip, sess_id) VALUES ('$ip', '$sess_id') ON DUPLICATE KEY UPDATE user_id = '$user_id', agent = '$useragent' {$page_sql}");
}

//если включен сбор статистики на сайте
if (cmsConfig::getConfig('stats')){
//смотрим, есть ли запись про текущего пользователя
$sql = "SELECT id FROM cms_stats WHERE (ip = '$ip' AND page = '$page')";
$result = $inDB->query($sql) ;
//если записи нет — добавляем
if (!$inDB->num_rows($result)){
$sql = "INSERT DELAYED INTO cms_stats (ip, logdate, page, agent, refer) VALUES ('$ip', NOW(), '$page', '$useragent', '$refer')";
$inDB->query($sql) ;
}
}

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Возвращает текущий URI
* Нужна для того, чтобы иметь возможность переопределить URI.
* По сути является эмулятором внутреннего mod_rewrite
* @return string
*/
private function detectURI(){

$uri = self::strClear($_SERVER['REQUEST_URI']);
$uri = ltrim($uri, '/');
$rules = array();

$folder = rtrim($uri, '/');

if (mb_strstr($uri, "?") && !preg_match('/^admin\/(.*)/ui', $uri) && !mb_strstr($uri, 'go/url=') && !mb_strstr($uri, 'load/url=')){
$query_str = mb_substr($uri, mb_strpos($uri, "?")+1);
$uri = mb_substr($uri, 0, mb_strpos($uri, "?"));
mb_parse_str($query_str, $temp_request);
$_REQUEST = array_merge($_REQUEST, $temp_request);
}

if (in_array($folder, array('admin', 'install', 'migrate', 'index.php'))) { return; }

//специальный хак для поиска по сайту, для совместимости со старыми шаблонами
if (mb_strstr($_SERVER['QUERY_STRING'], 'view=search')){ $uri = 'search'; }

if(file_exists(PATH.'/url_rewrite.php')) {
//подключаем список rewrite-правил
self::includeFile('url_rewrite.php');
if(function_exists('rewrite_rules')){
//получаем правила
$rules = rewrite_rules();
}
}

if(file_exists(PATH.'/custom_rewrite.php')) {
//подключаем список пользовательских rewrite-правил
self::includeFile('custom_rewrite.php');
if(function_exists('custom_rewrite_rules')){
//добавляем к полученным ранее правилам пользовательские
$rules = array_merge($rules, custom_rewrite_rules());
}
}

$found = false;

// Запоминаем реальный uri
$this->real_uri = $uri;

if ($rules){
//перебираем правила
foreach($rules as $rule_id=>$rule) {
//небольшая валидация правила
if (!$rule['source'] || !$rule['target'] || !$rule['action']) { continue; }
//проверяем совпадение выражения source с текущим uri
if (preg_match($rule['source'], $uri, $matches)){

//перебираем совпавшие сегменты и добавляем их в target
//чтобы сохранить параметры из $uri в новом адресе
foreach($matches as $key=>$value){
if (!$key) { continue; }
if (mb_strstr($rule['target'], '{'.$key.'}')){
$rule['target'] = str_replace('{'.$key.'}', $value, $rule['target']);
}
}

//действие по-умолчанию: rewrite
if (!$rule['action']) { $rule['action'] = 'rewrite'; }

//выполняем действие
switch($rule['action']){
case 'rewrite': $uri = $rule['target']; $found = true; break;
case 'redirect': self::redirect($rule['target']); break;
case 'redirect-301': self::redirect($rule['target'], '301'); break;
case 'alias': self::includeFile($rule['target']); self::halt();break;
}

}

if ($found) { break; }

}
}

return $uri;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Определяет текущий компонент
* Считается, что компонент указан в первом сегменте URI,
* иначе подключается компонент для главной страницы
* Критерий "включенности" компонента определяется в функции loadComponentConfig
* @return string $component
*/
private function detectComponent(){

$component = '';

//компонент на главной
if (!$this->uri && cmsConfig::getConfig('homecom')) { return cmsConfig::getConfig('homecom'); }

//определяем, есть ли слэши в адресе
$first_slash_pos = mb_strpos($this->uri, '/');

if ($first_slash_pos){
//если есть слэши, то компонент это сегмент до первого слэша
$component = mb_substr($this->uri, 0, $first_slash_pos);
} else {
//если слэшей нет, то компонент совпадает с адресом
$component = $this->uri;
}

if (is_dir(PATH.'/components/'.$component)){
//если компонент определен и существует
return $component;
} else {
//если компонент не существует, считаем что это content
$this->uri = cmsConfig::getConfig('com_without_name_in_url').'/'.$this->uri;
$this->url_without_com_name = true;
return cmsConfig::getConfig('com_without_name_in_url');
}

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Функция подключает файл router.php из папки с текущим компонентом
* и вызывает метод route_component(), которые возвращает массив правил
* для анализа URI. Если в массиве найдено совпадение с текущим URI,
* то URI парсится и переменные, содержащиеся в нем, забиваются в массив $_REQUEST.
* @return boolean
*/
private function parseComponentRoute(){

$component = $this->component;

//проверяем что компонент указаны
if (!$component) { return false; }
//если uri нет, все равно возвращаем истину — для опции "компонент на главной"
if (!$this->uri) { return true; }

// если uri совпадает с названием компонента, возвращаем истину
if($this->uri == $component) { return true; }

/**
* Критерий "включенности" компонента определяется в функции loadComponentConfig
*/
//подключаем список маршрутов компонента
if(!self::includeFile('components/'.$component.'/router.php')){ return false; }

$routes = call_user_func('routes_'.$component);
$routes = self::callEvent('GET_ROUTE_'.mb_strtoupper($component), $routes);
// Флаг удачного перебора
$is_found = false;
//перебираем все маршруты
if($routes){
foreach($routes as $route_id=>$route){

//сравниваем шаблон маршрута с текущим URI
preg_match($route['_uri'], $this->uri, $matches);

//Если найдено совпадение
if ($matches){

//удаляем шаблон из параметров маршрута, чтобы не мешал при переборе
unset($route['_uri']);

//перебираем параметры маршрута в виде ключ=>значение
foreach($route as $key=>$value){
if (is_integer($key)){
//Если ключ — целое число, то значением является сегмент URI
$_REQUEST[$value] = $matches[$key];
} else {
//иначе, значение берется из маршрута
$_REQUEST[$key] = $value;
}
}
// совпадение есть
$is_found = true;
//раз найдено совпадение, прерываем цикл
break;

}

}
}

// Если в маршруте нет совпадений
if(!$is_found) { return false; }

return true;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Генерирует тело страницы, вызывая нужный компонент
*/
public function proceedBody(){

$component = $this->component;

//проверяем что компонент указан
if (!$component) { return false; }
/**
* Критерий "включенности" компонента определяется в функции loadComponentConfig
*/
//проверяем что в названии только буквы и цифры
if (!preg_match("/^([a-z0-9])+$/u", $component)){ self::error404(); }

self::loadLanguage('components/'.$component);

//проверяем наличие компонента
if(!file_exists('components/'.$component.'/frontend.php')){ self::error404(); }

//парсим адрес и заполняем массив $_REQUEST (временное решение)
if(!$this->parseComponentRoute()) { self::error404(); }

ob_start();

require('components/'.$component.'/frontend.php');

call_user_func($component);

cmsPage::getInstance()->page_body = cms