source: branches/2.5/admin/include/functions.php @ 21566

Revision 21566, 56.5 KB checked in by plg, 7 years ago (diff)

bug 2867 fixed: move get_dirs function to a function file, so that it can be used in plugin LocalFiles Editor (see r18629)

  • Property svn:eol-style set to LF
Line 
1<?php
2// +-----------------------------------------------------------------------+
3// | Piwigo - a PHP based photo gallery                                    |
4// +-----------------------------------------------------------------------+
5// | Copyright(C) 2008-2013 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
24include(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
25
26// The function delete_site deletes a site and call the function
27// delete_categories for each primary category of the site
28function delete_site( $id )
29{
30  // destruction of the categories of the site
31  $query = '
32SELECT id
33  FROM '.CATEGORIES_TABLE.'
34  WHERE site_id = '.$id.'
35;';
36  $category_ids = array_from_query($query, 'id');
37  delete_categories($category_ids);
38
39  // destruction of the site
40  $query = '
41DELETE FROM '.SITES_TABLE.'
42  WHERE id = '.$id.'
43;';
44  pwg_query($query);
45}
46
47
48// The function delete_categories deletes the categories identified by the
49// (numeric) key of the array $ids. It also deletes (in the database) :
50//    - all the elements physically linked to the category (delete_elements, see further)
51//    - all the links between elements and this category
52//    - all the restrictions linked to the category
53// The function works recursively.
54//
55// the $photo_deletion_mode is for photos virtually linked to the categorty
56//   * no_delete : delete no photo, may create orphans
57//   * delete_orphans : delete photos that are no longer linked to any category
58//   * force_delete : delete photos even if they are linked to another category
59function delete_categories($ids, $photo_deletion_mode='no_delete')
60{
61  if (count($ids) == 0)
62  {
63    return;
64  }
65
66  // add sub-category ids to the given ids : if a category is deleted, all
67  // sub-categories must be so
68  $ids = get_subcat_ids($ids);
69
70  // destruction of all photos physically linked to the category
71  $query = '
72SELECT id
73  FROM '.IMAGES_TABLE.'
74  WHERE storage_category_id IN (
75'.wordwrap(implode(', ', $ids), 80, "\n").')
76;';
77  $element_ids = array_from_query($query, 'id');
78  delete_elements($element_ids);
79
80  // now, should we delete photos that are virtually linked to the category?
81  if ('delete_orphans' == $photo_deletion_mode or 'force_delete' == $photo_deletion_mode)
82  {
83    $query = '
84SELECT
85    DISTINCT(image_id)
86  FROM '.IMAGE_CATEGORY_TABLE.'
87  WHERE category_id IN ('.implode(',', $ids).')
88;';
89    $image_ids_linked = array_from_query($query, 'image_id');
90
91    if (count($image_ids_linked) > 0)
92    {
93      if ('delete_orphans' == $photo_deletion_mode)
94      {
95        $query = '
96SELECT
97    DISTINCT(image_id)
98  FROM '.IMAGE_CATEGORY_TABLE.'
99  WHERE image_id IN ('.implode(',', $image_ids_linked).')
100    AND category_id NOT IN ('.implode(',', $ids).')
101;';
102        $image_ids_not_orphans = array_from_query($query, 'image_id');
103        $image_ids_to_delete = array_diff($image_ids_linked, $image_ids_not_orphans);
104      }
105
106      if ('force_delete' == $photo_deletion_mode)
107      {
108        $image_ids_to_delete = $image_ids_linked;
109      }
110
111      delete_elements($image_ids_to_delete, true);
112    }
113  }
114
115  // destruction of the links between images and this category
116  $query = '
117DELETE FROM '.IMAGE_CATEGORY_TABLE.'
118  WHERE category_id IN (
119'.wordwrap(implode(', ', $ids), 80, "\n").')
120;';
121  pwg_query($query);
122
123  // destruction of the access linked to the category
124  $query = '
125DELETE FROM '.USER_ACCESS_TABLE.'
126  WHERE cat_id IN (
127'.wordwrap(implode(', ', $ids), 80, "\n").')
128;';
129  pwg_query($query);
130
131  $query = '
132DELETE FROM '.GROUP_ACCESS_TABLE.'
133  WHERE cat_id IN (
134'.wordwrap(implode(', ', $ids), 80, "\n").')
135;';
136  pwg_query($query);
137
138  // destruction of the category
139  $query = '
140DELETE FROM '.CATEGORIES_TABLE.'
141  WHERE id IN (
142'.wordwrap(implode(', ', $ids), 80, "\n").')
143;';
144  pwg_query($query);
145
146  $query='
147DELETE FROM '.OLD_PERMALINKS_TABLE.'
148  WHERE cat_id IN ('.implode(',',$ids).')';
149  pwg_query($query);
150
151  $query='
152DELETE FROM '.USER_CACHE_CATEGORIES_TABLE.'
153  WHERE cat_id IN ('.implode(',',$ids).')';
154  pwg_query($query);
155
156  trigger_action('delete_categories', $ids);
157}
158
159// Deletes all files (on disk) related to given image ids
160// @return image ids where files are deleted successfully
161function delete_element_files($ids)
162{
163  global $conf;
164  if (count($ids) == 0)
165  {
166    return 0;
167  }
168
169  $new_ids = array();
170
171  $query = '
172SELECT
173    id,
174    path,
175    representative_ext
176  FROM '.IMAGES_TABLE.'
177  WHERE id IN ('.implode(',', $ids).')
178;';
179  $result = pwg_query($query);
180  while ($row = pwg_db_fetch_assoc($result))
181  {
182    if (url_is_remote($row['path']))
183    {
184      continue;
185    }
186
187    $files = array();
188    $files[] = get_element_path($row);
189
190    if (!empty($row['representative_ext']))
191    {
192      $files[] = original_to_representative( $files[0], $row['representative_ext']);
193    }
194
195    $ok = true;
196    if (!isset($conf['never_delete_originals']))
197    {
198      foreach ($files as $path)
199      {
200        if (is_file($path) and !unlink($path))
201        {
202          $ok = false;
203          trigger_error('"'.$path.'" cannot be removed', E_USER_WARNING);
204          break;
205        }
206      }
207    }
208
209    if ($ok)
210    {
211      delete_element_derivatives($row);
212      $new_ids[] = $row['id'];
213    }
214    else
215    {
216      break;
217    }
218  }
219  return $new_ids;
220}
221
222// The function delete_elements deletes the elements identified by the
223// (numeric) values of the array $ids. It also deletes (in the database) :
224//    - all the comments related to elements
225//    - all the links between categories and elements
226//    - all the favorites associated to elements
227// @return number of deleted elements
228function delete_elements($ids, $physical_deletion=false)
229{
230  if (count($ids) == 0)
231  {
232    return 0;
233  }
234  trigger_action('begin_delete_elements', $ids);
235
236  if ($physical_deletion)
237  {
238    $ids = delete_element_files($ids);
239    if (count($ids)==0)
240    {
241      return 0;
242    }
243  }
244
245  // destruction of the comments on the image
246  $query = '
247DELETE FROM '.COMMENTS_TABLE.'
248  WHERE image_id IN (
249'.wordwrap(implode(', ', $ids), 80, "\n").')
250;';
251  pwg_query($query);
252
253  // destruction of the links between images and this category
254  $query = '
255DELETE FROM '.IMAGE_CATEGORY_TABLE.'
256  WHERE image_id IN (
257'.wordwrap(implode(', ', $ids), 80, "\n").')
258;';
259  pwg_query($query);
260
261  // destruction of the links between images and tags
262  $query = '
263DELETE FROM '.IMAGE_TAG_TABLE.'
264  WHERE image_id IN (
265'.wordwrap(implode(', ', $ids), 80, "\n").')
266;';
267  pwg_query($query);
268
269  // destruction of the favorites associated with the picture
270  $query = '
271DELETE FROM '.FAVORITES_TABLE.'
272  WHERE image_id IN (
273'.wordwrap(implode(', ', $ids), 80, "\n").')
274;';
275  pwg_query($query);
276
277  // destruction of the rates associated to this element
278  $query = '
279DELETE FROM '.RATE_TABLE.'
280  WHERE element_id IN (
281'.wordwrap(implode(', ', $ids), 80, "\n").')
282;';
283  pwg_query($query);
284
285  // destruction of the rates associated to this element
286  $query = '
287DELETE FROM '.CADDIE_TABLE.'
288  WHERE element_id IN (
289'.wordwrap(implode(', ', $ids), 80, "\n").')
290;';
291  pwg_query($query);
292
293  // destruction of the image
294  $query = '
295DELETE FROM '.IMAGES_TABLE.'
296  WHERE id IN (
297'.wordwrap(implode(', ', $ids), 80, "\n").')
298;';
299  pwg_query($query);
300
301  // are the photo used as category representant?
302  $query = '
303SELECT
304    id
305  FROM '.CATEGORIES_TABLE.'
306  WHERE representative_picture_id IN (
307'.wordwrap(implode(', ', $ids), 80, "\n").')
308;';
309  $category_ids = array_from_query($query, 'id');
310  if (count($category_ids) > 0)
311  {
312    update_category($category_ids);
313  }
314
315  trigger_action('delete_elements', $ids);
316  return count($ids);
317}
318
319// The delete_user function delete a user identified by the $user_id
320// It also deletes :
321//     - all the access linked to this user
322//     - all the links to any group
323//     - all the favorites linked to this user
324//     - calculated permissions linked to the user
325//     - all datas about notifications for the user
326function delete_user($user_id)
327{
328  global $conf;
329  $tables = array(
330    // destruction of the access linked to the user
331    USER_ACCESS_TABLE,
332    // destruction of data notification by mail for this user
333    USER_MAIL_NOTIFICATION_TABLE,
334    // destruction of data RSS notification for this user
335    USER_FEED_TABLE,
336    // deletion of calculated permissions linked to the user
337    USER_CACHE_TABLE,
338    // deletion of computed cache data linked to the user
339    USER_CACHE_CATEGORIES_TABLE,
340    // destruction of the group links for this user
341    USER_GROUP_TABLE,
342    // destruction of the favorites associated with the user
343    FAVORITES_TABLE,
344    // destruction of the caddie associated with the user
345    CADDIE_TABLE,
346    // deletion of piwigo specific informations
347    USER_INFOS_TABLE,
348    );
349
350  foreach ($tables as $table)
351  {
352    $query = '
353DELETE FROM '.$table.'
354  WHERE user_id = '.$user_id.'
355;';
356    pwg_query($query);
357  }
358
359  // destruction of the user
360  $query = '
361DELETE FROM '.SESSIONS_TABLE.'
362  WHERE data LIKE \'pwg_uid|i:'.(int)$user_id.';%\'
363;';
364  pwg_query($query);
365
366  // destruction of the user
367  $query = '
368DELETE FROM '.USERS_TABLE.'
369  WHERE '.$conf['user_fields']['id'].' = '.$user_id.'
370;';
371  pwg_query($query);
372
373  trigger_action('delete_user', $user_id);
374}
375
376/**
377 * Deletes all tags linked to no photo
378 */
379function delete_orphan_tags()
380{
381  $orphan_tags = get_orphan_tags();
382
383  if (count($orphan_tags) > 0)
384  {
385    $orphan_tag_ids = array();
386    foreach ($orphan_tags as $tag)
387    {
388      $orphan_tag_ids[] = $tag['id'];
389    }
390
391    $query = '
392DELETE
393  FROM '.TAGS_TABLE.'
394  WHERE id IN ('.implode(',', $orphan_tag_ids).')
395;';
396    pwg_query($query);
397  }
398}
399
400/**
401 * Get all tags (id + name) linked to no photo
402 */
403function get_orphan_tags()
404{
405  $query = '
406SELECT
407    id,
408    name
409  FROM '.TAGS_TABLE.'
410    LEFT JOIN '.IMAGE_TAG_TABLE.' ON id = tag_id
411  WHERE tag_id IS NULL
412;';
413  return array_from_query($query);
414}
415
416/**
417 * Verifies that the representative picture really exists in the db and
418 * picks up a random represantive if possible and based on config.
419 *
420 * @param mixed category id
421 * @returns void
422 */
423function update_category($ids = 'all')
424{
425  global $conf;
426
427  if ($ids=='all')
428  {
429    $where_cats = '1=1';
430  }
431  elseif ( !is_array($ids) )
432  {
433    $where_cats = '%s='.$ids;
434  }
435  else
436  {
437    if (count($ids) == 0)
438    {
439      return false;
440    }
441    $where_cats = '%s IN('.wordwrap(implode(', ', $ids), 120, "\n").')';
442  }
443
444  // find all categories where the setted representative is not possible :
445  // the picture does not exist
446  $query = '
447SELECT DISTINCT c.id
448  FROM '.CATEGORIES_TABLE.' AS c LEFT JOIN '.IMAGES_TABLE.' AS i
449    ON c.representative_picture_id = i.id
450  WHERE representative_picture_id IS NOT NULL
451    AND '.sprintf($where_cats, 'c.id').'
452    AND i.id IS NULL
453;';
454  $wrong_representant = array_from_query($query, 'id');
455
456  if (count($wrong_representant) > 0)
457  {
458    $query = '
459UPDATE '.CATEGORIES_TABLE.'
460  SET representative_picture_id = NULL
461  WHERE id IN ('.wordwrap(implode(', ', $wrong_representant), 120, "\n").')
462;';
463    pwg_query($query);
464  }
465
466  if (!$conf['allow_random_representative'])
467  {
468    // If the random representant is not allowed, we need to find
469    // categories with elements and with no representant. Those categories
470    // must be added to the list of categories to set to a random
471    // representant.
472    $query = '
473SELECT DISTINCT id
474  FROM '.CATEGORIES_TABLE.' INNER JOIN '.IMAGE_CATEGORY_TABLE.'
475    ON id = category_id
476  WHERE representative_picture_id IS NULL
477    AND '.sprintf($where_cats, 'category_id').'
478;';
479    $to_rand = array_from_query($query, 'id');
480    if (count($to_rand) > 0)
481    {
482      set_random_representant($to_rand);
483    }
484  }
485}
486
487/**
488 * check and repair images integrity
489 *
490 * TODO see delete_elements function to check all linked tables
491 */
492function images_integrity()
493{
494  $query = '
495SELECT
496    image_id
497  FROM '.IMAGE_CATEGORY_TABLE.'
498    LEFT JOIN '.IMAGES_TABLE.' ON id = image_id
499  WHERE id IS NULL
500;';
501  $result = pwg_query($query);
502  $orphan_image_ids = array_from_query($query, 'image_id');
503
504  if (count($orphan_image_ids) > 0)
505  {
506    $query = '
507DELETE
508  FROM '.IMAGE_CATEGORY_TABLE.'
509  WHERE image_id IN ('.implode(',', $orphan_image_ids).')
510;';
511    pwg_query($query);
512  }
513}
514
515/**
516 * returns an array containing sub-directories which can be a category,
517 * recursive by default
518 *
519 * directories nammed "thumbnail", "pwg_high" or "pwg_representative" are
520 * omitted
521 *
522 * @param string $basedir
523 * @return array
524 */
525function get_fs_directories($path, $recursive = true)
526{
527  $dirs = array();
528
529  if (is_dir($path))
530  {
531    if ($contents = opendir($path))
532    {
533      while (($node = readdir($contents)) !== false)
534      {
535        if ($node != '.'
536            and $node != '..'
537            and $node != '.svn'
538            and $node != 'thumbnail'
539            and $node != 'pwg_high'
540            and $node != 'pwg_representative'
541            and is_dir($path.'/'.$node))
542        {
543          array_push($dirs, $path.'/'.$node);
544          if ($recursive)
545          {
546            $dirs = array_merge($dirs, get_fs_directories($path.'/'.$node));
547          }
548        }
549      }
550      closedir($contents);
551    }
552  }
553
554  return $dirs;
555}
556
557/**
558 * order categories (update categories.rank and global_rank database fields)
559 * so that rank field are consecutive integers starting at 1 for each child
560 * @return void
561 */
562function update_global_rank()
563{
564  $query = '
565SELECT id, id_uppercat, uppercats, rank, global_rank
566  FROM '.CATEGORIES_TABLE.'
567  ORDER BY id_uppercat,rank,name';
568
569  $cat_map = array();
570
571  $current_rank = 0;
572  $current_uppercat = '';
573
574  $result = pwg_query($query);
575  while ($row = pwg_db_fetch_assoc($result))
576  {
577    if ($row['id_uppercat'] != $current_uppercat)
578    {
579      $current_rank = 0;
580      $current_uppercat = $row['id_uppercat'];
581    }
582    ++$current_rank;
583    $cat =
584      array(
585        'rank' =>        $current_rank,
586        'rank_changed' =>$current_rank!=$row['rank'],
587        'global_rank' => $row['global_rank'],
588        'uppercats' =>   $row['uppercats'],
589        );
590    $cat_map[ $row['id'] ] = $cat;
591  }
592
593  $datas = array();
594
595  foreach( $cat_map as $id=>$cat )
596  {
597    $new_global_rank = preg_replace(
598          '/(\d+)/e',
599          "\$cat_map['$1']['rank']",
600          str_replace(',', '.', $cat['uppercats'] )
601          );
602    if ( $cat['rank_changed']
603      or $new_global_rank!=$cat['global_rank']
604      )
605    {
606      $datas[] = array(
607          'id' => $id,
608          'rank' => $cat['rank'],
609          'global_rank' => $new_global_rank,
610        );
611    }
612  }
613
614  mass_updates(
615    CATEGORIES_TABLE,
616    array(
617      'primary' => array('id'),
618      'update'  => array('rank', 'global_rank')
619      ),
620    $datas
621    );
622  return count($datas);
623}
624
625/**
626 * change the visible property on a set of categories
627 *
628 * @param array categories
629 * @param string value
630 * @return void
631 */
632function set_cat_visible($categories, $value)
633{
634  if (!in_array($value, array('true', 'false')))
635  {
636    trigger_error("set_cat_visible invalid param $value", E_USER_WARNING);
637    return false;
638  }
639
640  // unlocking a category => all its parent categories become unlocked
641  if ($value == 'true')
642  {
643    $uppercats = get_uppercat_ids($categories);
644    $query = '
645UPDATE '.CATEGORIES_TABLE.'
646  SET visible = \'true\'
647  WHERE id IN ('.implode(',', $uppercats).')';
648    pwg_query($query);
649  }
650  // locking a category   => all its child categories become locked
651  if ($value == 'false')
652  {
653    $subcats = get_subcat_ids($categories);
654    $query = '
655UPDATE '.CATEGORIES_TABLE.'
656  SET visible = \'false\'
657  WHERE id IN ('.implode(',', $subcats).')';
658    pwg_query($query);
659  }
660}
661
662/**
663 * change the status property on a set of categories : private or public
664 *
665 * @param array categories
666 * @param string value
667 * @return void
668 */
669function set_cat_status($categories, $value)
670{
671  if (!in_array($value, array('public', 'private')))
672  {
673    trigger_error("set_cat_status invalid param $value", E_USER_WARNING);
674    return false;
675  }
676
677  // make public a category => all its parent categories become public
678  if ($value == 'public')
679  {
680    $uppercats = get_uppercat_ids($categories);
681    $query = '
682UPDATE '.CATEGORIES_TABLE.'
683  SET status = \'public\'
684  WHERE id IN ('.implode(',', $uppercats).')
685;';
686    pwg_query($query);
687  }
688  // make a category private => all its child categories become private
689  if ($value == 'private')
690  {
691    $subcats = get_subcat_ids($categories);
692    $query = '
693UPDATE '.CATEGORIES_TABLE.'
694  SET status = \'private\'
695  WHERE id IN ('.implode(',', $subcats).')';
696    pwg_query($query);
697  }
698}
699
700/**
701 * returns all uppercats category ids of the given category ids
702 *
703 * @param array cat_ids
704 * @return array
705 */
706function get_uppercat_ids($cat_ids)
707{
708  if (!is_array($cat_ids) or count($cat_ids) < 1)
709  {
710    return array();
711  }
712
713  $uppercats = array();
714
715  $query = '
716SELECT uppercats
717  FROM '.CATEGORIES_TABLE.'
718  WHERE id IN ('.implode(',', $cat_ids).')
719;';
720  $result = pwg_query($query);
721  while ($row = pwg_db_fetch_assoc($result))
722  {
723    $uppercats = array_merge($uppercats,
724                             explode(',', $row['uppercats']));
725  }
726  $uppercats = array_unique($uppercats);
727
728  return $uppercats;
729}
730
731/**
732 * set a new random representant to the categories
733 *
734 * @param array categories
735 */
736function set_random_representant($categories)
737{
738  $datas = array();
739  foreach ($categories as $category_id)
740  {
741    $query = '
742SELECT image_id
743  FROM '.IMAGE_CATEGORY_TABLE.'
744  WHERE category_id = '.$category_id.'
745  ORDER BY '.DB_RANDOM_FUNCTION.'()
746  LIMIT 1
747;';
748    list($representative) = pwg_db_fetch_row(pwg_query($query));
749
750    array_push(
751      $datas,
752      array(
753        'id' => $category_id,
754        'representative_picture_id' => $representative,
755        )
756      );
757  }
758
759  mass_updates(
760    CATEGORIES_TABLE,
761    array(
762      'primary' => array('id'),
763      'update' => array('representative_picture_id')
764      ),
765    $datas
766    );
767}
768
769/**
770 * returns the fulldir for each given category id
771 *
772 * @param array cat_ids
773 * @return array
774 */
775function get_fulldirs($cat_ids)
776{
777  if (count($cat_ids) == 0)
778  {
779    return array();
780  }
781
782  // caching directories of existing categories
783  $query = '
784SELECT id, dir
785  FROM '.CATEGORIES_TABLE.'
786  WHERE dir IS NOT NULL
787;';
788  $cat_dirs = simple_hash_from_query($query, 'id', 'dir');
789
790  // caching galleries_url
791  $query = '
792SELECT id, galleries_url
793  FROM '.SITES_TABLE.'
794;';
795  $galleries_url = simple_hash_from_query($query, 'id', 'galleries_url');
796
797  // categories : id, site_id, uppercats
798  $query = '
799SELECT id, uppercats, site_id
800  FROM '.CATEGORIES_TABLE.'
801  WHERE dir IS NOT NULL
802    AND id IN (
803'.wordwrap(implode(', ', $cat_ids), 80, "\n").')
804;';
805  $categories = array_from_query($query);
806
807  // filling $cat_fulldirs
808  $cat_fulldirs = array();
809  foreach ($categories as $category)
810  {
811    $uppercats = str_replace(',', '/', $category['uppercats']);
812    $cat_fulldirs[$category['id']] = $galleries_url[$category['site_id']];
813    $cat_fulldirs[$category['id']].= preg_replace('/(\d+)/e',
814                                                  "\$cat_dirs['$1']",
815                                                  $uppercats);
816  }
817
818  return $cat_fulldirs;
819}
820
821/**
822 * returns an array with all file system files according to
823 * $conf['file_ext']
824 *
825 * @param string $path
826 * @param bool recursive
827 * @return array
828 */
829function get_fs($path, $recursive = true)
830{
831  global $conf;
832
833  // because isset is faster than in_array...
834  if (!isset($conf['flip_picture_ext']))
835  {
836    $conf['flip_picture_ext'] = array_flip($conf['picture_ext']);
837  }
838  if (!isset($conf['flip_file_ext']))
839  {
840    $conf['flip_file_ext'] = array_flip($conf['file_ext']);
841  }
842
843  $fs['elements'] = array();
844  $fs['thumbnails'] = array();
845  $fs['representatives'] = array();
846  $subdirs = array();
847
848  if (is_dir($path))
849  {
850    if ($contents = opendir($path))
851    {
852      while (($node = readdir($contents)) !== false)
853      {
854        if ($node == '.' or $node == '..') continue;
855
856        if (is_file($path.'/'.$node))
857        {
858          $extension = get_extension($node);
859
860//          if (in_array($extension, $conf['picture_ext']))
861          if (isset($conf['flip_picture_ext'][$extension]))
862          {
863            if (basename($path) == 'thumbnail')
864            {
865              array_push($fs['thumbnails'], $path.'/'.$node);
866            }
867            else if (basename($path) == 'pwg_representative')
868            {
869              array_push($fs['representatives'], $path.'/'.$node);
870            }
871            else
872            {
873              array_push($fs['elements'], $path.'/'.$node);
874            }
875          }
876//          else if (in_array($extension, $conf['file_ext']))
877          else if (isset($conf['flip_file_ext'][$extension]))
878          {
879            array_push($fs['elements'], $path.'/'.$node);
880          }
881        }
882        else if (is_dir($path.'/'.$node) and $node != 'pwg_high' and $recursive)
883        {
884          array_push($subdirs, $node);
885        }
886      }
887    }
888    closedir($contents);
889
890    foreach ($subdirs as $subdir)
891    {
892      $tmp_fs = get_fs($path.'/'.$subdir);
893
894      $fs['elements']        = array_merge($fs['elements'],
895                                           $tmp_fs['elements']);
896
897      $fs['thumbnails']      = array_merge($fs['thumbnails'],
898                                           $tmp_fs['thumbnails']);
899
900      $fs['representatives'] = array_merge($fs['representatives'],
901                                           $tmp_fs['representatives']);
902    }
903  }
904  return $fs;
905}
906
907/**
908 * synchronize base users list and related users list
909 *
910 * compares and synchronizes base users table (USERS_TABLE) with its child
911 * tables (USER_INFOS_TABLE, USER_ACCESS, USER_CACHE, USER_GROUP) : each
912 * base user must be present in child tables, users in child tables not
913 * present in base table must be deleted.
914 *
915 * @return void
916 */
917function sync_users()
918{
919  global $conf;
920
921  $query = '
922SELECT '.$conf['user_fields']['id'].' AS id
923  FROM '.USERS_TABLE.'
924;';
925  $base_users = array_from_query($query, 'id');
926
927  $query = '
928SELECT user_id
929  FROM '.USER_INFOS_TABLE.'
930;';
931  $infos_users = array_from_query($query, 'user_id');
932
933  // users present in $base_users and not in $infos_users must be added
934  $to_create = array_diff($base_users, $infos_users);
935
936  if (count($to_create) > 0)
937  {
938    create_user_infos($to_create);
939  }
940
941  // users present in user related tables must be present in the base user
942  // table
943  $tables = array(
944    USER_MAIL_NOTIFICATION_TABLE,
945    USER_FEED_TABLE,
946    USER_INFOS_TABLE,
947    USER_ACCESS_TABLE,
948    USER_CACHE_TABLE,
949    USER_CACHE_CATEGORIES_TABLE,
950    USER_GROUP_TABLE
951    );
952
953  foreach ($tables as $table)
954  {
955    $query = '
956SELECT DISTINCT user_id
957  FROM '.$table.'
958;';
959    $to_delete = array_diff(
960      array_from_query($query, 'user_id'),
961      $base_users
962      );
963
964    if (count($to_delete) > 0)
965    {
966      $query = '
967DELETE
968  FROM '.$table.'
969  WHERE user_id in ('.implode(',', $to_delete).')
970;';
971      pwg_query($query);
972    }
973  }
974}
975
976/**
977 * updates categories.uppercats field based on categories.id +
978 * categories.id_uppercat
979 *
980 * @return void
981 */
982function update_uppercats()
983{
984  $query = '
985SELECT id, id_uppercat, uppercats
986  FROM '.CATEGORIES_TABLE.'
987;';
988  $cat_map = hash_from_query($query, 'id');
989
990  $datas = array();
991  foreach ($cat_map as $id => $cat)
992  {
993    $upper_list = array();
994
995    $uppercat = $id;
996    while ($uppercat)
997    {
998      array_push($upper_list, $uppercat);
999      $uppercat = $cat_map[$uppercat]['id_uppercat'];
1000    }
1001
1002    $new_uppercats = implode(',', array_reverse($upper_list));
1003    if ($new_uppercats != $cat['uppercats'])
1004    {
1005      array_push(
1006        $datas,
1007        array(
1008          'id' => $id,
1009          'uppercats' => $new_uppercats
1010          )
1011        );
1012    }
1013  }
1014  $fields = array('primary' => array('id'), 'update' => array('uppercats'));
1015  mass_updates(CATEGORIES_TABLE, $fields, $datas);
1016}
1017
1018/**
1019 * update images.path field
1020 *
1021 * @return void
1022 */
1023function update_path()
1024{
1025  $query = '
1026SELECT DISTINCT(storage_category_id)
1027  FROM '.IMAGES_TABLE.'
1028  WHERE storage_category_id IS NOT NULL
1029;';
1030  $cat_ids = array_from_query($query, 'storage_category_id');
1031  $fulldirs = get_fulldirs($cat_ids);
1032
1033  foreach ($cat_ids as $cat_id)
1034  {
1035    $query = '
1036UPDATE '.IMAGES_TABLE.'
1037  SET path = '.pwg_db_concat(array("'".$fulldirs[$cat_id]."/'",'file')).'
1038  WHERE storage_category_id = '.$cat_id.'
1039;';
1040    pwg_query($query);
1041  }
1042}
1043
1044/**
1045 * change the parent category of the given categories. The categories are
1046 * supposed virtual.
1047 *
1048 * @param array category identifiers
1049 * @param int parent category identifier
1050 * @return void
1051 */
1052function move_categories($category_ids, $new_parent = -1)
1053{
1054  global $page;
1055
1056  if (count($category_ids) == 0)
1057  {
1058    return;
1059  }
1060
1061  $new_parent = $new_parent < 1 ? 'NULL' : $new_parent;
1062
1063  $categories = array();
1064
1065  $query = '
1066SELECT id, id_uppercat, status, uppercats
1067  FROM '.CATEGORIES_TABLE.'
1068  WHERE id IN ('.implode(',', $category_ids).')
1069;';
1070  $result = pwg_query($query);
1071  while ($row = pwg_db_fetch_assoc($result))
1072  {
1073    $categories[$row['id']] =
1074      array(
1075        'parent' => empty($row['id_uppercat']) ? 'NULL' : $row['id_uppercat'],
1076        'status' => $row['status'],
1077        'uppercats' => $row['uppercats']
1078        );
1079  }
1080
1081  // is the movement possible? The movement is impossible if you try to move
1082  // a category in a sub-category or itself
1083  if ('NULL' != $new_parent)
1084  {
1085    $query = '
1086SELECT uppercats
1087  FROM '.CATEGORIES_TABLE.'
1088  WHERE id = '.$new_parent.'
1089;';
1090    list($new_parent_uppercats) = pwg_db_fetch_row(pwg_query($query));
1091
1092    foreach ($categories as $category)
1093    {
1094      // technically, you can't move a category with uppercats 12,125,13,14
1095      // into a new parent category with uppercats 12,125,13,14,24
1096      if (preg_match('/^'.$category['uppercats'].'(,|$)/', $new_parent_uppercats))
1097      {
1098        array_push(
1099          $page['errors'],
1100          l10n('You cannot move an album in its own sub album')
1101          );
1102        return;
1103      }
1104    }
1105  }
1106
1107  $tables =
1108    array(
1109      USER_ACCESS_TABLE => 'user_id',
1110      GROUP_ACCESS_TABLE => 'group_id'
1111      );
1112
1113  $query = '
1114UPDATE '.CATEGORIES_TABLE.'
1115  SET id_uppercat = '.$new_parent.'
1116  WHERE id IN ('.implode(',', $category_ids).')
1117;';
1118  pwg_query($query);
1119
1120  update_uppercats();
1121  update_global_rank();
1122
1123  // status and related permissions management
1124  if ('NULL' == $new_parent)
1125  {
1126    $parent_status = 'public';
1127  }
1128  else
1129  {
1130    $query = '
1131SELECT status
1132  FROM '.CATEGORIES_TABLE.'
1133  WHERE id = '.$new_parent.'
1134;';
1135    list($parent_status) = pwg_db_fetch_row(pwg_query($query));
1136  }
1137
1138  if ('private' == $parent_status)
1139  {
1140    foreach ($categories as $cat_id => $category)
1141    {
1142      switch ($category['status'])
1143      {
1144        case 'public' :
1145        {
1146          set_cat_status(array($cat_id), 'private');
1147          break;
1148        }
1149        case 'private' :
1150        {
1151          $subcats = get_subcat_ids(array($cat_id));
1152
1153          foreach ($tables as $table => $field)
1154          {
1155            $query = '
1156SELECT '.$field.'
1157  FROM '.$table.'
1158  WHERE cat_id = '.$cat_id.'
1159;';
1160            $category_access = array_from_query($query, $field);
1161
1162            $query = '
1163SELECT '.$field.'
1164  FROM '.$table.'
1165  WHERE cat_id = '.$new_parent.'
1166;';
1167            $parent_access = array_from_query($query, $field);
1168
1169            $to_delete = array_diff($parent_access, $category_access);
1170
1171            if (count($to_delete) > 0)
1172            {
1173              $query = '
1174DELETE FROM '.$table.'
1175  WHERE '.$field.' IN ('.implode(',', $to_delete).')
1176    AND cat_id IN ('.implode(',', $subcats).')
1177;';
1178              pwg_query($query);
1179            }
1180          }
1181          break;
1182        }
1183      }
1184    }
1185  }
1186
1187  array_push(
1188    $page['infos'],
1189    l10n_dec(
1190      '%d album moved', '%d albums moved',
1191      count($categories)
1192      )
1193    );
1194}
1195
1196/**
1197 * create a virtual category
1198 *
1199 * @param string category name
1200 * @param int parent category id
1201 * @return array with ('info' and 'id') or ('error') key
1202 */
1203function create_virtual_category($category_name, $parent_id=null, $options=array())
1204{
1205  global $conf, $user;
1206
1207  // is the given category name only containing blank spaces ?
1208  if (preg_match('/^\s*$/', $category_name))
1209  {
1210    return array('error' => l10n('The name of an album must not be empty'));
1211  }
1212
1213  $insert = array(
1214    'name' => $category_name,
1215    'rank' => 0,
1216    'global_rank' => 0,
1217    );
1218
1219  // is the album commentable?
1220  if (isset($options['commentable']) and is_bool($options['commentable']))
1221  {
1222    $insert['commentable'] = $options['commentable'];
1223  }
1224  else
1225  {
1226    $insert['commentable'] = $conf['newcat_default_commentable'];
1227  }
1228  $insert['commentable'] = boolean_to_string($insert['commentable']);
1229
1230  // is the album temporarily locked? (only visible by administrators,
1231  // whatever permissions) (may be overwritten if parent album is not
1232  // visible)
1233  if (isset($options['visible']) and is_bool($options['visible']))
1234  {
1235    $insert['visible'] = $options['visible'];
1236  }
1237  else
1238  {
1239    $insert['visible'] = $conf['newcat_default_visible'];
1240  }
1241  $insert['visible'] = boolean_to_string($insert['visible']);
1242
1243  // is the album private? (may be overwritten if parent album is private)
1244  if (isset($options['status']) and 'private' == $options['status'])
1245  {
1246    $insert['status'] = 'private';
1247  }
1248  else
1249  {
1250    $insert['status'] = $conf['newcat_default_status'];
1251  }
1252
1253  // any description for this album?
1254  if (isset($options['comment']))
1255  {
1256    $insert['comment'] = $conf['allow_html_descriptions'] ? $options['comment'] : strip_tags($options['comment']);
1257  }
1258
1259  if (!empty($parent_id) and is_numeric($parent_id))
1260  {
1261    $query = '
1262SELECT id, uppercats, global_rank, visible, status
1263  FROM '.CATEGORIES_TABLE.'
1264  WHERE id = '.$parent_id.'
1265;';
1266    $parent = pwg_db_fetch_assoc(pwg_query($query));
1267
1268    $insert['id_uppercat'] = $parent['id'];
1269    $insert['global_rank'] = $parent['global_rank'].'.'.$insert['rank'];
1270
1271    // at creation, must a category be visible or not ? Warning : if the
1272    // parent category is invisible, the category is automatically create
1273    // invisible. (invisible = locked)
1274    if ('false' == $parent['visible'])
1275    {
1276      $insert['visible'] = 'false';
1277    }
1278
1279    // at creation, must a category be public or private ? Warning : if the
1280    // parent category is private, the category is automatically create
1281    // private.
1282    if ('private' == $parent['status'])
1283    {
1284      $insert['status'] = 'private';
1285    }
1286
1287    $uppercats_prefix = $parent['uppercats'].',';
1288  }
1289  else
1290  {
1291    $uppercats_prefix = '';
1292  }
1293
1294  // we have then to add the virtual category
1295  single_insert(CATEGORIES_TABLE, $insert);
1296  $inserted_id = pwg_db_insert_id(CATEGORIES_TABLE);
1297
1298  single_update(
1299    CATEGORIES_TABLE,
1300    array('uppercats' => $uppercats_prefix.$inserted_id),
1301    array('id' => $inserted_id)
1302    );
1303
1304  update_global_rank();
1305
1306  if ('private' == $insert['status'])
1307  {
1308    add_permission_on_category($inserted_id, array_unique(array_merge(get_admins(), array($user['id']))));
1309  }
1310
1311  return array(
1312    'info' => l10n('Virtual album added'),
1313    'id'   => $inserted_id,
1314    );
1315}
1316
1317/**
1318 * Set tags to an image. Warning: given tags are all tags associated to the
1319 * image, not additionnal tags.
1320 *
1321 * @param array tag ids
1322 * @param int image id
1323 * @return void
1324 */
1325function set_tags($tags, $image_id)
1326{
1327  set_tags_of( array($image_id=>$tags) );
1328}
1329
1330/**
1331 * Add new tags to a set of images.
1332 *
1333 * @param array tag ids
1334 * @param array image ids
1335 * @return void
1336 */
1337function add_tags($tags, $images)
1338{
1339  if (count($tags) == 0 or count($images) == 0)
1340  {
1341    return;
1342  }
1343
1344  // we can't insert twice the same {image_id,tag_id} so we must first
1345  // delete lines we'll insert later
1346  $query = '
1347DELETE
1348  FROM '.IMAGE_TAG_TABLE.'
1349  WHERE image_id IN ('.implode(',', $images).')
1350    AND tag_id IN ('.implode(',', $tags).')
1351;';
1352  pwg_query($query);
1353
1354  $inserts = array();
1355  foreach ($images as $image_id)
1356  {
1357    foreach ( array_unique($tags) as $tag_id)
1358    {
1359      $inserts[] = array(
1360          'image_id' => $image_id,
1361          'tag_id' => $tag_id,
1362        );
1363    }
1364  }
1365  mass_inserts(
1366    IMAGE_TAG_TABLE,
1367    array_keys($inserts[0]),
1368    $inserts
1369    );
1370}
1371
1372/**
1373 *
1374 */
1375function delete_tags($tag_ids)
1376{
1377  if (is_numeric($tag_ids))
1378  {
1379    $tag_ids = array($tag_ids);
1380  }
1381
1382  if (!is_array($tag_ids))
1383  {
1384    return false;
1385  }
1386
1387  $query = '
1388DELETE
1389  FROM '.IMAGE_TAG_TABLE.'
1390  WHERE tag_id IN ('.implode(',', $tag_ids).')
1391;';
1392  pwg_query($query);
1393
1394  $query = '
1395DELETE
1396  FROM '.TAGS_TABLE.'
1397  WHERE id IN ('.implode(',', $tag_ids).')
1398;';
1399  pwg_query($query);
1400}
1401
1402function tag_id_from_tag_name($tag_name)
1403{
1404  global $page;
1405
1406  $tag_name = trim($tag_name);
1407  if (isset($page['tag_id_from_tag_name_cache'][$tag_name]))
1408  {
1409    return $page['tag_id_from_tag_name_cache'][$tag_name];
1410  }
1411
1412  // search existing by exact name
1413  $query = '
1414SELECT id
1415  FROM '.TAGS_TABLE.'
1416  WHERE name = \''.$tag_name.'\'
1417;';
1418  if (count($existing_tags = array_from_query($query, 'id')) == 0)
1419  {
1420    // search existing by case insensitive name
1421    $query = '
1422SELECT id
1423  FROM '.TAGS_TABLE.'
1424  WHERE CONVERT(name, CHAR) = \''.$tag_name.'\'
1425;';
1426    if (count($existing_tags = array_from_query($query, 'id')) == 0)
1427    {
1428      $url_name = trigger_event('render_tag_url', $tag_name);
1429      // search existing by url name
1430      $query = '
1431SELECT id
1432  FROM '.TAGS_TABLE.'
1433  WHERE url_name = \''.$url_name.'\'
1434;';
1435      if (count($existing_tags = array_from_query($query, 'id')) == 0)
1436      {
1437        mass_inserts(
1438          TAGS_TABLE,
1439          array('name', 'url_name'),
1440          array(
1441            array(
1442              'name' => $tag_name,
1443              'url_name' => $url_name,
1444              )
1445            )
1446          );
1447        $page['tag_id_from_tag_name_cache'][$tag_name] = pwg_db_insert_id(TAGS_TABLE);
1448        return $page['tag_id_from_tag_name_cache'][$tag_name];
1449      }
1450    }
1451  }
1452
1453  $page['tag_id_from_tag_name_cache'][$tag_name] = $existing_tags[0];
1454  return $page['tag_id_from_tag_name_cache'][$tag_name];
1455}
1456
1457function set_tags_of($tags_of)
1458{
1459  if (count($tags_of) > 0)
1460  {
1461    $query = '
1462DELETE
1463  FROM '.IMAGE_TAG_TABLE.'
1464  WHERE image_id IN ('.implode(',', array_keys($tags_of)).')
1465;';
1466    pwg_query($query);
1467
1468    $inserts = array();
1469
1470    foreach ($tags_of as $image_id => $tag_ids)
1471    {
1472      foreach (array_unique($tag_ids) as $tag_id)
1473      {
1474        $inserts[] = array(
1475            'image_id' => $image_id,
1476            'tag_id' => $tag_id,
1477          );
1478      }
1479    }
1480
1481    if (count($inserts))
1482    {
1483      mass_inserts(
1484        IMAGE_TAG_TABLE,
1485        array_keys($inserts[0]),
1486        $inserts
1487        );
1488    }
1489  }
1490}
1491
1492/**
1493 * Associate a list of images to a list of categories.
1494 *
1495 * The function will not duplicate links and will preserve ranks
1496 *
1497 * @param array images
1498 * @param array categories
1499 * @return void
1500 */
1501function associate_images_to_categories($images, $categories)
1502{
1503  if (count($images) == 0
1504      or count($categories) == 0)
1505  {
1506    return false;
1507  }
1508
1509  // get existing associations
1510  $query = '
1511SELECT
1512    image_id,
1513    category_id
1514  FROM '.IMAGE_CATEGORY_TABLE.'
1515  WHERE image_id IN ('.implode(',', $images).')
1516    AND category_id IN ('.implode(',', $categories).')
1517;';
1518  $result = pwg_query($query);
1519
1520  $existing = array();
1521  while ($row = pwg_db_fetch_assoc($result))
1522  {
1523    $existing[ $row['category_id'] ][] = $row['image_id'];
1524  }
1525
1526  // get max rank of each categories
1527  $query = '
1528SELECT
1529    category_id,
1530    MAX(rank) AS max_rank
1531  FROM '.IMAGE_CATEGORY_TABLE.'
1532  WHERE rank IS NOT NULL
1533    AND category_id IN ('.implode(',', $categories).')
1534  GROUP BY category_id
1535;';
1536
1537  $current_rank_of = simple_hash_from_query(
1538    $query,
1539    'category_id',
1540    'max_rank'
1541    );
1542
1543  // associate only not already associated images
1544  $inserts = array();
1545  foreach ($categories as $category_id)
1546  {
1547    if (!isset($current_rank_of[$category_id]))
1548    {
1549      $current_rank_of[$category_id] = 0;
1550    }
1551    if (!isset($existing[$category_id]))
1552    {
1553      $existing[$category_id] = array();
1554    }
1555
1556    foreach ($images as $image_id)
1557    {
1558      if (!in_array($image_id, $existing[$category_id]))
1559      {
1560        $rank = ++$current_rank_of[$category_id];
1561
1562        array_push(
1563          $inserts,
1564          array(
1565            'image_id' => $image_id,
1566            'category_id' => $category_id,
1567            'rank' => $rank,
1568            )
1569          );
1570      }
1571    }
1572  }
1573
1574  if (count($inserts))
1575  {
1576    mass_inserts(
1577      IMAGE_CATEGORY_TABLE,
1578      array_keys($inserts[0]),
1579      $inserts
1580      );
1581
1582    update_category($categories);
1583  }
1584}
1585
1586/**
1587 * Dissociate images from all old categories except their storage category and
1588 * associate to new categories.
1589 *
1590 * This function will preserve ranks
1591 *
1592 * @param array images
1593 * @param array categories
1594 * @return void
1595 */
1596function move_images_to_categories($images, $categories)
1597{
1598  if (count($images) == 0)
1599  {
1600    return false;
1601  }
1602
1603  // let's first break links with all old albums but their "storage album"
1604  $query = '
1605DELETE '.IMAGE_CATEGORY_TABLE.'.*
1606  FROM '.IMAGE_CATEGORY_TABLE.'
1607    JOIN '.IMAGES_TABLE.' ON image_id=id
1608  WHERE id IN ('.implode(',', $images).')
1609';
1610
1611  if (is_array($categories) and count($categories) > 0)
1612  {
1613    $query.= '
1614    AND category_id NOT IN ('.implode(',', $categories).')
1615';
1616  }
1617
1618  $query.= '
1619    AND (storage_category_id IS NULL OR storage_category_id != category_id)
1620;';
1621  pwg_query($query);
1622
1623  if (is_array($categories) and count($categories) > 0)
1624  {
1625    associate_images_to_categories($images, $categories);
1626  }
1627}
1628
1629/**
1630 * Associate images associated to a list of source categories to a list of
1631 * destination categories.
1632 *
1633 * @param array sources
1634 * @param array destinations
1635 * @return void
1636 */
1637function associate_categories_to_categories($sources, $destinations)
1638{
1639  if (count($sources) == 0)
1640  {
1641    return false;
1642  }
1643
1644  $query = '
1645SELECT image_id
1646  FROM '.IMAGE_CATEGORY_TABLE.'
1647  WHERE category_id IN ('.implode(',', $sources).')
1648;';
1649  $images = array_from_query($query, 'image_id');
1650
1651  associate_images_to_categories($images, $destinations);
1652}
1653
1654/**
1655 * Refer main Piwigo URLs (currently PHPWG_DOMAIN domain)
1656 *
1657 * @param void
1658 * @return array like $conf['links']
1659 */
1660function pwg_URL()
1661{
1662  $urls = array(
1663    'HOME'       => PHPWG_URL,
1664    'WIKI'       => PHPWG_URL.'/doc',
1665    'DEMO'       => PHPWG_URL.'/demo',
1666    'FORUM'      => PHPWG_URL.'/forum',
1667    'BUGS'       => PHPWG_URL.'/bugs',
1668    'EXTENSIONS' => PHPWG_URL.'/ext',
1669    );
1670  return $urls;
1671}
1672
1673/**
1674 * Invalidates cahed data (permissions and category counts) for all users.
1675 */
1676function invalidate_user_cache($full = true)
1677{
1678  if ($full)
1679  {
1680    $query = '
1681TRUNCATE TABLE '.USER_CACHE_CATEGORIES_TABLE.';';
1682    pwg_query($query);
1683    $query = '
1684TRUNCATE TABLE '.USER_CACHE_TABLE.';';
1685    pwg_query($query);
1686  }
1687  else
1688  {
1689    $query = '
1690UPDATE '.USER_CACHE_TABLE.'
1691  SET need_update = \'true\';';
1692    pwg_query($query);
1693  }
1694  trigger_action('invalidate_user_cache', $full);
1695}
1696
1697/**
1698 * adds the caracter set to a create table sql query.
1699 * all CREATE TABLE queries must call this function
1700 * @param string query - the sql query
1701 */
1702function create_table_add_character_set($query)
1703{
1704  defined('DB_CHARSET') or fatal_error('create_table_add_character_set DB_CHARSET undefined');
1705  if ('DB_CHARSET'!='')
1706  {
1707    if ( version_compare(pwg_get_db_version(), '4.1.0', '<') )
1708    {
1709      return $query;
1710    }
1711    $charset_collate = " DEFAULT CHARACTER SET ".DB_CHARSET;
1712    if (DB_COLLATE!='')
1713    {
1714      $charset_collate .= " COLLATE ".DB_COLLATE;
1715    }
1716    if ( is_array($query) )
1717    {
1718      foreach( $query as $id=>$q)
1719      {
1720        $q=trim($q);
1721        $q=trim($q, ';');
1722        if (preg_match('/^CREATE\s+TABLE/i',$q))
1723        {
1724          $q.=$charset_collate;
1725        }
1726        $q .= ';';
1727        $query[$id] = $q;
1728      }
1729    }
1730    else
1731    {
1732      $query=trim($query);
1733      $query=trim($query, ';');
1734      if (preg_match('/^CREATE\s+TABLE/i',$query))
1735      {
1736        $query.=$charset_collate;
1737      }
1738      $query .= ';';
1739    }
1740  }
1741  return $query;
1742}
1743
1744/**
1745 * Returns array use on template with html_options method
1746 * @param Min and Max access to use
1747 * @return array of user access level
1748 */
1749function get_user_access_level_html_options($MinLevelAccess = ACCESS_FREE, $MaxLevelAccess = ACCESS_CLOSED)
1750{
1751  $tpl_options = array();
1752  for ($level = $MinLevelAccess; $level <= $MaxLevelAccess; $level++)
1753  {
1754    $tpl_options[$level] = l10n(sprintf('ACCESS_%d', $level));
1755  }
1756  return $tpl_options;
1757}
1758
1759/**
1760 * returns a list of templates currently available in template-extension
1761 * Each .tpl file is extracted from template-extension.
1762 * @return array
1763 */
1764function get_extents($start='')
1765{
1766  if ($start == '') { $start = './template-extension'; }
1767  $dir = opendir($start);
1768  $extents = array();
1769
1770  while (($file = readdir($dir)) !== false)
1771  {
1772    if ( $file == '.' or $file == '..' or $file == '.svn') continue;
1773    $path = $start . '/' . $file;
1774    if (is_dir($path))
1775    {
1776      $extents = array_merge($extents, get_extents($path));
1777    }
1778    elseif ( !is_link($path) and file_exists($path)
1779            and get_extension($path) == 'tpl' )
1780    {
1781      $extents[] = substr($path, 21);
1782    }
1783  }
1784  return $extents;
1785}
1786
1787function create_tag($tag_name)
1788{
1789  // does the tag already exists?
1790  $query = '
1791SELECT id
1792  FROM '.TAGS_TABLE.'
1793  WHERE name = \''.$tag_name.'\'
1794;';
1795  $existing_tags = array_from_query($query, 'id');
1796
1797  if (count($existing_tags) == 0)
1798  {
1799    mass_inserts(
1800      TAGS_TABLE,
1801      array('name', 'url_name'),
1802      array(
1803        array(
1804          'name' => $tag_name,
1805          'url_name' => trigger_event('render_tag_url', $tag_name),
1806          )
1807        )
1808      );
1809
1810    $inserted_id = pwg_db_insert_id(TAGS_TABLE);
1811
1812    return array(
1813      'info' => sprintf(
1814        l10n('Tag "%s" was added'),
1815        stripslashes($tag_name)
1816        ),
1817      'id' => $inserted_id,
1818      );
1819  }
1820  else
1821  {
1822    return array(
1823      'error' => sprintf(
1824        l10n('Tag "%s" already exists'),
1825        stripslashes($tag_name)
1826        )
1827      );
1828  }
1829}
1830
1831/**
1832 * Is the category accessible to the (Admin) user ?
1833 *
1834 * Note : if the user is not authorized to see this category, category jump
1835 * will be replaced by admin cat_modify page
1836 *
1837 * @param int category id to verify
1838 * @return bool
1839 */
1840function cat_admin_access($category_id)
1841{
1842  global $user;
1843
1844  // $filter['visible_categories'] and $filter['visible_images']
1845  // are not used because it's not necessary (filter <> restriction)
1846  if (in_array($category_id, explode(',', $user['forbidden_categories'])))
1847  {
1848    return false;
1849  }
1850  return true;
1851}
1852
1853/**
1854 * Retrieve data from external URL
1855 *
1856 * @param string $src: URL
1857 * @param global $dest: can be a file ressource or string
1858 * @return bool
1859 */
1860function fetchRemote($src, &$dest, $get_data=array(), $post_data=array(), $user_agent='Piwigo', $step=0)
1861{
1862  // Try to retrieve data from local file?
1863  if (!url_is_remote($src))
1864  {
1865    $content = @file_get_contents($src);
1866    if ($content !== false)
1867    {
1868      is_resource($dest) ? @fwrite($dest, $content) : $dest = $content;
1869      return true;
1870    }
1871    else
1872    {
1873      return false;
1874    }
1875  }
1876
1877  // After 3 redirections, return false
1878  if ($step > 3) return false;
1879
1880  // Initialization
1881  $method  = empty($post_data) ? 'GET' : 'POST';
1882  $request = empty($post_data) ? '' : http_build_query($post_data, '', '&');
1883  if (!empty($get_data))
1884  {
1885    $src .= strpos($src, '?') === false ? '?' : '&';
1886    $src .= http_build_query($get_data, '', '&');
1887  }
1888
1889  // Initialize $dest
1890  is_resource($dest) or $dest = '';
1891
1892  // Try curl to read remote file
1893  if (function_exists('curl_init'))
1894  {
1895    $ch = @curl_init();
1896    @curl_setopt($ch, CURLOPT_URL, $src);
1897    @curl_setopt($ch, CURLOPT_HEADER, 1);
1898    @curl_setopt($ch, CURLOPT_USERAGENT, $user_agent);
1899    @curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
1900    if ($method == 'POST')
1901    {
1902      @curl_setopt($ch, CURLOPT_POST, 1);
1903      @curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
1904    }
1905    $content = @curl_exec($ch);
1906    $header_length = @curl_getinfo($ch, CURLINFO_HEADER_SIZE);
1907    $status = @curl_getinfo($ch, CURLINFO_HTTP_CODE);
1908    @curl_close($ch);
1909    if ($content !== false and $status >= 200 and $status < 400)
1910    {
1911      if (preg_match('/Location:\s+?(.+)/', substr($content, 0, $header_length), $m))
1912      {
1913        return fetchRemote($m[1], $dest, array(), array(), $user_agent, $step+1);
1914      }
1915      $content = substr($content, $header_length);
1916      is_resource($dest) ? @fwrite($dest, $content) : $dest = $content;
1917      return true;
1918    }
1919  }
1920
1921  // Try file_get_contents to read remote file
1922  if (ini_get('allow_url_fopen'))
1923  {
1924    $opts = array(
1925      'http' => array(
1926        'method' => $method,
1927        'user_agent' => $user_agent,
1928      )
1929    );
1930    if ($method == 'POST')
1931    {
1932      $opts['http']['content'] = $request;
1933    }
1934    $context = @stream_context_create($opts);
1935    $content = @file_get_contents($src, false, $context);
1936    if ($content !== false)
1937    {
1938      is_resource($dest) ? @fwrite($dest, $content) : $dest = $content;
1939      return true;
1940    }
1941  }
1942
1943  // Try fsockopen to read remote file
1944  $src = parse_url($src);
1945  $host = $src['host'];
1946  $path = isset($src['path']) ? $src['path'] : '/';
1947  $path .= isset($src['query']) ? '?'.$src['query'] : '';
1948
1949  if (($s = @fsockopen($host,80,$errno,$errstr,5)) === false)
1950  {
1951    return false;
1952  }
1953
1954  $http_request  = $method." ".$path." HTTP/1.0\r\n";
1955  $http_request .= "Host: ".$host."\r\n";
1956  if ($method == 'POST')
1957  {
1958    $http_request .= "Content-Type: application/x-www-form-urlencoded;\r\n";
1959    $http_request .= "Content-Length: ".strlen($request)."\r\n";
1960  }
1961  $http_request .= "User-Agent: ".$user_agent."\r\n";
1962  $http_request .= "Accept: */*\r\n";
1963  $http_request .= "\r\n";
1964  $http_request .= $request;
1965
1966  fwrite($s, $http_request);
1967
1968  $i = 0;
1969  $in_content = false;
1970  while (!feof($s))
1971  {
1972    $line = fgets($s);
1973
1974    if (rtrim($line,"\r\n") == '' && !$in_content)
1975    {
1976      $in_content = true;
1977      $i++;
1978      continue;
1979    }
1980    if ($i == 0)
1981    {
1982      if (!preg_match('/HTTP\/(\\d\\.\\d)\\s*(\\d+)\\s*(.*)/',rtrim($line,"\r\n"), $m))
1983      {
1984        fclose($s);
1985        return false;
1986      }
1987      $status = (integer) $m[2];
1988      if ($status < 200 || $status >= 400)
1989      {
1990        fclose($s);
1991        return false;
1992      }
1993    }
1994    if (!$in_content)
1995    {
1996      if (preg_match('/Location:\s+?(.+)$/',rtrim($line,"\r\n"),$m))
1997      {
1998        fclose($s);
1999        return fetchRemote(trim($m[1]),$dest,array(),array(),$user_agent,$step+1);
2000      }
2001      $i++;
2002      continue;
2003    }
2004    is_resource($dest) ? @fwrite($dest, $line) : $dest .= $line;
2005    $i++;
2006  }
2007  fclose($s);
2008  return true;
2009}
2010
2011
2012/**
2013 * returns the groupname corresponding to the given group identifier if
2014 * exists
2015 *
2016 * @param int group_id
2017 * @return mixed
2018 */
2019function get_groupname($group_id)
2020{
2021  $query = '
2022SELECT name
2023  FROM '.GROUPS_TABLE.'
2024  WHERE id = '.intval($group_id).'
2025;';
2026  $result = pwg_query($query);
2027  if (pwg_db_num_rows($result) > 0)
2028  {
2029    list($groupname) = pwg_db_fetch_row($result);
2030  }
2031  else
2032  {
2033    return false;
2034  }
2035
2036  return $groupname;
2037}
2038
2039/**
2040 * returns the username corresponding to the given user identifier if exists
2041 *
2042 * @param int user_id
2043 * @return mixed
2044 */
2045function get_username($user_id)
2046{
2047  global $conf;
2048
2049  $query = '
2050SELECT '.$conf['user_fields']['username'].'
2051  FROM '.USERS_TABLE.'
2052  WHERE '.$conf['user_fields']['id'].' = '.intval($user_id).'
2053;';
2054  $result = pwg_query($query);
2055  if (pwg_db_num_rows($result) > 0)
2056  {
2057    list($username) = pwg_db_fetch_row($result);
2058  }
2059  else
2060  {
2061    return false;
2062  }
2063
2064  return stripslashes($username);
2065}
2066
2067function get_newsletter_subscribe_base_url($language) {
2068  return PHPWG_URL.'/announcement/subscribe/';
2069}
2070
2071/**
2072 * Accordion menus need to know which section to open by default when
2073 * loading the page
2074 */
2075function get_active_menu($menu_page)
2076{
2077  global $page;
2078
2079  if (isset($page['active_menu']))
2080  {
2081    return $page['active_menu'];
2082  }
2083
2084  switch ($menu_page)
2085  {
2086    case 'photo':
2087    case 'photos_add':
2088    case 'rating':
2089    case 'tags':
2090    case 'batch_manager':
2091      return 0;
2092
2093    case 'album':
2094    case 'cat_list':
2095    case 'cat_move':
2096    case 'cat_options':
2097    case 'permalinks':
2098      return 1;
2099
2100    case 'user_list':
2101    case 'user_perm':
2102    case 'group_list':
2103    case 'group_perm':
2104    case 'notification_by_mail':
2105      return 2;
2106
2107    case 'plugins':
2108    case 'plugin':
2109      return 3;
2110
2111    case 'site_manager':
2112    case 'site_update':
2113    case 'stats':
2114    case 'history':
2115    case 'maintenance':
2116    case 'comments':
2117    case 'updates':
2118      return 4;
2119
2120    case 'configuration':
2121    case 'derivatives':
2122    case 'extend_for_templates':
2123    case 'menubar':
2124    case 'themes':
2125    case 'theme':
2126    case 'languages':
2127      return 5;
2128  }
2129  return 0;
2130}
2131
2132/*
2133 * get tags list from SQL query (ids are surrounded by ~~, for get_tag_ids())
2134 * @param string: query
2135 * @param boolean: only_user_language, if true, only local name is returned for multilingual tags
2136 */
2137function get_taglist($query, $only_user_language=true)
2138{
2139  $result = pwg_query($query);
2140
2141  $taglist = array();
2142  $altlist = array();
2143  while ($row = pwg_db_fetch_assoc($result))
2144  {
2145    $raw_name = $row['name'];
2146    $name = trigger_event('render_tag_name', $raw_name);
2147
2148    $taglist[] =  array(
2149        'name' => $name,
2150        'id' => '~~'.$row['id'].'~~',
2151      );
2152
2153    if (!$only_user_language)
2154    {
2155      $alt_names = trigger_event('get_tag_alt_names', array(), $raw_name);
2156
2157      foreach( array_diff( array_unique($alt_names), array($name) ) as $alt)
2158      {
2159        $altlist[] =  array(
2160            'name' => $alt,
2161            'id' => '~~'.$row['id'].'~~',
2162          );
2163      }
2164    }
2165  }
2166
2167  usort($taglist, 'tag_alpha_compare');
2168  if (count($altlist))
2169  {
2170    usort($altlist, 'tag_alpha_compare');
2171    $taglist = array_merge($taglist, $altlist);
2172  }
2173
2174  return $taglist;
2175}
2176
2177/*
2178 * get tags ids from a list of raw tags (existing tags or new tags)
2179 * @param mixed: raw_tags, array or comma separated string
2180 * @param boolean: allow_create
2181 */
2182function get_tag_ids($raw_tags, $allow_create=true)
2183{
2184  // In $raw_tags we receive something like array('~~6~~', '~~59~~', 'New
2185  // tag', 'Another new tag') The ~~34~~ means that it is an existing
2186  // tag. I've added the surrounding ~~ to permit creation of tags like "10"
2187  // or "1234" (numeric characters only)
2188
2189  $tag_ids = array();
2190  if (!is_array($raw_tags))
2191  {
2192    $raw_tags = explode(',',$raw_tags);
2193  }
2194
2195  foreach ($raw_tags as $raw_tag)
2196  {
2197    if (preg_match('/^~~(\d+)~~$/', $raw_tag, $matches))
2198    {
2199      $tag_ids[] = $matches[1];
2200    }
2201    elseif ($allow_create)
2202    {
2203      // we have to create a new tag
2204      $tag_ids[] = tag_id_from_tag_name($raw_tag);
2205    }
2206  }
2207
2208  return $tag_ids;
2209}
2210
2211/** returns the argument_ids array with new sequenced keys based on related
2212 * names. Sequence is not case sensitive.
2213 * Warning: By definition, this function breaks original keys
2214 */
2215function order_by_name($element_ids,$name)
2216{
2217  $ordered_element_ids = array();
2218  foreach ($element_ids as $k_id => $element_id)
2219  {
2220    $key = strtolower($name[$element_id]) .'-'. $name[$element_id] .'-'. $k_id;
2221    $ordered_element_ids[$key] = $element_id;
2222  }
2223  ksort($ordered_element_ids);
2224  return $ordered_element_ids;
2225}
2226
2227function add_permission_on_category($category_ids, $user_ids)
2228{
2229  // array-ify categories and users
2230  if (!is_array($category_ids))
2231  {
2232    $category_ids = array($category_ids);
2233  }
2234
2235  if (!is_array($user_ids))
2236  {
2237    $user_ids = array($user_ids);
2238  }
2239
2240  // check for emptiness
2241  if (count($category_ids) == 0 or count($user_ids) == 0)
2242  {
2243    return;
2244  }
2245
2246  // make sure categories are private and select uppercats or subcats
2247  $cat_ids = (isset($_POST['apply_on_sub'])) ? implode(',', get_subcat_ids($category_ids)).",".implode(',', get_uppercat_ids($category_ids)) : implode(',', get_uppercat_ids($category_ids));
2248  $query = '
2249SELECT
2250    id
2251  FROM '.CATEGORIES_TABLE.'
2252  WHERE id IN ('.$cat_ids.')
2253    AND status = \'private\'
2254;';
2255  $private_cats = array_from_query($query, 'id');
2256
2257  if (count($private_cats) == 0)
2258  {
2259    return;
2260  }
2261
2262  // We must not reinsert already existing lines in user_access table
2263  $granteds = array();
2264  foreach ($private_cats as $cat_id)
2265  {
2266    $granteds[$cat_id] = array();
2267  }
2268
2269  $query = '
2270SELECT
2271    user_id,
2272    cat_id
2273  FROM '.USER_ACCESS_TABLE.'
2274  WHERE cat_id IN ('.implode(',', $private_cats).')
2275    AND user_id IN ('.implode(',', $user_ids).')
2276;';
2277  $result = pwg_query($query);
2278  while ($row = pwg_db_fetch_assoc($result))
2279  {
2280    array_push($granteds[$row['cat_id']], $row['user_id']);
2281  }
2282
2283  $inserts = array();
2284
2285  foreach ($private_cats as $cat_id)
2286  {
2287    $grant_to_users = array_diff($user_ids, $granteds[$cat_id]);
2288
2289    foreach ($grant_to_users as $user_id)
2290    {
2291      array_push(
2292        $inserts,
2293        array(
2294          'user_id' => $user_id,
2295          'cat_id' => $cat_id
2296          )
2297        );
2298    }
2299  }
2300
2301  if (count($inserts) > 0)
2302  {
2303    mass_inserts(USER_ACCESS_TABLE, array_keys($inserts[0]), $inserts);
2304  }
2305}
2306
2307
2308function get_admins($include_webmaster=true)
2309{
2310  $status_list = array('admin');
2311
2312  if ($include_webmaster)
2313  {
2314    $status_list[] = 'webmaster';
2315  }
2316
2317  $query = '
2318SELECT
2319    user_id
2320  FROM '.USER_INFOS_TABLE.'
2321  WHERE status in (\''.implode("','", $status_list).'\')
2322;';
2323
2324  return array_from_query($query, 'user_id');
2325}
2326
2327/** delete all derivative files for one or several types */
2328function clear_derivative_cache($types='all')
2329{
2330  if ($types === 'all')
2331  {
2332    $types = ImageStdParams::get_all_types();
2333    $types[] = IMG_CUSTOM;
2334  }
2335  elseif (!is_array($types))
2336  {
2337    $types = array($types);
2338  }
2339
2340  for ($i=0; $i<count($types); $i++)
2341  {
2342    $type = $types[$i];
2343    if ($type == IMG_CUSTOM)
2344    {
2345      $type = derivative_to_url($type).'[a-zA-Z0-9]+';
2346    }
2347    elseif (in_array($type, ImageStdParams::get_all_types()))
2348    {
2349      $type = derivative_to_url($type);
2350    }
2351    else
2352    {//assume a custom type
2353      $type = derivative_to_url(IMG_CUSTOM).'_'.$type;
2354    }
2355    $types[$i] = $type;
2356  }
2357
2358  $pattern='#.*-';
2359  if (count($types)>1)
2360  {
2361    $pattern .= '(' . implode('|',$types) . ')';
2362  }
2363  else
2364  {
2365    $pattern .= $types[0];
2366  }
2367  $pattern.='\.[a-zA-Z0-9]{3,4}$#';
2368
2369  if ($contents = @opendir(PHPWG_ROOT_PATH.PWG_DERIVATIVE_DIR))
2370  {
2371    while (($node = readdir($contents)) !== false)
2372    {
2373      if ($node != '.'
2374          and $node != '..'
2375          and is_dir(PHPWG_ROOT_PATH.PWG_DERIVATIVE_DIR.$node))
2376      {
2377        clear_derivative_cache_rec(PHPWG_ROOT_PATH.PWG_DERIVATIVE_DIR.$node, $pattern);
2378      }
2379    }
2380    closedir($contents);
2381  }
2382}
2383
2384function clear_derivative_cache_rec($path, $pattern)
2385{
2386  $rmdir = true;
2387  $rm_index = false;
2388
2389  if ($contents = opendir($path))
2390  {
2391    while (($node = readdir($contents)) !== false)
2392    {
2393      if ($node == '.' or $node == '..')
2394        continue;
2395      if (is_dir($path.'/'.$node))
2396      {
2397        $rmdir &= clear_derivative_cache_rec($path.'/'.$node, $pattern);
2398      }
2399      else
2400      {
2401        if (preg_match($pattern, $node))
2402        {
2403          unlink($path.'/'.$node);
2404        }
2405        elseif ($node=='index.htm')
2406        {
2407          $rm_index = true;
2408        }
2409        else
2410        {
2411          $rmdir = false;
2412        }
2413      }
2414    }
2415    closedir($contents);
2416
2417    if ($rmdir)
2418    {
2419      if ($rm_index)
2420      {
2421        unlink($path.'/index.htm');
2422      }
2423      clearstatcache();
2424      @rmdir($path);
2425    }
2426    return $rmdir;
2427  }
2428}
2429
2430function delete_element_derivatives($infos, $type='all')
2431{
2432  $path = $infos['path'];
2433  if (!empty($infos['representative_ext']))
2434  {
2435    $path = original_to_representative( $path, $infos['representative_ext']);
2436  }
2437  if (substr_compare($path, '../', 0, 3)==0)
2438  {
2439    $path = substr($path, 3);
2440  }
2441  $dot = strrpos($path, '.');
2442  if ($type=='all')
2443  {
2444    $pattern = '-*';
2445  }
2446  else
2447  {
2448    $pattern = '-'.derivative_to_url($type).'*';
2449  }
2450  $path = substr_replace($path, $pattern, $dot, 0);
2451  if ( ($glob=glob(PHPWG_ROOT_PATH.PWG_DERIVATIVE_DIR.$path)) !== false)
2452  {
2453    foreach( $glob as $file)
2454    {
2455      @unlink($file);
2456    }
2457  }
2458}
2459
2460/**
2461 * returns an array contening sub-directories, excluding ".svn"
2462 *
2463 * @param string $dir
2464 * @return array
2465 */
2466function get_dirs($directory)
2467{
2468  $sub_dirs = array();
2469  if ($opendir = opendir($directory))
2470  {
2471    while ($file = readdir($opendir))
2472    {
2473      if ($file != '.'
2474          and $file != '..'
2475          and is_dir($directory.'/'.$file)
2476          and $file != '.svn')
2477      {
2478        array_push($sub_dirs, $file);
2479      }
2480    }
2481    closedir($opendir);
2482  }
2483  return $sub_dirs;
2484}
2485?>
Note: See TracBrowser for help on using the repository browser.