/**
* Получить список отношений друзей
*
* @param array $aUserId
* @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 $aTopicId Список ID топиков
* @param int $sUserId ID пользователя
* @return array
*/
public function GetTopicsReadByArray($aTopicId, $sUserId)
{
if (!$aTopicId) {
return array();
}
if (Config::Get('sys.cache.solid')) {
return $this->GetTopicsReadByArraySolid($aTopicId, $sUserId);
}
if (!is_array($aTopicId)) {
$aTopicId = array($aTopicId);
}
$aTopicId = array_unique($aTopicId);
$aTopicsRead = array();
$aTopicIdNotNeedQuery = array();
/**
* Делаем мульти-запрос к кешу
*/
$aCacheKeys = func_build_cache_keys($aTopicId, 'topic_read_', '_' . $sUserId);
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
/**
* проверяем что досталось из кеша
*/
foreach ($aCacheKeys as $sValue => $sKey) {
if (array_key_exists($sKey, $data)) {
if ($data[$sKey]) {
$aTopicsRead[$data[$sKey]->getTopicId()] = $data[$sKey];
} else {
$aTopicIdNotNeedQuery[] = $sValue;
}
}
}
}
/**
* Смотрим каких топиков не было в кеше и делаем запрос в БД
*/
$aTopicIdNeedQuery = array_diff($aTopicId, array_keys($aTopicsRead));
$aTopicIdNeedQuery = array_diff($aTopicIdNeedQuery, $aTopicIdNotNeedQuery);
$aTopicIdNeedStore = $aTopicIdNeedQuery;
if ($data = $this->oMapperTopic->GetTopicsReadByArray($aTopicIdNeedQuery, $sUserId)) {
foreach ($data as $oTopicRead) {
/**
* Добавляем к результату и сохраняем в кеш
*/
$aTopicsRead[$oTopicRead->getTopicId()] = $oTopicRead;
$this->Cache_Set($oTopicRead, "topic_read_{$oTopicRead->getTopicId()}_{$oTopicRead->getUserId()}", array(), 60 * 60 * 24 * 4);
$aTopicIdNeedStore = array_diff($aTopicIdNeedStore, array($oTopicRead->getTopicId()));
}
}
/**
* Сохраняем в кеш запросы не вернувшие результата
*/
foreach ($aTopicIdNeedStore as $sId) {
$this->Cache_Set(null, "topic_read_{$sId}_{$sUserId}", array(), 60 * 60 * 24 * 4);
}
/**
* Сортируем результат согласно входящему массиву
*/
$aTopicsRead = func_array_sort_by_keys($aTopicsRead, $aTopicId);
return $aTopicsRead;
}
/**
* Список комментов по ID
*
* @param array $aCommentId Список ID комментариев
* @return array
*/
public function GetCommentsByArrayId($aCommentId)
{
if (!$aCommentId) {
return array();
}
if (Config::Get('sys.cache.solid')) {
return $this->GetCommentsByArrayIdSolid($aCommentId);
}
if (!is_array($aCommentId)) {
$aCommentId = array($aCommentId);
}
$aCommentId = array_unique($aCommentId);
$aComments = array();
$aCommentIdNotNeedQuery = array();
/**
* Делаем мульти-запрос к кешу
*/
$aCacheKeys = func_build_cache_keys($aCommentId, 'comment_');
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
/**
* Проверяем что досталось из кеша
*/
foreach ($aCacheKeys as $sValue => $sKey) {
if (array_key_exists($sKey, $data)) {
if ($data[$sKey]) {
$aComments[$data[$sKey]->getId()] = $data[$sKey];
} else {
$aCommentIdNotNeedQuery[] = $sValue;
}
}
}
}
/**
* Смотрим каких комментов не было в кеше и делаем запрос в БД
*/
$aCommentIdNeedQuery = array_diff($aCommentId, array_keys($aComments));
$aCommentIdNeedQuery = array_diff($aCommentIdNeedQuery, $aCommentIdNotNeedQuery);
$aCommentIdNeedStore = $aCommentIdNeedQuery;
if ($data = $this->oMapper->GetCommentsByArrayId($aCommentIdNeedQuery)) {
foreach ($data as $oComment) {
/**
* Добавляем к результату и сохраняем в кеш
*/
$aComments[$oComment->getId()] = $oComment;
$this->Cache_Set($oComment, "comment_{$oComment->getId()}", array(), 60 * 60 * 24 * 4);
$aCommentIdNeedStore = array_diff($aCommentIdNeedStore, array($oComment->getId()));
}
}
/**
* Сохраняем в кеш запросы не вернувшие результата
*/
foreach ($aCommentIdNeedStore as $sId) {
$this->Cache_Set(null, "comment_{$sId}", array(), 60 * 60 * 24 * 4);
}
/**
* Сортируем результат согласно входящему массиву
*/
$aComments = func_array_sort_by_keys($aComments, $aCommentId);
return $aComments;
}
/**
* Получить список отношений разговор-юзер по списку айдишников
*
* @param array $aTalkId Список ID сообщений
* @param int $sUserId ID пользователя
* @return array
*/
public function GetTalkUsersByArray($aTalkId, $sUserId)
{
if (!is_array($aTalkId)) {
$aTalkId = array($aTalkId);
}
$aTalkId = array_unique($aTalkId);
$aTalkUsers = array();
$aTalkIdNotNeedQuery = array();
/**
* Делаем мульти-запрос к кешу
*/
$aCacheKeys = func_build_cache_keys($aTalkId, 'talk_user_', '_' . $sUserId);
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
/**
* проверяем что досталось из кеша
*/
foreach ($aCacheKeys as $sValue => $sKey) {
if (array_key_exists($sKey, $data)) {
if ($data[$sKey]) {
$aTalkUsers[$data[$sKey]->getTalkId()] = $data[$sKey];
} else {
$aTalkIdNotNeedQuery[] = $sValue;
}
}
}
}
/**
* Смотрим чего не было в кеше и делаем запрос в БД
*/
$aTalkIdNeedQuery = array_diff($aTalkId, array_keys($aTalkUsers));
$aTalkIdNeedQuery = array_diff($aTalkIdNeedQuery, $aTalkIdNotNeedQuery);
$aTalkIdNeedStore = $aTalkIdNeedQuery;
if ($data = $this->oMapper->GetTalkUserByArray($aTalkIdNeedQuery, $sUserId)) {
foreach ($data as $oTalkUser) {
/**
* Добавляем к результату и сохраняем в кеш
*/
$aTalkUsers[$oTalkUser->getTalkId()] = $oTalkUser;
$this->Cache_Set($oTalkUser, "talk_user_{$oTalkUser->getTalkId()}_{$oTalkUser->getUserId()}", array("update_talk_user_{$oTalkUser->getTalkId()}"), 60 * 60 * 24 * 4);
$aTalkIdNeedStore = array_diff($aTalkIdNeedStore, array($oTalkUser->getTalkId()));
}
}
/**
* Сохраняем в кеш запросы не вернувшие результата
*/
foreach ($aTalkIdNeedStore as $sId) {
$this->Cache_Set(null, "talk_user_{$sId}_{$sUserId}", array("update_talk_user_{$sId}"), 60 * 60 * 24 * 4);
}
/**
* Сортируем результат согласно входящему массиву
*/
$aTalkUsers = func_array_sort_by_keys($aTalkUsers, $aTalkId);
return $aTalkUsers;
}
/**
* Получить список избранного по списку айдишников
*
* @param array $aTargetId Список ID владельцев
* @param string $sTargetType Тип владельца
* @param int $sUserId ID пользователя
* @return array
*/
public function GetFavouritesByArray($aTargetId, $sTargetType, $sUserId)
{
if (!$aTargetId) {
return array();
}
if (Config::Get('sys.cache.solid')) {
return $this->GetFavouritesByArraySolid($aTargetId, $sTargetType, $sUserId);
}
if (!is_array($aTargetId)) {
$aTargetId = array($aTargetId);
}
$aTargetId = array_unique($aTargetId);
$aFavourite = array();
$aIdNotNeedQuery = array();
/**
* Делаем мульти-запрос к кешу
*/
$aCacheKeys = func_build_cache_keys($aTargetId, "favourite_{$sTargetType}_", '_' . $sUserId);
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
/**
* проверяем что досталось из кеша
*/
foreach ($aCacheKeys as $sValue => $sKey) {
if (array_key_exists($sKey, $data)) {
if ($data[$sKey]) {
$aFavourite[$data[$sKey]->getTargetId()] = $data[$sKey];
} else {
$aIdNotNeedQuery[] = $sValue;
}
}
}
}
/**
* Смотрим чего не было в кеше и делаем запрос в БД
*/
$aIdNeedQuery = array_diff($aTargetId, array_keys($aFavourite));
$aIdNeedQuery = array_diff($aIdNeedQuery, $aIdNotNeedQuery);
$aIdNeedStore = $aIdNeedQuery;
if ($data = $this->oMapper->GetFavouritesByArray($aIdNeedQuery, $sTargetType, $sUserId)) {
foreach ($data as $oFavourite) {
/**
* Добавляем к результату и сохраняем в кеш
*/
$aFavourite[$oFavourite->getTargetId()] = $oFavourite;
$this->Cache_Set($oFavourite, "favourite_{$oFavourite->getTargetType()}_{$oFavourite->getTargetId()}_{$sUserId}", array(), 60 * 60 * 24 * 7);
$aIdNeedStore = array_diff($aIdNeedStore, array($oFavourite->getTargetId()));
}
}
/**
* Сохраняем в кеш запросы не вернувшие результата
*/
foreach ($aIdNeedStore as $sId) {
$this->Cache_Set(null, "favourite_{$sTargetType}_{$sId}_{$sUserId}", array(), 60 * 60 * 24 * 7);
}
/**
* Сортируем результат согласно входящему массиву
*/
$aFavourite = func_array_sort_by_keys($aFavourite, $aTargetId);
return $aFavourite;
}
public function GetCategoryByArrayId($aCategoryId, $aOrder = null)
{
if (!$aCategoryId) {
return array();
}
if (Config::Get('sys.cache.solid')) {
return $this->GetCategoryByArrayIdSolid($aCategoryId, $aOrder);
}
if (!is_array($aCategoryId)) {
$aCategoryId = array($aCategoryId);
}
$aCategoryId = array_unique($aCategoryId);
$aCategory = $aCategoryIdNotNeedQuery = array();
$aCacheKeys = func_build_cache_keys($aCategoryId, 'receptiondesk_category_');
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
foreach ($aCacheKeys as $sValue => $sKey) {
if (array_key_exists($sKey, $data)) {
if ($data[$sKey]) {
$aCategory[$data[$sKey]->getId()] = $data[$sKey];
} else {
$aCategoryIdNotNeedQuery[] = $sValue;
}
}
}
}
$aCategoryIdNeedQuery = array_diff($aCategoryId, array_keys($aCategory));
$aCategoryIdNeedQuery = array_diff($aCategoryIdNeedQuery, $aCategoryIdNotNeedQuery);
$aCategoryIdNeedStore = $aCategoryIdNeedQuery;
if ($data = $this->oMapper->GetCategoryByArrayId($aCategoryIdNeedQuery)) {
foreach ($data as $oCategory) {
$aCategory[$oCategory->getId()] = $oCategory;
$this->Cache_Set($oCategory, 'receptiondesk_category_{$oCategory->getId()}', array(), 60 * 60 * 24 * 4);
$aCategoryIdNeedStore = array_diff($aCategoryIdNeedStore, array($oCategory->getId()));
}
}
foreach ($aCategoryIdNeedStore as $sId) {
$this->Cache_Set(null, 'receptiondesk_category_{$sId}', array(), 60 * 60 * 24 * 4);
}
$aCategory = func_array_sort_by_keys($aCategory, $aCategoryId);
return $aCategory;
}
