/**
 * Плагин для смарти
 * Подключает обработчик блоков шаблона
 *
 * @param array $aParams
 * @param Smarty $oSmarty
 * @return string
 */
function smarty_insert_block($aParams, &$oSmarty)
{
    if (!isset($aParams['block'])) {
        trigger_error('Not found param "block"', E_USER_WARNING);
        return;
    }
    /**
     * Устанавливаем шаблон
     */
    $sBlock = ucfirst(basename($aParams['block']));
    /**
     * Проверяем наличие шаблона. Определяем значения параметров работы в зависимости от того,
     * принадлежит ли блок одному из плагинов, или является пользовательским классом движка
     */
    if (isset($aParams['params']) and isset($aParams['params']['plugin'])) {
        $sBlockTemplate = Plugin::GetTemplatePath($aParams['params']['plugin']) . 'blocks/block.' . $aParams['block'] . '.tpl';
        $sBlock = 'Plugin' . func_camelize($aParams['params']['plugin']) . '_Block' . $sBlock;
    } else {
        $sBlockTemplate = 'blocks/block.' . $aParams['block'] . '.tpl';
        $sBlock = 'Block' . $sBlock;
    }
    $sBlock = Engine::getInstance()->Plugin_GetDelegate('block', $sBlock);
    /**
     * параметры
     */
    $aParamsBlock = array();
    if (isset($aParams['params'])) {
        $aParamsBlock = $aParams['params'];
    }
    /**
     * Подключаем необходимый обработчик
     */
    $oBlock = new $sBlock($aParamsBlock);
    $oBlock->SetTemplate($sBlockTemplate);
    /**
     * Запускаем обработчик
     */
    $mResult = $oBlock->Exec();
    if (is_string($mResult) or $mResult === false) {
        /**
         * Если метод возвращает строку - выводим ее вместо рендеринга шаблона
         */
        return $mResult;
    } else {
        /**
         * Получаем шаблон, возможно его переопределили в обработчике блока
         */
        $sBlockTemplate = Engine::getInstance()->Plugin_GetDelegate('template', $oBlock->GetTemplate());
        if (!Engine::getInstance()->Viewer_TemplateExists($sBlockTemplate)) {
            return "<b>Not found template for block: <i>{$sBlockTemplate} ({$sBlock})</i></b>";
        }
    }
    /**
     * Возвращаем результат в виде обработанного шаблона блока
     */
    return Engine::getInstance()->Viewer_Fetch($sBlockTemplate);
}

 /**
  * Инициализация
  */
 public function Init()
 {
     parent::Init();
     $this->aValidateRules[] = array('text', 'string', 'max' => Config::Get('module.user.complaint_text_max'), 'min' => 1, 'allowEmpty' => !Config::Get('module.user.complaint_text_required'), 'label' => $this->Lang_Get('user_complaint_text_title'));
     if (Config::Get('module.user.complaint_captcha')) {
         $sCaptchaValidateType = func_camelize('captcha_' . Config::Get('sys.captcha.type'));
         $this->aValidateRules[] = array('captcha', $sCaptchaValidateType, 'name' => 'complaint_user');
     }
 }

 public function getValueTypeObject()
 {
     if (!$this->_getDataOne('value_type_object')) {
         $oObject = Engine::GetEntity('ModuleProperty_EntityValueType' . func_camelize($this->getPropertyType()));
         $oObject->setValueObject($this);
         $this->setValueTypeObject($oObject);
     }
     return $this->_getDataOne('value_type_object');
 }

 /**
  * Определяем дополнительные правила валидации
  *
  * @param array|bool $aParam
  */
 public function __construct($aParam = false)
 {
     $this->aValidateRules[] = array('password', 'string', 'allowEmpty' => false, 'min' => 5, 'on' => array('registration'), 'label' => $this->Lang_Get('auth.labels.password'));
     $this->aValidateRules[] = array('password_confirm', 'compare', 'compareField' => 'password', 'on' => array('registration'), 'label' => $this->Lang_Get('auth.registration.form.fields.password_confirm.label'));
     $sCaptchaValidateType = func_camelize('captcha_' . Config::Get('sys.captcha.type'));
     if (Config::Get('module.user.captcha_use_registration')) {
         $this->aValidateRules[] = array('captcha', $sCaptchaValidateType, 'name' => 'user_signup', 'on' => array('registration'), 'label' => $this->Lang_Get('auth.labels.captcha_field'));
     }
     if (Config::Get('general.login.captcha')) {
         $this->aValidateRules[] = array('captcha', $sCaptchaValidateType, 'name' => 'user_auth', 'on' => array('signIn'), 'label' => $this->Lang_Get('auth.labels.captcha_field'));
     }
     parent::__construct($aParam);
 }

 public function actionNew($aArgs)
 {
     // Передано ли имя нового плагина
     if (!isset($aArgs[0])) {
         die("The plugin name is not specified.\n");
     }
     $this->_name_under = func_underscore($aArgs[0]);
     $this->_name = func_camelize($this->_name_under);
     $path = strtr($this->_name_under, '/\\', DIRECTORY_SEPARATOR);
     $path = Config::Get('path.application.plugins.server') . '/' . $path;
     if (strpos($path, DIRECTORY_SEPARATOR) === false) {
         $path = '.' . DIRECTORY_SEPARATOR . $path;
     }
     $dir = rtrim(realpath(dirname($path)), '\\/');
     if ($dir === false || !is_dir($dir)) {
         die("The directory '{$path}' is not valid. Please make sure the parent directory exists.\n");
     }
     $sourceDir = realpath(dirname(__FILE__) . '/../protected/plugin');
     if ($sourceDir === false) {
         die("\nUnable to locate the source directory.\n");
     }
     // Создаем массив файлов для функции копирования
     $aList = $this->buildFileList($sourceDir, $path);
     // Парсим имена плагинов и пересоздаем массив
     foreach ($aList as $sName => $aFile) {
         $sTarget = str_replace('Example', $this->_name, $aFile['target']);
         $sTarget = str_replace('example', $this->_name_under, $sTarget);
         $sNewName = str_replace('Example', $this->_name, $sName);
         $sNewName = str_replace('example', $this->_name_under, $sNewName);
         if ($sName != $sNewName) {
             unset($aList[$sName]);
         }
         $aFile['target'] = $sTarget;
         $aList[$sNewName] = $aFile;
         $aList[$sNewName]['callback'] = array($this, 'generatePlugin');
     }
     // Копируем файлы
     $this->copyFiles($aList);
     echo "\nYour plugin has been created successfully under {$path}.\n";
 }

 /**
  * Определяет тип блока
  *
  * @param string $sName	Название блока
  * @param string|null $sPlugin	код плагина, если блок принадлежит плагину
  * @return string ('block','template','undefined')
  */
 protected function DefineTypeBlock($sName, $sPlugin = null)
 {
     $sDir = $sPlugin ? Plugin::GetTemplatePath($sPlugin) : null;
     /**
      * Если ли обработчик блока?
      */
     $sClassBlock = ($sPlugin ? 'Plugin' . func_camelize($sPlugin) . '_' : '') . 'Block' . func_camelize($sName);
     if (class_exists($sClassBlock)) {
         return 'block';
     } elseif ($this->TemplateExists(is_null($sDir) ? $sName : rtrim($sDir, '/') . '/' . ltrim($sName, '/'))) {
         /**
          * Если найден шаблон по имени блока то считаем его простым шаблоном
          */
         return 'template';
     } else {
         /**
          * Считаем что тип не определен
          */
         throw new Exception('Can not find the block`s template: ' . $sName);
         return 'undefined';
     }
 }

 /**
  * Проверяет разрешение для конкретного пользователя
  *
  * @param ModuleUser_EntityUser $oUser Пользователь
  * @param string $sPermissionCode Код разрешения
  * @param array $aParams Параметры
  * @param mixed $sPlugin Плагин, можно указать код плагина, название класса или объект
  *
  * @return bool
  */
 protected function IsAllowUserFull($oUser, $sPermissionCode, $aParams = array(), $sPlugin = null)
 {
     if (!$sPermissionCode) {
         return false;
     }
     $sPlugin = $sPlugin ? Plugin::GetPluginCode($sPlugin) : '';
     /**
      * Загружаем все роли и пермишены
      */
     $this->LoadRoleAndPermissions();
     $sUserId = self::ROLE_CODE_GUEST;
     if ($oUser) {
         $sUserId = $oUser->getId();
     }
     /**
      * Смотрим роли в кеше
      */
     if (!isset($this->aUserRoleCache[$sUserId])) {
         if ($sUserId == self::ROLE_CODE_GUEST) {
             $aRoles = $this->GetRoleByCodeAndState(self::ROLE_CODE_GUEST, self::ROLE_STATE_ACTIVE);
             $aRoles = $aRoles ? array($aRoles) : array();
         } else {
             $aRoles = $this->GetRolesByUser($oUser);
         }
         $this->aUserRoleCache[$sUserId] = $aRoles;
     } else {
         $aRoles = $this->aUserRoleCache[$sUserId];
     }
     /**
      * Получаем пермишены для ролей
      */
     $sPermissionCode = func_underscore($sPermissionCode);
     $mResult = false;
     foreach ($aRoles as $oRole) {
         /**
          * У роли есть необходимый пермишен, то проверим на возможную кастомную обработку с параметрами
          */
         if ($this->CheckPermissionByRole($oRole, $sPermissionCode, $sPlugin)) {
             /**
              * Проверяем на передачу коллбека
              */
             if (isset($aParams['callback']) and is_callable($aParams['callback'])) {
                 $mResult = call_user_func($aParams['callback'], $oUser, $aParams);
             } else {
                 /**
                  * Для плагинов: CheckCustomPluginArticleCreate
                  * Для ядра: CheckCustomCreate
                  */
                 $sAdd = $sPlugin ? 'Plugin' . func_camelize($sPlugin) : '';
                 $sMethod = 'CheckCustom' . $sAdd . func_camelize($sPermissionCode);
                 if (method_exists($this, $sMethod)) {
                     $mResult = call_user_func(array($this, $sMethod), $oUser, $aParams);
                 } else {
                     return true;
                 }
             }
             break;
         }
     }
     /**
      * Дефолтное сообщение об ошибке
      */
     $sMsg = 'У вас нет прав на "' . $sPermissionCode . '"';
     /**
      * Проверяем результат кастомной обработки
      */
     if ($mResult === true) {
         return true;
     } elseif (is_string($mResult)) {
         /**
          * Вернули кастомное сообщение об ошибке
          */
         $sMsg = $mResult;
     } else {
         /**
          * Формируем сообщение об ошибке
          */
         if (isset($this->aPermissionCache[$sPlugin][$sPermissionCode])) {
             $aPerm = $this->aPermissionCache[$sPlugin][$sPermissionCode];
             if ($aPerm['msg_error']) {
                 $sMsg = $this->Lang_Get($aPerm['msg_error']);
             } else {
                 $sMsg = 'У вас нет прав на "' . ($aPerm['title'] ? $aPerm['title'] : $aPerm['code']) . '"';
             }
         }
     }
     $this->sMessageLast = $sMsg;
     return false;
 }

 /**
  * Ставим хук на вызов неизвестного метода и считаем что хотели вызвать метод какого либо модуля.
  * Также обрабатывает различные ORM методы сущности, например
  * <pre>
  * $oUser->Save();
  * $oUser->Delete();
  * </pre>
  * И методы модуля ORM, например
  * <pre>
  *    $this->User_getUserItemsByName('Claus');
  *    $this->User_getUserItemsAll();
  * </pre>
  * @see Engine::_CallModule
  *
  * @param string $sName Имя метода
  * @param array $aArgs Аргументы
  * @return mixed
  */
 public function __call($sName, $aArgs)
 {
     $sNameUnderscore = func_underscore($sName);
     if (preg_match("@^add([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_AddEntity($aArgs[0]);
     }
     if (preg_match("@^update([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_UpdateEntity($aArgs[0]);
     }
     if (preg_match("@^save([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_SaveEntity($aArgs[0]);
     }
     if (preg_match("@^delete([a-z]+)\$@i", $sName, $aMatch) and !strpos($sNameUnderscore, 'items_by_filter')) {
         return $this->_DeleteEntity($aArgs[0]);
     }
     if (preg_match("@^reload([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_ReloadEntity($aArgs[0]);
     }
     if (preg_match("@^showcolumnsfrom([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_ShowColumnsFrom($aArgs[0]);
     }
     if (preg_match("@^showprimaryindexfrom([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_ShowPrimaryIndexFrom($aArgs[0]);
     }
     if (preg_match("@^getchildrenof([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_GetChildrenOfEntity($aArgs[0]);
     }
     if (preg_match("@^getparentof([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_GetParentOfEntity($aArgs[0]);
     }
     if (preg_match("@^getdescendantsof([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_GetDescendantsOfEntity($aArgs[0]);
     }
     if (preg_match("@^getancestorsof([a-z]+)\$@i", $sName, $aMatch)) {
         return $this->_GetAncestorsOfEntity($aArgs[0]);
     }
     if (preg_match("@^loadtreeof([a-z]+)\$@i", $sName, $aMatch)) {
         $sEntityFull = array_key_exists(1, $aMatch) ? $aMatch[1] : null;
         return $this->LoadTree(isset($aArgs[0]) ? $aArgs[0] : array(), $sEntityFull);
     }
     $iEntityPosEnd = 0;
     if (strpos($sNameUnderscore, '_items') >= 3) {
         $iEntityPosEnd = strpos($sNameUnderscore, '_items');
     } else {
         if (strpos($sNameUnderscore, '_by') >= 3) {
             $iEntityPosEnd = strpos($sNameUnderscore, '_by');
         } else {
             if (strpos($sNameUnderscore, '_all') >= 3) {
                 $iEntityPosEnd = strpos($sNameUnderscore, '_all');
             }
         }
     }
     if ($iEntityPosEnd && $iEntityPosEnd > 4) {
         $sEntityName = substr($sNameUnderscore, 4, $iEntityPosEnd - 4);
     } else {
         $sEntityName = func_underscore(Engine::GetModuleName($this)) . '_';
         $sNameUnderscore = substr_replace($sNameUnderscore, $sEntityName, 4, 0);
         $iEntityPosEnd = strlen($sEntityName) - 1 + 4;
     }
     $sNameUnderscore = substr_replace($sNameUnderscore, str_replace('_', '', $sEntityName), 4, $iEntityPosEnd - 4);
     $sEntityName = func_camelize($sEntityName);
     /**
      * getMaxRatingFromUserByFilter() get_max_rating_from_user_by_filter
      */
     if (preg_match("@^get_(max|min|avg|sum)_([a-z][_a-z0-9]*)_from_([a-z][_a-z0-9]*)_by_filter\$@i", func_underscore($sName), $aMatch)) {
         return $this->GetAggregateFunctionByFilter($aMatch[1], $aMatch[2], isset($aArgs[0]) ? $aArgs[0] : array(), func_camelize($aMatch[3]));
     }
     /**
      * getMaxRatingFromUserByStatusAndActive() get_max_rating_from_user_by_status_and_active
      */
     if (preg_match("@^get_(max|min|avg|sum)_([a-z][_a-z0-9]*)_from_([a-z][_a-z0-9]*)_by_([_a-z]+)\$@i", func_underscore($sName), $aMatch)) {
         $aSearchParams = explode('_and_', $aMatch[4]);
         $aSplit = array_chunk($aArgs, count($aSearchParams));
         $aFilter = array_combine($aSearchParams, $aSplit[0]);
         if (isset($aSplit[1][0])) {
             $aFilter = array_merge($aFilter, $aSplit[1][0]);
         }
         return $this->GetAggregateFunctionByFilter($aMatch[1], $aMatch[2], $aFilter, func_camelize($aMatch[3]));
     }
     /**
      * getCountFromUserByFilter() get_count_from_user_by_filter
      */
//.........这里部分代码省略.........

 /**
  * Загрузка плагинов и делегирование
  *
  */
 protected function LoadPlugins()
 {
     if ($aPluginList = func_list_plugins()) {
         foreach ($aPluginList as $sPluginName) {
             $sClassName = 'Plugin' . func_camelize($sPluginName);
             $oPlugin = new $sClassName();
             $oPlugin->Delegate();
             $this->aPlugins[$sPluginName] = $oPlugin;
         }
     }
 }

 public function CallbackParserTag($sTag, $aParams, $sContent)
 {
     $sParserClass = 'ModuleText_EntityParserTag' . func_camelize($sTag);
     if (class_exists($sParserClass)) {
         $oParser = Engine::GetEntity($sParserClass);
         return $oParser->parse($sContent, $aParams);
     }
     return '';
 }

 /**
  * Ajax валидация каптчи
  */
 protected function EventCaptchaValidate()
 {
     $sName = isset($_REQUEST['params']['name']) ? $_REQUEST['params']['name'] : '';
     $sValue = isset($_REQUEST['fields'][0]['value']) ? $_REQUEST['fields'][0]['value'] : '';
     $sField = isset($_REQUEST['fields'][0]['field']) ? $_REQUEST['fields'][0]['field'] : '';
     $sCaptchaValidateType = func_camelize('captcha_' . Config::Get('sys.captcha.type'));
     if (!$this->Validate_Validate($sCaptchaValidateType, $sValue, array('name' => $sName))) {
         $aErrors = $this->Validate_GetErrors();
         $this->Viewer_AssignAjax('aErrors', array(htmlspecialchars($sField) => array(reset($aErrors))));
     }
 }

 /**
  * Возвращает объект бекенда кеша
  *
  * @param string|null $sCacheType Тип кеша
  *
  * @return ModuleCache_EntityBackend    Объект бекенда кеша
  * @throws Exception
  */
 protected function GetCacheBackend($sCacheType = null)
 {
     if ($sCacheType) {
         $sCacheType = strtolower($sCacheType);
     } else {
         $sCacheType = $this->sCacheType;
     }
     /**
      * Устанавливает алиас memory == memcached
      */
     if ($sCacheType == 'memory') {
         $sCacheType = 'memcached';
     }
     if (isset($this->aCacheBackends[$sCacheType])) {
         return $this->aCacheBackends[$sCacheType];
     }
     $sCacheTypeCam = func_camelize($sCacheType);
     /**
      * Формируем имя класса бекенда
      */
     $sClass = "ModuleCache_EntityBackend{$sCacheTypeCam}";
     $sClass = Engine::GetEntityClass($sClass);
     if (class_exists($sClass)) {
         /**
          * Создаем объект и проверяем доступность его использования
          */
         $oBackend = new $sClass();
         if (true === ($mResult = $oBackend->IsAvailable())) {
             $oBackend->Init(array('stats_callback' => array($this, 'CalcStats')));
             $this->aCacheBackends[$sCacheType] = $oBackend;
             return $oBackend;
         } else {
             throw new Exception("Cache '{$sCacheTypeCam}' not available: {$mResult}");
         }
     }
     throw new Exception("Not found class for cache type: " . $sCacheTypeCam);
 }

 /**
  * Возвращает относительный путь
  *
  * @param string $sPath Исходный путь с префиксом, например, [server]/home/webmaster/site.com/image.jpg
  * @param bool $bWithType
  *
  * @return string
  */
 public function GetPathRelative($sPath, $bWithType = false)
 {
     list($sType, $sPath) = $this->GetParsedPath($sPath);
     if ($sType != self::PATH_TYPE_RELATIVE) {
         /**
          * Пробуем вызвать метод GetPathRelativeFrom[Type]()
          */
         $sMethod = 'GetPathRelativeFrom' . func_camelize($sType);
         if (method_exists($this, $sMethod)) {
             $sPath = $this->{$sMethod}($sPath);
         }
     }
     if ($bWithType) {
         $sPath = $this->MakePath($sPath, self::PATH_TYPE_RELATIVE);
     }
     return $sPath;
 }

 public function CheckAllowTargetObject($sTargetType, $iTargetId, $aParams = array())
 {
     $sMethod = 'CheckAllowTargetObject' . func_camelize($sTargetType);
     if (method_exists($this, $sMethod)) {
         if (!array_key_exists('user', $aParams)) {
             $aParams['user'] = $this->oUserCurrent;
         }
         return $this->{$sMethod}($iTargetId, $aParams);
     }
     /**
      * По умолчанию считаем доступ разрешен
      */
     return true;
 }

 /**
  * Выполняет откат изменений плагина к БД
  * Обратный по действию метод - ApplyPluginUpdate (@see ApplyPluginUpdate)
  *
  * @param $sPlugin
  */
 protected function PurgePluginUpdate($sPlugin)
 {
     $sPlugin = strtolower($sPlugin);
     $sPluginDir = Plugin::GetPath($sPlugin) . 'update/';
     /**
      * Получаем список выполненых миграций из БД
      */
     $aMigrationItemsGroup = $this->GetMigrationItemsByFilter(array('code' => $sPlugin, '#order' => array('file' => 'asc'), '#index-group' => 'version'));
     $aMigrationItemsGroup = array_reverse($this->SortVersions($aMigrationItemsGroup, true), true);
     foreach ($aMigrationItemsGroup as $sVersion => $aMigrationItems) {
         foreach ($aMigrationItems as $oMigration) {
             $sPath = $sPluginDir . $sVersion . '/' . $oMigration->getFile();
             if (file_exists($sPath)) {
                 require_once $sPath;
                 $sClass = 'Plugin' . func_camelize($sPlugin) . '_Update_' . basename($oMigration->getFile(), '.php');
                 $oUpdate = new $sClass();
                 $oUpdate->down();
             }
             /**
              * Удаляем запись из БД
              */
             $oMigration->Delete();
         }
     }
     /**
      * Удаляем версию
      */
     if ($oVersion = $this->GetVersionByCode($sPlugin)) {
         $oVersion->Delete();
     }
     /**
      * Удаляем данные плагина из хранилища настроек
      */
     $this->Storage_RemoveAll('Plugin' . func_camelize($sPlugin));
     $this->Storage_Remove('__config__', 'Plugin' . func_camelize($sPlugin));
     // хардим удаление конфига админки
 }

 /**
  * Создает и возвращает объект валидатора
  *
  * @param $sName	Имя валидатора или метода при использовании параметра $oObject
  * @param $oObject	Объект в котором необходимо вызвать метод валидации
  * @param null $aFields	Список полей сущности для которых необходимо провести валидацию
  * @param array $aParams
  *
  * @return mixed
  */
 public function CreateValidator($sName, $oObject, $aFields = null, $aParams = array())
 {
     if (is_string($aFields)) {
         $aFields = preg_split('/[\\s,]+/', $aFields, -1, PREG_SPLIT_NO_EMPTY);
     }
     /**
      * Определяем список сценариев валидации
      */
     if (isset($aParams['on'])) {
         if (is_array($aParams['on'])) {
             $aOn = $aParams['on'];
         } else {
             $aOn = preg_split('/[\\s,]+/', $aParams['on'], -1, PREG_SPLIT_NO_EMPTY);
         }
     } else {
         $aOn = array();
     }
     /**
      * Если в качестве имени валидатора указан метод объекта, то создаем специальный валидатор
      */
     $sMethod = 'validate' . func_camelize($sName);
     if (method_exists($oObject, $sMethod)) {
         $oValidator = Engine::GetEntity('ModuleValidate_EntityValidatorInline');
         if (!is_null($aFields)) {
             $oValidator->fields = $aFields;
         }
         $oValidator->object = $oObject;
         $oValidator->method = $sMethod;
         $oValidator->params = $aParams;
         if (isset($aParams['skipOnError'])) {
             $oValidator->skipOnError = $aParams['skipOnError'];
         }
     } else {
         /**
          * Иначе создаем валидатор по имени
          */
         if (!is_null($aFields)) {
             $aParams['fields'] = $aFields;
         }
         $sValidateName = 'Validator' . func_camelize($sName);
         $oValidator = Engine::GetEntity('ModuleValidate_Entity' . $sValidateName);
         foreach ($aParams as $sNameParam => $sValue) {
             $oValidator->{$sNameParam} = $sValue;
         }
     }
     $oValidator->on = empty($aOn) ? array() : array_combine($aOn, $aOn);
     return $oValidator;
 }

 public function __get($sName)
 {
     // Обработка обращений к обёрткам связей MANY_TO_MANY
     // Если связь загружена, возвращаем объект связи
     if (isset($this->_aManyToManyRelations[func_underscore($sName)])) {
         return $this->_aManyToManyRelations[func_underscore($sName)];
         // Есл не загружена, но связь с таким именем существет, пробуем загрузить и вернуть объект связи
     } elseif (isset($this->aRelations[func_underscore($sName)]) && $this->aRelations[func_underscore($sName)][0] == self::RELATION_TYPE_MANY_TO_MANY) {
         $sMethod = 'get' . func_camelize($sName);
         $this->__call($sMethod, array());
         if (isset($this->_aManyToManyRelations[func_underscore($sName)])) {
             return $this->_aManyToManyRelations[func_underscore($sName)];
         }
         // В противном случае возвращаем то, что просили у объекта
     } else {
         return $this->{$sName};
     }
 }

 /**
  * Создает и возврашает объект типа
  *
  * @param string $sType
  *
  * @return bool|ModuleAsset_EntityType
  */
 public function CreateObjectType($sType)
 {
     /**
      * Формируем имя класса для типа
      */
     $sClass = "ModuleAsset_EntityType" . func_camelize($sType);
     if (class_exists(Engine::GetEntityClass($sClass))) {
         return Engine::GetEntity($sClass);
     }
     return false;
 }

 /**
  * Возвращает список тегов для объекта избранного
  *
  * @param string $sTargetType	Тип владельца
  * @param int $iTargetId	ID владельца
  * @return bool|array
  */
 public function GetTagsTarget($sTargetType, $iTargetId)
 {
     $sMethod = 'GetTagsTarget' . func_camelize($sTargetType);
     if (method_exists($this, $sMethod)) {
         return $this->{$sMethod}($iTargetId);
     }
     return false;
 }

 /**
  * Устанавливает значение поля текущей сущности
  *
  * @param string $sField
  * @param string|mixed $sValue
  */
 protected function setValueOfCurrentEntity($sField, $sValue)
 {
     if ($this->oEntityCurrent) {
         call_user_func_array(array($this->oEntityCurrent, 'set' . func_camelize($sField)), array($sValue));
     }
 }