source: branches/2.6/admin/include/functions.php @ 26904

Revision 26904, 58.9 KB checked in by mistic100, 5 years ago (diff)

bug 2989: Deprecated: preg_replace(): The /e modifier is deprecated

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