root/trunk/classes/modules/blog/Blog.class.php

Revision 1353, 28.0 KB (checked in by ort, 9 months ago)

fix сортировки блогов в настройках ленты
Line 
1<?php
2/*-------------------------------------------------------
3*
4*   LiveStreet Engine Social Networking
5*   Copyright © 2008 Mzhelskiy Maxim
6*
7*--------------------------------------------------------
8*
9*   Official site: www.livestreet.ru
10*   Contact e-mail: rus.engine@gmail.com
11*
12*   GNU General Public License, version 2:
13*   http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
14*
15---------------------------------------------------------
16*/
17
18/**
19 * Модуль для работы с блогами
20 *
21 */
22class ModuleBlog extends Module {
23        /**
24         * Возможные роли пользователя в блоге
25         */
26        const BLOG_USER_ROLE_GUEST         = 0;
27        const BLOG_USER_ROLE_USER          = 1;
28        const BLOG_USER_ROLE_MODERATOR     = 2;
29        const BLOG_USER_ROLE_ADMINISTRATOR = 4;
30        /**
31         * Пользователь, приглашенный админом блога в блог
32         */
33        const BLOG_USER_ROLE_INVITE        = -1;
34        /**
35         * Пользователь, отклонивший приглашение админа
36         */
37        const BLOG_USER_ROLE_REJECT        = -2;
38        /**
39         * Забаненный в блоге пользователь
40         */
41        const BLOG_USER_ROLE_BAN           = -4;
42       
43        protected $oMapperBlog; 
44        protected $oUserCurrent=null;
45               
46        /**
47         * Инициализация
48         *
49         */
50        public function Init() {
51                $this->oMapperBlog=Engine::GetMapper(__CLASS__);
52                $this->oMapperBlog->SetUserCurrent($this->User_GetUserCurrent());
53                $this->oUserCurrent=$this->User_GetUserCurrent();               
54        }
55        /**
56         * Получает дополнительные данные(объекты) для блогов по их ID
57         *
58         */
59        public function GetBlogsAdditionalData($aBlogId,$aAllowData=array('vote','owner'=>array(),'relation_user'),$aOrder=null) {
60                func_array_simpleflip($aAllowData);
61                if (!is_array($aBlogId)) {
62                        $aBlogId=array($aBlogId);
63                }
64                /**
65                 * Получаем блоги
66                 */
67                $aBlogs=$this->GetBlogsByArrayId($aBlogId,$aOrder);
68                /**
69                 * Формируем ID дополнительных данных, которые нужно получить
70                 */
71                $aUserId=array();               
72                foreach ($aBlogs as $oBlog) {
73                        if (isset($aAllowData['owner'])) {
74                                $aUserId[]=$oBlog->getOwnerId();
75                        }                                               
76                }
77                /**
78                 * Получаем дополнительные данные
79                 */
80                $aBlogUsers=array();
81                $aBlogsVote=array();
82                $aUsers=isset($aAllowData['owner']) && is_array($aAllowData['owner']) ? $this->User_GetUsersAdditionalData($aUserId,$aAllowData['owner']) : $this->User_GetUsersAdditionalData($aUserId);                               
83                if (isset($aAllowData['relation_user']) and $this->oUserCurrent) {
84                        $aBlogUsers=$this->GetBlogUsersByArrayBlog($aBlogId,$this->oUserCurrent->getId());     
85                }
86                if (isset($aAllowData['vote']) and $this->oUserCurrent) {                       
87                        $aBlogsVote=$this->Vote_GetVoteByArray($aBlogId,'blog',$this->oUserCurrent->getId());
88                }
89                /**
90                 * Добавляем данные к результату - списку блогов
91                 */
92                foreach ($aBlogs as $oBlog) {
93                        if (isset($aUsers[$oBlog->getOwnerId()])) {
94                                $oBlog->setOwner($aUsers[$oBlog->getOwnerId()]);
95                        } else {
96                                $oBlog->setOwner(null); // или $oBlog->setOwner(new ModuleUser_EntityUser());
97                        }
98                        if (isset($aBlogUsers[$oBlog->getId()])) {
99                                $oBlog->setUserIsJoin(true);
100                                $oBlog->setUserIsAdministrator($aBlogUsers[$oBlog->getId()]->getIsAdministrator());
101                                $oBlog->setUserIsModerator($aBlogUsers[$oBlog->getId()]->getIsModerator());
102                        } else {
103                                $oBlog->setUserIsJoin(false);
104                                $oBlog->setUserIsAdministrator(false);
105                                $oBlog->setUserIsModerator(false);
106                        }
107                        if (isset($aBlogsVote[$oBlog->getId()])) {
108                                $oBlog->setVote($aBlogsVote[$oBlog->getId()]);                         
109                        } else {
110                                $oBlog->setVote(null);
111                        }
112                }
113               
114                return $aBlogs;
115        }
116        /**
117         * Список блогов по ID
118         *
119         * @param array $aUserId
120         */
121        public function GetBlogsByArrayId($aBlogId,$aOrder=null) {
122                if (!$aBlogId) {
123                        return array();
124                }
125                if (Config::Get('sys.cache.solid')) {
126                        return $this->GetBlogsByArrayIdSolid($aBlogId,$aOrder);
127                }
128                if (!is_array($aBlogId)) {
129                        $aBlogId=array($aBlogId);
130                }
131                $aBlogId=array_unique($aBlogId);
132                $aBlogs=array();
133                $aBlogIdNotNeedQuery=array();
134                /**
135                 * Делаем мульти-запрос к кешу
136                 */
137                $aCacheKeys=func_build_cache_keys($aBlogId,'blog_');
138                if (false !== ($data = $this->Cache_Get($aCacheKeys))) {                       
139                        /**
140                         * проверяем что досталось из кеша
141                         */
142                        foreach ($aCacheKeys as $sValue => $sKey ) {
143                                if (array_key_exists($sKey,$data)) {   
144                                        if ($data[$sKey]) {
145                                                $aBlogs[$data[$sKey]->getId()]=$data[$sKey];
146                                        } else {
147                                                $aBlogIdNotNeedQuery[]=$sValue;
148                                        }
149                                } 
150                        }
151                }
152                /**
153                 * Смотрим каких блогов не было в кеше и делаем запрос в БД
154                 */             
155                $aBlogIdNeedQuery=array_diff($aBlogId,array_keys($aBlogs));             
156                $aBlogIdNeedQuery=array_diff($aBlogIdNeedQuery,$aBlogIdNotNeedQuery);           
157                $aBlogIdNeedStore=$aBlogIdNeedQuery;
158                if ($data = $this->oMapperBlog->GetBlogsByArrayId($aBlogIdNeedQuery)) {
159                        foreach ($data as $oBlog) {
160                                /**
161                                 * Добавляем к результату и сохраняем в кеш
162                                 */
163                                $aBlogs[$oBlog->getId()]=$oBlog;
164                                $this->Cache_Set($oBlog, "blog_{$oBlog->getId()}", array(), 60*60*24*4);
165                                $aBlogIdNeedStore=array_diff($aBlogIdNeedStore,array($oBlog->getId()));
166                        }
167                }
168                /**
169                 * Сохраняем в кеш запросы не вернувшие результата
170                 */
171                foreach ($aBlogIdNeedStore as $sId) {
172                        $this->Cache_Set(null, "blog_{$sId}", array(), 60*60*24*4);
173                }               
174                /**
175                 * Сортируем результат согласно входящему массиву
176                 */
177                $aBlogs=func_array_sort_by_keys($aBlogs,$aBlogId);
178                return $aBlogs;         
179        }
180        /**
181         * Список блогов по ID, но используя единый кеш
182         *
183         * @param unknown_type $aBlogId
184         * @return unknown
185         */
186        public function GetBlogsByArrayIdSolid($aBlogId,$aOrder=null) {
187                if (!is_array($aBlogId)) {
188                        $aBlogId=array($aBlogId);
189                }
190                $aBlogId=array_unique($aBlogId);       
191                $aBlogs=array();       
192                $s=join(',',$aBlogId);
193                if (false === ($data = $this->Cache_Get("blog_id_{$s}"))) {                     
194                        $data = $this->oMapperBlog->GetBlogsByArrayId($aBlogId,$aOrder);
195                        foreach ($data as $oBlog) {
196                                $aBlogs[$oBlog->getId()]=$oBlog;
197                        }
198                        $this->Cache_Set($aBlogs, "blog_id_{$s}", array("blog_update"), 60*60*24*1);
199                        return $aBlogs;
200                }               
201                return $data;
202        }
203        /**
204         * Получить персональный блог юзера
205         *
206         * @param Entity_User $oUser
207         * @return unknown
208         */
209        public function GetPersonalBlogByUserId($sUserId) {
210                $id=$this->oMapperBlog->GetPersonalBlogByUserId($sUserId);
211                return $this->GetBlogById($id);
212        }
213        /**
214         * Получить блог по айдишнику(номеру)
215         *
216         * @param unknown_type $sBlogId
217         * @return unknown
218         */
219        public function GetBlogById($sBlogId) {
220                $aBlogs=$this->GetBlogsAdditionalData($sBlogId);
221                if (isset($aBlogs[$sBlogId])) {
222                        return $aBlogs[$sBlogId];
223                }
224                return null;           
225        }
226        /**
227         * Получить блог по УРЛу
228         *
229         * @param unknown_type $sBlogUrl
230         * @return unknown
231         */
232        public function GetBlogByUrl($sBlogUrl) {               
233                if (false === ($id = $this->Cache_Get("blog_url_{$sBlogUrl}"))) {                                               
234                        if ($id = $this->oMapperBlog->GetBlogByUrl($sBlogUrl)) {                               
235                                $this->Cache_Set($id, "blog_url_{$sBlogUrl}", array("blog_update_{$id}"), 60*60*24*2);                         
236                        } else {
237                                $this->Cache_Set(null, "blog_url_{$sBlogUrl}", array('blog_update','blog_new'), 60*60);
238                        }
239                }               
240                return $this->GetBlogById($id);         
241        }
242        /**
243         * Получить блог по названию
244         *
245         * @param unknown_type $sTitle
246         * @return unknown
247         */
248        public function GetBlogByTitle($sTitle) {               
249                if (false === ($id = $this->Cache_Get("blog_title_{$sTitle}"))) {                                               
250                        if ($id = $this->oMapperBlog->GetBlogByTitle($sTitle)) {                               
251                                $this->Cache_Set($id, "blog_title_{$sTitle}", array("blog_update_{$id}",'blog_new'), 60*60*24*2);                               
252                        } else {
253                                $this->Cache_Set(null, "blog_title_{$sTitle}", array('blog_update','blog_new'), 60*60);
254                        }
255                }
256                return $this->GetBlogById($id);         
257        }
258        /**
259         * Создаёт персональный блог
260         *
261         * @param Entity_User $oUser
262         * @return unknown
263         */
264        public function CreatePersonalBlog(ModuleUser_EntityUser $oUser) {
265                $oBlog=Engine::GetEntity('Blog');
266                $oBlog->setOwnerId($oUser->getId());
267                $oBlog->setTitle($this->Lang_Get('blogs_personal_title').' '.$oUser->getLogin());
268                $oBlog->setType('personal');
269                $oBlog->setDescription($this->Lang_Get('blogs_personal_description'));
270                $oBlog->setDateAdd(date("Y-m-d H:i:s")); 
271                $oBlog->setLimitRatingTopic(-1000);
272                $oBlog->setUrl(null);   
273                $oBlog->setAvatar(null);
274                return $this->AddBlog($oBlog);         
275        }
276        /**
277         * Добавляет блог
278         *
279         * @param ModuleBlog_EntityBlog $oBlog
280         * @return unknown
281         */
282        public function AddBlog(ModuleBlog_EntityBlog $oBlog) {         
283                if ($sId=$this->oMapperBlog->AddBlog($oBlog)) {
284                        $oBlog->setId($sId);
285                        //чистим зависимые кеши
286                        $this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('blog_new',"blog_new_user_{$oBlog->getOwnerId()}"));                                           
287                        return $oBlog;
288                }
289                return false;
290        }
291        /**
292         * Обновляет блог
293         *
294         * @param ModuleBlog_EntityBlog $oBlog
295         * @return unknown
296         */
297        public function UpdateBlog(ModuleBlog_EntityBlog $oBlog) {
298                $oBlog->setDateEdit(date("Y-m-d H:i:s"));
299                $res=$this->oMapperBlog->UpdateBlog($oBlog);           
300                if ($res) {                     
301                        //чистим зависимые кеши
302                        $this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array('blog_update',"blog_update_{$oBlog->getId()}","topic_update"));
303                        $this->Cache_Delete("blog_{$oBlog->getId()}");
304                        return true;
305                }
306                return false;
307        }       
308        /**
309         * Добавляет отношение юзера к блогу, по сути присоединяет к блогу
310         *
311         * @param ModuleBlog_EntityBlogUser $oBlogUser
312         * @return unknown
313         */
314        public function AddRelationBlogUser(ModuleBlog_EntityBlogUser $oBlogUser) {
315                if ($this->oMapperBlog->AddRelationBlogUser($oBlogUser)) {             
316                        $this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("blog_relation_change_{$oBlogUser->getUserId()}","blog_relation_change_blog_{$oBlogUser->getBlogId()}"));       
317                        $this->Cache_Delete("blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}"); 
318                        return true;
319                }
320                return false;
321        }
322        /**
323         * Удалет отношение юзера к блогу, по сути отключает от блога
324         *
325         * @param ModuleBlog_EntityBlogUser $oBlogUser
326         * @return unknown
327         */
328        public function DeleteRelationBlogUser(ModuleBlog_EntityBlogUser $oBlogUser) {
329                if ($this->oMapperBlog->DeleteRelationBlogUser($oBlogUser)) {
330                        $this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("blog_relation_change_{$oBlogUser->getUserId()}","blog_relation_change_blog_{$oBlogUser->getBlogId()}"));               
331                        $this->Cache_Delete("blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}");
332                        return true;
333                }
334                return false;
335        }
336        /**
337         * Получает список блогов по хозяину
338         *
339         * @param unknown_type $sUserId
340         * @return unknown
341         */
342        public function GetBlogsByOwnerId($sUserId,$bReturnIdOnly=false) {
343                $data=$this->oMapperBlog->GetBlogsByOwnerId($sUserId);
344                /**
345                 * Возвращаем только иденитификаторы
346                 */
347                if($bReturnIdOnly) return $data;
348               
349                $data=$this->GetBlogsAdditionalData($data);
350                return $data;
351        }
352        /**
353         * Получает список всех НЕ персональных блогов
354         *
355         * @return unknown
356         */
357        public function GetBlogs($bReturnIdOnly=false) {
358                $data=$this->oMapperBlog->GetBlogs();
359                /**
360                 * Возвращаем только иденитификаторы
361                 */
362                if($bReturnIdOnly) return $data;
363                               
364                $data=$this->GetBlogsAdditionalData($data);
365                return $data;
366        }
367               
368        /**
369         * Получает список пользователей блога.
370         * Если роль не указана, то считаем что
371         * поиск производиться по положительным значениям
372         * (статусом выше GUEST).
373         *
374         * @param  string           $sBlogId
375         * @param  (null|int|array) $iRole
376         * @return array
377         */
378        public function GetBlogUsersByBlogId($sBlogId,$iRole=null,$iPage=1,$iPerPage=100) {
379                $aFilter=array(
380                        'blog_id'=> $sBlogId,                   
381                );
382                if($iRole!==null) {
383                        $aFilter['user_role']=$iRole;   
384                }
385                $s=serialize($aFilter);
386                if (false === ($data = $this->Cache_Get("blog_relation_user_by_filter_{$s}_{$iPage}_{$iPerPage}"))) {                           
387                        $data = array('collection'=>$this->oMapperBlog->GetBlogUsers($aFilter,$iCount,$iPage,$iPerPage),'count'=>$iCount);
388                        $this->Cache_Set($data, "blog_relation_user_by_filter_{$s}_{$iPage}_{$iPerPage}", array("blog_relation_change_blog_{$sBlogId}"), 60*60*24*3);
389                }
390                /**
391                 * Достаем дополнительные данные, для этого формируем список юзеров и делаем мульти-запрос
392                 */
393                if ($data['collection']) {
394                        $aUserId=array();
395                        foreach ($data['collection'] as $oBlogUser) {
396                                $aUserId[]=$oBlogUser->getUserId();
397                        }
398                        $aUsers=$this->User_GetUsersAdditionalData($aUserId);
399                        $aBlogs=$this->Blog_GetBlogsAdditionalData($sBlogId);
400                       
401                        $aResults=array();
402                        foreach ($data['collection'] as $oBlogUser) {
403                                if (isset($aUsers[$oBlogUser->getUserId()])) {
404                                        $oBlogUser->setUser($aUsers[$oBlogUser->getUserId()]);
405                                } else {
406                                        $oBlogUser->setUser(null);
407                                }
408                                if (isset($aBlogs[$oBlogUser->getBlogId()])) {
409                                        $oBlogUser->setBlog($aBlogs[$oBlogUser->getBlogId()]);
410                                } else {
411                                        $oBlogUser->setBlog(null);
412                                }
413                                $aResults[$oBlogUser->getUserId()]=$oBlogUser;
414                        }
415                        $data['collection']=$aResults;
416                }
417                return $data;           
418        }
419        /**
420         * Получает отношения юзера к блогам(состоит в блоге или нет)
421         *
422         * @param unknown_type $sUserId
423         * @return unknown
424         */
425        public function GetBlogUsersByUserId($sUserId,$iRole=null,$bReturnIdOnly=false) {
426                $aFilter=array(
427                        'user_id'=> $sUserId
428                );
429                if($iRole!==null) {
430                        $aFilter['user_role']=$iRole;
431                }
432                $s=serialize($aFilter);
433                if (false === ($data = $this->Cache_Get("blog_relation_user_by_filter_$s"))) {                         
434                        $data = $this->oMapperBlog->GetBlogUsers($aFilter);
435                        $this->Cache_Set($data, "blog_relation_user_by_filter_$s", array("blog_update", "blog_relation_change_{$sUserId}"), 60*60*24*3);
436                }
437                /**
438                 * Достаем дополнительные данные, для этого формируем список блогов и делаем мульти-запрос
439                 */
440                $aBlogId=array();               
441                if ($data) {
442                        foreach ($data as $oBlogUser) {
443                                $aBlogId[]=$oBlogUser->getBlogId();
444                        }
445                       
446                        /**
447                         * Если указано возвращать полные объекты
448                         */
449                        if(!$bReturnIdOnly) {
450                                $aUsers=$this->User_GetUsersAdditionalData($sUserId);
451                                $aBlogs=$this->Blog_GetBlogsAdditionalData($aBlogId);
452                                foreach ($data as $oBlogUser) {
453                                        if (isset($aUsers[$oBlogUser->getUserId()])) {
454                                                $oBlogUser->setUser($aUsers[$oBlogUser->getUserId()]);
455                                        } else {
456                                                $oBlogUser->setUser(null);
457                                        }
458                                        if (isset($aBlogs[$oBlogUser->getBlogId()])) {
459                                                $oBlogUser->setBlog($aBlogs[$oBlogUser->getBlogId()]);
460                                        } else {
461                                                $oBlogUser->setBlog(null);
462                                        }
463                                }                               
464                        }
465                }
466                return ($bReturnIdOnly) ? $aBlogId : $data;
467        }
468        /**
469         * Состоит ли юзер в конкретном блоге
470         *
471         * @param unknown_type $sBlogId
472         * @param unknown_type $sUserId
473         * @return unknown
474         */
475        public function GetBlogUserByBlogIdAndUserId($sBlogId,$sUserId) {               
476                if ($aBlogUser=$this->GetBlogUsersByArrayBlog($sBlogId,$sUserId)) {
477                        if (isset($aBlogUser[$sBlogId])) {
478                                return $aBlogUser[$sBlogId];
479                        }
480                }
481                return null;
482        }
483        /**
484         * Получить список отношений блог-юзер по списку айдишников
485         *
486         * @param unknown_type $aTopicId
487         */
488        public function GetBlogUsersByArrayBlog($aBlogId,$sUserId) {
489                if (!$aBlogId) {
490                        return array();
491                }
492                if (Config::Get('sys.cache.solid')) {
493                        return $this->GetBlogUsersByArrayBlogSolid($aBlogId,$sUserId);
494                }
495                if (!is_array($aBlogId)) {
496                        $aBlogId=array($aBlogId);
497                }
498                $aBlogId=array_unique($aBlogId);
499                $aBlogUsers=array();
500                $aBlogIdNotNeedQuery=array();
501                /**
502                 * Делаем мульти-запрос к кешу
503                 */
504                $aCacheKeys=func_build_cache_keys($aBlogId,'blog_relation_user_','_'.$sUserId);
505                if (false !== ($data = $this->Cache_Get($aCacheKeys))) {                       
506                        /**
507                         * проверяем что досталось из кеша
508                         */
509                        foreach ($aCacheKeys as $sValue => $sKey ) {
510                                if (array_key_exists($sKey,$data)) {   
511                                        if ($data[$sKey]) {
512                                                $aBlogUsers[$data[$sKey]->getBlogId()]=$data[$sKey];
513                                        } else {
514                                                $aBlogIdNotNeedQuery[]=$sValue;
515                                        }
516                                } 
517                        }
518                }
519                /**
520                 * Смотрим каких блогов не было в кеше и делаем запрос в БД
521                 */             
522                $aBlogIdNeedQuery=array_diff($aBlogId,array_keys($aBlogUsers));         
523                $aBlogIdNeedQuery=array_diff($aBlogIdNeedQuery,$aBlogIdNotNeedQuery);           
524                $aBlogIdNeedStore=$aBlogIdNeedQuery;
525                if ($data = $this->oMapperBlog->GetBlogUsersByArrayBlog($aBlogIdNeedQuery,$sUserId)) {
526                        foreach ($data as $oBlogUser) {
527                                /**
528                                 * Добавляем к результату и сохраняем в кеш
529                                 */
530                                $aBlogUsers[$oBlogUser->getBlogId()]=$oBlogUser;
531                                $this->Cache_Set($oBlogUser, "blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}", array(), 60*60*24*4);
532                                $aBlogIdNeedStore=array_diff($aBlogIdNeedStore,array($oBlogUser->getBlogId()));
533                        }
534                }
535                /**
536                 * Сохраняем в кеш запросы не вернувшие результата
537                 */
538                foreach ($aBlogIdNeedStore as $sId) {
539                        $this->Cache_Set(null, "blog_relation_user_{$sId}_{$sUserId}", array(), 60*60*24*4);
540                }               
541                /**
542                 * Сортируем результат согласно входящему массиву
543                 */
544                $aBlogUsers=func_array_sort_by_keys($aBlogUsers,$aBlogId);
545                return $aBlogUsers;             
546        }       
547        public function GetBlogUsersByArrayBlogSolid($aBlogId,$sUserId) {
548                if (!is_array($aBlogId)) {
549                        $aBlogId=array($aBlogId);
550                }
551                $aBlogId=array_unique($aBlogId);       
552                $aBlogUsers=array();   
553                $s=join(',',$aBlogId);
554                if (false === ($data = $this->Cache_Get("blog_relation_user_{$sUserId}_id_{$s}"))) {                   
555                        $data = $this->oMapperBlog->GetBlogUsersByArrayBlog($aBlogId,$sUserId);
556                        foreach ($data as $oBlogUser) {
557                                $aBlogUsers[$oBlogUser->getBlogId()]=$oBlogUser;
558                        }
559                        $this->Cache_Set($aBlogUsers, "blog_relation_user_{$sUserId}_id_{$s}", array("blog_update", "blog_relation_change_{$sUserId}"), 60*60*24*1);
560                        return $aBlogUsers;
561                }               
562                return $data;
563        }
564        public function UpdateRelationBlogUser(ModuleBlog_EntityBlogUser $oBlogUser) {
565                $this->Cache_Clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG,array("blog_relation_change_{$oBlogUser->getUserId()}","blog_relation_change_blog_{$oBlogUser->getBlogId()}"));               
566                $this->Cache_Delete("blog_relation_user_{$oBlogUser->getBlogId()}_{$oBlogUser->getUserId()}");
567                return $this->oMapperBlog->UpdateRelationBlogUser($oBlogUser);
568        }
569        /**
570         * Получает список блогов по рейтингу
571         *
572         * @param unknown_type $iLimit
573         * @return unknown
574         */
575        public function GetBlogsRating($iCurrPage,$iPerPage) {         
576                if (false === ($data = $this->Cache_Get("blog_rating_{$iCurrPage}_{$iPerPage}"))) {                             
577                        $data = array('collection'=>$this->oMapperBlog->GetBlogsRating($iCount,$iCurrPage,$iPerPage),'count'=>$iCount);
578                        $this->Cache_Set($data, "blog_rating_{$iCurrPage}_{$iPerPage}", array("blog_update","blog_new"), 60*60*24*2);
579                }
580                $data['collection']=$this->GetBlogsAdditionalData($data['collection'],array('owner'=>array(),'relation_user'));
581                return $data;
582        }
583        /**
584         * Список подключенных блогов по рейтингу
585         *
586         * @param unknown_type $sUserId
587         * @param unknown_type $iLimit
588         * @return unknown
589         */
590        public function GetBlogsRatingJoin($sUserId,$iLimit) {         
591                if (false === ($data = $this->Cache_Get("blog_rating_join_{$sUserId}_{$iLimit}"))) {                           
592                        $data = $this->oMapperBlog->GetBlogsRatingJoin($sUserId,$iLimit);                       
593                        $this->Cache_Set($data, "blog_rating_join_{$sUserId}_{$iLimit}", array('blog_update',"blog_relation_change_{$sUserId}"), 60*60*24);
594                }
595                return $data;           
596        }
597        /**
598         * Список сових блогов по рейтингу
599         *
600         * @param unknown_type $sUserId
601         * @param unknown_type $iLimit
602         * @return unknown
603         */
604        public function GetBlogsRatingSelf($sUserId,$iLimit) {         
605                if (false === ($data = $this->Cache_Get("blog_rating_self_{$sUserId}_{$iLimit}"))) {                           
606                        $data = $this->oMapperBlog->GetBlogsRatingSelf($sUserId,$iLimit);                       
607                        $this->Cache_Set($data, "blog_rating_self_{$sUserId}_{$iLimit}", array('blog_update',"blog_new_user_{$sUserId}"), 60*60*24);
608                }
609                return $data;           
610        }       
611        /**
612         * Получает список блогов в которые может постить юзер
613         *
614         * @param unknown_type $oUser   
615         * @return unknown
616         */
617        public function GetBlogsAllowByUser($oUser) {           
618                if ($oUser->isAdministrator()) {
619                        return $this->GetBlogs();
620                } else {                                               
621                        $aAllowBlogsUser=$this->GetBlogsByOwnerId($oUser->getId());
622                        $aBlogUsers=$this->GetBlogUsersByUserId($oUser->getId());                       
623                        foreach ($aBlogUsers as $oBlogUser) {
624                                $oBlog=$oBlogUser->getBlog();
625                                if ($this->ACL_CanAddTopic($oUser,$oBlog) or $oBlogUser->getIsAdministrator() or $oBlogUser->getIsModerator()) {
626                                        $aAllowBlogsUser[$oBlog->getId()]=$oBlog;
627                                }
628                        }
629                        return  $aAllowBlogsUser;
630                }               
631        }       
632
633        /**
634         * Получаем массив блогов,
635         * которые являются открытыми для пользователя
636         *
637         * @param  ModuleUser_EntityUser $oUser
638         * @return array
639         */
640        public function GetAccessibleBlogsByUser($oUser) {
641                if ($oUser->isAdministrator()) {
642                        return $this->GetBlogs(true);
643                }
644               
645                if (false === ($aOpenBlogsUser = $this->Cache_Get("blog_accessible_user_{$oUser->getId()}"))) {
646                        /**
647                        * Заносим блоги, созданные пользователем
648                        */
649                        $aOpenBlogsUser=array();
650                        $aOpenBlogsUser=$this->GetBlogsByOwnerId($oUser->getId(),true);
651                        /**
652                        * Добавляем блоги, в которых состоит пользователь
653                        * (читателем, модератором, или администратором)
654                        */
655                        $aOpenBlogsUser=array_merge($aOpenBlogsUser,$this->GetBlogUsersByUserId($oUser->getId(),null,true));
656                        $this->Cache_Set($aOpenBlogsUser, "blog_accessible_user_{$oUser->getId()}", array('blog_new','blog_update',"blog_relation_change_{$oUser->getId()}"), 60*60*24);
657                }
658                return $aOpenBlogsUser;
659        }
660
661        /**
662         * Получаем массив идентификаторов блогов,
663         * которые являются закрытыми для пользователя
664         *
665         * @param  ModuleUser_EntityUser $oUser
666         * @return array
667         */     
668        public function GetInaccessibleBlogsByUser($oUser=null) {
669                if ($oUser&&$oUser->isAdministrator()) {
670                        return array();
671                }
672               
673                $sUserId=$oUser ? $oUser->getId() : 'quest';           
674                if (false === ($aCloseBlogs = $this->Cache_Get("blog_inaccessible_user_{$sUserId}"))) {
675                        $aCloseBlogs=array();
676                        $aCloseBlogs = $this->oMapperBlog->GetCloseBlogs();
677
678                        if($oUser) {
679                                /**
680                                * Получаем массив идентификаторов блогов,
681                                * которые являются откытыми для данного пользователя
682                                */
683                                $aOpenBlogs = array();
684                                $aOpenBlogs=$this->GetBlogUsersByUserId($oUser->getId(),null,true);
685                               
686                                $aCloseBlogs=array_diff($aCloseBlogs,$aOpenBlogs);
687                        }
688
689                        // Сохраняем в кеш
690                        if ($oUser) {
691                                $this->Cache_Set($aCloseBlogs, "blog_inaccessible_user_{$sUserId}", array('blog_new','blog_update',"blog_relation_change_{$oUser->getId()}"), 60*60*24);               
692                        } else {
693                                $this->Cache_Set($aCloseBlogs, "blog_inaccessible_user_{$sUserId}", array('blog_new','blog_update'), 60*60*24*3);
694                        }
695                }
696                return $aCloseBlogs;
697        }
698       
699        /**
700         * Удаляет блог
701         *
702         * @param  int $iBlogId
703         * @return bool
704         */
705        public function DeleteBlog($iBlogId) {
706                if($iBlogId instanceof ModuleBlog_EntityBlog){
707                        $iBlogId = $iBlogId->getId();
708                }
709                /**
710                 * Получаем идентификаторы топиков блога. Удаляем топики блога.
711                 * При удалении топиков удаляются комментарии к ним и голоса.
712                 */
713                $aTopicIds = $this->Topic_GetTopicsByBlogId($iBlogId);         
714                /**
715                 * Если блог не удален, возвращаем false
716                 */
717                if(!$this->oMapperBlog->DeleteBlog($iBlogId)) { return false; }
718                /**
719                 * Чистим кеш
720                 */
721                $this->Cache_Clean(
722                        Zend_Cache::CLEANING_MODE_MATCHING_TAG,
723                        array(
724                                "blog_update", "blog_relation_change_blog_{$iBlogId}",
725                                "topic_update", "comment_online_update_topic", "comment_update"
726                        )
727                );
728                $this->Cache_Delete("blog_{$iBlogId}");
729               
730                if(is_array($aTopicIds) and count($aTopicIds)) {
731                        /**
732                         * Удаляем топики
733                         */
734                        foreach ($aTopicIds as $iTopicId) {
735                                $this->Cache_Delete("topic_{$iTopicId}");
736                                if(Config::Get('db.tables.engine')=="InnoDB") {
737                                        $this->Topic_DeleteTopicAdditionalData($iTopicId);
738                                } else {
739                                        $this->Topic_DeleteTopic($iTopicId);
740                                }
741                        }
742
743                }
744               
745                /**
746                 * Удаляем связи пользователей блога.
747                 */
748                if(Config::Get('db.tables.engine')!="InnoDB"){ 
749                        $this->oMapperBlog->DeleteBlogUsersByBlogId($iBlogId);
750                }
751                /**
752                 * Удаляем голосование за блог
753                 */
754                $this->Vote_DeleteVoteByTarget($iBlogId, 'blog');
755                /**
756                 * Удаляем комментарии к записям из блога и метки прямого эфира
757                 */
758               
759                return true;
760        }
761        /**
762         * Upload blog avatar on server
763         * Make resized images
764         *
765         * @param  array           $aFile
766         * @param  ModuleBlog_EntityBlog $oUser
767         * @return (string|bool)
768         */
769        public function UploadBlogAvatar($aFile,$oBlog) {
770                if(!is_array($aFile) || !isset($aFile['tmp_name'])) {
771                        return false;
772                }
773               
774                $sFileTmp=Config::Get('sys.cache.dir').func_generator();               
775                if (!move_uploaded_file($aFile['tmp_name'],$sFileTmp)) {
776                        return false;
777                }
778       
779                $sPath=$this->Image_GetIdDir($oBlog->getOwnerId());
780                $aParams=$this->Image_BuildParams('avatar');
781
782                $oImage=new LiveImage($sFileTmp);
783                /**
784                 * Если объект изображения не создан,
785                 * возвращаем ошибку
786                 */
787                if($sError=$oImage->get_last_error()) {
788                        // Вывод сообщения об ошибки, произошедшей при создании объекта изображения
789                        // $this->Message_AddError($sError,$this->Lang_Get('error'));
790                        @unlink($sFileTmp);
791                        return false;
792                }               
793                /**
794                 * Срезаем квадрат
795                 */
796                $oImage = $this->Image_CropSquare($oImage);
797               
798                $aSize=Config::Get('module.blog.avatar_size');
799                rsort($aSize,SORT_NUMERIC);
800                $sSizeBig=array_shift($aSize);
801                if ($oImage && $sFileAvatar=$this->Image_Resize($sFileTmp,$sPath,"avatar_blog_{$oBlog->getUrl()}_{$sSizeBig}x{$sSizeBig}",Config::Get('view.img_max_width'),Config::Get('view.img_max_height'),$sSizeBig,$sSizeBig,false,$aParams,$oImage)) {
802                        foreach ($aSize as $iSize) {
803                                if ($iSize==0) {
804                                        $this->Image_Resize($sFileTmp,$sPath,"avatar_blog_{$oBlog->getUrl()}",Config::Get('view.img_max_width'),Config::Get('view.img_max_height'),null,null,false,$aParams,$oImage);
805                                } else {
806                                        $this->Image_Resize($sFileTmp,$sPath,"avatar_blog_{$oBlog->getUrl()}_{$iSize}x{$iSize}",Config::Get('view.img_max_width'),Config::Get('view.img_max_height'),$iSize,$iSize,false,$aParams,$oImage);
807                                }
808                        }
809                        @unlink($sFileTmp);
810                        /**
811                         * Если все нормально, возвращаем расширение загруженного аватара
812                         */
813                        return $this->Image_GetWebPath($sFileAvatar);
814                }
815                @unlink($sFileTmp);
816                /**
817                 * В случае ошибки, возвращаем false
818                 */
819                return false;
820        }
821        /**
822         * Delete blog avatar from server
823         *
824         * @param ModuleBlog_EntityBlog $oUser
825         */
826        public function DeleteBlogAvatar($oBlog) {
827                /**
828                 * Если аватар есть, удаляем его и его рейсайзы
829                 */
830                if($oBlog->getAvatar()) {               
831                        $aSize=array_merge(Config::Get('module.blog.avatar_size'),array(48));
832                        foreach ($aSize as $iSize) {
833                                @unlink($this->Image_GetServerPath($oBlog->getAvatarPath($iSize)));
834                        }               
835                }
836        }       
837}
838?>
Note: See TracBrowser for help on using the browser.