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
|
|
|
|
|
*
|
|
|
|
|
---------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
set_include_path(get_include_path().PATH_SEPARATOR.dirname(__FILE__));
|
|
|
|
|
require_once('mapper/Blog.mapper.class.php');
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Модуль для работы с блогами
|
|
|
|
|
*
|
|
|
|
|
*/
|
2009-03-21 15:48:00 +02:00
|
|
|
|
class LsBlog extends Module {
|
2009-09-17 21:54:55 +03:00
|
|
|
|
/**
|
|
|
|
|
* Возможные роли пользователя в блоге
|
|
|
|
|
*/
|
|
|
|
|
const BLOG_USER_ROLE_GUEST = 0;
|
|
|
|
|
const BLOG_USER_ROLE_USER = 1;
|
|
|
|
|
const BLOG_USER_ROLE_MODERATOR = 2;
|
|
|
|
|
const BLOG_USER_ROLE_ADMINISTRATOR = 4;
|
2009-09-22 00:08:00 +03:00
|
|
|
|
/**
|
|
|
|
|
* Пользователь, приглашенный админом блога в блог
|
|
|
|
|
*/
|
|
|
|
|
const BLOG_USER_ROLE_INVITE = -1;
|
|
|
|
|
/**
|
|
|
|
|
* Пользователь, отклонивший приглашение админа
|
|
|
|
|
*/
|
|
|
|
|
const BLOG_USER_ROLE_REJECT = -2;
|
2009-09-26 23:32:33 +03:00
|
|
|
|
/**
|
|
|
|
|
* Забаненный в блоге пользователь
|
|
|
|
|
*/
|
|
|
|
|
const BLOG_USER_ROLE_BAN = -4;
|
2009-09-22 00:08:00 +03:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
protected $oMapperBlog;
|
|
|
|
|
protected $oUserCurrent=null;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Инициализация
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
public function Init() {
|
|
|
|
|
$this->oMapperBlog=new Mapper_Blog($this->Database_GetConnect());
|
|
|
|
|
$this->oMapperBlog->SetUserCurrent($this->User_GetUserCurrent());
|
|
|
|
|
$this->oUserCurrent=$this->User_GetUserCurrent();
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает дополнительные данные(объекты) для блогов по их ID
|
|
|
|
|
*
|
|
|
|
|
*/
|
2009-07-26 16:43:16 +03:00
|
|
|
|
public function GetBlogsAdditionalData($aBlogId,$aAllowData=array('vote','owner'=>array(),'relation_user')) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
func_array_simpleflip($aAllowData);
|
|
|
|
|
if (!is_array($aBlogId)) {
|
|
|
|
|
$aBlogId=array($aBlogId);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получаем блоги
|
|
|
|
|
*/
|
|
|
|
|
$aBlogs=$this->GetBlogsByArrayId($aBlogId);
|
|
|
|
|
/**
|
|
|
|
|
* Формируем ID дополнительных данных, которые нужно получить
|
|
|
|
|
*/
|
|
|
|
|
$aUserId=array();
|
|
|
|
|
foreach ($aBlogs as $oBlog) {
|
|
|
|
|
if (isset($aAllowData['owner'])) {
|
|
|
|
|
$aUserId[]=$oBlog->getOwnerId();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получаем дополнительные данные
|
|
|
|
|
*/
|
2009-06-02 22:29:05 +03:00
|
|
|
|
$aBlogUsers=array();
|
|
|
|
|
$aBlogsVote=array();
|
|
|
|
|
$aUsers=isset($aAllowData['owner']) && is_array($aAllowData['owner']) ? $this->User_GetUsersAdditionalData($aUserId,$aAllowData['owner']) : $this->User_GetUsersAdditionalData($aUserId);
|
|
|
|
|
if (isset($aAllowData['relation_user']) and $this->oUserCurrent) {
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$aBlogUsers=$this->GetBlogUsersByArrayBlog($aBlogId,$this->oUserCurrent->getId());
|
2009-06-02 22:29:05 +03:00
|
|
|
|
}
|
2009-06-28 17:04:44 +03:00
|
|
|
|
if (isset($aAllowData['vote']) and $this->oUserCurrent) {
|
|
|
|
|
$aBlogsVote=$this->Vote_GetVoteByArray($aBlogId,'blog',$this->oUserCurrent->getId());
|
2009-06-02 22:29:05 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем данные к результату - списку блогов
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aBlogs as $oBlog) {
|
|
|
|
|
if (isset($aUsers[$oBlog->getOwnerId()])) {
|
|
|
|
|
$oBlog->setOwner($aUsers[$oBlog->getOwnerId()]);
|
|
|
|
|
} else {
|
|
|
|
|
$oBlog->setOwner(null); // или $oBlog->setOwner(new UserEntity_User());
|
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (isset($aBlogUsers[$oBlog->getId()])) {
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$oBlog->setUserIsJoin(true);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if ($aBlogUsers[$oBlog->getId()]->getIsAdministrator()) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$oBlog->setUserIsAdministrator(true);
|
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if ($aBlogUsers[$oBlog->getId()]->getIsModerator()) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
$oBlog->setUserIsModerator(true);
|
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
} else {
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$oBlog->setUserIsJoin(false);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
$oBlog->setUserIsAdministrator(false);
|
|
|
|
|
$oBlog->setUserIsModerator(false);
|
2009-06-28 17:04:44 +03:00
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (isset($aBlogsVote[$oBlog->getId()])) {
|
2009-06-28 17:04:44 +03:00
|
|
|
|
$oBlog->setVote($aBlogsVote[$oBlog->getId()]);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
} else {
|
2009-06-28 17:04:44 +03:00
|
|
|
|
$oBlog->setVote(null);
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return $aBlogs;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Список блогов по ID
|
|
|
|
|
*
|
|
|
|
|
* @param array $aUserId
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogsByArrayId($aBlogId) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
if (!$aBlogId) {
|
|
|
|
|
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->GetBlogsByArrayIdSolid($aBlogId);
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if (!is_array($aBlogId)) {
|
|
|
|
|
$aBlogId=array($aBlogId);
|
|
|
|
|
}
|
|
|
|
|
$aBlogId=array_unique($aBlogId);
|
2009-06-04 18:02:10 +03:00
|
|
|
|
$aBlogs=array();
|
|
|
|
|
$aBlogIdNotNeedQuery=array();
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Делаем мульти-запрос к кешу
|
|
|
|
|
*/
|
2009-06-04 18:02:10 +03:00
|
|
|
|
$aCacheKeys=func_build_cache_keys($aBlogId,'blog_');
|
2009-08-08 12:33:32 +03:00
|
|
|
|
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* проверяем что досталось из кеша
|
2009-06-04 18:02:10 +03:00
|
|
|
|
*/
|
|
|
|
|
foreach ($aCacheKeys as $sValue => $sKey ) {
|
|
|
|
|
if (array_key_exists($sKey,$data)) {
|
|
|
|
|
if ($data[$sKey]) {
|
|
|
|
|
$aBlogs[$data[$sKey]->getId()]=$data[$sKey];
|
|
|
|
|
} else {
|
|
|
|
|
$aBlogIdNotNeedQuery[]=$sValue;
|
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-04 18:02:10 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
/**
|
|
|
|
|
* Смотрим каких блогов не было в кеше и делаем запрос в БД
|
|
|
|
|
*/
|
2009-06-04 18:02:10 +03:00
|
|
|
|
$aBlogIdNeedQuery=array_diff($aBlogId,array_keys($aBlogs));
|
|
|
|
|
$aBlogIdNeedQuery=array_diff($aBlogIdNeedQuery,$aBlogIdNotNeedQuery);
|
|
|
|
|
$aBlogIdNeedStore=$aBlogIdNeedQuery;
|
2009-05-29 18:32:37 +03:00
|
|
|
|
if ($data = $this->oMapperBlog->GetBlogsByArrayId($aBlogIdNeedQuery)) {
|
|
|
|
|
foreach ($data as $oBlog) {
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем к результату и сохраняем в кеш
|
|
|
|
|
*/
|
|
|
|
|
$aBlogs[$oBlog->getId()]=$oBlog;
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$this->Cache_Set($oBlog, "blog_{$oBlog->getId()}", array(), 60*60*24*4);
|
2009-06-04 18:02:10 +03:00
|
|
|
|
$aBlogIdNeedStore=array_diff($aBlogIdNeedStore,array($oBlog->getId()));
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-04 18:02:10 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сохраняем в кеш запросы не вернувшие результата
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aBlogIdNeedStore as $sId) {
|
2009-07-26 16:43:16 +03:00
|
|
|
|
$this->Cache_Set(null, "blog_{$sId}", array(), 60*60*24*4);
|
2009-06-04 18:02:10 +03:00
|
|
|
|
}
|
2009-06-23 20:06:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сортируем результат согласно входящему массиву
|
|
|
|
|
*/
|
|
|
|
|
$aBlogs=func_array_sort_by_keys($aBlogs,$aBlogId);
|
2009-05-29 18:32:37 +03:00
|
|
|
|
return $aBlogs;
|
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
/**
|
|
|
|
|
* Список блогов по ID, но используя единый кеш
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $aBlogId
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogsByArrayIdSolid($aBlogId) {
|
|
|
|
|
if (!is_array($aBlogId)) {
|
|
|
|
|
$aBlogId=array($aBlogId);
|
|
|
|
|
}
|
|
|
|
|
$aBlogId=array_unique($aBlogId);
|
|
|
|
|
$aBlogs=array();
|
|
|
|
|
$s=join(',',$aBlogId);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_id_{$s}"))) {
|
|
|
|
|
$data = $this->oMapperBlog->GetBlogsByArrayId($aBlogId);
|
|
|
|
|
foreach ($data as $oBlog) {
|
|
|
|
|
$aBlogs[$oBlog->getId()]=$oBlog;
|
|
|
|
|
}
|
|
|
|
|
$this->Cache_Set($aBlogs, "blog_id_{$s}", array("blog_update"), 60*60*24*1);
|
|
|
|
|
return $aBlogs;
|
|
|
|
|
}
|
|
|
|
|
return $data;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить персональный блог юзера
|
|
|
|
|
*
|
|
|
|
|
* @param Entity_User $oUser
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
2008-10-04 00:07:32 +03:00
|
|
|
|
public function GetPersonalBlogByUserId($sUserId) {
|
2009-06-20 16:54:24 +03:00
|
|
|
|
$id=$this->oMapperBlog->GetPersonalBlogByUserId($sUserId);
|
2009-06-24 00:35:20 +03:00
|
|
|
|
return $this->GetBlogById($id);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получить блог по айдишнику(номеру)
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sBlogId
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogById($sBlogId) {
|
2009-06-09 18:55:10 +03:00
|
|
|
|
$aBlogs=$this->GetBlogsAdditionalData($sBlogId);
|
|
|
|
|
if (isset($aBlogs[$sBlogId])) {
|
|
|
|
|
return $aBlogs[$sBlogId];
|
2009-05-29 18:32:37 +03:00
|
|
|
|
}
|
|
|
|
|
return null;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получить блог по УРЛу
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sBlogUrl
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
2009-06-07 20:20:58 +03:00
|
|
|
|
public function GetBlogByUrl($sBlogUrl) {
|
|
|
|
|
if (false === ($id = $this->Cache_Get("blog_url_{$sBlogUrl}"))) {
|
|
|
|
|
if ($id = $this->oMapperBlog->GetBlogByUrl($sBlogUrl)) {
|
|
|
|
|
$this->Cache_Set($id, "blog_url_{$sBlogUrl}", array("blog_update_{$id}"), 60*60*24*2);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
} else {
|
2009-07-06 23:04:20 +03:00
|
|
|
|
$this->Cache_Set(null, "blog_url_{$sBlogUrl}", array('blog_update','blog_new'), 60*60);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-06-07 20:20:58 +03:00
|
|
|
|
}
|
2009-06-24 00:35:20 +03:00
|
|
|
|
return $this->GetBlogById($id);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2008-10-16 18:40:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить блог по названию
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sTitle
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogByTitle($sTitle) {
|
2009-07-06 23:04:20 +03:00
|
|
|
|
if (false === ($id = $this->Cache_Get("blog_title_{$sTitle}"))) {
|
2009-06-24 00:35:20 +03:00
|
|
|
|
if ($id = $this->oMapperBlog->GetBlogByTitle($sTitle)) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$this->Cache_Set($id, "blog_title_{$sTitle}", array("blog_update_{$id}",'blog_new'), 60*60*24*2);
|
2008-10-16 18:40:57 +03:00
|
|
|
|
} else {
|
2009-07-06 23:04:20 +03:00
|
|
|
|
$this->Cache_Set(null, "blog_title_{$sTitle}", array('blog_update','blog_new'), 60*60);
|
2008-10-16 18:40:57 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-24 00:35:20 +03:00
|
|
|
|
return $this->GetBlogById($id);
|
2008-10-16 18:40:57 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Создаёт персональный блог
|
|
|
|
|
*
|
|
|
|
|
* @param Entity_User $oUser
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function CreatePersonalBlog(UserEntity_User $oUser) {
|
2009-09-08 15:02:51 +03:00
|
|
|
|
$oBlog=Engine::GetEntity('Blog');
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$oBlog->setOwnerId($oUser->getId());
|
2009-04-23 16:59:40 +03:00
|
|
|
|
$oBlog->setTitle($this->Lang_Get('blogs_personal_title').' '.$oUser->getLogin());
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$oBlog->setType('personal');
|
2009-04-23 16:59:40 +03:00
|
|
|
|
$oBlog->setDescription($this->Lang_Get('blogs_personal_description'));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$oBlog->setDateAdd(date("Y-m-d H:i:s"));
|
|
|
|
|
$oBlog->setLimitRatingTopic(-1000);
|
2008-10-26 11:54:38 +02:00
|
|
|
|
$oBlog->setUrl(null);
|
|
|
|
|
$oBlog->setAvatar(0);
|
|
|
|
|
$oBlog->setAvatarType(null);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $this->AddBlog($oBlog);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Добавляет блог
|
|
|
|
|
*
|
|
|
|
|
* @param BlogEntity_Blog $oBlog
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function AddBlog(BlogEntity_Blog $oBlog) {
|
|
|
|
|
if ($sId=$this->oMapperBlog->AddBlog($oBlog)) {
|
|
|
|
|
$oBlog->setId($sId);
|
|
|
|
|
//чистим зависимые кеши
|
2009-02-06 23:24:30 +02:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('blog_new',"blog_new_user_{$oBlog->getOwnerId()}"));
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return $oBlog;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Обновляет блог
|
|
|
|
|
*
|
|
|
|
|
* @param BlogEntity_Blog $oBlog
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function UpdateBlog(BlogEntity_Blog $oBlog) {
|
|
|
|
|
$oBlog->setDateEdit(date("Y-m-d H:i:s"));
|
|
|
|
|
$res=$this->oMapperBlog->UpdateBlog($oBlog);
|
|
|
|
|
if ($res) {
|
|
|
|
|
//чистим зависимые кеши
|
2009-09-26 23:32:33 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('blog_update',"blog_update_{$oBlog->getId()}","topic_update"));
|
2009-07-26 16:43:16 +03:00
|
|
|
|
$this->Cache_Delete("blog_{$oBlog->getId()}");
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
2009-06-28 17:04:44 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляет отношение юзера к блогу, по сути присоединяет к блогу
|
|
|
|
|
*
|
|
|
|
|
* @param BlogEntity_BlogUser $oBlogUser
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function AddRelationBlogUser(BlogEntity_BlogUser $oBlogUser) {
|
2009-02-06 23:24:30 +02:00
|
|
|
|
if ($this->oMapperBlog->AddRelationBlogUser($oBlogUser)) {
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("blog_relation_change_{$oBlogUser->getUserId()}","blog_relation_change_blog_{$oBlogUser->getBlogId()}"));
|
|
|
|
|
$this->Cache_Delete("blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}");
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Удалет отношение юзера к блогу, по сути отключает от блога
|
|
|
|
|
*
|
|
|
|
|
* @param BlogEntity_BlogUser $oBlogUser
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function DeleteRelationBlogUser(BlogEntity_BlogUser $oBlogUser) {
|
2009-09-17 21:54:55 +03:00
|
|
|
|
if ($this->oMapperBlog->DeleteRelationBlogUser($oBlogUser)) {
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("blog_relation_change_{$oBlogUser->getUserId()}","blog_relation_change_blog_{$oBlogUser->getBlogId()}"));
|
|
|
|
|
$this->Cache_Delete("blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}");
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Получает список блогов по хозяину
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sUserId
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogsByOwnerId($sUserId) {
|
2009-06-13 14:32:06 +03:00
|
|
|
|
$data=$this->oMapperBlog->GetBlogsByOwnerId($sUserId);
|
|
|
|
|
$data=$this->GetBlogsAdditionalData($data);
|
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2008-10-04 00:07:32 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список всех НЕ персональных блогов
|
|
|
|
|
*
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogs() {
|
2009-06-15 00:15:11 +03:00
|
|
|
|
$data=$this->oMapperBlog->GetBlogs();
|
|
|
|
|
$data=$this->GetBlogsAdditionalData($data);
|
|
|
|
|
return $data;
|
2008-10-04 00:07:32 +03:00
|
|
|
|
}
|
2009-06-07 20:20:58 +03:00
|
|
|
|
|
2009-03-17 21:05:30 +02:00
|
|
|
|
/**
|
2009-09-22 00:08:00 +03:00
|
|
|
|
* Получает список пользователей блога.
|
|
|
|
|
* Если роль не указана, то считаем что
|
|
|
|
|
* поиск производиться по положительным значениям
|
|
|
|
|
* (статусом выше GUEST).
|
2009-03-17 21:05:30 +02:00
|
|
|
|
*
|
2009-09-22 00:08:00 +03:00
|
|
|
|
* @param string $sBlogId
|
|
|
|
|
* @param (null|int|array) $iRole
|
|
|
|
|
* @return array
|
2009-03-17 21:05:30 +02:00
|
|
|
|
*/
|
2009-06-07 20:20:58 +03:00
|
|
|
|
public function GetBlogUsersByBlogId($sBlogId,$iRole=null) {
|
2009-03-17 21:05:30 +02:00
|
|
|
|
$aFilter=array(
|
2009-06-07 20:20:58 +03:00
|
|
|
|
'blog_id'=> $sBlogId,
|
2009-03-17 21:05:30 +02:00
|
|
|
|
);
|
2009-09-17 21:54:55 +03:00
|
|
|
|
if($iRole!==null) {
|
|
|
|
|
$aFilter['user_role']=$iRole;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
}
|
|
|
|
|
$s=serialize($aFilter);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_relation_user_by_filter_$s"))) {
|
|
|
|
|
$data = $this->oMapperBlog->GetBlogUsers($aFilter);
|
|
|
|
|
$this->Cache_Set($data, "blog_relation_user_by_filter_$s", array("blog_relation_change_blog_{$sBlogId}"), 60*60*24*3);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Достаем дополнительные данные, для этого формируем список юзеров и делаем мульти-запрос
|
|
|
|
|
*/
|
|
|
|
|
if ($data) {
|
|
|
|
|
$aUserId=array();
|
|
|
|
|
foreach ($data as $oBlogUser) {
|
|
|
|
|
$aUserId[]=$oBlogUser->getUserId();
|
|
|
|
|
}
|
|
|
|
|
$aUsers=$this->User_GetUsersAdditionalData($aUserId);
|
|
|
|
|
$aBlogs=$this->Blog_GetBlogsAdditionalData($sBlogId);
|
2009-09-29 19:21:47 +03:00
|
|
|
|
|
|
|
|
|
$aResults=array();
|
2009-06-07 20:20:58 +03:00
|
|
|
|
foreach ($data as $oBlogUser) {
|
|
|
|
|
if (isset($aUsers[$oBlogUser->getUserId()])) {
|
|
|
|
|
$oBlogUser->setUser($aUsers[$oBlogUser->getUserId()]);
|
|
|
|
|
} else {
|
|
|
|
|
$oBlogUser->setUser(null);
|
|
|
|
|
}
|
|
|
|
|
if (isset($aBlogs[$oBlogUser->getBlogId()])) {
|
|
|
|
|
$oBlogUser->setBlog($aBlogs[$oBlogUser->getBlogId()]);
|
|
|
|
|
} else {
|
|
|
|
|
$oBlogUser->setBlog(null);
|
|
|
|
|
}
|
2009-09-29 19:21:47 +03:00
|
|
|
|
$aResults[$oBlogUser->getUserId()]=$oBlogUser;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
}
|
2009-09-29 19:21:47 +03:00
|
|
|
|
$data=$aResults;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
}
|
|
|
|
|
return $data;
|
2009-03-17 21:05:30 +02: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
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sUserId
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
2009-06-07 20:20:58 +03:00
|
|
|
|
public function GetBlogUsersByUserId($sUserId,$iRole=null) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aFilter=array(
|
|
|
|
|
'user_id'=> $sUserId
|
|
|
|
|
);
|
2009-09-17 21:54:55 +03:00
|
|
|
|
if($iRole!==null) {
|
|
|
|
|
$aFilter['user_role']=$iRole;
|
2009-05-06 23:14:41 +03:00
|
|
|
|
}
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$s=serialize($aFilter);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_relation_user_by_filter_$s"))) {
|
|
|
|
|
$data = $this->oMapperBlog->GetBlogUsers($aFilter);
|
|
|
|
|
$this->Cache_Set($data, "blog_relation_user_by_filter_$s", array("blog_relation_change_{$sUserId}"), 60*60*24*3);
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Достаем дополнительные данные, для этого формируем список блогов и делаем мульти-запрос
|
|
|
|
|
*/
|
|
|
|
|
if ($data) {
|
|
|
|
|
$aBlogId=array();
|
|
|
|
|
foreach ($data as $oBlogUser) {
|
|
|
|
|
$aBlogId[]=$oBlogUser->getBlogId();
|
|
|
|
|
}
|
|
|
|
|
$aUsers=$this->User_GetUsersAdditionalData($sUserId);
|
|
|
|
|
$aBlogs=$this->Blog_GetBlogsAdditionalData($aBlogId);
|
|
|
|
|
foreach ($data as $oBlogUser) {
|
|
|
|
|
if (isset($aUsers[$oBlogUser->getUserId()])) {
|
|
|
|
|
$oBlogUser->setUser($aUsers[$oBlogUser->getUserId()]);
|
|
|
|
|
} else {
|
|
|
|
|
$oBlogUser->setUser(null);
|
|
|
|
|
}
|
|
|
|
|
if (isset($aBlogs[$oBlogUser->getBlogId()])) {
|
|
|
|
|
$oBlogUser->setBlog($aBlogs[$oBlogUser->getBlogId()]);
|
|
|
|
|
} else {
|
|
|
|
|
$oBlogUser->setBlog(null);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Состоит ли юзер в конкретном блоге
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sBlogId
|
|
|
|
|
* @param unknown_type $sUserId
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
2009-06-07 20:20:58 +03:00
|
|
|
|
public function GetBlogUserByBlogIdAndUserId($sBlogId,$sUserId) {
|
|
|
|
|
if ($aBlogUser=$this->GetBlogUsersByArrayBlog($sBlogId,$sUserId)) {
|
|
|
|
|
if (isset($aBlogUser[$sBlogId])) {
|
|
|
|
|
return $aBlogUser[$sBlogId];
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-05-29 18:32:37 +03:00
|
|
|
|
return null;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получить список отношений блог-юзер по списку айдишников
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $aTopicId
|
|
|
|
|
*/
|
2009-06-07 20:20:58 +03:00
|
|
|
|
public function GetBlogUsersByArrayBlog($aBlogId,$sUserId) {
|
2009-08-08 12:33:32 +03:00
|
|
|
|
if (!$aBlogId) {
|
|
|
|
|
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->GetBlogUsersByArrayBlogSolid($aBlogId,$sUserId);
|
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (!is_array($aBlogId)) {
|
|
|
|
|
$aBlogId=array($aBlogId);
|
|
|
|
|
}
|
|
|
|
|
$aBlogId=array_unique($aBlogId);
|
2009-06-05 15:32:12 +03:00
|
|
|
|
$aBlogUsers=array();
|
|
|
|
|
$aBlogIdNotNeedQuery=array();
|
2009-06-02 22:29:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Делаем мульти-запрос к кешу
|
|
|
|
|
*/
|
2009-06-05 15:32:12 +03:00
|
|
|
|
$aCacheKeys=func_build_cache_keys($aBlogId,'blog_relation_user_','_'.$sUserId);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
if (false !== ($data = $this->Cache_Get($aCacheKeys))) {
|
|
|
|
|
/**
|
|
|
|
|
* проверяем что досталось из кеша
|
2009-06-05 15:32:12 +03:00
|
|
|
|
*/
|
|
|
|
|
foreach ($aCacheKeys as $sValue => $sKey ) {
|
|
|
|
|
if (array_key_exists($sKey,$data)) {
|
|
|
|
|
if ($data[$sKey]) {
|
|
|
|
|
$aBlogUsers[$data[$sKey]->getBlogId()]=$data[$sKey];
|
|
|
|
|
} else {
|
|
|
|
|
$aBlogIdNotNeedQuery[]=$sValue;
|
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-05 15:32:12 +03:00
|
|
|
|
}
|
2009-06-02 22:29:05 +03:00
|
|
|
|
/**
|
|
|
|
|
* Смотрим каких блогов не было в кеше и делаем запрос в БД
|
|
|
|
|
*/
|
2009-06-05 15:32:12 +03:00
|
|
|
|
$aBlogIdNeedQuery=array_diff($aBlogId,array_keys($aBlogUsers));
|
|
|
|
|
$aBlogIdNeedQuery=array_diff($aBlogIdNeedQuery,$aBlogIdNotNeedQuery);
|
|
|
|
|
$aBlogIdNeedStore=$aBlogIdNeedQuery;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
if ($data = $this->oMapperBlog->GetBlogUsersByArrayBlog($aBlogIdNeedQuery,$sUserId)) {
|
2009-06-02 22:29:05 +03:00
|
|
|
|
foreach ($data as $oBlogUser) {
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем к результату и сохраняем в кеш
|
|
|
|
|
*/
|
|
|
|
|
$aBlogUsers[$oBlogUser->getBlogId()]=$oBlogUser;
|
|
|
|
|
$this->Cache_Set($oBlogUser, "blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}", array(), 60*60*24*4);
|
2009-06-05 15:32:12 +03:00
|
|
|
|
$aBlogIdNeedStore=array_diff($aBlogIdNeedStore,array($oBlogUser->getBlogId()));
|
2009-06-02 22:29:05 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-05 15:32:12 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сохраняем в кеш запросы не вернувшие результата
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aBlogIdNeedStore as $sId) {
|
|
|
|
|
$this->Cache_Set(null, "blog_relation_user_{$sId}_{$sUserId}", array(), 60*60*24*4);
|
|
|
|
|
}
|
2009-06-23 20:06:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сортируем результат согласно входящему массиву
|
|
|
|
|
*/
|
|
|
|
|
$aBlogUsers=func_array_sort_by_keys($aBlogUsers,$aBlogId);
|
2009-06-02 22:29:05 +03:00
|
|
|
|
return $aBlogUsers;
|
2009-06-07 20:20:58 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
public function GetBlogUsersByArrayBlogSolid($aBlogId,$sUserId) {
|
|
|
|
|
if (!is_array($aBlogId)) {
|
|
|
|
|
$aBlogId=array($aBlogId);
|
|
|
|
|
}
|
|
|
|
|
$aBlogId=array_unique($aBlogId);
|
|
|
|
|
$aBlogUsers=array();
|
|
|
|
|
$s=join(',',$aBlogId);
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_relation_user_{$sUserId}_id_{$s}"))) {
|
|
|
|
|
$data = $this->oMapperBlog->GetBlogUsersByArrayBlog($aBlogId,$sUserId);
|
|
|
|
|
foreach ($data as $oBlogUser) {
|
|
|
|
|
$aBlogUsers[$oBlogUser->getBlogId()]=$oBlogUser;
|
|
|
|
|
}
|
|
|
|
|
$this->Cache_Set($aBlogUsers, "blog_relation_user_{$sUserId}_id_{$s}", array("blog_relation_change_{$sUserId}"), 60*60*24*1);
|
|
|
|
|
return $aBlogUsers;
|
|
|
|
|
}
|
|
|
|
|
return $data;
|
|
|
|
|
}
|
2008-10-16 23:26:53 +03:00
|
|
|
|
public function UpdateRelationBlogUser(BlogEntity_BlogUser $oBlogUser) {
|
2009-06-07 20:20:58 +03:00
|
|
|
|
$this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("blog_relation_change_{$oBlogUser->getUserId()}","blog_relation_change_blog_{$oBlogUser->getBlogId()}"));
|
|
|
|
|
$this->Cache_Delete("blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}");
|
2008-10-16 23:26:53 +03:00
|
|
|
|
return $this->oMapperBlog->UpdateRelationBlogUser($oBlogUser);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список блогов по рейтингу
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $iLimit
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
2009-06-09 18:55:10 +03:00
|
|
|
|
public function GetBlogsRating($iCurrPage,$iPerPage) {
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_rating_{$iCurrPage}_{$iPerPage}"))) {
|
2008-10-26 17:51:03 +02:00
|
|
|
|
$data = array('collection'=>$this->oMapperBlog->GetBlogsRating($iCount,$iCurrPage,$iPerPage),'count'=>$iCount);
|
2009-07-06 23:04:20 +03:00
|
|
|
|
$this->Cache_Set($data, "blog_rating_{$iCurrPage}_{$iPerPage}", array("blog_update","blog_new"), 60*60*24*2);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-08-08 12:33:32 +03:00
|
|
|
|
$data['collection']=$this->GetBlogsAdditionalData($data['collection'],array('owner'=>array(),'relation_user'));
|
2009-09-18 23:36:07 +03:00
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-02-06 23:24:30 +02:00
|
|
|
|
/**
|
|
|
|
|
* Список подключенных блогов по рейтингу
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sUserId
|
|
|
|
|
* @param unknown_type $iLimit
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogsRatingJoin($sUserId,$iLimit) {
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_rating_join_{$sUserId}_{$iLimit}"))) {
|
|
|
|
|
$data = $this->oMapperBlog->GetBlogsRatingJoin($sUserId,$iLimit);
|
|
|
|
|
$this->Cache_Set($data, "blog_rating_join_{$sUserId}_{$iLimit}", array('blog_update',"blog_relation_change_{$sUserId}"), 60*60*24);
|
|
|
|
|
}
|
|
|
|
|
return $data;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Список сових блогов по рейтингу
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sUserId
|
|
|
|
|
* @param unknown_type $iLimit
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetBlogsRatingSelf($sUserId,$iLimit) {
|
|
|
|
|
if (false === ($data = $this->Cache_Get("blog_rating_self_{$sUserId}_{$iLimit}"))) {
|
|
|
|
|
$data = $this->oMapperBlog->GetBlogsRatingSelf($sUserId,$iLimit);
|
|
|
|
|
$this->Cache_Set($data, "blog_rating_self_{$sUserId}_{$iLimit}", array('blog_update',"blog_new_user_{$sUserId}"), 60*60*24);
|
|
|
|
|
}
|
|
|
|
|
return $data;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-06-15 00:15:11 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получает список блогов в которые может постить юзер
|
|
|
|
|
*
|
2009-06-20 16:54:24 +03:00
|
|
|
|
* @param unknown_type $oUser
|
2009-06-15 00:15:11 +03:00
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
2009-06-20 16:54:24 +03:00
|
|
|
|
public function GetBlogsAllowByUser($oUser) {
|
2009-06-15 00:15:11 +03:00
|
|
|
|
if ($oUser->isAdministrator()) {
|
|
|
|
|
return $this->GetBlogs();
|
|
|
|
|
} else {
|
|
|
|
|
$aAllowBlogsUser=$this->GetBlogsByOwnerId($oUser->getId());
|
|
|
|
|
$aBlogUsers=$this->GetBlogUsersByUserId($oUser->getId());
|
|
|
|
|
foreach ($aBlogUsers as $oBlogUser) {
|
|
|
|
|
$oBlog=$oBlogUser->getBlog();
|
2009-06-20 16:54:24 +03:00
|
|
|
|
if ($this->ACL_CanAddTopic($oUser,$oBlog) or $oBlogUser->getIsAdministrator() or $oBlogUser->getIsModerator()) {
|
2009-06-15 00:15:11 +03:00
|
|
|
|
$aAllowBlogsUser[$oBlog->getId()]=$oBlog;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return $aAllowBlogsUser;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-20 16:54:24 +03:00
|
|
|
|
/**
|
|
|
|
|
* Проверяет можно или нет юзеру постить в данный блог
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $oBlog
|
|
|
|
|
* @param unknown_type $oUser
|
|
|
|
|
* @param unknown_type $sBlogIdAllow
|
|
|
|
|
*/
|
|
|
|
|
public function IsAllowBlog($oBlog,$oUser) {
|
|
|
|
|
if ($oUser->isAdministrator()) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
if ($oBlog->getOwnerId()==$oUser->getId()) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
if ($oBlogUser=$this->GetBlogUserByBlogIdAndUserId($oBlog->getId(),$oUser->getId())) {
|
|
|
|
|
if ($this->ACL_CanAddTopic($oUser,$oBlog) or $oBlogUser->getIsAdministrator() or $oBlogUser->getIsModerator()) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2009-09-18 23:36:07 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем массив блогов,
|
|
|
|
|
* которые являются открытыми для пользователя
|
|
|
|
|
*
|
|
|
|
|
* @param UserEntity_User $oUser
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
2009-09-20 21:43:20 +03:00
|
|
|
|
public function GetAccessibleBlogsByUser($oUser) {
|
2009-09-18 23:36:07 +03:00
|
|
|
|
if ($oUser->isAdministrator()) {
|
|
|
|
|
return $this->GetBlogs();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Заносим блоги, созданные пользователем
|
|
|
|
|
*/
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aOpenBlogsUser=array();
|
2009-09-18 23:36:07 +03:00
|
|
|
|
$aOpenBlogsUser=$this->GetBlogsByOwnerId($oUser->getId());
|
|
|
|
|
|
|
|
|
|
/**
|
2009-09-20 16:26:09 +03:00
|
|
|
|
* Добавляем блоги, в которых состоит пользователь
|
2009-09-18 23:36:07 +03:00
|
|
|
|
* (читателем, модератором, или администратором)
|
|
|
|
|
*/
|
2009-09-29 01:31:49 +03:00
|
|
|
|
$aBlogUsers=$this->GetBlogUsersByUserId($oUser->getId());
|
2009-09-18 23:36:07 +03:00
|
|
|
|
foreach ($aBlogUsers as $oBlogUser) {
|
|
|
|
|
$oBlog=$oBlogUser->getBlog();
|
|
|
|
|
if($oBlogUser->getUserRole()>self::BLOG_USER_ROLE_GUEST) {
|
|
|
|
|
$aOpenBlogsUser[$oBlog->getId()]=$oBlog;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-09-22 00:08:00 +03:00
|
|
|
|
|
2009-09-18 23:36:07 +03:00
|
|
|
|
return $aOpenBlogsUser;
|
|
|
|
|
}
|
2009-09-19 03:43:00 +03:00
|
|
|
|
|
|
|
|
|
/**
|
2009-09-19 17:48:28 +03:00
|
|
|
|
* Получаем массив идентификаторов блогов,
|
2009-09-19 03:43:00 +03:00
|
|
|
|
* которые являются закрытыми для пользователя
|
|
|
|
|
*
|
|
|
|
|
* @param UserEntity_User $oUser
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
2009-09-20 21:43:20 +03:00
|
|
|
|
public function GetInaccessibleBlogsByUser($oUser=null) {
|
2009-09-19 17:48:28 +03:00
|
|
|
|
if ($oUser&&$oUser->isAdministrator()) {
|
2009-09-19 03:43:00 +03:00
|
|
|
|
return array();
|
|
|
|
|
}
|
2009-09-20 21:43:20 +03:00
|
|
|
|
$aCloseBlogs=array();
|
2009-09-19 17:48:28 +03:00
|
|
|
|
$aCloseBlogs = $this->oMapperBlog->GetCloseBlogs();
|
|
|
|
|
|
|
|
|
|
if(!$oUser) {
|
|
|
|
|
return $aCloseBlogs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Получаем массив идентификаторов блогов,
|
|
|
|
|
* которые являются откытыми для данного пользователя
|
|
|
|
|
*/
|
|
|
|
|
$aOpenBlogs = array();
|
|
|
|
|
$aBlogUsers=$this->GetBlogUsersByUserId($oUser->getId());
|
|
|
|
|
foreach ($aBlogUsers as $oBlogUser) {
|
|
|
|
|
$oBlog=$oBlogUser->getBlog();
|
|
|
|
|
if($oBlogUser->getUserRole()>self::BLOG_USER_ROLE_GUEST) {
|
|
|
|
|
$aOpenBlogs[]=$oBlog->getId();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return array_diff($aCloseBlogs,$aOpenBlogs);
|
2009-09-19 03:43:00 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
?>
|