/**
  * Получить список избранного по списку айдишников
  *
  * @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;
 }
Exemple #2
0
 public function getTopicsIdByBounds($iTopLeftX, $iTopLeftY, $iBotRightX, $iBotRightY)
 {
     $iMinX = floor(min($iTopLeftX, $iBotRightX));
     $iMaxX = ceil(max($iTopLeftX, $iBotRightX));
     $iMinY = floor(min($iTopLeftY, $iBotRightY));
     $iMaxY = ceil(max($iTopLeftY, $iBotRightY));
     if ($iMinX == $iMaxX) {
         $iMaxX = $iMinX + 1;
     }
     if ($iMinY == $iMaxY) {
         $iMaxY = $iMinY + 1;
     }
     $aCoordinatesKeys = array();
     for ($x = $iMinX; $x < $iMaxX; $x++) {
         for ($y = $iMinY; $y < $iMaxY; $y++) {
             $aCoordinatesKeys[] = "{$x}_{$y}";
         }
     }
     $aRectNotNeedQuery = array();
     $aCacheKeys = func_build_cache_keys($aCoordinatesKeys, 'topic_coordinate_rect_');
     $aTopics = array();
     foreach ($aCacheKeys as $sValue => $sKey) {
         if (false !== ($data = $this->Cache_Get($sKey))) {
             $aTopics = array_merge($aTopics, $data);
             $aRectNotNeedQuery[$sValue] = $sValue;
         }
     }
     $aRectNeedToQuery = array();
     for ($x = $iMinX; $x < $iMaxX; $x++) {
         for ($y = $iMinY; $y < $iMaxY; $y++) {
             if (!isset($aRectNotNeedQuery["{$x}_{$y}"])) {
                 $aRectNeedToQuery[] = array('x' => $x, 'y' => $y);
             }
         }
     }
     if ($aRectNeedToQuery) {
         $aTopicZones = $this->oMapperTopic->getTopicsIdZones($aRectNeedToQuery);
         foreach ($aTopicZones as $sKey => $aTopicsZone) {
             $aTopics = array_merge($aTopics, $aTopicsZone);
             $this->Cache_Set($aTopicsZone, "topic_coordinate_rect_{$sKey}", array('topic_update', 'topic_new'), 60 * 60 * 24 * 1);
         }
     }
     return $aTopics;
 }
 public function GetQuestionByArrayId($aQuestionId, $aOrder = null)
 {
     if (!$aQuestionId) {
         return array();
     }
     if (Config::Get('sys.cache.solid')) {
         return $this->GetQuestionByArrayIdSolid($aQuestionId, $aOrder);
     }
     if (!is_array($aQuestionId)) {
         $aQuestionId = array($aQuestionId);
     }
     $aQuestionId = array_unique($aQuestionId);
     $aQuestion = $aQuestionIdNotNeedQuery = array();
     $aCacheKeys = func_build_cache_keys($aQuestionId, 'receptiondesk_question_');
     if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
         foreach ($aCacheKeys as $sValue => $sKey) {
             if (array_key_exists($sKey, $data)) {
                 if ($data[$sKey]) {
                     $aQuestion[$data[$sKey]->getId()] = $data[$sKey];
                 } else {
                     $aQuestionIdNotNeedQuery[] = $sValue;
                 }
             }
         }
     }
     $aQuestionIdNeedQuery = array_diff($aQuestionId, array_keys($aQuestion));
     $aQuestionIdNeedQuery = array_diff($aQuestionIdNeedQuery, $aQuestionIdNotNeedQuery);
     $aQuestionIdNeedStore = $aQuestionIdNeedQuery;
     if ($data = $this->oMapper->GetQuestionByArrayId($aQuestionIdNeedQuery)) {
         foreach ($data as $oQuestion) {
             $aQuestion[$oQuestion->getId()] = $oQuestion;
             $this->Cache_Set($oQuestion, "receptiondesk_question_{$oQuestion->getId()}", array(), 60 * 60 * 24 * 4);
             $aQuestionIdNeedStore = array_diff($aQuestionIdNeedStore, array($oQuestion->getId()));
         }
     }
     foreach ($aQuestionIdNeedStore as $sId) {
         $this->Cache_Set(null, "receptiondesk_question_{$sId}", array(), 60 * 60 * 24 * 4);
     }
     $aQuestion = func_array_sort_by_keys($aQuestion, $aQuestionId);
     return $aQuestion;
 }
Exemple #4
0
 /**
  * Получить список отношений друзей
  *
  * @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;
 }
Exemple #7
0
 /**
  * Получить список отношений разговор-юзер по списку айдишников
  *
  * @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;
 }