Dotclear

source: inc/core/class.dc.blog.php @ 2655:a568d9e7d732

Revision 2655:a568d9e7d732, 61.5 KB checked in by Dsls, 12 years ago (diff)

composer locked on CB 0.9.0, restored favorites
Line 
1<?php
2# -- BEGIN LICENSE BLOCK ---------------------------------------
3#
4# This file is part of Dotclear 2.
5#
6# Copyright (c) 2003-2013 Olivier Meunier & Association Dotclear
7# Licensed under the GPL version 2.0 license.
8# See LICENSE file or
9# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
10#
11# -- END LICENSE BLOCK -----------------------------------------
12if (!defined('DC_RC_PATH')) { return; }
13
14/**
15@ingroup DC_CORE
16@nosubgrouping
17@brief Dotclear blog class.
18
19Dotclear blog class instance is provided by dcCore $blog property.
20*/
21class dcBlog
22{
23     /** @var dcCore dcCore instance */
24     protected $core;
25     /** @var connection Database connection object */
26     public $con;
27     /** @var string Database table prefix */
28     public $prefix;
29
30     /** @var string Blog ID */
31     public $id;
32     /** @var string Blog unique ID */
33     public $uid;
34     /** @var string Blog name */
35     public $name;
36     /** @var string Blog description */
37     public $desc;
38     /** @var string Blog URL */
39     public $url;
40     /** @var string Blog host */
41     public $host;
42     /** @var string Blog creation date */
43     public $creadt;
44     /** @var string Blog last update date */
45     public $upddt;
46     /** @var string Blog status */
47     public $status;
48
49     /** @var dcSettings dcSettings object */
50     public $settings;
51     /** @var string Blog theme path */
52     public $themes_path;
53     /** @var string Blog public path */
54     public $public_path;
55
56     private $post_status = array();
57     private $comment_status = array();
58
59     private $categories;
60
61     /** @var boolean Disallow entries password protection */
62     public $without_password = true;
63
64     /**
65     Inits dcBlog object
66
67     @param    core      <b>dcCore</b>       Dotclear core reference
68     @param    id        <b>string</b>       Blog ID
69     */
70     public function __construct($core, $id)
71     {
72          $this->con =& $core->con;
73          $this->prefix = $core->prefix;
74          $this->core =& $core;
75
76          if (($b = $this->core->getBlog($id)) !== false)
77          {
78               $this->id = $id;
79               $this->uid = $b->blog_uid;
80               $this->name = $b->blog_name;
81               $this->desc = $b->blog_desc;
82               $this->url = $b->blog_url;
83               $this->host = http::getHostFromURL($this->url);
84               $this->creadt = strtotime($b->blog_creadt);
85               $this->upddt = strtotime($b->blog_upddt);
86               $this->status = $b->blog_status;
87
88               $this->settings = new dcSettings($this->core,$this->id);
89
90               $this->themes_path = path::fullFromRoot($this->settings->system->themes_path,DC_ROOT);
91               $this->public_path = path::fullFromRoot($this->settings->system->public_path,DC_ROOT);
92
93               $this->post_status['-2'] = __('Pending');
94               $this->post_status['-1'] = __('Scheduled');
95               $this->post_status['0'] = __('Unpublished');
96               $this->post_status['1'] = __('Published');
97
98               $this->comment_status['-2'] = __('Junk');
99               $this->comment_status['-1'] = __('Pending');
100               $this->comment_status['0'] = __('Unpublished');
101               $this->comment_status['1'] = __('Published');
102
103               # --BEHAVIOR-- coreBlogConstruct
104               $this->core->callBehavior('coreBlogConstruct',$this);
105          }
106     }
107
108     /// @name Common public methods
109     //@{
110     /**
111     Returns blog URL ending with a question mark.
112     */
113     public function getQmarkURL()
114     {
115          if (substr($this->url,-1) != '?') {
116               return $this->url.'?';
117          }
118
119          return $this->url;
120     }
121
122     /**
123     Returns an entry status name given to a code. Status are translated, never
124     use it for tests. If status code does not exist, returns <i>unpublished</i>.
125
126     @param    s    <b>integer</b> Status code
127     @return   <b>string</b> Blog status name
128     */
129     public function getPostStatus($s)
130     {
131          if (isset($this->post_status[$s])) {
132               return $this->post_status[$s];
133          }
134          return $this->post_status['0'];
135     }
136
137     /**
138     Returns an array of available entry status codes and names.
139
140     @return   <b>array</b> Simple array with codes in keys and names in value
141     */
142     public function getAllPostStatus()
143     {
144          return $this->post_status;
145     }
146
147     /**
148     Returns an array of available comment status codes and names.
149
150     @return   <b>array</b> Simple array with codes in keys and names in value
151     */
152     public function getAllCommentStatus()
153     {
154          return $this->comment_status;
155     }
156
157     /**
158     Disallows entries password protection. You need to set it to
159     <var>false</var> while serving a public blog.
160
161     @param    v         <b>boolean</b>
162     */
163     public function withoutPassword($v)
164     {
165          $this->without_password = (boolean) $v;
166     }
167     //@}
168
169     /// @name Triggers methods
170     //@{
171     /**
172     Updates blog last update date. Should be called every time you change
173     an element related to the blog.
174     */
175     public function triggerBlog()
176     {
177          $cur = $this->con->openCursor($this->prefix.'blog');
178
179          $cur->blog_upddt = date('Y-m-d H:i:s');
180
181          $cur->update("WHERE blog_id = '".$this->con->escape($this->id)."' ");
182
183          # --BEHAVIOR-- coreBlogAfterTriggerBlog
184          $this->core->callBehavior('coreBlogAfterTriggerBlog',$cur);
185     }
186
187     /**
188     Updates comment and trackback counters in post table. Should be called
189     every time a comment or trackback is added, removed or changed its status.
190
191     @param    id        <b>integer</b>      Comment ID
192     @param    del       <b>boolean</b>      If comment is delete, set this to true
193     */
194     public function triggerComment($id,$del=false)
195     {
196          $this->triggerComments($id,$del);
197     }
198
199     /**
200     Updates comments and trackbacks counters in post table. Should be called
201     every time comments or trackbacks are added, removed or changed their status.
202
203     @param    ids       <b>mixed</b>        Comment(s) ID(s)
204     @param    del       <b>boolean</b>      If comment is delete, set this to true
205     @param    affected_posts      <b>mixed</b>        Posts(s) ID(s)
206     */
207     public function triggerComments($ids, $del=false, $affected_posts=null)
208     {
209          $comments_ids = dcUtils::cleanIds($ids);
210
211          # Get posts affected by comments edition
212          if (empty($affected_posts)) {
213               $strReq =
214                    'SELECT post_id '.
215                    'FROM '.$this->prefix.'comment '.
216                    'WHERE comment_id'.$this->con->in($comments_ids).
217                    'GROUP BY post_id';
218
219               $rs = $this->con->select($strReq);
220
221               $affected_posts = array();
222               while ($rs->fetch()) {
223                    $affected_posts[] = (integer) $rs->post_id;
224               }
225          }
226
227          if (!is_array($affected_posts) || empty($affected_posts)) {
228               return;
229          }
230
231          # Count number of comments if exists for affected posts
232          $strReq =
233               'SELECT post_id, COUNT(post_id) AS nb_comment, comment_trackback '.
234               'FROM '.$this->prefix.'comment '.
235               'WHERE comment_status = 1 '.
236               'AND post_id'.$this->con->in($affected_posts).
237               'GROUP BY post_id,comment_trackback';
238
239          $rs = $this->con->select($strReq);
240
241          $posts = array();
242          while ($rs->fetch()) {
243               if ($rs->comment_trackback) {
244                    $posts[$rs->post_id]['trackback'] = $rs->nb_comment;
245               } else {
246                    $posts[$rs->post_id]['comment'] = $rs->nb_comment;
247               }
248          }
249
250          # Update number of comments on affected posts
251          $cur = $this->con->openCursor($this->prefix.'post');
252          foreach($affected_posts as $post_id)
253          {
254               $cur->clean();
255
256               if (!array_key_exists($post_id,$posts)) {
257                    $cur->nb_trackback = 0;
258                    $cur->nb_comment = 0;
259               } else {
260                    $cur->nb_trackback = empty($posts[$post_id]['trackback']) ? 0 : $posts[$post_id]['trackback'];
261                    $cur->nb_comment = empty($posts[$post_id]['comment']) ? 0 : $posts[$post_id]['comment'];
262               }
263
264               $cur->update('WHERE post_id = '.$post_id);
265          }
266     }
267     //@}
268
269     /// @name Categories management methods
270     //@{
271     public function categories()
272     {
273          if (!($this->categories instanceof dcCategories)) {
274               $this->categories = new dcCategories($this->core);
275          }
276
277          return $this->categories;
278     }
279
280     /**
281     Retrieves categories. <var>$params</var> is an associative array which can
282     take the following parameters:
283
284     - post_type: Get only entries with given type (default "post")
285     - cat_url: filter on cat_url field
286     - cat_id: filter on cat_id field
287     - start: start with a given category
288     - level: categories level to retrieve
289
290     @param    params    <b>array</b>        Parameters
291     @return   <b>record</b>
292     */
293     public function getCategories($params=array())
294     {
295          $c_params = array();
296          if (isset($params['post_type'])) {
297               $c_params['post_type'] = $params['post_type'];
298               unset($params['post_type']);
299          }
300          $counter = $this->getCategoriesCounter($c_params);
301
302          if (isset($params['without_empty']) && ($params['without_empty'] == false)) {
303               $without_empty = false;
304          } else {
305               $without_empty = $this->core->auth->userID() == false; # Get all categories if in admin display
306          }
307
308          $start = isset($params['start']) ? (integer) $params['start'] : 0;
309          $l = isset($params['level']) ? (integer) $params['level'] : 0;
310
311          $rs = $this->categories()->getChildren($start,null,'desc');
312
313          # Get each categories total posts count
314          $data = array();
315          $stack = array();
316          $level = 0;
317          $cols = $rs->columns();
318          while ($rs->fetch())
319          {
320               $nb_post = isset($counter[$rs->cat_id]) ? (integer) $counter[$rs->cat_id] : 0;
321
322               if ($rs->level > $level) {
323                    $nb_total = $nb_post;
324                    $stack[$rs->level] = (integer) $nb_post;
325               } elseif ($rs->level == $level) {
326                    $nb_total = $nb_post;
327                    $stack[$rs->level] += $nb_post;
328               } else {
329                    $nb_total = $stack[$rs->level+1] + $nb_post;
330                    if (isset($stack[$rs->level])) {
331                         $stack[$rs->level] += $nb_total;
332                    } else {
333                         $stack[$rs->level] = $nb_total;
334                    }
335                    unset($stack[$rs->level+1]);
336               }
337
338               if ($nb_total == 0 && $without_empty) {
339                    continue;
340               }
341
342               $level = $rs->level;
343
344               $t = array();
345               foreach ($cols as $c) {
346                    $t[$c] = $rs->f($c);
347               }
348               $t['nb_post'] = $nb_post;
349               $t['nb_total'] = $nb_total;
350
351               if ($l == 0 || ($l > 0 && $l == $rs->level)) {
352                    array_unshift($data,$t);
353               }
354          }
355
356          # We need to apply filter after counting
357          if (isset($params['cat_id']) && $params['cat_id'] !== '')
358          {
359               $found = false;
360               foreach ($data as $v) {
361                    if ($v['cat_id'] == $params['cat_id']) {
362                         $found = true;
363                         $data = array($v);
364                         break;
365                    }
366               }
367               if (!$found) {
368                    $data = array();
369               }
370          }
371
372          if (isset($params['cat_url']) && ($params['cat_url'] !== '')
373               && !isset($params['cat_id']))
374          {
375               $found = false;
376               foreach ($data as $v) {
377                    if ($v['cat_url'] == $params['cat_url']) {
378                         $found = true;
379                         $data = array($v);
380                         break;
381                    }
382               }
383               if (!$found) {
384                    $data = array();
385               }
386          }
387
388          return staticRecord::newFromArray($data);
389     }
390
391     /**
392     Retrieves a category by its ID.
393
394     @param    id        <b>integer</b>      Category ID
395     @return   <b>record</b>
396     */
397     public function getCategory($id)
398     {
399          return $this->getCategories(array('cat_id' => $id));
400     }
401
402     /**
403     Retrieves parents of a given category.
404
405     @param    id        <b>integer</b>      Category ID
406     @return   <b>record</b>
407     */
408     public function getCategoryParents($id)
409     {
410          return $this->categories()->getParents($id);
411     }
412
413     /**
414     Retrieves first parent of a given category.
415
416     @param    id        <b>integer</b>      Category ID
417     @return   <b>record</b>
418     */
419     public function getCategoryParent($id)
420     {
421          return $this->categories()->getParent($id);
422     }
423
424     /**
425     Retrieves all category's first children
426
427     @param    id        <b>integer</b>      Category ID
428     @return   <b>record</b>
429     */
430     public function getCategoryFirstChildren($id)
431     {
432          return $this->getCategories(array('start' => $id,'level' => $id == 0 ? 1 : 2));
433     }
434
435     private function getCategoriesCounter($params=array())
436     {
437          $strReq =
438          'SELECT  C.cat_id, COUNT(P.post_id) AS nb_post '.
439          'FROM '.$this->prefix.'category AS C '.
440          'JOIN '.$this->prefix."post P ON (C.cat_id = P.cat_id AND P.blog_id = '".$this->con->escape($this->id)."' ) ".
441          "WHERE C.blog_id = '".$this->con->escape($this->id)."' ";
442
443          if (!$this->core->auth->userID()) {
444               $strReq .= 'AND P.post_status = 1 ';
445          }
446
447          if (!empty($params['post_type'])) {
448               $strReq .= 'AND P.post_type '.$this->con->in($params['post_type']);
449          }
450
451          $strReq .= 'GROUP BY C.cat_id ';
452
453          $rs = $this->con->select($strReq);
454          $counters = array();
455          while ($rs->fetch()) {
456               $counters[$rs->cat_id] = $rs->nb_post;
457          }
458
459          return $counters;
460     }
461
462     /**
463     Creates a new category. Takes a cursor as input and returns the new category
464     ID.
465
466     @param    cur       <b>cursor</b>       Category cursor
467     @return   <b>integer</b>      New category ID
468     */
469     public function addCategory($cur,$parent=0)
470     {
471          if (!$this->core->auth->check('categories',$this->id)) {
472               throw new Exception(__('You are not allowed to add categories'));
473          }
474
475          $url = array();
476          if ($parent != 0)
477          {
478               $rs = $this->getCategory($parent);
479               if ($rs->isEmpty()) {
480                    $url = array();
481               } else {
482                    $url[] = $rs->cat_url;
483               }
484          }
485
486          if ($cur->cat_url == '') {
487               $url[] = text::tidyURL($cur->cat_title,false);
488          } else {
489               $url[] = $cur->cat_url;
490          }
491
492          $cur->cat_url = implode('/',$url);
493
494          $this->getCategoryCursor($cur);
495          $cur->blog_id = (string) $this->id;
496
497          # --BEHAVIOR-- coreBeforeCategoryCreate
498          $this->core->callBehavior('coreBeforeCategoryCreate',$this,$cur);
499
500          $id = $this->categories()->addNode($cur,$parent);
501          # Update category's cursor
502          $rs = $this->getCategory($id);
503          if (!$rs->isEmpty()) {
504               $cur->cat_lft = $rs->cat_lft;
505               $cur->cat_rgt = $rs->cat_rgt;
506          }
507
508          # --BEHAVIOR-- coreAfterCategoryCreate
509          $this->core->callBehavior('coreAfterCategoryCreate',$this,$cur);
510          $this->triggerBlog();
511
512          return $cur->cat_id;
513     }
514
515     /**
516     Updates an existing category.
517
518     @param    id        <b>integer</b>      Category ID
519     @param    cur       <b>cursor</b>       Category cursor
520     */
521     public function updCategory($id,$cur)
522     {
523          if (!$this->core->auth->check('categories',$this->id)) {
524               throw new Exception(__('You are not allowed to update categories'));
525          }
526
527          if ($cur->cat_url == '')
528          {
529               $url = array();
530               $rs = $this->categories()->getParents($id);
531               while ($rs->fetch()) {
532                    if ($rs->index() == $rs->count()-1) {
533                         $url[] = $rs->cat_url;
534                    }
535               }
536
537
538               $url[] = text::tidyURL($cur->cat_title,false);
539               $cur->cat_url = implode('/',$url);
540          }
541
542          $this->getCategoryCursor($cur,$id);
543
544          # --BEHAVIOR-- coreBeforeCategoryUpdate
545          $this->core->callBehavior('coreBeforeCategoryUpdate',$this,$cur);
546
547          $cur->update(
548          'WHERE cat_id = '.(integer) $id.' '.
549          "AND blog_id = '".$this->con->escape($this->id)."' ");
550
551          # --BEHAVIOR-- coreAfterCategoryUpdate
552          $this->core->callBehavior('coreAfterCategoryUpdate',$this,$cur);
553
554          $this->triggerBlog();
555     }
556
557        /**
558        Set category position
559
560        @param  id              <b>integer</b>          Category ID
561        @param  left            <b>integer</b>          Category ID before
562        @param  right           <b>integer</b>          Category ID after
563        */
564        public function updCategoryPosition($id,$left,$right)
565        {
566                $this->categories()->updatePosition($id,$left,$right);
567                $this->triggerBlog();
568        }
569
570     /**
571     DEPRECATED METHOD. Use dcBlog::setCategoryParent and dcBlog::moveCategory
572     instead.
573
574     @param    id        <b>integer</b>      Category ID
575     @param    order     <b>integer</b>      Category position
576     */
577     public function updCategoryOrder($id,$order)
578     {
579          return;
580     }
581
582     /**
583     Set a category parent
584
585     @param    id        <b>integer</b>      Category ID
586     @param    parent    <b>integer</b>      Parent Category ID
587     */
588     public function setCategoryParent($id,$parent)
589     {
590          $this->categories()->setNodeParent($id,$parent);
591          $this->triggerBlog();
592     }
593
594     /**
595     Set category position
596
597     @param    id        <b>integer</b>      Category ID
598     @param    sibling   <b>integer</b>      Sibling Category ID
599     @param    move      <b>integer</b>      Order (before|after)
600     */
601     public function setCategoryPosition($id,$sibling,$move)
602     {
603          $this->categories()->setNodePosition($id,$sibling,$move);
604          $this->triggerBlog();
605     }
606
607     /**
608     Deletes a category.
609
610     @param    id        <b>integer</b>      Category ID
611     */
612     public function delCategory($id)
613     {
614          if (!$this->core->auth->check('categories',$this->id)) {
615               throw new Exception(__('You are not allowed to delete categories'));
616          }
617
618          $strReq = 'SELECT COUNT(post_id) AS nb_post '.
619                    'FROM '.$this->prefix.'post '.
620                    'WHERE cat_id = '.(integer) $id.' '.
621                    "AND blog_id = '".$this->con->escape($this->id)."' ";
622
623          $rs = $this->con->select($strReq);
624
625          if ($rs->nb_post > 0) {
626               throw new Exception(__('This category is not empty.'));
627          }
628
629          $this->categories()->deleteNode($id,true);
630          $this->triggerBlog();
631     }
632
633     /**
634     Reset categories order and relocate them to first level
635     */
636     public function resetCategoriesOrder()
637     {
638          if (!$this->core->auth->check('categories',$this->id)) {
639               throw new Exception(__('You are not allowed to reset categories order'));
640          }
641
642          $this->categories()->resetOrder();
643          $this->triggerBlog();
644     }
645
646     private function checkCategory($title,$url,$id=null)
647     {
648          # Let's check if URL is taken...
649          $strReq =
650               'SELECT cat_url FROM '.$this->prefix.'category '.
651               "WHERE cat_url = '".$this->con->escape($url)."' ".
652               ($id ? 'AND cat_id <> '.(integer) $id. ' ' : '').
653               "AND blog_id = '".$this->con->escape($this->id)."' ".
654               'ORDER BY cat_url DESC';
655
656          $rs = $this->con->select($strReq);
657
658          if (!$rs->isEmpty())
659          {
660               if ($this->con->driver() == 'mysql' || $this->con->driver() == 'mysqli') {
661                    $clause = "REGEXP '^".$this->con->escape($url)."[0-9]+$'";
662               } elseif ($this->con->driver() == 'pgsql') {
663                    $clause = "~ '^".$this->con->escape($url)."[0-9]+$'";
664               } else {
665                    $clause = "LIKE '".$this->con->escape($url)."%'";
666               }
667               $strReq =
668                    'SELECT cat_url FROM '.$this->prefix.'category '.
669                    "WHERE cat_url ".$clause.' '.
670                    ($id ? 'AND cat_id <> '.(integer) $id. ' ' : '').
671                    "AND blog_id = '".$this->con->escape($this->id)."' ".
672                    'ORDER BY cat_url DESC ';
673
674               $rs = $this->con->select($strReq);
675               $a = array();
676               while ($rs->fetch()) {
677                    $a[] = $rs->cat_url;
678               }
679
680               natsort($a);
681               $t_url = end($a);
682
683               if (preg_match('/(.*?)([0-9]+)$/',$t_url,$m)) {
684                    $i = (integer) $m[2];
685                    $url = $m[1];
686               } else {
687                    $i = 1;
688               }
689
690               return $url.($i+1);
691          }
692
693          # URL is empty?
694          if ($url == '') {
695               throw new Exception(__('Empty category URL'));
696          }
697
698          return $url;
699     }
700
701     private function getCategoryCursor($cur,$id=null)
702     {
703          if ($cur->cat_title == '') {
704               throw new Exception(__('You must provide a category title'));
705          }
706
707          # If we don't have any cat_url, let's do one
708          if ($cur->cat_url == '') {
709               $cur->cat_url = text::tidyURL($cur->cat_title,false);
710          }
711
712          # Still empty ?
713          if ($cur->cat_url == '') {
714               throw new Exception(__('You must provide a category URL'));
715          } else {
716               $cur->cat_url = text::tidyURL($cur->cat_url,true);
717          }
718
719          # Check if title or url are unique
720          $cur->cat_url = $this->checkCategory($cur->cat_title,$cur->cat_url,$id);
721
722          if ($cur->cat_desc !== null) {
723               $cur->cat_desc = $this->core->HTMLfilter($cur->cat_desc);
724          }
725     }
726     //@}
727
728     /// @name Entries management methods
729     //@{
730     /**
731     Retrieves entries. <b>$params</b> is an array taking the following
732     optionnal parameters:
733
734     - no_content: Don't retrieve entry content (excerpt and content)
735     - post_type: Get only entries with given type (default "post", array for many types and '' for no type)
736     - post_id: (integer or array) Get entry with given post_id
737     - post_url: Get entry with given post_url field
738     - user_id: (integer) Get entries belonging to given user ID
739     - cat_id: (string or array) Get entries belonging to given category ID
740     - cat_id_not: deprecated (use cat_id with "id ?not" instead)
741     - cat_url: (string or array) Get entries belonging to given category URL
742     - cat_url_not: deprecated (use cat_url with "url ?not" instead)
743     - post_status: (integer) Get entries with given post_status
744     - post_selected: (boolean) Get select flaged entries
745     - post_year: (integer) Get entries with given year
746     - post_month: (integer) Get entries with given month
747     - post_day: (integer) Get entries with given day
748     - post_lang: Get entries with given language code
749     - search: Get entries corresponding of the following search string
750     - columns: (array) More columns to retrieve
751     - sql: Append SQL string at the end of the query
752     - from: Append SQL string after "FROM" statement in query
753     - order: Order of results (default "ORDER BY post_dt DES")
754     - limit: Limit parameter
755     - sql_only : return the sql request instead of results. Only ids are selected
756     - exclude_post_id : (integer or array) Exclude entries with given post_id
757
758     Please note that on every cat_id or cat_url, you can add ?not to exclude
759     the category and ?sub to get subcategories.
760
761     @param    params         <b>array</b>        Parameters
762     @param    count_only     <b>boolean</b>      Only counts results
763     @return   <b>record</b>  A record with some more capabilities or the SQL request
764     */
765     public function getPosts($params=array(),$count_only=false)
766     {
767          # --BEHAVIOR-- coreBlogBeforeGetPosts
768          $params = new ArrayObject($params);
769          $this->core->callBehavior('coreBlogBeforeGetPosts',$params);
770
771          if ($count_only)
772          {
773               $strReq = 'SELECT count(DISTINCT P.post_id) ';
774          }
775          elseif (!empty($params['sql_only']))
776          {
777               $strReq = 'SELECT P.post_id ';
778          }
779          else
780          {
781               if (!empty($params['no_content'])) {
782                    $content_req = '';
783               } else {
784                    $content_req =
785                    'post_excerpt, post_excerpt_xhtml, '.
786                    'post_content, post_content_xhtml, post_notes, ';
787               }
788
789               if (!empty($params['columns']) && is_array($params['columns'])) {
790                    $content_req .= implode(', ',$params['columns']).', ';
791               }
792
793
794               $strReq =
795               'SELECT P.post_id, P.blog_id, P.user_id, P.cat_id, post_dt, '.
796               'post_tz, post_creadt, post_upddt, post_format, post_password, '.
797               'post_url, post_lang, post_title, '.$content_req.
798               'post_type, post_meta, post_status, post_selected, post_position, '.
799               'post_open_comment, post_open_tb, nb_comment, nb_trackback, '.
800               'U.user_name, U.user_firstname, U.user_displayname, U.user_email, '.
801               'U.user_url, '.
802               'C.cat_title, C.cat_url, C.cat_desc ';
803          }
804
805          $strReq .=
806          'FROM '.$this->prefix.'post P '.
807          'INNER JOIN '.$this->prefix.'user U ON U.user_id = P.user_id '.
808          'LEFT OUTER JOIN '.$this->prefix.'category C ON P.cat_id = C.cat_id ';
809
810          if (!empty($params['from'])) {
811               $strReq .= $params['from'].' ';
812          }
813
814          $strReq .=
815          "WHERE P.blog_id = '".$this->con->escape($this->id)."' ";
816
817          if (!$this->core->auth->check('contentadmin',$this->id)) {
818               $strReq .= 'AND ((post_status = 1 ';
819
820               if ($this->without_password) {
821                    $strReq .= 'AND post_password IS NULL ';
822               }
823               $strReq .= ') ';
824
825               if ($this->core->auth->userID()) {
826                    $strReq .= "OR P.user_id = '".$this->con->escape($this->core->auth->userID())."')";
827               } else {
828                    $strReq .= ') ';
829               }
830          }
831
832          #Adding parameters
833          if (isset($params['post_type']))
834          {
835               if (is_array($params['post_type']) || $params['post_type'] != '') {
836                    $strReq .= 'AND post_type '.$this->con->in($params['post_type']);
837               }
838          }
839          else
840          {
841               $strReq .= "AND post_type = 'post' ";
842          }
843
844          if (isset($params['post_id']) && $params['post_id'] !== '') {
845               if (is_array($params['post_id'])) {
846                    array_walk($params['post_id'],create_function('&$v,$k','if($v!==null){$v=(integer)$v;}'));
847               } else {
848                    $params['post_id'] = array((integer) $params['post_id']);
849               }
850               $strReq .= 'AND P.post_id '.$this->con->in($params['post_id']);
851          }
852
853          if (isset($params['exclude_post_id']) && $params['exclude_post_id'] !== '') {
854               if (is_array($params['exclude_post_id'])) {
855                    array_walk($params['exclude_post_id'],create_function('&$v,$k','if($v!==null){$v=(integer)$v;}'));
856               } else {
857                    $params['exclude_post_id'] = array((integer) $params['exclude_post_id']);
858               }
859               $strReq .= 'AND P.post_id NOT '.$this->con->in($params['exclude_post_id']);
860          }
861
862          if (isset($params['post_url']) && $params['post_url'] !== '') {
863               $strReq .= "AND post_url = '".$this->con->escape($params['post_url'])."' ";
864          }
865
866          if (!empty($params['user_id'])) {
867               $not="";
868               if (!empty($params['user_id_not'])) {
869                    $not=" not";
870               }
871               $strReq .= "AND U.user_id ".$not.$this->con->in($params['user_id'])." ";
872          }
873
874          if (isset($params['cat_id']) && $params['cat_id'] !== '')
875          {
876               if (!is_array($params['cat_id'])) {
877                    $params['cat_id'] = array($params['cat_id']);
878               }
879               if (!empty($params['cat_id_not'])) {
880                    array_walk($params['cat_id'],create_function('&$v,$k','$v=$v." ?not";'));
881               }
882               $strReq .= 'AND '.$this->getPostsCategoryFilter($params['cat_id'],'cat_id').' ';
883          }
884          elseif (isset($params['cat_url']) && $params['cat_url'] !== '')
885          {
886               if (!is_array($params['cat_url'])) {
887                    $params['cat_url'] = array($params['cat_url']);
888               }
889               if (!empty($params['cat_url_not'])) {
890                    array_walk($params['cat_url'],create_function('&$v,$k','$v=$v." ?not";'));
891               }
892               $strReq .= 'AND '.$this->getPostsCategoryFilter($params['cat_url'],'cat_url').' ';
893          }
894
895          /* Other filters */
896          if (isset($params['post_status'])) {
897               $strReq .= 'AND post_status = '.(integer) $params['post_status'].' ';
898          }
899
900          if (isset($params['post_selected'])) {
901               $strReq .= 'AND post_selected = '.(integer) $params['post_selected'].' ';
902          }
903
904          if (!empty($params['post_year'])) {
905               $strReq .= 'AND '.$this->con->dateFormat('post_dt','%Y').' = '.
906               "'".sprintf('%04d',$params['post_year'])."' ";
907          }
908
909          if (!empty($params['post_month'])) {
910               $strReq .= 'AND '.$this->con->dateFormat('post_dt','%m').' = '.
911               "'".sprintf('%02d',$params['post_month'])."' ";
912          }
913
914          if (!empty($params['post_day'])) {
915               $strReq .= 'AND '.$this->con->dateFormat('post_dt','%d').' = '.
916               "'".sprintf('%02d',$params['post_day'])."' ";
917          }
918
919          if (!empty($params['post_lang'])) {
920               $strReq .= "AND P.post_lang = '".$this->con->escape($params['post_lang'])."' ";
921          }
922
923          if (!empty($params['search']))
924          {
925               $words = text::splitWords($params['search']);
926
927               if (!empty($words))
928               {
929                    # --BEHAVIOR-- corePostSearch
930                    if ($this->core->hasBehavior('corePostSearch')) {
931                         $this->core->callBehavior('corePostSearch',$this->core,array(&$words,&$strReq,&$params));
932                    }
933
934                    if ($words)
935                    {
936                         foreach ($words as $i => $w) {
937                              $words[$i] = "post_words LIKE '%".$this->con->escape($w)."%'";
938                         }
939                         $strReq .= 'AND '.implode(' AND ',$words).' ';
940                    }
941               }
942          }
943
944          if (isset($params['media'])) {
945               if ($params['media'] == '0') {
946                    $strReq .= 'AND NOT ';
947               } else {
948                    $strReq .= 'AND ';
949               }
950               $strReq .= 'EXISTS (SELECT M.post_id FROM '.$this->prefix.'post_media M '.
951                    'WHERE M.post_id = P.post_id ';
952               if (isset($params['link_type'])) {
953                    $strReq .= " AND M.link_type ".$this->con->in($params['link_type'])." ";
954               }
955               $strReq .= ")";
956          }
957
958          if (!empty($params['sql'])) {
959               $strReq .= $params['sql'].' ';
960          }
961
962          if (!$count_only)
963          {
964               if (!empty($params['order'])) {
965                    $strReq .= 'ORDER BY '.$this->con->escape($params['order']).' ';
966               } else {
967                    $strReq .= 'ORDER BY post_dt DESC ';
968               }
969          }
970
971          if (!$count_only && !empty($params['limit'])) {
972                    $strReq .= $this->con->limit($params['limit']);
973               }
974
975          if (!empty($params['sql_only'])) {
976               return $strReq;
977          }
978
979          $rs = $this->con->select($strReq);
980          $rs->core = $this->core;
981          $rs->_nb_media = array();
982          $rs->extend('rsExtPost');
983
984          # --BEHAVIOR-- coreBlogGetPosts
985          $this->core->callBehavior('coreBlogGetPosts',$rs);
986
987          return $rs;
988     }
989
990     /**
991     Returns a record with post id, title and date for next or previous post
992     according to the post ID.
993     $dir could be 1 (next post) or -1 (previous post).
994
995     @param    post_id                  <b>integer</b>      Post ID
996     @param    dir                      <b>integer</b>      Search direction
997     @param    restrict_to_category     <b>boolean</b>      Restrict to post with same category
998     @param    restrict_to_lang         <b>boolean</b>      Restrict to post with same lang
999     @return   record
1000     */
1001     public function getNextPost($post,$dir,$restrict_to_category=false, $restrict_to_lang=false)
1002     {
1003          $dt = $post->post_dt;
1004          $post_id = (integer) $post->post_id;
1005
1006          if($dir > 0) {
1007               $sign = '>';
1008               $order = 'ASC';
1009          }
1010          else {
1011               $sign = '<';
1012               $order = 'DESC';
1013          }
1014
1015          $params['post_type'] = $post->post_type;
1016          $params['limit'] = 1;
1017          $params['order'] = 'post_dt '.$order.', P.post_id '.$order;
1018          $params['sql'] =
1019          'AND ( '.
1020          "    (post_dt = '".$this->con->escape($dt)."' AND P.post_id ".$sign." ".$post_id.") ".
1021          "    OR post_dt ".$sign." '".$this->con->escape($dt)."' ".
1022          ') ';
1023
1024          if ($restrict_to_category) {
1025               $params['sql'] .= $post->cat_id ? 'AND P.cat_id = '.(integer) $post->cat_id.' ' : 'AND P.cat_id IS NULL ';
1026          }
1027
1028          if ($restrict_to_lang) {
1029               $params['sql'] .= $post->post_lang ? 'AND P.post_lang = \''. $this->con->escape($post->post_lang) .'\' ': 'AND P.post_lang IS NULL ';
1030          }
1031
1032          $rs = $this->getPosts($params);
1033
1034          if ($rs->isEmpty()) {
1035               return null;
1036          }
1037
1038          return $rs;
1039     }
1040
1041     /**
1042     Retrieves different languages and post count on blog, based on post_lang
1043     field. <var>$params</var> is an array taking the following optionnal
1044     parameters:
1045
1046     - post_type: Get only entries with given type (default "post", '' for no type)
1047     - lang: retrieve post count for selected lang
1048     - order: order statement (default post_lang DESC)
1049
1050     @param    params    <b>array</b>        Parameters
1051     @return   record
1052     */
1053     public function getLangs($params=array())
1054     {
1055          $strReq = 'SELECT COUNT(post_id) as nb_post, post_lang '.
1056                    'FROM '.$this->prefix.'post '.
1057                    "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1058                    "AND post_lang <> '' ".
1059                    "AND post_lang IS NOT NULL ";
1060
1061          if (!$this->core->auth->check('contentadmin',$this->id)) {
1062               $strReq .= 'AND ((post_status = 1 ';
1063
1064               if ($this->without_password) {
1065                    $strReq .= 'AND post_password IS NULL ';
1066               }
1067               $strReq .= ') ';
1068
1069               if ($this->core->auth->userID()) {
1070                    $strReq .= "OR user_id = '".$this->con->escape($this->core->auth->userID())."')";
1071               } else {
1072                    $strReq .= ') ';
1073               }
1074          }
1075
1076          if (isset($params['post_type'])) {
1077               if ($params['post_type'] != '') {
1078                    $strReq .= "AND post_type = '".$this->con->escape($params['post_type'])."' ";
1079               }
1080          } else {
1081               $strReq .= "AND post_type = 'post' ";
1082          }
1083
1084          if (isset($params['lang'])) {
1085               $strReq .= "AND post_lang = '".$this->con->escape($params['lang'])."' ";
1086          }
1087
1088          $strReq .= 'GROUP BY post_lang ';
1089
1090          $order = 'desc';
1091          if (!empty($params['order']) && preg_match('/^(desc|asc)$/i',$params['order'])) {
1092               $order = $params['order'];
1093          }
1094          $strReq .= 'ORDER BY post_lang '.$order.' ';
1095
1096          return $this->con->select($strReq);
1097     }
1098
1099     /**
1100     Returns a record with all distinct blog dates and post count.
1101     <var>$params</var> is an array taking the following optionnal parameters:
1102
1103     - type: (day|month|year) Get days, months or years
1104     - year: (integer) Get dates for given year
1105     - month: (integer) Get dates for given month
1106     - day: (integer) Get dates for given day
1107     - cat_id: (integer) Category ID filter
1108     - cat_url: Category URL filter
1109     - post_lang: lang of the posts
1110     - next: Get date following match
1111     - previous: Get date before match
1112     - order: Sort by date "ASC" or "DESC"
1113
1114     @param    params    <b>array</b>        Parameters array
1115     @return   record
1116     */
1117     public function getDates($params=array())
1118     {
1119          $dt_f = '%Y-%m-%d';
1120          $dt_fc = '%Y%m%d';
1121          if (isset($params['type'])) {
1122               if ($params['type'] == 'year') {
1123                    $dt_f = '%Y-01-01';
1124                    $dt_fc = '%Y0101';
1125               } elseif ($params['type'] == 'month') {
1126                    $dt_f = '%Y-%m-01';
1127                    $dt_fc = '%Y%m01';
1128               }
1129          }
1130          $dt_f .= ' 00:00:00';
1131          $dt_fc .= '000000';
1132
1133          $cat_field = $catReq = $limit = '';
1134
1135          if (isset($params['cat_id']) && $params['cat_id'] !== '') {
1136               $catReq = 'AND P.cat_id = '.(integer) $params['cat_id'].' ';
1137               $cat_field = ', C.cat_url ';
1138          } elseif (isset($params['cat_url']) && $params['cat_url'] !== '') {
1139               $catReq = "AND C.cat_url = '".$this->con->escape($params['cat_url'])."' ";
1140               $cat_field = ', C.cat_url ';
1141          }
1142          if (!empty($params['post_lang'])) {
1143               $catReq = 'AND P.post_lang = \''. $params['post_lang'].'\' ';
1144          }
1145
1146          $strReq = 'SELECT DISTINCT('.$this->con->dateFormat('post_dt',$dt_f).') AS dt '.
1147                    $cat_field.
1148                    ',COUNT(P.post_id) AS nb_post '.
1149                    'FROM '.$this->prefix.'post P LEFT JOIN '.$this->prefix.'category C '.
1150                    'ON P.cat_id = C.cat_id '.
1151                    "WHERE P.blog_id = '".$this->con->escape($this->id)."' ".
1152                    $catReq;
1153
1154          if (!$this->core->auth->check('contentadmin',$this->id)) {
1155               $strReq .= 'AND ((post_status = 1 ';
1156
1157               if ($this->without_password) {
1158                    $strReq .= 'AND post_password IS NULL ';
1159               }
1160               $strReq .= ') ';
1161
1162               if ($this->core->auth->userID()) {
1163                    $strReq .= "OR P.user_id = '".$this->con->escape($this->core->auth->userID())."')";
1164               } else {
1165                    $strReq .= ') ';
1166               }
1167          }
1168
1169          if (!empty($params['post_type'])) {
1170               $strReq .= "AND post_type ".$this->con->in($params['post_type'])." ";
1171          } else {
1172               $strReq .= "AND post_type = 'post' ";
1173          }
1174
1175          if (!empty($params['year'])) {
1176               $strReq .= 'AND '.$this->con->dateFormat('post_dt','%Y')." = '".sprintf('%04d',$params['year'])."' ";
1177          }
1178
1179          if (!empty($params['month'])) {
1180               $strReq .= 'AND '.$this->con->dateFormat('post_dt','%m')." = '".sprintf('%02d',$params['month'])."' ";
1181          }
1182
1183          if (!empty($params['day'])) {
1184               $strReq .= 'AND '.$this->con->dateFormat('post_dt','%d')." = '".sprintf('%02d',$params['day'])."' ";
1185          }
1186
1187          # Get next or previous date
1188          if (!empty($params['next']) || !empty($params['previous']))
1189          {
1190               if (!empty($params['next'])) {
1191                    $pdir = ' > ';
1192                    $params['order'] = 'asc';
1193                    $dt = $params['next'];
1194               } else {
1195                    $pdir = ' < ';
1196                    $params['order'] = 'desc';
1197                    $dt = $params['previous'];
1198               }
1199
1200               $dt = date('YmdHis',strtotime($dt));
1201
1202               $strReq .= 'AND '.$this->con->dateFormat('post_dt',$dt_fc).$pdir."'".$dt."' ";
1203               $limit = $this->con->limit(1);
1204          }
1205
1206          $strReq .= 'GROUP BY dt '.$cat_field;
1207
1208          $order = 'desc';
1209          if (!empty($params['order']) && preg_match('/^(desc|asc)$/i',$params['order'])) {
1210               $order = $params['order'];
1211          }
1212
1213          $strReq .=
1214          'ORDER BY dt '.$order.' '.
1215          $limit;
1216
1217          $rs = $this->con->select($strReq);
1218          $rs->extend('rsExtDates');
1219          return $rs;
1220     }
1221
1222     /**
1223     Creates a new entry. Takes a cursor as input and returns the new entry
1224     ID.
1225
1226     @param    cur       <b>cursor</b>       Post cursor
1227     @return   <b>integer</b>      New post ID
1228     */
1229     public function addPost($cur)
1230     {
1231          if (!$this->core->auth->check('usage,contentadmin',$this->id)) {
1232               throw new Exception(__('You are not allowed to create an entry'));
1233          }
1234
1235          $this->con->writeLock($this->prefix.'post');
1236          try
1237          {
1238               # Get ID
1239               $rs = $this->con->select(
1240                    'SELECT MAX(post_id) '.
1241                    'FROM '.$this->prefix.'post '
1242                    );
1243
1244               $cur->post_id = (integer) $rs->f(0) + 1;
1245               $cur->blog_id = (string) $this->id;
1246               $cur->post_creadt = date('Y-m-d H:i:s');
1247               $cur->post_upddt = date('Y-m-d H:i:s');
1248               $cur->post_tz = $this->core->auth->getInfo('user_tz');
1249
1250               # Post excerpt and content
1251               $this->getPostContent($cur,$cur->post_id);
1252
1253               $this->getPostCursor($cur);
1254
1255               $cur->post_url = $this->getPostURL($cur->post_url,$cur->post_dt,$cur->post_title,$cur->post_id);
1256
1257               if (!$this->core->auth->check('publish,contentadmin',$this->id)) {
1258                    $cur->post_status = -2;
1259               }
1260
1261               # --BEHAVIOR-- coreBeforePostCreate
1262               $this->core->callBehavior('coreBeforePostCreate',$this,$cur);
1263
1264               $cur->insert();
1265               $this->con->unlock();
1266          }
1267          catch (Exception $e)
1268          {
1269               $this->con->unlock();
1270               throw $e;
1271          }
1272
1273          # --BEHAVIOR-- coreAfterPostCreate
1274          $this->core->callBehavior('coreAfterPostCreate',$this,$cur);
1275
1276          $this->triggerBlog();
1277
1278          return $cur->post_id;
1279     }
1280
1281     /**
1282     Updates an existing post.
1283
1284     @param    id        <b>integer</b>      Post ID
1285     @param    cur       <b>cursor</b>       Post cursor
1286     */
1287     public function updPost($id,$cur)
1288     {
1289          if (!$this->core->auth->check('usage,contentadmin',$this->id)) {
1290               throw new Exception(__('You are not allowed to update entries'));
1291          }
1292
1293          $id = (integer) $id;
1294
1295          if (empty($id)) {
1296               throw new Exception(__('No such entry ID'));
1297          }
1298
1299          # Post excerpt and content
1300          $this->getPostContent($cur,$id);
1301
1302          $this->getPostCursor($cur);
1303
1304          if ($cur->post_url !== null) {
1305               $cur->post_url = $this->getPostURL($cur->post_url,$cur->post_dt,$cur->post_title,$id);
1306          }
1307
1308          if (!$this->core->auth->check('publish,contentadmin',$this->id)) {
1309               $cur->unsetField('post_status');
1310          }
1311
1312          $cur->post_upddt = date('Y-m-d H:i:s');
1313
1314          #If user is only "usage", we need to check the post's owner
1315          if (!$this->core->auth->check('contentadmin',$this->id))
1316          {
1317               $strReq = 'SELECT post_id '.
1318                         'FROM '.$this->prefix.'post '.
1319                         'WHERE post_id = '.$id.' '.
1320                         "AND user_id = '".$this->con->escape($this->core->auth->userID())."' ";
1321
1322               $rs = $this->con->select($strReq);
1323
1324               if ($rs->isEmpty()) {
1325                    throw new Exception(__('You are not allowed to edit this entry'));
1326               }
1327          }
1328
1329          # --BEHAVIOR-- coreBeforePostUpdate
1330          $this->core->callBehavior('coreBeforePostUpdate',$this,$cur);
1331
1332          $cur->update('WHERE post_id = '.$id.' ');
1333
1334          # --BEHAVIOR-- coreAfterPostUpdate
1335          $this->core->callBehavior('coreAfterPostUpdate',$this,$cur);
1336
1337          $this->triggerBlog();
1338     }
1339
1340     /**
1341     Updates post status.
1342
1343     @param    id        <b>integer</b>      Post ID
1344     @param    status    <b>integer</b>      Post status
1345     */
1346     public function updPostStatus($id,$status)
1347     {
1348          $this->updPostsStatus($id,$status);
1349     }
1350
1351     /**
1352     Updates posts status.
1353
1354     @param    ids       <b>mixed</b>        Post(s) ID(s)
1355     @param    status    <b>integer</b>      Post status
1356     */
1357     public function updPostsStatus($ids,$status)
1358     {
1359          if (!$this->core->auth->check('publish,contentadmin',$this->id)) {
1360               throw new Exception(__('You are not allowed to change this entry status'));
1361          }
1362
1363          $posts_ids = dcUtils::cleanIds($ids);
1364          $status = (integer) $status;
1365
1366          $strReq = "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1367                    "AND post_id ".$this->con->in($posts_ids);
1368
1369          #If user can only publish, we need to check the post's owner
1370          if (!$this->core->auth->check('contentadmin',$this->id))
1371          {
1372               $strReq .= "AND user_id = '".$this->con->escape($this->core->auth->userID())."' ";
1373          }
1374
1375          $cur = $this->con->openCursor($this->prefix.'post');
1376
1377          $cur->post_status = $status;
1378          $cur->post_upddt = date('Y-m-d H:i:s');
1379
1380          $cur->update($strReq);
1381          $this->triggerBlog();
1382     }
1383
1384     /**
1385     Updates post selection.
1386
1387     @param    id        <b>integer</b>      Post ID
1388     @param    selected  <b>integer</b>      Is selected post
1389     */
1390     public function updPostSelected($id,$selected)
1391     {
1392          $this->updPostsSelected($id,$selected);
1393     }
1394
1395     /**
1396     Updates posts selection.
1397
1398     @param    ids       <b>mixed</b>        Post(s) ID(s)
1399     @param    selected  <b>integer</b>      Is selected post(s)
1400     */
1401     public function updPostsSelected($ids,$selected)
1402     {
1403          if (!$this->core->auth->check('usage,contentadmin',$this->id)) {
1404               throw new Exception(__('You are not allowed to change this entry category'));
1405          }
1406
1407          $posts_ids = dcUtils::cleanIds($ids);
1408          $selected = (boolean) $selected;
1409
1410          $strReq = "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1411                    "AND post_id ".$this->con->in($posts_ids);
1412
1413          # If user is only usage, we need to check the post's owner
1414          if (!$this->core->auth->check('contentadmin',$this->id))
1415          {
1416               $strReq .= "AND user_id = '".$this->con->escape($this->core->auth->userID())."' ";
1417          }
1418
1419          $cur = $this->con->openCursor($this->prefix.'post');
1420
1421          $cur->post_selected = (integer) $selected;
1422          $cur->post_upddt = date('Y-m-d H:i:s');
1423
1424          $cur->update($strReq);
1425          $this->triggerBlog();
1426     }
1427
1428     /**
1429     Updates post category. <var>$cat_id</var> can be null.
1430
1431     @param    id        <b>integer</b>      Post ID
1432     @param    cat_id    <b>integer</b>      Category ID
1433     */
1434     public function updPostCategory($id,$cat_id)
1435     {
1436          $this->updPostsCategory($id,$cat_id);
1437     }
1438
1439     /**
1440     Updates posts category. <var>$cat_id</var> can be null.
1441
1442     @param    ids       <b>mixed</b>        Post(s) ID(s)
1443     @param    cat_id    <b>integer</b>      Category ID
1444     */
1445     public function updPostsCategory($ids,$cat_id)
1446     {
1447          if (!$this->core->auth->check('usage,contentadmin',$this->id)) {
1448               throw new Exception(__('You are not allowed to change this entry category'));
1449          }
1450
1451          $posts_ids = dcUtils::cleanIds($ids);
1452          $cat_id = (integer) $cat_id;
1453
1454          $strReq = "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1455                    "AND post_id ".$this->con->in($posts_ids);
1456
1457          # If user is only usage, we need to check the post's owner
1458          if (!$this->core->auth->check('contentadmin',$this->id))
1459          {
1460               $strReq .= "AND user_id = '".$this->con->escape($this->core->auth->userID())."' ";
1461          }
1462
1463          $cur = $this->con->openCursor($this->prefix.'post');
1464
1465          $cur->cat_id = ($cat_id ? $cat_id : null);
1466          $cur->post_upddt = date('Y-m-d H:i:s');
1467
1468          $cur->update($strReq);
1469          $this->triggerBlog();
1470     }
1471
1472     /**
1473     Updates posts category. <var>$new_cat_id</var> can be null.
1474
1475     @param    old_cat_id     <b>integer</b>      Old category ID
1476     @param    new_cat_id     <b>integer</b>      New category ID
1477     */
1478     public function changePostsCategory($old_cat_id,$new_cat_id)
1479     {
1480          if (!$this->core->auth->check('contentadmin,categories',$this->id)) {
1481               throw new Exception(__('You are not allowed to change entries category'));
1482          }
1483
1484          $old_cat_id = (integer) $old_cat_id;
1485          $new_cat_id = (integer) $new_cat_id;
1486
1487          $cur = $this->con->openCursor($this->prefix.'post');
1488
1489          $cur->cat_id = ($new_cat_id ? $new_cat_id : null);
1490          $cur->post_upddt = date('Y-m-d H:i:s');
1491
1492          $cur->update(
1493               'WHERE cat_id = '.$old_cat_id.' '.
1494               "AND blog_id = '".$this->con->escape($this->id)."' "
1495          );
1496          $this->triggerBlog();
1497     }
1498
1499     /**
1500     Deletes a post.
1501
1502     @param    id        <b>integer</b>      Post ID
1503     */
1504     public function delPost($id)
1505     {
1506          $this->delPosts($id);
1507     }
1508
1509     /**
1510     Deletes multiple posts.
1511
1512     @param    ids       <b>mixed</b>        Post(s) ID(s)
1513     */
1514     public function delPosts($ids)
1515     {
1516          if (!$this->core->auth->check('delete,contentadmin',$this->id)) {
1517               throw new Exception(__('You are not allowed to delete entries'));
1518          }
1519
1520          $posts_ids = dcUtils::cleanIds($ids);
1521
1522          if (empty($posts_ids)) {
1523               throw new Exception(__('No such entry ID'));
1524          }
1525
1526          $strReq = 'DELETE FROM '.$this->prefix.'post '.
1527                    "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1528                    "AND post_id ".$this->con->in($posts_ids);
1529
1530          #If user can only delete, we need to check the post's owner
1531          if (!$this->core->auth->check('contentadmin',$this->id))
1532          {
1533               $strReq .= "AND user_id = '".$this->con->escape($this->core->auth->userID())."' ";
1534          }
1535
1536          $this->con->execute($strReq);
1537          $this->triggerBlog();
1538     }
1539
1540     /**
1541     Publishes all entries flaged as "scheduled".
1542     */
1543     public function publishScheduledEntries()
1544     {
1545          $strReq = 'SELECT post_id, post_dt, post_tz '.
1546                    'FROM '.$this->prefix.'post '.
1547                    'WHERE post_status = -1 '.
1548                    "AND blog_id = '".$this->con->escape($this->id)."' ";
1549
1550          $rs = $this->con->select($strReq);
1551
1552          $now = dt::toUTC(time());
1553          $to_change = new ArrayObject();
1554
1555          if ($rs->isEmpty()) {
1556               return;
1557          }
1558
1559          while ($rs->fetch())
1560          {
1561               # Now timestamp with post timezone
1562               $now_tz = $now + dt::getTimeOffset($rs->post_tz,$now);
1563
1564               # Post timestamp
1565               $post_ts = strtotime($rs->post_dt);
1566
1567               # If now_tz >= post_ts, we publish the entry
1568               if ($now_tz >= $post_ts) {
1569                    $to_change[] = (integer) $rs->post_id;
1570               }
1571          }
1572          if (count($to_change))
1573          {
1574               # --BEHAVIOR-- coreBeforeScheduledEntriesPublish
1575               $this->core->callBehavior('coreBeforeScheduledEntriesPublish',$this,$to_change);
1576
1577               $strReq =
1578               'UPDATE '.$this->prefix.'post SET '.
1579               'post_status = 1 '.
1580               "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1581               'AND post_id '.$this->con->in((array)$to_change).' ';
1582               $this->con->execute($strReq);
1583               $this->triggerBlog();
1584
1585               # --BEHAVIOR-- coreAfterScheduledEntriesPublish
1586               $this->core->callBehavior('coreAfterScheduledEntriesPublish',$this,$to_change);
1587          }
1588
1589     }
1590
1591     /**
1592     Retrieves all users having posts on current blog.
1593
1594     @param    post_type      <b>string</b>       post_type filter (post)
1595     @return   record
1596     */
1597     public function getPostsUsers($post_type='post')
1598     {
1599          $strReq = 'SELECT P.user_id, user_name, user_firstname, '.
1600                    'user_displayname, user_email '.
1601                    'FROM '.$this->prefix.'post P, '.$this->prefix.'user U '.
1602                    'WHERE P.user_id = U.user_id '.
1603                    "AND blog_id = '".$this->con->escape($this->id)."' ";
1604
1605          if ($post_type) {
1606               $strReq .= "AND post_type = '".$this->con->escape($post_type)."' ";
1607          }
1608
1609          $strReq .= 'GROUP BY P.user_id, user_name, user_firstname, user_displayname, user_email ';
1610
1611          return $this->con->select($strReq);
1612     }
1613
1614     private function getPostsCategoryFilter($arr,$field='cat_id')
1615     {
1616          $field = $field == 'cat_id' ? 'cat_id' : 'cat_url';
1617
1618          $sub = array();
1619          $not = array();
1620          $queries = array();
1621
1622          foreach ($arr as $v)
1623          {
1624               $v = trim($v);
1625               $args = preg_split('/\s*[?]\s*/',$v,-1,PREG_SPLIT_NO_EMPTY);
1626               $id = array_shift($args);
1627               $args = array_flip($args);
1628
1629               if (isset($args['not'])) { $not[$id] = 1; }
1630               if (isset($args['sub'])) { $sub[$id] = 1; }
1631               if ($field == 'cat_id') {
1632                    if (preg_match('/^null$/i',$id)) {
1633                         $queries[$id] = 'P.cat_id IS NULL';
1634                    }
1635                    else {
1636                         $queries[$id] = 'P.cat_id = '.(integer) $id;
1637                    }
1638               } else {
1639                    $queries[$id] = "C.cat_url = '".$this->con->escape($id)."' ";
1640               }
1641          }
1642
1643          if (!empty($sub)) {
1644               $rs = $this->con->select(
1645                    'SELECT cat_id, cat_url, cat_lft, cat_rgt FROM '.$this->prefix.'category '.
1646                    "WHERE blog_id = '".$this->con->escape($this->id)."' ".
1647                    'AND '.$field.' '.$this->con->in(array_keys($sub))
1648               );
1649
1650               while ($rs->fetch()) {
1651                    $queries[$rs->f($field)] = '(C.cat_lft BETWEEN '.$rs->cat_lft.' AND '.$rs->cat_rgt.')';
1652               }
1653          }
1654
1655          # Create queries
1656          $sql = array(
1657               0 => array(), # wanted categories
1658               1 => array()  # excluded categories
1659          );
1660
1661          foreach ($queries as $id => $q) {
1662               $sql[(integer) isset($not[$id])][] = $q;
1663          }
1664
1665          $sql[0] = implode(' OR ',$sql[0]);
1666          $sql[1] = implode(' OR ',$sql[1]);
1667
1668          if ($sql[0]) {
1669               $sql[0] = '('.$sql[0].')';
1670          } else {
1671               unset($sql[0]);
1672          }
1673
1674          if ($sql[1]) {
1675               $sql[1] = '(P.cat_id IS NULL OR NOT('.$sql[1].'))';
1676          } else {
1677               unset($sql[1]);
1678          }
1679
1680          return implode(' AND ',$sql);
1681     }
1682
1683     private function getPostCursor($cur,$post_id=null)
1684     {
1685          if ($cur->post_title == '') {
1686               throw new Exception(__('No entry title'));
1687          }
1688
1689          if ($cur->post_content == '') {
1690               throw new Exception(__('No entry content'));
1691          }
1692
1693          if ($cur->post_password === '') {
1694               $cur->post_password = null;
1695          }
1696
1697          if ($cur->post_dt == '') {
1698               $offset = dt::getTimeOffset($this->core->auth->getInfo('user_tz'));
1699               $now = time() + $offset;
1700               $cur->post_dt = date('Y-m-d H:i:00',$now);
1701          }
1702
1703          $post_id = is_int($post_id) ? $post_id : $cur->post_id;
1704
1705          if ($cur->post_content_xhtml == '') {
1706               throw new Exception(__('No entry content'));
1707          }
1708
1709          # Words list
1710          if ($cur->post_title !== null && $cur->post_excerpt_xhtml !== null
1711          && $cur->post_content_xhtml !== null)
1712          {
1713               $words =
1714               $cur->post_title.' '.
1715               $cur->post_excerpt_xhtml.' '.
1716               $cur->post_content_xhtml;
1717
1718               $cur->post_words = implode(' ',text::splitWords($words));
1719          }
1720     }
1721
1722     private function getPostContent($cur,$post_id)
1723     {
1724          $post_excerpt = $cur->post_excerpt;
1725          $post_excerpt_xhtml = $cur->post_excerpt_xhtml;
1726          $post_content = $cur->post_content;
1727          $post_content_xhtml = $cur->post_content_xhtml;
1728
1729          $this->setPostContent(
1730               $post_id,$cur->post_format,$cur->post_lang,
1731               $post_excerpt,$post_excerpt_xhtml,
1732               $post_content,$post_content_xhtml
1733          );
1734
1735          $cur->post_excerpt = $post_excerpt;
1736          $cur->post_excerpt_xhtml = $post_excerpt_xhtml;
1737          $cur->post_content = $post_content;
1738          $cur->post_content_xhtml = $post_content_xhtml;
1739     }
1740
1741     /**
1742     Creates post HTML content, taking format and lang into account.
1743
1744     @param         post_id        <b>integer</b>      Post ID
1745     @param         format         <b>string</b>       Post format
1746     @param         lang           <b>string</b>       Post lang
1747     @param         excerpt        <b>string</b>       Post excerpt
1748     @param[out]    excerpt_xhtml  <b>string</b>       Post excerpt HTML
1749     @param         content        <b>string</b>       Post content
1750     @param[out]    content_xhtml  <b>string</b>       Post content HTML
1751     */
1752     public function setPostContent($post_id,$format,$lang,&$excerpt,&$excerpt_xhtml,&$content,&$content_xhtml)
1753     {
1754          if ($format == 'wiki')
1755          {
1756               $this->core->initWikiPost();
1757               $this->core->wiki2xhtml->setOpt('note_prefix','pnote-'.$post_id);
1758               switch ($this->settings->system->note_title_tag) {
1759                    case 1:
1760                         $tag = 'h3';
1761                         break;
1762                    case 2:
1763                         $tag = 'p';
1764                         break;
1765                    default:
1766                         $tag = 'h4';
1767                         break;
1768               }
1769               $this->core->wiki2xhtml->setOpt('note_str','<div class="footnotes"><'.$tag.' class="footnotes-title">'.
1770                    __('Notes').'</'.$tag.'>%s</div>');
1771               $this->core->wiki2xhtml->setOpt('note_str_single','<div class="footnotes"><'.$tag.' class="footnotes-title">'.
1772                    __('Note').'</'.$tag.'>%s</div>');
1773               if (strpos($lang,'fr') === 0) {
1774                    $this->core->wiki2xhtml->setOpt('active_fr_syntax',1);
1775               }
1776          }
1777
1778          if ($excerpt) {
1779               $excerpt_xhtml = $this->core->callFormater($format,$excerpt);
1780               $excerpt_xhtml = $this->core->HTMLfilter($excerpt_xhtml);
1781          } else {
1782               $excerpt_xhtml = '';
1783          }
1784
1785          if ($content) {
1786               $content_xhtml = $this->core->callFormater($format,$content);
1787               $content_xhtml = $this->core->HTMLfilter($content_xhtml);
1788          } else {
1789               $content_xhtml = '';
1790          }
1791
1792          # --BEHAVIOR-- coreAfterPostContentFormat
1793          $this->core->callBehavior('coreAfterPostContentFormat',array(
1794               'excerpt' => &$excerpt,
1795               'content' => &$content,
1796               'excerpt_xhtml' => &$excerpt_xhtml,
1797               'content_xhtml' => &$content_xhtml
1798          ));
1799     }
1800
1801     /**
1802     Returns URL for a post according to blog setting <var>post_url_format</var>.
1803     It will try to guess URL and append some figures if needed.
1804
1805     @param    url            <b>string</b>       Origin URL, could be empty
1806     @param    post_dt        <b>string</b>       Post date (in YYYY-MM-DD HH:mm:ss)
1807     @param    post_title     <b>string</b>       Post title
1808     @param    post_id        <b>integer</b>      Post ID
1809     @return   <b>string</b>  result URL
1810     */
1811     public function getPostURL($url,$post_dt,$post_title,$post_id)
1812     {
1813          $url = trim($url);
1814
1815          $url_patterns = array(
1816          '{y}' => date('Y',strtotime($post_dt)),
1817          '{m}' => date('m',strtotime($post_dt)),
1818          '{d}' => date('d',strtotime($post_dt)),
1819          '{t}' => text::tidyURL($post_title),
1820          '{id}' => (integer) $post_id
1821          );
1822
1823          # If URL is empty, we create a new one
1824          if ($url == '')
1825          {
1826               # Transform with format
1827               $url = str_replace(
1828                    array_keys($url_patterns),
1829                    array_values($url_patterns),
1830                    $this->settings->system->post_url_format
1831               );
1832          }
1833          else
1834          {
1835               $url = text::tidyURL($url);
1836          }
1837
1838          # Let's check if URL is taken...
1839          $strReq = 'SELECT post_url FROM '.$this->prefix.'post '.
1840                    "WHERE post_url = '".$this->con->escape($url)."' ".
1841                    'AND post_id <> '.(integer) $post_id. ' '.
1842                    "AND blog_id = '".$this->con->escape($this->id)."' ".
1843                    'ORDER BY post_url DESC';
1844
1845          $rs = $this->con->select($strReq);
1846
1847          if (!$rs->isEmpty())
1848          {
1849               if ($this->con->driver() == 'mysql' || $this->con->driver() == 'mysqli') {
1850                    $clause = "REGEXP '^".$this->con->escape($url)."[0-9]+$'";
1851               } elseif ($this->con->driver() == 'pgsql') {
1852                    $clause = "~ '^".$this->con->escape($url)."[0-9]+$'";
1853               } else {
1854                    $clause = "LIKE '".$this->con->escape($url)."%'";
1855               }
1856               $strReq = 'SELECT post_url FROM '.$this->prefix.'post '.
1857                         "WHERE post_url ".$clause.' '.
1858                         'AND post_id <> '.(integer) $post_id.' '.
1859                         "AND blog_id = '".$this->con->escape($this->id)."' ".
1860                         'ORDER BY post_url DESC ';
1861
1862               $rs = $this->con->select($strReq);
1863               $a = array();
1864               while ($rs->fetch()) {
1865                    $a[] = $rs->post_url;
1866               }
1867
1868               natsort($a);
1869               $t_url = end($a);
1870
1871               if (preg_match('/(.*?)([0-9]+)$/',$t_url,$m)) {
1872                    $i = (integer) $m[2];
1873                    $url = $m[1];
1874               } else {
1875                    $i = 1;
1876               }
1877
1878               return $url.($i+1);
1879          }
1880
1881          # URL is empty?
1882          if ($url == '') {
1883               throw new Exception(__('Empty entry URL'));
1884          }
1885
1886          return $url;
1887     }
1888     //@}
1889
1890     /// @name Comments management methods
1891     //@{
1892     /**
1893     Retrieves comments. <b>$params</b> is an array taking the following
1894     optionnal parameters:
1895
1896     - no_content: Don't retrieve comment content
1897     - post_type: Get only entries with given type (default no type, array for many types)
1898     - post_id: (integer) Get comments belonging to given post_id
1899     - cat_id: (integer or array) Get comments belonging to entries of given category ID
1900     - comment_id: (integer or array) Get comment with given ID (or IDs)
1901     - comment_site: (string) Get comments with given comment_site
1902     - comment_status: (integer) Get comments with given comment_status
1903     - comment_trackback: (integer) Get only comments (0) or trackbacks (1)
1904     - comment_ip: (string) Get comments with given IP address
1905     - post_url: Get entry with given post_url field
1906     - user_id: (integer) Get entries belonging to given user ID
1907     - q_author: Search comments by author
1908     - sql: Append SQL string at the end of the query
1909     - from: Append SQL string after "FROM" statement in query
1910     - order: Order of results (default "ORDER BY comment_dt DES")
1911     - limit: Limit parameter
1912     - sql_only : return the sql request instead of results. Only ids are selected
1913
1914     @param    params         <b>array</b>        Parameters
1915     @param    count_only     <b>boolean</b>      Only counts results
1916     @return   <b>record</b>  A record with some more capabilities
1917     */
1918     public function getComments($params=array(),$count_only=false)
1919     {
1920          if ($count_only)
1921          {
1922               $strReq = 'SELECT count(comment_id) ';
1923          }
1924          elseif (!empty($params['sql_only']))
1925          {
1926               $strReq = 'SELECT P.post_id ';
1927          }
1928          else
1929          {
1930               if (!empty($params['no_content'])) {
1931                    $content_req = '';
1932               } else {
1933                    $content_req = 'comment_content, ';
1934               }
1935
1936               if (!empty($params['columns']) && is_array($params['columns'])) {
1937                    $content_req .= implode(', ',$params['columns']).', ';
1938               }
1939
1940               $strReq =
1941               'SELECT C.comment_id, comment_dt, comment_tz, comment_upddt, '.
1942               'comment_author, comment_email, comment_site, '.
1943               $content_req.' comment_trackback, comment_status, '.
1944               'comment_spam_status, comment_spam_filter, comment_ip, '.
1945               'P.post_title, P.post_url, P.post_id, P.post_password, P.post_type, '.
1946               'P.post_dt, P.user_id, U.user_email, U.user_url ';
1947          }
1948
1949          $strReq .=
1950          'FROM '.$this->prefix.'comment C '.
1951          'INNER JOIN '.$this->prefix.'post P ON C.post_id = P.post_id '.
1952          'INNER JOIN '.$this->prefix.'user U ON P.user_id = U.user_id ';
1953
1954          if (!empty($params['from'])) {
1955               $strReq .= $params['from'].' ';
1956          }
1957
1958          $strReq .=
1959          "WHERE P.blog_id = '".$this->con->escape($this->id)."' ";
1960
1961          if (!$this->core->auth->check('contentadmin',$this->id)) {
1962               $strReq .= 'AND ((comment_status = 1 AND P.post_status = 1 ';
1963
1964               if ($this->without_password) {
1965                    $strReq .= 'AND post_password IS NULL ';
1966               }
1967               $strReq .= ') ';
1968
1969               if ($this->core->auth->userID()) {
1970                    $strReq .= "OR P.user_id = '".$this->con->escape($this->core->auth->userID())."')";
1971               } else {
1972                    $strReq .= ') ';
1973               }
1974          }
1975
1976          if (!empty($params['post_type']))
1977          {
1978               $strReq .= 'AND post_type '.$this->con->in($params['post_type']);
1979          }
1980
1981          if (isset($params['post_id']) && $params['post_id'] !== '') {
1982               $strReq .= 'AND P.post_id = '.(integer) $params['post_id'].' ';
1983          }
1984
1985          if (isset($params['cat_id']) && $params['cat_id'] !== '') {
1986               $strReq .= 'AND P.cat_id = '.(integer) $params['cat_id'].' ';
1987          }
1988
1989          if (isset($params['comment_id']) && $params['comment_id'] !== '') {
1990               if (is_array($params['comment_id'])) {
1991                    array_walk($params['comment_id'],create_function('&$v,$k','if($v!==null){$v=(integer)$v;}'));
1992               } else {
1993                    $params['comment_id'] = array((integer) $params['comment_id']);
1994               }
1995               $strReq .= 'AND comment_id '.$this->con->in($params['comment_id']);
1996          }
1997
1998          if (isset($params['comment_site'])) {
1999               $comment_site = $this->con->escape(str_replace('*','%',$params['comment_site']));
2000               $strReq .= "AND comment_site LIKE '".$comment_site."' ";
2001          }
2002
2003          if (isset($params['comment_status'])) {
2004               $strReq .= 'AND comment_status = '.(integer) $params['comment_status'].' ';
2005          }
2006
2007          if (!empty($params['comment_status_not']))
2008          {
2009               $strReq .= 'AND comment_status <> '.(integer) $params['comment_status_not'].' ';
2010          }
2011
2012          if (isset($params['comment_trackback'])) {
2013               $strReq .= 'AND comment_trackback = '.(integer) (boolean) $params['comment_trackback'].' ';
2014          }
2015
2016          if (isset($params['comment_ip'])) {
2017               $comment_ip = $this->con->escape(str_replace('*','%',$params['comment_ip']));
2018               $strReq .= "AND comment_ip LIKE '".$comment_ip."' ";
2019          }
2020
2021          if (isset($params['q_author'])) {
2022               $q_author = $this->con->escape(str_replace('*','%',strtolower($params['q_author'])));
2023               $strReq .= "AND LOWER(comment_author) LIKE '".$q_author."' ";
2024          }
2025
2026          if (!empty($params['search']))
2027          {
2028               $words = text::splitWords($params['search']);
2029
2030               if (!empty($words))
2031               {
2032                    # --BEHAVIOR coreCommentSearch
2033                    if ($this->core->hasBehavior('coreCommentSearch')) {
2034                         $this->core->callBehavior('coreCommentSearch',$this->core,array(&$words,&$strReq,&$params));
2035                    }
2036
2037                    if ($words)
2038                    {
2039                         foreach ($words as $i => $w) {
2040                              $words[$i] = "comment_words LIKE '%".$this->con->escape($w)."%'";
2041                         }
2042                         $strReq .= 'AND '.implode(' AND ',$words).' ';
2043                    }
2044               }
2045          }
2046
2047          if (!empty($params['sql'])) {
2048               $strReq .= $params['sql'].' ';
2049          }
2050
2051          if (!$count_only)
2052          {
2053               if (!empty($params['order'])) {
2054                    $strReq .= 'ORDER BY '.$this->con->escape($params['order']).' ';
2055               } else {
2056                    $strReq .= 'ORDER BY comment_dt DESC ';
2057               }
2058          }
2059
2060          if (!$count_only && !empty($params['limit'])) {
2061               $strReq .= $this->con->limit($params['limit']);
2062          }
2063
2064          if (!empty($params['sql_only'])) {
2065               return $strReq;
2066          }
2067
2068          $rs = $this->con->select($strReq);
2069          $rs->core = $this->core;
2070          $rs->extend('rsExtComment');
2071
2072          # --BEHAVIOR-- coreBlogGetComments
2073          $this->core->callBehavior('coreBlogGetComments',$rs);
2074
2075          return $rs;
2076     }
2077
2078     /**
2079     Creates a new comment. Takes a cursor as input and returns the new comment
2080     ID.
2081
2082     @param    cur       <b>cursor</b>       Comment cursor
2083     @return   <b>integer</b>      New comment ID
2084     */
2085     public function addComment($cur)
2086     {
2087          $this->con->writeLock($this->prefix.'comment');
2088          try
2089          {
2090               # Get ID
2091               $rs = $this->con->select(
2092                    'SELECT MAX(comment_id) '.
2093                    'FROM '.$this->prefix.'comment '
2094               );
2095
2096               $cur->comment_id = (integer) $rs->f(0) + 1;
2097               $cur->comment_upddt = date('Y-m-d H:i:s');
2098
2099               $offset = dt::getTimeOffset($this->settings->system->blog_timezone);
2100               $cur->comment_dt = date('Y-m-d H:i:s',time() + $offset);
2101               $cur->comment_tz = $this->settings->system->blog_timezone;
2102
2103               $this->getCommentCursor($cur);
2104
2105               if ($cur->comment_ip === null) {
2106                    $cur->comment_ip = http::realIP();
2107               }
2108
2109               # --BEHAVIOR-- coreBeforeCommentCreate
2110               $this->core->callBehavior('coreBeforeCommentCreate',$this,$cur);
2111
2112               $cur->insert();
2113               $this->con->unlock();
2114          }
2115          catch (Exception $e)
2116          {
2117               $this->con->unlock();
2118               throw $e;
2119          }
2120
2121          # --BEHAVIOR-- coreAfterCommentCreate
2122          $this->core->callBehavior('coreAfterCommentCreate',$this,$cur);
2123
2124          $this->triggerComment($cur->comment_id);
2125          if ($cur->comment_status != -2) {
2126               $this->triggerBlog();
2127          }
2128          return $cur->comment_id;
2129     }
2130
2131     /**
2132     Updates an existing comment.
2133
2134     @param    id        <b>integer</b>      Comment ID
2135     @param    cur       <b>cursor</b>       Comment cursor
2136     */
2137     public function updComment($id,$cur)
2138     {
2139          if (!$this->core->auth->check('usage,contentadmin',$this->id)) {
2140               throw new Exception(__('You are not allowed to update comments'));
2141          }
2142
2143          $id = (integer) $id;
2144
2145          if (empty($id)) {
2146               throw new Exception(__('No such comment ID'));
2147          }
2148
2149          $rs = $this->getComments(array('comment_id' => $id));
2150
2151          if ($rs->isEmpty()) {
2152               throw new Exception(__('No such comment ID'));
2153          }
2154
2155          #If user is only usage, we need to check the post's owner
2156          if (!$this->core->auth->check('contentadmin',$this->id))
2157          {
2158               if ($rs->user_id != $this->core->auth->userID()) {
2159                    throw new Exception(__('You are not allowed to update this comment'));
2160               }
2161          }
2162
2163          $this->getCommentCursor($cur);
2164
2165          $cur->comment_upddt = date('Y-m-d H:i:s');
2166
2167          if (!$this->core->auth->check('publish,contentadmin',$this->id)) {
2168               $cur->unsetField('comment_status');
2169          }
2170
2171          # --BEHAVIOR-- coreBeforeCommentUpdate
2172          $this->core->callBehavior('coreBeforeCommentUpdate',$this,$cur,$rs);
2173
2174          $cur->update('WHERE comment_id = '.$id.' ');
2175
2176          # --BEHAVIOR-- coreAfterCommentUpdate
2177          $this->core->callBehavior('coreAfterCommentUpdate',$this,$cur,$rs);
2178
2179          $this->triggerComment($id);
2180          $this->triggerBlog();
2181     }
2182
2183     /**
2184     Updates comment status.
2185
2186     @param    id        <b>integer</b>      Comment ID
2187     @param    status    <b>integer</b>      Comment status
2188     */
2189     public function updCommentStatus($id,$status)
2190     {
2191          $this->updCommentsStatus($id,$status);
2192     }
2193
2194     /**
2195     Updates comments status.
2196
2197     @param    ids       <b>mixed</b>        Comment(s) ID(s)
2198     @param    status    <b>integer</b>      Comment status
2199     */
2200     public function updCommentsStatus($ids,$status)
2201     {
2202          if (!$this->core->auth->check('publish,contentadmin',$this->id)) {
2203               throw new Exception(__("You are not allowed to change this comment's status"));
2204          }
2205
2206          $co_ids = dcUtils::cleanIds($ids);
2207          $status = (integer) $status;
2208
2209          $strReq =
2210               'UPDATE '.$this->prefix.'comment '.
2211               'SET comment_status = '.$status.' ';
2212               $strReq .=
2213               'WHERE comment_id'.$this->con->in($co_ids).
2214               'AND post_id in (SELECT tp.post_id '.
2215               'FROM '.$this->prefix.'post tp '.
2216               "WHERE tp.blog_id = '".$this->con->escape($this->id)."' ";
2217          if (!$this->core->auth->check('contentadmin',$this->id))
2218          {
2219               $strReq .=
2220                    "AND user_id = '".$this->con->escape($this->core->auth->userID())."' ";
2221          }
2222          $strReq .= ')';
2223          $this->con->execute($strReq);
2224          $this->triggerComments($co_ids);
2225          $this->triggerBlog();
2226     }
2227
2228     /**
2229     Delete a comment
2230
2231     @param    id        <b>integer</b>      Comment ID
2232     */
2233     public function delComment($id)
2234     {
2235          $this->delComments($id);
2236     }
2237
2238     /**
2239     Delete comments
2240
2241     @param    ids       <b>mixed</b>        Comment(s) ID(s)
2242     */
2243     public function delComments($ids)
2244     {
2245          if (!$this->core->auth->check('delete,contentadmin',$this->id)) {
2246               throw new Exception(__('You are not allowed to delete comments'));
2247          }
2248
2249          $co_ids = dcUtils::cleanIds($ids);
2250
2251          if (empty($co_ids)) {
2252               throw new Exception(__('No such comment ID'));
2253          }
2254
2255          # Retrieve posts affected by comments edition
2256          $affected_posts = array();
2257          $strReq =
2258               'SELECT post_id '.
2259               'FROM '.$this->prefix.'comment '.
2260               'WHERE comment_id'.$this->con->in($co_ids).
2261               'GROUP BY post_id';
2262
2263          $rs = $this->con->select($strReq);
2264
2265          while ($rs->fetch()) {
2266               $affected_posts[] = (integer) $rs->post_id;
2267          }
2268
2269               $strReq =
2270               'DELETE FROM '.$this->prefix.'comment '.
2271               'WHERE comment_id'.$this->con->in($co_ids).' '.
2272               'AND post_id in (SELECT tp.post_id '.
2273               'FROM '.$this->prefix.'post tp '.
2274               "WHERE tp.blog_id = '".$this->con->escape($this->id)."' ";
2275          #If user can only delete, we need to check the post's owner
2276          if (!$this->core->auth->check('contentadmin',$this->id))
2277          {
2278               $strReq .=
2279                    "AND tp.user_id = '".$this->con->escape($this->core->auth->userID())."' ";
2280          }
2281          $strReq .= ")";
2282          $this->con->execute($strReq);
2283          $this->triggerComments($co_ids, true, $affected_posts);
2284          $this->triggerBlog();
2285     }
2286
2287     public function delJunkComments()
2288     {
2289          if (!$this->core->auth->check('delete,contentadmin',$this->id)) {
2290               throw new Exception(__('You are not allowed to delete comments'));
2291          }
2292
2293               $strReq =
2294               'DELETE FROM '.$this->prefix.'comment '.
2295               'WHERE comment_status = -2 '.
2296               'AND post_id in (SELECT tp.post_id '.
2297               'FROM '.$this->prefix.'post tp '.
2298               "WHERE tp.blog_id = '".$this->con->escape($this->id)."' ";
2299          #If user can only delete, we need to check the post's owner
2300          if (!$this->core->auth->check('contentadmin',$this->id))
2301          {
2302               $strReq .=
2303                    "AND tp.user_id = '".$this->con->escape($this->core->auth->userID())."' ";
2304          }
2305          $strReq .= ")";
2306          $this->con->execute($strReq);
2307          $this->triggerBlog();
2308     }
2309
2310     private function getCommentCursor($cur)
2311     {
2312          if ($cur->comment_content !== null && $cur->comment_content == '') {
2313               throw new Exception(__('You must provide a comment'));
2314          }
2315
2316          if ($cur->comment_author !== null && $cur->comment_author == '') {
2317               throw new Exception(__('You must provide an author name'));
2318          }
2319
2320          if ($cur->comment_email != '' && !text::isEmail($cur->comment_email)) {
2321               throw new Exception(__('Email address is not valid.'));
2322          }
2323
2324          if ($cur->comment_site !== null && $cur->comment_site != '') {
2325               if (!preg_match('|^http(s?)://|i',$cur->comment_site, $matches)) {
2326                    $cur->comment_site = 'http://'.$cur->comment_site;
2327               }else{
2328                    $cur->comment_site = strtolower($matches[0]).substr($cur->comment_site, strlen($matches[0]));
2329               }
2330          }
2331
2332          if ($cur->comment_status === null) {
2333               $cur->comment_status = (integer) $this->settings->system->comments_pub;
2334          }
2335
2336          # Words list
2337          if ($cur->comment_content !== null)
2338          {
2339               $cur->comment_words = implode(' ',text::splitWords($cur->comment_content));
2340          }
2341     }
2342     //@}
2343}
Note: See TracBrowser for help on using the repository browser.

Sites map