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