source: branches/2.2/include/ws_functions.inc.php @ 11152

Last change on this file since 11152 was 11152, checked in by plg, 10 years ago

feature 1622 added: pwg.categories.getList is now able to return a tree with
the new "tree_output" option. Only compatible with json/php output formats.

  • Property svn:eol-style set to LF
File size: 64.3 KB
Line 
1<?php
2// +-----------------------------------------------------------------------+
3// | Piwigo - a PHP based photo gallery                                    |
4// +-----------------------------------------------------------------------+
5// | Copyright(C) 2008-2011 Piwigo Team                  http://piwigo.org |
6// | Copyright(C) 2003-2008 PhpWebGallery Team    http://phpwebgallery.net |
7// | Copyright(C) 2002-2003 Pierrick LE GALL   http://le-gall.net/pierrick |
8// +-----------------------------------------------------------------------+
9// | This program is free software; you can redistribute it and/or modify  |
10// | it under the terms of the GNU General Public License as published by  |
11// | the Free Software Foundation                                          |
12// |                                                                       |
13// | This program is distributed in the hope that it will be useful, but   |
14// | WITHOUT ANY WARRANTY; without even the implied warranty of            |
15// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      |
16// | General Public License for more details.                              |
17// |                                                                       |
18// | You should have received a copy of the GNU General Public License     |
19// | along with this program; if not, write to the Free Software           |
20// | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
21// | USA.                                                                  |
22// +-----------------------------------------------------------------------+
23
24/**** IMPLEMENTATION OF WEB SERVICE METHODS ***********************************/
25
26/**
27 * Event handler for method invocation security check. Should return a PwgError
28 * if the preconditions are not satifsied for method invocation.
29 */
30function 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 */
52function ws_std_image_sql_filter( $params, $tbl_name='' )
53{
54  $clauses = array();
55  if ( is_numeric($params['f_min_rate']) )
56  {
57    $clauses[] = $tbl_name.'average_rate>'.$params['f_min_rate'];
58  }
59  if ( is_numeric($params['f_max_rate']) )
60  {
61    $clauses[] = $tbl_name.'average_rate<='.$params['f_max_rate'];
62  }
63  if ( is_numeric($params['f_min_hit']) )
64  {
65    $clauses[] = $tbl_name.'hit>'.$params['f_min_hit'];
66  }
67  if ( is_numeric($params['f_max_hit']) )
68  {
69    $clauses[] = $tbl_name.'hit<='.$params['f_max_hit'];
70  }
71  if ( isset($params['f_min_date_available']) )
72  {
73    $clauses[] = $tbl_name."date_available>='".$params['f_min_date_available']."'";
74  }
75  if ( isset($params['f_max_date_available']) )
76  {
77    $clauses[] = $tbl_name."date_available<'".$params['f_max_date_available']."'";
78  }
79  if ( isset($params['f_min_date_created']) )
80  {
81    $clauses[] = $tbl_name."date_creation>='".$params['f_min_date_created']."'";
82  }
83  if ( isset($params['f_max_date_created']) )
84  {
85    $clauses[] = $tbl_name."date_creation<'".$params['f_max_date_created']."'";
86  }
87  if ( is_numeric($params['f_min_ratio']) )
88  {
89    $clauses[] = $tbl_name.'width/'.$tbl_name.'height>'.$params['f_min_ratio'];
90  }
91  if ( is_numeric($params['f_max_ratio']) )
92  {
93    $clauses[] = $tbl_name.'width/'.$tbl_name.'height<='.$params['f_max_ratio'];
94  }
95  if ( $params['f_with_thumbnail'] )
96  {
97    $clauses[] = $tbl_name.'tn_ext IS NOT NULL';
98  }
99  return $clauses;
100}
101
102/**
103 * returns a "standard" (for our web service) ORDER BY sql clause for images
104 */
105function ws_std_image_sql_order( $params, $tbl_name='' )
106{
107  $ret = '';
108  if ( empty($params['order']) )
109  {
110    return $ret;
111  }
112  $matches = array();
113  preg_match_all('/([a-z_]+) *(?:(asc|desc)(?:ending)?)? *(?:, *|$)/i',
114    $params['order'], $matches);
115  for ($i=0; $i<count($matches[1]); $i++)
116  {
117    switch ($matches[1][$i])
118    {
119      case 'date_created':
120        $matches[1][$i] = 'date_creation'; break;
121      case 'date_posted':
122        $matches[1][$i] = 'date_available'; break;
123      case 'rand': case 'random':
124        $matches[1][$i] = DB_RANDOM_FUNCTION.'()'; break;
125    }
126    $sortable_fields = array('id', 'file', 'name', 'hit', 'average_rate',
127      'date_creation', 'date_available', DB_RANDOM_FUNCTION.'()' );
128    if ( in_array($matches[1][$i], $sortable_fields) )
129    {
130      if (!empty($ret))
131        $ret .= ', ';
132      if ($matches[1][$i] != DB_RANDOM_FUNCTION.'()' )
133      {
134        $ret .= $tbl_name;
135      }
136      $ret .= $matches[1][$i];
137      $ret .= ' '.$matches[2][$i];
138    }
139  }
140  return $ret;
141}
142
143/**
144 * returns an array map of urls (thumb/element) for image_row - to be returned
145 * in a standard way by different web service methods
146 */
147function 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 */
165function 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 */
175function 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 */
187function 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
251function 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 = '
264SELECT 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 */
284function 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 = '
320SELECT 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 = '
355SELECT 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).'
360GROUP BY i.id
361'.$order_by.'
362LIMIT '.(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 */
431function 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 = '
490SELECT id, name, permalink, uppercats, global_rank, id_uppercat,
491    comment,
492    nb_images, count_images AS total_nb_images,
493    date_last, max_date_last, count_categories AS nb_categories
494  FROM '.CATEGORIES_TABLE.'
495   '.$join_type.' JOIN '.USER_CACHE_CATEGORIES_TABLE.' ON id=cat_id AND user_id='.$join_user.'
496  WHERE '. implode('
497    AND ', $where);
498
499  $result = pwg_query($query);
500
501  $cats = array();
502  while ($row = pwg_db_fetch_assoc($result))
503  {
504    $row['url'] = make_index_url(
505        array(
506          'category' => $row
507          )
508      );
509    foreach( array('id','nb_images','total_nb_images','nb_categories') as $key)
510    {
511      $row[$key] = (int)$row[$key];
512    }
513
514    $row['name'] = strip_tags(
515      trigger_event(
516        'render_category_name',
517        $row['name'],
518        'ws_categories_getList'
519        )
520      );
521   
522    $row['comment'] = strip_tags(
523      trigger_event(
524        'render_category_description',
525        $row['comment'],
526        'ws_categories_getList'
527        )
528      );
529   
530    array_push($cats, $row);
531  }
532  usort($cats, 'global_rank_compare');
533
534  if ($params['tree_output'])
535  { 
536    return categories_flatlist_to_tree($cats);
537  }
538  else
539  {
540    return array(
541      'categories' => new PwgNamedArray(
542        $cats,
543        'category',
544        array(
545          'id',
546          'url',
547          'nb_images',
548          'total_nb_images',
549          'nb_categories',
550          'date_last',
551          'max_date_last',
552          )
553        )
554      );
555  }
556}
557
558/**
559 * returns the list of categories as you can see them in administration (web
560 * service method).
561 *
562 * Only admin can run this method and permissions are not taken into
563 * account.
564 */
565function ws_categories_getAdminList($params, &$service)
566{
567  if (!is_admin())
568  {
569    return new PwgError(401, 'Access denied');
570  }
571
572  $query = '
573SELECT
574    category_id,
575    COUNT(*) AS counter
576  FROM '.IMAGE_CATEGORY_TABLE.'
577  GROUP BY category_id
578;';
579  $nb_images_of = simple_hash_from_query($query, 'category_id', 'counter');
580
581  $query = '
582SELECT
583    id,
584    name,
585    comment,
586    uppercats,
587    global_rank
588  FROM '.CATEGORIES_TABLE.'
589;';
590  $result = pwg_query($query);
591  $cats = array();
592
593  while ($row = pwg_db_fetch_assoc($result))
594  {
595    $id = $row['id'];
596    $row['nb_images'] = isset($nb_images_of[$id]) ? $nb_images_of[$id] : 0;
597    $row['name'] = strip_tags(
598      trigger_event(
599        'render_category_name',
600        $row['name'],
601        'ws_categories_getAdminList'
602        )
603      );
604    $row['comment'] = strip_tags(
605      trigger_event(
606        'render_category_description',
607        $row['comment'],
608        'ws_categories_getAdminList'
609        )
610      );
611    array_push($cats, $row);
612  }
613
614  usort($cats, 'global_rank_compare');
615  return array(
616    'categories' => new PwgNamedArray(
617      $cats,
618      'category',
619      array(
620        'id',
621        'nb_images',
622        'name',
623        'uppercats',
624        'global_rank',
625        )
626      )
627    );
628}
629
630/**
631 * returns detailed information for an element (web service method)
632 */
633function ws_images_addComment($params, &$service)
634{
635  if (!$service->isPost())
636  {
637    return new PwgError(405, "This method requires HTTP POST");
638  }
639  $params['image_id'] = (int)$params['image_id'];
640  $query = '
641SELECT DISTINCT image_id
642  FROM '.IMAGE_CATEGORY_TABLE.' INNER JOIN '.CATEGORIES_TABLE.' ON category_id=id
643  WHERE commentable="true"
644    AND image_id='.$params['image_id'].
645    get_sql_condition_FandF(
646      array(
647        'forbidden_categories' => 'id',
648        'visible_categories' => 'id',
649        'visible_images' => 'image_id'
650      ),
651      ' AND'
652    );
653  if ( !pwg_db_num_rows( pwg_query( $query ) ) )
654  {
655    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
656  }
657
658  $comm = array(
659    'author' => trim( $params['author'] ),
660    'content' => trim( $params['content'] ),
661    'image_id' => $params['image_id'],
662   );
663
664  include_once(PHPWG_ROOT_PATH.'include/functions_comment.inc.php');
665
666  $comment_action = insert_user_comment(
667      $comm, $params['key'], $infos
668    );
669
670  switch ($comment_action)
671  {
672    case 'reject':
673      array_push($infos, l10n('Your comment has NOT been registered because it did not pass the validation rules') );
674      return new PwgError(403, implode("; ", $infos) );
675    case 'validate':
676    case 'moderate':
677      $ret = array(
678          'id' => $comm['id'],
679          'validation' => $comment_action=='validate',
680        );
681      return new PwgNamedStruct(
682          'comment',
683          $ret,
684          null, array()
685        );
686    default:
687      return new PwgError(500, "Unknown comment action ".$comment_action );
688  }
689}
690
691/**
692 * returns detailed information for an element (web service method)
693 */
694function ws_images_getInfo($params, &$service)
695{
696  @include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
697  global $user, $conf;
698  $params['image_id'] = (int)$params['image_id'];
699  if ( $params['image_id']<=0 )
700  {
701    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
702  }
703
704  $query='
705SELECT * FROM '.IMAGES_TABLE.'
706  WHERE id='.$params['image_id'].
707    get_sql_condition_FandF(
708      array('visible_images' => 'id'),
709      ' AND'
710    ).'
711LIMIT 1';
712
713  $image_row = pwg_db_fetch_assoc(pwg_query($query));
714  if ($image_row==null)
715  {
716    return new PwgError(404, "image_id not found");
717  }
718  $image_row = array_merge( $image_row, ws_std_get_urls($image_row) );
719
720  //-------------------------------------------------------- related categories
721  $query = '
722SELECT id, name, permalink, uppercats, global_rank, commentable
723  FROM '.IMAGE_CATEGORY_TABLE.'
724    INNER JOIN '.CATEGORIES_TABLE.' ON category_id = id
725  WHERE image_id = '.$image_row['id'].
726  get_sql_condition_FandF(
727      array( 'forbidden_categories' => 'category_id' ),
728      ' AND'
729    ).'
730;';
731  $result = pwg_query($query);
732  $is_commentable = false;
733  $related_categories = array();
734  while ($row = pwg_db_fetch_assoc($result))
735  {
736    if ($row['commentable']=='true')
737    {
738      $is_commentable = true;
739    }
740    unset($row['commentable']);
741    $row['url'] = make_index_url(
742        array(
743          'category' => $row
744          )
745      );
746
747    $row['page_url'] = make_picture_url(
748        array(
749          'image_id' => $image_row['id'],
750          'image_file' => $image_row['file'],
751          'category' => $row
752          )
753      );
754    $row['id']=(int)$row['id'];
755    array_push($related_categories, $row);
756  }
757  usort($related_categories, 'global_rank_compare');
758  if ( empty($related_categories) )
759  {
760    return new PwgError(401, 'Access denied');
761  }
762
763  //-------------------------------------------------------------- related tags
764  $related_tags = get_common_tags( array($image_row['id']), -1 );
765  foreach( $related_tags as $i=>$tag)
766  {
767    $tag['url'] = make_index_url(
768        array(
769          'tags' => array($tag)
770          )
771      );
772    $tag['page_url'] = make_picture_url(
773        array(
774          'image_id' => $image_row['id'],
775          'image_file' => $image_row['file'],
776          'tags' => array($tag),
777          )
778      );
779    unset($tag['counter']);
780    $tag['id']=(int)$tag['id'];
781    $related_tags[$i]=$tag;
782  }
783  //------------------------------------------------------------- related rates
784  $query = '
785SELECT COUNT(rate) AS count
786     , ROUND(AVG(rate),2) AS average
787  FROM '.RATE_TABLE.'
788  WHERE element_id = '.$image_row['id'].'
789;';
790  $rating = pwg_db_fetch_assoc(pwg_query($query));
791  $rating['count'] = (int)$rating['count'];
792
793  //---------------------------------------------------------- related comments
794  $related_comments = array();
795
796  $where_comments = 'image_id = '.$image_row['id'];
797  if ( !is_admin() )
798  {
799    $where_comments .= '
800    AND validated="true"';
801  }
802
803  $query = '
804SELECT COUNT(id) AS nb_comments
805  FROM '.COMMENTS_TABLE.'
806  WHERE '.$where_comments;
807  list($nb_comments) = array_from_query($query, 'nb_comments');
808  $nb_comments = (int)$nb_comments;
809
810  if ( $nb_comments>0 and $params['comments_per_page']>0 )
811  {
812    $query = '
813SELECT id, date, author, content
814  FROM '.COMMENTS_TABLE.'
815  WHERE '.$where_comments.'
816  ORDER BY date
817  LIMIT '.(int)$params['comments_per_page'].
818    ' OFFSET '.(int)($params['comments_per_page']*$params['comments_page']);
819
820    $result = pwg_query($query);
821    while ($row = pwg_db_fetch_assoc($result))
822    {
823      $row['id']=(int)$row['id'];
824      array_push($related_comments, $row);
825    }
826  }
827
828  $comment_post_data = null;
829  if ($is_commentable and
830      (!is_a_guest()
831        or (is_a_guest() and $conf['comments_forall'] )
832      )
833      )
834  {
835    $comment_post_data['author'] = stripslashes($user['username']);
836    $comment_post_data['key'] = get_ephemeral_key(2, $params['image_id']);
837  }
838
839  $ret = $image_row;
840  foreach ( array('id','width','height','hit','filesize') as $k )
841  {
842    if (isset($ret[$k]))
843    {
844      $ret[$k] = (int)$ret[$k];
845    }
846  }
847  foreach ( array('path', 'storage_category_id') as $k )
848  {
849    unset($ret[$k]);
850  }
851
852  $ret['rates'] = array( WS_XML_ATTRIBUTES => $rating );
853  $ret['categories'] = new PwgNamedArray($related_categories, 'category', array('id','url', 'page_url') );
854  $ret['tags'] = new PwgNamedArray($related_tags, 'tag', array('id','url_name','url','name','page_url') );
855  if ( isset($comment_post_data) )
856  {
857    $ret['comment_post'] = array( WS_XML_ATTRIBUTES => $comment_post_data );
858  }
859  $ret['comments'] = array(
860     WS_XML_ATTRIBUTES =>
861        array(
862          'page' => $params['comments_page'],
863          'per_page' => $params['comments_per_page'],
864          'count' => count($related_comments),
865          'nb_comments' => $nb_comments,
866        ),
867     WS_XML_CONTENT => new PwgNamedArray($related_comments, 'comment', array('id','date') )
868      );
869
870  return new PwgNamedStruct('image',$ret, null, array('name','comment') );
871}
872
873
874/**
875 * rates the image_id in the parameter
876 */
877function ws_images_Rate($params, &$service)
878{
879  $image_id = (int)$params['image_id'];
880  $query = '
881SELECT DISTINCT id FROM '.IMAGES_TABLE.'
882  INNER JOIN '.IMAGE_CATEGORY_TABLE.' ON id=image_id
883  WHERE id='.$image_id
884  .get_sql_condition_FandF(
885    array(
886        'forbidden_categories' => 'category_id',
887        'forbidden_images' => 'id',
888      ),
889    '    AND'
890    ).'
891    LIMIT 1';
892  if ( pwg_db_num_rows( pwg_query($query) )==0 )
893  {
894    return new PwgError(404, "Invalid image_id or access denied" );
895  }
896  $rate = (int)$params['rate'];
897  include_once(PHPWG_ROOT_PATH.'include/functions_rate.inc.php');
898  $res = rate_picture( $image_id, $rate );
899  if ($res==false)
900  {
901    global $conf;
902    return new PwgError( 403, "Forbidden or rate not in ". implode(',',$conf['rate_items']));
903  }
904  return $res;
905}
906
907
908/**
909 * returns a list of elements corresponding to a query search
910 */
911function ws_images_search($params, &$service)
912{
913  global $page;
914  $images = array();
915  include_once( PHPWG_ROOT_PATH .'include/functions_search.inc.php' );
916  include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
917
918  $where_clauses = ws_std_image_sql_filter( $params, 'i.' );
919  $order_by = ws_std_image_sql_order($params, 'i.');
920
921  $super_order_by = false;
922  if ( !empty($order_by) )
923  {
924    global $conf;
925    $conf['order_by'] = 'ORDER BY '.$order_by;
926    $super_order_by=true; // quick_search_result might be faster
927  }
928
929  $search_result = get_quick_search_results($params['query'],
930      $super_order_by,
931      implode(',', $where_clauses)
932    );
933
934  $image_ids = array_slice(
935      $search_result['items'],
936      $params['page']*$params['per_page'],
937      $params['per_page']
938    );
939
940  if ( count($image_ids) )
941  {
942    $query = '
943SELECT * FROM '.IMAGES_TABLE.'
944  WHERE id IN ('.implode(',', $image_ids).')';
945
946    $image_ids = array_flip($image_ids);
947    $result = pwg_query($query);
948    while ($row = pwg_db_fetch_assoc($result))
949    {
950      $image = array();
951      foreach ( array('id', 'width', 'height', 'hit') as $k )
952      {
953        if (isset($row[$k]))
954        {
955          $image[$k] = (int)$row[$k];
956        }
957      }
958      foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
959      {
960        $image[$k] = $row[$k];
961      }
962      $image = array_merge( $image, ws_std_get_urls($row) );
963      $images[$image_ids[$image['id']]] = $image;
964    }
965    ksort($images, SORT_NUMERIC);
966    $images = array_values($images);
967  }
968
969
970  return array( 'images' =>
971    array (
972      WS_XML_ATTRIBUTES =>
973        array(
974            'page' => $params['page'],
975            'per_page' => $params['per_page'],
976            'count' => count($images)
977          ),
978       WS_XML_CONTENT => new PwgNamedArray($images, 'image',
979          ws_std_get_image_xml_attributes() )
980      )
981    );
982}
983
984function ws_images_setPrivacyLevel($params, &$service)
985{
986  if (!is_admin())
987  {
988    return new PwgError(401, 'Access denied');
989  }
990  if (!$service->isPost())
991  {
992    return new PwgError(405, "This method requires HTTP POST");
993  }
994  $params['image_id'] = array_map( 'intval',$params['image_id'] );
995  if ( empty($params['image_id']) )
996  {
997    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
998  }
999  global $conf;
1000  if ( !in_array( (int)$params['level'], $conf['available_permission_levels']) )
1001  {
1002    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid level");
1003  }
1004
1005  $query = '
1006UPDATE '.IMAGES_TABLE.'
1007  SET level='.(int)$params['level'].'
1008  WHERE id IN ('.implode(',',$params['image_id']).')';
1009  $result = pwg_query($query);
1010  $affected_rows = pwg_db_changes($result);
1011  if ($affected_rows)
1012  {
1013    include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1014    invalidate_user_cache();
1015  }
1016  return $affected_rows;
1017}
1018
1019function ws_images_add_chunk($params, &$service)
1020{
1021  global $conf;
1022 
1023  ws_logfile('[ws_images_add_chunk] welcome');
1024  // data
1025  // original_sum
1026  // type {thumb, file, high}
1027  // position
1028
1029  if (!is_admin())
1030  {
1031    return new PwgError(401, 'Access denied');
1032  }
1033
1034  if (!$service->isPost())
1035  {
1036    return new PwgError(405, "This method requires HTTP POST");
1037  }
1038
1039  foreach ($params as $param_key => $param_value) {
1040    if ('data' == $param_key) {
1041      continue;
1042    }
1043   
1044    ws_logfile(
1045      sprintf(
1046        '[ws_images_add_chunk] input param "%s" : "%s"',
1047        $param_key,
1048        is_null($param_value) ? 'NULL' : $param_value
1049        )
1050      );
1051  }
1052
1053  $upload_dir = $conf['upload_dir'].'/buffer';
1054
1055  // create the upload directory tree if not exists
1056  if (!is_dir($upload_dir)) {
1057    umask(0000);
1058    $recursive = true;
1059    if (!@mkdir($upload_dir, 0777, $recursive))
1060    {
1061      return new PwgError(500, 'error during buffer directory creation');
1062    }
1063  }
1064
1065  if (!is_writable($upload_dir))
1066  {
1067    // last chance to make the directory writable
1068    @chmod($upload_dir, 0777);
1069
1070    if (!is_writable($upload_dir))
1071    {
1072      return new PwgError(500, 'buffer directory has no write access');
1073    }
1074  }
1075
1076  secure_directory($upload_dir);
1077
1078  $filename = sprintf(
1079    '%s-%s-%05u.block',
1080    $params['original_sum'],
1081    $params['type'],
1082    $params['position']
1083    );
1084
1085  ws_logfile('[ws_images_add_chunk] data length : '.strlen($params['data']));
1086
1087  $bytes_written = file_put_contents(
1088    $upload_dir.'/'.$filename,
1089    base64_decode($params['data'])
1090    );
1091
1092  if (false === $bytes_written) {
1093    return new PwgError(
1094      500,
1095      'an error has occured while writting chunk '.$params['position'].' for '.$params['type']
1096      );
1097  }
1098}
1099
1100function merge_chunks($output_filepath, $original_sum, $type)
1101{
1102  global $conf;
1103 
1104  ws_logfile('[merge_chunks] input parameter $output_filepath : '.$output_filepath);
1105
1106  if (is_file($output_filepath))
1107  {
1108    unlink($output_filepath);
1109
1110    if (is_file($output_filepath))
1111    {
1112      new PwgError(500, '[merge_chunks] error while trying to remove existing '.$output_filepath);
1113      exit();
1114    }
1115  }
1116
1117  $upload_dir = $conf['upload_dir'].'/buffer';
1118  $pattern = '/'.$original_sum.'-'.$type.'/';
1119  $chunks = array();
1120
1121  if ($handle = opendir($upload_dir))
1122  {
1123    while (false !== ($file = readdir($handle)))
1124    {
1125      if (preg_match($pattern, $file))
1126      {
1127        ws_logfile($file);
1128        array_push($chunks, $upload_dir.'/'.$file);
1129      }
1130    }
1131    closedir($handle);
1132  }
1133
1134  sort($chunks);
1135
1136  if (function_exists('memory_get_usage')) {
1137    ws_logfile('[merge_chunks] memory_get_usage before loading chunks: '.memory_get_usage());
1138  }
1139
1140  $i = 0;
1141
1142  foreach ($chunks as $chunk)
1143  {
1144    $string = file_get_contents($chunk);
1145
1146    if (function_exists('memory_get_usage')) {
1147      ws_logfile('[merge_chunks] memory_get_usage on chunk '.++$i.': '.memory_get_usage());
1148    }
1149
1150    if (!file_put_contents($output_filepath, $string, FILE_APPEND))
1151    {
1152      new PwgError(500, '[merge_chunks] error while writting chunks for '.$output_filepath);
1153      exit();
1154    }
1155
1156    unlink($chunk);
1157  }
1158
1159  if (function_exists('memory_get_usage')) {
1160    ws_logfile('[merge_chunks] memory_get_usage after loading chunks: '.memory_get_usage());
1161  }
1162}
1163
1164/*
1165 * The $file_path must be the path of the basic "web sized" photo
1166 * The $type value will automatically modify the $file_path to the corresponding file
1167 */
1168function add_file($file_path, $type, $original_sum, $file_sum)
1169{
1170  include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1171 
1172  $file_path = file_path_for_type($file_path, $type);
1173
1174  $upload_dir = dirname($file_path);
1175  if (substr(PHP_OS, 0, 3) == 'WIN')
1176  {
1177    $upload_dir = str_replace('/', DIRECTORY_SEPARATOR, $upload_dir);
1178  }
1179
1180  ws_logfile('[add_file] file_path  : '.$file_path);
1181  ws_logfile('[add_file] upload_dir : '.$upload_dir);
1182 
1183  if (!is_dir($upload_dir)) {
1184    umask(0000);
1185    $recursive = true;
1186    if (!@mkdir($upload_dir, 0777, $recursive))
1187    {
1188      new PwgError(500, '[add_file] error during '.$type.' directory creation');
1189      exit();
1190    }
1191  }
1192
1193  if (!is_writable($upload_dir))
1194  {
1195    // last chance to make the directory writable
1196    @chmod($upload_dir, 0777);
1197
1198    if (!is_writable($upload_dir))
1199    {
1200      new PwgError(500, '[add_file] '.$type.' directory has no write access');
1201      exit();
1202    }
1203  }
1204
1205  secure_directory($upload_dir);
1206
1207  // merge the thumbnail
1208  merge_chunks($file_path, $original_sum, $type);
1209  chmod($file_path, 0644);
1210
1211  // check dumped thumbnail md5
1212  $dumped_md5 = md5_file($file_path);
1213  if ($dumped_md5 != $file_sum) {
1214    new PwgError(500, '[add_file] '.$type.' transfer failed');
1215    exit();
1216  }
1217
1218  list($width, $height) = getimagesize($file_path);
1219  $filesize = floor(filesize($file_path)/1024);
1220
1221  return array(
1222    'width' => $width,
1223    'height' => $height,
1224    'filesize' => $filesize,
1225    );
1226}
1227
1228function ws_images_addFile($params, &$service)
1229{
1230  // image_id
1231  // type {thumb, file, high}
1232  // sum
1233
1234  global $conf;
1235  if (!is_admin())
1236  {
1237    return new PwgError(401, 'Access denied');
1238  }
1239
1240  $params['image_id'] = (int)$params['image_id'];
1241  if ($params['image_id'] <= 0)
1242  {
1243    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1244  }
1245
1246  //
1247  // what is the path?
1248  //
1249  $query = '
1250SELECT
1251    path,
1252    md5sum
1253  FROM '.IMAGES_TABLE.'
1254  WHERE id = '.$params['image_id'].'
1255;';
1256  list($file_path, $original_sum) = pwg_db_fetch_row(pwg_query($query));
1257
1258  // TODO only files added with web API can be updated with web API
1259
1260  //
1261  // makes sure directories are there and call the merge_chunks
1262  //
1263  $infos = add_file($file_path, $params['type'], $original_sum, $params['sum']);
1264
1265  //
1266  // update basic metadata from file
1267  //
1268  $update = array();
1269
1270  if ('high' == $params['type'])
1271  {
1272    $update['high_filesize'] = $infos['filesize'];
1273    $update['has_high'] = 'true';
1274  }
1275
1276  if ('file' == $params['type'])
1277  {
1278    $update['filesize'] = $infos['filesize'];
1279    $update['width'] = $infos['width'];
1280    $update['height'] = $infos['height'];
1281  }
1282
1283  // we may have nothing to update at database level, for example with a
1284  // thumbnail update
1285  if (count($update) > 0)
1286  {
1287    $update['id'] = $params['image_id'];
1288
1289    include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1290    mass_updates(
1291      IMAGES_TABLE,
1292      array(
1293        'primary' => array('id'),
1294        'update'  => array_diff(array_keys($update), array('id'))
1295        ),
1296      array($update)
1297      );
1298  }
1299}
1300
1301function ws_images_add($params, &$service)
1302{
1303  global $conf, $user;
1304  if (!is_admin())
1305  {
1306    return new PwgError(401, 'Access denied');
1307  }
1308
1309  foreach ($params as $param_key => $param_value) {
1310    ws_logfile(
1311      sprintf(
1312        '[pwg.images.add] input param "%s" : "%s"',
1313        $param_key,
1314        is_null($param_value) ? 'NULL' : $param_value
1315        )
1316      );
1317  }
1318
1319  // does the image already exists ?
1320  if ('md5sum' == $conf['uniqueness_mode'])
1321  {
1322    $where_clause = "md5sum = '".$params['original_sum']."'";
1323  }
1324  if ('filename' == $conf['uniqueness_mode'])
1325  {
1326    $where_clause = "file = '".$params['original_filename']."'";
1327  }
1328 
1329  $query = '
1330SELECT
1331    COUNT(*) AS counter
1332  FROM '.IMAGES_TABLE.'
1333  WHERE '.$where_clause.'
1334;';
1335  list($counter) = pwg_db_fetch_row(pwg_query($query));
1336  if ($counter != 0) {
1337    return new PwgError(500, 'file already exists');
1338  }
1339
1340  // current date
1341  list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
1342  list($year, $month, $day) = preg_split('/[^\d]/', $dbnow, 4);
1343
1344  // upload directory hierarchy
1345  $upload_dir = sprintf(
1346    $conf['upload_dir'].'/%s/%s/%s',
1347    $year,
1348    $month,
1349    $day
1350    );
1351
1352  // compute file path
1353  $date_string = preg_replace('/[^\d]/', '', $dbnow);
1354  $random_string = substr($params['file_sum'], 0, 8);
1355  $filename_wo_ext = $date_string.'-'.$random_string;
1356  $file_path = $upload_dir.'/'.$filename_wo_ext.'.jpg';
1357
1358  // add files
1359  $file_infos  = add_file($file_path, 'file',  $params['original_sum'], $params['file_sum']);
1360  $thumb_infos = add_file($file_path, 'thumb', $params['original_sum'], $params['thumbnail_sum']);
1361
1362  if (isset($params['high_sum']))
1363  {
1364    $high_infos = add_file($file_path, 'high', $params['original_sum'], $params['high_sum']);
1365  }
1366
1367  // database registration
1368  $insert = array(
1369    'file' => !empty($params['original_filename']) ? $params['original_filename'] : $filename_wo_ext.'.jpg',
1370    'date_available' => $dbnow,
1371    'tn_ext' => 'jpg',
1372    'name' => $params['name'],
1373    'path' => $file_path,
1374    'filesize' => $file_infos['filesize'],
1375    'width' => $file_infos['width'],
1376    'height' => $file_infos['height'],
1377    'md5sum' => $params['original_sum'],
1378    'added_by' => $user['id'],
1379    );
1380
1381  $info_columns = array(
1382    'name',
1383    'author',
1384    'comment',
1385    'level',
1386    'date_creation',
1387    );
1388
1389  foreach ($info_columns as $key)
1390  {
1391    if (isset($params[$key]))
1392    {
1393      $insert[$key] = $params[$key];
1394    }
1395  }
1396
1397  if (isset($params['high_sum']))
1398  {
1399    $insert['has_high'] = 'true';
1400    $insert['high_filesize'] = $high_infos['filesize'];
1401  }
1402
1403  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1404  mass_inserts(
1405    IMAGES_TABLE,
1406    array_keys($insert),
1407    array($insert)
1408    );
1409
1410  $image_id = pwg_db_insert_id(IMAGES_TABLE);
1411
1412  // let's add links between the image and the categories
1413  if (isset($params['categories']))
1414  {
1415    ws_add_image_category_relations($image_id, $params['categories']);
1416  }
1417
1418  // and now, let's create tag associations
1419  if (isset($params['tag_ids']) and !empty($params['tag_ids']))
1420  {
1421    set_tags(
1422      explode(',', $params['tag_ids']),
1423      $image_id
1424      );
1425  }
1426
1427  // update metadata from the uploaded file (exif/iptc)
1428  require_once(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
1429  update_metadata(array($image_id=>$file_path));
1430 
1431  invalidate_user_cache();
1432}
1433
1434function ws_images_addSimple($params, &$service)
1435{
1436  global $conf;
1437  if (!is_admin())
1438  {
1439    return new PwgError(401, 'Access denied');
1440  }
1441
1442  if (!$service->isPost())
1443  {
1444    return new PwgError(405, "This method requires HTTP POST");
1445  }
1446
1447  if (!isset($_FILES['image']))
1448  {
1449    return new PwgError(405, "The image (file) parameter is missing");
1450  }
1451 
1452  $params['image_id'] = (int)$params['image_id'];
1453  if ($params['image_id'] > 0)
1454  {
1455    include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1456
1457    $query='
1458SELECT *
1459  FROM '.IMAGES_TABLE.'
1460  WHERE id = '.$params['image_id'].'
1461;';
1462
1463    $image_row = pwg_db_fetch_assoc(pwg_query($query));
1464    if ($image_row == null)
1465    {
1466      return new PwgError(404, "image_id not found");
1467    }
1468  }
1469
1470  // category
1471  $params['category'] = (int)$params['category'];
1472  if ($params['category'] <= 0 and $params['image_id'] <= 0)
1473  {
1474    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
1475  }
1476
1477  include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1478  prepare_upload_configuration();
1479
1480  $image_id = add_uploaded_file(
1481    $_FILES['image']['tmp_name'],
1482    $_FILES['image']['name'],
1483    $params['category'] > 0 ? array($params['category']) : null,
1484    8,
1485    $params['image_id'] > 0 ? $params['image_id'] : null
1486    );
1487
1488  $info_columns = array(
1489    'name',
1490    'author',
1491    'comment',
1492    'level',
1493    'date_creation',
1494    );
1495
1496  foreach ($info_columns as $key)
1497  {
1498    if (isset($params[$key]))
1499    {
1500      $update[$key] = $params[$key];
1501    }
1502  }
1503
1504  if (count(array_keys($update)) > 0)
1505  {
1506    $update['id'] = $image_id;
1507
1508    include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1509    mass_updates(
1510      IMAGES_TABLE,
1511      array(
1512        'primary' => array('id'),
1513        'update'  => array_diff(array_keys($update), array('id'))
1514        ),
1515      array($update)
1516      );
1517  }
1518
1519
1520  if (isset($params['tags']) and !empty($params['tags']))
1521  {
1522    $tag_ids = array();
1523    $tag_names = explode(',', $params['tags']);
1524    foreach ($tag_names as $tag_name)
1525    {
1526      $tag_id = tag_id_from_tag_name($tag_name);
1527      array_push($tag_ids, $tag_id);
1528    }
1529
1530    add_tags($tag_ids, array($image_id));
1531  }
1532
1533  $url_params = array('image_id' => $image_id);
1534
1535  if ($params['category'] > 0)
1536  {
1537    $query = '
1538SELECT id, name, permalink
1539  FROM '.CATEGORIES_TABLE.'
1540  WHERE id = '.$params['category'].'
1541;';
1542    $result = pwg_query($query);
1543    $category = pwg_db_fetch_assoc($result);
1544
1545    $url_params['section'] = 'categories';
1546    $url_params['category'] = $category;
1547  }
1548
1549  // update metadata from the uploaded file (exif/iptc), even if the sync
1550  // was already performed by add_uploaded_file().
1551  $query = '
1552SELECT
1553    path
1554  FROM '.IMAGES_TABLE.'
1555  WHERE id = '.$image_id.'
1556;';
1557  list($file_path) = pwg_db_fetch_row(pwg_query($query));
1558 
1559  require_once(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
1560  update_metadata(array($image_id=>$file_path));
1561
1562  return array(
1563    'image_id' => $image_id,
1564    'url' => make_picture_url($url_params),
1565    );
1566}
1567
1568/**
1569 * perform a login (web service method)
1570 */
1571function ws_session_login($params, &$service)
1572{
1573  global $conf;
1574
1575  if (!$service->isPost())
1576  {
1577    return new PwgError(405, "This method requires HTTP POST");
1578  }
1579  if (try_log_user($params['username'], $params['password'],false))
1580  {
1581    return true;
1582  }
1583  return new PwgError(999, 'Invalid username/password');
1584}
1585
1586
1587/**
1588 * performs a logout (web service method)
1589 */
1590function ws_session_logout($params, &$service)
1591{
1592  if (!is_a_guest())
1593  {
1594    logout_user();
1595  }
1596  return true;
1597}
1598
1599function ws_session_getStatus($params, &$service)
1600{
1601  global $user;
1602  $res = array();
1603  $res['username'] = is_a_guest() ? 'guest' : stripslashes($user['username']);
1604  foreach ( array('status', 'theme', 'language') as $k )
1605  {
1606    $res[$k] = $user[$k];
1607  }
1608  $res['pwg_token'] = get_pwg_token();
1609  $res['charset'] = get_pwg_charset();
1610  return $res;
1611}
1612
1613
1614/**
1615 * returns a list of tags (web service method)
1616 */
1617function ws_tags_getList($params, &$service)
1618{
1619  $tags = get_available_tags();
1620  if ($params['sort_by_counter'])
1621  {
1622    usort($tags, create_function('$a,$b', 'return -$a["counter"]+$b["counter"];') );
1623  }
1624  else
1625  {
1626    usort($tags, 'tag_alpha_compare');
1627  }
1628  for ($i=0; $i<count($tags); $i++)
1629  {
1630    $tags[$i]['id'] = (int)$tags[$i]['id'];
1631    $tags[$i]['counter'] = (int)$tags[$i]['counter'];
1632    $tags[$i]['url'] = make_index_url(
1633        array(
1634          'section'=>'tags',
1635          'tags'=>array($tags[$i])
1636        )
1637      );
1638  }
1639  return array('tags' => new PwgNamedArray($tags, 'tag', array('id','url_name','url', 'name', 'counter' )) );
1640}
1641
1642/**
1643 * returns the list of tags as you can see them in administration (web
1644 * service method).
1645 *
1646 * Only admin can run this method and permissions are not taken into
1647 * account.
1648 */
1649function ws_tags_getAdminList($params, &$service)
1650{
1651  if (!is_admin())
1652  {
1653    return new PwgError(401, 'Access denied');
1654  }
1655
1656  $tags = get_all_tags();
1657  return array(
1658    'tags' => new PwgNamedArray(
1659      $tags,
1660      'tag',
1661      array(
1662        'name',
1663        'id',
1664        'url_name',
1665        )
1666      )
1667    );
1668}
1669
1670/**
1671 * returns a list of images for tags (web service method)
1672 */
1673function ws_tags_getImages($params, &$service)
1674{
1675  @include_once(PHPWG_ROOT_PATH.'include/functions_picture.inc.php');
1676  global $conf;
1677
1678  // first build all the tag_ids we are interested in
1679  $params['tag_id'] = array_map( 'intval',$params['tag_id'] );
1680  $tags = find_tags($params['tag_id'], $params['tag_url_name'], $params['tag_name']);
1681  $tags_by_id = array();
1682  foreach( $tags as $tag )
1683  {
1684    $tags['id'] = (int)$tag['id'];
1685    $tags_by_id[ $tag['id'] ] = $tag;
1686  }
1687  unset($tags);
1688  $tag_ids = array_keys($tags_by_id);
1689
1690
1691  $where_clauses = ws_std_image_sql_filter($params);
1692  if (!empty($where_clauses))
1693  {
1694    $where_clauses = implode( ' AND ', $where_clauses);
1695  }
1696  $image_ids = get_image_ids_for_tags(
1697    $tag_ids,
1698    $params['tag_mode_and'] ? 'AND' : 'OR',
1699    $where_clauses,
1700    ws_std_image_sql_order($params) );
1701
1702
1703  $image_ids = array_slice($image_ids, (int)($params['per_page']*$params['page']), (int)$params['per_page'] );
1704 
1705  $image_tag_map = array();
1706  if ( !empty($image_ids) and !$params['tag_mode_and'] )
1707  { // build list of image ids with associated tags per image
1708    $query = '
1709SELECT image_id, GROUP_CONCAT(tag_id) AS tag_ids
1710  FROM '.IMAGE_TAG_TABLE.'
1711  WHERE tag_id IN ('.implode(',',$tag_ids).') AND image_id IN ('.implode(',',$image_ids).')
1712  GROUP BY image_id';
1713    $result = pwg_query($query);
1714    while ( $row=pwg_db_fetch_assoc($result) )
1715    {
1716      $row['image_id'] = (int)$row['image_id'];
1717      array_push( $image_ids, $row['image_id'] );
1718      $image_tag_map[ $row['image_id'] ] = explode(',', $row['tag_ids']);
1719    }
1720  }
1721
1722  $images = array();
1723  if (!empty($image_ids))
1724  {
1725    $rank_of = array_flip($image_ids);
1726    $result = pwg_query('
1727SELECT * FROM '.IMAGES_TABLE.'
1728  WHERE id IN ('.implode(',',$image_ids).')');
1729    while ($row = pwg_db_fetch_assoc($result))
1730    {
1731      $image = array();
1732      $image['rank'] = $rank_of[ $row['id'] ];
1733      foreach ( array('id', 'width', 'height', 'hit') as $k )
1734      {
1735        if (isset($row[$k]))
1736        {
1737          $image[$k] = (int)$row[$k];
1738        }
1739      }
1740      foreach ( array('file', 'name', 'comment', 'date_creation', 'date_available') as $k )
1741      {
1742        $image[$k] = $row[$k];
1743      }
1744      $image = array_merge( $image, ws_std_get_urls($row) );
1745
1746      $image_tag_ids = ($params['tag_mode_and']) ? $tag_ids : $image_tag_map[$image['id']];
1747      $image_tags = array();
1748      foreach ($image_tag_ids as $tag_id)
1749      {
1750        $url = make_index_url(
1751                 array(
1752                  'section'=>'tags',
1753                  'tags'=> array($tags_by_id[$tag_id])
1754                )
1755              );
1756        $page_url = make_picture_url(
1757                 array(
1758                  'section'=>'tags',
1759                  'tags'=> array($tags_by_id[$tag_id]),
1760                  'image_id' => $row['id'],
1761                  'image_file' => $row['file'],
1762                )
1763              );
1764        array_push($image_tags, array(
1765                'id' => (int)$tag_id,
1766                'url' => $url,
1767                'page_url' => $page_url,
1768              )
1769            );
1770      }
1771      $image['tags'] = new PwgNamedArray($image_tags, 'tag',
1772              array('id','url_name','url','page_url')
1773            );
1774      array_push($images, $image);
1775    }
1776    usort($images, 'rank_compare');
1777    unset($rank_of);
1778  }
1779
1780  return array( 'images' =>
1781    array (
1782      WS_XML_ATTRIBUTES =>
1783        array(
1784            'page' => $params['page'],
1785            'per_page' => $params['per_page'],
1786            'count' => count($images)
1787          ),
1788       WS_XML_CONTENT => new PwgNamedArray($images, 'image',
1789          ws_std_get_image_xml_attributes() )
1790      )
1791    );
1792}
1793
1794function ws_categories_add($params, &$service)
1795{
1796  if (!is_admin())
1797  {
1798    return new PwgError(401, 'Access denied');
1799  }
1800
1801  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1802
1803  $creation_output = create_virtual_category(
1804    $params['name'],
1805    $params['parent']
1806    );
1807
1808  if (isset($creation_output['error']))
1809  {
1810    return new PwgError(500, $creation_output['error']);
1811  }
1812
1813  invalidate_user_cache();
1814
1815  return $creation_output;
1816}
1817
1818function ws_tags_add($params, &$service)
1819{
1820  if (!is_admin())
1821  {
1822    return new PwgError(401, 'Access denied');
1823  }
1824
1825  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1826
1827  $creation_output = create_tag($params['name']);
1828
1829  if (isset($creation_output['error']))
1830  {
1831    return new PwgError(500, $creation_output['error']);
1832  }
1833
1834  return $creation_output;
1835}
1836
1837function ws_images_exist($params, &$service)
1838{
1839  global $conf;
1840 
1841  if (!is_admin())
1842  {
1843    return new PwgError(401, 'Access denied');
1844  }
1845
1846  $split_pattern = '/[\s,;\|]/';
1847
1848  if ('md5sum' == $conf['uniqueness_mode'])
1849  {
1850    // search among photos the list of photos already added, based on md5sum
1851    // list
1852    $md5sums = preg_split(
1853      $split_pattern,
1854      $params['md5sum_list'],
1855      -1,
1856      PREG_SPLIT_NO_EMPTY
1857    );
1858
1859    $query = '
1860SELECT
1861    id,
1862    md5sum
1863  FROM '.IMAGES_TABLE.'
1864  WHERE md5sum IN (\''.implode("','", $md5sums).'\')
1865;';
1866    $id_of_md5 = simple_hash_from_query($query, 'md5sum', 'id');
1867
1868    $result = array();
1869
1870    foreach ($md5sums as $md5sum)
1871    {
1872      $result[$md5sum] = null;
1873      if (isset($id_of_md5[$md5sum]))
1874      {
1875        $result[$md5sum] = $id_of_md5[$md5sum];
1876      }
1877    }
1878  }
1879 
1880  if ('filename' == $conf['uniqueness_mode'])
1881  {
1882    // search among photos the list of photos already added, based on
1883    // filename list
1884    $filenames = preg_split(
1885      $split_pattern,
1886      $params['filename_list'],
1887      -1,
1888      PREG_SPLIT_NO_EMPTY
1889    );
1890
1891    $query = '
1892SELECT
1893    id,
1894    file
1895  FROM '.IMAGES_TABLE.'
1896  WHERE file IN (\''.implode("','", $filenames).'\')
1897;';
1898    $id_of_filename = simple_hash_from_query($query, 'file', 'id');
1899
1900    $result = array();
1901
1902    foreach ($filenames as $filename)
1903    {
1904      $result[$filename] = null;
1905      if (isset($id_of_filename[$filename]))
1906      {
1907        $result[$filename] = $id_of_filename[$filename];
1908      }
1909    }
1910  }
1911
1912  return $result;
1913}
1914
1915function ws_images_checkFiles($params, &$service)
1916{
1917  if (!is_admin())
1918  {
1919    return new PwgError(401, 'Access denied');
1920  }
1921
1922  // input parameters
1923  //
1924  // image_id
1925  // thumbnail_sum
1926  // file_sum
1927  // high_sum
1928
1929  $params['image_id'] = (int)$params['image_id'];
1930  if ($params['image_id'] <= 0)
1931  {
1932    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1933  }
1934
1935  $query = '
1936SELECT
1937    path
1938  FROM '.IMAGES_TABLE.'
1939  WHERE id = '.$params['image_id'].'
1940;';
1941  $result = pwg_query($query);
1942  if (pwg_db_num_rows($result) == 0) {
1943    return new PwgError(404, "image_id not found");
1944  }
1945  list($path) = pwg_db_fetch_row($result);
1946
1947  $ret = array();
1948
1949  foreach (array('thumb', 'file', 'high') as $type) {
1950    $param_name = $type;
1951    if ('thumb' == $type) {
1952      $param_name = 'thumbnail';
1953    }
1954
1955    if (isset($params[$param_name.'_sum'])) {
1956      include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
1957      $type_path = file_path_for_type($path, $type);
1958      if (!is_file($type_path)) {
1959        $ret[$param_name] = 'missing';
1960      }
1961      else {
1962        if (md5_file($type_path) != $params[$param_name.'_sum']) {
1963          $ret[$param_name] = 'differs';
1964        }
1965        else {
1966          $ret[$param_name] = 'equals';
1967        }
1968      }
1969    }
1970  }
1971
1972  return $ret;
1973}
1974
1975function ws_images_setInfo($params, &$service)
1976{
1977  global $conf;
1978  if (!is_admin())
1979  {
1980    return new PwgError(401, 'Access denied');
1981  }
1982
1983  if (!$service->isPost())
1984  {
1985    return new PwgError(405, "This method requires HTTP POST");
1986  }
1987
1988  $params['image_id'] = (int)$params['image_id'];
1989  if ($params['image_id'] <= 0)
1990  {
1991    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid image_id");
1992  }
1993
1994  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
1995
1996  $query='
1997SELECT *
1998  FROM '.IMAGES_TABLE.'
1999  WHERE id = '.$params['image_id'].'
2000;';
2001
2002  $image_row = pwg_db_fetch_assoc(pwg_query($query));
2003  if ($image_row == null)
2004  {
2005    return new PwgError(404, "image_id not found");
2006  }
2007
2008  // database registration
2009  $update = array();
2010
2011  $info_columns = array(
2012    'name',
2013    'author',
2014    'comment',
2015    'level',
2016    'date_creation',
2017    );
2018
2019  foreach ($info_columns as $key)
2020  {
2021    if (isset($params[$key]))
2022    {
2023      if ('fill_if_empty' == $params['single_value_mode'])
2024      {
2025        if (empty($image_row[$key]))
2026        {
2027          $update[$key] = $params[$key];
2028        }
2029      }
2030      elseif ('replace' == $params['single_value_mode'])
2031      {
2032        $update[$key] = $params[$key];
2033      }
2034      else
2035      {
2036        new PwgError(
2037          500,
2038          '[ws_images_setInfo]'
2039          .' invalid parameter single_value_mode "'.$params['single_value_mode'].'"'
2040          .', possible values are {fill_if_empty, replace}.'
2041          );
2042        exit();
2043      }
2044    }
2045  }
2046
2047  if (count(array_keys($update)) > 0)
2048  {
2049    $update['id'] = $params['image_id'];
2050
2051    mass_updates(
2052      IMAGES_TABLE,
2053      array(
2054        'primary' => array('id'),
2055        'update'  => array_diff(array_keys($update), array('id'))
2056        ),
2057      array($update)
2058      );
2059  }
2060
2061  if (isset($params['categories']))
2062  {
2063    ws_add_image_category_relations(
2064      $params['image_id'],
2065      $params['categories'],
2066      ('replace' == $params['multiple_value_mode'] ? true : false)
2067      );
2068  }
2069
2070  // and now, let's create tag associations
2071  if (isset($params['tag_ids']))
2072  {
2073    $tag_ids = explode(',', $params['tag_ids']);
2074
2075    if ('replace' == $params['multiple_value_mode'])
2076    {
2077      set_tags(
2078        $tag_ids,
2079        $params['image_id']
2080        );
2081    }
2082    elseif ('append' == $params['multiple_value_mode'])
2083    {
2084      add_tags(
2085        $tag_ids,
2086        array($params['image_id'])
2087        );
2088    }
2089    else
2090    {
2091      new PwgError(
2092        500,
2093        '[ws_images_setInfo]'
2094        .' invalid parameter multiple_value_mode "'.$params['multiple_value_mode'].'"'
2095        .', possible values are {replace, append}.'
2096        );
2097      exit();
2098    }
2099  }
2100
2101  invalidate_user_cache();
2102}
2103
2104function ws_images_delete($params, &$service)
2105{
2106  global $conf;
2107  if (!is_admin())
2108  {
2109    return new PwgError(401, 'Access denied');
2110  }
2111
2112  if (!$service->isPost())
2113  {
2114    return new PwgError(405, "This method requires HTTP POST");
2115  }
2116
2117  if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2118  {
2119    return new PwgError(403, 'Invalid security token');
2120  }
2121
2122  $params['image_id'] = preg_split(
2123    '/[\s,;\|]/',
2124    $params['image_id'],
2125    -1,
2126    PREG_SPLIT_NO_EMPTY
2127    );
2128  $params['image_id'] = array_map('intval', $params['image_id']);
2129
2130  $image_ids = array();
2131  foreach ($params['image_id'] as $image_id)
2132  {
2133    if ($image_id > 0)
2134    {
2135      array_push($image_ids, $image_id);
2136    }
2137  }
2138
2139  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2140  delete_elements($image_ids, true);
2141}
2142
2143function ws_add_image_category_relations($image_id, $categories_string, $replace_mode=false)
2144{
2145  // let's add links between the image and the categories
2146  //
2147  // $params['categories'] should look like 123,12;456,auto;789 which means:
2148  //
2149  // 1. associate with category 123 on rank 12
2150  // 2. associate with category 456 on automatic rank
2151  // 3. associate with category 789 on automatic rank
2152  $cat_ids = array();
2153  $rank_on_category = array();
2154  $search_current_ranks = false;
2155
2156  $tokens = explode(';', $categories_string);
2157  foreach ($tokens as $token)
2158  {
2159    @list($cat_id, $rank) = explode(',', $token);
2160
2161    if (!preg_match('/^\d+$/', $cat_id))
2162    {
2163      continue;
2164    }
2165
2166    array_push($cat_ids, $cat_id);
2167
2168    if (!isset($rank))
2169    {
2170      $rank = 'auto';
2171    }
2172    $rank_on_category[$cat_id] = $rank;
2173
2174    if ($rank == 'auto')
2175    {
2176      $search_current_ranks = true;
2177    }
2178  }
2179
2180  $cat_ids = array_unique($cat_ids);
2181
2182  if (count($cat_ids) == 0)
2183  {
2184    new PwgError(
2185      500,
2186      '[ws_add_image_category_relations] there is no category defined in "'.$categories_string.'"'
2187      );
2188    exit();
2189  }
2190
2191  $query = '
2192SELECT
2193    id
2194  FROM '.CATEGORIES_TABLE.'
2195  WHERE id IN ('.implode(',', $cat_ids).')
2196;';
2197  $db_cat_ids = array_from_query($query, 'id');
2198
2199  $unknown_cat_ids = array_diff($cat_ids, $db_cat_ids);
2200  if (count($unknown_cat_ids) != 0)
2201  {
2202    new PwgError(
2203      500,
2204      '[ws_add_image_category_relations] the following categories are unknown: '.implode(', ', $unknown_cat_ids)
2205      );
2206    exit();
2207  }
2208
2209  $to_update_cat_ids = array();
2210
2211  // in case of replace mode, we first check the existing associations
2212  $query = '
2213SELECT
2214    category_id
2215  FROM '.IMAGE_CATEGORY_TABLE.'
2216  WHERE image_id = '.$image_id.'
2217;';
2218  $existing_cat_ids = array_from_query($query, 'category_id');
2219
2220  if ($replace_mode)
2221  {
2222    $to_remove_cat_ids = array_diff($existing_cat_ids, $cat_ids);
2223    if (count($to_remove_cat_ids) > 0)
2224    {
2225      $query = '
2226DELETE
2227  FROM '.IMAGE_CATEGORY_TABLE.'
2228  WHERE image_id = '.$image_id.'
2229    AND category_id IN ('.implode(', ', $to_remove_cat_ids).')
2230;';
2231      pwg_query($query);
2232      update_category($to_remove_cat_ids);
2233    }
2234  }
2235
2236  $new_cat_ids = array_diff($cat_ids, $existing_cat_ids);
2237  if (count($new_cat_ids) == 0)
2238  {
2239    return true;
2240  }
2241
2242  if ($search_current_ranks)
2243  {
2244    $query = '
2245SELECT
2246    category_id,
2247    MAX(rank) AS max_rank
2248  FROM '.IMAGE_CATEGORY_TABLE.'
2249  WHERE rank IS NOT NULL
2250    AND category_id IN ('.implode(',', $new_cat_ids).')
2251  GROUP BY category_id
2252;';
2253    $current_rank_of = simple_hash_from_query(
2254      $query,
2255      'category_id',
2256      'max_rank'
2257      );
2258
2259    foreach ($new_cat_ids as $cat_id)
2260    {
2261      if (!isset($current_rank_of[$cat_id]))
2262      {
2263        $current_rank_of[$cat_id] = 0;
2264      }
2265
2266      if ('auto' == $rank_on_category[$cat_id])
2267      {
2268        $rank_on_category[$cat_id] = $current_rank_of[$cat_id] + 1;
2269      }
2270    }
2271  }
2272
2273  $inserts = array();
2274
2275  foreach ($new_cat_ids as $cat_id)
2276  {
2277    array_push(
2278      $inserts,
2279      array(
2280        'image_id' => $image_id,
2281        'category_id' => $cat_id,
2282        'rank' => $rank_on_category[$cat_id],
2283        )
2284      );
2285  }
2286
2287  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2288  mass_inserts(
2289    IMAGE_CATEGORY_TABLE,
2290    array_keys($inserts[0]),
2291    $inserts
2292    );
2293
2294  update_category($new_cat_ids);
2295}
2296
2297function ws_categories_setInfo($params, &$service)
2298{
2299  global $conf;
2300  if (!is_admin())
2301  {
2302    return new PwgError(401, 'Access denied');
2303  }
2304
2305  if (!$service->isPost())
2306  {
2307    return new PwgError(405, "This method requires HTTP POST");
2308  }
2309
2310  // category_id
2311  // name
2312  // comment
2313
2314  $params['category_id'] = (int)$params['category_id'];
2315  if ($params['category_id'] <= 0)
2316  {
2317    return new PwgError(WS_ERR_INVALID_PARAM, "Invalid category_id");
2318  }
2319
2320  // database registration
2321  $update = array(
2322    'id' => $params['category_id'],
2323    );
2324
2325  $info_columns = array(
2326    'name',
2327    'comment',
2328    );
2329
2330  $perform_update = false;
2331  foreach ($info_columns as $key)
2332  {
2333    if (isset($params[$key]))
2334    {
2335      $perform_update = true;
2336      $update[$key] = $params[$key];
2337    }
2338  }
2339
2340  if ($perform_update)
2341  {
2342    include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2343    mass_updates(
2344      CATEGORIES_TABLE,
2345      array(
2346        'primary' => array('id'),
2347        'update'  => array_diff(array_keys($update), array('id'))
2348        ),
2349      array($update)
2350      );
2351  }
2352
2353}
2354
2355function ws_categories_delete($params, &$service)
2356{
2357  global $conf;
2358  if (!is_admin())
2359  {
2360    return new PwgError(401, 'Access denied');
2361  }
2362
2363  if (!$service->isPost())
2364  {
2365    return new PwgError(405, "This method requires HTTP POST");
2366  }
2367
2368  if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2369  {
2370    return new PwgError(403, 'Invalid security token');
2371  }
2372
2373  $modes = array('no_delete', 'delete_orphans', 'force_delete');
2374  if (!in_array($params['photo_deletion_mode'], $modes))
2375  {
2376    return new PwgError(
2377      500,
2378      '[ws_categories_delete]'
2379      .' invalid parameter photo_deletion_mode "'.$params['photo_deletion_mode'].'"'
2380      .', possible values are {'.implode(', ', $modes).'}.'
2381      );
2382  }
2383
2384  $params['category_id'] = preg_split(
2385    '/[\s,;\|]/',
2386    $params['category_id'],
2387    -1,
2388    PREG_SPLIT_NO_EMPTY
2389    );
2390  $params['category_id'] = array_map('intval', $params['category_id']);
2391
2392  $category_ids = array();
2393  foreach ($params['category_id'] as $category_id)
2394  {
2395    if ($category_id > 0)
2396    {
2397      array_push($category_ids, $category_id);
2398    }
2399  }
2400
2401  if (count($category_ids) == 0)
2402  {
2403    return;
2404  }
2405
2406  $query = '
2407SELECT id
2408  FROM '.CATEGORIES_TABLE.'
2409  WHERE id IN ('.implode(',', $category_ids).')
2410;';
2411  $category_ids = array_from_query($query, 'id');
2412
2413  if (count($category_ids) == 0)
2414  {
2415    return;
2416  }
2417 
2418  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2419  delete_categories($category_ids, $params['photo_deletion_mode']);
2420  update_global_rank();
2421}
2422
2423function ws_categories_move($params, &$service)
2424{
2425  global $conf, $page;
2426 
2427  if (!is_admin())
2428  {
2429    return new PwgError(401, 'Access denied');
2430  }
2431
2432  if (!$service->isPost())
2433  {
2434    return new PwgError(405, "This method requires HTTP POST");
2435  }
2436
2437  if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2438  {
2439    return new PwgError(403, 'Invalid security token');
2440  }
2441
2442  $params['category_id'] = preg_split(
2443    '/[\s,;\|]/',
2444    $params['category_id'],
2445    -1,
2446    PREG_SPLIT_NO_EMPTY
2447    );
2448  $params['category_id'] = array_map('intval', $params['category_id']);
2449
2450  $category_ids = array();
2451  foreach ($params['category_id'] as $category_id)
2452  {
2453    if ($category_id > 0)
2454    {
2455      array_push($category_ids, $category_id);
2456    }
2457  }
2458
2459  if (count($category_ids) == 0)
2460  {
2461    return new PwgError(403, 'Invalid category_id input parameter, no category to move');
2462  }
2463
2464  // we can't move physical categories
2465  $categories_in_db = array();
2466 
2467  $query = '
2468SELECT
2469    id,
2470    name,
2471    dir
2472  FROM '.CATEGORIES_TABLE.'
2473  WHERE id IN ('.implode(',', $category_ids).')
2474;';
2475  $result = pwg_query($query);
2476  while ($row = pwg_db_fetch_assoc($result))
2477  {
2478    $categories_in_db[$row['id']] = $row;
2479    // we break on error at first physical category detected
2480    if (!empty($row['dir']))
2481    {
2482      $row['name'] = strip_tags(
2483        trigger_event(
2484          'render_category_name',
2485          $row['name'],
2486          'ws_categories_move'
2487          )
2488        );
2489     
2490      return new PwgError(
2491        403,
2492        sprintf(
2493          'Category %s (%u) is not a virtual category, you cannot move it',
2494          $row['name'],
2495          $row['id']
2496          )
2497        );
2498    }
2499  }
2500
2501  if (count($categories_in_db) != count($category_ids))
2502  {
2503    $unknown_category_ids = array_diff($category_ids, array_keys($categories_in_db));
2504   
2505    return new PwgError(
2506      403,
2507      sprintf(
2508        'Category %u does not exist',
2509        $unknown_category_ids[0]
2510        )
2511      );
2512  }
2513
2514  // does this parent exists? This check should be made in the
2515  // move_categories function, not here
2516  //
2517  // 0 as parent means "move categories at gallery root"
2518  if (!is_numeric($params['parent']))
2519  {
2520    return new PwgError(403, 'Invalid parent input parameter');
2521  }
2522 
2523  if (0 != $params['parent']) {
2524    $params['parent'] = intval($params['parent']);
2525    $subcat_ids = get_subcat_ids(array($params['parent']));
2526    if (count($subcat_ids) == 0)
2527    {
2528      return new PwgError(403, 'Unknown parent category id');
2529    }
2530  }
2531
2532  $page['infos'] = array();
2533  $page['errors'] = array();
2534  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2535  move_categories($category_ids, $params['parent']);
2536  invalidate_user_cache();
2537
2538  if (count($page['errors']) != 0)
2539  {
2540    return new PwgError(403, implode('; ', $page['errors']));
2541  }
2542}
2543
2544function ws_logfile($string)
2545{
2546  global $conf;
2547
2548  if (!$conf['ws_enable_log']) {
2549    return true;
2550  }
2551
2552  file_put_contents(
2553    $conf['ws_log_filepath'],
2554    '['.date('c').'] '.$string."\n",
2555    FILE_APPEND
2556    );
2557}
2558
2559function ws_images_checkUpload($params, &$service)
2560{
2561  global $conf;
2562
2563  if (!is_admin())
2564  {
2565    return new PwgError(401, 'Access denied');
2566  }
2567
2568  include_once(PHPWG_ROOT_PATH.'admin/include/functions_upload.inc.php');
2569  $ret['message'] = ready_for_upload_message();
2570  $ret['ready_for_upload'] = true;
2571 
2572  if (!empty($ret['message']))
2573  {
2574    $ret['ready_for_upload'] = false;
2575  }
2576 
2577  return $ret;
2578}
2579
2580function ws_plugins_getList($params, &$service)
2581{
2582  global $conf;
2583 
2584  if (!is_admin())
2585  {
2586    return new PwgError(401, 'Access denied');
2587  }
2588
2589  include_once(PHPWG_ROOT_PATH.'admin/include/plugins.class.php');
2590  $plugins = new plugins();
2591  $plugins->sort_fs_plugins('name');
2592  $plugin_list = array();
2593
2594  foreach($plugins->fs_plugins as $plugin_id => $fs_plugin)
2595  {
2596    if (isset($plugins->db_plugins_by_id[$plugin_id]))
2597    {
2598      $state = $plugins->db_plugins_by_id[$plugin_id]['state'];
2599    }
2600    else
2601    {
2602      $state = 'uninstalled';
2603    }
2604
2605    array_push(
2606      $plugin_list,
2607      array(
2608        'id' => $plugin_id,
2609        'name' => $fs_plugin['name'],
2610        'version' => $fs_plugin['version'],
2611        'state' => $state,
2612        'description' => $fs_plugin['description'],
2613        )
2614      );
2615  }
2616
2617  return $plugin_list;
2618}
2619
2620function ws_plugins_performAction($params, &$service)
2621{
2622  global $template;
2623 
2624  if (!is_admin())
2625  {
2626    return new PwgError(401, 'Access denied');
2627  }
2628
2629  if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2630  {
2631    return new PwgError(403, 'Invalid security token');
2632  }
2633
2634  define('IN_ADMIN', true);
2635  include_once(PHPWG_ROOT_PATH.'admin/include/plugins.class.php');
2636  $plugins = new plugins();
2637  $errors = $plugins->perform_action($params['action'], $params['plugin']);
2638
2639 
2640  if (!empty($errors))
2641  {
2642    return new PwgError(500, $errors);
2643  }
2644  else
2645  {
2646    if (in_array($params['action'], array('activate', 'deactivate')))
2647    {
2648      $template->delete_compiled_templates();
2649    }
2650    return true;
2651  }
2652}
2653
2654function ws_themes_performAction($params, &$service)
2655{
2656  global $template;
2657 
2658  if (!is_admin())
2659  {
2660    return new PwgError(401, 'Access denied');
2661  }
2662
2663  if (empty($params['pwg_token']) or get_pwg_token() != $params['pwg_token'])
2664  {
2665    return new PwgError(403, 'Invalid security token');
2666  }
2667
2668  define('IN_ADMIN', true);
2669  include_once(PHPWG_ROOT_PATH.'admin/include/themes.class.php');
2670  $themes = new themes();
2671  $errors = $themes->perform_action($params['action'], $params['theme']);
2672 
2673  if (!empty($errors))
2674  {
2675    return new PwgError(500, $errors);
2676  }
2677  else
2678  {
2679    if (in_array($params['action'], array('activate', 'deactivate')))
2680    {
2681      $template->delete_compiled_templates();
2682    }
2683    return true;
2684  }
2685}
2686?>
Note: See TracBrowser for help on using the repository browser.