<?php
/*-------------------------------------------------------
*
*   LiveStreet Engine Social Networking
*   Copyright © 2008 Mzhelskiy Maxim
*
*--------------------------------------------------------
*
*   Official site: www.livestreet.ru
*   Contact e-mail: rus.engine@gmail.com
*
*   GNU General Public License, version 2:
*   http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
*
---------------------------------------------------------
*/

/**
 * Модуль для работы с пользователями
 *
 * @package modules.user
 * @since 1.0
 */
class ModuleUser extends Module {
	/**
	 * Статусы дружбы между пользователями
	 */
	const USER_FRIEND_OFFER  = 1;
	const USER_FRIEND_ACCEPT = 2;
	const USER_FRIEND_DELETE = 4;
	const USER_FRIEND_REJECT = 8;
	const USER_FRIEND_NULL   = 16;
	/**
	 * Статусы жалобы на пользователя
	 */
	const COMPLAINT_STATE_NEW = 1;
	const COMPLAINT_STATE_READ = 2;
	/**
	 * Объект маппера
	 *
	 * @var ModuleUser_MapperUser
	 */
	protected $oMapper;
	/**
	 * Объект текущего пользователя
	 *
	 * @var ModuleUser_EntityUser|null
	 */
	protected $oUserCurrent=null;
	/**
	 * Объект сессии текущего пользователя
	 *
	 * @var ModuleUser_EntitySession|null
	 */
	protected $oSession=null;
	/**
	 * Список типов пользовательских полей
	 *
	 * @var array
	 */
	protected $aUserFieldTypes=array(
		'social','contact'
	);

