Context Navigation

source: trunk/include/ws_functions.inc.php @ 11118

Last change on this file since 11118 was 11118, checked in by plg, 13 years ago

merge r11117 from branch 2.2 to trunk

bug 2299 fixed: web API, method pwg.images.addSimple returns a clean error when parameter "image" is missing

Property svn:eol-style set to LF

File size: 71.4 KB

Line
1	<?php
2	// +-----------------------------------------------------------------------+
3	// \| Piwigo - a PHP based photo gallery \|
4	// +-----------------------------------------------------------------------+
5	// \| Copyright(C) 2008-2011 Piwigo Team http://piwigo.org \|
6	// \| Copyright(C) 2003-2008 PhpWebGallery Team http://phpwebgallery.net \|
7	// \| Copyright(C) 2002-2003 Pierrick LE GALL http://le-gall.net/pierrick \|
8	// +-----------------------------------------------------------------------+
9	// \| This program is free software; you can redistribute it and/or modify \|
10	// \| it under the terms of the GNU General Public License as published by \|
11	// \| the Free Software Foundation \|
12	// \| \|
13	// \| This program is distributed in the hope that it will be useful, but \|
14	// \| WITHOUT ANY WARRANTY; without even the implied warranty of \|
15	// \| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \|
16	// \| General Public License for more details. \|
17	// \| \|
18	// \| You should have received a copy of the GNU General Public License \|
19	// \| along with this program; if not, write to the Free Software \|
20	// \| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, \|
21	// \| USA. \|
22	// +-----------------------------------------------------------------------+
23
24	/** IMPLEMENTATION OF WEB SERVICE METHODS *********************************/
25
26	/**
27	* Event handler for method invocation security check. Should return a PwgError
28	* if the preconditions are not satifsied for method invocation.
29	*/
30	function ws_isInvokeAllowed($res, $methodName, $params)
31	{
32	global $conf;
33
34	if ( strpos($methodName,'reflection.')===0 )
35	{ // OK for reflection
36	return $res;
37	}
38
39	if ( !is_autorize_status(ACCESS_GUEST) and
40	strpos($methodName,'pwg.session.')!==0 )
41	{
42	return new PwgError(401, 'Access denied');
43	}
44
45	return $res;
46	}
47
48	/**
49	* returns a "standard" (for our web service) array of sql where clauses that
50	* filters the images (images table only)
51	*/
52	function ws_std_image_sql_filter( $params, $tbl_name='' )
53	{
54	$clauses = array();
55	if ( is_numeric($params['f_min_rate']) )
56	{
57	$clauses[] = $tbl_name.'average_rate>'.$params['f_min_rate'];
58	}
59	if ( is_numeric($params['f_max_rate']) )
60	{
61	$clauses[] = $tbl_name.'average_rate<='.$params['f_max_rate'];
62	}
63	if ( is_numeric($params['f_min_hit']) )
64	{
65	$clauses[] = $tbl_name.'hit>'.$params['f_min_hit'];
66	}
67	if ( is_numeric($params['f_max_hit']) )
68	{
69	$clauses[] = $tbl_name.'hit<='.$params['f_max_hit'];
70	}
71	if ( isset($params['f_min_date_available']) )
72	{
73	$clauses[] = $tbl_name."date_available>='".$params['f_min_date_available']."'";
74	}
75	if ( isset($params['f_max_date_available']) )
76	{
77	$clauses[] = $tbl_name."date_available<'".$params['f_max_date_available']."'";
78	}
79	if ( isset($params['f_min_date_created']) )
80	{
81	$clauses[] = $tbl_name."date_creation>='".$params['f_min_date_created']."'";
82	}
83	if ( isset($params['f_max_date_created']) )
84	{
85	$clauses[] = $tbl_name."date_creation<'".$params['f_max_date_created']."'";
86	}
87	if ( is_numeric($params['f_min_ratio']) )
88	{
89	$clauses[] = $tbl_name.'width/'.$tbl_name.'height>'.$params['f_min_ratio'];
90	}
91	if ( is_numeric($params['f_max_ratio']) )
92	{
93	$clauses[] = $tbl_name.'width/'.$tbl_name.'height<='.$params['f_max_ratio'];
94	}
95	if ( $params['f_with_thumbnail'] )
96	{
97	$clauses[] = $tbl_name.'tn_ext IS NOT NULL';
98	}
99	return $clauses;
100	}
101
102	/**
103	* returns a "standard" (for our web service) ORDER BY sql clause for images
104	*/
105	function ws_std_image_sql_order( $params, $tbl_name='' )
106	{
107	$ret = '';
108	if ( empty($params['order']) )
109	{
110	return $ret;
111	}
112	$matches = array();
113	preg_match_all('/([a-z_]+) (?:(asc\|desc)(?:ending)?)? (?:, *\|$)/i',
114	$params['order'], $matches);
115	for ($i=0; $i<count($matches[1]); $i++)
116	{
117	switch ($matches[1][$i])
118	{
119	case 'date_created':
120	$matches[1][$i] = 'date_creation'; break;
121	case 'date_posted':
122	$matches[1][$i] = 'date_available'; break;
123	case 'rand': case 'random':
124	$matches[1][$i] = DB_RANDOM_FUNCTION.'()'; break;
125	}
126	$sortable_fields = array('id', 'file', 'name', 'hit', 'average_rate',
127	'date_creation', 'date_available', DB_RANDOM_FUNCTION.'()' );
128	if ( in_array($matches[1][$i], $sortable_fields) )
129	{
130	if (!empty($ret))
131	$ret .= ', ';
132	if ($matches[1][$i] != DB_RANDOM_FUNCTION.'()' )
133	{
134	$ret .= $tbl_name;
135	}
136	$ret .= $matches[1][$i];
137	$ret .= ' '.$matches[2][$i];
138	}
139	}
140	return $ret;
141	}
142
143	/**
144	* returns an array map of urls (thumb/element) for image_row - to be returned
145	* in a standard way by different web service methods
146	*/
147	function ws_std_get_urls($image_row)
148	{
149	$ret = array(
150	'tn_url' => get_thumbnail_url($image_row),
151	'element_url' => get_element_url($image_row)
152	);
153	global $user;
154	if ($user['enabled_high'] and $image_row['has_high'] )
155	{
156	$ret['high_url'] = get_high_url($image_row);
157	}
158	return $ret;
159	}
160
161	/**
162	* returns an array of image attributes that are to be encoded as xml attributes
163	* instead of xml elements
164	*/
165	function ws_std_get_image_xml_attributes()
166	{
167	return array(
168	'id','tn_url','element_url','high_url', 'file','width','height','hit','date_available','date_creation'
169	);
170	}
171
172	/**
173	* returns PWG version (web service method)
174	*/
175	function ws_getVersion($params, &$service)
176	{
177	global $conf;
178	if ($conf['show_version'] or is_admin() )
179	return PHPWG_VERSION;
180	else
181	return new PwgError(403, 'Forbidden');
182	}
183
184	/**
185	* returns general informations (web service method)
186	*/
187	function ws_getInfos($params, &$service)
188	{
189	if (!is_admin())
190	{
191	return new PwgError(403, 'Forbidden');
192	}
193
194	$infos['version'] = PHPWG_VERSION;
195
196	$query = 'SELECT COUNT(*) FROM '.IMAGES_TABLE.';';
197	list($infos['nb_elements']) = pwg_db_fetch_row(pwg_query($query));
198
199	$query = 'SELECT COUNT(*) FROM '.CATEGORIES_TABLE.';';
200	list($infos['nb_categories']) = pwg_db_fetch_row(pwg_query($query));
201
202	$query = 'SELECT COUNT(*) FROM '.CATEGORIES_TABLE.' WHERE dir IS NULL;';
203	list($infos['nb_virtual']) = pwg_db_fetch_row(pwg_query($query));
204
205	$query = 'SELECT COUNT(*) FROM '.CATEGORIES_TABLE.' WHERE dir IS NOT NULL;';
206	list($infos['nb_physical']) = pwg_db_fetch_row(pwg_query($query));
207
208	$query = 'SELECT COUNT(*) FROM '.IMAGE_CATEGORY_TABLE.';';
209	list($infos['nb_image_category']) = pwg_db_fetch_row(pwg_query($query));
210
211	$query = 'SELECT COUNT(*) FROM '.TAGS_TABLE.';';
212	list($infos['nb_tags']) = pwg_db_fetch_row(pwg_query($query));
213
214	$query = 'SELECT COUNT(*) FROM '.IMAGE_TAG_TABLE.';';
215	list($infos['nb_image_tag']) = pwg_db_fetch_row(pwg_query($query));
216
217	$query = 'SELECT COUNT(*) FROM '.USERS_TABLE.';';
218	list($infos['nb_users']) = pwg_db_fetch_row(pwg_query($query));
219
220	$query = 'SELECT COUNT(*) FROM '.GROUPS_TABLE.';';
221	list($infos['nb_groups']) = pwg_db_fetch_row(pwg_query($query));
222
223	$query = 'SELECT COUNT(*) FROM '.COMMENTS_TABLE.';';
224	list($infos['nb_comments']) = pwg_db_fetch_row(pwg_query($query));
225
226	// first element
227	if ($infos['nb_elements'] > 0)
228	{
229	$query = 'SELECT MIN(date_available) FROM '.IMAGES_TABLE.';';
230	list($infos['first_date']) = pwg_db_fetch_row(pwg_query($query));
231	}
232
233	// unvalidated comments
234	if ($infos['nb_comments'] > 0)
235	{
236	$query = 'SELECT COUNT(*) FROM '.COMMENTS_TABLE.' WHERE validated=\'false\';';
237	list($infos['nb_unvalidated_comments']) = pwg_db_fetch_row(pwg_query($query));
238	}
239
240	foreach ($infos as $name => $value)
241	{
242	$output[] = array(
243	'name' => $name,
244	'value' => $value,
245	);
246	}
247
248	return array('infos' => new PwgNamedArray($output, 'item'));
249	}
250
251	function ws_caddie_add($params, &$service)
252	{
253	if (!is_admin())
254	{
255	return new PwgError(401, 'Access denied');
256	}
257	$params['image_id'] = array_map( 'intval',$params['image_id'] );
258	if ( empty($params['image_id']) )
259	{
260	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
261	}
262	global $user;
263	$query = '
264	SELECT id
265	FROM '.IMAGES_TABLE.' LEFT JOIN '.CADDIE_TABLE.' ON id=element_id AND user_id='.$user['id'].'
266	WHERE id IN ('.implode(',',$params['image_id']).')
267	AND element_id IS NULL';
268	$datas = array();
269	foreach ( array_from_query($query, 'id') as $id )
270	{
271	array_push($datas, array('element_id'=>$id, 'user_id'=>$user['id']) );
272	}
273	if (count($datas))
274	{
275	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
276	mass_inserts(CADDIE_TABLE, array('element_id','user_id'), $datas);
277	}
278	return count($datas);
279	}
280
281	/**
282	* returns images per category (web service method)
283	*/
284	function ws_categories_getImages($params, &$service)
285	{
286	@include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
287	global $user, $conf;
288
289	$images = array();
290
291	//------------------------------------------------- get the related categories
292	$where_clauses = array();
293	foreach($params['cat_id'] as $cat_id)
294	{
295	$cat_id = (int)$cat_id;
296	if ($cat_id<=0)
297	continue;
298	if ($params['recursive'])
299	{
300	$where_clauses[] = 'uppercats '.DB_REGEX_OPERATOR.' \'(^\|,)'.$cat_id.'(,\|$)\'';
301	}
302	else
303	{
304	$where_clauses[] = 'id='.$cat_id;
305	}
306	}
307	if (!empty($where_clauses))
308	{
309	$where_clauses = array( '('.
310	implode('
311	OR ', $where_clauses) . ')'
312	);
313	}
314	$where_clauses[] = get_sql_condition_FandF(
315	array('forbidden_categories' => 'id'),
316	NULL, true
317	);
318
319	$query = '
320	SELECT id, name, permalink, image_order
321	FROM '.CATEGORIES_TABLE.'
322	WHERE '. implode('
323	AND ', $where_clauses);
324	$result = pwg_query($query);
325	$cats = array();
326	while ($row = pwg_db_fetch_assoc($result))
327	{
328	$row['id'] = (int)$row['id'];
329	$cats[ $row['id'] ] = $row;
330	}
331
332	//-------------------------------------------------------- get the images
333	if ( !empty($cats) )
334	{
335	$where_clauses = ws_std_image_sql_filter( $params, 'i.' );
336	$where_clauses[] = 'category_id IN ('
337	.implode(',', array_keys($cats) )
338	.')';
339	$where_clauses[] = get_sql_condition_FandF( array(
340	'visible_images' => 'i.id'
341	), null, true
342	);
343
344	$order_by = ws_std_image_sql_order($params, 'i.');
345	if ( empty($order_by)
346	and count($params['cat_id'])==1
347	and isset($cats[ $params['cat_id'][0] ]['image_order'])
348	)
349	{
350	$order_by = $cats[ $params['cat_id'][0] ]['image_order'];
351	}
352	$order_by = empty($order_by) ? $conf['order_by'] : 'ORDER BY '.$order_by;
353
354	$query = '
355	SELECT i.*, GROUP_CONCAT(category_id) AS cat_ids
356	FROM '.IMAGES_TABLE.' i
357	INNER JOIN '.IMAGE_CATEGORY_TABLE.' ON i.id=image_id
358	WHERE '. implode('
359	AND ', $where_clauses).'
360	GROUP BY i.id
361	'.$order_by.'
362	LIMIT '.(int)$params['per_page'].' OFFSET '.(int)($params['per_page']*$params['page']);
363
364	$result = pwg_query($query);
365	while ($row = pwg_db_fetch_assoc($result))
366	{
367	$image = array();
368	foreach ( array('id', 'width', 'height', 'hit') as $k )
369	{
370	if (isset($row[$k]))
371	{
372	$image[$k] = (int)$row[$k];
373	}
374	}
375	foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
376	{
377	$image[$k] = $row[$k];
378	}
379	$image = array_merge( $image, ws_std_get_urls($row) );
380
381	$image_cats = array();
382	foreach ( explode(',', $row['cat_ids']) as $cat_id )
383	{
384	$url = make_index_url(
385	array(
386	'category' => $cats[$cat_id],
387	)
388	);
389	$page_url = make_picture_url(
390	array(
391	'category' => $cats[$cat_id],
392	'image_id' => $row['id'],
393	'image_file' => $row['file'],
394	)
395	);
396	array_push( $image_cats, array(
397	WS_XML_ATTRIBUTES => array (
398	'id' => (int)$cat_id,
399	'url' => $url,
400	'page_url' => $page_url,
401	)
402	)
403	);
404	}
405
406	$image['categories'] = new PwgNamedArray(
407	$image_cats,'category', array('id','url','page_url')
408	);
409	array_push($images, $image);
410	}
411	}
412
413	return array( 'images' =>
414	array (
415	WS_XML_ATTRIBUTES =>
416	array(
417	'page' => $params['page'],
418	'per_page' => $params['per_page'],
419	'count' => count($images)
420	),
421	WS_XML_CONTENT => new PwgNamedArray($images, 'image',
422	ws_std_get_image_xml_attributes() )
423	)
424	);
425	}
426
427
428	/**
429	* returns a list of categories (web service method)
430	*/
431	function ws_categories_getList($params, &$service)
432	{
433	global $user,$conf;
434
435	$where = array('1=1');
436	$join_type = 'INNER';
437	$join_user = $user['id'];
438
439	if (!$params['recursive'])
440	{
441	if ($params['cat_id']>0)
442	$where[] = '(id_uppercat='.(int)($params['cat_id']).'
443	OR id='.(int)($params['cat_id']).')';
444	else
445	$where[] = 'id_uppercat IS NULL';
446	}
447	else if ($params['cat_id']>0)
448	{
449	$where[] = 'uppercats '.DB_REGEX_OPERATOR.' \'(^\|,)'.
450	(int)($params['cat_id'])
451	.'(,\|$)\'';
452	}
453
454	if ($params['public'])
455	{
456	$where[] = 'status = "public"';
457	$where[] = 'visible = "true"';
458
459	$join_user = $conf['guest_id'];
460	}
461	elseif (is_admin())
462	{
463	// in this very specific case, we don't want to hide empty
464	// categories. Function calculate_permissions will only return
465	// categories that are either locked or private and not permitted
466	//
467	// calculate_permissions does not consider empty categories as forbidden
468	$forbidden_categories = calculate_permissions($user['id'], $user['status']);
469	$where[]= 'id NOT IN ('.$forbidden_categories.')';
470	$join_type = 'LEFT';
471	}
472
473	$query = '
474	SELECT id, name, permalink, uppercats, global_rank,
475	comment,
476	nb_images, count_images AS total_nb_images,
477	date_last, max_date_last, count_categories AS nb_categories
478	FROM '.CATEGORIES_TABLE.'
479	'.$join_type.' JOIN '.USER_CACHE_CATEGORIES_TABLE.' ON id=cat_id AND user_id='.$join_user.'
480	WHERE '. implode('
481	AND ', $where);
482
483	$result = pwg_query($query);
484
485	$cats = array();
486	while ($row = pwg_db_fetch_assoc($result))
487	{
488	$row['url'] = make_index_url(
489	array(
490	'category' => $row
491	)
492	);
493	foreach( array('id','nb_images','total_nb_images','nb_categories') as $key)
494	{
495	$row[$key] = (int)$row[$key];
496	}
497
498	$row['name'] = strip_tags(
499	trigger_event(
500	'render_category_name',
501	$row['name'],
502	'ws_categories_getList'
503	)
504	);
505
506	$row['comment'] = strip_tags(
507	trigger_event(
508	'render_category_description',
509	$row['comment'],
510	'ws_categories_getList'
511	)
512	);
513
514	array_push($cats, $row);
515	}
516	usort($cats, 'global_rank_compare');
517	return array(
518	'categories' => new PwgNamedArray(
519	$cats,
520	'category',
521	array(
522	'id',
523	'url',
524	'nb_images',
525	'total_nb_images',
526	'nb_categories',
527	'date_last',
528	'max_date_last',
529	)
530	)
531	);
532	}
533
534	/**
535	* returns the list of categories as you can see them in administration (web
536	* service method).
537	*
538	* Only admin can run this method and permissions are not taken into
539	* account.
540	*/
541	function ws_categories_getAdminList($params, &$service)
542	{
543	if (!is_admin())
544	{
545	return new PwgError(401, 'Access denied');
546	}
547
548	$query = '
549	SELECT
550	category_id,
551	COUNT(*) AS counter
552	FROM '.IMAGE_CATEGORY_TABLE.'
553	GROUP BY category_id
554	;';
555	$nb_images_of = simple_hash_from_query($query, 'category_id', 'counter');
556
557	$query = '
558	SELECT
559	id,
560	name,
561	comment,
562	uppercats,
563	global_rank
564	FROM '.CATEGORIES_TABLE.'
565	;';
566	$result = pwg_query($query);
567	$cats = array();
568
569	while ($row = pwg_db_fetch_assoc($result))
570	{
571	$id = $row['id'];
572	$row['nb_images'] = isset($nb_images_of[$id]) ? $nb_images_of[$id] : 0;
573	$row['name'] = strip_tags(
574	trigger_event(
575	'render_category_name',
576	$row['name'],
577	'ws_categories_getAdminList'
578	)
579	);
580	$row['comment'] = strip_tags(
581	trigger_event(
582	'render_category_description',
583	$row['comment'],
584	'ws_categories_getAdminList'
585	)
586	);
587	array_push($cats, $row);
588	}
589
590	usort($cats, 'global_rank_compare');
591	return array(
592	'categories' => new PwgNamedArray(
593	$cats,
594	'category',
595	array(
596	'id',
597	'nb_images',
598	'name',
599	'uppercats',
600	'global_rank',
601	)
602	)
603	);
604	}
605
606	/**
607	* returns detailed information for an element (web service method)
608	*/
609	function ws_images_addComment($params, &$service)
610	{
611	if (!$service->isPost())
612	{
613	return new PwgError(405, "This method requires HTTP POST");
614	}
615	$params['image_id'] = (int)$params['image_id'];
616	$query = '
617	SELECT DISTINCT image_id
618	FROM '.IMAGE_CATEGORY_TABLE.' INNER JOIN '.CATEGORIES_TABLE.' ON category_id=id
619	WHERE commentable="true"
620	AND image_id='.$params['image_id'].
621	get_sql_condition_FandF(
622	array(
623	'forbidden_categories' => 'id',
624	'visible_categories' => 'id',
625	'visible_images' => 'image_id'
626	),
627	' AND'
628	);
629	if ( !pwg_db_num_rows( pwg_query( $query ) ) )
630	{
631	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
632	}
633
634	$comm = array(
635	'author' => trim( $params['author'] ),
636	'content' => trim( $params['content'] ),
637	'image_id' => $params['image_id'],
638	);
639
640	include_once(PHPWG_ROOT_PATH.'include/functions_comment.inc.php');
641
642	$comment_action = insert_user_comment(
643	$comm, $params['key'], $infos
644	);
645
646	switch ($comment_action)
647	{
648	case 'reject':
649	array_push($infos, l10n('Your comment has NOT been registered because it did not pass the validation rules') );
650	return new PwgError(403, implode("; ", $infos) );
651	case 'validate':
652	case 'moderate':
653	$ret = array(
654	'id' => $comm['id'],
655	'validation' => $comment_action=='validate',
656	);
657	return new PwgNamedStruct(
658	'comment',
659	$ret,
660	null, array()
661	);
662	default:
663	return new PwgError(500, "Unknown comment action ".$comment_action );
664	}
665	}
666
667	/**
668	* returns detailed information for an element (web service method)
669	*/
670	function ws_images_getInfo($params, &$service)
671	{
672	@include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
673	global $user, $conf;
674	$params['image_id'] = (int)$params['image_id'];
675	if ( $params['image_id']<=0 )
676	{
677	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
678	}
679
680	$query='
681	SELECT * FROM '.IMAGES_TABLE.'
682	WHERE id='.$params['image_id'].
683	get_sql_condition_FandF(
684	array('visible_images' => 'id'),
685	' AND'
686	).'
687	LIMIT 1';
688
689	$image_row = pwg_db_fetch_assoc(pwg_query($query));
690	if ($image_row==null)
691	{
692	return new PwgError(404, "image_id not found");
693	}
694	$image_row = array_merge( $image_row, ws_std_get_urls($image_row) );
695
696	//-------------------------------------------------------- related categories
697	$query = '
698	SELECT id, name, permalink, uppercats, global_rank, commentable
699	FROM '.IMAGE_CATEGORY_TABLE.'
700	INNER JOIN '.CATEGORIES_TABLE.' ON category_id = id
701	WHERE image_id = '.$image_row['id'].
702	get_sql_condition_FandF(
703	array( 'forbidden_categories' => 'category_id' ),
704	' AND'
705	).'
706	;';
707	$result = pwg_query($query);
708	$is_commentable = false;
709	$related_categories = array();
710	while ($row = pwg_db_fetch_assoc($result))
711	{
712	if ($row['commentable']=='true')
713	{
714	$is_commentable = true;
715	}
716	unset($row['commentable']);
717	$row['url'] = make_index_url(
718	array(
719	'category' => $row
720	)
721	);
722
723	$row['page_url'] = make_picture_url(
724	array(
725	'image_id' => $image_row['id'],
726	'image_file' => $image_row['file'],
727	'category' => $row
728	)
729	);
730	$row['id']=(int)$row['id'];
731	array_push($related_categories, $row);
732	}
733	usort($related_categories, 'global_rank_compare');
734	if ( empty($related_categories) )
735	{
736	return new PwgError(401, 'Access denied');
737	}
738
739	//-------------------------------------------------------------- related tags
740	$related_tags = get_common_tags( array($image_row['id']), -1 );
741	foreach( $related_tags as $i=>$tag)
742	{
743	$tag['url'] = make_index_url(
744	array(
745	'tags' => array($tag)
746	)
747	);
748	$tag['page_url'] = make_picture_url(
749	array(
750	'image_id' => $image_row['id'],
751	'image_file' => $image_row['file'],
752	'tags' => array($tag),
753	)
754	);
755	unset($tag['counter']);
756	$tag['id']=(int)$tag['id'];
757	$related_tags[$i]=$tag;
758	}
759	//------------------------------------------------------------- related rates
760	$query = '
761	SELECT COUNT(rate) AS count
762	, ROUND(AVG(rate),2) AS average
763	FROM '.RATE_TABLE.'
764	WHERE element_id = '.$image_row['id'].'
765	;';
766	$rating = pwg_db_fetch_assoc(pwg_query($query));
767	$rating['count'] = (int)$rating['count'];
768
769	//---------------------------------------------------------- related comments
770	$related_comments = array();
771
772	$where_comments = 'image_id = '.$image_row['id'];
773	if ( !is_admin() )
774	{
775	$where_comments .= '
776	AND validated="true"';
777	}
778
779	$query = '
780	SELECT COUNT(id) AS nb_comments
781	FROM '.COMMENTS_TABLE.'
782	WHERE '.$where_comments;
783	list($nb_comments) = array_from_query($query, 'nb_comments');
784	$nb_comments = (int)$nb_comments;
785
786	if ( $nb_comments>0 and $params['comments_per_page']>0 )
787	{
788	$query = '
789	SELECT id, date, author, content
790	FROM '.COMMENTS_TABLE.'
791	WHERE '.$where_comments.'
792	ORDER BY date
793	LIMIT '.(int)$params['comments_per_page'].
794	' OFFSET '.(int)($params['comments_per_page']*$params['comments_page']);
795
796	$result = pwg_query($query);
797	while ($row = pwg_db_fetch_assoc($result))
798	{
799	$row['id']=(int)$row['id'];
800	array_push($related_comments, $row);
801	}
802	}
803
804	$comment_post_data = null;
805	if ($is_commentable and
806	(!is_a_guest()
807	or (is_a_guest() and $conf['comments_forall'] )
808	)
809	)
810	{
811	$comment_post_data['author'] = stripslashes($user['username']);
812	$comment_post_data['key'] = get_ephemeral_key(2, $params['image_id']);
813	}
814
815	$ret = $image_row;
816	foreach ( array('id','width','height','hit','filesize') as $k )
817	{
818	if (isset($ret[$k]))
819	{
820	$ret[$k] = (int)$ret[$k];
821	}
822	}
823	foreach ( array('path', 'storage_category_id') as $k )
824	{
825	unset($ret[$k]);
826	}
827
828	$ret['rates'] = array( WS_XML_ATTRIBUTES => $rating );
829	$ret['categories'] = new PwgNamedArray($related_categories, 'category', array('id','url', 'page_url') );
830	$ret['tags'] = new PwgNamedArray($related_tags, 'tag', array('id','url_name','url','name','page_url') );
831	if ( isset($comment_post_data) )
832	{
833	$ret['comment_post'] = array( WS_XML_ATTRIBUTES => $comment_post_data );
834	}
835	$ret['comments'] = array(
836	WS_XML_ATTRIBUTES =>
837	array(
838	'page' => $params['comments_page'],
839	'per_page' => $params['comments_per_page'],
840	'count' => count($related_comments),
841	'nb_comments' => $nb_comments,
842	),
843	WS_XML_CONTENT => new PwgNamedArray($related_comments, 'comment', array('id','date') )
844	);
845
846	return new PwgNamedStruct('image',$ret, null, array('name','comment') );
847	}
848
849
850	/**
851	* rates the image_id in the parameter
852	*/
853	function ws_images_Rate($params, &$service)
854	{
855	$image_id = (int)$params['image_id'];
856	$query = '
857	SELECT DISTINCT id FROM '.IMAGES_TABLE.'
858	INNER JOIN '.IMAGE_CATEGORY_TABLE.' ON id=image_id
859	WHERE id='.$image_id
860	.get_sql_condition_FandF(
861	array(
862	'forbidden_categories' => 'category_id',
863	'forbidden_images' => 'id',
864	),
865	' AND'
866	).'
867	LIMIT 1';
868	if ( pwg_db_num_rows( pwg_query($query) )==0 )
869	{
870	return new PwgError(404, "Invalid image_id or access denied" );
871	}
872	$rate = (int)$params['rate'];
873	include_once(PHPWG_ROOT_PATH.'include/functions_rate.inc.php');
874	$res = rate_picture( $image_id, $rate );
875	if ($res==false)
876	{
877	global $conf;
878	return new PwgError( 403, "Forbidden or rate not in ". implode(',',$conf['rate_items']));
879	}
880	return $res;
881	}
882
883
884	/**
885	* returns a list of elements corresponding to a query search
886	*/
887	function ws_images_search($params, &$service)
888	{
889	global $page;
890	$images = array();
891	include_once( PHPWG_ROOT_PATH .'include/functions_search.inc.php' );
892	include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
893
894	$where_clauses = ws_std_image_sql_filter( $params, 'i.' );
895	$order_by = ws_std_image_sql_order($params, 'i.');
896
897	$super_order_by = false;
898	if ( !empty($order_by) )
899	{
900	global $conf;
901	$conf['order_by'] = 'ORDER BY '.$order_by;
902	$super_order_by=true; // quick_search_result might be faster
903	}
904
905	$search_result = get_quick_search_results($params['query'],
906	$super_order_by,
907	implode(',', $where_clauses)
908	);
909
910	$image_ids = array_slice(
911	$search_result['items'],
912	$params['page']*$params['per_page'],
913	$params['per_page']
914	);
915
916	if ( count($image_ids) )
917	{
918	$query = '
919	SELECT * FROM '.IMAGES_TABLE.'
920	WHERE id IN ('.implode(',', $image_ids).')';
921
922	$image_ids = array_flip($image_ids);
923	$result = pwg_query($query);
924	while ($row = pwg_db_fetch_assoc($result))
925	{
926	$image = array();
927	foreach ( array('id', 'width', 'height', 'hit') as $k )
928	{
929	if (isset($row[$k]))
930	{
931	$image[$k] = (int)$row[$k];
932	}
933	}
934	foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
935	{
936	$image[$k] = $row[$k];
937	}
938	$image = array_merge( $image, ws_std_get_urls($row) );
939	$images[$image_ids[$image['id']]] = $image;
940	}
941	ksort($images, SORT_NUMERIC);
942	$images = array_values($images);
943	}
944
945
946	return array( 'images' =>
947	array (
948	WS_XML_ATTRIBUTES =>
949	array(
950	'page' => $params['page'],
951	'per_page' => $params['per_page'],
952	'count' => count($images)
953	),
954	WS_XML_CONTENT => new PwgNamedArray($images, 'image',
955	ws_std_get_image_xml_attributes() )
956	)
957	);
958	}
959
960	function ws_images_setPrivacyLevel($params, &$service)
961	{
962	if (!is_admin())
963	{
964	return new PwgError(401, 'Access denied');
965	}
966	if (!$service->isPost())
967	{
968	return new PwgError(405, "This method requires HTTP POST");
969	}
970	$params['image_id'] = array_map( 'intval',$params['image_id'] );
971	if ( empty($params['image_id']) )
972	{
973	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
974	}
975	global $conf;
976	if ( !in_array( (int)$params['level'], $conf['available_permission_levels']) )
977	{
978	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid level");
979	}
980
981	$query = '
982	UPDATE '.IMAGES_TABLE.'
983	SET level='.(int)$params['level'].'
984	WHERE id IN ('.implode(',',$params['image_id']).')';
985	$result = pwg_query($query);
986	$affected_rows = pwg_db_changes($result);
987	if ($affected_rows)
988	{
989	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
990	invalidate_user_cache();
991	}
992	return $affected_rows;
993	}
994
995	function ws_images_add_chunk($params, &$service)
996	{
997	global $conf;
998
999	ws_logfile('[ws_images_add_chunk] welcome');
1000	// data
1001	// original_sum
1002	// type {thumb, file, high}
1003	// position
1004
1005	if (!is_admin())
1006	{
1007	return new PwgError(401, 'Access denied');
1008	}
1009
1010	if (!$service->isPost())
1011	{
1012	return new PwgError(405, "This method requires HTTP POST");
1013	}
1014
1015	foreach ($params as $param_key => $param_value) {
1016	if ('data' == $param_key) {
1017	continue;
1018	}
1019
1020	ws_logfile(
1021	sprintf(
1022	'[ws_images_add_chunk] input param "%s" : "%s"',
1023	$param_key,
1024	is_null($param_value) ? 'NULL' : $param_value
1025	)
1026	);
1027	}
1028
1029	$upload_dir = $conf['upload_dir'].'/buffer';
1030
1031	// create the upload directory tree if not exists
1032	if (!is_dir($upload_dir)) {
1033	umask(0000);
1034	$recursive = true;
1035	if (!@mkdir($upload_dir, 0777, $recursive))
1036	{
1037	return new PwgError(500, 'error during buffer directory creation');
1038	}
1039	}
1040
1041	if (!is_writable($upload_dir))
1042	{
1043	// last chance to make the directory writable
1044	@chmod($upload_dir, 0777);
1045
1046	if (!is_writable($upload_dir))
1047	{
1048	return new PwgError(500, 'buffer directory has no write access');
1049	}
1050	}
1051
1052	secure_directory($upload_dir);
1053
1054	$filename = sprintf(
1055	'%s-%s-%05u.block',
1056	$params['original_sum'],
1057	$params['type'],
1058	$params['position']
1059	);
1060
1061	ws_logfile('[ws_images_add_chunk] data length : '.strlen($params['data']));
1062
1063	$bytes_written = file_put_contents(
1064	$upload_dir.'/'.$filename,
1065	base64_decode($params['data'])
1066	);
1067
1068	if (false === $bytes_written) {
1069	return new PwgError(
1070	500,
1071	'an error has occured while writting chunk '.$params['position'].' for '.$params['type']
1072	);
1073	}
1074	}
1075
1076	function merge_chunks($output_filepath, $original_sum, $type)
1077	{
1078	global $conf;
1079
1080	ws_logfile('[merge_chunks] input parameter $output_filepath : '.$output_filepath);
1081
1082	if (is_file($output_filepath))
1083	{
1084	unlink($output_filepath);
1085
1086	if (is_file($output_filepath))
1087	{
1088	new PwgError(500, '[merge_chunks] error while trying to remove existing '.$output_filepath);
1089	exit();
1090	}
1091	}
1092
1093	$upload_dir = $conf['upload_dir'].'/buffer';
1094	$pattern = '/'.$original_sum.'-'.$type.'/';
1095	$chunks = array();
1096
1097	if ($handle = opendir($upload_dir))
1098	{
1099	while (false !== ($file = readdir($handle)))
1100	{
1101	if (preg_match($pattern, $file))
1102	{
1103	ws_logfile($file);
1104	array_push($chunks, $upload_dir.'/'.$file);
1105	}
1106	}
1107	closedir($handle);
1108	}
1109
1110	sort($chunks);
1111
1112	if (function_exists('memory_get_usage')) {
1113	ws_logfile('[merge_chunks] memory_get_usage before loading chunks: '.memory_get_usage());
1114	}
1115
1116	$i = 0;
1117
1118	foreach ($chunks as $chunk)
1119	{
1120	$string = file_get_contents($chunk);
1121
1122	if (function_exists('memory_get_usage')) {
1123	ws_logfile('[merge_chunks] memory_get_usage on chunk '.++$i.': '.memory_get_usage());
1124	}
1125
1126	if (!file_put_contents($output_filepath, $string, FILE_APPEND))
1127	{
1128	new PwgError(500, '[merge_chunks] error while writting chunks for '.$output_filepath);
1129	exit();
1130	}
1131
1132	unlink($chunk);
1133	}
1134
1135	if (function_exists('memory_get_usage')) {
1136	ws_logfile('[merge_chunks] memory_get_usage after loading chunks: '.memory_get_usage());
1137	}
1138	}
1139
1140	/*
1141	* The $file_path must be the path of the basic "web sized" photo
1142	* The $type value will automatically modify the $file_path to the corresponding file
1143	*/
1144	function add_file($file_path, $type, $original_sum, $file_sum)
1145	{
1146	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1147
1148	$file_path = file_path_for_type($file_path, $type);
1149
1150	$upload_dir = dirname($file_path);
1151	if (substr(PHP_OS, 0, 3) == 'WIN')
1152	{
1153	$upload_dir = str_replace('/', DIRECTORY_SEPARATOR, $upload_dir);
1154	}
1155
1156	ws_logfile('[add_file] file_path : '.$file_path);
1157	ws_logfile('[add_file] upload_dir : '.$upload_dir);
1158
1159	if (!is_dir($upload_dir)) {
1160	umask(0000);
1161	$recursive = true;
1162	if (!@mkdir($upload_dir, 0777, $recursive))
1163	{
1164	new PwgError(500, '[add_file] error during '.$type.' directory creation');
1165	exit();
1166	}
1167	}
1168
1169	if (!is_writable($upload_dir))
1170	{
1171	// last chance to make the directory writable
1172	@chmod($upload_dir, 0777);
1173
1174	if (!is_writable($upload_dir))
1175	{
1176	new PwgError(500, '[add_file] '.$type.' directory has no write access');
1177	exit();
1178	}
1179	}
1180
1181	secure_directory($upload_dir);
1182
1183	// merge the thumbnail
1184	merge_chunks($file_path, $original_sum, $type);
1185	chmod($file_path, 0644);
1186
1187	// check dumped thumbnail md5
1188	$dumped_md5 = md5_file($file_path);
1189	if ($dumped_md5 != $file_sum) {
1190	new PwgError(500, '[add_file] '.$type.' transfer failed');
1191	exit();
1192	}
1193
1194	list($width, $height) = getimagesize($file_path);
1195	$filesize = floor(filesize($file_path)/1024);
1196
1197	return array(
1198	'width' => $width,
1199	'height' => $height,
1200	'filesize' => $filesize,
1201	);
1202	}
1203
1204	function ws_images_addFile($params, &$service)
1205	{
1206	// image_id
1207	// type {thumb, file, high}
1208	// sum
1209
1210	global $conf;
1211	if (!is_admin())
1212	{
1213	return new PwgError(401, 'Access denied');
1214	}
1215
1216	$params['image_id'] = (int)$params['image_id'];
1217	if ($params['image_id'] <= 0)
1218	{
1219	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1220	}
1221
1222	//
1223	// what is the path?
1224	//
1225	$query = '
1226	SELECT
1227	path,
1228	md5sum
1229	FROM '.IMAGES_TABLE.'
1230	WHERE id = '.$params['image_id'].'
1231	;';
1232	list($file_path, $original_sum) = pwg_db_fetch_row(pwg_query($query));
1233
1234	// TODO only files added with web API can be updated with web API
1235
1236	//
1237	// makes sure directories are there and call the merge_chunks
1238	//
1239	$infos = add_file($file_path, $params['type'], $original_sum, $params['sum']);
1240
1241	//
1242	// update basic metadata from file
1243	//
1244	$update = array();
1245
1246	if ('high' == $params['type'])
1247	{
1248	$update['high_filesize'] = $infos['filesize'];
1249	$update['high_width'] = $infos['width'];
1250	$update['high_height'] = $infos['height'];
1251	$update['has_high'] = 'true';
1252	}
1253
1254	if ('file' == $params['type'])
1255	{
1256	$update['filesize'] = $infos['filesize'];
1257	$update['width'] = $infos['width'];
1258	$update['height'] = $infos['height'];
1259	}
1260
1261	// we may have nothing to update at database level, for example with a
1262	// thumbnail update
1263	if (count($update) > 0)
1264	{
1265	$update['id'] = $params['image_id'];
1266
1267	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1268	mass_updates(
1269	IMAGES_TABLE,
1270	array(
1271	'primary' => array('id'),
1272	'update' => array_diff(array_keys($update), array('id'))
1273	),
1274	array($update)
1275	);
1276	}
1277	}
1278
1279	function ws_images_add($params, &$service)
1280	{
1281	global $conf, $user;
1282	if (!is_admin())
1283	{
1284	return new PwgError(401, 'Access denied');
1285	}
1286
1287	foreach ($params as $param_key => $param_value) {
1288	ws_logfile(
1289	sprintf(
1290	'[pwg.images.add] input param "%s" : "%s"',
1291	$param_key,
1292	is_null($param_value) ? 'NULL' : $param_value
1293	)
1294	);
1295	}
1296
1297	// does the image already exists ?
1298	if ('md5sum' == $conf['uniqueness_mode'])
1299	{
1300	$where_clause = "md5sum = '".$params['original_sum']."'";
1301	}
1302	if ('filename' == $conf['uniqueness_mode'])
1303	{
1304	$where_clause = "file = '".$params['original_filename']."'";
1305	}
1306
1307	$query = '
1308	SELECT
1309	COUNT(*) AS counter
1310	FROM '.IMAGES_TABLE.'
1311	WHERE '.$where_clause.'
1312	;';
1313	list($counter) = pwg_db_fetch_row(pwg_query($query));
1314	if ($counter != 0) {
1315	return new PwgError(500, 'file already exists');
1316	}
1317
1318	// current date
1319	list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
1320	list($year, $month, $day) = preg_split('/[^\d]/', $dbnow, 4);
1321
1322	// upload directory hierarchy
1323	$upload_dir = sprintf(
1324	$conf['upload_dir'].'/%s/%s/%s',
1325	$year,
1326	$month,
1327	$day
1328	);
1329
1330	// compute file path
1331	$date_string = preg_replace('/[^\d]/', '', $dbnow);
1332	$random_string = substr($params['file_sum'], 0, 8);
1333	$filename_wo_ext = $date_string.'-'.$random_string;
1334	$file_path = $upload_dir.'/'.$filename_wo_ext.'.jpg';
1335
1336	// add files
1337	$file_infos = add_file($file_path, 'file', $params['original_sum'], $params['file_sum']);
1338	$thumb_infos = add_file($file_path, 'thumb', $params['original_sum'], $params['thumbnail_sum']);
1339
1340	if (isset($params['high_sum']))
1341	{
1342	$high_infos = add_file($file_path, 'high', $params['original_sum'], $params['high_sum']);
1343	}
1344
1345	// database registration
1346	$insert = array(
1347	'file' => !empty($params['original_filename']) ? $params['original_filename'] : $filename_wo_ext.'.jpg',
1348	'date_available' => $dbnow,
1349	'tn_ext' => 'jpg',
1350	'name' => $params['name'],
1351	'path' => $file_path,
1352	'filesize' => $file_infos['filesize'],
1353	'width' => $file_infos['width'],
1354	'height' => $file_infos['height'],
1355	'md5sum' => $params['original_sum'],
1356	'added_by' => $user['id'],
1357	);
1358
1359	$info_columns = array(
1360	'name',
1361	'author',
1362	'comment',
1363	'level',
1364	'date_creation',
1365	);
1366
1367	foreach ($info_columns as $key)
1368	{
1369	if (isset($params[$key]))
1370	{
1371	$insert[$key] = $params[$key];
1372	}
1373	}
1374
1375	if (isset($params['high_sum']))
1376	{
1377	$insert['has_high'] = 'true';
1378	$insert['high_filesize'] = $high_infos['filesize'];
1379	$insert['high_width'] = $high_infos['width'];
1380	$insert['high_height'] = $high_infos['height'];
1381	}
1382
1383	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1384	mass_inserts(
1385	IMAGES_TABLE,
1386	array_keys($insert),
1387	array($insert)
1388	);
1389
1390	$image_id = pwg_db_insert_id(IMAGES_TABLE);
1391
1392	// let's add links between the image and the categories
1393	if (isset($params['categories']))
1394	{
1395	ws_add_image_category_relations($image_id, $params['categories']);
1396	}
1397
1398	// and now, let's create tag associations
1399	if (isset($params['tag_ids']) and !empty($params['tag_ids']))
1400	{
1401	set_tags(
1402	explode(',', $params['tag_ids']),
1403	$image_id
1404	);
1405	}
1406
1407	// update metadata from the uploaded file (exif/iptc)
1408	require_once(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
1409	update_metadata(array($image_id=>$file_path));
1410
1411	invalidate_user_cache();
1412	}
1413
1414	function ws_images_addSimple($params, &$service)
1415	{
1416	global $conf;
1417	if (!is_admin())
1418	{
1419	return new PwgError(401, 'Access denied');
1420	}
1421
1422	if (!$service->isPost())
1423	{
1424	return new PwgError(405, "This method requires HTTP POST");
1425	}
1426
1427	if (!isset($_FILES['image']))
1428	{
1429	return new PwgError(405, "The image (file) parameter is missing");
1430	}
1431
1432	$params['image_id'] = (int)$params['image_id'];
1433	if ($params['image_id'] > 0)
1434	{
1435	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1436
1437	$query='
1438	SELECT *
1439	FROM '.IMAGES_TABLE.'
1440	WHERE id = '.$params['image_id'].'
1441	;';
1442
1443	$image_row = pwg_db_fetch_assoc(pwg_query($query));
1444	if ($image_row == null)
1445	{
1446	return new PwgError(404, "image_id not found");
1447	}
1448	}
1449
1450	// category
1451	$params['category'] = (int)$params['category'];
1452	if ($params['category'] <= 0 and $params['image_id'] <= 0)
1453	{
1454	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
1455	}
1456
1457	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1458
1459	$image_id = add_uploaded_file(
1460	$_FILES['image']['tmp_name'],
1461	$_FILES['image']['name'],
1462	$params['category'] > 0 ? array($params['category']) : null,
1463	8,
1464	$params['image_id'] > 0 ? $params['image_id'] : null
1465	);
1466
1467	$info_columns = array(
1468	'name',
1469	'author',
1470	'comment',
1471	'level',
1472	'date_creation',
1473	);
1474
1475	foreach ($info_columns as $key)
1476	{
1477	if (isset($params[$key]))
1478	{
1479	$update[$key] = $params[$key];
1480	}
1481	}
1482
1483	if (count(array_keys($update)) > 0)
1484	{
1485	$update['id'] = $image_id;
1486
1487	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1488	mass_updates(
1489	IMAGES_TABLE,
1490	array(
1491	'primary' => array('id'),
1492	'update' => array_diff(array_keys($update), array('id'))
1493	),
1494	array($update)
1495	);
1496	}
1497
1498
1499	if (isset($params['tags']) and !empty($params['tags']))
1500	{
1501	$tag_ids = array();
1502	$tag_names = explode(',', $params['tags']);
1503	foreach ($tag_names as $tag_name)
1504	{
1505	$tag_id = tag_id_from_tag_name($tag_name);
1506	array_push($tag_ids, $tag_id);
1507	}
1508
1509	add_tags($tag_ids, array($image_id));
1510	}
1511
1512	$url_params = array('image_id' => $image_id);
1513
1514	if ($params['category'] > 0)
1515	{
1516	$query = '
1517	SELECT id, name, permalink
1518	FROM '.CATEGORIES_TABLE.'
1519	WHERE id = '.$params['category'].'
1520	;';
1521	$result = pwg_query($query);
1522	$category = pwg_db_fetch_assoc($result);
1523
1524	$url_params['section'] = 'categories';
1525	$url_params['category'] = $category;
1526	}
1527
1528	// update metadata from the uploaded file (exif/iptc), even if the sync
1529	// was already performed by add_uploaded_file().
1530	$query = '
1531	SELECT
1532	path
1533	FROM '.IMAGES_TABLE.'
1534	WHERE id = '.$image_id.'
1535	;';
1536	list($file_path) = pwg_db_fetch_row(pwg_query($query));
1537
1538	require_once(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
1539	update_metadata(array($image_id=>$file_path));
1540
1541	return array(
1542	'image_id' => $image_id,
1543	'url' => make_picture_url($url_params),
1544	);
1545	}
1546
1547	/**
1548	* perform a login (web service method)
1549	*/
1550	function ws_session_login($params, &$service)
1551	{
1552	global $conf;
1553
1554	if (!$service->isPost())
1555	{
1556	return new PwgError(405, "This method requires HTTP POST");
1557	}
1558	if (try_log_user($params['username'], $params['password'],false))
1559	{
1560	return true;
1561	}
1562	return new PwgError(999, 'Invalid username/password');
1563	}
1564
1565
1566	/**
1567	* performs a logout (web service method)
1568	*/
1569	function ws_session_logout($params, &$service)
1570	{
1571	if (!is_a_guest())
1572	{
1573	logout_user();
1574	}
1575	return true;
1576	}
1577
1578	function ws_session_getStatus($params, &$service)
1579	{
1580	global $user;
1581	$res = array();
1582	$res['username'] = is_a_guest() ? 'guest' : stripslashes($user['username']);
1583	foreach ( array('status', 'theme', 'language') as $k )
1584	{
1585	$res[$k] = $user[$k];
1586	}
1587	$res['pwg_token'] = get_pwg_token();
1588	$res['charset'] = get_pwg_charset();
1589	return $res;
1590	}
1591
1592
1593	/**
1594	* returns a list of tags (web service method)
1595	*/
1596	function ws_tags_getList($params, &$service)
1597	{
1598	$tags = get_available_tags();
1599	if ($params['sort_by_counter'])
1600	{
1601	usort($tags, create_function('$a,$b', 'return -$a["counter"]+$b["counter"];') );
1602	}
1603	else
1604	{
1605	usort($tags, 'tag_alpha_compare');
1606	}
1607	for ($i=0; $i<count($tags); $i++)
1608	{
1609	$tags[$i]['id'] = (int)$tags[$i]['id'];
1610	$tags[$i]['counter'] = (int)$tags[$i]['counter'];
1611	$tags[$i]['url'] = make_index_url(
1612	array(
1613	'section'=>'tags',
1614	'tags'=>array($tags[$i])
1615	)
1616	);
1617	}
1618	return array('tags' => new PwgNamedArray($tags, 'tag', array('id','url_name','url', 'name', 'counter' )) );
1619	}
1620
1621	/**
1622	* returns the list of tags as you can see them in administration (web
1623	* service method).
1624	*
1625	* Only admin can run this method and permissions are not taken into
1626	* account.
1627	*/
1628	function ws_tags_getAdminList($params, &$service)
1629	{
1630	if (!is_admin())
1631	{
1632	return new PwgError(401, 'Access denied');
1633	}
1634
1635	$tags = get_all_tags();
1636	return array(
1637	'tags' => new PwgNamedArray(
1638	$tags,
1639	'tag',
1640	array(
1641	'name',
1642	'id',
1643	'url_name',
1644	)
1645	)
1646	);
1647	}
1648
1649	/**
1650	* returns a list of images for tags (web service method)
1651	*/
1652	function ws_tags_getImages($params, &$service)
1653	{
1654	@include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
1655	global $conf;
1656
1657	// first build all the tag_ids we are interested in
1658	$params['tag_id'] = array_map( 'intval',$params['tag_id'] );
1659	$tags = find_tags($params['tag_id'], $params['tag_url_name'], $params['tag_name']);
1660	$tags_by_id = array();
1661	foreach( $tags as $tag )
1662	{
1663	$tags['id'] = (int)$tag['id'];
1664	$tags_by_id[ $tag['id'] ] = $tag;
1665	}
1666	unset($tags);
1667	$tag_ids = array_keys($tags_by_id);
1668
1669
1670	$where_clauses = ws_std_image_sql_filter($params);
1671	if (!empty($where_clauses))
1672	{
1673	$where_clauses = implode( ' AND ', $where_clauses);
1674	}
1675	$image_ids = get_image_ids_for_tags(
1676	$tag_ids,
1677	$params['tag_mode_and'] ? 'AND' : 'OR',
1678	$where_clauses,
1679	ws_std_image_sql_order($params) );
1680
1681
1682	$image_ids = array_slice($image_ids, (int)($params['per_page']*$params['page']), (int)$params['per_page'] );
1683
1684	$image_tag_map = array();
1685	if ( !empty($image_ids) and !$params['tag_mode_and'] )
1686	{ // build list of image ids with associated tags per image
1687	$query = '
1688	SELECT image_id, GROUP_CONCAT(tag_id) AS tag_ids
1689	FROM '.IMAGE_TAG_TABLE.'
1690	WHERE tag_id IN ('.implode(',',$tag_ids).') AND image_id IN ('.implode(',',$image_ids).')
1691	GROUP BY image_id';
1692	$result = pwg_query($query);
1693	while ( $row=pwg_db_fetch_assoc($result) )
1694	{
1695	$row['image_id'] = (int)$row['image_id'];
1696	array_push( $image_ids, $row['image_id'] );
1697	$image_tag_map[ $row['image_id'] ] = explode(',', $row['tag_ids']);
1698	}
1699	}
1700
1701	$images = array();
1702	if (!empty($image_ids))
1703	{
1704	$rank_of = array_flip($image_ids);
1705	$result = pwg_query('
1706	SELECT * FROM '.IMAGES_TABLE.'
1707	WHERE id IN ('.implode(',',$image_ids).')');
1708	while ($row = pwg_db_fetch_assoc($result))
1709	{
1710	$image = array();
1711	$image['rank'] = $rank_of[ $row['id'] ];
1712	foreach ( array('id', 'width', 'height', 'hit') as $k )
1713	{
1714	if (isset($row[$k]))
1715	{
1716	$image[$k] = (int)$row[$k];
1717	}
1718	}
1719	foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
1720	{
1721	$image[$k] = $row[$k];
1722	}
1723	$image = array_merge( $image, ws_std_get_urls($row) );
1724
1725	$image_tag_ids = ($params['tag_mode_and']) ? $tag_ids : $image_tag_map[$image['id']];
1726	$image_tags = array();
1727	foreach ($image_tag_ids as $tag_id)
1728	{
1729	$url = make_index_url(
1730	array(
1731	'section'=>'tags',
1732	'tags'=> array($tags_by_id[$tag_id])
1733	)
1734	);
1735	$page_url = make_picture_url(
1736	array(
1737	'section'=>'tags',
1738	'tags'=> array($tags_by_id[$tag_id]),
1739	'image_id' => $row['id'],
1740	'image_file' => $row['file'],
1741	)
1742	);
1743	array_push($image_tags, array(
1744	'id' => (int)$tag_id,
1745	'url' => $url,
1746	'page_url' => $page_url,
1747	)
1748	);
1749	}
1750	$image['tags'] = new PwgNamedArray($image_tags, 'tag',
1751	array('id','url_name','url','page_url')
1752	);
1753	array_push($images, $image);
1754	}
1755	usort($images, 'rank_compare');
1756	unset($rank_of);
1757	}
1758
1759	return array( 'images' =>
1760	array (
1761	WS_XML_ATTRIBUTES =>
1762	array(
1763	'page' => $params['page'],
1764	'per_page' => $params['per_page'],
1765	'count' => count($images)
1766	),
1767	WS_XML_CONTENT => new PwgNamedArray($images, 'image',
1768	ws_std_get_image_xml_attributes() )
1769	)
1770	);
1771	}
1772
1773	function ws_categories_add($params, &$service)
1774	{
1775	if (!is_admin())
1776	{
1777	return new PwgError(401, 'Access denied');
1778	}
1779
1780	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1781
1782	$creation_output = create_virtual_category(
1783	$params['name'],
1784	$params['parent']
1785	);
1786
1787	if (isset($creation_output['error']))
1788	{
1789	return new PwgError(500, $creation_output['error']);
1790	}
1791
1792	invalidate_user_cache();
1793
1794	return $creation_output;
1795	}
1796
1797	function ws_tags_add($params, &$service)
1798	{
1799	if (!is_admin())
1800	{
1801	return new PwgError(401, 'Access denied');
1802	}
1803
1804	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1805
1806	$creation_output = create_tag($params['name']);
1807
1808	if (isset($creation_output['error']))
1809	{
1810	return new PwgError(500, $creation_output['error']);
1811	}
1812
1813	return $creation_output;
1814	}
1815
1816	function ws_images_exist($params, &$service)
1817	{
1818	global $conf;
1819
1820	if (!is_admin())
1821	{
1822	return new PwgError(401, 'Access denied');
1823	}
1824
1825	$split_pattern = '/[\s,;\\|]/';
1826
1827	if ('md5sum' == $conf['uniqueness_mode'])
1828	{
1829	// search among photos the list of photos already added, based on md5sum
1830	// list
1831	$md5sums = preg_split(
1832	$split_pattern,
1833	$params['md5sum_list'],
1834	-1,
1835	PREG_SPLIT_NO_EMPTY
1836	);
1837
1838	$query = '
1839	SELECT
1840	id,
1841	md5sum
1842	FROM '.IMAGES_TABLE.'
1843	WHERE md5sum IN (\''.implode("','", $md5sums).'\')
1844	;';
1845	$id_of_md5 = simple_hash_from_query($query, 'md5sum', 'id');
1846
1847	$result = array();
1848
1849	foreach ($md5sums as $md5sum)
1850	{
1851	$result[$md5sum] = null;
1852	if (isset($id_of_md5[$md5sum]))
1853	{
1854	$result[$md5sum] = $id_of_md5[$md5sum];
1855	}
1856	}
1857	}
1858
1859	if ('filename' == $conf['uniqueness_mode'])
1860	{
1861	// search among photos the list of photos already added, based on
1862	// filename list
1863	$filenames = preg_split(
1864	$split_pattern,
1865	$params['filename_list'],
1866	-1,
1867	PREG_SPLIT_NO_EMPTY
1868	);
1869
1870	$query = '
1871	SELECT
1872	id,
1873	file
1874	FROM '.IMAGES_TABLE.'
1875	WHERE file IN (\''.implode("','", $filenames).'\')
1876	;';
1877	$id_of_filename = simple_hash_from_query($query, 'file', 'id');
1878
1879	$result = array();
1880
1881	foreach ($filenames as $filename)
1882	{
1883	$result[$filename] = null;
1884	if (isset($id_of_filename[$filename]))
1885	{
1886	$result[$filename] = $id_of_filename[$filename];
1887	}
1888	}
1889	}
1890
1891	return $result;
1892	}
1893
1894	function ws_images_checkFiles($params, &$service)
1895	{
1896	if (!is_admin())
1897	{
1898	return new PwgError(401, 'Access denied');
1899	}
1900
1901	// input parameters
1902	//
1903	// image_id
1904	// thumbnail_sum
1905	// file_sum
1906	// high_sum
1907
1908	$params['image_id'] = (int)$params['image_id'];
1909	if ($params['image_id'] <= 0)
1910	{
1911	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1912	}
1913
1914	$query = '
1915	SELECT
1916	path
1917	FROM '.IMAGES_TABLE.'
1918	WHERE id = '.$params['image_id'].'
1919	;';
1920	$result = pwg_query($query);
1921	if (pwg_db_num_rows($result) == 0) {
1922	return new PwgError(404, "image_id not found");
1923	}
1924	list($path) = pwg_db_fetch_row($result);
1925
1926	$ret = array();
1927
1928	foreach (array('thumb', 'file', 'high') as $type) {
1929	$param_name = $type;
1930	if ('thumb' == $type) {
1931	$param_name = 'thumbnail';
1932	}
1933
1934	if (isset($params[$param_name.'_sum'])) {
1935	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1936	$type_path = file_path_for_type($path, $type);
1937	if (!is_file($type_path)) {
1938	$ret[$param_name] = 'missing';
1939	}
1940	else {
1941	if (md5_file($type_path) != $params[$param_name.'_sum']) {
1942	$ret[$param_name] = 'differs';
1943	}
1944	else {
1945	$ret[$param_name] = 'equals';
1946	}
1947	}
1948	}
1949	}
1950
1951	return $ret;
1952	}
1953
1954	function ws_images_setInfo($params, &$service)
1955	{
1956	global $conf;
1957	if (!is_admin())
1958	{
1959	return new PwgError(401, 'Access denied');
1960	}
1961
1962	if (!$service->isPost())
1963	{
1964	return new PwgError(405, "This method requires HTTP POST");
1965	}
1966
1967	$params['image_id'] = (int)$params['image_id'];
1968	if ($params['image_id'] <= 0)
1969	{
1970	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1971	}
1972
1973	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1974
1975	$query='
1976	SELECT *
1977	FROM '.IMAGES_TABLE.'
1978	WHERE id = '.$params['image_id'].'
1979	;';
1980
1981	$image_row = pwg_db_fetch_assoc(pwg_query($query));
1982	if ($image_row == null)
1983	{
1984	return new PwgError(404, "image_id not found");
1985	}
1986
1987	// database registration
1988	$update = array();
1989
1990	$info_columns = array(
1991	'name',
1992	'author',
1993	'comment',
1994	'level',
1995	'date_creation',
1996	);
1997
1998	foreach ($info_columns as $key)
1999	{
2000	if (isset($params[$key]))
2001	{
2002	if ('fill_if_empty' == $params['single_value_mode'])
2003	{
2004	if (empty($image_row[$key]))
2005	{
2006	$update[$key] = $params[$key];
2007	}
2008	}
2009	elseif ('replace' == $params['single_value_mode'])
2010	{
2011	$update[$key] = $params[$key];
2012	}
2013	else
2014	{
2015	new PwgError(
2016	500,
2017	'[ws_images_setInfo]'
2018	.' invalid parameter single_value_mode "'.$params['single_value_mode'].'"'
2019	.', possible values are {fill_if_empty, replace}.'
2020	);
2021	exit();
2022	}
2023	}
2024	}
2025
2026	if (count(array_keys($update)) > 0)
2027	{
2028	$update['id'] = $params['image_id'];
2029
2030	mass_updates(
2031	IMAGES_TABLE,
2032	array(
2033	'primary' => array('id'),
2034	'update' => array_diff(array_keys($update), array('id'))
2035	),
2036	array($update)
2037	);
2038	}
2039
2040	if (isset($params['categories']))
2041	{
2042	ws_add_image_category_relations(
2043	$params['image_id'],
2044	$params['categories'],
2045	('replace' == $params['multiple_value_mode'] ? true : false)
2046	);
2047	}
2048
2049	// and now, let's create tag associations
2050	if (isset($params['tag_ids']))
2051	{
2052	$tag_ids = explode(',', $params['tag_ids']);
2053
2054	if ('replace' == $params['multiple_value_mode'])
2055	{
2056	set_tags(
2057	$tag_ids,
2058	$params['image_id']
2059	);
2060	}
2061	elseif ('append' == $params['multiple_value_mode'])
2062	{
2063	add_tags(
2064	$tag_ids,
2065	array($params['image_id'])
2066	);
2067	}
2068	else
2069	{
2070	new PwgError(
2071	500,
2072	'[ws_images_setInfo]'
2073	.' invalid parameter multiple_value_mode "'.$params['multiple_value_mode'].'"'
2074	.', possible values are {replace, append}.'
2075	);
2076	exit();
2077	}
2078	}
2079
2080	invalidate_user_cache();
2081	}
2082
2083	function ws_images_delete($params, &$service)
2084	{
2085	global $conf;
2086	if (!is_admin())
2087	{
2088	return new PwgError(401, 'Access denied');
2089	}
2090
2091	if (!$service->isPost())
2092	{
2093	return new PwgError(405, "This method requires HTTP POST");
2094	}
2095
2096	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2097	{
2098	return new PwgError(403, 'Invalid security token');
2099	}
2100
2101	$params['image_id'] = preg_split(
2102	'/[\s,;\\|]/',
2103	$params['image_id'],
2104	-1,
2105	PREG_SPLIT_NO_EMPTY
2106	);
2107	$params['image_id'] = array_map('intval', $params['image_id']);
2108
2109	$image_ids = array();
2110	foreach ($params['image_id'] as $image_id)
2111	{
2112	if ($image_id > 0)
2113	{
2114	array_push($image_ids, $image_id);
2115	}
2116	}
2117
2118	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2119	delete_elements($image_ids, true);
2120	}
2121
2122	function ws_add_image_category_relations($image_id, $categories_string, $replace_mode=false)
2123	{
2124	// let's add links between the image and the categories
2125	//
2126	// $params['categories'] should look like 123,12;456,auto;789 which means:
2127	//
2128	// 1. associate with category 123 on rank 12
2129	// 2. associate with category 456 on automatic rank
2130	// 3. associate with category 789 on automatic rank
2131	$cat_ids = array();
2132	$rank_on_category = array();
2133	$search_current_ranks = false;
2134
2135	$tokens = explode(';', $categories_string);
2136	foreach ($tokens as $token)
2137	{
2138	@list($cat_id, $rank) = explode(',', $token);
2139
2140	if (!preg_match('/^\d+$/', $cat_id))
2141	{
2142	continue;
2143	}
2144
2145	array_push($cat_ids, $cat_id);
2146
2147	if (!isset($rank))
2148	{
2149	$rank = 'auto';
2150	}
2151	$rank_on_category[$cat_id] = $rank;
2152
2153	if ($rank == 'auto')
2154	{
2155	$search_current_ranks = true;
2156	}
2157	}
2158
2159	$cat_ids = array_unique($cat_ids);
2160
2161	if (count($cat_ids) == 0)
2162	{
2163	new PwgError(
2164	500,
2165	'[ws_add_image_category_relations] there is no category defined in "'.$categories_string.'"'
2166	);
2167	exit();
2168	}
2169
2170	$query = '
2171	SELECT
2172	id
2173	FROM '.CATEGORIES_TABLE.'
2174	WHERE id IN ('.implode(',', $cat_ids).')
2175	;';
2176	$db_cat_ids = array_from_query($query, 'id');
2177
2178	$unknown_cat_ids = array_diff($cat_ids, $db_cat_ids);
2179	if (count($unknown_cat_ids) != 0)
2180	{
2181	new PwgError(
2182	500,
2183	'[ws_add_image_category_relations] the following categories are unknown: '.implode(', ', $unknown_cat_ids)
2184	);
2185	exit();
2186	}
2187
2188	$to_update_cat_ids = array();
2189
2190	// in case of replace mode, we first check the existing associations
2191	$query = '
2192	SELECT
2193	category_id
2194	FROM '.IMAGE_CATEGORY_TABLE.'
2195	WHERE image_id = '.$image_id.'
2196	;';
2197	$existing_cat_ids = array_from_query($query, 'category_id');
2198
2199	if ($replace_mode)
2200	{
2201	$to_remove_cat_ids = array_diff($existing_cat_ids, $cat_ids);
2202	if (count($to_remove_cat_ids) > 0)
2203	{
2204	$query = '
2205	DELETE
2206	FROM '.IMAGE_CATEGORY_TABLE.'
2207	WHERE image_id = '.$image_id.'
2208	AND category_id IN ('.implode(', ', $to_remove_cat_ids).')
2209	;';
2210	pwg_query($query);
2211	update_category($to_remove_cat_ids);
2212	}
2213	}
2214
2215	$new_cat_ids = array_diff($cat_ids, $existing_cat_ids);
2216	if (count($new_cat_ids) == 0)
2217	{
2218	return true;
2219	}
2220
2221	if ($search_current_ranks)
2222	{
2223	$query = '
2224	SELECT
2225	category_id,
2226	MAX(rank) AS max_rank
2227	FROM '.IMAGE_CATEGORY_TABLE.'
2228	WHERE rank IS NOT NULL
2229	AND category_id IN ('.implode(',', $new_cat_ids).')
2230	GROUP BY category_id
2231	;';
2232	$current_rank_of = simple_hash_from_query(
2233	$query,
2234	'category_id',
2235	'max_rank'
2236	);
2237
2238	foreach ($new_cat_ids as $cat_id)
2239	{
2240	if (!isset($current_rank_of[$cat_id]))
2241	{
2242	$current_rank_of[$cat_id] = 0;
2243	}
2244
2245	if ('auto' == $rank_on_category[$cat_id])
2246	{
2247	$rank_on_category[$cat_id] = $current_rank_of[$cat_id] + 1;
2248	}
2249	}
2250	}
2251
2252	$inserts = array();
2253
2254	foreach ($new_cat_ids as $cat_id)
2255	{
2256	array_push(
2257	$inserts,
2258	array(
2259	'image_id' => $image_id,
2260	'category_id' => $cat_id,
2261	'rank' => $rank_on_category[$cat_id],
2262	)
2263	);
2264	}
2265
2266	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2267	mass_inserts(
2268	IMAGE_CATEGORY_TABLE,
2269	array_keys($inserts[0]),
2270	$inserts
2271	);
2272
2273	update_category($new_cat_ids);
2274	}
2275
2276	function ws_categories_setInfo($params, &$service)
2277	{
2278	global $conf;
2279	if (!is_admin())
2280	{
2281	return new PwgError(401, 'Access denied');
2282	}
2283
2284	if (!$service->isPost())
2285	{
2286	return new PwgError(405, "This method requires HTTP POST");
2287	}
2288
2289	// category_id
2290	// name
2291	// comment
2292
2293	$params['category_id'] = (int)$params['category_id'];
2294	if ($params['category_id'] <= 0)
2295	{
2296	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
2297	}
2298
2299	// database registration
2300	$update = array(
2301	'id' => $params['category_id'],
2302	);
2303
2304	$info_columns = array(
2305	'name',
2306	'comment',
2307	);
2308
2309	$perform_update = false;
2310	foreach ($info_columns as $key)
2311	{
2312	if (isset($params[$key]))
2313	{
2314	$perform_update = true;
2315	$update[$key] = $params[$key];
2316	}
2317	}
2318
2319	if ($perform_update)
2320	{
2321	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2322	mass_updates(
2323	CATEGORIES_TABLE,
2324	array(
2325	'primary' => array('id'),
2326	'update' => array_diff(array_keys($update), array('id'))
2327	),
2328	array($update)
2329	);
2330	}
2331
2332	}
2333
2334	function ws_categories_delete($params, &$service)
2335	{
2336	global $conf;
2337	if (!is_admin())
2338	{
2339	return new PwgError(401, 'Access denied');
2340	}
2341
2342	if (!$service->isPost())
2343	{
2344	return new PwgError(405, "This method requires HTTP POST");
2345	}
2346
2347	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2348	{
2349	return new PwgError(403, 'Invalid security token');
2350	}
2351
2352	$modes = array('no_delete', 'delete_orphans', 'force_delete');
2353	if (!in_array($params['photo_deletion_mode'], $modes))
2354	{
2355	return new PwgError(
2356	500,
2357	'[ws_categories_delete]'
2358	.' invalid parameter photo_deletion_mode "'.$params['photo_deletion_mode'].'"'
2359	.', possible values are {'.implode(', ', $modes).'}.'
2360	);
2361	}
2362
2363	$params['category_id'] = preg_split(
2364	'/[\s,;\\|]/',
2365	$params['category_id'],
2366	-1,
2367	PREG_SPLIT_NO_EMPTY
2368	);
2369	$params['category_id'] = array_map('intval', $params['category_id']);
2370
2371	$category_ids = array();
2372	foreach ($params['category_id'] as $category_id)
2373	{
2374	if ($category_id > 0)
2375	{
2376	array_push($category_ids, $category_id);
2377	}
2378	}
2379
2380	if (count($category_ids) == 0)
2381	{
2382	return;
2383	}
2384
2385	$query = '
2386	SELECT id
2387	FROM '.CATEGORIES_TABLE.'
2388	WHERE id IN ('.implode(',', $category_ids).')
2389	;';
2390	$category_ids = array_from_query($query, 'id');
2391
2392	if (count($category_ids) == 0)
2393	{
2394	return;
2395	}
2396
2397	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2398	delete_categories($category_ids, $params['photo_deletion_mode']);
2399	update_global_rank();
2400	}
2401
2402	function ws_categories_move($params, &$service)
2403	{
2404	global $conf, $page;
2405
2406	if (!is_admin())
2407	{
2408	return new PwgError(401, 'Access denied');
2409	}
2410
2411	if (!$service->isPost())
2412	{
2413	return new PwgError(405, "This method requires HTTP POST");
2414	}
2415
2416	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2417	{
2418	return new PwgError(403, 'Invalid security token');
2419	}
2420
2421	$params['category_id'] = preg_split(
2422	'/[\s,;\\|]/',
2423	$params['category_id'],
2424	-1,
2425	PREG_SPLIT_NO_EMPTY
2426	);
2427	$params['category_id'] = array_map('intval', $params['category_id']);
2428
2429	$category_ids = array();
2430	foreach ($params['category_id'] as $category_id)
2431	{
2432	if ($category_id > 0)
2433	{
2434	array_push($category_ids, $category_id);
2435	}
2436	}
2437
2438	if (count($category_ids) == 0)
2439	{
2440	return new PwgError(403, 'Invalid category_id input parameter, no category to move');
2441	}
2442
2443	// we can't move physical categories
2444	$categories_in_db = array();
2445
2446	$query = '
2447	SELECT
2448	id,
2449	name,
2450	dir
2451	FROM '.CATEGORIES_TABLE.'
2452	WHERE id IN ('.implode(',', $category_ids).')
2453	;';
2454	$result = pwg_query($query);
2455	while ($row = pwg_db_fetch_assoc($result))
2456	{
2457	$categories_in_db[$row['id']] = $row;
2458	// we break on error at first physical category detected
2459	if (!empty($row['dir']))
2460	{
2461	$row['name'] = strip_tags(
2462	trigger_event(
2463	'render_category_name',
2464	$row['name'],
2465	'ws_categories_move'
2466	)
2467	);
2468
2469	return new PwgError(
2470	403,
2471	sprintf(
2472	'Category %s (%u) is not a virtual category, you cannot move it',
2473	$row['name'],
2474	$row['id']
2475	)
2476	);
2477	}
2478	}
2479
2480	if (count($categories_in_db) != count($category_ids))
2481	{
2482	$unknown_category_ids = array_diff($category_ids, array_keys($categories_in_db));
2483
2484	return new PwgError(
2485	403,
2486	sprintf(
2487	'Category %u does not exist',
2488	$unknown_category_ids[0]
2489	)
2490	);
2491	}
2492
2493	// does this parent exists? This check should be made in the
2494	// move_categories function, not here
2495	//
2496	// 0 as parent means "move categories at gallery root"
2497	if (!is_numeric($params['parent']))
2498	{
2499	return new PwgError(403, 'Invalid parent input parameter');
2500	}
2501
2502	if (0 != $params['parent']) {
2503	$params['parent'] = intval($params['parent']);
2504	$subcat_ids = get_subcat_ids(array($params['parent']));
2505	if (count($subcat_ids) == 0)
2506	{
2507	return new PwgError(403, 'Unknown parent category id');
2508	}
2509	}
2510
2511	$page['infos'] = array();
2512	$page['errors'] = array();
2513	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2514	move_categories($category_ids, $params['parent']);
2515	invalidate_user_cache();
2516
2517	if (count($page['errors']) != 0)
2518	{
2519	return new PwgError(403, implode('; ', $page['errors']));
2520	}
2521	}
2522
2523	function ws_logfile($string)
2524	{
2525	global $conf;
2526
2527	if (!$conf['ws_enable_log']) {
2528	return true;
2529	}
2530
2531	file_put_contents(
2532	$conf['ws_log_filepath'],
2533	'['.date('c').'] '.$string."\n",
2534	FILE_APPEND
2535	);
2536	}
2537
2538	function ws_images_checkUpload($params, &$service)
2539	{
2540	global $conf;
2541
2542	if (!is_admin())
2543	{
2544	return new PwgError(401, 'Access denied');
2545	}
2546
2547	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
2548	$ret['message'] = ready_for_upload_message();
2549	$ret['ready_for_upload'] = true;
2550
2551	if (!empty($ret['message']))
2552	{
2553	$ret['ready_for_upload'] = false;
2554	}
2555
2556	return $ret;
2557	}
2558
2559	function ws_plugins_getList($params, &$service)
2560	{
2561	global $conf;
2562
2563	if (!is_admin())
2564	{
2565	return new PwgError(401, 'Access denied');
2566	}
2567
2568	include_once(PHPWG_ROOT_PATH.'admin/include/plugins.class.php');
2569	$plugins = new plugins();
2570	$plugins->sort_fs_plugins('name');
2571	$plugin_list = array();
2572
2573	foreach($plugins->fs_plugins as $plugin_id => $fs_plugin)
2574	{
2575	if (isset($plugins->db_plugins_by_id[$plugin_id]))
2576	{
2577	$state = $plugins->db_plugins_by_id[$plugin_id]['state'];
2578	}
2579	else
2580	{
2581	$state = 'uninstalled';
2582	}
2583
2584	array_push(
2585	$plugin_list,
2586	array(
2587	'id' => $plugin_id,
2588	'name' => $fs_plugin['name'],
2589	'version' => $fs_plugin['version'],
2590	'state' => $state,
2591	'description' => $fs_plugin['description'],
2592	)
2593	);
2594	}
2595
2596	return $plugin_list;
2597	}
2598
2599	function ws_plugins_performAction($params, &$service)
2600	{
2601	global $template;
2602
2603	if (!is_admin())
2604	{
2605	return new PwgError(401, 'Access denied');
2606	}
2607
2608	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2609	{
2610	return new PwgError(403, 'Invalid security token');
2611	}
2612
2613	define('IN_ADMIN', true);
2614	include_once(PHPWG_ROOT_PATH.'admin/include/plugins.class.php');
2615	$plugins = new plugins();
2616	$errors = $plugins->perform_action($params['action'], $params['plugin']);
2617
2618
2619	if (!empty($errors))
2620	{
2621	return new PwgError(500, $errors);
2622	}
2623	else
2624	{
2625	if (in_array($params['action'], array('activate', 'deactivate')))
2626	{
2627	$template->delete_compiled_templates();
2628	}
2629	return true;
2630	}
2631	}
2632
2633	function ws_themes_performAction($params, &$service)
2634	{
2635	global $template;
2636
2637	if (!is_admin())
2638	{
2639	return new PwgError(401, 'Access denied');
2640	}
2641
2642	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2643	{
2644	return new PwgError(403, 'Invalid security token');
2645	}
2646
2647	define('IN_ADMIN', true);
2648	include_once(PHPWG_ROOT_PATH.'admin/include/themes.class.php');
2649	$themes = new themes();
2650	$errors = $themes->perform_action($params['action'], $params['theme']);
2651
2652	if (!empty($errors))
2653	{
2654	return new PwgError(500, $errors);
2655	}
2656	else
2657	{
2658	if (in_array($params['action'], array('activate', 'deactivate')))
2659	{
2660	$template->delete_compiled_templates();
2661	}
2662	return true;
2663	}
2664	}
2665
2666	function ws_images_resizethumbnail($params, &$service)
2667	{
2668	if (!is_admin())
2669	{
2670	return new PwgError(401, 'Access denied');
2671	}
2672
2673	if (empty($params['image_id']) and empty($params['image_path']))
2674	{
2675	return new PwgError(403, "image_id or image_path is missing");
2676	}
2677
2678	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
2679	include_once(PHPWG_ROOT_PATH.'admin/include/image.class.php');
2680
2681	if (!empty($params['image_id']))
2682	{
2683	$query='
2684	SELECT id, path, tn_ext, has_high
2685	FROM '.IMAGES_TABLE.'
2686	WHERE id = '.(int)$params['image_id'].'
2687	;';
2688	$image = pwg_db_fetch_assoc(pwg_query($query));
2689
2690	if ($image == null)
2691	{
2692	return new PwgError(403, "image_id not found");
2693	}
2694
2695	$image_path = $image['path'];
2696	$thumb_path = get_thumbnail_path($image);
2697	}
2698	else
2699	{
2700	$image_path = $params['image_path'];
2701	$thumb_path = file_path_for_type($image_path, 'thumb');
2702	}
2703
2704	if (!file_exists($image_path) or !is_valid_image_extension(get_extension($image_path)))
2705	{
2706	return new PwgError(403, "image can't be resized");
2707	}
2708
2709	$result = false;
2710	prepare_directory(dirname($thumb_path));
2711	$img = new pwg_image($image_path, $params['library']);
2712
2713	$result = $img->pwg_resize(
2714	$thumb_path,
2715	$params['maxwidth'],
2716	$params['maxheight'],
2717	$params['quality'],
2718	false, // automatic rotation is not needed for thumbnails.
2719	true, // strip metadata
2720	get_boolean($params['crop']),
2721	get_boolean($params['follow_orientation'])
2722	);
2723
2724	$img->destroy();
2725	return $result;
2726	}
2727
2728	function ws_images_resizewebsize($params, &$service)
2729	{
2730	if (!is_admin())
2731	{
2732	return new PwgError(401, 'Access denied');
2733	}
2734
2735	include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
2736	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
2737	include_once(PHPWG_ROOT_PATH.'admin/include/image.class.php');
2738
2739	$query='
2740	SELECT id, path, tn_ext, has_high
2741	FROM '.IMAGES_TABLE.'
2742	WHERE id = '.(int)$params['image_id'].'
2743	;';
2744	$image = pwg_db_fetch_assoc(pwg_query($query));
2745
2746	if ($image == null)
2747	{
2748	return new PwgError(403, "image_id not found");
2749	}
2750
2751	$image_path = $image['path'];
2752	$hd_path = get_high_path($image);
2753
2754	if (empty($image['has_high']) or !file_exists($hd_path) or !is_valid_image_extension(get_extension($image_path)))
2755	{
2756	return new PwgError(403, "image can't be resized");
2757	}
2758
2759	$result = false;
2760	$img = new pwg_image($hd_path, $params['library']);
2761
2762	$result = $img->pwg_resize(
2763	$image_path,
2764	$params['maxwidth'],
2765	$params['maxheight'],
2766	$params['quality'],
2767	$params['automatic_rotation'],
2768	false // strip metadata
2769	);
2770
2771	$img->destroy();
2772
2773	global $conf;
2774	$conf['use_exif'] = false;
2775	$conf['use_iptc'] = false;
2776	update_metadata(array($image['id'] => $image['path']));
2777
2778	return $result;
2779	}
2780
2781	function ws_extensions_update($params, &$service)
2782	{
2783	if (!is_webmaster())
2784	{
2785	return new PwgError(401, l10n('Webmaster status is required.'));
2786	}
2787
2788	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2789	{
2790	return new PwgError(403, 'Invalid security token');
2791	}
2792
2793	if (empty($params['type']) or !in_array($params['type'], array('plugins', 'themes', 'languages')))
2794	{
2795	return new PwgError(403, "invalid extension type");
2796	}
2797
2798	if (empty($params['id']) or empty($params['revision']))
2799	{
2800	return new PwgError(null, 'Wrong parameters');
2801	}
2802
2803	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2804	include_once(PHPWG_ROOT_PATH.'admin/include/'.$params['type'].'.class.php');
2805
2806	$type = $params['type'];
2807	$extension_id = $params['id'];
2808	$revision = $params['revision'];
2809
2810	$extension = new $type();
2811
2812	if ($type == 'plugins')
2813	{
2814	if (isset($extension->db_plugins_by_id[$extension_id]) and $extension->db_plugins_by_id[$extension_id]['state'] == 'active')
2815	{
2816	$extension->perform_action('deactivate', $extension_id);
2817
2818	redirect(PHPWG_ROOT_PATH
2819	. 'ws.php'
2820	. '?method=pwg.extensions.update'
2821	. '&type=plugins'
2822	. '&id=' . $extension_id
2823	. '&revision=' . $revision
2824	. '&reactivate=true'
2825	. '&pwg_token=' . get_pwg_token()
2826	. '&format=json'
2827	);
2828	}
2829
2830	$upgrade_status = $extension->extract_plugin_files('upgrade', $revision, $extension_id);
2831	$extension_name = $extension->fs_plugins[$extension_id]['name'];
2832
2833	if (isset($params['reactivate']))
2834	{
2835	$extension->perform_action('activate', $extension_id);
2836	}
2837	}
2838	elseif ($type == 'themes')
2839	{
2840	$upgrade_status = $extension->extract_theme_files('upgrade', $revision, $extension_id);
2841	$extension_name = $extension->fs_themes[$extension_id]['name'];
2842	}
2843	elseif ($type == 'languages')
2844	{
2845	$upgrade_status = $extension->extract_language_files('upgrade', $revision, $extension_id);
2846	$extension_name = $extension->fs_languages[$extension_id]['name'];
2847	}
2848
2849	global $template;
2850	$template->delete_compiled_templates();
2851
2852	switch ($upgrade_status)
2853	{
2854	case 'ok':
2855	return sprintf(l10n('%s has been successfully updated.'), $extension_name);
2856
2857	case 'temp_path_error':
2858	return new PwgError(null, l10n('Can\'t create temporary file.'));
2859
2860	case 'dl_archive_error':
2861	return new PwgError(null, l10n('Can\'t download archive.'));
2862
2863	case 'archive_error':
2864	return new PwgError(null, l10n('Can\'t read or extract archive.'));
2865
2866	default:
2867	return new PwgError(null, sprintf(l10n('An error occured during extraction (%s).'), $upgrade_status));
2868	}
2869	}
2870
2871	function ws_extensions_ignoreupdate($params, &$service)
2872	{
2873	global $conf;
2874
2875	define('IN_ADMIN', true);
2876	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2877
2878	if (!is_webmaster())
2879	{
2880	return new PwgError(401, 'Access denied');
2881	}
2882
2883	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2884	{
2885	return new PwgError(403, 'Invalid security token');
2886	}
2887
2888	$conf['updates_ignored'] = unserialize($conf['updates_ignored']);
2889
2890	// Reset ignored extension
2891	if ($params['reset'])
2892	{
2893	if (!empty($params['type']) and isset($conf['updates_ignored'][$params['type']]))
2894	{
2895	$conf['updates_ignored'][$params['type']] = array();
2896	}
2897	else
2898	{
2899	$conf['updates_ignored'] = array(
2900	'plugins'=>array(),
2901	'themes'=>array(),
2902	'languages'=>array()
2903	);
2904	}
2905	conf_update_param('updates_ignored', pwg_db_real_escape_string(serialize($conf['updates_ignored'])));
2906	unset($_SESSION['extensions_need_update']);
2907	return true;
2908	}
2909
2910	if (empty($params['id']) or empty($params['type']) or !in_array($params['type'], array('plugins', 'themes', 'languages')))
2911	{
2912	return new PwgError(403, 'Invalid parameters');
2913	}
2914
2915	// Add or remove extension from ignore list
2916	if (!in_array($params['id'], $conf['updates_ignored'][$params['type']]))
2917	{
2918	array_push($conf['updates_ignored'][$params['type']], $params['id']);
2919	}
2920	conf_update_param('updates_ignored', pwg_db_real_escape_string(serialize($conf['updates_ignored'])));
2921	unset($_SESSION['extensions_need_update']);
2922	return true;
2923	}
2924
2925	function ws_extensions_checkupdates($params, &$service)
2926	{
2927	global $conf;
2928
2929	define('IN_ADMIN', true);
2930	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2931	include_once(PHPWG_ROOT_PATH.'admin/include/updates.class.php');
2932	$update = new updates();
2933
2934	if (!is_admin())
2935	{
2936	return new PwgError(401, 'Access denied');
2937	}
2938
2939	$result = array();
2940
2941	if (!isset($_SESSION['need_update']))
2942	$update->check_piwigo_upgrade();
2943
2944	$result['piwigo_need_update'] = $_SESSION['need_update'];
2945
2946	$conf['updates_ignored'] = unserialize($conf['updates_ignored']);
2947
2948	if (!isset($_SESSION['extensions_need_update']))
2949	$update->check_extensions();
2950	else
2951	$update->check_updated_extensions();
2952
2953	if (!is_array($_SESSION['extensions_need_update']))
2954	$result['ext_need_update'] = null;
2955	else
2956	$result['ext_need_update'] = !empty($_SESSION['extensions_need_update']);
2957
2958	return $result;
2959	}
2960	?>

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

Download in other formats: