class.dc.blog.php @ 1540:e74d2f707815

Visit:

Revision 1540:e74d2f707815, 60.0 KB checked in by Lepeltier kévin, 12 years ago (diff)

ticket #1430
test sur getPosts

"AND post_id not in (10,24,36) "

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

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

Dotclear

Context Navigation

source: inc/core/class.dc.blog.php @ 1540:e74d2f707815

Download in other formats:

Sites map