Dotclear

source: inc/core/class.dc.blog.php @ 833:e52d87b4cbd1

Revision 833:e52d87b4cbd1, 54.6 KB checked in by Dsls <dsls@…>, 13 years ago (diff)

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

Sites map