class.dc.blog.php @ 3423:e34ec8af1a67

Visit:

Revision 3423:e34ec8af1a67, 63.8 KB checked in by Jean-Christian Denis, 9 years ago (diff)
Add First Publication mecanism, closes #970, adresses #784, #843, #871, #548

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

Note: See TracBrowser for help on using the repository browser.

Dotclear

Context Navigation

source: inc/core/class.dc.blog.php @ 3423:e34ec8af1a67

Download in other formats:

Sites map