	/**
	 * Инициализация
	 *
	 */
	public function Init() {
		$this->oMapper=Engine::GetMapper(__CLASS__);
		/**
		 * Проверяем есть ли у юзера сессия, т.е. залогинен или нет
		 */
		$sUserId=$this->Session_Get('user_id');
		if ($sUserId and $oUser=$this->GetUserById($sUserId) and $oUser->getActivate()) {
			if ($this->oSession=$oUser->getSession()) {
				/**
				 * Сюда можно вставить условие на проверку айпишника сессии
				 */
				$this->oUserCurrent=$oUser;
			}
		}
		/**
		 * Запускаем автозалогинивание
		 * В куках стоит время на сколько запоминать юзера
		 */
		$this->AutoLogin();
		/**
		 * Обновляем сессию
		 */
		if (isset($this->oSession)) {
			$this->UpdateSession();
		}
	}
	/**
	 * Возвращает список типов полей
	 *
	 * @return array
	 */
	public function GetUserFieldTypes() {
		return $this->aUserFieldTypes;
	}
	/**
	 * Добавляет новый тип с пользовательские поля
	 *
	 * @param string $sType	Тип
	 * @return bool
	 */
	public function AddUserFieldTypes($sType) {
		if (!in_array($sType,$this->aUserFieldTypes)) {
			$this->aUserFieldTypes[]=$sType;
			return true;
		}
		return false;
	}
	/**
	 * Получает дополнительные данные(объекты) для юзеров по их ID
	 *
	 * @param array $aUserId	Список ID пользователей
	 * @param array|null $aAllowData	Список типод дополнительных данных для подгрузки у пользователей
	 * @return array
	 */
	public function GetUsersAdditionalData($aUserId,$aAllowData=null) {
		if (is_null($aAllowData)) {
			$aAllowData=array('vote','session','friend','geo_target','note');
		}
		func_array_simpleflip($aAllowData);
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		/**
		 * Получаем юзеров
		 */
		$aUsers=$this->GetUsersByArrayId($aUserId);
		/**
		 * Получаем дополнительные данные
		 */
		$aSessions=array();
		$aFriends=array();
		$aVote=array();
		$aGeoTargets=array();
		$aNotes=array();
		if (isset($aAllowData['session'])) {
			$aSessions=$this->GetSessionsByArrayId($aUserId);
		}
		if (isset($aAllowData['friend']) and $this->oUserCurrent) {
			$aFriends=$this->GetFriendsByArray($aUserId,$this->oUserCurrent->getId());
		}

		if (isset($aAllowData['vote']) and $this->oUserCurrent) {
			$aVote=$this->Vote_GetVoteByArray($aUserId,'user',$this->oUserCurrent->getId());
		}
		if (isset($aAllowData['geo_target'])) {
			$aGeoTargets=$this->Geo_GetTargetsByTargetArray('user',$aUserId);
		}
		if (isset($aAllowData['note']) and $this->oUserCurrent) {
			$aNotes=$this->GetUserNotesByArray($aUserId,$this->oUserCurrent->getId());
		}
		/**
		 * Добавляем данные к результату
		 */
		foreach ($aUsers as $oUser) {
			if (isset($aSessions[$oUser->getId()])) {
				$oUser->setSession($aSessions[$oUser->getId()]);
			} else {
				$oUser->setSession(null); // или $oUser->setSession(new ModuleUser_EntitySession());
			}
			if ($aFriends&&isset($aFriends[$oUser->getId()])) {
				$oUser->setUserFriend($aFriends[$oUser->getId()]);
			} else {
				$oUser->setUserFriend(null);
			}

			if (isset($aVote[$oUser->getId()])) {
				$oUser->setVote($aVote[$oUser->getId()]);
			} else {
				$oUser->setVote(null);
			}
			if (isset($aGeoTargets[$oUser->getId()])) {
				$aTargets=$aGeoTargets[$oUser->getId()];
				$oUser->setGeoTarget(isset($aTargets[0]) ? $aTargets[0] : null);
			} else {
				$oUser->setGeoTarget(null);
			}
			if (isset($aAllowData['note'])) {
				if (isset($aNotes[$oUser->getId()])) {
					$oUser->setUserNote($aNotes[$oUser->getId()]);
				} else {
					$oUser->setUserNote(false);
				}
			}
		}

		return $aUsers;
	}
	/**
	 * Список юзеров по ID
	 *
	 * @param array $aUserId Список ID пользователей
	 * @return array
	 */
	public function GetUsersByArrayId($aUserId) {
		if (!$aUserId) {
			return array();
		}
		if (Config::Get('sys.cache.solid')) {
			return $this->GetUsersByArrayIdSolid($aUserId);
		}
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aUsers=array();
		$aUserIdNotNeedQuery=array();
		/**
		 * Делаем мульти-запрос к кешу
		 */
		$aCacheKeys=func_build_cache_keys($aUserId,'user_');
		if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
			/**
			 * проверяем что досталось из кеша
			 */
			foreach ($aCacheKeys as $sValue => $sKey ) {
				if (array_key_exists($sKey,$data)) {
					if ($data[$sKey]) {
						$aUsers[$data[$sKey]->getId()]=$data[$sKey];
					} else {
						$aUserIdNotNeedQuery[]=$sValue;
					}
				}
			}
		}
		/**
		 * Смотрим каких юзеров не было в кеше и делаем запрос в БД
		 */
		$aUserIdNeedQuery=array_diff($aUserId,array_keys($aUsers));
		$aUserIdNeedQuery=array_diff($aUserIdNeedQuery,$aUserIdNotNeedQuery);
		$aUserIdNeedStore=$aUserIdNeedQuery;
		if ($data = $this->oMapper->GetUsersByArrayId($aUserIdNeedQuery)) {
			foreach ($data as $oUser) {
				/**
				 * Добавляем к результату и сохраняем в кеш
				 */
				$aUsers[$oUser->getId()]=$oUser;
				$this->Cache_Set($oUser, "user_{$oUser->getId()}", array(), 60*60*24*4);
				$aUserIdNeedStore=array_diff($aUserIdNeedStore,array($oUser->getId()));
			}
		}
		/**
		 * Сохраняем в кеш запросы не вернувшие результата
		 */
		foreach ($aUserIdNeedStore as $sId) {
			$this->Cache_Set(null, "user_{$sId}", array(), 60*60*24*4);
		}
		/**
		 * Сортируем результат согласно входящему массиву
		 */
		$aUsers=func_array_sort_by_keys($aUsers,$aUserId);
		return $aUsers;
	}
	/**
	 * Алиас для корректной работы ORM
	 *
	 * @param array $aUserId	Список ID пользователей
	 * @return array
	 */
	public function GetUserItemsByArrayId($aUserId) {
		return $this->GetUsersByArrayId($aUserId);
	}
	/**
	 * Получение пользователей по списку ID используя общий кеш
	 *
	 * @param array $aUserId	Список ID пользователей
	 * @return array
	 */
	public function GetUsersByArrayIdSolid($aUserId) {
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aUsers=array();
		$s=join(',',$aUserId);
		if (false === ($data = $this->Cache_Get("user_id_{$s}"))) {
			$data = $this->oMapper->GetUsersByArrayId($aUserId);
			foreach ($data as $oUser) {
				$aUsers[$oUser->getId()]=$oUser;
			}
			$this->Cache_Set($aUsers, "user_id_{$s}", array("user_update","user_new"), 60*60*24*1);
			return $aUsers;
		}
		return $data;
	}
	/**
	 * Список сессий юзеров по ID
	 *
	 * @param array $aUserId	Список ID пользователей
	 * @return array
	 */
	public function GetSessionsByArrayId($aUserId) {
		if (!$aUserId) {
			return array();
		}
		if (Config::Get('sys.cache.solid')) {
			return $this->GetSessionsByArrayIdSolid($aUserId);
		}
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aSessions=array();
		$aUserIdNotNeedQuery=array();
		/**
		 * Делаем мульти-запрос к кешу
		 */
		$aCacheKeys=func_build_cache_keys($aUserId,'user_session_');
		if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
			/**
			 * проверяем что досталось из кеша
			 */
			foreach ($aCacheKeys as $sValue => $sKey ) {
				if (array_key_exists($sKey,$data)) {
					if ($data[$sKey] and $data[$sKey]['session']) {
						$aSessions[$data[$sKey]['session']->getUserId()]=$data[$sKey]['session'];
					} else {
						$aUserIdNotNeedQuery[]=$sValue;
					}
				}
			}
		}
		/**
		 * Смотрим каких юзеров не было в кеше и делаем запрос в БД
		 */
		$aUserIdNeedQuery=array_diff($aUserId,array_keys($aSessions));
		$aUserIdNeedQuery=array_diff($aUserIdNeedQuery,$aUserIdNotNeedQuery);
		$aUserIdNeedStore=$aUserIdNeedQuery;
		if ($data = $this->oMapper->GetSessionsByArrayId($aUserIdNeedQuery)) {
			foreach ($data as $oSession) {
				/**
				 * Добавляем к результату и сохраняем в кеш
				 */
				$aSessions[$oSession->getUserId()]=$oSession;
				$this->Cache_Set(array('time'=>time(),'session'=>$oSession), "user_session_{$oSession->getUserId()}", array(), 60*60*24*4);
				$aUserIdNeedStore=array_diff($aUserIdNeedStore,array($oSession->getUserId()));
			}
		}
		/**
		 * Сохраняем в кеш запросы не вернувшие результата
		 */
		foreach ($aUserIdNeedStore as $sId) {
			$this->Cache_Set(array('time'=>time(),'session'=>null), "user_session_{$sId}", array(), 60*60*24*4);
		}
		/**
		 * Сортируем результат согласно входящему массиву
		 */
		$aSessions=func_array_sort_by_keys($aSessions,$aUserId);
		return $aSessions;
	}
	/**
	 * Получить список сессий по списку айдишников, но используя единый кеш
	 *
	 * @param array $aUserId	Список ID пользователей
	 * @return array
	 */
	public function GetSessionsByArrayIdSolid($aUserId) {
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aSessions=array();
		$s=join(',',$aUserId);
		if (false === ($data = $this->Cache_Get("user_session_id_{$s}"))) {
			$data = $this->oMapper->GetSessionsByArrayId($aUserId);
			foreach ($data as $oSession) {
				$aSessions[$oSession->getUserId()]=$oSession;
			}
			$this->Cache_Set($aSessions, "user_session_id_{$s}", array("user_session_update"), 60*60*24*1);
			return $aSessions;
		}
		return $data;
	}
	/**
	 * Получает сессию юзера
	 *
	 * @param int $sUserId	ID пользователя
	 * @return ModuleUser_EntitySession|null
	 */
	public function GetSessionByUserId($sUserId) {
		$aSessions=$this->GetSessionsByArrayId($sUserId);
		if (isset($aSessions[$sUserId])) {
			return $aSessions[$sUserId];
		}
		return null;
	}
	/**
	 * При завершенни модуля загружаем в шалон объект текущего юзера
	 *
	 */
	public function Shutdown() {
		if ($this->oUserCurrent) {
			$this->Viewer_Assign('iUserCurrentCountTalkNew',$this->Talk_GetCountTalkNew($this->oUserCurrent->getId()));
			$this->Viewer_Assign('iUserCurrentCountTopicDraft',$this->Topic_GetCountDraftTopicsByUserId($this->oUserCurrent->getId()));
		}
		$this->Viewer_Assign('oUserCurrent',$this->oUserCurrent);
	}
	/**
	 * Добавляет юзера
	 *
	 * @param ModuleUser_EntityUser $oUser	Объект пользователя
	 * @return ModuleUser_EntityUser|bool
	 */
	public function Add(ModuleUser_EntityUser $oUser) {
		if ($sId=$this->oMapper->Add($oUser)) {
			$oUser->setId($sId);
			//чистим зависимые кеши
			$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('user_new'));
			/**
			 * Создаем персональный блог
			 */
			$this->Blog_CreatePersonalBlog($oUser);
			return $oUser;
		}
		return false;
	}
	/**
	 * Получить юзера по ключу активации
	 *
	 * @param string $sKey	Ключ активации
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserByActivateKey($sKey) {
		$id=$this->oMapper->GetUserByActivateKey($sKey);
		return $this->GetUserById($id);
	}
	/**
	 * Получить юзера по ключу сессии
	 *
	 * @param string $sKey	Сессионный ключ
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserBySessionKey($sKey) {
		$id=$this->oMapper->GetUserBySessionKey($sKey);
		return $this->GetUserById($id);
	}
	/**
	 * Получить юзера по мылу
	 *
	 * @param string $sMail	Емайл
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserByMail($sMail) {
		$id=$this->oMapper->GetUserByMail($sMail);
		return $this->GetUserById($id);
	}
	/**
	 * Получить юзера по логину
	 *
	 * @param string $sLogin Логин пользователя
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserByLogin($sLogin) {
		$s=strtolower($sLogin);
		if (false === ($id = $this->Cache_Get("user_login_{$s}"))) {
			if ($id = $this->oMapper->GetUserByLogin($sLogin)) {
				$this->Cache_Set($id, "user_login_{$s}", array(), 60*60*24*1);
			}
		}
		return $this->GetUserById($id);
	}
	/**
	 * Получить юзера по айдишнику
	 *
	 * @param int $sId	ID пользователя
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserById($sId) {
		if (!is_numeric($sId)) {
			return null;
		}
		$aUsers=$this->GetUsersAdditionalData($sId);
		if (isset($aUsers[$sId])) {
			return $aUsers[$sId];
		}
		return null;
	}
	/**
	 * Обновляет юзера
	 *
	 * @param ModuleUser_EntityUser $oUser	Объект пользователя
	 * @return bool
	 */
	public function Update(ModuleUser_EntityUser $oUser) {
		//чистим зависимые кеши
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('user_update'));
		$this->Cache_Delete("user_{$oUser->getId()}");
		return $this->oMapper->Update($oUser);
	}
	/**
	 * Авторизовывает юзера
	 *
	 * @param ModuleUser_EntityUser $oUser	Объект пользователя
	 * @param bool $bRemember	Запоминать пользователя или нет
	 * @param string $sKey	Ключ авторизации для куков
	 * @return bool
	 */
	public function Authorization(ModuleUser_EntityUser $oUser,$bRemember=true,$sKey=null) {
		if (!$oUser->getId() or !$oUser->getActivate()) {
			return false;
		}
		/**
		 * Генерим новый ключ авторизаии для куков
		 */
		if(is_null($sKey)){
			$sKey=md5(func_generator().time().$oUser->getLogin());
		}
		/**
		 * Создаём новую сессию
		 */
		if (!$this->CreateSession($oUser,$sKey)) {
			return false;
		}
		/**
		 * Запоминаем в сесси юзера
		 */
		$this->Session_Set('user_id',$oUser->getId());
		$this->oUserCurrent=$oUser;
		/**
		 * Ставим куку
		 */
		if ($bRemember) {
			setcookie('key',$sKey,time()+Config::Get('sys.cookie.time'),Config::Get('sys.cookie.path'),Config::Get('sys.cookie.host'),false,true);
		}
		return true;
	}
	/**
	 * Автоматическое заллогинивание по ключу из куков
	 *
	 */
	protected function AutoLogin() {
		if ($this->oUserCurrent) {
			return;
		}
		if (isset($_COOKIE['key']) and is_string($_COOKIE['key']) and $sKey=$_COOKIE['key']) {
			if ($oUser=$this->GetUserBySessionKey($sKey)) {
				$this->Authorization($oUser);
			} else {
				$this->Logout();
			}
		}
	}
	/**
	 * Авторизован ли юзер
	 *
	 * @return bool
	 */
	public function IsAuthorization() {
		if ($this->oUserCurrent) {
			return true;
		} else {
			return false;
		}
	}
	/**
	 * Получить текущего юзера
	 *
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserCurrent() {
		return $this->oUserCurrent;
	}
	/**
	 * Проверяет является ли текущий пользователь администратором
	 *
	 * @param bool $bReturnUser Возвращать или нет объект пользователя
	 *
	 * @return bool|ModuleUser_EntityUser
	 */
	public function GetIsAdmin($bReturnUser=false) {
		if ($this->oUserCurrent and $this->oUserCurrent->isAdministrator()) {
			return $bReturnUser ? $this->oUserCurrent : true;
		}
		return false;
	}
	/**
	 * Разлогинивание
	 *
	 */
	public function Logout() {
		$this->oUserCurrent=null;
		$this->oSession=null;
		/**
		 * Дропаем из сессии
		 */
		$this->Session_Drop('user_id');
		/**
		 * Дропаем куку
		 */
		setcookie('key','',1,Config::Get('sys.cookie.path'),Config::Get('sys.cookie.host'));
	}
	/**
	 * Обновление данных сессии
	 * Важный момент: сессию обновляем в кеше и раз в 10 минут скидываем в БД
	 */
	protected function UpdateSession() {
		$this->oSession->setDateLast(date("Y-m-d H:i:s"));
		$this->oSession->setIpLast(func_getIp());
		if (false === ($data = $this->Cache_Get("user_session_{$this->oSession->getUserId()}"))) {
			$data=array(
				'time'=>time(),
				'session'=>$this->oSession
			);
		} else {
			$data['session']=$this->oSession;
		}
		if (!Config::Get('sys.cache.use') or $data['time']<time()-60*10) {
			$data['time']=time();
			$this->oMapper->UpdateSession($this->oSession);
			$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('user_session_update'));
		}
		$this->Cache_Set($data, "user_session_{$this->oSession->getUserId()}", array(), 60*60*24*4);
	}
	/**
	 * Создание пользовательской сессии
	 *
	 * @param ModuleUser_EntityUser $oUser	Объект пользователя
	 * @param string $sKey	Сессионный ключ
	 * @return bool
	 */
	protected function CreateSession(ModuleUser_EntityUser $oUser,$sKey) {
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('user_session_update'));
		$this->Cache_Delete("user_session_{$oUser->getId()}");
		$oSession=Engine::GetEntity('User_Session');
		$oSession->setUserId($oUser->getId());
		$oSession->setKey($sKey);
		$oSession->setIpLast(func_getIp());
		$oSession->setIpCreate(func_getIp());
		$oSession->setDateLast(date("Y-m-d H:i:s"));
		$oSession->setDateCreate(date("Y-m-d H:i:s"));
		if ($this->oMapper->CreateSession($oSession)) {
			$this->oSession=$oSession;
			return true;
		}
		return false;
	}
	/**
	 * Получить список юзеров по дате последнего визита
	 *
	 * @param int $iLimit Количество
	 * @return array
	 */
	public function GetUsersByDateLast($iLimit=20) {
		if ($this->IsAuthorization()) {
			$data=$this->oMapper->GetUsersByDateLast($iLimit);
		} elseif (false === ($data = $this->Cache_Get("user_date_last_{$iLimit}"))) {
			$data = $this->oMapper->GetUsersByDateLast($iLimit);
			$this->Cache_Set($data, "user_date_last_{$iLimit}", array("user_session_update"), 60*60*24*2);
		}
		$data=$this->GetUsersAdditionalData($data);
		return $data;
	}
	/**
	 * Возвращает список пользователей по фильтру
	 *
	 * @param array $aFilter	Фильтр
	 * @param array $aOrder	Сортировка
	 * @param int $iCurrPage	Номер страницы
	 * @param int $iPerPage	Количество элментов на страницу
	 * @param array $aAllowData	Список типо данных для подгрузки к пользователям
	 * @return array('collection'=>array,'count'=>int)
	 */
	public function GetUsersByFilter($aFilter,$aOrder,$iCurrPage,$iPerPage,$aAllowData=null) {
		$sKey="user_filter_".serialize($aFilter).serialize($aOrder)."_{$iCurrPage}_{$iPerPage}";
		if (false === ($data = $this->Cache_Get($sKey))) {
			$data = array('collection'=>$this->oMapper->GetUsersByFilter($aFilter,$aOrder,$iCount,$iCurrPage,$iPerPage),'count'=>$iCount);
			/**
			 * Если есть фильтр по "кто онлайн", то уменьшаем время кеширования до 10 минут
			 */
			$iTimeCache=isset($aFilter['date_last_more']) ? 60*10 : 60*60*24*2;
			$this->Cache_Set($data, $sKey, array("user_update","user_new"), $iTimeCache);
		}
		$data['collection']=$this->GetUsersAdditionalData($data['collection'],$aAllowData);
		return $data;
	}
	/**
	 * Получить список юзеров по дате регистрации
	 *
	 * @param int $iLimit	Количество
	 * @return array
	 */
	public function GetUsersByDateRegister($iLimit=20) {
		$aResult=$this->GetUsersByFilter(array('activate'=>1),array('id'=>'desc'),1,$iLimit);
		return $aResult['collection'];
	}
	/**
	 * Получить статистику по юзерам
	 *
	 * @return array
	 */
	public function GetStatUsers() {
		if (false === ($aStat = $this->Cache_Get("user_stats"))) {
			$aStat['count_all']=$this->oMapper->GetCountUsers();
			$sDate=date("Y-m-d H:i:s",time()-Config::Get('module.user.time_active'));
			$aStat['count_active']=$this->oMapper->GetCountUsersActive($sDate);
			$aStat['count_inactive']=$aStat['count_all']-$aStat['count_active'];
			$aSex=$this->oMapper->GetCountUsersSex();
			$aStat['count_sex_man']=(isset($aSex['man']) ? $aSex['man']['count'] : 0);
			$aStat['count_sex_woman']=(isset($aSex['woman']) ? $aSex['woman']['count'] : 0);
			$aStat['count_sex_other']=(isset($aSex['other']) ? $aSex['other']['count'] : 0);

			$this->Cache_Set($aStat, "user_stats", array("user_update","user_new"), 60*60*24*4);
		}
		return $aStat;
	}
	/**
	 * Получить список юзеров по первым  буквам логина
	 *
	 * @param string $sUserLogin	Логин
	 * @param int $iLimit	Количество
	 * @return array
	 */
	public function GetUsersByLoginLike($sUserLogin,$iLimit) {
		if (false === ($data = $this->Cache_Get("user_like_{$sUserLogin}_{$iLimit}"))) {
			$data = $this->oMapper->GetUsersByLoginLike($sUserLogin,$iLimit);
			$this->Cache_Set($data, "user_like_{$sUserLogin}_{$iLimit}", array("user_new"), 60*60*24*2);
		}
		$data=$this->GetUsersAdditionalData($data);
		return $data;
	}
	/**
	 * Получить список отношений друзей
	 *
	 * @param  array $aUserId	Список ID пользователей проверяемых на дружбу
	 * @param  int $sUserId	ID пользователя у которого проверяем друзей
	 * @return array
	 */
	public function GetFriendsByArray($aUserId,$sUserId) {
		if (!$aUserId) {
			return array();
		}
		if (Config::Get('sys.cache.solid')) {
			return $this->GetFriendsByArraySolid($aUserId,$sUserId);
		}
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aFriends=array();
		$aUserIdNotNeedQuery=array();
		/**
		 * Делаем мульти-запрос к кешу
		 */
		$aCacheKeys=func_build_cache_keys($aUserId,'user_friend_','_'.$sUserId);
		if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
			/**
			 * проверяем что досталось из кеша
			 */
			foreach ($aCacheKeys as $sValue => $sKey ) {
				if (array_key_exists($sKey,$data)) {
					if ($data[$sKey]) {
						$aFriends[$data[$sKey]->getFriendId()]=$data[$sKey];
					} else {
						$aUserIdNotNeedQuery[]=$sValue;
					}
				}
			}
		}
		/**
		 * Смотрим каких френдов не было в кеше и делаем запрос в БД
		 */
		$aUserIdNeedQuery=array_diff($aUserId,array_keys($aFriends));
		$aUserIdNeedQuery=array_diff($aUserIdNeedQuery,$aUserIdNotNeedQuery);
		$aUserIdNeedStore=$aUserIdNeedQuery;
		if ($data = $this->oMapper->GetFriendsByArrayId($aUserIdNeedQuery,$sUserId)) {
			foreach ($data as $oFriend) {
				/**
				 * Добавляем к результату и сохраняем в кеш
				 */
				$aFriends[$oFriend->getFriendId($sUserId)]=$oFriend;
				/**
				 * Тут кеш нужно будет продумать как-то по другому.
				 * Пока не трогаю, ибо этот код все равно не выполняется.
				 * by Kachaev
				 */
				$this->Cache_Set($oFriend, "user_friend_{$oFriend->getFriendId()}_{$oFriend->getUserId()}", array(), 60*60*24*4);
				$aUserIdNeedStore=array_diff($aUserIdNeedStore,array($oFriend->getFriendId()));
			}
		}
		/**
		 * Сохраняем в кеш запросы не вернувшие результата
		 */
		foreach ($aUserIdNeedStore as $sId) {
			$this->Cache_Set(null, "user_friend_{$sId}_{$sUserId}", array(), 60*60*24*4);
		}
		/**
		 * Сортируем результат согласно входящему массиву
		 */
		$aFriends=func_array_sort_by_keys($aFriends,$aUserId);
		return $aFriends;
	}
	/**
	 * Получить список отношений друзей используя единый кеш
	 *
	 * @param  array $aUserId	Список ID пользователей проверяемых на дружбу
	 * @param  int $sUserId	ID пользователя у которого проверяем друзей
	 * @return array
	 */
	public function GetFriendsByArraySolid($aUserId,$sUserId) {
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aFriends=array();
		$s=join(',',$aUserId);
		if (false === ($data = $this->Cache_Get("user_friend_{$sUserId}_id_{$s}"))) {
			$data = $this->oMapper->GetFriendsByArrayId($aUserId,$sUserId);
			foreach ($data as $oFriend) {
				$aFriends[$oFriend->getFriendId($sUserId)]=$oFriend;
			}

			$this->Cache_Set($aFriends, "user_friend_{$sUserId}_id_{$s}", array("friend_change_user_{$sUserId}"), 60*60*24*1);
			return $aFriends;
		}
		return $data;
	}
	/**
	 * Получаем привязку друга к юзеру(есть ли у юзера данный друг)
	 *
	 * @param  int $sFriendId	ID пользователя друга
	 * @param  int $sUserId	ID пользователя
	 * @return ModuleUser_EntityFriend|null
	 */
	public function GetFriend($sFriendId,$sUserId) {
		$data=$this->GetFriendsByArray($sFriendId,$sUserId);
		if (isset($data[$sFriendId])) {
			return $data[$sFriendId];
		}
		return null;
	}
	/**
	 * Добавляет друга
	 *
	 * @param  ModuleUser_EntityFriend $oFriend	Объект дружбы(связи пользователей)
	 * @return bool
	 */
	public function AddFriend(ModuleUser_EntityFriend $oFriend) {
		//чистим зависимые кеши
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("friend_change_user_{$oFriend->getUserFrom()}","friend_change_user_{$oFriend->getUserTo()}"));
		$this->Cache_Delete("user_friend_{$oFriend->getUserFrom()}_{$oFriend->getUserTo()}");
		$this->Cache_Delete("user_friend_{$oFriend->getUserTo()}_{$oFriend->getUserFrom()}");

		return $this->oMapper->AddFriend($oFriend);
	}
	/**
	 * Удаляет друга
	 *
	 * @param  ModuleUser_EntityFriend $oFriend Объект дружбы(связи пользователей)
	 * @return bool
	 */
	public function DeleteFriend(ModuleUser_EntityFriend $oFriend) {
		//чистим зависимые кеши
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("friend_change_user_{$oFriend->getUserFrom()}","friend_change_user_{$oFriend->getUserTo()}"));
		$this->Cache_Delete("user_friend_{$oFriend->getUserFrom()}_{$oFriend->getUserTo()}");
		$this->Cache_Delete("user_friend_{$oFriend->getUserTo()}_{$oFriend->getUserFrom()}");

		// устанавливаем статус дружбы "удалено"
		$oFriend->setStatusByUserId(ModuleUser::USER_FRIEND_DELETE,$oFriend->getUserId());
		return $this->oMapper->UpdateFriend($oFriend);
	}
	/**
	 * Удаляет информацию о дружбе из базы данных
	 *
	 * @param  ModuleUser_EntityFriend $oFriend	Объект дружбы(связи пользователей)
	 * @return bool
	 */
	public function EraseFriend(ModuleUser_EntityFriend $oFriend) {
		//чистим зависимые кеши
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("friend_change_user_{$oFriend->getUserFrom()}","friend_change_user_{$oFriend->getUserTo()}"));
		$this->Cache_Delete("user_friend_{$oFriend->getUserFrom()}_{$oFriend->getUserTo()}");
		$this->Cache_Delete("user_friend_{$oFriend->getUserTo()}_{$oFriend->getUserFrom()}");
		return $this->oMapper->EraseFriend($oFriend);
	}
	/**
	 * Обновляет информацию о друге
	 *
	 * @param  ModuleUser_EntityFriend $oFriend	Объект дружбы(связи пользователей)
	 * @return bool
	 */
	public function UpdateFriend(ModuleUser_EntityFriend $oFriend) {
		//чистим зависимые кеши
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("friend_change_user_{$oFriend->getUserFrom()}","friend_change_user_{$oFriend->getUserTo()}"));
		$this->Cache_Delete("user_friend_{$oFriend->getUserFrom()}_{$oFriend->getUserTo()}");
		$this->Cache_Delete("user_friend_{$oFriend->getUserTo()}_{$oFriend->getUserFrom()}");
		return $this->oMapper->UpdateFriend($oFriend);
	}
	/**
	 * Получает список друзей
	 *
	 * @param  int $sUserId	ID пользователя
	 * @param  int $iPage	Номер страницы
	 * @param  int $iPerPage	Количество элементов на страницу
	 * @return array
	 */
	public function GetUsersFriend($sUserId,$iPage=1,$iPerPage=10) {
		$sKey="user_friend_{$sUserId}_{$iPage}_{$iPerPage}";
		if (false === ($data = $this->Cache_Get($sKey))) {
			$data = array('collection'=>$this->oMapper->GetUsersFriend($sUserId,$iCount,$iPage,$iPerPage),'count'=>$iCount);
			$this->Cache_Set($data, $sKey, array("friend_change_user_{$sUserId}"), 60*60*24*2);
		}
		$data['collection']=$this->GetUsersAdditionalData($data['collection']);
		return $data;
	}
	/**
	 * Получает количество друзей
	 *
	 * @param  int $sUserId	ID пользователя
	 * @return int
	 */
	public function GetCountUsersFriend($sUserId) {
		$sKey="count_user_friend_{$sUserId}";
		if (false === ($data = $this->Cache_Get($sKey))) {
			$data = $this->oMapper->GetCountUsersFriend($sUserId);
			$this->Cache_Set($data, $sKey, array("friend_change_user_{$sUserId}"), 60*60*24*2);
		}
		return $data;
	}
	/**
	 * Получает инвайт по его коду
	 *
	 * @param  string $sCode	Код инвайта
	 * @param  int    $iUsed	Флаг испольщования инвайта
	 * @return ModuleUser_EntityInvite|null
	 */
	public function GetInviteByCode($sCode,$iUsed=0) {
		return $this->oMapper->GetInviteByCode($sCode,$iUsed);
	}
	/**
	 * Добавляет новый инвайт
	 *
	 * @param ModuleUser_EntityInvite $oInvite	Объект инвайта
	 * @return ModuleUser_EntityInvite|bool
	 */
	public function AddInvite(ModuleUser_EntityInvite $oInvite) {
		if ($sId=$this->oMapper->AddInvite($oInvite)) {
			$oInvite->setId($sId);
			return $oInvite;
		}
		return false;
	}
	/**
	 * Обновляет инвайт
	 *
	 * @param ModuleUser_EntityInvite $oInvite	бъект инвайта
	 * @return bool
	 */
	public function UpdateInvite(ModuleUser_EntityInvite $oInvite) {
		//чистим зависимые кеши
		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("invate_new_to_{$oInvite->getUserToId()}","invate_new_from_{$oInvite->getUserFromId()}"));
		return $this->oMapper->UpdateInvite($oInvite);
	}
	/**
	 * Генерирует новый инвайт
	 *
	 * @param ModuleUser_EntityUser $oUser	Объект пользователя
	 * @return ModuleUser_EntityInvite|bool
	 */
	public function GenerateInvite($oUser) {
		$oInvite=Engine::GetEntity('User_Invite');
		$oInvite->setCode(func_generator(32));
		$oInvite->setDateAdd(date("Y-m-d H:i:s"));
		$oInvite->setUserFromId($oUser->getId());
		return $this->AddInvite($oInvite);
	}
	/**
	 * Получает число использованых приглашений юзером за определенную дату
	 *
	 * @param int $sUserIdFrom	ID пользователя
	 * @param string $sDate	Дата
	 * @return int
	 */
	public function GetCountInviteUsedByDate($sUserIdFrom,$sDate) {
		return $this->oMapper->GetCountInviteUsedByDate($sUserIdFrom,$sDate);
	}
	/**
	 * Получает полное число использованных приглашений юзера
	 *
	 * @param int $sUserIdFrom	ID пользователя
	 * @return int
	 */
	public function GetCountInviteUsed($sUserIdFrom) {
		return $this->oMapper->GetCountInviteUsed($sUserIdFrom);
	}
	/**
	 * Получаем число доступных приглашений для юзера
	 *
	 * @param ModuleUser_EntityUser $oUserFrom Объект пользователя
	 * @return int
	 */
	public function GetCountInviteAvailable(ModuleUser_EntityUser $oUserFrom) {
		$sDay=7;
		$iCountUsed=$this->GetCountInviteUsedByDate($oUserFrom->getId(),date("Y-m-d 00:00:00",mktime(0,0,0,date("m"),date("d")-$sDay,date("Y"))));
		$iCountAllAvailable=round($oUserFrom->getRating()+$oUserFrom->getSkill());
		$iCountAllAvailable = $iCountAllAvailable<0 ? 0 : $iCountAllAvailable;
		$iCountAvailable=$iCountAllAvailable-$iCountUsed;
		$iCountAvailable = $iCountAvailable<0 ? 0 : $iCountAvailable;
		return $iCountAvailable;
	}
	/**
	 * Получает список приглашенных юзеров
	 *
	 * @param int $sUserId	ID пользователя
	 * @return array
	 */
	public function GetUsersInvite($sUserId) {
		if (false === ($data = $this->Cache_Get("users_invite_{$sUserId}"))) {
			$data = $this->oMapper->GetUsersInvite($sUserId);
			$this->Cache_Set($data, "users_invite_{$sUserId}", array("invate_new_from_{$sUserId}"), 60*60*24*1);
		}
		$data=$this->GetUsersAdditionalData($data);
		return $data;
	}
	/**
	 * Получает юзера который пригласил
	 *
	 * @param int $sUserIdTo	ID пользователя
	 * @return ModuleUser_EntityUser|null
	 */
	public function GetUserInviteFrom($sUserIdTo) {
		if (false === ($id = $this->Cache_Get("user_invite_from_{$sUserIdTo}"))) {
			$id = $this->oMapper->GetUserInviteFrom($sUserIdTo);
			$this->Cache_Set($id, "user_invite_from_{$sUserIdTo}", array("invate_new_to_{$sUserIdTo}"), 60*60*24*1);
		}
		return $this->GetUserById($id);
	}
	/**
	 * Добавляем воспоминание(восстановление) пароля
	 *
	 * @param ModuleUser_EntityReminder $oReminder	Объект восстановления пароля
	 * @return bool
	 */
	public function AddReminder(ModuleUser_EntityReminder $oReminder) {
		return $this->oMapper->AddReminder($oReminder);
	}
	/**
	 * Сохраняем воспомнинание(восстановление) пароля
	 *
	 * @param ModuleUser_EntityReminder $oReminder	Объект восстановления пароля
	 * @return bool
	 */
	public function UpdateReminder(ModuleUser_EntityReminder $oReminder) {
		return $this->oMapper->UpdateReminder($oReminder);
	}
	/**
	 * Получаем запись восстановления пароля по коду
	 *
	 * @param string $sCode	Код восстановления пароля
	 * @return ModuleUser_EntityReminder|null
	 */
	public function GetReminderByCode($sCode) {
		return $this->oMapper->GetReminderByCode($sCode);
	}
	/**
	 * Создает аватар пользователя на основе области из изображения
	 *
	 * @param      $sFileFrom
	 * @param      $oUser
	 * @param      $aSize
	 * @param null $iCanvasWidth
	 *
	 * @return bool
	 */
	public function CreateProfileAvatar($sFileFrom,$oUser,$aSize=null,$iCanvasWidth=null) {
		$aParams=$this->Image_BuildParams('profile_avatar');
		/**
		 * Если объект изображения не создан, возвращаем ошибку
		 */
		if(!$oImage=$this->Image_OpenFrom($sFileFrom,$aParams)) {
			return $this->Image_GetLastError();
		}
		/**
		 * Если нет области, то берем центральный квадрат
		 */
		if (!$aSize) {
			$oImage->cropSquare();
		} else {
			/**
			 * Вырезаем область из исходного файла
			 */
			$oImage->cropFromSelected($aSize,$iCanvasWidth);
		}
		if ($sError=$this->Image_GetLastError()) {
			return $sError;
		}
		/**
		 * Сохраняем во временный файл для дальнейшего ресайза
		 */
		if (false===($sFileTmp=$oImage->saveTmp())) {
			return $this->Image_GetLastError();
		}
		$sPath=$this->Image_GetIdDir($oUser->getId(),'users');
		/**
		 * Удаляем старый аватар
		 */
		$this->DeleteProfileAvatar($oUser);
		/**
		 * Имя файла для сохранения
		 */
		$sFileName='avatar-user-'.$oUser->getId();
		/**
		 * Сохраняем оригинальный аватар
		 */
		if (false===($sFileResult=$oImage->saveSmart($sPath,$sFileName))) {
			return $this->Image_GetLastError();
		}
		/**
		 * Генерируем варианты с необходимыми размерами
		 */
		$this->Media_GenerateImageBySizes($sFileTmp,$sPath,$sFileName,Config::Get('module.user.avatar_size'),$aParams);
		/**
		 * Теперь можно удалить временный файл
		 */
		$this->Fs_RemoveFileLocal($sFileTmp);
		$oUser->setProfileAvatar($sFileResult);
		$this->User_Update($oUser);
		return true;
	}
	/**
	 * Загрузка фото в профиль пользователя
	 *
	 * @param $aFile
	 * @param $oUser
	 *
	 * @return bool
	 */
	public function UploadProfilePhoto($aFile,$oUser) {
		if(!is_array($aFile) || !isset($aFile['tmp_name'])) {
			return false;
		}

		$sFileTmp=Config::Get('sys.cache.dir').func_generator();
		if (!move_uploaded_file($aFile['tmp_name'],$sFileTmp)) {
			return false;
		}

		$aParams=$this->Image_BuildParams('profile_photo');
		/**
		 * Если объект изображения не создан, возвращаем ошибку
		 */
		if(!$oImage=$this->Image_Open($sFileTmp,$aParams)) {
			$this->Fs_RemoveFileLocal($sFileTmp);
			return $this->Image_GetLastError();
		}
		$sPath=$this->Image_GetIdDir($oUser->getId(),'users');
		/**
		 * Имя файла для сохранения
		 */
		$sFileName=func_generator(8);
		/**
		 * Сохраняем копию нужного размера
		 */
		$aSize=$this->Media_ParsedImageSize(Config::Get('module.user.profile_photo_size'));
		if ($aSize['crop']) {
			$oImage->cropProportion($aSize['w']/$aSize['h'],'center');
		}
		if (!$sFileResult=$oImage->resize($aSize['w'],$aSize['h'],true)->saveSmart($sPath,$sFileName)) {
			return $this->Image_GetLastError();
		}
		/**
		 * Теперь можно удалить временный файл
		 */
		$this->Fs_RemoveFileLocal($sFileTmp);
		/**
		 * Если было старое фото, то удаляем
		 */
		$this->DeleteProfilePhoto($oUser);
		$oUser->setProfileFoto($sFileResult);
		$this->User_Update($oUser);
		return true;
	}
	/**
	 * Удаляет фото пользователя
	 *
	 * @param ModuleUser_EntityUser $oUser
	 */
	public function DeleteProfilePhoto($oUser) {
		if ($oUser->getProfileFoto()) {
			$this->Image_RemoveFile($oUser->getProfileFoto());
			$oUser->setProfileFoto(null);
		}
	}
	/**
	 * Удаляет аватар пользователя
	 *
	 * @param ModuleUser_EntityUser $oUser
	 */
	public function DeleteProfileAvatar($oUser) {
		if ($oUser->getProfileAvatar()) {
			$this->Media_RemoveImageBySizes($oUser->getProfileAvatar(),Config::Get('module.user.avatar_size'));
			$oUser->setProfileAvatar(null);
		}
	}
	/**
	 * Проверяет логин на корректность
	 *
	 * @param string $sLogin	Логин пользователя
	 * @return bool
	 */
	public function CheckLogin($sLogin) {
		$charset = Config::Get('module.user.login.charset');
		$min = Config::Get('module.user.login.min_size');
		$max = Config::Get('module.user.login.max_size');
		if (preg_match('/^[' . $charset . ']{' . $min . ',' . $max . '}$/i',$sLogin)){
			return true;
		}
		return false;
	}
	/**
	 * Получить дополнительные поля профиля пользователя
	 *
	 * @param array|null $aType Типы полей, null - все типы
	 * @return array
	 */
	public function getUserFields($aType=null) {
		return $this->oMapper->getUserFields($aType);
	}
	/**
	 * Получить значения дополнительных полей профиля пользователя
	 *
	 * @param int $iUserId ID пользователя
	 * @param bool $bOnlyNoEmpty Загружать только непустые поля
	 * @param array $aType Типы полей, null - все типы
	 * @return array
	 */
	public function getUserFieldsValues($iUserId, $bOnlyNoEmpty = true, $aType=array('')) {
		return $this->oMapper->getUserFieldsValues($iUserId, $bOnlyNoEmpty, $aType);
	}
	/**
	 * Получить по имени поля его значение дял определённого пользователя
	 *
	 * @param int $iUserId	ID пользователя
	 * @param string $sName Имя поля
	 * @return string
	 */
	public function getUserFieldValueByName($iUserId, $sName) {
		return $this->oMapper->getUserFieldValueByName($iUserId, $sName);
	}
	/**
	 * Установить значения дополнительных полей профиля пользователя
	 *
	 * @param int $iUserId	ID пользователя
	 * @param array $aFields Ассоциативный массив полей id => value
	 * @param int $iCountMax Максимальное количество одинаковых полей
	 * @return bool
	 */
	public function setUserFieldsValues($iUserId, $aFields, $iCountMax=1) {
		return $this->oMapper->setUserFieldsValues($iUserId, $aFields, $iCountMax);
	}
	/**
	 * Добавить поле
	 *
	 * @param ModuleUser_EntityField $oField	Объект пользовательского поля
	 * @return bool
	 */
	public function addUserField($oField) {
		return $this->oMapper->addUserField($oField);
	}
	/**
	 * Изменить поле
	 *
	 * @param ModuleUser_EntityField $oField	Объект пользовательского поля
	 * @return bool
	 */
	public function updateUserField($oField) {
		return $this->oMapper->updateUserField($oField);
	}
	/**
	 * Удалить поле
	 *
	 * @param int $iId	ID пользовательского поля
	 * @return bool
	 */
	public function deleteUserField($iId) {
		return $this->oMapper->deleteUserField($iId);
	}
	/**
	 * Проверяет существует ли поле с таким именем
	 *
	 * @param string $sName Имя поля
	 * @param int|null $iId	ID поля
	 * @return bool
	 */
	public function userFieldExistsByName($sName, $iId = null) {
		return $this->oMapper->userFieldExistsByName($sName, $iId);
	}
	/**
	 * Проверяет существует ли поле с таким ID
	 *
	 * @param int $iId	ID поля
	 * @return bool
	 */
	public function userFieldExistsById($iId) {
		return $this->oMapper->userFieldExistsById($iId);
	}
	/**
	 * Удаляет у пользователя значения полей
	 *
	 * @param int $iUserId	ID пользователя
	 * @param array|null $aType	Список типов для удаления
	 * @return bool
	 */
	public function DeleteUserFieldValues($iUserId,$aType=null) {
		return $this->oMapper->DeleteUserFieldValues($iUserId,$aType);
	}
	/**
	 * Возвращает список заметок пользователя
	 *
	 * @param int $iUserId	ID пользователя
	 * @param int $iCurrPage	Номер страницы
	 * @param int $iPerPage	Количество элементов на страницу
	 * @return array('collection'=>array,'count'=>int)
	 */
	public function GetUserNotesByUserId($iUserId,$iCurrPage,$iPerPage) {
		$aResult=$this->oMapper->GetUserNotesByUserId($iUserId,$iCount,$iCurrPage,$iPerPage);
		/**
		 * Цепляем пользователей
		 */
		$aUserId=array();
		foreach($aResult as $oNote) {
			$aUserId[]=$oNote->getTargetUserId();
		}
		$aUsers=$this->GetUsersAdditionalData($aUserId,array());
		foreach($aResult as $oNote) {
			if (isset($aUsers[$oNote->getTargetUserId()])) {
				$oNote->setTargetUser($aUsers[$oNote->getTargetUserId()]);
			} else {
				$oNote->setTargetUser(Engine::GetEntity('User')); // пустого пользователя во избеания ошибок, т.к. пользователь всегда должен быть
			}
		}
		return array('collection'=>$aResult,'count'=>$iCount);
	}
	/**
	 * Возвращает список пользователей к которым юзер оставлял заметку
	 *
	 * @param int $iUserId	ID пользователя
	 * @param int $iCurrPage	Номер страницы
	 * @param int $iPerPage	Количество элементов на страницу
	 *
	 * @return array('collection'=>array,'count'=>int)
	 */
	public function GetUsersByNoteAndUserId($iUserId,$iCurrPage,$iPerPage) {
		$aUsersId=$this->oMapper->GetUsersByNoteAndUserId($iUserId,$iCount,$iCurrPage,$iPerPage);
		$aResult=$this->GetUsersAdditionalData($aUsersId);
		return array('collection'=>$aResult,'count'=>$iCount);
	}
	/**
	 * Возвращает количество заметок у пользователя
	 *
	 * @param int $iUserId	ID пользователя
	 * @return int
	 */
	public function GetCountUserNotesByUserId($iUserId) {
		return $this->oMapper->GetCountUserNotesByUserId($iUserId);
	}
	/**
	 * Возвращет заметку по автору и пользователю
	 *
	 * @param int $iTargetUserId	ID пользователя о ком заметка
	 * @param int $iUserId	ID пользователя автора заметки
	 * @return ModuleUser_EntityNote
	 */
	public function GetUserNote($iTargetUserId,$iUserId) {
		return $this->oMapper->GetUserNote($iTargetUserId,$iUserId);
	}
	/**
	 * Возвращает заметку по ID
	 *
	 * @param int $iId	ID заметки
	 * @return ModuleUser_EntityNote
	 */
	public function GetUserNoteById($iId) {
		return $this->oMapper->GetUserNoteById($iId);
	}
	/**
	 * Возвращает список заметок пользователя по ID целевых юзеров
	 *
	 * @param array $aUserId	Список ID целевых пользователей
	 * @param int $sUserId	ID пользователя, кто оставлял заметки
	 * @return array
	 */
	public function GetUserNotesByArray($aUserId,$sUserId) {
		if (!$aUserId) {
			return array();
		}
		if (!is_array($aUserId)) {
			$aUserId=array($aUserId);
		}
		$aUserId=array_unique($aUserId);
		$aNotes=array();
		$s=join(',',$aUserId);
		if (false === ($data = $this->Cache_Get("user_notes_{$sUserId}_id_{$s}"))) {
			$data = $this->oMapper->GetUserNotesByArrayUserId($aUserId,$sUserId);
			foreach ($data as $oNote) {
				$aNotes[$oNote->getTargetUserId()]=$oNote;
			}

			$this->Cache_Set($aNotes, "user_notes_{$sUserId}_id_{$s}", array("user_note_change_by_user_{$sUserId}"), 60*60*24*1);
			return $aNotes;
		}
		return $data;
	}
	/**
	 * Удаляет заметку по ID
	 *
	 * @param int $iId	ID заметки
	 * @return bool
	 */
	public function DeleteUserNoteById($iId) {
		if ($oNote=$this->GetUserNoteById($iId)) {
			$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("user_note_change_by_user_{$oNote->getUserId()}"));
		}
		return $this->oMapper->DeleteUserNoteById($iId);
	}
	/**
	 * Сохраняет заметку в БД, если ее нет то создает новую
	 *
	 * @param ModuleUser_EntityNote $oNote	Объект заметки
	 * @return bool|ModuleUser_EntityNote
	 */
	public function SaveNote($oNote) {
		if (!$oNote->getDateAdd()) {
			$oNote->setDateAdd(date("Y-m-d H:i:s"));
		}

		$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("user_note_change_by_user_{$oNote->getUserId()}"));
		if ($oNoteOld=$this->GetUserNote($oNote->getTargetUserId(),$oNote->getUserId()) ) {
			$oNoteOld->setText($oNote->getText());
			$this->oMapper->UpdateUserNote($oNoteOld);
			return $oNoteOld;
		} else {
			if ($iId=$this->oMapper->AddUserNote($oNote)) {
				$oNote->setId($iId);
				return $oNote;
			}
		}
		return false;
	}
	public function AddComplaint($oComplaint) {
		if (!$oComplaint->getDateAdd()) {
			$oComplaint->setDateAdd(date("Y-m-d H:i:s"));
		}

		if ($iId=$this->oMapper->AddComplaint($oComplaint)) {
			$oComplaint->setId($iId);
			return $oComplaint;
		}
		return false;
	}
	/**
	 * Возвращает список префиксов логинов пользователей (для алфавитного указателя)
	 *
	 * @param int $iPrefixLength	Длина префикса
	 * @return array
	 */
	public function GetGroupPrefixUser($iPrefixLength=1) {
		if (false === ($data = $this->Cache_Get("group_prefix_user_{$iPrefixLength}"))) {
			$data = $this->oMapper->GetGroupPrefixUser($iPrefixLength);
			$this->Cache_Set($data, "group_prefix_user_{$iPrefixLength}", array("user_new"), 60*60*24*1);
		}
		return $data;
	}
	/**
	 * Добавляет запись о смене емайла
	 *
	 * @param ModuleUser_EntityChangemail $oChangemail	Объект смены емайла
	 * @return bool|ModuleUser_EntityChangemail
	 */
	public function AddUserChangemail($oChangemail) {
		if ($sId=$this->oMapper->AddUserChangemail($oChangemail)) {
			$oChangemail->setId($sId);
			return $oChangemail;
		}
		return false;
	}
	/**
	 * Обновляет запись о смене емайла
	 *
	 * @param ModuleUser_EntityChangemail $oChangemail	Объект смены емайла
	 * @return int
	 */
	public function UpdateUserChangemail($oChangemail) {
		return $this->oMapper->UpdateUserChangemail($oChangemail);
	}
	/**
	 * Возвращает объект смены емайла по коду подтверждения
	 *
	 * @param string $sCode Код подтверждения
	 * @return ModuleUser_EntityChangemail|null
	 */
	public function GetUserChangemailByCodeFrom($sCode) {
		return $this->oMapper->GetUserChangemailByCodeFrom($sCode);
	}
	/**
	 * Возвращает объект смены емайла по коду подтверждения
	 *
	 * @param string $sCode Код подтверждения
	 * @return ModuleUser_EntityChangemail|null
	 */
	public function GetUserChangemailByCodeTo($sCode) {
		return $this->oMapper->GetUserChangemailByCodeTo($sCode);
	}
	/**
	 * Формирование процесса смены емайла в профиле пользователя
	 *
	 * @param ModuleUser_EntityUser $oUser	Объект пользователя
	 * @param string $sMailNew	Новый емайл
	 * @return bool|ModuleUser_EntityChangemail
	 */
	public function MakeUserChangemail($oUser,$sMailNew) {
		$oChangemail=Engine::GetEntity('ModuleUser_EntityChangemail');
		$oChangemail->setUserId($oUser->getId());
		$oChangemail->setDateAdd(date("Y-m-d H:i:s"));
		$oChangemail->setDateExpired(date("Y-m-d H:i:s",time()+3*24*60*60)); // 3 дня для смены емайла
		$oChangemail->setMailFrom($oUser->getMail() ? $oUser->getMail() : '');
		$oChangemail->setMailTo($sMailNew);
		$oChangemail->setCodeFrom(func_generator(32));
		$oChangemail->setCodeTo(func_generator(32));
		if ($this->AddUserChangemail($oChangemail)) {
			/**
			 * Если у пользователя раньше не было емайла, то сразу шлем подтверждение на новый емайл
			 */
			if (!$oChangemail->getMailFrom()) {
				$oChangemail->setConfirmFrom(1);
				$this->User_UpdateUserChangemail($oChangemail);
				/**
				 * Отправляем уведомление на новый емайл
				 */
				$this->Notify_Send($oChangemail->getMailTo(),
								   Config::Get('module.notify.prefix').'.user_changemail_to.tpl',
								   $this->Lang_Get('notify_subject_user_changemail'),
								   array(
									   'oUser' => $oUser,
									   'oChangemail' => $oChangemail,
								   ));

			} else {
				/**
				 * Отправляем уведомление на старый емайл
				 */
				$this->Notify_Send($oUser,
								   Config::Get('module.notify.prefix').'.user_changemail_from.tpl',
								   $this->Lang_Get('notify_subject_user_changemail'),
								   array(
									   'oUser' => $oUser,
									   'oChangemail' => $oChangemail,
								   ));
			}
			return $oChangemail;
		}
		return false;
	}
}