Context Navigation

ws_functions.inc.php @ 12750

Visit:

Revision 12750, 86.1 KB (checked in by patdenice, 17 months ago)
merge r12749 from trunk to branch 2.3 bug:2535 Image is not cropped and ressized if requested size is bigger than image size.
Property svn:eol-style set to `LF`

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.'rating_score>'.$params['f_min_rate'];
58	}
59	if ( is_numeric($params['f_max_rate']) )
60	{
61	$clauses[] = $tbl_name.'rating_score<='.$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', 'rating_score',
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	if ($params['tree_output'])
436	{
437	if (!isset($_GET['format']) or !in_array($_GET['format'], array('php', 'json')))
438	{
439	// the algorithm used to build a tree from a flat list of categories
440	// keeps original array keys, which is not compatible with
441	// PwgNamedArray.
442	//
443	// PwgNamedArray is useful to define which data is an attribute and
444	// which is an element in the XML output. The "hierarchy" output is
445	// only compatible with json/php output.
446
447	return new PwgError(405, "The tree_output option is only compatible with json/php output formats");
448	}
449	}
450
451	$where = array('1=1');
452	$join_type = 'INNER';
453	$join_user = $user['id'];
454
455	if (!$params['recursive'])
456	{
457	if ($params['cat_id']>0)
458	$where[] = '(id_uppercat='.(int)($params['cat_id']).'
459	OR id='.(int)($params['cat_id']).')';
460	else
461	$where[] = 'id_uppercat IS NULL';
462	}
463	else if ($params['cat_id']>0)
464	{
465	$where[] = 'uppercats '.DB_REGEX_OPERATOR.' \'(^\|,)'.
466	(int)($params['cat_id'])
467	.'(,\|$)\'';
468	}
469
470	if ($params['public'])
471	{
472	$where[] = 'status = "public"';
473	$where[] = 'visible = "true"';
474
475	$join_user = $conf['guest_id'];
476	}
477	elseif (is_admin())
478	{
479	// in this very specific case, we don't want to hide empty
480	// categories. Function calculate_permissions will only return
481	// categories that are either locked or private and not permitted
482	//
483	// calculate_permissions does not consider empty categories as forbidden
484	$forbidden_categories = calculate_permissions($user['id'], $user['status']);
485	$where[]= 'id NOT IN ('.$forbidden_categories.')';
486	$join_type = 'LEFT';
487	}
488
489	$query = '
490	SELECT id, name, permalink, uppercats, global_rank, id_uppercat,
491	comment,
492	nb_images, count_images AS total_nb_images,
493	user_representative_picture_id, count_images, count_categories,
494	date_last, max_date_last, count_categories AS nb_categories
495	FROM '.CATEGORIES_TABLE.'
496	'.$join_type.' JOIN '.USER_CACHE_CATEGORIES_TABLE.' ON id=cat_id AND user_id='.$join_user.'
497	WHERE '. implode('
498	AND ', $where);
499
500	$result = pwg_query($query);
501
502	// management of the album thumbnail -- starts here
503	$image_ids = array();
504	$categories = array();
505	$user_representative_updates_for = array();
506	// management of the album thumbnail -- stops here
507
508	$cats = array();
509	while ($row = pwg_db_fetch_assoc($result))
510	{
511	$row['url'] = make_index_url(
512	array(
513	'category' => $row
514	)
515	);
516	foreach( array('id','nb_images','total_nb_images','nb_categories') as $key)
517	{
518	$row[$key] = (int)$row[$key];
519	}
520
521	if ($params['fullname'])
522	{
523	$row['name'] = strip_tags(get_cat_display_name_cache($row['uppercats'], null, false));
524	}
525	else
526	{
527	$row['name'] = strip_tags(
528	trigger_event(
529	'render_category_name',
530	$row['name'],
531	'ws_categories_getList'
532	)
533	);
534	}
535
536	$row['comment'] = strip_tags(
537	trigger_event(
538	'render_category_description',
539	$row['comment'],
540	'ws_categories_getList'
541	)
542	);
543
544	// management of the album thumbnail -- starts here
545	//
546	// on branch 2.3, the algorithm is duplicated from
547	// include/category_cats, but we should use a common code for Piwigo 2.4
548	//
549	// warning : if the API method is called with $params['public'], the
550	// album thumbnail may be not accurate. The thumbnail can be viewed by
551	// the connected user, but maybe not by the guest. Changing the
552	// filtering method would be too complicated for now. We will simply
553	// avoid to persist the user_representative_picture_id in the database
554	// if $params['public']
555	if (!empty($row['user_representative_picture_id']))
556	{
557	$image_id = $row['user_representative_picture_id'];
558	}
559	else if (!empty($row['representative_picture_id']))
560	{ // if a representative picture is set, it has priority
561	$image_id = $row['representative_picture_id'];
562	}
563	else if ($conf['allow_random_representative'])
564	{
565	// searching a random representant among elements in sub-categories
566	$image_id = get_random_image_in_category($row);
567	}
568	else
569	{ // searching a random representant among representant of sub-categories
570	if ($row['count_categories']>0 and $row['count_images']>0)
571	{
572	$query = '
573	SELECT representative_picture_id
574	FROM '.CATEGORIES_TABLE.' INNER JOIN '.USER_CACHE_CATEGORIES_TABLE.'
575	ON id = cat_id and user_id = '.$user['id'].'
576	WHERE uppercats LIKE \''.$row['uppercats'].',%\'
577	AND representative_picture_id IS NOT NULL'
578	.get_sql_condition_FandF
579	(
580	array
581	(
582	'visible_categories' => 'id',
583	),
584	"\n AND"
585	).'
586	ORDER BY '.DB_RANDOM_FUNCTION.'()
587	LIMIT 1
588	;';
589	$subresult = pwg_query($query);
590	if (pwg_db_num_rows($subresult) > 0)
591	{
592	list($image_id) = pwg_db_fetch_row($subresult);
593	}
594	}
595	}
596
597	if (isset($image_id))
598	{
599	if ($conf['representative_cache_on_subcats'] and $row['user_representative_picture_id'] != $image_id)
600	{
601	$user_representative_updates_for[ $user['id'].'#'.$row['id'] ] = $image_id;
602	}
603
604	$row['representative_picture_id'] = $image_id;
605	array_push($image_ids, $image_id);
606	array_push($categories, $row);
607	}
608	unset($image_id);
609	// management of the album thumbnail -- stops here
610
611
612	array_push($cats, $row);
613	}
614	usort($cats, 'global_rank_compare');
615
616	// management of the album thumbnail -- starts here
617	if (count($categories) > 0)
618	{
619	$thumbnail_src_of = array();
620	$new_image_ids = array();
621
622	$query = '
623	SELECT id, path, tn_ext, level
624	FROM '.IMAGES_TABLE.'
625	WHERE id IN ('.implode(',', $image_ids).')
626	;';
627	$result = pwg_query($query);
628	while ($row = pwg_db_fetch_assoc($result))
629	{
630	if ($row['level'] <= $user['level'])
631	{
632	$thumbnail_src_of[$row['id']] = get_thumbnail_url($row);
633	}
634	else
635	{
636	// problem: we must not display the thumbnail of a photo which has a
637	// higher privacy level than user privacy level
638	//
639	// * what is the represented category?
640	// * find a random photo matching user permissions
641	// * register it at user_representative_picture_id
642	// * set it as the representative_picture_id for the category
643
644	foreach ($categories as &$category)
645	{
646	if ($row['id'] == $category['representative_picture_id'])
647	{
648	// searching a random representant among elements in sub-categories
649	$image_id = get_random_image_in_category($category);
650
651	if (isset($image_id) and !in_array($image_id, $image_ids))
652	{
653	array_push($new_image_ids, $image_id);
654	}
655
656	if ($conf['representative_cache_on_level'])
657	{
658	$user_representative_updates_for[ $user['id'].'#'.$category['id'] ] = $image_id;
659	}
660
661	$category['representative_picture_id'] = $image_id;
662	}
663	}
664	unset($category);
665	}
666	}
667
668	if (count($new_image_ids) > 0)
669	{
670	$query = '
671	SELECT id, path, tn_ext
672	FROM '.IMAGES_TABLE.'
673	WHERE id IN ('.implode(',', $new_image_ids).')
674	;';
675	$result = pwg_query($query);
676	while ($row = pwg_db_fetch_assoc($result))
677	{
678	$thumbnail_src_of[$row['id']] = get_thumbnail_url($row);
679	}
680	}
681	}
682
683	// compared to code in include/category_cats, we only persist the new
684	// user_representative if we have used $user['id'] and not the guest id,
685	// or else the real guest may see thumbnail that he should not
686	if (!$params['public'] and count($user_representative_updates_for))
687	{
688	$updates = array();
689
690	foreach ($user_representative_updates_for as $user_cat => $image_id)
691	{
692	list($user_id, $cat_id) = explode('#', $user_cat);
693
694	array_push(
695	$updates,
696	array(
697	'user_id' => $user_id,
698	'cat_id' => $cat_id,
699	'user_representative_picture_id' => $image_id,
700	)
701	);
702	}
703
704	mass_updates(
705	USER_CACHE_CATEGORIES_TABLE,
706	array(
707	'primary' => array('user_id', 'cat_id'),
708	'update' => array('user_representative_picture_id')
709	),
710	$updates
711	);
712	}
713
714	foreach ($cats as &$cat)
715	{
716	foreach ($categories as $category)
717	{
718	if ($category['id'] == $cat['id'])
719	{
720	$cat['tn_url'] = $thumbnail_src_of[$category['representative_picture_id']];
721	}
722	}
723	// we don't want them in the output
724	unset($cat['user_representative_picture_id']);
725	unset($cat['count_images']);
726	unset($cat['count_categories']);
727	}
728	unset($cat);
729	// management of the album thumbnail -- stops here
730
731	if ($params['tree_output'])
732	{
733	return categories_flatlist_to_tree($cats);
734	}
735	else
736	{
737	return array(
738	'categories' => new PwgNamedArray(
739	$cats,
740	'category',
741	array(
742	'id',
743	'url',
744	'nb_images',
745	'total_nb_images',
746	'nb_categories',
747	'date_last',
748	'max_date_last',
749	)
750	)
751	);
752	}
753	}
754
755	/**
756	* returns the list of categories as you can see them in administration (web
757	* service method).
758	*
759	* Only admin can run this method and permissions are not taken into
760	* account.
761	*/
762	function ws_categories_getAdminList($params, &$service)
763	{
764	if (!is_admin())
765	{
766	return new PwgError(401, 'Access denied');
767	}
768
769	$query = '
770	SELECT
771	category_id,
772	COUNT(*) AS counter
773	FROM '.IMAGE_CATEGORY_TABLE.'
774	GROUP BY category_id
775	;';
776	$nb_images_of = simple_hash_from_query($query, 'category_id', 'counter');
777
778	$query = '
779	SELECT
780	id,
781	name,
782	comment,
783	uppercats,
784	global_rank
785	FROM '.CATEGORIES_TABLE.'
786	;';
787	$result = pwg_query($query);
788	$cats = array();
789
790	while ($row = pwg_db_fetch_assoc($result))
791	{
792	$id = $row['id'];
793	$row['nb_images'] = isset($nb_images_of[$id]) ? $nb_images_of[$id] : 0;
794	$row['name'] = strip_tags(
795	trigger_event(
796	'render_category_name',
797	$row['name'],
798	'ws_categories_getAdminList'
799	)
800	);
801	$row['comment'] = strip_tags(
802	trigger_event(
803	'render_category_description',
804	$row['comment'],
805	'ws_categories_getAdminList'
806	)
807	);
808	array_push($cats, $row);
809	}
810
811	usort($cats, 'global_rank_compare');
812	return array(
813	'categories' => new PwgNamedArray(
814	$cats,
815	'category',
816	array(
817	'id',
818	'nb_images',
819	'name',
820	'uppercats',
821	'global_rank',
822	)
823	)
824	);
825	}
826
827	/**
828	* returns detailed information for an element (web service method)
829	*/
830	function ws_images_addComment($params, &$service)
831	{
832	if (!$service->isPost())
833	{
834	return new PwgError(405, "This method requires HTTP POST");
835	}
836	$params['image_id'] = (int)$params['image_id'];
837	$query = '
838	SELECT DISTINCT image_id
839	FROM '.IMAGE_CATEGORY_TABLE.' INNER JOIN '.CATEGORIES_TABLE.' ON category_id=id
840	WHERE commentable="true"
841	AND image_id='.$params['image_id'].
842	get_sql_condition_FandF(
843	array(
844	'forbidden_categories' => 'id',
845	'visible_categories' => 'id',
846	'visible_images' => 'image_id'
847	),
848	' AND'
849	);
850	if ( !pwg_db_num_rows( pwg_query( $query ) ) )
851	{
852	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
853	}
854
855	$comm = array(
856	'author' => trim( $params['author'] ),
857	'content' => trim( $params['content'] ),
858	'image_id' => $params['image_id'],
859	);
860
861	include_once(PHPWG_ROOT_PATH.'include/functions_comment.inc.php');
862
863	$comment_action = insert_user_comment(
864	$comm, $params['key'], $infos
865	);
866
867	switch ($comment_action)
868	{
869	case 'reject':
870	array_push($infos, l10n('Your comment has NOT been registered because it did not pass the validation rules') );
871	return new PwgError(403, implode("; ", $infos) );
872	case 'validate':
873	case 'moderate':
874	$ret = array(
875	'id' => $comm['id'],
876	'validation' => $comment_action=='validate',
877	);
878	return new PwgNamedStruct(
879	'comment',
880	$ret,
881	null, array()
882	);
883	default:
884	return new PwgError(500, "Unknown comment action ".$comment_action );
885	}
886	}
887
888	/**
889	* returns detailed information for an element (web service method)
890	*/
891	function ws_images_getInfo($params, &$service)
892	{
893	@include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
894	global $user, $conf;
895	$params['image_id'] = (int)$params['image_id'];
896	if ( $params['image_id']<=0 )
897	{
898	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
899	}
900
901	$query='
902	SELECT * FROM '.IMAGES_TABLE.'
903	WHERE id='.$params['image_id'].
904	get_sql_condition_FandF(
905	array('visible_images' => 'id'),
906	' AND'
907	).'
908	LIMIT 1';
909
910	$image_row = pwg_db_fetch_assoc(pwg_query($query));
911	if ($image_row==null)
912	{
913	return new PwgError(404, "image_id not found");
914	}
915	$image_row = array_merge( $image_row, ws_std_get_urls($image_row) );
916
917	//-------------------------------------------------------- related categories
918	$query = '
919	SELECT id, name, permalink, uppercats, global_rank, commentable
920	FROM '.IMAGE_CATEGORY_TABLE.'
921	INNER JOIN '.CATEGORIES_TABLE.' ON category_id = id
922	WHERE image_id = '.$image_row['id'].
923	get_sql_condition_FandF(
924	array( 'forbidden_categories' => 'category_id' ),
925	' AND'
926	).'
927	;';
928	$result = pwg_query($query);
929	$is_commentable = false;
930	$related_categories = array();
931	while ($row = pwg_db_fetch_assoc($result))
932	{
933	if ($row['commentable']=='true')
934	{
935	$is_commentable = true;
936	}
937	unset($row['commentable']);
938	$row['url'] = make_index_url(
939	array(
940	'category' => $row
941	)
942	);
943
944	$row['page_url'] = make_picture_url(
945	array(
946	'image_id' => $image_row['id'],
947	'image_file' => $image_row['file'],
948	'category' => $row
949	)
950	);
951	$row['id']=(int)$row['id'];
952	array_push($related_categories, $row);
953	}
954	usort($related_categories, 'global_rank_compare');
955	if ( empty($related_categories) )
956	{
957	return new PwgError(401, 'Access denied');
958	}
959
960	//-------------------------------------------------------------- related tags
961	$related_tags = get_common_tags( array($image_row['id']), -1 );
962	foreach( $related_tags as $i=>$tag)
963	{
964	$tag['url'] = make_index_url(
965	array(
966	'tags' => array($tag)
967	)
968	);
969	$tag['page_url'] = make_picture_url(
970	array(
971	'image_id' => $image_row['id'],
972	'image_file' => $image_row['file'],
973	'tags' => array($tag),
974	)
975	);
976	unset($tag['counter']);
977	$tag['id']=(int)$tag['id'];
978	$related_tags[$i]=$tag;
979	}
980	//------------------------------------------------------------- related rates
981	$rating = array('score'=>$image_row['rating_score'], 'count'=>0, 'average'=>null);
982	if (isset($rating['score']))
983	{
984	$query = '
985	SELECT COUNT(rate) AS count
986	, ROUND(AVG(rate),2) AS average
987	FROM '.RATE_TABLE.'
988	WHERE element_id = '.$image_row['id'].'
989	;';
990	$row = pwg_db_fetch_assoc(pwg_query($query));
991	$rating['score'] = (float)$rating['score'];
992	$rating['average'] = (float)$row['average'];
993	$rating['count'] = (int)$row['count'];
994	}
995
996	//---------------------------------------------------------- related comments
997	$related_comments = array();
998
999	$where_comments = 'image_id = '.$image_row['id'];
1000	if ( !is_admin() )
1001	{
1002	$where_comments .= '
1003	AND validated="true"';
1004	}
1005
1006	$query = '
1007	SELECT COUNT(id) AS nb_comments
1008	FROM '.COMMENTS_TABLE.'
1009	WHERE '.$where_comments;
1010	list($nb_comments) = array_from_query($query, 'nb_comments');
1011	$nb_comments = (int)$nb_comments;
1012
1013	if ( $nb_comments>0 and $params['comments_per_page']>0 )
1014	{
1015	$query = '
1016	SELECT id, date, author, content
1017	FROM '.COMMENTS_TABLE.'
1018	WHERE '.$where_comments.'
1019	ORDER BY date
1020	LIMIT '.(int)$params['comments_per_page'].
1021	' OFFSET '.(int)($params['comments_per_page']*$params['comments_page']);
1022
1023	$result = pwg_query($query);
1024	while ($row = pwg_db_fetch_assoc($result))
1025	{
1026	$row['id']=(int)$row['id'];
1027	array_push($related_comments, $row);
1028	}
1029	}
1030
1031	$comment_post_data = null;
1032	if ($is_commentable and
1033	(!is_a_guest()
1034	or (is_a_guest() and $conf['comments_forall'] )
1035	)
1036	)
1037	{
1038	$comment_post_data['author'] = stripslashes($user['username']);
1039	$comment_post_data['key'] = get_ephemeral_key(2, $params['image_id']);
1040	}
1041
1042	$ret = $image_row;
1043	foreach ( array('id','width','height','hit','filesize') as $k )
1044	{
1045	if (isset($ret[$k]))
1046	{
1047	$ret[$k] = (int)$ret[$k];
1048	}
1049	}
1050	foreach ( array('path', 'storage_category_id') as $k )
1051	{
1052	unset($ret[$k]);
1053	}
1054
1055	$ret['rates'] = array( WS_XML_ATTRIBUTES => $rating );
1056	$ret['categories'] = new PwgNamedArray($related_categories, 'category', array('id','url', 'page_url') );
1057	$ret['tags'] = new PwgNamedArray($related_tags, 'tag', array('id','url_name','url','name','page_url') );
1058	if ( isset($comment_post_data) )
1059	{
1060	$ret['comment_post'] = array( WS_XML_ATTRIBUTES => $comment_post_data );
1061	}
1062	$ret['comments'] = array(
1063	WS_XML_ATTRIBUTES =>
1064	array(
1065	'page' => $params['comments_page'],
1066	'per_page' => $params['comments_per_page'],
1067	'count' => count($related_comments),
1068	'nb_comments' => $nb_comments,
1069	),
1070	WS_XML_CONTENT => new PwgNamedArray($related_comments, 'comment', array('id','date') )
1071	);
1072
1073	return new PwgNamedStruct('image',$ret, null, array('name','comment') );
1074	}
1075
1076
1077	/**
1078	* rates the image_id in the parameter
1079	*/
1080	function ws_images_Rate($params, &$service)
1081	{
1082	$image_id = (int)$params['image_id'];
1083	$query = '
1084	SELECT DISTINCT id FROM '.IMAGES_TABLE.'
1085	INNER JOIN '.IMAGE_CATEGORY_TABLE.' ON id=image_id
1086	WHERE id='.$image_id
1087	.get_sql_condition_FandF(
1088	array(
1089	'forbidden_categories' => 'category_id',
1090	'forbidden_images' => 'id',
1091	),
1092	' AND'
1093	).'
1094	LIMIT 1';
1095	if ( pwg_db_num_rows( pwg_query($query) )==0 )
1096	{
1097	return new PwgError(404, "Invalid image_id or access denied" );
1098	}
1099	$rate = (int)$params['rate'];
1100	include_once(PHPWG_ROOT_PATH.'include/functions_rate.inc.php');
1101	$res = rate_picture( $image_id, $rate );
1102	if ($res==false)
1103	{
1104	global $conf;
1105	return new PwgError( 403, "Forbidden or rate not in ". implode(',',$conf['rate_items']));
1106	}
1107	return $res;
1108	}
1109
1110
1111	/**
1112	* returns a list of elements corresponding to a query search
1113	*/
1114	function ws_images_search($params, &$service)
1115	{
1116	global $page;
1117	$images = array();
1118	include_once( PHPWG_ROOT_PATH .'include/functions_search.inc.php' );
1119	include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
1120
1121	$where_clauses = ws_std_image_sql_filter( $params, 'i.' );
1122	$order_by = ws_std_image_sql_order($params, 'i.');
1123
1124	$super_order_by = false;
1125	if ( !empty($order_by) )
1126	{
1127	global $conf;
1128	$conf['order_by'] = 'ORDER BY '.$order_by;
1129	$super_order_by=true; // quick_search_result might be faster
1130	}
1131
1132	$search_result = get_quick_search_results($params['query'],
1133	$super_order_by,
1134	implode(',', $where_clauses)
1135	);
1136
1137	$image_ids = array_slice(
1138	$search_result['items'],
1139	$params['page']*$params['per_page'],
1140	$params['per_page']
1141	);
1142
1143	if ( count($image_ids) )
1144	{
1145	$query = '
1146	SELECT * FROM '.IMAGES_TABLE.'
1147	WHERE id IN ('.implode(',', $image_ids).')';
1148
1149	$image_ids = array_flip($image_ids);
1150	$result = pwg_query($query);
1151	while ($row = pwg_db_fetch_assoc($result))
1152	{
1153	$image = array();
1154	foreach ( array('id', 'width', 'height', 'hit') as $k )
1155	{
1156	if (isset($row[$k]))
1157	{
1158	$image[$k] = (int)$row[$k];
1159	}
1160	}
1161	foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
1162	{
1163	$image[$k] = $row[$k];
1164	}
1165	$image = array_merge( $image, ws_std_get_urls($row) );
1166	$images[$image_ids[$image['id']]] = $image;
1167	}
1168	ksort($images, SORT_NUMERIC);
1169	$images = array_values($images);
1170	}
1171
1172
1173	return array( 'images' =>
1174	array (
1175	WS_XML_ATTRIBUTES =>
1176	array(
1177	'page' => $params['page'],
1178	'per_page' => $params['per_page'],
1179	'count' => count($images)
1180	),
1181	WS_XML_CONTENT => new PwgNamedArray($images, 'image',
1182	ws_std_get_image_xml_attributes() )
1183	)
1184	);
1185	}
1186
1187	function ws_images_setPrivacyLevel($params, &$service)
1188	{
1189	if (!is_admin())
1190	{
1191	return new PwgError(401, 'Access denied');
1192	}
1193	if (!$service->isPost())
1194	{
1195	return new PwgError(405, "This method requires HTTP POST");
1196	}
1197	$params['image_id'] = array_map( 'intval',$params['image_id'] );
1198	if ( empty($params['image_id']) )
1199	{
1200	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1201	}
1202	global $conf;
1203	if ( !in_array( (int)$params['level'], $conf['available_permission_levels']) )
1204	{
1205	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid level");
1206	}
1207
1208	$query = '
1209	UPDATE '.IMAGES_TABLE.'
1210	SET level='.(int)$params['level'].'
1211	WHERE id IN ('.implode(',',$params['image_id']).')';
1212	$result = pwg_query($query);
1213	$affected_rows = pwg_db_changes($result);
1214	if ($affected_rows)
1215	{
1216	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1217	invalidate_user_cache();
1218	}
1219	return $affected_rows;
1220	}
1221
1222	function ws_images_setRank($params, &$service)
1223	{
1224	if (!is_admin())
1225	{
1226	return new PwgError(401, 'Access denied');
1227	}
1228
1229	if (!$service->isPost())
1230	{
1231	return new PwgError(405, "This method requires HTTP POST");
1232	}
1233
1234	// is the image_id valid?
1235	$params['image_id'] = (int)$params['image_id'];
1236	if ($params['image_id'] <= 0)
1237	{
1238	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1239	}
1240
1241	// is the category valid?
1242	$params['category_id'] = (int)$params['category_id'];
1243	if ($params['category_id'] <= 0)
1244	{
1245	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
1246	}
1247
1248	// is the rank valid?
1249	$params['rank'] = (int)$params['rank'];
1250	if ($params['rank'] <= 0)
1251	{
1252	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid rank");
1253	}
1254
1255	// does the image really exist?
1256	$query='
1257	SELECT
1258	*
1259	FROM '.IMAGES_TABLE.'
1260	WHERE id = '.$params['image_id'].'
1261	;';
1262
1263	$image_row = pwg_db_fetch_assoc(pwg_query($query));
1264	if ($image_row == null)
1265	{
1266	return new PwgError(404, "image_id not found");
1267	}
1268
1269	// is the image associated to this category?
1270	$query = '
1271	SELECT
1272	image_id,
1273	category_id,
1274	rank
1275	FROM '.IMAGE_CATEGORY_TABLE.'
1276	WHERE image_id = '.$params['image_id'].'
1277	AND category_id = '.$params['category_id'].'
1278	;';
1279	$category_row = pwg_db_fetch_assoc(pwg_query($query));
1280	if ($category_row == null)
1281	{
1282	return new PwgError(404, "This image is not associated to this category");
1283	}
1284
1285	// what is the current higher rank for this category?
1286	$query = '
1287	SELECT
1288	MAX(rank) AS max_rank
1289	FROM '.IMAGE_CATEGORY_TABLE.'
1290	WHERE category_id = '.$params['category_id'].'
1291	;';
1292	$result = pwg_query($query);
1293	$row = pwg_db_fetch_assoc($result);
1294
1295	if (is_numeric($row['max_rank']))
1296	{
1297	if ($params['rank'] > $row['max_rank'])
1298	{
1299	$params['rank'] = $row['max_rank'] + 1;
1300	}
1301	}
1302	else
1303	{
1304	$params['rank'] = 1;
1305	}
1306
1307	// update rank for all other photos in the same category
1308	$query = '
1309	UPDATE '.IMAGE_CATEGORY_TABLE.'
1310	SET rank = rank + 1
1311	WHERE category_id = '.$params['category_id'].'
1312	AND rank IS NOT NULL
1313	AND rank >= '.$params['rank'].'
1314	;';
1315	pwg_query($query);
1316
1317	// set the new rank for the photo
1318	$query = '
1319	UPDATE '.IMAGE_CATEGORY_TABLE.'
1320	SET rank = '.$params['rank'].'
1321	WHERE image_id = '.$params['image_id'].'
1322	AND category_id = '.$params['category_id'].'
1323	;';
1324	pwg_query($query);
1325
1326	// return data for client
1327	return array(
1328	'image_id' => $params['image_id'],
1329	'category_id' => $params['category_id'],
1330	'rank' => $params['rank'],
1331	);
1332	}
1333
1334	function ws_images_add_chunk($params, &$service)
1335	{
1336	global $conf;
1337
1338	ws_logfile('[ws_images_add_chunk] welcome');
1339	// data
1340	// original_sum
1341	// type {thumb, file, high}
1342	// position
1343
1344	if (!is_admin())
1345	{
1346	return new PwgError(401, 'Access denied');
1347	}
1348
1349	if (!$service->isPost())
1350	{
1351	return new PwgError(405, "This method requires HTTP POST");
1352	}
1353
1354	foreach ($params as $param_key => $param_value) {
1355	if ('data' == $param_key) {
1356	continue;
1357	}
1358
1359	ws_logfile(
1360	sprintf(
1361	'[ws_images_add_chunk] input param "%s" : "%s"',
1362	$param_key,
1363	is_null($param_value) ? 'NULL' : $param_value
1364	)
1365	);
1366	}
1367
1368	$upload_dir = $conf['upload_dir'].'/buffer';
1369
1370	// create the upload directory tree if not exists
1371	if (!is_dir($upload_dir)) {
1372	umask(0000);
1373	$recursive = true;
1374	if (!@mkdir($upload_dir, 0777, $recursive))
1375	{
1376	return new PwgError(500, 'error during buffer directory creation');
1377	}
1378	}
1379
1380	if (!is_writable($upload_dir))
1381	{
1382	// last chance to make the directory writable
1383	@chmod($upload_dir, 0777);
1384
1385	if (!is_writable($upload_dir))
1386	{
1387	return new PwgError(500, 'buffer directory has no write access');
1388	}
1389	}
1390
1391	secure_directory($upload_dir);
1392
1393	$filename = sprintf(
1394	'%s-%s-%05u.block',
1395	$params['original_sum'],
1396	$params['type'],
1397	$params['position']
1398	);
1399
1400	ws_logfile('[ws_images_add_chunk] data length : '.strlen($params['data']));
1401
1402	$bytes_written = file_put_contents(
1403	$upload_dir.'/'.$filename,
1404	base64_decode($params['data'])
1405	);
1406
1407	if (false === $bytes_written) {
1408	return new PwgError(
1409	500,
1410	'an error has occured while writting chunk '.$params['position'].' for '.$params['type']
1411	);
1412	}
1413	}
1414
1415	function merge_chunks($output_filepath, $original_sum, $type)
1416	{
1417	global $conf;
1418
1419	ws_logfile('[merge_chunks] input parameter $output_filepath : '.$output_filepath);
1420
1421	if (is_file($output_filepath))
1422	{
1423	unlink($output_filepath);
1424
1425	if (is_file($output_filepath))
1426	{
1427	new PwgError(500, '[merge_chunks] error while trying to remove existing '.$output_filepath);
1428	exit();
1429	}
1430	}
1431
1432	$upload_dir = $conf['upload_dir'].'/buffer';
1433	$pattern = '/'.$original_sum.'-'.$type.'/';
1434	$chunks = array();
1435
1436	if ($handle = opendir($upload_dir))
1437	{
1438	while (false !== ($file = readdir($handle)))
1439	{
1440	if (preg_match($pattern, $file))
1441	{
1442	ws_logfile($file);
1443	array_push($chunks, $upload_dir.'/'.$file);
1444	}
1445	}
1446	closedir($handle);
1447	}
1448
1449	sort($chunks);
1450
1451	if (function_exists('memory_get_usage')) {
1452	ws_logfile('[merge_chunks] memory_get_usage before loading chunks: '.memory_get_usage());
1453	}
1454
1455	$i = 0;
1456
1457	foreach ($chunks as $chunk)
1458	{
1459	$string = file_get_contents($chunk);
1460
1461	if (function_exists('memory_get_usage')) {
1462	ws_logfile('[merge_chunks] memory_get_usage on chunk '.++$i.': '.memory_get_usage());
1463	}
1464
1465	if (!file_put_contents($output_filepath, $string, FILE_APPEND))
1466	{
1467	new PwgError(500, '[merge_chunks] error while writting chunks for '.$output_filepath);
1468	exit();
1469	}
1470
1471	unlink($chunk);
1472	}
1473
1474	if (function_exists('memory_get_usage')) {
1475	ws_logfile('[merge_chunks] memory_get_usage after loading chunks: '.memory_get_usage());
1476	}
1477	}
1478
1479	/*
1480	* The $file_path must be the path of the basic "web sized" photo
1481	* The $type value will automatically modify the $file_path to the corresponding file
1482	*/
1483	function add_file($file_path, $type, $original_sum, $file_sum)
1484	{
1485	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1486
1487	$file_path = file_path_for_type($file_path, $type);
1488
1489	$upload_dir = dirname($file_path);
1490	if (substr(PHP_OS, 0, 3) == 'WIN')
1491	{
1492	$upload_dir = str_replace('/', DIRECTORY_SEPARATOR, $upload_dir);
1493	}
1494
1495	ws_logfile('[add_file] file_path : '.$file_path);
1496	ws_logfile('[add_file] upload_dir : '.$upload_dir);
1497
1498	if (!is_dir($upload_dir)) {
1499	umask(0000);
1500	$recursive = true;
1501	if (!@mkdir($upload_dir, 0777, $recursive))
1502	{
1503	new PwgError(500, '[add_file] error during '.$type.' directory creation');
1504	exit();
1505	}
1506	}
1507
1508	if (!is_writable($upload_dir))
1509	{
1510	// last chance to make the directory writable
1511	@chmod($upload_dir, 0777);
1512
1513	if (!is_writable($upload_dir))
1514	{
1515	new PwgError(500, '[add_file] '.$type.' directory has no write access');
1516	exit();
1517	}
1518	}
1519
1520	secure_directory($upload_dir);
1521
1522	// merge the thumbnail
1523	merge_chunks($file_path, $original_sum, $type);
1524	chmod($file_path, 0644);
1525
1526	// check dumped thumbnail md5
1527	$dumped_md5 = md5_file($file_path);
1528	if ($dumped_md5 != $file_sum) {
1529	new PwgError(500, '[add_file] '.$type.' transfer failed');
1530	exit();
1531	}
1532
1533	list($width, $height) = getimagesize($file_path);
1534	$filesize = floor(filesize($file_path)/1024);
1535
1536	return array(
1537	'width' => $width,
1538	'height' => $height,
1539	'filesize' => $filesize,
1540	);
1541	}
1542
1543	function ws_images_addFile($params, &$service)
1544	{
1545	// image_id
1546	// type {thumb, file, high}
1547	// sum
1548
1549	global $conf;
1550	if (!is_admin())
1551	{
1552	return new PwgError(401, 'Access denied');
1553	}
1554
1555	$params['image_id'] = (int)$params['image_id'];
1556	if ($params['image_id'] <= 0)
1557	{
1558	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1559	}
1560
1561	//
1562	// what is the path?
1563	//
1564	$query = '
1565	SELECT
1566	path,
1567	md5sum
1568	FROM '.IMAGES_TABLE.'
1569	WHERE id = '.$params['image_id'].'
1570	;';
1571	list($file_path, $original_sum) = pwg_db_fetch_row(pwg_query($query));
1572
1573	// TODO only files added with web API can be updated with web API
1574
1575	//
1576	// makes sure directories are there and call the merge_chunks
1577	//
1578	$infos = add_file($file_path, $params['type'], $original_sum, $params['sum']);
1579
1580	//
1581	// update basic metadata from file
1582	//
1583	$update = array();
1584
1585	if ('high' == $params['type'])
1586	{
1587	$update['high_filesize'] = $infos['filesize'];
1588	$update['high_width'] = $infos['width'];
1589	$update['high_height'] = $infos['height'];
1590	$update['has_high'] = 'true';
1591	}
1592
1593	if ('file' == $params['type'])
1594	{
1595	$update['filesize'] = $infos['filesize'];
1596	$update['width'] = $infos['width'];
1597	$update['height'] = $infos['height'];
1598	}
1599
1600	// we may have nothing to update at database level, for example with a
1601	// thumbnail update
1602	if (count($update) > 0)
1603	{
1604	$update['id'] = $params['image_id'];
1605
1606	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1607	mass_updates(
1608	IMAGES_TABLE,
1609	array(
1610	'primary' => array('id'),
1611	'update' => array_diff(array_keys($update), array('id'))
1612	),
1613	array($update)
1614	);
1615	}
1616	}
1617
1618	function ws_images_add($params, &$service)
1619	{
1620	global $conf, $user;
1621	if (!is_admin())
1622	{
1623	return new PwgError(401, 'Access denied');
1624	}
1625
1626	foreach ($params as $param_key => $param_value) {
1627	ws_logfile(
1628	sprintf(
1629	'[pwg.images.add] input param "%s" : "%s"',
1630	$param_key,
1631	is_null($param_value) ? 'NULL' : $param_value
1632	)
1633	);
1634	}
1635
1636	// does the image already exists ?
1637	if ($params['check_uniqueness'])
1638	{
1639	if ('md5sum' == $conf['uniqueness_mode'])
1640	{
1641	$where_clause = "md5sum = '".$params['original_sum']."'";
1642	}
1643	if ('filename' == $conf['uniqueness_mode'])
1644	{
1645	$where_clause = "file = '".$params['original_filename']."'";
1646	}
1647
1648	$query = '
1649	SELECT
1650	COUNT(*) AS counter
1651	FROM '.IMAGES_TABLE.'
1652	WHERE '.$where_clause.'
1653	;';
1654	list($counter) = pwg_db_fetch_row(pwg_query($query));
1655	if ($counter != 0) {
1656	return new PwgError(500, 'file already exists');
1657	}
1658	}
1659
1660	if ($params['resize'])
1661	{
1662	ws_logfile('[pwg.images.add] resize activated');
1663
1664	// temporary file path
1665	$type = 'file';
1666	$file_path = $conf['upload_dir'].'/buffer/'.$params['original_sum'].'-'.$type;
1667
1668	merge_chunks($file_path, $params['original_sum'], $type);
1669	chmod($file_path, 0644);
1670
1671	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1672
1673	$image_id = add_uploaded_file(
1674	$file_path,
1675	$params['original_filename']
1676	);
1677
1678	// add_uploaded_file doesn't remove the original file in the buffer
1679	// directory if it was not uploaded as $_FILES
1680	unlink($file_path);
1681
1682	$info_columns = array(
1683	'name',
1684	'author',
1685	'comment',
1686	'level',
1687	'date_creation',
1688	);
1689
1690	foreach ($info_columns as $key)
1691	{
1692	if (isset($params[$key]))
1693	{
1694	$update[$key] = $params[$key];
1695	}
1696	}
1697
1698	if (count(array_keys($update)) > 0)
1699	{
1700	single_update(
1701	IMAGES_TABLE,
1702	$update,
1703	array('id' => $image_id)
1704	);
1705	}
1706	}
1707	else
1708	{
1709	// current date
1710	list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
1711	list($year, $month, $day) = preg_split('/[^\d]/', $dbnow, 4);
1712
1713	// upload directory hierarchy
1714	$upload_dir = sprintf(
1715	$conf['upload_dir'].'/%s/%s/%s',
1716	$year,
1717	$month,
1718	$day
1719	);
1720
1721	// compute file path
1722	$date_string = preg_replace('/[^\d]/', '', $dbnow);
1723	$random_string = substr($params['file_sum'], 0, 8);
1724	$filename_wo_ext = $date_string.'-'.$random_string;
1725	$file_path = $upload_dir.'/'.$filename_wo_ext.'.jpg';
1726
1727	// add files
1728	$file_infos = add_file($file_path, 'file', $params['original_sum'], $params['file_sum']);
1729	$thumb_infos = add_file($file_path, 'thumb', $params['original_sum'], $params['thumbnail_sum']);
1730
1731	if (isset($params['high_sum']))
1732	{
1733	$high_infos = add_file($file_path, 'high', $params['original_sum'], $params['high_sum']);
1734	}
1735
1736	// database registration
1737	$insert = array(
1738	'file' => !empty($params['original_filename']) ? $params['original_filename'] : $filename_wo_ext.'.jpg',
1739	'date_available' => $dbnow,
1740	'tn_ext' => 'jpg',
1741	'name' => $params['name'],
1742	'path' => $file_path,
1743	'filesize' => $file_infos['filesize'],
1744	'width' => $file_infos['width'],
1745	'height' => $file_infos['height'],
1746	'md5sum' => $params['original_sum'],
1747	'added_by' => $user['id'],
1748	);
1749
1750	$info_columns = array(
1751	'name',
1752	'author',
1753	'comment',
1754	'level',
1755	'date_creation',
1756	);
1757
1758	foreach ($info_columns as $key)
1759	{
1760	if (isset($params[$key]))
1761	{
1762	$insert[$key] = $params[$key];
1763	}
1764	}
1765
1766	if (isset($params['high_sum']))
1767	{
1768	$insert['has_high'] = 'true';
1769	$insert['high_filesize'] = $high_infos['filesize'];
1770	$insert['high_width'] = $high_infos['width'];
1771	$insert['high_height'] = $high_infos['height'];
1772	}
1773
1774	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1775	mass_inserts(
1776	IMAGES_TABLE,
1777	array_keys($insert),
1778	array($insert)
1779	);
1780
1781	$image_id = pwg_db_insert_id(IMAGES_TABLE);
1782
1783	// update metadata from the uploaded file (exif/iptc)
1784	require_once(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
1785	update_metadata(array($image_id=>$file_path));
1786	}
1787
1788	$url_params = array('image_id' => $image_id);
1789
1790	// let's add links between the image and the categories
1791	if (isset($params['categories']))
1792	{
1793	ws_add_image_category_relations($image_id, $params['categories']);
1794
1795	if (preg_match('/^\d+/', $params['categories'], $matches)) {
1796	$category_id = $matches[0];
1797
1798	$query = '
1799	SELECT id, name, permalink
1800	FROM '.CATEGORIES_TABLE.'
1801	WHERE id = '.$category_id.'
1802	;';
1803	$result = pwg_query($query);
1804	$category = pwg_db_fetch_assoc($result);
1805
1806	$url_params['section'] = 'categories';
1807	$url_params['category'] = $category;
1808	}
1809	}
1810
1811	// and now, let's create tag associations
1812	if (isset($params['tag_ids']) and !empty($params['tag_ids']))
1813	{
1814	set_tags(
1815	explode(',', $params['tag_ids']),
1816	$image_id
1817	);
1818	}
1819
1820	invalidate_user_cache();
1821
1822	return array(
1823	'image_id' => $image_id,
1824	'url' => make_picture_url($url_params),
1825	);
1826	}
1827
1828	function ws_images_addSimple($params, &$service)
1829	{
1830	global $conf;
1831	if (!is_admin())
1832	{
1833	return new PwgError(401, 'Access denied');
1834	}
1835
1836	if (!$service->isPost())
1837	{
1838	return new PwgError(405, "This method requires HTTP POST");
1839	}
1840
1841	if (!isset($_FILES['image']))
1842	{
1843	return new PwgError(405, "The image (file) parameter is missing");
1844	}
1845
1846	$params['image_id'] = (int)$params['image_id'];
1847	if ($params['image_id'] > 0)
1848	{
1849	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1850
1851	$query='
1852	SELECT *
1853	FROM '.IMAGES_TABLE.'
1854	WHERE id = '.$params['image_id'].'
1855	;';
1856
1857	$image_row = pwg_db_fetch_assoc(pwg_query($query));
1858	if ($image_row == null)
1859	{
1860	return new PwgError(404, "image_id not found");
1861	}
1862	}
1863
1864	// category
1865	$params['category'] = (int)$params['category'];
1866	if ($params['category'] <= 0 and $params['image_id'] <= 0)
1867	{
1868	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
1869	}
1870
1871	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1872
1873	$image_id = add_uploaded_file(
1874	$_FILES['image']['tmp_name'],
1875	$_FILES['image']['name'],
1876	$params['category'] > 0 ? array($params['category']) : null,
1877	8,
1878	$params['image_id'] > 0 ? $params['image_id'] : null
1879	);
1880
1881	$info_columns = array(
1882	'name',
1883	'author',
1884	'comment',
1885	'level',
1886	'date_creation',
1887	);
1888
1889	foreach ($info_columns as $key)
1890	{
1891	if (isset($params[$key]))
1892	{
1893	$update[$key] = $params[$key];
1894	}
1895	}
1896
1897	if (count(array_keys($update)) > 0)
1898	{
1899	$update['id'] = $image_id;
1900
1901	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1902	mass_updates(
1903	IMAGES_TABLE,
1904	array(
1905	'primary' => array('id'),
1906	'update' => array_diff(array_keys($update), array('id'))
1907	),
1908	array($update)
1909	);
1910	}
1911
1912
1913	if (isset($params['tags']) and !empty($params['tags']))
1914	{
1915	$tag_ids = array();
1916	$tag_names = explode(',', $params['tags']);
1917	foreach ($tag_names as $tag_name)
1918	{
1919	$tag_id = tag_id_from_tag_name($tag_name);
1920	array_push($tag_ids, $tag_id);
1921	}
1922
1923	add_tags($tag_ids, array($image_id));
1924	}
1925
1926	$url_params = array('image_id' => $image_id);
1927
1928	if ($params['category'] > 0)
1929	{
1930	$query = '
1931	SELECT id, name, permalink
1932	FROM '.CATEGORIES_TABLE.'
1933	WHERE id = '.$params['category'].'
1934	;';
1935	$result = pwg_query($query);
1936	$category = pwg_db_fetch_assoc($result);
1937
1938	$url_params['section'] = 'categories';
1939	$url_params['category'] = $category;
1940	}
1941
1942	// update metadata from the uploaded file (exif/iptc), even if the sync
1943	// was already performed by add_uploaded_file().
1944	$query = '
1945	SELECT
1946	path
1947	FROM '.IMAGES_TABLE.'
1948	WHERE id = '.$image_id.'
1949	;';
1950	list($file_path) = pwg_db_fetch_row(pwg_query($query));
1951
1952	require_once(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
1953	update_metadata(array($image_id=>$file_path));
1954
1955	return array(
1956	'image_id' => $image_id,
1957	'url' => make_picture_url($url_params),
1958	);
1959	}
1960
1961	function ws_rates_delete($params, &$service)
1962	{
1963	global $conf;
1964
1965	if (!$service->isPost())
1966	{
1967	return new PwgError(405, 'This method requires HTTP POST');
1968	}
1969
1970	if (!is_admin())
1971	{
1972	return new PwgError(401, 'Access denied');
1973	}
1974
1975	$user_id = (int)$params['user_id'];
1976	if ($user_id<=0)
1977	{
1978	return new PwgError(WS_ERR_INVALID_PARAM, 'Invalid user_id');
1979	}
1980
1981	$query = '
1982	DELETE FROM '.RATE_TABLE.'
1983	WHERE user_id='.$user_id;
1984
1985	if (!empty($params['anonymous_id']))
1986	{
1987	$query .= ' AND anonymous_id=\''.$params['anonymous_id'].'\'';
1988	}
1989
1990	$changes = pwg_db_changes(pwg_query($query));
1991	if ($changes)
1992	{
1993	include_once(PHPWG_ROOT_PATH.'include/functions_rate.inc.php');
1994	update_rating_score();
1995	}
1996	return $changes;
1997	}
1998
1999
2000	/**
2001	* perform a login (web service method)
2002	*/
2003	function ws_session_login($params, &$service)
2004	{
2005	global $conf;
2006
2007	if (!$service->isPost())
2008	{
2009	return new PwgError(405, "This method requires HTTP POST");
2010	}
2011	if (try_log_user($params['username'], $params['password'],false))
2012	{
2013	return true;
2014	}
2015	return new PwgError(999, 'Invalid username/password');
2016	}
2017
2018
2019	/**
2020	* performs a logout (web service method)
2021	*/
2022	function ws_session_logout($params, &$service)
2023	{
2024	if (!is_a_guest())
2025	{
2026	logout_user();
2027	}
2028	return true;
2029	}
2030
2031	function ws_session_getStatus($params, &$service)
2032	{
2033	global $user;
2034	$res = array();
2035	$res['username'] = is_a_guest() ? 'guest' : stripslashes($user['username']);
2036	foreach ( array('status', 'theme', 'language') as $k )
2037	{
2038	$res[$k] = $user[$k];
2039	}
2040	$res['pwg_token'] = get_pwg_token();
2041	$res['charset'] = get_pwg_charset();
2042
2043	list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
2044	$res['current_datetime'] = $dbnow;
2045
2046	return $res;
2047	}
2048
2049
2050	/**
2051	* returns a list of tags (web service method)
2052	*/
2053	function ws_tags_getList($params, &$service)
2054	{
2055	$tags = get_available_tags();
2056	if ($params['sort_by_counter'])
2057	{
2058	usort($tags, create_function('$a,$b', 'return -$a["counter"]+$b["counter"];') );
2059	}
2060	else
2061	{
2062	usort($tags, 'tag_alpha_compare');
2063	}
2064	for ($i=0; $i<count($tags); $i++)
2065	{
2066	$tags[$i]['id'] = (int)$tags[$i]['id'];
2067	$tags[$i]['counter'] = (int)$tags[$i]['counter'];
2068	$tags[$i]['url'] = make_index_url(
2069	array(
2070	'section'=>'tags',
2071	'tags'=>array($tags[$i])
2072	)
2073	);
2074	}
2075	return array('tags' => new PwgNamedArray($tags, 'tag', array('id','url_name','url', 'name', 'counter' )) );
2076	}
2077
2078	/**
2079	* returns the list of tags as you can see them in administration (web
2080	* service method).
2081	*
2082	* Only admin can run this method and permissions are not taken into
2083	* account.
2084	*/
2085	function ws_tags_getAdminList($params, &$service)
2086	{
2087	if (!is_admin())
2088	{
2089	return new PwgError(401, 'Access denied');
2090	}
2091
2092	$tags = get_all_tags();
2093	return array(
2094	'tags' => new PwgNamedArray(
2095	$tags,
2096	'tag',
2097	array(
2098	'name',
2099	'id',
2100	'url_name',
2101	)
2102	)
2103	);
2104	}
2105
2106	/**
2107	* returns a list of images for tags (web service method)
2108	*/
2109	function ws_tags_getImages($params, &$service)
2110	{
2111	@include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
2112	global $conf;
2113
2114	// first build all the tag_ids we are interested in
2115	$params['tag_id'] = array_map( 'intval',$params['tag_id'] );
2116	$tags = find_tags($params['tag_id'], $params['tag_url_name'], $params['tag_name']);
2117	$tags_by_id = array();
2118	foreach( $tags as $tag )
2119	{
2120	$tags['id'] = (int)$tag['id'];
2121	$tags_by_id[ $tag['id'] ] = $tag;
2122	}
2123	unset($tags);
2124	$tag_ids = array_keys($tags_by_id);
2125
2126
2127	$where_clauses = ws_std_image_sql_filter($params);
2128	if (!empty($where_clauses))
2129	{
2130	$where_clauses = implode( ' AND ', $where_clauses);
2131	}
2132	$image_ids = get_image_ids_for_tags(
2133	$tag_ids,
2134	$params['tag_mode_and'] ? 'AND' : 'OR',
2135	$where_clauses,
2136	ws_std_image_sql_order($params) );
2137
2138
2139	$image_ids = array_slice($image_ids, (int)($params['per_page']*$params['page']), (int)$params['per_page'] );
2140
2141	$image_tag_map = array();
2142	if ( !empty($image_ids) and !$params['tag_mode_and'] )
2143	{ // build list of image ids with associated tags per image
2144	$query = '
2145	SELECT image_id, GROUP_CONCAT(tag_id) AS tag_ids
2146	FROM '.IMAGE_TAG_TABLE.'
2147	WHERE tag_id IN ('.implode(',',$tag_ids).') AND image_id IN ('.implode(',',$image_ids).')
2148	GROUP BY image_id';
2149	$result = pwg_query($query);
2150	while ( $row=pwg_db_fetch_assoc($result) )
2151	{
2152	$row['image_id'] = (int)$row['image_id'];
2153	array_push( $image_ids, $row['image_id'] );
2154	$image_tag_map[ $row['image_id'] ] = explode(',', $row['tag_ids']);
2155	}
2156	}
2157
2158	$images = array();
2159	if (!empty($image_ids))
2160	{
2161	$rank_of = array_flip($image_ids);
2162	$result = pwg_query('
2163	SELECT * FROM '.IMAGES_TABLE.'
2164	WHERE id IN ('.implode(',',$image_ids).')');
2165	while ($row = pwg_db_fetch_assoc($result))
2166	{
2167	$image = array();
2168	$image['rank'] = $rank_of[ $row['id'] ];
2169	foreach ( array('id', 'width', 'height', 'hit') as $k )
2170	{
2171	if (isset($row[$k]))
2172	{
2173	$image[$k] = (int)$row[$k];
2174	}
2175	}
2176	foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
2177	{
2178	$image[$k] = $row[$k];
2179	}
2180	$image = array_merge( $image, ws_std_get_urls($row) );
2181
2182	$image_tag_ids = ($params['tag_mode_and']) ? $tag_ids : $image_tag_map[$image['id']];
2183	$image_tags = array();
2184	foreach ($image_tag_ids as $tag_id)
2185	{
2186	$url = make_index_url(
2187	array(
2188	'section'=>'tags',
2189	'tags'=> array($tags_by_id[$tag_id])
2190	)
2191	);
2192	$page_url = make_picture_url(
2193	array(
2194	'section'=>'tags',
2195	'tags'=> array($tags_by_id[$tag_id]),
2196	'image_id' => $row['id'],
2197	'image_file' => $row['file'],
2198	)
2199	);
2200	array_push($image_tags, array(
2201	'id' => (int)$tag_id,
2202	'url' => $url,
2203	'page_url' => $page_url,
2204	)
2205	);
2206	}
2207	$image['tags'] = new PwgNamedArray($image_tags, 'tag',
2208	array('id','url_name','url','page_url')
2209	);
2210	array_push($images, $image);
2211	}
2212	usort($images, 'rank_compare');
2213	unset($rank_of);
2214	}
2215
2216	return array( 'images' =>
2217	array (
2218	WS_XML_ATTRIBUTES =>
2219	array(
2220	'page' => $params['page'],
2221	'per_page' => $params['per_page'],
2222	'count' => count($images)
2223	),
2224	WS_XML_CONTENT => new PwgNamedArray($images, 'image',
2225	ws_std_get_image_xml_attributes() )
2226	)
2227	);
2228	}
2229
2230	function ws_categories_add($params, &$service)
2231	{
2232	if (!is_admin())
2233	{
2234	return new PwgError(401, 'Access denied');
2235	}
2236
2237	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2238
2239	$creation_output = create_virtual_category(
2240	$params['name'],
2241	$params['parent']
2242	);
2243
2244	if (isset($creation_output['error']))
2245	{
2246	return new PwgError(500, $creation_output['error']);
2247	}
2248
2249	invalidate_user_cache();
2250
2251	return $creation_output;
2252	}
2253
2254	function ws_tags_add($params, &$service)
2255	{
2256	if (!is_admin())
2257	{
2258	return new PwgError(401, 'Access denied');
2259	}
2260
2261	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2262
2263	$creation_output = create_tag($params['name']);
2264
2265	if (isset($creation_output['error']))
2266	{
2267	return new PwgError(500, $creation_output['error']);
2268	}
2269
2270	return $creation_output;
2271	}
2272
2273	function ws_images_exist($params, &$service)
2274	{
2275	global $conf;
2276
2277	if (!is_admin())
2278	{
2279	return new PwgError(401, 'Access denied');
2280	}
2281
2282	$split_pattern = '/[\s,;\\|]/';
2283
2284	if ('md5sum' == $conf['uniqueness_mode'])
2285	{
2286	// search among photos the list of photos already added, based on md5sum
2287	// list
2288	$md5sums = preg_split(
2289	$split_pattern,
2290	$params['md5sum_list'],
2291	-1,
2292	PREG_SPLIT_NO_EMPTY
2293	);
2294
2295	$query = '
2296	SELECT
2297	id,
2298	md5sum
2299	FROM '.IMAGES_TABLE.'
2300	WHERE md5sum IN (\''.implode("','", $md5sums).'\')
2301	;';
2302	$id_of_md5 = simple_hash_from_query($query, 'md5sum', 'id');
2303
2304	$result = array();
2305
2306	foreach ($md5sums as $md5sum)
2307	{
2308	$result[$md5sum] = null;
2309	if (isset($id_of_md5[$md5sum]))
2310	{
2311	$result[$md5sum] = $id_of_md5[$md5sum];
2312	}
2313	}
2314	}
2315
2316	if ('filename' == $conf['uniqueness_mode'])
2317	{
2318	// search among photos the list of photos already added, based on
2319	// filename list
2320	$filenames = preg_split(
2321	$split_pattern,
2322	$params['filename_list'],
2323	-1,
2324	PREG_SPLIT_NO_EMPTY
2325	);
2326
2327	$query = '
2328	SELECT
2329	id,
2330	file
2331	FROM '.IMAGES_TABLE.'
2332	WHERE file IN (\''.implode("','", $filenames).'\')
2333	;';
2334	$id_of_filename = simple_hash_from_query($query, 'file', 'id');
2335
2336	$result = array();
2337
2338	foreach ($filenames as $filename)
2339	{
2340	$result[$filename] = null;
2341	if (isset($id_of_filename[$filename]))
2342	{
2343	$result[$filename] = $id_of_filename[$filename];
2344	}
2345	}
2346	}
2347
2348	return $result;
2349	}
2350
2351	function ws_images_checkFiles($params, &$service)
2352	{
2353	if (!is_admin())
2354	{
2355	return new PwgError(401, 'Access denied');
2356	}
2357
2358	// input parameters
2359	//
2360	// image_id
2361	// thumbnail_sum
2362	// file_sum
2363	// high_sum
2364
2365	$params['image_id'] = (int)$params['image_id'];
2366	if ($params['image_id'] <= 0)
2367	{
2368	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
2369	}
2370
2371	$query = '
2372	SELECT
2373	path
2374	FROM '.IMAGES_TABLE.'
2375	WHERE id = '.$params['image_id'].'
2376	;';
2377	$result = pwg_query($query);
2378	if (pwg_db_num_rows($result) == 0) {
2379	return new PwgError(404, "image_id not found");
2380	}
2381	list($path) = pwg_db_fetch_row($result);
2382
2383	$ret = array();
2384
2385	foreach (array('thumb', 'file', 'high') as $type) {
2386	$param_name = $type;
2387	if ('thumb' == $type) {
2388	$param_name = 'thumbnail';
2389	}
2390
2391	if (isset($params[$param_name.'_sum'])) {
2392	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
2393	$type_path = file_path_for_type($path, $type);
2394	if (!is_file($type_path)) {
2395	$ret[$param_name] = 'missing';
2396	}
2397	else {
2398	if (md5_file($type_path) != $params[$param_name.'_sum']) {
2399	$ret[$param_name] = 'differs';
2400	}
2401	else {
2402	$ret[$param_name] = 'equals';
2403	}
2404	}
2405	}
2406	}
2407
2408	return $ret;
2409	}
2410
2411	function ws_images_setInfo($params, &$service)
2412	{
2413	global $conf;
2414	if (!is_admin())
2415	{
2416	return new PwgError(401, 'Access denied');
2417	}
2418
2419	if (!$service->isPost())
2420	{
2421	return new PwgError(405, "This method requires HTTP POST");
2422	}
2423
2424	$params['image_id'] = (int)$params['image_id'];
2425	if ($params['image_id'] <= 0)
2426	{
2427	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
2428	}
2429
2430	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2431
2432	$query='
2433	SELECT *
2434	FROM '.IMAGES_TABLE.'
2435	WHERE id = '.$params['image_id'].'
2436	;';
2437
2438	$image_row = pwg_db_fetch_assoc(pwg_query($query));
2439	if ($image_row == null)
2440	{
2441	return new PwgError(404, "image_id not found");
2442	}
2443
2444	// database registration
2445	$update = array();
2446
2447	$info_columns = array(
2448	'name',
2449	'author',
2450	'comment',
2451	'level',
2452	'date_creation',
2453	);
2454
2455	foreach ($info_columns as $key)
2456	{
2457	if (isset($params[$key]))
2458	{
2459	if ('fill_if_empty' == $params['single_value_mode'])
2460	{
2461	if (empty($image_row[$key]))
2462	{
2463	$update[$key] = $params[$key];
2464	}
2465	}
2466	elseif ('replace' == $params['single_value_mode'])
2467	{
2468	$update[$key] = $params[$key];
2469	}
2470	else
2471	{
2472	new PwgError(
2473	500,
2474	'[ws_images_setInfo]'
2475	.' invalid parameter single_value_mode "'.$params['single_value_mode'].'"'
2476	.', possible values are {fill_if_empty, replace}.'
2477	);
2478	exit();
2479	}
2480	}
2481	}
2482
2483	if (isset($params['file']))
2484	{
2485	if (!empty($image_row['storage_category_id']))
2486	{
2487	new PwgError(500, '[ws_images_setInfo] updating "file" is forbidden on photos added by synchronization');
2488	exit();
2489	}
2490
2491	$update['file'] = $params['file'];
2492	}
2493
2494	if (count(array_keys($update)) > 0)
2495	{
2496	$update['id'] = $params['image_id'];
2497
2498	mass_updates(
2499	IMAGES_TABLE,
2500	array(
2501	'primary' => array('id'),
2502	'update' => array_diff(array_keys($update), array('id'))
2503	),
2504	array($update)
2505	);
2506	}
2507
2508	if (isset($params['categories']))
2509	{
2510	ws_add_image_category_relations(
2511	$params['image_id'],
2512	$params['categories'],
2513	('replace' == $params['multiple_value_mode'] ? true : false)
2514	);
2515	}
2516
2517	// and now, let's create tag associations
2518	if (isset($params['tag_ids']))
2519	{
2520	$tag_ids = explode(',', $params['tag_ids']);
2521
2522	if ('replace' == $params['multiple_value_mode'])
2523	{
2524	set_tags(
2525	$tag_ids,
2526	$params['image_id']
2527	);
2528	}
2529	elseif ('append' == $params['multiple_value_mode'])
2530	{
2531	add_tags(
2532	$tag_ids,
2533	array($params['image_id'])
2534	);
2535	}
2536	else
2537	{
2538	new PwgError(
2539	500,
2540	'[ws_images_setInfo]'
2541	.' invalid parameter multiple_value_mode "'.$params['multiple_value_mode'].'"'
2542	.', possible values are {replace, append}.'
2543	);
2544	exit();
2545	}
2546	}
2547
2548	invalidate_user_cache();
2549	}
2550
2551	function ws_images_delete($params, &$service)
2552	{
2553	global $conf;
2554	if (!is_admin())
2555	{
2556	return new PwgError(401, 'Access denied');
2557	}
2558
2559	if (!$service->isPost())
2560	{
2561	return new PwgError(405, "This method requires HTTP POST");
2562	}
2563
2564	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2565	{
2566	return new PwgError(403, 'Invalid security token');
2567	}
2568
2569	$params['image_id'] = preg_split(
2570	'/[\s,;\\|]/',
2571	$params['image_id'],
2572	-1,
2573	PREG_SPLIT_NO_EMPTY
2574	);
2575	$params['image_id'] = array_map('intval', $params['image_id']);
2576
2577	$image_ids = array();
2578	foreach ($params['image_id'] as $image_id)
2579	{
2580	if ($image_id > 0)
2581	{
2582	array_push($image_ids, $image_id);
2583	}
2584	}
2585
2586	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2587	delete_elements($image_ids, true);
2588	}
2589
2590	function ws_add_image_category_relations($image_id, $categories_string, $replace_mode=false)
2591	{
2592	// let's add links between the image and the categories
2593	//
2594	// $params['categories'] should look like 123,12;456,auto;789 which means:
2595	//
2596	// 1. associate with category 123 on rank 12
2597	// 2. associate with category 456 on automatic rank
2598	// 3. associate with category 789 on automatic rank
2599	$cat_ids = array();
2600	$rank_on_category = array();
2601	$search_current_ranks = false;
2602
2603	$tokens = explode(';', $categories_string);
2604	foreach ($tokens as $token)
2605	{
2606	@list($cat_id, $rank) = explode(',', $token);
2607
2608	if (!preg_match('/^\d+$/', $cat_id))
2609	{
2610	continue;
2611	}
2612
2613	array_push($cat_ids, $cat_id);
2614
2615	if (!isset($rank))
2616	{
2617	$rank = 'auto';
2618	}
2619	$rank_on_category[$cat_id] = $rank;
2620
2621	if ($rank == 'auto')
2622	{
2623	$search_current_ranks = true;
2624	}
2625	}
2626
2627	$cat_ids = array_unique($cat_ids);
2628
2629	if (count($cat_ids) == 0)
2630	{
2631	new PwgError(
2632	500,
2633	'[ws_add_image_category_relations] there is no category defined in "'.$categories_string.'"'
2634	);
2635	exit();
2636	}
2637
2638	$query = '
2639	SELECT
2640	id
2641	FROM '.CATEGORIES_TABLE.'
2642	WHERE id IN ('.implode(',', $cat_ids).')
2643	;';
2644	$db_cat_ids = array_from_query($query, 'id');
2645
2646	$unknown_cat_ids = array_diff($cat_ids, $db_cat_ids);
2647	if (count($unknown_cat_ids) != 0)
2648	{
2649	new PwgError(
2650	500,
2651	'[ws_add_image_category_relations] the following categories are unknown: '.implode(', ', $unknown_cat_ids)
2652	);
2653	exit();
2654	}
2655
2656	$to_update_cat_ids = array();
2657
2658	// in case of replace mode, we first check the existing associations
2659	$query = '
2660	SELECT
2661	category_id
2662	FROM '.IMAGE_CATEGORY_TABLE.'
2663	WHERE image_id = '.$image_id.'
2664	;';
2665	$existing_cat_ids = array_from_query($query, 'category_id');
2666
2667	if ($replace_mode)
2668	{
2669	$to_remove_cat_ids = array_diff($existing_cat_ids, $cat_ids);
2670	if (count($to_remove_cat_ids) > 0)
2671	{
2672	$query = '
2673	DELETE
2674	FROM '.IMAGE_CATEGORY_TABLE.'
2675	WHERE image_id = '.$image_id.'
2676	AND category_id IN ('.implode(', ', $to_remove_cat_ids).')
2677	;';
2678	pwg_query($query);
2679	update_category($to_remove_cat_ids);
2680	}
2681	}
2682
2683	$new_cat_ids = array_diff($cat_ids, $existing_cat_ids);
2684	if (count($new_cat_ids) == 0)
2685	{
2686	return true;
2687	}
2688
2689	if ($search_current_ranks)
2690	{
2691	$query = '
2692	SELECT
2693	category_id,
2694	MAX(rank) AS max_rank
2695	FROM '.IMAGE_CATEGORY_TABLE.'
2696	WHERE rank IS NOT NULL
2697	AND category_id IN ('.implode(',', $new_cat_ids).')
2698	GROUP BY category_id
2699	;';
2700	$current_rank_of = simple_hash_from_query(
2701	$query,
2702	'category_id',
2703	'max_rank'
2704	);
2705
2706	foreach ($new_cat_ids as $cat_id)
2707	{
2708	if (!isset($current_rank_of[$cat_id]))
2709	{
2710	$current_rank_of[$cat_id] = 0;
2711	}
2712
2713	if ('auto' == $rank_on_category[$cat_id])
2714	{
2715	$rank_on_category[$cat_id] = $current_rank_of[$cat_id] + 1;
2716	}
2717	}
2718	}
2719
2720	$inserts = array();
2721
2722	foreach ($new_cat_ids as $cat_id)
2723	{
2724	array_push(
2725	$inserts,
2726	array(
2727	'image_id' => $image_id,
2728	'category_id' => $cat_id,
2729	'rank' => $rank_on_category[$cat_id],
2730	)
2731	);
2732	}
2733
2734	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2735	mass_inserts(
2736	IMAGE_CATEGORY_TABLE,
2737	array_keys($inserts[0]),
2738	$inserts
2739	);
2740
2741	update_category($new_cat_ids);
2742	}
2743
2744	function ws_categories_setInfo($params, &$service)
2745	{
2746	global $conf;
2747	if (!is_admin())
2748	{
2749	return new PwgError(401, 'Access denied');
2750	}
2751
2752	if (!$service->isPost())
2753	{
2754	return new PwgError(405, "This method requires HTTP POST");
2755	}
2756
2757	// category_id
2758	// name
2759	// comment
2760
2761	$params['category_id'] = (int)$params['category_id'];
2762	if ($params['category_id'] <= 0)
2763	{
2764	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
2765	}
2766
2767	// database registration
2768	$update = array(
2769	'id' => $params['category_id'],
2770	);
2771
2772	$info_columns = array(
2773	'name',
2774	'comment',
2775	);
2776
2777	$perform_update = false;
2778	foreach ($info_columns as $key)
2779	{
2780	if (isset($params[$key]))
2781	{
2782	$perform_update = true;
2783	$update[$key] = $params[$key];
2784	}
2785	}
2786
2787	if ($perform_update)
2788	{
2789	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2790	mass_updates(
2791	CATEGORIES_TABLE,
2792	array(
2793	'primary' => array('id'),
2794	'update' => array_diff(array_keys($update), array('id'))
2795	),
2796	array($update)
2797	);
2798	}
2799
2800	}
2801
2802	function ws_categories_setRepresentative($params, &$service)
2803	{
2804	global $conf;
2805
2806	if (!is_admin())
2807	{
2808	return new PwgError(401, 'Access denied');
2809	}
2810
2811	if (!$service->isPost())
2812	{
2813	return new PwgError(405, "This method requires HTTP POST");
2814	}
2815
2816	// category_id
2817	// image_id
2818
2819	$params['category_id'] = (int)$params['category_id'];
2820	if ($params['category_id'] <= 0)
2821	{
2822	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
2823	}
2824
2825	// does the category really exist?
2826	$query='
2827	SELECT
2828	*
2829	FROM '.CATEGORIES_TABLE.'
2830	WHERE id = '.$params['category_id'].'
2831	;';
2832	$row = pwg_db_fetch_assoc(pwg_query($query));
2833	if ($row == null)
2834	{
2835	return new PwgError(404, "category_id not found");
2836	}
2837
2838	$params['image_id'] = (int)$params['image_id'];
2839	if ($params['image_id'] <= 0)
2840	{
2841	return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
2842	}
2843
2844	// does the image really exist?
2845	$query='
2846	SELECT
2847	*
2848	FROM '.IMAGES_TABLE.'
2849	WHERE id = '.$params['image_id'].'
2850	;';
2851
2852	$row = pwg_db_fetch_assoc(pwg_query($query));
2853	if ($row == null)
2854	{
2855	return new PwgError(404, "image_id not found");
2856	}
2857
2858	// apply change
2859	$query = '
2860	UPDATE '.CATEGORIES_TABLE.'
2861	SET representative_picture_id = '.$params['image_id'].'
2862	WHERE id = '.$params['category_id'].'
2863	;';
2864	pwg_query($query);
2865
2866	$query = '
2867	UPDATE '.USER_CACHE_CATEGORIES_TABLE.'
2868	SET user_representative_picture_id = NULL
2869	WHERE cat_id = '.$params['category_id'].'
2870	;';
2871	pwg_query($query);
2872	}
2873
2874	function ws_categories_delete($params, &$service)
2875	{
2876	global $conf;
2877	if (!is_admin())
2878	{
2879	return new PwgError(401, 'Access denied');
2880	}
2881
2882	if (!$service->isPost())
2883	{
2884	return new PwgError(405, "This method requires HTTP POST");
2885	}
2886
2887	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2888	{
2889	return new PwgError(403, 'Invalid security token');
2890	}
2891
2892	$modes = array('no_delete', 'delete_orphans', 'force_delete');
2893	if (!in_array($params['photo_deletion_mode'], $modes))
2894	{
2895	return new PwgError(
2896	500,
2897	'[ws_categories_delete]'
2898	.' invalid parameter photo_deletion_mode "'.$params['photo_deletion_mode'].'"'
2899	.', possible values are {'.implode(', ', $modes).'}.'
2900	);
2901	}
2902
2903	$params['category_id'] = preg_split(
2904	'/[\s,;\\|]/',
2905	$params['category_id'],
2906	-1,
2907	PREG_SPLIT_NO_EMPTY
2908	);
2909	$params['category_id'] = array_map('intval', $params['category_id']);
2910
2911	$category_ids = array();
2912	foreach ($params['category_id'] as $category_id)
2913	{
2914	if ($category_id > 0)
2915	{
2916	array_push($category_ids, $category_id);
2917	}
2918	}
2919
2920	if (count($category_ids) == 0)
2921	{
2922	return;
2923	}
2924
2925	$query = '
2926	SELECT id
2927	FROM '.CATEGORIES_TABLE.'
2928	WHERE id IN ('.implode(',', $category_ids).')
2929	;';
2930	$category_ids = array_from_query($query, 'id');
2931
2932	if (count($category_ids) == 0)
2933	{
2934	return;
2935	}
2936
2937	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2938	delete_categories($category_ids, $params['photo_deletion_mode']);
2939	update_global_rank();
2940	}
2941
2942	function ws_categories_move($params, &$service)
2943	{
2944	global $conf, $page;
2945
2946	if (!is_admin())
2947	{
2948	return new PwgError(401, 'Access denied');
2949	}
2950
2951	if (!$service->isPost())
2952	{
2953	return new PwgError(405, "This method requires HTTP POST");
2954	}
2955
2956	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2957	{
2958	return new PwgError(403, 'Invalid security token');
2959	}
2960
2961	$params['category_id'] = preg_split(
2962	'/[\s,;\\|]/',
2963	$params['category_id'],
2964	-1,
2965	PREG_SPLIT_NO_EMPTY
2966	);
2967	$params['category_id'] = array_map('intval', $params['category_id']);
2968
2969	$category_ids = array();
2970	foreach ($params['category_id'] as $category_id)
2971	{
2972	if ($category_id > 0)
2973	{
2974	array_push($category_ids, $category_id);
2975	}
2976	}
2977
2978	if (count($category_ids) == 0)
2979	{
2980	return new PwgError(403, 'Invalid category_id input parameter, no category to move');
2981	}
2982
2983	// we can't move physical categories
2984	$categories_in_db = array();
2985
2986	$query = '
2987	SELECT
2988	id,
2989	name,
2990	dir
2991	FROM '.CATEGORIES_TABLE.'
2992	WHERE id IN ('.implode(',', $category_ids).')
2993	;';
2994	$result = pwg_query($query);
2995	while ($row = pwg_db_fetch_assoc($result))
2996	{
2997	$categories_in_db[$row['id']] = $row;
2998	// we break on error at first physical category detected
2999	if (!empty($row['dir']))
3000	{
3001	$row['name'] = strip_tags(
3002	trigger_event(
3003	'render_category_name',
3004	$row['name'],
3005	'ws_categories_move'
3006	)
3007	);
3008
3009	return new PwgError(
3010	403,
3011	sprintf(
3012	'Category %s (%u) is not a virtual category, you cannot move it',
3013	$row['name'],
3014	$row['id']
3015	)
3016	);
3017	}
3018	}
3019
3020	if (count($categories_in_db) != count($category_ids))
3021	{
3022	$unknown_category_ids = array_diff($category_ids, array_keys($categories_in_db));
3023
3024	return new PwgError(
3025	403,
3026	sprintf(
3027	'Category %u does not exist',
3028	$unknown_category_ids[0]
3029	)
3030	);
3031	}
3032
3033	// does this parent exists? This check should be made in the
3034	// move_categories function, not here
3035	//
3036	// 0 as parent means "move categories at gallery root"
3037	if (!is_numeric($params['parent']))
3038	{
3039	return new PwgError(403, 'Invalid parent input parameter');
3040	}
3041
3042	if (0 != $params['parent']) {
3043	$params['parent'] = intval($params['parent']);
3044	$subcat_ids = get_subcat_ids(array($params['parent']));
3045	if (count($subcat_ids) == 0)
3046	{
3047	return new PwgError(403, 'Unknown parent category id');
3048	}
3049	}
3050
3051	$page['infos'] = array();
3052	$page['errors'] = array();
3053	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
3054	move_categories($category_ids, $params['parent']);
3055	invalidate_user_cache();
3056
3057	if (count($page['errors']) != 0)
3058	{
3059	return new PwgError(403, implode('; ', $page['errors']));
3060	}
3061	}
3062
3063	function ws_logfile($string)
3064	{
3065	global $conf;
3066
3067	if (!$conf['ws_enable_log']) {
3068	return true;
3069	}
3070
3071	file_put_contents(
3072	$conf['ws_log_filepath'],
3073	'['.date('c').'] '.$string."\n",
3074	FILE_APPEND
3075	);
3076	}
3077
3078	function ws_images_checkUpload($params, &$service)
3079	{
3080	global $conf;
3081
3082	if (!is_admin())
3083	{
3084	return new PwgError(401, 'Access denied');
3085	}
3086
3087	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
3088	$ret['message'] = ready_for_upload_message();
3089	$ret['ready_for_upload'] = true;
3090
3091	if (!empty($ret['message']))
3092	{
3093	$ret['ready_for_upload'] = false;
3094	}
3095
3096	return $ret;
3097	}
3098
3099	function ws_plugins_getList($params, &$service)
3100	{
3101	global $conf;
3102
3103	if (!is_admin())
3104	{
3105	return new PwgError(401, 'Access denied');
3106	}
3107
3108	include_once(PHPWG_ROOT_PATH.'admin/include/plugins.class.php');
3109	$plugins = new plugins();
3110	$plugins->sort_fs_plugins('name');
3111	$plugin_list = array();
3112
3113	foreach($plugins->fs_plugins as $plugin_id => $fs_plugin)
3114	{
3115	if (isset($plugins->db_plugins_by_id[$plugin_id]))
3116	{
3117	$state = $plugins->db_plugins_by_id[$plugin_id]['state'];
3118	}
3119	else
3120	{
3121	$state = 'uninstalled';
3122	}
3123
3124	array_push(
3125	$plugin_list,
3126	array(
3127	'id' => $plugin_id,
3128	'name' => $fs_plugin['name'],
3129	'version' => $fs_plugin['version'],
3130	'state' => $state,
3131	'description' => $fs_plugin['description'],
3132	)
3133	);
3134	}
3135
3136	return $plugin_list;
3137	}
3138
3139	function ws_plugins_performAction($params, &$service)
3140	{
3141	global $template;
3142
3143	if (!is_admin())
3144	{
3145	return new PwgError(401, 'Access denied');
3146	}
3147
3148	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
3149	{
3150	return new PwgError(403, 'Invalid security token');
3151	}
3152
3153	define('IN_ADMIN', true);
3154	include_once(PHPWG_ROOT_PATH.'admin/include/plugins.class.php');
3155	$plugins = new plugins();
3156	$errors = $plugins->perform_action($params['action'], $params['plugin']);
3157
3158
3159	if (!empty($errors))
3160	{
3161	return new PwgError(500, $errors);
3162	}
3163	else
3164	{
3165	if (in_array($params['action'], array('activate', 'deactivate')))
3166	{
3167	$template->delete_compiled_templates();
3168	}
3169	return true;
3170	}
3171	}
3172
3173	function ws_themes_performAction($params, &$service)
3174	{
3175	global $template;
3176
3177	if (!is_admin())
3178	{
3179	return new PwgError(401, 'Access denied');
3180	}
3181
3182	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
3183	{
3184	return new PwgError(403, 'Invalid security token');
3185	}
3186
3187	define('IN_ADMIN', true);
3188	include_once(PHPWG_ROOT_PATH.'admin/include/themes.class.php');
3189	$themes = new themes();
3190	$errors = $themes->perform_action($params['action'], $params['theme']);
3191
3192	if (!empty($errors))
3193	{
3194	return new PwgError(500, $errors);
3195	}
3196	else
3197	{
3198	if (in_array($params['action'], array('activate', 'deactivate')))
3199	{
3200	$template->delete_compiled_templates();
3201	}
3202	return true;
3203	}
3204	}
3205
3206	function ws_images_resizethumbnail($params, &$service)
3207	{
3208	if (!is_admin())
3209	{
3210	return new PwgError(401, 'Access denied');
3211	}
3212
3213	if (empty($params['image_id']) and empty($params['image_path']))
3214	{
3215	return new PwgError(403, "image_id or image_path is missing");
3216	}
3217
3218	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
3219	include_once(PHPWG_ROOT_PATH.'admin/include/image.class.php');
3220
3221	if (!empty($params['image_id']))
3222	{
3223	$query='
3224	SELECT id, path, tn_ext, has_high
3225	FROM '.IMAGES_TABLE.'
3226	WHERE id = '.(int)$params['image_id'].'
3227	;';
3228	$image = pwg_db_fetch_assoc(pwg_query($query));
3229
3230	if ($image == null)
3231	{
3232	return new PwgError(403, "image_id not found");
3233	}
3234
3235	$image_path = $image['path'];
3236	$thumb_path = get_thumbnail_path($image);
3237	}
3238	else
3239	{
3240	$image_path = $params['image_path'];
3241	$thumb_path = file_path_for_type($image_path, 'thumb');
3242	}
3243
3244	if (!file_exists($image_path) or !is_valid_image_extension(get_extension($image_path)))
3245	{
3246	return new PwgError(403, "image can't be resized");
3247	}
3248
3249	$result = false;
3250	prepare_directory(dirname($thumb_path));
3251	$img = new pwg_image($image_path, $params['library']);
3252
3253	if (!is_bool($params['crop']))
3254	$params['crop'] = get_boolean($params['crop']);
3255	if (!is_bool($params['follow_orientation']))
3256	$params['follow_orientation'] = get_boolean($params['follow_orientation']);
3257
3258	$result = $img->pwg_resize(
3259	$thumb_path,
3260	$params['maxwidth'],
3261	$params['maxheight'],
3262	$params['quality'],
3263	false, // automatic rotation is not needed for thumbnails.
3264	true, // strip metadata
3265	$params['crop'],
3266	$params['follow_orientation']
3267	);
3268
3269	$img->destroy();
3270	return $result;
3271	}
3272
3273	function ws_images_resizewebsize($params, &$service)
3274	{
3275	if (!is_admin())
3276	{
3277	return new PwgError(401, 'Access denied');
3278	}
3279
3280	include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
3281	include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
3282	include_once(PHPWG_ROOT_PATH.'admin/include/image.class.php');
3283
3284	$query='
3285	SELECT id, path, tn_ext, has_high, width, height
3286	FROM '.IMAGES_TABLE.'
3287	WHERE id = '.(int)$params['image_id'].'
3288	;';
3289	$image = pwg_db_fetch_assoc(pwg_query($query));
3290
3291	if ($image == null)
3292	{
3293	return new PwgError(403, "image_id not found");
3294	}
3295
3296	$image_path = $image['path'];
3297
3298	if (!is_valid_image_extension(get_extension($image_path)))
3299	{
3300	return new PwgError(403, "image can't be resized");
3301	}
3302
3303	$hd_path = get_high_path($image);
3304
3305	if (empty($image['has_high']) or !file_exists($hd_path))
3306	{
3307	if ($image['width'] > $params['maxwidth'] or $image['height'] > $params['maxheight'])
3308	{
3309	$hd_path = file_path_for_type($image_path, 'high');
3310	$hd_dir = dirname($hd_path);
3311	prepare_directory($hd_dir);
3312
3313	rename($image_path, $hd_path);
3314	$hd_infos = pwg_image_infos($hd_path);
3315
3316	single_update(
3317	IMAGES_TABLE,
3318	array(
3319	'has_high' => 'true',
3320	'high_filesize' => $hd_infos['filesize'],
3321	'high_width' => $hd_infos['width'],
3322	'high_height' => $hd_infos['height'],
3323	),
3324	array(
3325	'id' => $image['id']
3326	)
3327	);
3328	}
3329	else
3330	{
3331	return new PwgError(403, "image can't be resized");
3332	}
3333	}
3334
3335	$result = false;
3336	$img = new pwg_image($hd_path, $params['library']);
3337
3338	$result = $img->pwg_resize(
3339	$image_path,
3340	$params['maxwidth'],
3341	$params['maxheight'],
3342	$params['quality'],
3343	$params['automatic_rotation'],
3344	false // strip metadata
3345	);
3346
3347	$img->destroy();
3348
3349	global $conf;
3350	$conf['use_exif'] = false;
3351	$conf['use_iptc'] = false;
3352	update_metadata(array($image['id'] => $image['path']));
3353
3354	return $result;
3355	}
3356
3357	function ws_extensions_update($params, &$service)
3358	{
3359	if (!is_webmaster())
3360	{
3361	return new PwgError(401, l10n('Webmaster status is required.'));
3362	}
3363
3364	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
3365	{
3366	return new PwgError(403, 'Invalid security token');
3367	}
3368
3369	if (empty($params['type']) or !in_array($params['type'], array('plugins', 'themes', 'languages')))
3370	{
3371	return new PwgError(403, "invalid extension type");
3372	}
3373
3374	if (empty($params['id']) or empty($params['revision']))
3375	{
3376	return new PwgError(null, 'Wrong parameters');
3377	}
3378
3379	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
3380	include_once(PHPWG_ROOT_PATH.'admin/include/'.$params['type'].'.class.php');
3381
3382	$type = $params['type'];
3383	$extension_id = $params['id'];
3384	$revision = $params['revision'];
3385
3386	$extension = new $type();
3387
3388	if ($type == 'plugins')
3389	{
3390	if (isset($extension->db_plugins_by_id[$extension_id]) and $extension->db_plugins_by_id[$extension_id]['state'] == 'active')
3391	{
3392	$extension->perform_action('deactivate', $extension_id);
3393
3394	redirect(PHPWG_ROOT_PATH
3395	. 'ws.php'
3396	. '?method=pwg.extensions.update'
3397	. '&type=plugins'
3398	. '&id=' . $extension_id
3399	. '&revision=' . $revision
3400	. '&reactivate=true'
3401	. '&pwg_token=' . get_pwg_token()
3402	. '&format=json'
3403	);
3404	}
3405
3406	$upgrade_status = $extension->extract_plugin_files('upgrade', $revision, $extension_id);
3407	$extension_name = $extension->fs_plugins[$extension_id]['name'];
3408
3409	if (isset($params['reactivate']))
3410	{
3411	$extension->perform_action('activate', $extension_id);
3412	}
3413	}
3414	elseif ($type == 'themes')
3415	{
3416	$upgrade_status = $extension->extract_theme_files('upgrade', $revision, $extension_id);
3417	$extension_name = $extension->fs_themes[$extension_id]['name'];
3418	}
3419	elseif ($type == 'languages')
3420	{
3421	$upgrade_status = $extension->extract_language_files('upgrade', $revision, $extension_id);
3422	$extension_name = $extension->fs_languages[$extension_id]['name'];
3423	}
3424
3425	global $template;
3426	$template->delete_compiled_templates();
3427
3428	switch ($upgrade_status)
3429	{
3430	case 'ok':
3431	return sprintf(l10n('%s has been successfully updated.'), $extension_name);
3432
3433	case 'temp_path_error':
3434	return new PwgError(null, l10n('Can\'t create temporary file.'));
3435
3436	case 'dl_archive_error':
3437	return new PwgError(null, l10n('Can\'t download archive.'));
3438
3439	case 'archive_error':
3440	return new PwgError(null, l10n('Can\'t read or extract archive.'));
3441
3442	default:
3443	return new PwgError(null, sprintf(l10n('An error occured during extraction (%s).'), $upgrade_status));
3444	}
3445	}
3446
3447	function ws_extensions_ignoreupdate($params, &$service)
3448	{
3449	global $conf;
3450
3451	define('IN_ADMIN', true);
3452	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
3453
3454	if (!is_webmaster())
3455	{
3456	return new PwgError(401, 'Access denied');
3457	}
3458
3459	if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
3460	{
3461	return new PwgError(403, 'Invalid security token');
3462	}
3463
3464	$conf['updates_ignored'] = unserialize($conf['updates_ignored']);
3465
3466	// Reset ignored extension
3467	if ($params['reset'])
3468	{
3469	if (!empty($params['type']) and isset($conf['updates_ignored'][$params['type']]))
3470	{
3471	$conf['updates_ignored'][$params['type']] = array();
3472	}
3473	else
3474	{
3475	$conf['updates_ignored'] = array(
3476	'plugins'=>array(),
3477	'themes'=>array(),
3478	'languages'=>array()
3479	);
3480	}
3481	conf_update_param('updates_ignored', pwg_db_real_escape_string(serialize($conf['updates_ignored'])));
3482	unset($_SESSION['extensions_need_update']);
3483	return true;
3484	}
3485
3486	if (empty($params['id']) or empty($params['type']) or !in_array($params['type'], array('plugins', 'themes', 'languages')))
3487	{
3488	return new PwgError(403, 'Invalid parameters');
3489	}
3490
3491	// Add or remove extension from ignore list
3492	if (!in_array($params['id'], $conf['updates_ignored'][$params['type']]))
3493	{
3494	array_push($conf['updates_ignored'][$params['type']], $params['id']);
3495	}
3496	conf_update_param('updates_ignored', pwg_db_real_escape_string(serialize($conf['updates_ignored'])));
3497	unset($_SESSION['extensions_need_update']);
3498	return true;
3499	}
3500
3501	function ws_extensions_checkupdates($params, &$service)
3502	{
3503	global $conf;
3504
3505	define('IN_ADMIN', true);
3506	include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
3507	include_once(PHPWG_ROOT_PATH.'admin/include/updates.class.php');
3508	$update = new updates();
3509
3510	if (!is_admin())
3511	{
3512	return new PwgError(401, 'Access denied');
3513	}
3514
3515	$result = array();
3516
3517	if (!isset($_SESSION['need_update']))
3518	$update->check_piwigo_upgrade();
3519
3520	$result['piwigo_need_update'] = $_SESSION['need_update'];
3521
3522	$conf['updates_ignored'] = unserialize($conf['updates_ignored']);
3523
3524	if (!isset($_SESSION['extensions_need_update']))
3525	$update->check_extensions();
3526	else
3527	$update->check_updated_extensions();
3528
3529	if (!is_array($_SESSION['extensions_need_update']))
3530	$result['ext_need_update'] = null;
3531	else
3532	$result['ext_need_update'] = !empty($_SESSION['extensions_need_update']);
3533
3534	return $result;
3535	}
3536	?>

Note: See TracBrowser for help on using the browser.

Context Navigation

root/branches/2.3/include/ws_functions.inc.php @ 12750

Download in other formats: