2009-05-10 10:50:39 +03:00
|
|
|
|
<?php
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/*-------------------------------------------------------
|
|
|
|
|
*
|
|
|
|
|
* 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
|
|
|
|
|
*
|
|
|
|
|
---------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Модуль для работы с топиками
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @package modules.topic
|
|
|
|
|
* @since 1.0
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
class ModuleTopic extends Module {
|
2012-06-25 20:53:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Объект маппера
|
|
|
|
|
*
|
|
|
|
|
* @var ModuleTopic_MapperTopic
|
|
|
|
|
*/
|
2008-09-21 09:36:57 +03:00
|
|
|
|
protected $oMapperTopic;
|
2012-06-25 20:53:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Объект текущего пользователя
|
|
|
|
|
*
|
|
|
|
|
* @var ModuleUser_EntityUser|null
|
|
|
|
|
*/
|
2008-09-21 09:36:57 +03:00
|
|
|
|
protected $oUserCurrent=null;
|
2012-06-25 20:53:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Список типов топика
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
2012-04-12 19:13:05 +03:00
|
|
|
|
protected $aTopicTypes=array(
|
|
|
|
|
'topic','link','question','photoset'
|
|
|
|
|
);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Инициализация
|
|
|
|
|
*
|
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function Init() {
|
2010-05-27 23:40:30 +03:00
|
|
|
|
$this->oMapperTopic=Engine::GetMapper(__CLASS__);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$this->oUserCurrent=$this->User_GetUserCurrent();
|
|
|
|
|
}
|
2012-04-12 19:13:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Возвращает список типов топика
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @return array
|
2012-04-12 19:13:05 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicTypes() {
|
|
|
|
|
return $this->aTopicTypes;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Добавляет в новый тип топика
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param string $sType Новый тип
|
|
|
|
|
* @return bool
|
2012-04-12 19:13:05 +03:00
|
|
|
|
*/
|
|
|
|
|
public function AddTopicType($sType) {
|
|
|
|
|
if (!in_array($sType,$this->aTopicTypes)) {
|
|
|
|
|
$this->aTopicTypes[]=$sType;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Проверяет разрешен ли данный тип топика
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param string $sType Тип
|
2012-04-12 19:13:05 +03:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function IsAllowTopicType($sType) {
|
|
|
|
|
return in_array($sType,$this->aTopicTypes);
|
|
|
|
|
}
|
2009-05-23 14:05:41 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает дополнительные данные(объекты) для топиков по их ID
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param array|null $aAllowData Список типов дополнительных данных, которые нужно подключать к топикам
|
|
|
|
|
* @return array
|
2009-05-23 14:05:41 +03:00
|
|
|
|
*/
|
2012-04-11 04:44:33 +03:00
|
|
|
|
public function GetTopicsAdditionalData($aTopicId,$aAllowData=null) {
|
|
|
|
|
if (is_null($aAllowData)) {
|
|
|
|
|
$aAllowData=array('user'=>array(),'blog'=>array('owner'=>array(),'relation_user'),'vote','favourite','comment_new');
|
|
|
|
|
}
|
2009-05-23 14:05:41 +03:00
|
|
|
|
func_array_simpleflip($aAllowData);
|
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получаем "голые" топики
|
|
|
|
|
*/
|
|
|
|
|
$aTopics=$this->GetTopicsByArrayId($aTopicId);
|
|
|
|
|
/**
|
|
|
|
|
* Формируем ID дополнительных данных, которые нужно получить
|
|
|
|
|
*/
|
|
|
|
|
$aUserId=array();
|
2009-06-28 17:04:44 +03:00
|
|
|
|
$aBlogId=array();
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$aTopicIdQuestion=array();
|
|
|
|
|
$aPhotoMainId=array();
|
2009-05-23 14:05:41 +03:00
|
|
|
|
foreach ($aTopics as $oTopic) {
|
|
|
|
|
if (isset($aAllowData['user'])) {
|
|
|
|
|
$aUserId[]=$oTopic->getUserId();
|
|
|
|
|
}
|
|
|
|
|
if (isset($aAllowData['blog'])) {
|
|
|
|
|
$aBlogId[]=$oTopic->getBlogId();
|
2009-06-28 17:04:44 +03:00
|
|
|
|
}
|
2011-07-24 00:55:56 +03:00
|
|
|
|
if ($oTopic->getType()=='question') {
|
2009-06-28 17:04:44 +03:00
|
|
|
|
$aTopicIdQuestion[]=$oTopic->getId();
|
|
|
|
|
}
|
2011-07-24 00:55:56 +03:00
|
|
|
|
if ($oTopic->getType()=='photoset' and $oTopic->getPhotosetMainPhotoId()) {
|
|
|
|
|
$aPhotoMainId[]=$oTopic->getPhotosetMainPhotoId();
|
|
|
|
|
}
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получаем дополнительные данные
|
|
|
|
|
*/
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$aTopicsVote=array();
|
|
|
|
|
$aFavouriteTopics=array();
|
|
|
|
|
$aTopicsQuestionVote=array();
|
2009-06-05 16:57:11 +03:00
|
|
|
|
$aTopicsRead=array();
|
2009-05-23 14:05:41 +03:00
|
|
|
|
$aUsers=isset($aAllowData['user']) && is_array($aAllowData['user']) ? $this->User_GetUsersAdditionalData($aUserId,$aAllowData['user']) : $this->User_GetUsersAdditionalData($aUserId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aBlogs=isset($aAllowData['blog']) && is_array($aAllowData['blog']) ? $this->Blog_GetBlogsAdditionalData($aBlogId,$aAllowData['blog']) : $this->Blog_GetBlogsAdditionalData($aBlogId);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (isset($aAllowData['vote']) and $this->oUserCurrent) {
|
2009-06-28 17:04:44 +03:00
|
|
|
|
$aTopicsVote=$this->Vote_GetVoteByArray($aTopicId,'topic',$this->oUserCurrent->getId());
|
|
|
|
|
$aTopicsQuestionVote=$this->GetTopicsQuestionVoteByArray($aTopicIdQuestion,$this->oUserCurrent->getId());
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (isset($aAllowData['favourite']) and $this->oUserCurrent) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFavouriteTopics=$this->GetFavouriteTopicsByArray($aTopicId,$this->oUserCurrent->getId());
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (isset($aAllowData['comment_new']) and $this->oUserCurrent) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aTopicsRead=$this->GetTopicsReadByArray($aTopicId,$this->oUserCurrent->getId());
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$aPhotosetMainPhotos=$this->GetTopicPhotosByArrayId($aPhotoMainId);
|
2009-05-23 14:05:41 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем данные к результату - списку топиков
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aTopics as $oTopic) {
|
|
|
|
|
if (isset($aUsers[$oTopic->getUserId()])) {
|
|
|
|
|
$oTopic->setUser($aUsers[$oTopic->getUserId()]);
|
|
|
|
|
} else {
|
2010-05-27 18:16:20 +03:00
|
|
|
|
$oTopic->setUser(null); // или $oTopic->setUser(new ModuleUser_EntityUser());
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
|
|
|
|
if (isset($aBlogs[$oTopic->getBlogId()])) {
|
|
|
|
|
$oTopic->setBlog($aBlogs[$oTopic->getBlogId()]);
|
|
|
|
|
} else {
|
2010-05-27 18:16:20 +03:00
|
|
|
|
$oTopic->setBlog(null); // или $oTopic->setBlog(new ModuleBlog_EntityBlog());
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if (isset($aTopicsVote[$oTopic->getId()])) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$oTopic->setVote($aTopicsVote[$oTopic->getId()]);
|
2009-05-29 18:32:37 +03:00
|
|
|
|
} else {
|
2009-06-28 01:35:26 +03:00
|
|
|
|
$oTopic->setVote(null);
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
if (isset($aFavouriteTopics[$oTopic->getId()])) {
|
2012-03-27 13:45:52 +03:00
|
|
|
|
$oTopic->setFavourite($aFavouriteTopics[$oTopic->getId()]);
|
2009-05-29 18:32:37 +03:00
|
|
|
|
} else {
|
2012-03-27 13:45:52 +03:00
|
|
|
|
$oTopic->setFavourite(null);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if (isset($aTopicsQuestionVote[$oTopic->getId()])) {
|
|
|
|
|
$oTopic->setUserQuestionIsVote(true);
|
|
|
|
|
} else {
|
|
|
|
|
$oTopic->setUserQuestionIsVote(false);
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (isset($aTopicsRead[$oTopic->getId()])) {
|
2009-06-05 16:57:11 +03:00
|
|
|
|
$oTopic->setCountCommentNew($oTopic->getCountComment()-$aTopicsRead[$oTopic->getId()]->getCommentCountLast());
|
|
|
|
|
$oTopic->setDateRead($aTopicsRead[$oTopic->getId()]->getDateRead());
|
2009-05-29 18:32:37 +03:00
|
|
|
|
} else {
|
|
|
|
|
$oTopic->setCountCommentNew(0);
|
2009-06-05 16:57:11 +03:00
|
|
|
|
$oTopic->setDateRead(date("Y-m-d H:i:s"));
|
2011-07-24 00:55:56 +03:00
|
|
|
|
}
|
|
|
|
|
if (isset($aPhotosetMainPhotos[$oTopic->getPhotosetMainPhotoId()])) {
|
|
|
|
|
$oTopic->setPhotosetMainPhoto($aPhotosetMainPhotos[$oTopic->getPhotosetMainPhotoId()]);
|
|
|
|
|
} else {
|
|
|
|
|
$oTopic->setPhotosetMainPhoto(null);
|
|
|
|
|
}
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
|
|
|
|
return $aTopics;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляет топик
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleTopic_EntityTopic $oTopic Объект топика
|
|
|
|
|
* @return ModuleTopic_EntityTopic|bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2010-05-27 18:16:20 +03:00
|
|
|
|
public function AddTopic(ModuleTopic_EntityTopic $oTopic) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
if ($sId=$this->oMapperTopic->AddTopic($oTopic)) {
|
|
|
|
|
$oTopic->setId($sId);
|
2012-04-14 15:57:07 +03:00
|
|
|
|
if ($oTopic->getPublish() and $oTopic->getTags()) {
|
2008-11-17 23:11:37 +02:00
|
|
|
|
$aTags=explode(',',$oTopic->getTags());
|
|
|
|
|
foreach ($aTags as $sTag) {
|
2009-09-08 15:02:51 +03:00
|
|
|
|
$oTag=Engine::GetEntity('Topic_TopicTag');
|
2008-11-17 23:11:37 +02:00
|
|
|
|
$oTag->setTopicId($oTopic->getId());
|
|
|
|
|
$oTag->setUserId($oTopic->getUserId());
|
|
|
|
|
$oTag->setBlogId($oTopic->getBlogId());
|
|
|
|
|
$oTag->setText($sTag);
|
2012-04-23 07:51:16 +03:00
|
|
|
|
$this->AddTopicTag($oTag);
|
2008-11-17 23:11:37 +02:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
//чистим зависимые кеши
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('topic_new',"topic_update_user_{$oTopic->getUserId()}","topic_new_blog_{$oTopic->getBlogId()}"));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $oTopic;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-04-23 07:51:16 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавление тега к топику
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleTopic_EntityTopicTag $oTopicTag Объект тега топика
|
|
|
|
|
* @return int
|
2012-04-23 07:51:16 +03:00
|
|
|
|
*/
|
|
|
|
|
public function AddTopicTag(ModuleTopic_EntityTopicTag $oTopicTag) {
|
|
|
|
|
return $this->oMapperTopic->AddTopicTag($oTopicTag);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Удаляет теги у топика
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sTopicId ID топика
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function DeleteTopicTagsByTopicId($sTopicId) {
|
|
|
|
|
return $this->oMapperTopic->DeleteTopicTagsByTopicId($sTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-11-22 19:30:25 +02:00
|
|
|
|
/**
|
|
|
|
|
* Удаляет топик.
|
|
|
|
|
* Если тип таблиц в БД InnoDB, то удалятся всё связи по топику(комменты,голосования,избранное)
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleTopic_EntityTopic|int $oTopicId Объект топика или ID
|
|
|
|
|
* @return bool
|
2008-11-22 19:30:25 +02:00
|
|
|
|
*/
|
2010-03-06 17:48:44 +02:00
|
|
|
|
public function DeleteTopic($oTopicId) {
|
2010-05-27 18:16:20 +03:00
|
|
|
|
if ($oTopicId instanceof ModuleTopic_EntityTopic) {
|
2010-03-06 17:48:44 +02:00
|
|
|
|
$sTopicId=$oTopicId->getId();
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_update_user_{$oTopicId->getUserId()}"));
|
|
|
|
|
} else {
|
|
|
|
|
$sTopicId=$oTopicId;
|
|
|
|
|
}
|
2009-10-25 22:01:05 +02:00
|
|
|
|
/**
|
|
|
|
|
* Чистим зависимые кеши
|
2009-10-27 19:22:11 +02:00
|
|
|
|
*/
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('topic_update'));
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Delete("topic_{$sTopicId}");
|
2009-10-25 22:01:05 +02:00
|
|
|
|
/**
|
|
|
|
|
* Если топик успешно удален, удаляем связанные данные
|
|
|
|
|
*/
|
2009-11-25 16:06:02 +02:00
|
|
|
|
if($bResult=$this->oMapperTopic->DeleteTopic($sTopicId)){
|
2009-10-27 19:22:11 +02:00
|
|
|
|
return $this->DeleteTopicAdditionalData($sTopicId);
|
|
|
|
|
}
|
2009-11-25 16:06:02 +02:00
|
|
|
|
|
2009-10-25 22:01:05 +02:00
|
|
|
|
return false;
|
2008-11-22 19:30:25 +02:00
|
|
|
|
}
|
2009-10-27 19:22:11 +02:00
|
|
|
|
/**
|
|
|
|
|
* Удаляет свзяанные с топика данные
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iTopicId ID топика
|
2009-10-27 19:22:11 +02:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function DeleteTopicAdditionalData($iTopicId) {
|
2009-11-25 16:06:02 +02:00
|
|
|
|
/**
|
|
|
|
|
* Чистим зависимые кеши
|
|
|
|
|
*/
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('topic_update'));
|
|
|
|
|
$this->Cache_Delete("topic_{$iTopicId}");
|
2011-08-23 17:29:03 +03:00
|
|
|
|
/**
|
|
|
|
|
* Удаляем контент топика
|
|
|
|
|
*/
|
|
|
|
|
$this->DeleteTopicContentByTopicId($iTopicId);
|
2009-10-27 19:22:11 +02:00
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Удаляем комментарии к топику.
|
2009-10-27 19:22:11 +02:00
|
|
|
|
* При удалении комментариев они удаляются из избранного,прямого эфира и голоса за них
|
|
|
|
|
*/
|
|
|
|
|
$this->Comment_DeleteCommentByTargetId($iTopicId,'topic');
|
|
|
|
|
/**
|
|
|
|
|
* Удаляем топик из избранного
|
|
|
|
|
*/
|
|
|
|
|
$this->DeleteFavouriteTopicByArrayId($iTopicId);
|
|
|
|
|
/**
|
|
|
|
|
* Удаляем топик из прочитанного
|
|
|
|
|
*/
|
|
|
|
|
$this->DeleteTopicReadByArrayId($iTopicId);
|
|
|
|
|
/**
|
|
|
|
|
* Удаляем голосование к топику
|
|
|
|
|
*/
|
2010-07-07 17:39:36 +03:00
|
|
|
|
$this->Vote_DeleteVoteByTarget($iTopicId,'topic');
|
|
|
|
|
/**
|
|
|
|
|
* Удаляем теги
|
|
|
|
|
*/
|
|
|
|
|
$this->DeleteTopicTagsByTopicId($iTopicId);
|
2011-07-24 00:55:56 +03:00
|
|
|
|
/**
|
|
|
|
|
* Удаляем фото у топика фотосета
|
|
|
|
|
*/
|
|
|
|
|
if ($aPhotos=$this->getPhotosByTopicId($iTopicId)) {
|
|
|
|
|
foreach ($aPhotos as $oPhoto) {
|
|
|
|
|
$this->deleteTopicPhoto($oPhoto);
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-27 19:22:11 +02:00
|
|
|
|
return true;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Обновляет топик
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleTopic_EntityTopic $oTopic Объект топика
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2010-05-27 18:16:20 +03:00
|
|
|
|
public function UpdateTopic(ModuleTopic_EntityTopic $oTopic) {
|
2009-06-24 00:35:20 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем топик ДО изменения
|
|
|
|
|
*/
|
|
|
|
|
$oTopicOld=$this->GetTopicById($oTopic->getId());
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$oTopic->setDateEdit(date("Y-m-d H:i:s"));
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if ($this->oMapperTopic->UpdateTopic($oTopic)) {
|
2008-10-10 20:23:00 +03:00
|
|
|
|
/**
|
2009-12-04 18:11:07 +02:00
|
|
|
|
* Если топик изменил видимость(publish) или локацию (BlogId) или список тегов
|
2008-10-10 20:23:00 +03:00
|
|
|
|
*/
|
2009-12-04 18:11:07 +02:00
|
|
|
|
if (($oTopic->getPublish()!=$oTopicOld->getPublish()) || ($oTopic->getBlogId()!=$oTopicOld->getBlogId()) || ($oTopic->getTags()!=$oTopicOld->getTags())) {
|
2009-06-24 00:35:20 +03:00
|
|
|
|
/**
|
|
|
|
|
* Обновляем теги
|
|
|
|
|
*/
|
|
|
|
|
$this->DeleteTopicTagsByTopicId($oTopic->getId());
|
2012-04-14 15:57:07 +03:00
|
|
|
|
if ($oTopic->getPublish() and $oTopic->getTags()) {
|
|
|
|
|
$aTags=explode(',',$oTopic->getTags());
|
2009-06-24 00:35:20 +03:00
|
|
|
|
foreach ($aTags as $sTag) {
|
2009-09-08 15:02:51 +03:00
|
|
|
|
$oTag=Engine::GetEntity('Topic_TopicTag');
|
2009-06-24 00:35:20 +03:00
|
|
|
|
$oTag->setTopicId($oTopic->getId());
|
|
|
|
|
$oTag->setUserId($oTopic->getUserId());
|
|
|
|
|
$oTag->setBlogId($oTopic->getBlogId());
|
|
|
|
|
$oTag->setText($sTag);
|
2012-04-23 07:51:16 +03:00
|
|
|
|
$this->AddTopicTag($oTag);
|
2009-06-24 00:35:20 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-09-26 05:04:47 +03:00
|
|
|
|
}
|
|
|
|
|
if ($oTopic->getPublish()!=$oTopicOld->getPublish()) {
|
2009-06-24 00:35:20 +03:00
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Обновляем избранное
|
|
|
|
|
*/
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->SetFavouriteTopicPublish($oTopic->getId(),$oTopic->getPublish());
|
2009-06-24 00:35:20 +03:00
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Удаляем комментарий топика из прямого эфира
|
|
|
|
|
*/
|
2009-06-24 00:35:20 +03:00
|
|
|
|
if ($oTopic->getPublish()==0) {
|
|
|
|
|
$this->Comment_DeleteCommentOnlineByTargetId($oTopic->getId(),'topic');
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Изменяем видимость комментов
|
|
|
|
|
*/
|
|
|
|
|
$this->Comment_SetCommentsPublish($oTopic->getId(),'topic',$oTopic->getPublish());
|
2008-10-10 20:23:00 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
//чистим зависимые кеши
|
2012-06-10 13:43:34 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('topic_update',"topic_update_user_{$oTopic->getUserId()}"));
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Delete("topic_{$oTopic->getId()}");
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2011-08-23 17:29:03 +03:00
|
|
|
|
/**
|
|
|
|
|
* Удаление контента топика по его номеру
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iTopicId ID топика
|
|
|
|
|
* @return bool
|
2011-08-23 17:29:03 +03:00
|
|
|
|
*/
|
|
|
|
|
public function DeleteTopicContentByTopicId($iTopicId) {
|
|
|
|
|
return $this->oMapperTopic->DeleteTopicContentByTopicId($iTopicId);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
2009-05-17 20:35:47 +03:00
|
|
|
|
* Получить топик по айдишнику
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sId ID топика
|
|
|
|
|
* @return ModuleTopic_EntityTopic|null
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function GetTopicById($sId) {
|
2012-07-08 11:50:36 +03:00
|
|
|
|
if (!is_numeric($sId)) {
|
|
|
|
|
return null;
|
|
|
|
|
}
|
2009-05-24 14:02:34 +03:00
|
|
|
|
$aTopics=$this->GetTopicsAdditionalData($sId);
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if (isset($aTopics[$sId])) {
|
|
|
|
|
return $aTopics[$sId];
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
|
|
|
|
return null;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-11-12 22:04:21 +02:00
|
|
|
|
/**
|
|
|
|
|
* Получить список топиков по списку айдишников
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @return array
|
2008-11-12 22:04:21 +02:00
|
|
|
|
*/
|
2009-06-04 17:42:43 +03:00
|
|
|
|
public function GetTopicsByArrayId($aTopicId) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
if (!$aTopicId) {
|
|
|
|
|
return array();
|
|
|
|
|
}
|
2009-10-10 22:13:14 +03:00
|
|
|
|
if (Config::Get('sys.cache.solid')) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
return $this->GetTopicsByArrayIdSolid($aTopicId);
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2009-05-23 14:05:41 +03:00
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$aTopicId=array_unique($aTopicId);
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aTopics=array();
|
|
|
|
|
$aTopicIdNotNeedQuery=array();
|
2009-05-23 14:05:41 +03:00
|
|
|
|
/**
|
|
|
|
|
* Делаем мульти-запрос к кешу
|
|
|
|
|
*/
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aCacheKeys=func_build_cache_keys($aTopicId,'topic_');
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
|
2009-05-23 14:05:41 +03:00
|
|
|
|
/**
|
|
|
|
|
* проверяем что досталось из кеша
|
2009-06-04 17:42:43 +03:00
|
|
|
|
*/
|
|
|
|
|
foreach ($aCacheKeys as $sValue => $sKey ) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (array_key_exists($sKey,$data)) {
|
2009-06-04 17:42:43 +03:00
|
|
|
|
if ($data[$sKey]) {
|
|
|
|
|
$aTopics[$data[$sKey]->getId()]=$data[$sKey];
|
|
|
|
|
} else {
|
|
|
|
|
$aTopicIdNotNeedQuery[]=$sValue;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
2009-06-04 17:42:43 +03:00
|
|
|
|
}
|
2009-05-23 14:05:41 +03:00
|
|
|
|
/**
|
|
|
|
|
* Смотрим каких топиков не было в кеше и делаем запрос в БД
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
|
|
|
|
$aTopicIdNeedQuery=array_diff($aTopicId,array_keys($aTopics));
|
|
|
|
|
$aTopicIdNeedQuery=array_diff($aTopicIdNeedQuery,$aTopicIdNotNeedQuery);
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aTopicIdNeedStore=$aTopicIdNeedQuery;
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if ($data = $this->oMapperTopic->GetTopicsByArrayId($aTopicIdNeedQuery)) {
|
2009-05-23 14:05:41 +03:00
|
|
|
|
foreach ($data as $oTopic) {
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем к результату и сохраняем в кеш
|
|
|
|
|
*/
|
|
|
|
|
$aTopics[$oTopic->getId()]=$oTopic;
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Set($oTopic, "topic_{$oTopic->getId()}", array(), 60*60*24*4);
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aTopicIdNeedStore=array_diff($aTopicIdNeedStore,array($oTopic->getId()));
|
2009-05-23 14:05:41 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-04 17:42:43 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сохраняем в кеш запросы не вернувшие результата
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aTopicIdNeedStore as $sId) {
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Set(null, "topic_{$sId}", array(), 60*60*24*4);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-06-23 20:06:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сортируем результат согласно входящему массиву
|
|
|
|
|
*/
|
|
|
|
|
$aTopics=func_array_sort_by_keys($aTopics,$aTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $aTopics;
|
2008-11-12 22:04:21 +02:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить список топиков по списку айдишников, но используя единый кеш
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @return array
|
2009-08-08 12:33:32 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsByArrayIdSolid($aTopicId) {
|
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aTopicId=array_unique($aTopicId);
|
|
|
|
|
$aTopics=array();
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$s=join(',',$aTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_id_{$s}"))) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetTopicsByArrayId($aTopicId);
|
|
|
|
|
foreach ($data as $oTopic) {
|
|
|
|
|
$aTopics[$oTopic->getId()]=$oTopic;
|
|
|
|
|
}
|
|
|
|
|
$this->Cache_Set($aTopics, "topic_id_{$s}", array("topic_update"), 60*60*24*1);
|
|
|
|
|
return $aTopics;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
return $data;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список топиков из избранного
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @param int $iCurrPage Номер текущей страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @return array('collection'=>array,'count'=>int)
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function GetTopicsFavouriteByUserId($sUserId,$iCurrPage,$iPerPage) {
|
|
|
|
|
$aCloseTopics =array();
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем список идентификаторов избранных записей
|
|
|
|
|
*/
|
2009-09-19 13:53:33 +03:00
|
|
|
|
$data = ($this->oUserCurrent && $sUserId==$this->oUserCurrent->getId())
|
2009-10-15 02:34:03 +03:00
|
|
|
|
? $this->Favourite_GetFavouritesByUserId($sUserId,'topic',$iCurrPage,$iPerPage,$aCloseTopics)
|
2009-09-19 13:53:33 +03:00
|
|
|
|
: $this->Favourite_GetFavouriteOpenTopicsByUserId($sUserId,$iCurrPage,$iPerPage);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем записи по переданому массиву айдишников
|
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$data['collection']=$this->GetTopicsAdditionalData($data['collection']);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Возвращает число топиков в избранном
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sUserId ID пользователя
|
2009-08-22 00:01:09 +03:00
|
|
|
|
* @return int
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetCountTopicsFavouriteByUserId($sUserId) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aCloseTopics = array();
|
|
|
|
|
return ($this->oUserCurrent && $sUserId==$this->oUserCurrent->getId())
|
2009-09-19 13:53:33 +03:00
|
|
|
|
? $this->Favourite_GetCountFavouritesByUserId($sUserId,'topic',$aCloseTopics)
|
2012-04-15 13:10:59 +03:00
|
|
|
|
: $this->Favourite_GetCountFavouriteOpenTopicsByUserId($sUserId);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-06-27 18:05:17 +03:00
|
|
|
|
/**
|
|
|
|
|
* Список топиков по фильтру
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aFilter Фильтр
|
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param array|null $aAllowData Список типов данных для подгрузки в топики
|
|
|
|
|
* @return array('collection'=>array,'count'=>int)
|
2009-06-27 18:05:17 +03:00
|
|
|
|
*/
|
2012-07-09 08:47:42 +03:00
|
|
|
|
public function GetTopicsByFilter($aFilter,$iPage=1,$iPerPage=10,$aAllowData=null) {
|
|
|
|
|
if (!is_numeric($iPage) or $iPage<=0) {
|
|
|
|
|
$iPage=1;
|
|
|
|
|
}
|
2009-05-17 20:35:47 +03:00
|
|
|
|
$s=serialize($aFilter);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_filter_{$s}_{$iPage}_{$iPerPage}"))) {
|
2012-07-09 08:02:26 +03:00
|
|
|
|
$data = array(
|
|
|
|
|
'collection'=>$this->oMapperTopic->GetTopics($aFilter,$iCount,$iPage,$iPerPage),
|
|
|
|
|
'count'=>$iCount
|
|
|
|
|
);
|
2009-05-24 14:02:34 +03:00
|
|
|
|
$this->Cache_Set($data, "topic_filter_{$s}_{$iPage}_{$iPerPage}", array('topic_update','topic_new'), 60*60*24*3);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-10-27 19:22:11 +02:00
|
|
|
|
$data['collection']=$this->GetTopicsAdditionalData($data['collection'],$aAllowData);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-06-27 18:05:17 +03:00
|
|
|
|
/**
|
|
|
|
|
* Количество топиков по фильтру
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aFilter Фильтр
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* @return int
|
2009-06-27 18:05:17 +03:00
|
|
|
|
*/
|
2010-02-06 23:41:57 +02:00
|
|
|
|
public function GetCountTopicsByFilter($aFilter) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$s=serialize($aFilter);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_count_{$s}"))) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetCountTopics($aFilter);
|
2009-05-24 14:02:34 +03:00
|
|
|
|
$this->Cache_Set($data, "topic_count_{$s}", array('topic_update','topic_new'), 60*60*24*1);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
return $data;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
/**
|
|
|
|
|
* Количество черновиков у пользователя
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iUserId ID пользователя
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* @return int
|
|
|
|
|
*/
|
|
|
|
|
public function GetCountDraftTopicsByUserId($iUserId) {
|
|
|
|
|
return $this->GetCountTopicsByFilter(array(
|
|
|
|
|
'user_id' => $iUserId,
|
|
|
|
|
'topic_publish' => 0
|
|
|
|
|
));
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список хороших топиков для вывода на главную страницу(из всех блогов, как коллективных так и персональных)
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* @param bool $bAddAccessible Указывает на необходимость добавить в выдачу топики,
|
2009-10-15 18:52:53 +03:00
|
|
|
|
* из блогов доступных пользователю. При указании false,
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* в выдачу будут переданы только топики из общедоступных блогов.
|
2009-10-15 18:52:53 +03:00
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-10-15 18:52:53 +03:00
|
|
|
|
public function GetTopicsGood($iPage,$iPerPage,$bAddAccessible=true) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
2009-09-18 23:36:07 +03:00
|
|
|
|
'open'
|
2008-09-21 09:36:57 +03:00
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
'topic_rating' => array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.index_good'),
|
2008-09-21 09:36:57 +03:00
|
|
|
|
'type' => 'top',
|
2008-10-11 00:02:31 +03:00
|
|
|
|
'publish_index' => 1,
|
2009-09-18 23:36:07 +03:00
|
|
|
|
)
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
2009-10-15 18:52:53 +03:00
|
|
|
|
if($this->oUserCurrent && $bAddAccessible) {
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
2009-09-18 23:36:07 +03:00
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-06-16 15:02:20 +03:00
|
|
|
|
* Получает список новых топиков, ограничение новизны по дате из конфига
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* @param bool $bAddAccessible Указывает на необходимость добавить в выдачу топики,
|
2009-10-15 18:52:53 +03:00
|
|
|
|
* из блогов доступных пользователю. При указании false,
|
|
|
|
|
* в выдачу будут переданы только топики из общедоступных блогов.
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-10-15 18:52:53 +03:00
|
|
|
|
public function GetTopicsNew($iPage,$iPerPage,$bAddAccessible=true) {
|
2009-08-20 10:43:06 +03:00
|
|
|
|
$sDate=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
'open',
|
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
'topic_new' => $sDate,
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
2009-10-15 18:52:53 +03:00
|
|
|
|
if($this->oUserCurrent && $bAddAccessible) {
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
2010-01-09 18:45:09 +02:00
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
|
|
|
|
}
|
2012-06-16 15:02:20 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список ВСЕХ новых топиков
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
2012-06-16 15:02:20 +03:00
|
|
|
|
* @param bool $bAddAccessible Указывает на необходимость добавить в выдачу топики,
|
|
|
|
|
* из блогов доступных пользователю. При указании false,
|
|
|
|
|
* в выдачу будут переданы только топики из общедоступных блогов.
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsNewAll($iPage,$iPerPage,$bAddAccessible=true) {
|
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
'open',
|
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
);
|
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
|
|
|
|
if($this->oUserCurrent && $bAddAccessible) {
|
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
|
|
|
|
}
|
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
|
|
|
|
}
|
2012-03-31 20:10:02 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список ВСЕХ обсуждаемых топиков
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param int|string $sPeriod Период в виде секунд или конкретной даты
|
2012-03-31 20:10:02 +03:00
|
|
|
|
* @param bool $bAddAccessible Указывает на необходимость добавить в выдачу топики,
|
|
|
|
|
* из блогов доступных пользователю. При указании false,
|
|
|
|
|
* в выдачу будут переданы только топики из общедоступных блогов.
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsDiscussed($iPage,$iPerPage,$sPeriod=null,$bAddAccessible=true) {
|
|
|
|
|
if (is_numeric($sPeriod)) {
|
|
|
|
|
// количество последних секунд
|
|
|
|
|
$sPeriod=date("Y-m-d H:00:00",time()-$sPeriod);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
'open',
|
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1
|
|
|
|
|
);
|
|
|
|
|
if ($sPeriod) {
|
|
|
|
|
$aFilter['topic_date_more'] = $sPeriod;
|
|
|
|
|
}
|
2012-06-27 10:10:13 +03:00
|
|
|
|
$aFilter['order']=' t.topic_count_comment desc, t.topic_id desc ';
|
2012-03-31 20:10:02 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
|
|
|
|
if($this->oUserCurrent && $bAddAccessible) {
|
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
|
|
|
|
}
|
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает список ВСЕХ рейтинговых топиков
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param int|string $sPeriod Период в виде секунд или конкретной даты
|
2012-03-31 20:10:02 +03:00
|
|
|
|
* @param bool $bAddAccessible Указывает на необходимость добавить в выдачу топики,
|
|
|
|
|
* из блогов доступных пользователю. При указании false,
|
|
|
|
|
* в выдачу будут переданы только топики из общедоступных блогов.
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsTop($iPage,$iPerPage,$sPeriod=null,$bAddAccessible=true) {
|
|
|
|
|
if (is_numeric($sPeriod)) {
|
|
|
|
|
// количество последних секунд
|
|
|
|
|
$sPeriod=date("Y-m-d H:00:00",time()-$sPeriod);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
'open',
|
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1
|
|
|
|
|
);
|
|
|
|
|
if ($sPeriod) {
|
|
|
|
|
$aFilter['topic_date_more'] = $sPeriod;
|
|
|
|
|
}
|
|
|
|
|
$aFilter['order']=array('t.topic_rating desc','t.topic_id desc');
|
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
|
|
|
|
if($this->oUserCurrent && $bAddAccessible) {
|
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
|
|
|
|
}
|
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
|
|
|
|
}
|
2009-01-10 21:23:36 +02:00
|
|
|
|
/**
|
|
|
|
|
* Получает заданое число последних топиков
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iCount Количество
|
|
|
|
|
* @return array
|
2009-01-10 21:23:36 +02:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function GetTopicsLast($iCount) {
|
2009-01-10 21:23:36 +02:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
'open',
|
|
|
|
|
),
|
2012-04-15 13:10:59 +03:00
|
|
|
|
'topic_publish' => 1,
|
2009-09-18 23:36:07 +03:00
|
|
|
|
);
|
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
|
|
|
|
if($this->oUserCurrent) {
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
2010-01-09 18:45:09 +02:00
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-01-10 21:23:36 +02:00
|
|
|
|
$aReturn=$this->GetTopicsByFilter($aFilter,1,$iCount);
|
|
|
|
|
if (isset($aReturn['collection'])) {
|
|
|
|
|
return $aReturn['collection'];
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
2009-06-13 12:24:09 +03:00
|
|
|
|
* список топиков из персональных блогов
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param string $sShowType Тип выборки топиков
|
|
|
|
|
* @param string|int $sPeriod Период в виде секунд или конкретной даты
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-03-31 21:33:36 +03:00
|
|
|
|
public function GetTopicsPersonal($iPage,$iPerPage,$sShowType='good',$sPeriod=null) {
|
|
|
|
|
if (is_numeric($sPeriod)) {
|
|
|
|
|
// количество последних секунд
|
|
|
|
|
$sPeriod=date("Y-m-d H:00:00",time()-$sPeriod);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
),
|
2012-04-15 13:10:59 +03:00
|
|
|
|
'topic_publish' => 1,
|
2009-06-13 12:24:09 +03:00
|
|
|
|
);
|
2012-03-31 21:33:36 +03:00
|
|
|
|
if ($sPeriod) {
|
|
|
|
|
$aFilter['topic_date_more'] = $sPeriod;
|
|
|
|
|
}
|
2009-06-13 12:24:09 +03:00
|
|
|
|
switch ($sShowType) {
|
|
|
|
|
case 'good':
|
|
|
|
|
$aFilter['topic_rating']=array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.personal_good'),
|
2009-06-13 12:24:09 +03:00
|
|
|
|
'type' => 'top',
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
|
|
|
|
break;
|
2009-06-13 12:24:09 +03:00
|
|
|
|
case 'bad':
|
|
|
|
|
$aFilter['topic_rating']=array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.personal_good'),
|
2009-06-13 12:24:09 +03:00
|
|
|
|
'type' => 'down',
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
|
|
|
|
break;
|
2009-06-13 12:24:09 +03:00
|
|
|
|
case 'new':
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFilter['topic_new']=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2009-06-13 12:24:09 +03:00
|
|
|
|
break;
|
2012-06-16 15:02:20 +03:00
|
|
|
|
case 'newall':
|
|
|
|
|
// нет доп фильтра
|
|
|
|
|
break;
|
2012-03-31 21:33:36 +03:00
|
|
|
|
case 'discussed':
|
|
|
|
|
$aFilter['order']=array('t.topic_count_comment desc','t.topic_id desc');
|
|
|
|
|
break;
|
|
|
|
|
case 'top':
|
|
|
|
|
$aFilter['order']=array('t.topic_rating desc','t.topic_id desc');
|
|
|
|
|
break;
|
2009-06-13 12:24:09 +03:00
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает число новых топиков в персональных блогах
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @return int
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetCountTopicsPersonalNew() {
|
2009-08-20 10:43:06 +03:00
|
|
|
|
$sDate=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'personal',
|
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
'topic_new' => $sDate,
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->GetCountTopicsByFilter($aFilter);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает список топиков по юзеру
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @param int $iPublish Флаг публикации топика
|
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-05-17 20:35:47 +03:00
|
|
|
|
public function GetTopicsPersonalByUser($sUserId,$iPublish,$iPage,$iPerPage) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFilter=array(
|
2008-09-21 09:36:57 +03:00
|
|
|
|
'topic_publish' => $iPublish,
|
2009-09-18 23:36:07 +03:00
|
|
|
|
'user_id' => $sUserId,
|
|
|
|
|
'blog_type' => array('open','personal'),
|
2008-09-21 09:36:57 +03:00
|
|
|
|
);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь смотрит свой профиль, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
2009-09-19 13:53:33 +03:00
|
|
|
|
if($this->oUserCurrent && $this->oUserCurrent->getId()==$sUserId) {
|
2009-09-18 23:36:07 +03:00
|
|
|
|
$aFilter['blog_type'][]='close';
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Возвращает количество топиков которые создал юзер
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @param int $iPublish Флаг публикации топика
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetCountTopicsPersonalByUser($sUserId,$iPublish) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFilter=array(
|
2008-09-21 09:36:57 +03:00
|
|
|
|
'topic_publish' => $iPublish,
|
2009-09-18 23:36:07 +03:00
|
|
|
|
'user_id' => $sUserId,
|
|
|
|
|
'blog_type' => array('open','personal'),
|
2008-09-21 09:36:57 +03:00
|
|
|
|
);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь смотрит свой профиль, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
2009-09-19 13:53:33 +03:00
|
|
|
|
if($this->oUserCurrent && $this->oUserCurrent->getId()==$sUserId) {
|
2009-09-18 23:36:07 +03:00
|
|
|
|
$aFilter['blog_type'][]='close';
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-09-18 23:36:07 +03:00
|
|
|
|
$s=serialize($aFilter);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_count_user_{$s}"))) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetCountTopics($aFilter);
|
2010-03-06 17:48:44 +02:00
|
|
|
|
$this->Cache_Set($data, "topic_count_user_{$s}", array("topic_update_user_{$sUserId}"), 60*60*24);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-11-25 02:37:01 +02:00
|
|
|
|
/**
|
|
|
|
|
* Получает список топиков из указанного блога
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iBlogId ID блога
|
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param array $aAllowData Список типов данных для подгрузки в топики
|
|
|
|
|
* @param bool $bIdsOnly Возвращать только ID или список объектов
|
2009-11-25 02:37:01 +02:00
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsByBlogId($iBlogId,$iPage=0,$iPerPage=0,$aAllowData=array(),$bIdsOnly=true) {
|
|
|
|
|
$aFilter=array('blog_id'=>$iBlogId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2009-11-25 02:37:01 +02:00
|
|
|
|
if(!$aTopics = $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage,$aAllowData) ) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
|
|
|
|
return ($bIdsOnly)
|
2009-11-25 02:37:01 +02:00
|
|
|
|
? array_keys($aTopics['collection'])
|
2012-04-15 13:10:59 +03:00
|
|
|
|
: $aTopics;
|
2009-11-25 02:37:01 +02:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* Список топиков из коллективных блогов
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param string $sShowType Тип выборки топиков
|
|
|
|
|
* @param string $sPeriod Период в виде секунд или конкретной даты
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-03-31 21:33:36 +03:00
|
|
|
|
public function GetTopicsCollective($iPage,$iPerPage,$sShowType='good',$sPeriod=null) {
|
|
|
|
|
if (is_numeric($sPeriod)) {
|
|
|
|
|
// количество последних секунд
|
|
|
|
|
$sPeriod=date("Y-m-d H:00:00",time()-$sPeriod);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'open',
|
|
|
|
|
),
|
2012-04-15 13:10:59 +03:00
|
|
|
|
'topic_publish' => 1,
|
2012-03-31 21:33:36 +03:00
|
|
|
|
);
|
|
|
|
|
if ($sPeriod) {
|
|
|
|
|
$aFilter['topic_date_more'] = $sPeriod;
|
|
|
|
|
}
|
2009-06-07 21:40:54 +03:00
|
|
|
|
switch ($sShowType) {
|
|
|
|
|
case 'good':
|
|
|
|
|
$aFilter['topic_rating']=array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.collective_good'),
|
2009-06-07 21:40:54 +03:00
|
|
|
|
'type' => 'top',
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
|
|
|
|
break;
|
2009-06-07 21:40:54 +03:00
|
|
|
|
case 'bad':
|
|
|
|
|
$aFilter['topic_rating']=array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.collective_good'),
|
2009-06-07 21:40:54 +03:00
|
|
|
|
'type' => 'down',
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
|
|
|
|
break;
|
2009-06-07 21:40:54 +03:00
|
|
|
|
case 'new':
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFilter['topic_new']=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2009-06-07 21:40:54 +03:00
|
|
|
|
break;
|
2012-06-16 15:02:20 +03:00
|
|
|
|
case 'newall':
|
|
|
|
|
// нет доп фильтра
|
|
|
|
|
break;
|
2012-03-31 21:33:36 +03:00
|
|
|
|
case 'discussed':
|
|
|
|
|
$aFilter['order']=array('t.topic_count_comment desc','t.topic_id desc');
|
|
|
|
|
break;
|
|
|
|
|
case 'top':
|
|
|
|
|
$aFilter['order']=array('t.topic_rating desc','t.topic_id desc');
|
|
|
|
|
break;
|
2009-06-07 21:40:54 +03:00
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
|
|
|
|
if($this->oUserCurrent) {
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
2010-01-09 18:45:09 +02:00
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
2009-09-18 23:36:07 +03:00
|
|
|
|
}
|
2009-06-07 21:40:54 +03:00
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает число новых топиков в коллективных блогах
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @return int
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetCountTopicsCollectiveNew() {
|
2009-08-20 10:43:06 +03:00
|
|
|
|
$sDate=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'blog_type' => array(
|
|
|
|
|
'open',
|
|
|
|
|
),
|
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
'topic_new' => $sDate,
|
|
|
|
|
);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если пользователь авторизирован, то добавляем в выдачу
|
|
|
|
|
* закрытые блоги в которых он состоит
|
|
|
|
|
*/
|
|
|
|
|
if($this->oUserCurrent) {
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aOpenBlogs = $this->Blog_GetAccessibleBlogsByUser($this->oUserCurrent);
|
2010-01-09 18:45:09 +02:00
|
|
|
|
if(count($aOpenBlogs)) $aFilter['blog_type']['close'] = $aOpenBlogs;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
|
|
|
|
return $this->GetCountTopicsByFilter($aFilter);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает топики по рейтингу и дате
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param string $sDate Дата
|
|
|
|
|
* @param int $iLimit Количество
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-05-17 20:35:47 +03:00
|
|
|
|
public function GetTopicsRatingByDate($sDate,$iLimit=20) {
|
2009-09-19 17:48:28 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем список блогов, топики которых нужно исключить из выдачи
|
|
|
|
|
*/
|
|
|
|
|
$aCloseBlogs = ($this->oUserCurrent)
|
2009-09-20 21:43:20 +03:00
|
|
|
|
? $this->Blog_GetInaccessibleBlogsByUser($this->oUserCurrent)
|
2012-04-15 13:10:59 +03:00
|
|
|
|
: $this->Blog_GetInaccessibleBlogsByUser();
|
|
|
|
|
|
2009-09-19 17:48:28 +03:00
|
|
|
|
$s=serialize($aCloseBlogs);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2009-09-19 17:48:28 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_rating_{$sDate}_{$iLimit}_{$s}"))) {
|
|
|
|
|
$data = $this->oMapperTopic->GetTopicsRatingByDate($sDate,$iLimit,$aCloseBlogs);
|
|
|
|
|
$this->Cache_Set($data, "topic_rating_{$sDate}_{$iLimit}_{$s}", array('topic_update'), 60*60*24*2);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$data=$this->GetTopicsAdditionalData($data);
|
2009-09-18 23:36:07 +03:00
|
|
|
|
return $data;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
2009-06-07 20:20:58 +03:00
|
|
|
|
* Список топиков из блога
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleBlog_EntityBlog $oBlog Объект блога
|
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
|
|
|
|
* @param string $sShowType Тип выборки топиков
|
|
|
|
|
* @param string $sPeriod Период в виде секунд или конкретной даты
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-03-31 21:33:36 +03:00
|
|
|
|
public function GetTopicsByBlog($oBlog,$iPage,$iPerPage,$sShowType='good',$sPeriod=null) {
|
|
|
|
|
if (is_numeric($sPeriod)) {
|
|
|
|
|
// количество последних секунд
|
|
|
|
|
$sPeriod=date("Y-m-d H:00:00",time()-$sPeriod);
|
|
|
|
|
}
|
2010-03-31 17:39:44 +03:00
|
|
|
|
$aFilter=array(
|
2008-09-21 09:36:57 +03:00
|
|
|
|
'topic_publish' => 1,
|
2012-04-15 13:10:59 +03:00
|
|
|
|
'blog_id' => $oBlog->getId(),
|
2008-09-21 09:36:57 +03:00
|
|
|
|
);
|
2012-03-31 21:33:36 +03:00
|
|
|
|
if ($sPeriod) {
|
|
|
|
|
$aFilter['topic_date_more'] = $sPeriod;
|
|
|
|
|
}
|
2009-06-07 20:20:58 +03:00
|
|
|
|
switch ($sShowType) {
|
|
|
|
|
case 'good':
|
|
|
|
|
$aFilter['topic_rating']=array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.collective_good'),
|
2009-06-07 20:20:58 +03:00
|
|
|
|
'type' => 'top',
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
|
|
|
|
break;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
case 'bad':
|
|
|
|
|
$aFilter['topic_rating']=array(
|
2009-08-20 10:43:06 +03:00
|
|
|
|
'value' => Config::Get('module.blog.collective_good'),
|
2009-06-07 20:20:58 +03:00
|
|
|
|
'type' => 'down',
|
2012-04-15 13:10:59 +03:00
|
|
|
|
);
|
|
|
|
|
break;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
case 'new':
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFilter['topic_new']=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2009-06-07 20:20:58 +03:00
|
|
|
|
break;
|
2012-06-16 15:02:20 +03:00
|
|
|
|
case 'newall':
|
|
|
|
|
// нет доп фильтра
|
|
|
|
|
break;
|
2012-03-31 21:33:36 +03:00
|
|
|
|
case 'discussed':
|
|
|
|
|
$aFilter['order']=array('t.topic_count_comment desc','t.topic_id desc');
|
|
|
|
|
break;
|
|
|
|
|
case 'top':
|
|
|
|
|
$aFilter['order']=array('t.topic_rating desc','t.topic_id desc');
|
|
|
|
|
break;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
default:
|
|
|
|
|
break;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-06-07 20:20:58 +03:00
|
|
|
|
return $this->GetTopicsByFilter($aFilter,$iPage,$iPerPage);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает число новых топиков из блога
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleBlog_EntityBlog $oBlog Объект блога
|
|
|
|
|
* @return int
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetCountTopicsByBlogNew($oBlog) {
|
2009-08-20 10:43:06 +03:00
|
|
|
|
$sDate=date("Y-m-d H:00:00",time()-Config::Get('module.topic.new_time'));
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aFilter=array(
|
2008-09-21 09:36:57 +03:00
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
'blog_id' => $oBlog->getId(),
|
|
|
|
|
'topic_new' => $sDate,
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
|
|
|
|
);
|
|
|
|
|
return $this->GetCountTopicsByFilter($aFilter);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает список топиков по тегу
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param string $sTag Тег
|
|
|
|
|
* @param int $iPage Номер страницы
|
|
|
|
|
* @param int $iPerPage Количество элементов на страницу
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* @param bool $bAddAccessible Указывает на необходимость добавить в выдачу топики,
|
2009-10-15 18:52:53 +03:00
|
|
|
|
* из блогов доступных пользователю. При указании false,
|
|
|
|
|
* в выдачу будут переданы только топики из общедоступных блогов.
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-10-15 18:52:53 +03:00
|
|
|
|
public function GetTopicsByTag($sTag,$iPage,$iPerPage,$bAddAccessible=true) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aCloseBlogs = ($this->oUserCurrent && $bAddAccessible)
|
2010-04-25 16:56:03 +03:00
|
|
|
|
? $this->Blog_GetInaccessibleBlogsByUser($this->oUserCurrent)
|
|
|
|
|
: $this->Blog_GetInaccessibleBlogsByUser();
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
|
|
|
|
$s = serialize($aCloseBlogs);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_tag_{$sTag}_{$iPage}_{$iPerPage}_{$s}"))) {
|
2010-04-25 16:56:03 +03:00
|
|
|
|
$data = array('collection'=>$this->oMapperTopic->GetTopicsByTag($sTag,$aCloseBlogs,$iCount,$iPage,$iPerPage),'count'=>$iCount);
|
2009-10-15 18:52:53 +03:00
|
|
|
|
$this->Cache_Set($data, "topic_tag_{$sTag}_{$iPage}_{$iPerPage}_{$s}", array('topic_update','topic_new'), 60*60*24*2);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$data['collection']=$this->GetTopicsAdditionalData($data['collection']);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает список тегов топиков
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iLimit Количество
|
|
|
|
|
* @param array $aExcludeTopic Список ID топиков для исключения
|
|
|
|
|
* @return array
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-09-19 21:25:11 +03:00
|
|
|
|
public function GetTopicTags($iLimit,$aExcludeTopic=array()) {
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$s=serialize($aExcludeTopic);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("tag_{$iLimit}_{$s}"))) {
|
2009-09-19 21:25:11 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetTopicTags($iLimit,$aExcludeTopic);
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$this->Cache_Set($data, "tag_{$iLimit}_{$s}", array('topic_update','topic_new'), 60*60*24*3);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-09-20 21:43:20 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-09-20 21:43:20 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список тегов из топиков открытых блогов (open,personal)
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $iLimit Количество
|
|
|
|
|
* @param int|null $iUserId ID пользователя, чью теги получаем
|
2009-09-20 21:43:20 +03:00
|
|
|
|
* @return array
|
|
|
|
|
*/
|
2012-04-06 08:02:37 +03:00
|
|
|
|
public function GetOpenTopicTags($iLimit,$iUserId=null) {
|
|
|
|
|
if (false === ($data = $this->Cache_Get("tag_{$iLimit}_{$iUserId}_open"))) {
|
|
|
|
|
$data = $this->oMapperTopic->GetOpenTopicTags($iLimit,$iUserId);
|
|
|
|
|
$this->Cache_Set($data, "tag_{$iLimit}_{$iUserId}_open", array('topic_update','topic_new'), 60*60*24*3);
|
2009-09-20 21:43:20 +03:00
|
|
|
|
}
|
|
|
|
|
return $data;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Увеличивает у топика число комментов
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sTopicId ID топика
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function increaseTopicCountComment($sTopicId) {
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Delete("topic_{$sTopicId}");
|
2009-08-21 15:07:56 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_update"));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->oMapperTopic->increaseTopicCountComment($sTopicId);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает привязку топика к ибранному(добавлен ли топик в избранное у юзера)
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sTopicId ID топика
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return ModuleFavourite_EntityFavourite
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetFavouriteTopic($sTopicId,$sUserId) {
|
2009-08-22 00:01:09 +03:00
|
|
|
|
return $this->Favourite_GetFavourite($sTopicId,'topic',$sUserId);
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получить список избранного по списку айдишников
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return array
|
2009-05-29 18:32:37 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetFavouriteTopicsByArray($aTopicId,$sUserId) {
|
2009-08-22 00:01:09 +03:00
|
|
|
|
return $this->Favourite_GetFavouritesByArray($aTopicId,'topic',$sUserId);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить список избранного по списку айдишников, но используя единый кеш
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param int $sUserId ID пользователя
|
2009-08-08 12:33:32 +03:00
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetFavouriteTopicsByArraySolid($aTopicId,$sUserId) {
|
2009-08-22 00:01:09 +03:00
|
|
|
|
return $this->Favourite_GetFavouritesByArraySolid($aTopicId,'topic',$sUserId);
|
2009-08-08 12:33:32 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляет топик в избранное
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleFavourite_EntityFavourite $oFavouriteTopic Объект избранного
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function AddFavouriteTopic(ModuleFavourite_EntityFavourite $oFavouriteTopic) {
|
2009-08-22 01:17:40 +03:00
|
|
|
|
return $this->Favourite_AddFavourite($oFavouriteTopic);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Удаляет топик из избранного
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleFavourite_EntityFavourite $oFavouriteTopic Объект избранного
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function DeleteFavouriteTopic(ModuleFavourite_EntityFavourite $oFavouriteTopic) {
|
2009-08-22 01:17:40 +03:00
|
|
|
|
return $this->Favourite_DeleteFavourite($oFavouriteTopic);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-08-22 01:17:40 +03:00
|
|
|
|
/**
|
|
|
|
|
* Устанавливает переданный параметр публикации таргета (топика)
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sTopicId ID топика
|
|
|
|
|
* @param int $iPublish Флаг публикации топика
|
2009-08-22 01:17:40 +03:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
2009-06-27 18:05:17 +03:00
|
|
|
|
public function SetFavouriteTopicPublish($sTopicId,$iPublish) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $this->Favourite_SetFavouriteTargetPublish($sTopicId,'topic',$iPublish);
|
|
|
|
|
}
|
2009-10-25 22:01:05 +02:00
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Удаляет топики из избранного по списку
|
2009-10-25 22:01:05 +02:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
2009-10-25 22:01:05 +02:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function DeleteFavouriteTopicByArrayId($aTopicId) {
|
|
|
|
|
return $this->Favourite_DeleteFavouriteByTargetId($aTopicId, 'topic');
|
2009-06-27 18:05:17 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список тегов по первым буквам тега
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param string $sTag Тэг
|
|
|
|
|
* @param int $iLimit Количество
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicTagsByLike($sTag,$iLimit) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("tag_like_{$sTag}_{$iLimit}"))) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetTopicTagsByLike($sTag,$iLimit);
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Set($data, "tag_like_{$sTag}_{$iLimit}", array("topic_update","topic_new"), 60*60*24*3);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
2008-12-28 12:51:59 +02:00
|
|
|
|
* Обновляем/устанавливаем дату прочтения топика, если читаем его первый раз то добавляем
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleTopic_EntityTopicRead $oTopicRead Объект факта чтения топика
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2012-04-15 13:10:59 +03:00
|
|
|
|
public function SetTopicRead(ModuleTopic_EntityTopicRead $oTopicRead) {
|
2009-01-24 11:54:59 +02:00
|
|
|
|
if ($this->GetTopicRead($oTopicRead->getTopicId(),$oTopicRead->getUserId())) {
|
2009-06-07 22:32:58 +03:00
|
|
|
|
$this->Cache_Delete("topic_read_{$oTopicRead->getTopicId()}_{$oTopicRead->getUserId()}");
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_read_user_{$oTopicRead->getUserId()}"));
|
2009-01-24 11:54:59 +02:00
|
|
|
|
$this->oMapperTopic->UpdateTopicRead($oTopicRead);
|
2008-12-28 12:51:59 +02:00
|
|
|
|
} else {
|
2009-06-07 22:32:58 +03:00
|
|
|
|
$this->Cache_Delete("topic_read_{$oTopicRead->getTopicId()}_{$oTopicRead->getUserId()}");
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_read_user_{$oTopicRead->getUserId()}"));
|
2009-01-24 11:54:59 +02:00
|
|
|
|
$this->oMapperTopic->AddTopicRead($oTopicRead);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return true;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем дату прочтения топика юзером
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sTopicId ID топика
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return ModuleTopic_EntityTopicRead|null
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-01-24 11:54:59 +02:00
|
|
|
|
public function GetTopicRead($sTopicId,$sUserId) {
|
2009-06-07 22:32:58 +03:00
|
|
|
|
$data=$this->GetTopicsReadByArray($sTopicId,$sUserId);
|
|
|
|
|
if (isset($data[$sTopicId])) {
|
|
|
|
|
return $data[$sTopicId];
|
|
|
|
|
}
|
|
|
|
|
return null;
|
2009-10-25 22:01:05 +02:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Удаляет записи о чтении записей по списку идентификаторов
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array|int $aTopicId Список ID топиков
|
2009-10-25 22:01:05 +02:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function DeleteTopicReadByArrayId($aTopicId) {
|
|
|
|
|
if(!is_array($aTopicId)) $aTopicId = array($aTopicId);
|
|
|
|
|
return $this->oMapperTopic->DeleteTopicReadByArrayId($aTopicId);
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить список просмотром/чтения топиков по списку айдишников
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return array
|
2009-05-29 18:32:37 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsReadByArray($aTopicId,$sUserId) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
if (!$aTopicId) {
|
|
|
|
|
return array();
|
|
|
|
|
}
|
2009-10-10 22:13:14 +03:00
|
|
|
|
if (Config::Get('sys.cache.solid')) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
return $this->GetTopicsReadByArraySolid($aTopicId,$sUserId);
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
|
|
|
|
$aTopicId=array_unique($aTopicId);
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aTopicsRead=array();
|
|
|
|
|
$aTopicIdNotNeedQuery=array();
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Делаем мульти-запрос к кешу
|
|
|
|
|
*/
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aCacheKeys=func_build_cache_keys($aTopicId,'topic_read_','_'.$sUserId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* проверяем что досталось из кеша
|
2009-06-04 17:42:43 +03:00
|
|
|
|
*/
|
|
|
|
|
foreach ($aCacheKeys as $sValue => $sKey ) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (array_key_exists($sKey,$data)) {
|
2009-06-04 17:42:43 +03:00
|
|
|
|
if ($data[$sKey]) {
|
|
|
|
|
$aTopicsRead[$data[$sKey]->getTopicId()]=$data[$sKey];
|
|
|
|
|
} else {
|
|
|
|
|
$aTopicIdNotNeedQuery[]=$sValue;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
2009-06-04 17:42:43 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Смотрим каких топиков не было в кеше и делаем запрос в БД
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
|
|
|
|
$aTopicIdNeedQuery=array_diff($aTopicId,array_keys($aTopicsRead));
|
|
|
|
|
$aTopicIdNeedQuery=array_diff($aTopicIdNeedQuery,$aTopicIdNotNeedQuery);
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aTopicIdNeedStore=$aTopicIdNeedQuery;
|
2009-05-29 18:32:37 +03:00
|
|
|
|
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);
|
2009-06-04 17:42:43 +03:00
|
|
|
|
$aTopicIdNeedStore=array_diff($aTopicIdNeedStore,array($oTopicRead->getTopicId()));
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-04 17:42:43 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сохраняем в кеш запросы не вернувшие результата
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aTopicIdNeedStore as $sId) {
|
|
|
|
|
$this->Cache_Set(null, "topic_read_{$sId}_{$sUserId}", array(), 60*60*24*4);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-06-23 20:06:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сортируем результат согласно входящему массиву
|
|
|
|
|
*/
|
|
|
|
|
$aTopicsRead=func_array_sort_by_keys($aTopicsRead,$aTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $aTopicsRead;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить список просмотром/чтения топиков по списку айдишников, но используя единый кеш
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return array
|
2009-08-08 12:33:32 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsReadByArraySolid($aTopicId,$sUserId) {
|
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aTopicId=array_unique($aTopicId);
|
|
|
|
|
$aTopicsRead=array();
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$s=join(',',$aTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_read_{$sUserId}_id_{$s}"))) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetTopicsReadByArray($aTopicId,$sUserId);
|
|
|
|
|
foreach ($data as $oTopicRead) {
|
|
|
|
|
$aTopicsRead[$oTopicRead->getTopicId()]=$oTopicRead;
|
|
|
|
|
}
|
|
|
|
|
$this->Cache_Set($aTopicsRead, "topic_read_{$sUserId}_id_{$s}", array("topic_read_user_{$sUserId}"), 60*60*24*1);
|
|
|
|
|
return $aTopicsRead;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
return $data;
|
|
|
|
|
}
|
2008-10-01 21:53:51 +03:00
|
|
|
|
/**
|
|
|
|
|
* Проверяет голосовал ли юзер за топик-вопрос
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sTopicId ID топика
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return ModuleTopic_EntityTopicQuestionVote|null
|
2008-10-01 21:53:51 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicQuestionVote($sTopicId,$sUserId) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$data=$this->GetTopicsQuestionVoteByArray($sTopicId,$sUserId);
|
|
|
|
|
if (isset($data[$sTopicId])) {
|
|
|
|
|
return $data[$sTopicId];
|
|
|
|
|
}
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получить список голосований в топике-опросе по списку айдишников
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return array
|
2009-05-29 18:32:37 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsQuestionVoteByArray($aTopicId,$sUserId) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
if (!$aTopicId) {
|
|
|
|
|
return array();
|
|
|
|
|
}
|
2009-10-10 22:13:14 +03:00
|
|
|
|
if (Config::Get('sys.cache.solid')) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
return $this->GetTopicsQuestionVoteByArraySolid($aTopicId,$sUserId);
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
|
|
|
|
$aTopicId=array_unique($aTopicId);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
$aTopicsQuestionVote=array();
|
|
|
|
|
$aTopicIdNotNeedQuery=array();
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Делаем мульти-запрос к кешу
|
|
|
|
|
*/
|
2009-06-02 22:29:05 +03:00
|
|
|
|
$aCacheKeys=func_build_cache_keys($aTopicId,'topic_question_vote_','_'.$sUserId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* проверяем что досталось из кеша
|
2009-06-02 22:29:05 +03:00
|
|
|
|
*/
|
|
|
|
|
foreach ($aCacheKeys as $sValue => $sKey ) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (array_key_exists($sKey,$data)) {
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if ($data[$sKey]) {
|
|
|
|
|
$aTopicsQuestionVote[$data[$sKey]->getTopicId()]=$data[$sKey];
|
|
|
|
|
} else {
|
|
|
|
|
$aTopicIdNotNeedQuery[]=$sValue;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Смотрим каких топиков не было в кеше и делаем запрос в БД
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
|
|
|
|
$aTopicIdNeedQuery=array_diff($aTopicId,array_keys($aTopicsQuestionVote));
|
|
|
|
|
$aTopicIdNeedQuery=array_diff($aTopicIdNeedQuery,$aTopicIdNotNeedQuery);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
$aTopicIdNeedStore=$aTopicIdNeedQuery;
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if ($data = $this->oMapperTopic->GetTopicsQuestionVoteByArray($aTopicIdNeedQuery,$sUserId)) {
|
|
|
|
|
foreach ($data as $oTopicVote) {
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем к результату и сохраняем в кеш
|
|
|
|
|
*/
|
|
|
|
|
$aTopicsQuestionVote[$oTopicVote->getTopicId()]=$oTopicVote;
|
|
|
|
|
$this->Cache_Set($oTopicVote, "topic_question_vote_{$oTopicVote->getTopicId()}_{$oTopicVote->getVoterId()}", array(), 60*60*24*4);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
$aTopicIdNeedStore=array_diff($aTopicIdNeedStore,array($oTopicVote->getTopicId()));
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сохраняем в кеш запросы не вернувшие результата
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aTopicIdNeedStore as $sId) {
|
|
|
|
|
$this->Cache_Set(null, "topic_question_vote_{$sId}_{$sUserId}", array(), 60*60*24*4);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-06-23 20:06:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сортируем результат согласно входящему массиву
|
|
|
|
|
*/
|
|
|
|
|
$aTopicsQuestionVote=func_array_sort_by_keys($aTopicsQuestionVote,$aTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
return $aTopicsQuestionVote;
|
2008-10-01 21:53:51 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить список голосований в топике-опросе по списку айдишников, но используя единый кеш
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopicId Список ID топиков
|
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @return array
|
2009-08-08 12:33:32 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicsQuestionVoteByArraySolid($aTopicId,$sUserId) {
|
|
|
|
|
if (!is_array($aTopicId)) {
|
|
|
|
|
$aTopicId=array($aTopicId);
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$aTopicId=array_unique($aTopicId);
|
|
|
|
|
$aTopicsQuestionVote=array();
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$s=join(',',$aTopicId);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
if (false === ($data = $this->Cache_Get("topic_question_vote_{$sUserId}_id_{$s}"))) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$data = $this->oMapperTopic->GetTopicsQuestionVoteByArray($aTopicId,$sUserId);
|
|
|
|
|
foreach ($data as $oTopicVote) {
|
|
|
|
|
$aTopicsQuestionVote[$oTopicVote->getTopicId()]=$oTopicVote;
|
|
|
|
|
}
|
|
|
|
|
$this->Cache_Set($aTopicsQuestionVote, "topic_question_vote_{$sUserId}_id_{$s}", array("topic_question_vote_user_{$sUserId}"), 60*60*24*1);
|
|
|
|
|
return $aTopicsQuestionVote;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
return $data;
|
|
|
|
|
}
|
2008-10-01 21:53:51 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляет факт голосования за топик-вопрос
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleTopic_EntityTopicQuestionVote $oTopicQuestionVote Объект голосования в топике-опросе
|
|
|
|
|
* @return bool
|
2008-10-01 21:53:51 +03:00
|
|
|
|
*/
|
2010-05-27 18:16:20 +03:00
|
|
|
|
public function AddTopicQuestionVote(ModuleTopic_EntityTopicQuestionVote $oTopicQuestionVote) {
|
2009-06-27 18:05:17 +03:00
|
|
|
|
$this->Cache_Delete("topic_question_vote_{$oTopicQuestionVote->getTopicId()}_{$oTopicQuestionVote->getVoterId()}");
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_question_vote_user_{$oTopicQuestionVote->getVoterId()}"));
|
2008-10-01 21:53:51 +03:00
|
|
|
|
return $this->oMapperTopic->AddTopicQuestionVote($oTopicQuestionVote);
|
|
|
|
|
}
|
2009-03-01 12:19:06 +02:00
|
|
|
|
/**
|
|
|
|
|
* Получает топик по уникальному хешу(текст топика)
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sUserId
|
|
|
|
|
* @param string $sHash
|
|
|
|
|
* @return ModuleTopic_EntityTopic|null
|
2009-03-01 12:19:06 +02:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicUnique($sUserId,$sHash) {
|
2009-06-24 00:35:20 +03:00
|
|
|
|
$sId=$this->oMapperTopic->GetTopicUnique($sUserId,$sHash);
|
|
|
|
|
return $this->GetTopicById($sId);
|
2009-03-01 12:19:06 +02:00
|
|
|
|
}
|
2009-06-20 16:54:24 +03:00
|
|
|
|
/**
|
|
|
|
|
* Рассылает уведомления о новом топике подписчикам блога
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param ModuleBlog_EntityBlog $oBlog Объект блога
|
|
|
|
|
* @param ModuleTopic_EntityTopic $oTopic Объект топика
|
|
|
|
|
* @param ModuleUser_EntityUser $oUserTopic Объект пользователя
|
2009-06-20 16:54:24 +03:00
|
|
|
|
*/
|
|
|
|
|
public function SendNotifyTopicNew($oBlog,$oTopic,$oUserTopic) {
|
2011-05-05 16:30:01 +03:00
|
|
|
|
$aBlogUsersResult=$this->Blog_GetBlogUsersByBlogId($oBlog->getId(),null,null); // нужно постранично пробегаться по всем
|
|
|
|
|
$aBlogUsers=$aBlogUsersResult['collection'];
|
2009-06-20 16:54:24 +03:00
|
|
|
|
foreach ($aBlogUsers as $oBlogUser) {
|
|
|
|
|
if ($oBlogUser->getUserId()==$oUserTopic->getId()) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
$this->Notify_SendTopicNewToSubscribeBlog($oBlogUser->getUser(),$oTopic,$oBlog,$oUserTopic);
|
|
|
|
|
}
|
|
|
|
|
//отправляем создателю блога
|
|
|
|
|
if ($oBlog->getOwnerId()!=$oUserTopic->getId()) {
|
|
|
|
|
$this->Notify_SendTopicNewToSubscribeBlog($oBlog->getOwner(),$oTopic,$oBlog,$oUserTopic);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-06-20 16:54:24 +03:00
|
|
|
|
}
|
2009-11-04 12:36:08 +02:00
|
|
|
|
/**
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* Возвращает список последних топиков пользователя, опубликованных не более чем $iTimeLimit секунд назад
|
2009-11-04 12:36:08 +02:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sUserId ID пользователя
|
|
|
|
|
* @param int $iTimeLimit Число секунд
|
|
|
|
|
* @param int $iCountLimit Количество
|
|
|
|
|
* @param array $aAllowData Список типов данных для подгрузки в топики
|
2009-11-04 12:36:08 +02:00
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetLastTopicsByUserId($sUserId,$iTimeLimit,$iCountLimit=1,$aAllowData=array()) {
|
|
|
|
|
$aFilter = array(
|
|
|
|
|
'topic_publish' => 1,
|
|
|
|
|
'user_id' => $sUserId,
|
|
|
|
|
'topic_new' => date("Y-m-d H:i:s",time()-$iTimeLimit),
|
|
|
|
|
);
|
|
|
|
|
$aTopics = $this->GetTopicsByFilter($aFilter,1,$iCountLimit,$aAllowData);
|
|
|
|
|
|
|
|
|
|
return $aTopics;
|
|
|
|
|
}
|
2009-11-25 02:37:01 +02:00
|
|
|
|
/**
|
|
|
|
|
* Перемещает топики в другой блог
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aTopics Список ID топиков
|
|
|
|
|
* @param int $sBlogId ID блога
|
2009-11-25 02:37:01 +02:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function MoveTopicsByArrayId($aTopics,$sBlogId) {
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_update", "topic_new_blog_{$sBlogId}"));
|
2010-04-17 20:55:22 +03:00
|
|
|
|
if ($res=$this->oMapperTopic->MoveTopicsByArrayId($aTopics,$sBlogId)) {
|
|
|
|
|
// перемещаем теги
|
|
|
|
|
$this->oMapperTopic->MoveTopicsTagsByArrayId($aTopics,$sBlogId);
|
|
|
|
|
// меняем target parent у комментов
|
|
|
|
|
$this->Comment_UpdateTargetParentByTargetId($sBlogId, 'topic', $aTopics);
|
|
|
|
|
// меняем target parent у комментов в прямом эфире
|
|
|
|
|
$this->Comment_UpdateTargetParentByTargetIdOnline($sBlogId, 'topic', $aTopics);
|
|
|
|
|
return $res;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
2009-11-25 02:37:01 +02:00
|
|
|
|
}
|
2009-11-25 16:06:02 +02:00
|
|
|
|
/**
|
|
|
|
|
* Перемещает топики в другой блог
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param int $sBlogId ID старого блога
|
|
|
|
|
* @param int $sBlogIdNew ID нового блога
|
2009-11-25 16:06:02 +02:00
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function MoveTopics($sBlogId,$sBlogIdNew) {
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("topic_update", "topic_new_blog_{$sBlogId}", "topic_new_blog_{$sBlogIdNew}"));
|
2010-04-17 20:55:22 +03:00
|
|
|
|
if ($res=$this->oMapperTopic->MoveTopics($sBlogId,$sBlogIdNew)) {
|
|
|
|
|
// перемещаем теги
|
|
|
|
|
$this->oMapperTopic->MoveTopicsTags($sBlogId,$sBlogIdNew);
|
|
|
|
|
// меняем target parent у комментов
|
|
|
|
|
$this->Comment_MoveTargetParent($sBlogId, 'topic', $sBlogIdNew);
|
|
|
|
|
// меняем target parent у комментов в прямом эфире
|
|
|
|
|
$this->Comment_MoveTargetParentOnline($sBlogId, 'topic', $sBlogIdNew);
|
|
|
|
|
return $res;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
2009-12-10 18:57:30 +02:00
|
|
|
|
/**
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* Загрузка изображений при написании топика
|
2009-12-10 18:57:30 +02:00
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aFile Массив $_FILES
|
|
|
|
|
* @param ModuleUser_EntityUser $oUser Объект пользователя
|
2009-12-10 18:57:30 +02:00
|
|
|
|
* @return string|bool
|
|
|
|
|
*/
|
|
|
|
|
public function UploadTopicImageFile($aFile,$oUser) {
|
|
|
|
|
if(!is_array($aFile) || !isset($aFile['tmp_name'])) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
|
|
|
|
$sFileTmp=Config::Get('sys.cache.dir').func_generator();
|
|
|
|
|
if (!move_uploaded_file($aFile['tmp_name'],$sFileTmp)) {
|
2010-04-04 15:15:40 +03:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
$sDirUpload=$this->Image_GetIdDir($oUser->getId());
|
2009-12-10 18:57:30 +02:00
|
|
|
|
$aParams=$this->Image_BuildParams('topic');
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2010-04-17 22:37:27 +03:00
|
|
|
|
if ($sFileImage=$this->Image_Resize($sFileTmp,$sDirUpload,func_generator(6),Config::Get('view.img_max_width'),Config::Get('view.img_max_height'),Config::Get('view.img_resize_width'),null,true,$aParams)) {
|
2010-04-04 15:15:40 +03:00
|
|
|
|
@unlink($sFileTmp);
|
2009-12-10 20:30:05 +02:00
|
|
|
|
return $this->Image_GetWebPath($sFileImage);
|
2009-12-10 18:57:30 +02:00
|
|
|
|
}
|
2010-04-04 15:15:40 +03:00
|
|
|
|
@unlink($sFileTmp);
|
2009-12-10 18:57:30 +02:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Загрузка изображений по переданному URL
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param string $sUrl URL изображения
|
2010-05-27 18:16:20 +03:00
|
|
|
|
* @param ModuleUser_EntityUser $oUser
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @return string|int
|
2009-12-10 18:57:30 +02:00
|
|
|
|
*/
|
|
|
|
|
public function UploadTopicImageUrl($sUrl, $oUser) {
|
|
|
|
|
/**
|
|
|
|
|
* Проверяем, является ли файл изображением
|
|
|
|
|
*/
|
|
|
|
|
if(!@getimagesize($sUrl)) {
|
2010-05-27 17:02:43 +03:00
|
|
|
|
return ModuleImage::UPLOAD_IMAGE_ERROR_TYPE;
|
2009-12-10 18:57:30 +02:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Открываем файловый поток и считываем файл поблочно,
|
|
|
|
|
* контролируя максимальный размер изображения
|
|
|
|
|
*/
|
|
|
|
|
$oFile=fopen($sUrl,'r');
|
|
|
|
|
if(!$oFile) {
|
2010-05-27 17:02:43 +03:00
|
|
|
|
return ModuleImage::UPLOAD_IMAGE_ERROR_READ;
|
2009-12-10 18:57:30 +02:00
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2010-08-21 10:43:04 +03:00
|
|
|
|
$iMaxSizeKb=Config::Get('view.img_max_size_url');
|
2009-12-10 18:57:30 +02:00
|
|
|
|
$iSizeKb=0;
|
|
|
|
|
$sContent='';
|
|
|
|
|
while (!feof($oFile) and $iSizeKb<$iMaxSizeKb) {
|
|
|
|
|
$sContent.=fread($oFile ,1024*1);
|
|
|
|
|
$iSizeKb++;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Если конец файла не достигнут,
|
|
|
|
|
* значит файл имеет недопустимый размер
|
|
|
|
|
*/
|
|
|
|
|
if(!feof($oFile)) {
|
2010-05-27 17:02:43 +03:00
|
|
|
|
return ModuleImage::UPLOAD_IMAGE_ERROR_SIZE;
|
2009-12-10 18:57:30 +02:00
|
|
|
|
}
|
|
|
|
|
fclose($oFile);
|
|
|
|
|
/**
|
|
|
|
|
* Создаем tmp-файл, для временного хранения изображения
|
|
|
|
|
*/
|
|
|
|
|
$sFileTmp=Config::Get('sys.cache.dir').func_generator();
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2009-12-10 18:57:30 +02:00
|
|
|
|
$fp=fopen($sFileTmp,'w');
|
|
|
|
|
fwrite($fp,$sContent);
|
|
|
|
|
fclose($fp);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2009-12-10 21:07:54 +02:00
|
|
|
|
$sDirSave=$this->Image_GetIdDir($oUser->getId());
|
2009-12-10 18:57:30 +02:00
|
|
|
|
$aParams=$this->Image_BuildParams('topic');
|
|
|
|
|
/**
|
|
|
|
|
* Передаем изображение на обработку
|
|
|
|
|
*/
|
2010-04-17 22:37:27 +03:00
|
|
|
|
if ($sFileImg=$this->Image_Resize($sFileTmp,$sDirSave,func_generator(),Config::Get('view.img_max_width'),Config::Get('view.img_max_height'),Config::Get('view.img_resize_width'),null,true,$aParams)) {
|
2009-12-10 18:57:30 +02:00
|
|
|
|
@unlink($sFileTmp);
|
2009-12-10 20:30:05 +02:00
|
|
|
|
return $this->Image_GetWebPath($sFileImg);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
}
|
|
|
|
|
|
2009-12-10 18:57:30 +02:00
|
|
|
|
@unlink($sFileTmp);
|
2010-05-27 17:02:43 +03:00
|
|
|
|
return ModuleImage::UPLOAD_IMAGE_ERROR;
|
2009-12-10 18:57:30 +02:00
|
|
|
|
}
|
2011-07-24 00:55:56 +03:00
|
|
|
|
/**
|
|
|
|
|
* Возвращает список фотографий к топику-фотосет по списку id фоток
|
|
|
|
|
*
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* @param array $aPhotoId Список ID фото
|
|
|
|
|
* @return array
|
2011-07-24 00:55:56 +03:00
|
|
|
|
*/
|
|
|
|
|
public function GetTopicPhotosByArrayId($aPhotoId) {
|
|
|
|
|
if (!$aPhotoId) {
|
|
|
|
|
return array();
|
|
|
|
|
}
|
|
|
|
|
if (!is_array($aPhotoId)) {
|
|
|
|
|
$aPhotoId=array($aPhotoId);
|
|
|
|
|
}
|
|
|
|
|
$aPhotoId=array_unique($aPhotoId);
|
|
|
|
|
$aPhotos=array();
|
|
|
|
|
$s=join(',',$aPhotoId);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("photoset_photo_id_{$s}"))) {
|
|
|
|
|
$data = $this->oMapperTopic->GetTopicPhotosByArrayId($aPhotoId);
|
|
|
|
|
foreach ($data as $oPhoto) {
|
|
|
|
|
$aPhotos[$oPhoto->getId()]=$oPhoto;
|
|
|
|
|
}
|
|
|
|
|
$this->Cache_Set($aPhotos, "photoset_photo_id_{$s}", array("photoset_photo_update"), 60*60*24*1);
|
|
|
|
|
return $aPhotos;
|
|
|
|
|
}
|
|
|
|
|
return $data;
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Добавить к топику изображение
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param ModuleTopic_EntityTopicPhoto $oPhoto Объект фото к топику-фотосету
|
|
|
|
|
* @return ModuleTopic_EntityTopicPhoto|bool
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function addTopicPhoto($oPhoto) {
|
|
|
|
|
if ($sId=$this->oMapperTopic->addTopicPhoto($oPhoto)) {
|
|
|
|
|
$oPhoto->setId($sId);
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("photoset_photo_update"));
|
|
|
|
|
return $oPhoto;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Получить изображение из фотосета по его id
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param int $sId ID фото
|
|
|
|
|
* @return ModuleTopic_EntityTopicPhoto|null
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function getTopicPhotoById($sId) {
|
|
|
|
|
$aPhotos=$this->GetTopicPhotosByArrayId($sId);
|
|
|
|
|
if (isset($aPhotos[$sId])) {
|
|
|
|
|
return $aPhotos[$sId];
|
|
|
|
|
}
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Получить список изображений из фотосета по id топика
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param int $iTopicId ID топика
|
|
|
|
|
* @param int|null $iFromId ID с которого начинать выборку
|
|
|
|
|
* @param int|null $iCount Количество
|
|
|
|
|
* @return array
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function getPhotosByTopicId($iTopicId, $iFromId = null, $iCount = null) {
|
|
|
|
|
return $this->oMapperTopic->getPhotosByTopicId($iTopicId, $iFromId, $iCount);
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Получить список изображений из фотосета по временному коду
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param string $sTargetTmp Временный ключ
|
|
|
|
|
* @return array
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function getPhotosByTargetTmp($sTargetTmp) {
|
|
|
|
|
return $this->oMapperTopic->getPhotosByTargetTmp($sTargetTmp);
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Получить число изображений из фотосета по id топика
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param int $iTopicId ID топика
|
|
|
|
|
* @return int
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function getCountPhotosByTopicId($iTopicId) {
|
|
|
|
|
return $this->oMapperTopic->getCountPhotosByTopicId($iTopicId);
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Получить число изображений из фотосета по id топика
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param string $sTargetTmp Временный ключ
|
|
|
|
|
* @return int
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function getCountPhotosByTargetTmp($sTargetTmp) {
|
|
|
|
|
return $this->oMapperTopic->getCountPhotosByTargetTmp($sTargetTmp);
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-06-25 20:53:05 +03:00
|
|
|
|
* Обновить данные по изображению
|
|
|
|
|
*
|
|
|
|
|
* @param ModuleTopic_EntityTopicPhoto $oPhoto Объект фото
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function updateTopicPhoto($oPhoto) {
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("photoset_photo_update"));
|
|
|
|
|
$this->oMapperTopic->updateTopicPhoto($oPhoto);
|
2011-07-20 00:32:36 +03:00
|
|
|
|
}
|
2011-07-24 00:55:56 +03:00
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Удалить изображение
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param ModuleTopic_EntityTopicPhoto $oPhoto Объект фото
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function deleteTopicPhoto($oPhoto) {
|
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("photoset_photo_update"));
|
|
|
|
|
$this->oMapperTopic->deleteTopicPhoto($oPhoto->getId());
|
|
|
|
|
|
2012-04-08 17:37:43 +03:00
|
|
|
|
$this->Image_RemoveFile($this->Image_GetServerPath($oPhoto->getWebPath()));
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$aSizes=Config::Get('module.topic.photoset.size');
|
|
|
|
|
// Удаляем все сгенерированные миниатюры основываясь на данных из конфига.
|
|
|
|
|
foreach ($aSizes as $aSize) {
|
|
|
|
|
$sSize = $aSize['w'];
|
|
|
|
|
if ($aSize['crop']) {
|
|
|
|
|
$sSize .= 'crop';
|
|
|
|
|
}
|
2012-04-08 17:37:43 +03:00
|
|
|
|
$this->Image_RemoveFile($this->Image_GetServerPath($oPhoto->getWebPath($sSize)));
|
2011-07-24 00:55:56 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Загрузить изображение
|
2012-06-25 20:53:05 +03:00
|
|
|
|
*
|
|
|
|
|
* @param array $aFile Массив $_FILES
|
|
|
|
|
* @return string|bool
|
2012-04-15 13:10:59 +03:00
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
public function UploadTopicPhoto($aFile) {
|
|
|
|
|
if(!is_array($aFile) || !isset($aFile['tmp_name'])) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$sFileName = func_generator(10);
|
|
|
|
|
$sPath = Config::Get('path.uploads.images').'/topic/'.date('Y/m/d').'/';
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2011-07-24 00:55:56 +03:00
|
|
|
|
if (!is_dir(Config::Get('path.root.server').$sPath)) {
|
|
|
|
|
mkdir(Config::Get('path.root.server').$sPath, 0755, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$sFileTmp = Config::Get('path.root.server').$sPath.$sFileName;
|
|
|
|
|
if (!move_uploaded_file($aFile['tmp_name'],$sFileTmp)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
|
|
|
|
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$aParams=$this->Image_BuildParams('photoset');
|
|
|
|
|
|
2012-04-29 07:10:21 +03:00
|
|
|
|
$oImage =$this->Image_CreateImageObject($sFileTmp);
|
2011-07-24 00:55:56 +03:00
|
|
|
|
/**
|
2012-04-15 13:10:59 +03:00
|
|
|
|
* Если объект изображения не создан,
|
|
|
|
|
* возвращаем ошибку
|
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
if($sError=$oImage->get_last_error()) {
|
|
|
|
|
// Вывод сообщения об ошибки, произошедшей при создании объекта изображения
|
|
|
|
|
$this->Message_AddError($sError,$this->Lang_Get('error'));
|
|
|
|
|
@unlink($sFileTmp);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2011-08-10 12:36:55 +03:00
|
|
|
|
/**
|
|
|
|
|
* Превышает максимальные размеры из конфига
|
|
|
|
|
*/
|
|
|
|
|
if (($oImage->get_image_params('width')>Config::Get('view.img_max_width')) or ($oImage->get_image_params('height')>Config::Get('view.img_max_height'))) {
|
2012-04-15 13:10:59 +03:00
|
|
|
|
$this->Message_AddError($this->Lang_Get('topic_photoset_error_size'),$this->Lang_Get('error'));
|
|
|
|
|
@unlink($sFileTmp);
|
|
|
|
|
return false;
|
2011-08-10 12:36:55 +03:00
|
|
|
|
}
|
2012-06-25 20:53:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем к загруженному файлу расширение
|
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$sFile=$sFileTmp.'.'.$oImage->get_image_params('format');
|
|
|
|
|
rename($sFileTmp,$sFile);
|
2012-04-15 13:10:59 +03:00
|
|
|
|
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$aSizes=Config::Get('module.topic.photoset.size');
|
|
|
|
|
foreach ($aSizes as $aSize) {
|
2012-06-25 20:53:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Для каждого указанного в конфиге размера генерируем картинку
|
|
|
|
|
*/
|
2011-07-24 00:55:56 +03:00
|
|
|
|
$sNewFileName = $sFileName.'_'.$aSize['w'];
|
2012-04-29 07:10:21 +03:00
|
|
|
|
$oImage = $this->Image_CreateImageObject($sFile);
|
2011-07-24 00:55:56 +03:00
|
|
|
|
if ($aSize['crop']) {
|
|
|
|
|
$this->Image_CropProportion($oImage, $aSize['w'], $aSize['h'], true);
|
|
|
|
|
$sNewFileName .= 'crop';
|
|
|
|
|
}
|
|
|
|
|
$this->Image_Resize($sFile,$sPath,$sNewFileName,Config::Get('view.img_max_width'),Config::Get('view.img_max_height'),$aSize['w'],$aSize['h'],true,$aParams,$oImage);
|
|
|
|
|
}
|
|
|
|
|
return $this->Image_GetWebPath($sFile);
|
|
|
|
|
}
|
2012-04-15 13:10:59 +03:00
|
|
|
|
/**
|
|
|
|
|
* Пересчитывает счетчик избранных топиков
|
|
|
|
|
*
|
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function RecalculateFavourite(){
|
|
|
|
|
return $this->oMapperTopic->RecalculateFavourite();
|
|
|
|
|
}
|
2012-03-10 07:45:19 +02:00
|
|
|
|
/**
|
|
|
|
|
* Пересчитывает счетчики голосований
|
|
|
|
|
*
|
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function RecalculateVote(){
|
|
|
|
|
return $this->oMapperTopic->RecalculateVote();
|
|
|
|
|
}
|
2012-08-05 12:47:09 +03:00
|
|
|
|
/**
|
|
|
|
|
* Алиас для корректной работы ORM
|
|
|
|
|
*
|
|
|
|
|
* @param array $aTopocId Список ID топиков
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
public function GetTopicItemsByArrayId($aTopocId) {
|
|
|
|
|
return $this->GetTopicsByArrayId($aTopocId);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
?>
|