source: trunk/include/functions_user.inc.php @ 12670

Last change on this file since 12670 was 12670, checked in by rvelices, 9 years ago

removed unused css rules

  • Property svn:eol-style set to LF
File size: 36.5 KB
Line 
1<?php
2// +-----------------------------------------------------------------------+
3// | Piwigo - a PHP based photo gallery                                    |
4// +-----------------------------------------------------------------------+
5// | Copyright(C) 2008-2011 Piwigo Team                  http://piwigo.org |
6// | Copyright(C) 2003-2008 PhpWebGallery Team    http://phpwebgallery.net |
7// | Copyright(C) 2002-2003 Pierrick LE GALL   http://le-gall.net/pierrick |
8// +-----------------------------------------------------------------------+
9// | This program is free software; you can redistribute it and/or modify  |
10// | it under the terms of the GNU General Public License as published by  |
11// | the Free Software Foundation                                          |
12// |                                                                       |
13// | This program is distributed in the hope that it will be useful, but   |
14// | WITHOUT ANY WARRANTY; without even the implied warranty of            |
15// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      |
16// | General Public License for more details.                              |
17// |                                                                       |
18// | You should have received a copy of the GNU General Public License     |
19// | along with this program; if not, write to the Free Software           |
20// | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
21// | USA.                                                                  |
22// +-----------------------------------------------------------------------+
23
24// validate_mail_address:
25//   o verifies whether the given mail address has the
26//     right format. ie someone@domain.com "someone" can contain ".", "-" or
27//     even "_". Exactly as "domain". The extension doesn't have to be
28//     "com". The mail address can also be empty.
29//   o check if address could be empty
30//   o check if address is not used by a other user
31// If the mail address doesn't correspond, an error message is returned.
32//
33function validate_mail_address($user_id, $mail_address)
34{
35  global $conf;
36
37  if (empty($mail_address) and
38      !($conf['obligatory_user_mail_address'] and
39      in_array(script_basename(), array('register', 'profile'))))
40  {
41    return '';
42  }
43
44  $atom   = '[-a-z0-9!#$%&\'*+\\/=?^_`{|}~]';   // before  arobase
45  $domain = '([a-z0-9]([-a-z0-9]*[a-z0-9]+)?)'; // domain name
46  $regex = '/^' . $atom . '+' . '(\.' . $atom . '+)*' . '@' . '(' . $domain . '{1,63}\.)+' . $domain . '{2,63}$/i';
47
48  if ( !preg_match( $regex, $mail_address ) )
49  {
50    return l10n('mail address must be like xxx@yyy.eee (example : jack@altern.org)');
51  }
52
53  if (defined("PHPWG_INSTALLED") and !empty($mail_address))
54  {
55    $query = '
56select count(*)
57from '.USERS_TABLE.'
58where upper('.$conf['user_fields']['email'].') = upper(\''.$mail_address.'\')
59'.(is_numeric($user_id) ? 'and '.$conf['user_fields']['id'].' != \''.$user_id.'\'' : '').'
60;';
61    list($count) = pwg_db_fetch_row(pwg_query($query));
62    if ($count != 0)
63    {
64      return l10n('this email address is already in use');
65    }
66  }
67}
68
69// validate_login_case:
70//   o check if login is not used by a other user
71// If the login doesn't correspond, an error message is returned.
72//
73function validate_login_case($login)
74{
75  global $conf;
76 
77  if (defined("PHPWG_INSTALLED"))
78  {
79    $query = "
80SELECT ".$conf['user_fields']['username']."
81FROM ".USERS_TABLE."
82WHERE LOWER(".stripslashes($conf['user_fields']['username']).") = '".strtolower($login)."'
83;";
84
85    $count = pwg_db_num_rows(pwg_query($query));
86
87    if ($count > 0)
88    {
89      return l10n('this login is already used');
90    }
91  }
92}
93/**
94 * For test on username case sensitivity
95 *
96 * @param : $username typed in by user for identification
97 *
98 * @return : $username found in database
99 *
100 */
101function search_case_username($username)
102{
103  global $conf;
104
105  $username_lo = strtolower($username);
106
107  $SCU_users = array();
108 
109  $q = pwg_query("
110    SELECT ".$conf['user_fields']['username']." AS username
111    FROM `".USERS_TABLE."`;
112  ");
113  while ($r = pwg_db_fetch_assoc($q))
114   $SCU_users[$r['username']] = strtolower($r['username']);
115   // $SCU_users is now an associative table where the key is the account as
116   // registered in the DB, and the value is this same account, in lower case
117   
118  $users_found = array_keys($SCU_users, $username_lo);
119  // $users_found is now a table of which the values are all the accounts
120  // which can be written in lowercase the same way as $username
121  if (count($users_found) != 1) // If ambiguous, don't allow lowercase writing
122   return $username; // but normal writing will work
123  else
124   return $users_found[0];
125}
126function register_user($login, $password, $mail_address,
127  $with_notification = true, $errors = array())
128{
129  global $conf;
130
131  if ($login == '')
132  {
133    array_push($errors, l10n('Please, enter a login'));
134  }
135  if (preg_match('/^.* $/', $login))
136  {
137    array_push($errors, l10n('login mustn\'t end with a space character'));
138  }
139  if (preg_match('/^ .*$/', $login))
140  {
141    array_push($errors, l10n('login mustn\'t start with a space character'));
142  }
143  if (get_userid($login))
144  {
145    array_push($errors, l10n('this login is already used'));
146  }
147  if ($login != strip_tags($login))
148  {
149    array_push($errors, l10n('html tags are not allowed in login'));
150  }
151  $mail_error = validate_mail_address(null, $mail_address);
152  if ('' != $mail_error)
153  {
154    array_push($errors, $mail_error);
155  }
156
157  if ($conf['insensitive_case_logon'] == true)
158  {
159    $login_error = validate_login_case($login);
160    if ($login_error != '')
161    {
162      array_push($errors, $login_error);
163    }
164  }
165
166  $errors = trigger_event('register_user_check',
167              $errors,
168              array(
169                'username'=>$login,
170                'password'=>$password,
171                'email'=>$mail_address,
172              )
173            );
174
175  // if no error until here, registration of the user
176  if (count($errors) == 0)
177  {
178    // what will be the inserted id ?
179    $query = '
180SELECT MAX('.$conf['user_fields']['id'].') + 1
181  FROM '.USERS_TABLE.'
182;';
183    list($next_id) = pwg_db_fetch_row(pwg_query($query));
184
185    $insert =
186      array(
187        $conf['user_fields']['id'] => $next_id,
188        $conf['user_fields']['username'] => pwg_db_real_escape_string($login),
189        $conf['user_fields']['password'] => $conf['pass_convert']($password),
190        $conf['user_fields']['email'] => $mail_address
191        );
192
193    mass_inserts(USERS_TABLE, array_keys($insert), array($insert));
194
195    // Assign by default groups
196    {
197      $query = '
198SELECT id
199  FROM '.GROUPS_TABLE.'
200  WHERE is_default = \''.boolean_to_string(true).'\'
201  ORDER BY id ASC
202;';
203      $result = pwg_query($query);
204
205      $inserts = array();
206      while ($row = pwg_db_fetch_assoc($result))
207      {
208        array_push
209        (
210          $inserts,
211          array
212          (
213            'user_id' => $next_id,
214            'group_id' => $row['id']
215          )
216        );
217      }
218    }
219
220    if (count($inserts) != 0)
221    {
222      mass_inserts(USER_GROUP_TABLE, array('user_id', 'group_id'), $inserts);
223    }
224
225    $override = null;
226    if ($with_notification and $conf['browser_language'])
227    {
228      if ( !get_browser_language($override['language']) )
229        $override=null;
230    }
231    create_user_infos($next_id, $override);
232
233    if ($with_notification and $conf['email_admin_on_new_user'])
234    {
235      include_once(PHPWG_ROOT_PATH.'include/functions_mail.inc.php');
236      $admin_url = get_absolute_root_url()
237                   .'admin.php?page=user_list&username='.$login;
238
239      $keyargs_content = array
240      (
241        get_l10n_args('User: %s', stripslashes($login)),
242        get_l10n_args('Email: %s', $_POST['mail_address']),
243        get_l10n_args('', ''),
244        get_l10n_args('Admin: %s', $admin_url)
245      );
246
247      pwg_mail_notification_admins
248      (
249        get_l10n_args('Registration of %s', stripslashes($login)),
250        $keyargs_content
251      );
252    }
253
254    trigger_action('register_user',
255      array(
256        'id'=>$next_id,
257        'username'=>$login,
258        'email'=>$mail_address,
259       )
260      );
261  }
262
263  return $errors;
264}
265
266function build_user( $user_id, $use_cache )
267{
268  global $conf;
269
270  $user['id'] = $user_id;
271  $user = array_merge( $user, getuserdata($user_id, $use_cache) );
272
273  if ($user['id'] == $conf['guest_id'] and $user['status'] <> 'guest')
274  {
275    $user['status'] = 'guest';
276    $user['internal_status']['guest_must_be_guest'] = true;
277  }
278
279  // Check user theme
280  if (!isset($user['theme_name']))
281  {
282    $user['theme'] = get_default_theme();
283  }
284
285  return $user;
286}
287
288/**
289 * find informations related to the user identifier
290 *
291 * @param int user identifier
292 * @param boolean use_cache
293 * @param array
294 */
295function getuserdata($user_id, $use_cache)
296{
297  global $conf;
298
299  $userdata = array();
300
301  // retrieve basic user data
302  $query = '
303SELECT ';
304  $is_first = true;
305  foreach ($conf['user_fields'] as $pwgfield => $dbfield)
306  {
307    if ($is_first)
308    {
309      $is_first = false;
310    }
311    else
312    {
313      $query.= '
314     , ';
315    }
316    $query.= $dbfield.' AS '.$pwgfield;
317  }
318  $query.= '
319  FROM '.USERS_TABLE.'
320  WHERE '.$conf['user_fields']['id'].' = \''.$user_id.'\'';
321
322  $row = pwg_db_fetch_assoc(pwg_query($query));
323
324  // retrieve additional user data ?
325  if ($conf['external_authentification'])
326  {
327    $query = '
328SELECT
329    COUNT(1) AS counter
330  FROM '.USER_INFOS_TABLE.' AS ui
331    LEFT JOIN '.USER_CACHE_TABLE.' AS uc ON ui.user_id = uc.user_id
332    LEFT JOIN '.THEMES_TABLE.' AS t ON t.id = ui.theme
333  WHERE ui.user_id = '.$user_id.'
334  GROUP BY ui.user_id
335;';
336    list($counter) = pwg_db_fetch_row(pwg_query($query));
337    if ($counter != 1)
338    {
339      create_user_infos($user_id);
340    }
341  }
342
343  // retrieve user info
344  $query = '
345SELECT
346    ui.*,
347    uc.*,
348    t.name AS theme_name
349  FROM '.USER_INFOS_TABLE.' AS ui
350    LEFT JOIN '.USER_CACHE_TABLE.' AS uc ON ui.user_id = uc.user_id
351    LEFT JOIN '.THEMES_TABLE.' AS t ON t.id = ui.theme
352  WHERE ui.user_id = '.$user_id.'
353;';
354
355  $result = pwg_query($query);
356  $user_infos_row = pwg_db_fetch_assoc($result);
357
358  // then merge basic + additional user data
359  $row = array_merge($row, $user_infos_row);
360
361  foreach ($row as $key => $value)
362  {
363    if (!is_numeric($key))
364    {
365      // If the field is true or false, the variable is transformed into a
366      // boolean value.
367      if ($value == 'true' or $value == 'false')
368      {
369        $userdata[$key] = get_boolean($value);
370      }
371      else
372      {
373        $userdata[$key] = $value;
374      }
375    }
376  }
377
378  if ($use_cache)
379  {
380    if (!isset($userdata['need_update'])
381        or !is_bool($userdata['need_update'])
382        or $userdata['need_update'] == true)
383    {
384      $userdata['cache_update_time'] = time();
385
386      // Set need update are done
387      $userdata['need_update'] = false;
388
389      $userdata['forbidden_categories'] =
390        calculate_permissions($userdata['id'], $userdata['status']);
391
392      /* now we build the list of forbidden images (this list does not contain
393      images that are not in at least an authorized category)*/
394      $query = '
395SELECT DISTINCT(id)
396  FROM '.IMAGES_TABLE.' INNER JOIN '.IMAGE_CATEGORY_TABLE.' ON id=image_id
397  WHERE category_id NOT IN ('.$userdata['forbidden_categories'].')
398    AND level>'.$userdata['level'];
399      $forbidden_ids = array_from_query($query, 'id');
400
401      if ( empty($forbidden_ids) )
402      {
403        array_push( $forbidden_ids, 0 );
404      }
405      $userdata['image_access_type'] = 'NOT IN'; //TODO maybe later
406      $userdata['image_access_list'] = implode(',',$forbidden_ids);
407
408
409      $query = '
410SELECT COUNT(DISTINCT(image_id)) as total
411  FROM '.IMAGE_CATEGORY_TABLE.'
412  WHERE category_id NOT IN ('.$userdata['forbidden_categories'].')
413    AND image_id '.$userdata['image_access_type'].' ('.$userdata['image_access_list'].')';
414      list($userdata['nb_total_images']) = pwg_db_fetch_row(pwg_query($query));
415
416
417      // now we update user cache categories
418      $user_cache_cats = get_computed_categories($userdata, null);
419      if ( !is_admin($userdata['status']) )
420      { // for non admins we forbid categories with no image (feature 1053)
421        $forbidden_ids = array();
422        foreach ($user_cache_cats as $cat)
423        {
424          if ($cat['count_images']==0)
425          {
426            array_push($forbidden_ids, $cat['cat_id']);
427            unset( $user_cache_cats[$cat['cat_id']] );
428          }
429        }
430        if ( !empty($forbidden_ids) )
431        {
432          if ( empty($userdata['forbidden_categories']) )
433          {
434            $userdata['forbidden_categories'] = implode(',', $forbidden_ids);
435          }
436          else
437          {
438            $userdata['forbidden_categories'] .= ','.implode(',', $forbidden_ids);
439          }
440        }
441      }
442
443      // delete user cache
444      $query = '
445DELETE FROM '.USER_CACHE_CATEGORIES_TABLE.'
446  WHERE user_id = '.$userdata['id'];
447      pwg_query($query);
448
449      mass_inserts
450      (
451        USER_CACHE_CATEGORIES_TABLE,
452        array
453        (
454          'user_id', 'cat_id',
455          'date_last', 'max_date_last', 'nb_images', 'count_images', 'count_categories'
456        ),
457        $user_cache_cats
458      );
459
460
461      // update user cache
462      $query = '
463DELETE FROM '.USER_CACHE_TABLE.'
464  WHERE user_id = '.$userdata['id'];
465      pwg_query($query);
466
467      $query = '
468INSERT INTO '.USER_CACHE_TABLE.'
469  (user_id, need_update, cache_update_time, forbidden_categories, nb_total_images,
470    image_access_type, image_access_list)
471  VALUES
472  ('.$userdata['id'].',\''.boolean_to_string($userdata['need_update']).'\','
473  .$userdata['cache_update_time'].',\''
474  .$userdata['forbidden_categories'].'\','.$userdata['nb_total_images'].',\''
475  .$userdata['image_access_type'].'\',\''.$userdata['image_access_list'].'\')';
476      pwg_query($query);
477    }
478  }
479
480  return $userdata;
481}
482
483/*
484 * deletes favorites of the current user if he's not allowed to see them
485 *
486 * @return void
487 */
488function check_user_favorites()
489{
490  global $user;
491
492  if ($user['forbidden_categories'] == '')
493  {
494    return;
495  }
496
497  // $filter['visible_categories'] and $filter['visible_images']
498  // must be not used because filter <> restriction
499  // retrieving images allowed : belonging to at least one authorized
500  // category
501  $query = '
502SELECT DISTINCT f.image_id
503  FROM '.FAVORITES_TABLE.' AS f INNER JOIN '.IMAGE_CATEGORY_TABLE.' AS ic
504    ON f.image_id = ic.image_id
505  WHERE f.user_id = '.$user['id'].'
506'.get_sql_condition_FandF
507  (
508    array
509      (
510        'forbidden_categories' => 'ic.category_id',
511      ),
512    'AND'
513  ).'
514;';
515  $result = pwg_query($query);
516  $authorizeds = array();
517  while ($row = pwg_db_fetch_assoc($result))
518  {
519    array_push($authorizeds, $row['image_id']);
520  }
521
522  $query = '
523SELECT image_id
524  FROM '.FAVORITES_TABLE.'
525  WHERE user_id = '.$user['id'].'
526;';
527  $result = pwg_query($query);
528  $favorites = array();
529  while ($row = pwg_db_fetch_assoc($result))
530  {
531    array_push($favorites, $row['image_id']);
532  }
533
534  $to_deletes = array_diff($favorites, $authorizeds);
535
536  if (count($to_deletes) > 0)
537  {
538    $query = '
539DELETE FROM '.FAVORITES_TABLE.'
540  WHERE image_id IN ('.implode(',', $to_deletes).')
541    AND user_id = '.$user['id'].'
542;';
543    pwg_query($query);
544  }
545}
546
547/**
548 * calculates the list of forbidden categories for a given user
549 *
550 * Calculation is based on private categories minus categories authorized to
551 * the groups the user belongs to minus the categories directly authorized
552 * to the user. The list contains at least -1 to be compliant with queries
553 * such as "WHERE category_id NOT IN ($forbidden_categories)"
554 *
555 * @param int user_id
556 * @param string user_status
557 * @return string forbidden_categories
558 */
559function calculate_permissions($user_id, $user_status)
560{
561  $private_array = array();
562  $authorized_array = array();
563
564  $query = '
565SELECT id
566  FROM '.CATEGORIES_TABLE.'
567  WHERE status = \'private\'
568;';
569  $result = pwg_query($query);
570  while ($row = pwg_db_fetch_assoc($result))
571  {
572    array_push($private_array, $row['id']);
573  }
574
575  // retrieve category ids directly authorized to the user
576  $query = '
577SELECT cat_id
578  FROM '.USER_ACCESS_TABLE.'
579  WHERE user_id = '.$user_id.'
580;';
581  $authorized_array = array_from_query($query, 'cat_id');
582
583  // retrieve category ids authorized to the groups the user belongs to
584  $query = '
585SELECT cat_id
586  FROM '.USER_GROUP_TABLE.' AS ug INNER JOIN '.GROUP_ACCESS_TABLE.' AS ga
587    ON ug.group_id = ga.group_id
588  WHERE ug.user_id = '.$user_id.'
589;';
590  $authorized_array =
591    array_merge(
592      $authorized_array,
593      array_from_query($query, 'cat_id')
594      );
595
596  // uniquify ids : some private categories might be authorized for the
597  // groups and for the user
598  $authorized_array = array_unique($authorized_array);
599
600  // only unauthorized private categories are forbidden
601  $forbidden_array = array_diff($private_array, $authorized_array);
602
603  // if user is not an admin, locked categories are forbidden
604  if (!is_admin($user_status))
605  {
606    $query = '
607SELECT id
608  FROM '.CATEGORIES_TABLE.'
609  WHERE visible = \'false\'
610;';
611    $result = pwg_query($query);
612    while ($row = pwg_db_fetch_assoc($result))
613    {
614      array_push($forbidden_array, $row['id']);
615    }
616    $forbidden_array = array_unique($forbidden_array);
617  }
618
619  if ( empty($forbidden_array) )
620  {// at least, the list contains 0 value. This category does not exists so
621   // where clauses such as "WHERE category_id NOT IN(0)" will always be
622   // true.
623    array_push($forbidden_array, 0);
624  }
625
626  return implode(',', $forbidden_array);
627}
628
629/**
630 * compute data of categories branches (one branch only)
631 */
632function compute_branch_cat_data(&$cats, &$list_cat_id, &$level, &$ref_level)
633{
634  $date = '';
635  $count_images = 0;
636  $count_categories = 0;
637  do
638  {
639    $cat_id = array_pop($list_cat_id);
640    if (!is_null($cat_id))
641    {
642      // Count images and categories
643      $cats[$cat_id]['count_images'] += $count_images;
644      $cats[$cat_id]['count_categories'] += $count_categories;
645      $count_images = $cats[$cat_id]['count_images'];
646      $count_categories = $cats[$cat_id]['count_categories'] + 1;
647
648      if ((empty($cats[$cat_id]['max_date_last'])) or ($cats[$cat_id]['max_date_last'] < $date))
649      {
650        $cats[$cat_id]['max_date_last'] = $date;
651      }
652      else
653      {
654        $date = $cats[$cat_id]['max_date_last'];
655      }
656      $ref_level = substr_count($cats[$cat_id]['global_rank'], '.') + 1;
657    }
658    else
659    {
660      $ref_level = 0;
661    }
662  } while ($level <= $ref_level);
663
664  // Last cat updating must be added to list for next branch
665  if ($ref_level <> 0)
666  {
667    array_push($list_cat_id, $cat_id);
668  }
669}
670
671/**
672 * compute data of categories branches
673 */
674function compute_categories_data(&$cats)
675{
676  $ref_level = 0;
677  $level = 0;
678  $list_cat_id = array();
679
680  foreach ($cats as $id => $category)
681  {
682    // Compute
683    $level = substr_count($category['global_rank'], '.') + 1;
684    if ($level > $ref_level)
685    {
686      array_push($list_cat_id, $id);
687    }
688    else
689    {
690      compute_branch_cat_data($cats, $list_cat_id, $level, $ref_level);
691      array_push($list_cat_id, $id);
692    }
693    $ref_level = $level;
694  }
695
696  $level = 1;
697  compute_branch_cat_data($cats, $list_cat_id, $level, $ref_level);
698}
699
700/**
701 * get computed array of categories
702 *
703 * @param array userdata
704 * @param int filter_days number of recent days to filter on or null
705 * @return array
706 */
707function get_computed_categories($userdata, $filter_days=null)
708{
709  $query = 'SELECT c.id AS cat_id, global_rank';
710  // Count by date_available to avoid count null
711  $query .= ',
712  MAX(date_available) AS date_last, COUNT(date_available) AS nb_images
713FROM '.CATEGORIES_TABLE.' as c
714  LEFT JOIN '.IMAGE_CATEGORY_TABLE.' AS ic ON ic.category_id = c.id
715  LEFT JOIN '.IMAGES_TABLE.' AS i
716    ON ic.image_id = i.id
717      AND i.level<='.$userdata['level'];
718
719  if ( isset($filter_days) )
720  {
721    $query .= ' AND i.date_available > '.pwg_db_get_recent_period_expression($filter_days);
722  }
723
724  if ( !empty($userdata['forbidden_categories']) )
725  {
726    $query.= '
727  WHERE c.id NOT IN ('.$userdata['forbidden_categories'].')';
728  }
729
730  $query.= '
731  GROUP BY c.id, c.global_rank';
732
733  $result = pwg_query($query);
734
735  $cats = array();
736  while ($row = pwg_db_fetch_assoc($result))
737  {
738    $row['user_id'] = $userdata['id'];
739    $row['count_categories'] = 0;
740    $row['count_images'] = (int)$row['nb_images'];
741    $row['max_date_last'] = $row['date_last'];
742
743    $cats += array($row['cat_id'] => $row);
744  }
745  uasort($cats, 'global_rank_compare');
746
747  compute_categories_data($cats);
748
749  if ( isset($filter_days) )
750  {
751    $cat_tmp = $cats;
752    $cats = array();
753
754    foreach ($cat_tmp as $category)
755    {
756      if (!empty($category['max_date_last']))
757      {
758        // Re-init counters
759        $category['count_categories'] = 0;
760        $category['count_images'] = (int)$category['nb_images'];
761        // Keep category
762        $cats[$category['cat_id']] = $category;
763      }
764    }
765    // Compute a second time
766    compute_categories_data($cats);
767  }
768  return $cats;
769}
770
771/**
772 * returns user identifier thanks to his name, false if not found
773 *
774 * @param string username
775 * @param int user identifier
776 */
777function get_userid($username)
778{
779  global $conf;
780
781  $username = pwg_db_real_escape_string($username);
782
783  $query = '
784SELECT '.$conf['user_fields']['id'].'
785  FROM '.USERS_TABLE.'
786  WHERE '.$conf['user_fields']['username'].' = \''.$username.'\'
787;';
788  $result = pwg_query($query);
789
790  if (pwg_db_num_rows($result) == 0)
791  {
792    return false;
793  }
794  else
795  {
796    list($user_id) = pwg_db_fetch_row($result);
797    return $user_id;
798  }
799}
800
801function get_userid_by_email($email)
802{
803  global $conf;
804
805  $email = pwg_db_real_escape_string($email);
806 
807  $query = '
808SELECT
809    '.$conf['user_fields']['id'].'
810  FROM '.USERS_TABLE.'
811  WHERE UPPER('.$conf['user_fields']['email'].') = UPPER(\''.$email.'\')
812;';
813  $result = pwg_query($query);
814
815  if (pwg_db_num_rows($result) == 0)
816  {
817    return false;
818  }
819  else
820  {
821    list($user_id) = pwg_db_fetch_row($result);
822    return $user_id;
823  }
824}
825
826/**
827 * search an available feed_id
828 *
829 * @return string feed identifier
830 */
831function find_available_feed_id()
832{
833  while (true)
834  {
835    $key = generate_key(50);
836    $query = '
837SELECT COUNT(*)
838  FROM '.USER_FEED_TABLE.'
839  WHERE id = \''.$key.'\'
840;';
841    list($count) = pwg_db_fetch_row(pwg_query($query));
842    if (0 == $count)
843    {
844      return $key;
845    }
846  }
847}
848
849/*
850 * Returns a array with default user value
851 *
852 * @param convert_str allows to convert string value if necessary
853 */
854function get_default_user_info($convert_str = true)
855{
856  global $cache, $conf;
857
858  if (!isset($cache['default_user']))
859  {
860    $query = 'SELECT * FROM '.USER_INFOS_TABLE.
861            ' WHERE user_id = '.$conf['default_user_id'].';';
862
863    $result = pwg_query($query);
864    $cache['default_user'] = pwg_db_fetch_assoc($result);
865
866    if ($cache['default_user'] !== false)
867    {
868      unset($cache['default_user']['user_id']);
869      unset($cache['default_user']['status']);
870      unset($cache['default_user']['registration_date']);
871    }
872  }
873
874  if (is_array($cache['default_user']) and $convert_str)
875  {
876    $default_user = array();
877    foreach ($cache['default_user'] as $name => $value)
878    {
879      // If the field is true or false, the variable is transformed into a
880      // boolean value.
881      if ($value == 'true' or $value == 'false')
882      {
883        $default_user[$name] = get_boolean($value);
884      }
885      else
886      {
887        $default_user[$name] = $value;
888      }
889    }
890    return $default_user;
891  }
892  else
893  {
894    return $cache['default_user'];
895  }
896}
897
898/*
899 * Returns a default user value
900 *
901 * @param value_name: name of value
902 * @param sos_value: value used if don't exist value
903 */
904function get_default_user_value($value_name, $sos_value)
905{
906  $default_user = get_default_user_info(true);
907  if ($default_user === false or empty($default_user[$value_name]))
908  {
909    return $sos_value;
910  }
911  else
912  {
913   return $default_user[$value_name];
914  }
915}
916
917/*
918 * Returns the default template value
919 *
920 */
921function get_default_theme()
922{
923  $theme = get_default_user_value('theme', PHPWG_DEFAULT_TEMPLATE);
924  if (check_theme_installed($theme))
925  {
926    return $theme;
927  }
928 
929  // let's find the first available theme
930  $active_themes = get_pwg_themes();
931  foreach (array_keys(get_pwg_themes()) as $theme_id)
932  {
933    return $theme_id;
934  }
935}
936
937/*
938 * Returns the default language value
939 *
940 */
941function get_default_language()
942{
943  return get_default_user_value('language', PHPWG_DEFAULT_LANGUAGE);
944}
945
946/**
947  * Returns true if the browser language value is set into param $lang
948  *
949  */
950function get_browser_language(&$lang)
951{
952  $browser_language = substr(@$_SERVER["HTTP_ACCEPT_LANGUAGE"], 0, 2);
953  foreach (get_languages() as $language_code => $language_name)
954  {
955    if (substr($language_code, 0, 2) == $browser_language)
956    {
957      $lang = $language_code;
958      return true;
959    }
960  }
961  return false;
962}
963
964/**
965 * add user informations based on default values
966 *
967 * @param int user_id / array of user_if
968 * @param array of values used to override default user values
969 */
970function create_user_infos($arg_id, $override_values = null)
971{
972  global $conf;
973
974  if (is_array($arg_id))
975  {
976    $user_ids = $arg_id;
977  }
978  else
979  {
980    $user_ids = array();
981    if (is_numeric($arg_id))
982    {
983      $user_ids[] = $arg_id;
984    }
985  }
986
987  if (!empty($user_ids))
988  {
989    $inserts = array();
990    list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
991
992    $default_user = get_default_user_info(false);
993    if ($default_user === false)
994    {
995      // Default on structure are used
996      $default_user = array();
997    }
998
999    if (!is_null($override_values))
1000    {
1001      $default_user = array_merge($default_user, $override_values);
1002    }
1003
1004    foreach ($user_ids as $user_id)
1005    {
1006      $level= isset($default_user['level']) ? $default_user['level'] : 0;
1007      if ($user_id == $conf['webmaster_id'])
1008      {
1009        $status = 'webmaster';
1010        $level = max( $conf['available_permission_levels'] );
1011      }
1012      else if (($user_id == $conf['guest_id']) or
1013               ($user_id == $conf['default_user_id']))
1014      {
1015        $status = 'guest';
1016      }
1017      else
1018      {
1019        $status = 'normal';
1020      }
1021
1022      $insert = array_merge(
1023        $default_user,
1024        array(
1025          'user_id' => $user_id,
1026          'status' => $status,
1027          'registration_date' => $dbnow,
1028          'level' => $level
1029          ));
1030
1031      array_push($inserts, $insert);
1032    }
1033
1034    mass_inserts(USER_INFOS_TABLE, array_keys($inserts[0]), $inserts);
1035  }
1036}
1037
1038/**
1039 * returns the auto login key or false on error
1040 * @param int user_id
1041 * @param time_t time
1042 * @param string [out] username
1043*/
1044function calculate_auto_login_key($user_id, $time, &$username)
1045{
1046  global $conf;
1047  $query = '
1048SELECT '.$conf['user_fields']['username'].' AS username
1049  , '.$conf['user_fields']['password'].' AS password
1050FROM '.USERS_TABLE.'
1051WHERE '.$conf['user_fields']['id'].' = '.$user_id;
1052  $result = pwg_query($query);
1053  if (pwg_db_num_rows($result) > 0)
1054  {
1055    $row = pwg_db_fetch_assoc($result);
1056    $username = stripslashes($row['username']);
1057    $data = $time.$user_id.$username;
1058    $key = base64_encode( hash_hmac('sha1', $data, $conf['secret_key'].$row['password'],true) );
1059    return $key;
1060  }
1061  return false;
1062}
1063
1064/*
1065 * Performs all required actions for user login
1066 * @param int user_id
1067 * @param bool remember_me
1068 * @return void
1069*/
1070function log_user($user_id, $remember_me)
1071{
1072  global $conf, $user;
1073
1074  if ($remember_me and $conf['authorize_remembering'])
1075  {
1076    $now = time();
1077    $key = calculate_auto_login_key($user_id, $now, $username);
1078    if ($key!==false)
1079    {
1080      $cookie = $user_id.'-'.$now.'-'.$key;
1081      if (version_compare(PHP_VERSION, '5.2', '>=') )
1082      {
1083        setcookie($conf['remember_me_name'],
1084            $cookie,
1085            time()+$conf['remember_me_length'],
1086            cookie_path(),ini_get('session.cookie_domain'),ini_get('session.cookie_secure'),
1087            ini_get('session.cookie_httponly')
1088          );
1089      }
1090      else
1091      {
1092        setcookie($conf['remember_me_name'],
1093            $cookie,
1094            time()+$conf['remember_me_length'],
1095            cookie_path(),ini_get('session.cookie_domain'),ini_get('session.cookie_secure')
1096          );
1097      }
1098    }
1099  }
1100  else
1101  { // make sure we clean any remember me ...
1102    setcookie($conf['remember_me_name'], '', 0, cookie_path(),ini_get('session.cookie_domain'));
1103  }
1104  if ( session_id()!="" )
1105  { // we regenerate the session for security reasons
1106    // see http://www.acros.si/papers/session_fixation.pdf
1107    session_regenerate_id(true);
1108  }
1109  else
1110  {
1111    session_start();
1112  }
1113  $_SESSION['pwg_uid'] = (int)$user_id;
1114
1115  $user['id'] = $_SESSION['pwg_uid'];
1116}
1117
1118/*
1119 * Performs auto-connexion when cookie remember_me exists
1120 * @return true/false
1121*/
1122function auto_login() {
1123  global $conf;
1124
1125  if ( isset( $_COOKIE[$conf['remember_me_name']] ) )
1126  {
1127    $cookie = explode('-', stripslashes($_COOKIE[$conf['remember_me_name']]));
1128    if ( count($cookie)===3
1129        and is_numeric(@$cookie[0]) /*user id*/
1130        and is_numeric(@$cookie[1]) /*time*/
1131        and time()-$conf['remember_me_length']<=@$cookie[1]
1132        and time()>=@$cookie[1] /*cookie generated in the past*/ )
1133    {
1134      $key = calculate_auto_login_key( $cookie[0], $cookie[1], $username );
1135      if ($key!==false and $key===$cookie[2])
1136      {
1137        log_user($cookie[0], true);
1138        trigger_action('login_success', stripslashes($username));
1139        return true;
1140      }
1141    }
1142    setcookie($conf['remember_me_name'], '', 0, cookie_path(),ini_get('session.cookie_domain'));
1143  }
1144  return false;
1145}
1146
1147/**
1148 * Tries to login a user given username and password (must be MySql escaped)
1149 * return true on success
1150 */
1151function try_log_user($username, $password, $remember_me)
1152{
1153  // we force the session table to be clean
1154  pwg_session_gc();
1155 
1156  global $conf;
1157  // retrieving the encrypted password of the login submitted
1158  $query = '
1159SELECT '.$conf['user_fields']['id'].' AS id,
1160       '.$conf['user_fields']['password'].' AS password
1161  FROM '.USERS_TABLE.'
1162  WHERE '.$conf['user_fields']['username'].' = \''.pwg_db_real_escape_string($username).'\'
1163;';
1164  $row = pwg_db_fetch_assoc(pwg_query($query));
1165  if ($row['password'] == $conf['pass_convert']($password))
1166  {
1167    log_user($row['id'], $remember_me);
1168    trigger_action('login_success', stripslashes($username));
1169    return true;
1170  }
1171  trigger_action('login_failure', stripslashes($username));
1172  return false;
1173}
1174
1175/** Performs all the cleanup on user logout */
1176function logout_user()
1177{
1178  global $conf;
1179  $_SESSION = array();
1180  session_unset();
1181  session_destroy();
1182  setcookie(session_name(),'',0,
1183      ini_get('session.cookie_path'),
1184      ini_get('session.cookie_domain')
1185    );
1186  setcookie($conf['remember_me_name'], '', 0, cookie_path(),ini_get('session.cookie_domain'));
1187}
1188
1189/*
1190 * Return user status used in this library
1191 * @return string
1192*/
1193function get_user_status($user_status)
1194{
1195  global $user;
1196
1197  if (empty($user_status))
1198  {
1199    if (isset($user['status']))
1200    {
1201      $user_status = $user['status'];
1202    }
1203    else
1204    {
1205      // swicth to default value
1206      $user_status = '';
1207    }
1208  }
1209  return $user_status;
1210}
1211
1212/*
1213 * Return access_type definition of user
1214 * Test does with user status
1215 * @return bool
1216*/
1217function get_access_type_status($user_status='')
1218{
1219  global $conf;
1220
1221  switch (get_user_status($user_status))
1222  {
1223    case 'guest':
1224    {
1225      $access_type_status =
1226        ($conf['guest_access'] ? ACCESS_GUEST : ACCESS_FREE);
1227      break;
1228    }
1229    case 'generic':
1230    {
1231      $access_type_status = ACCESS_GUEST;
1232      break;
1233    }
1234    case 'normal':
1235    {
1236      $access_type_status = ACCESS_CLASSIC;
1237      break;
1238    }
1239    case 'admin':
1240    {
1241      $access_type_status = ACCESS_ADMINISTRATOR;
1242      break;
1243    }
1244    case 'webmaster':
1245    {
1246      $access_type_status = ACCESS_WEBMASTER;
1247      break;
1248    }
1249    default:
1250    {
1251      $access_type_status = ACCESS_FREE;
1252      break;
1253    }
1254  }
1255
1256  return $access_type_status;
1257}
1258
1259/*
1260 * Return if user have access to access_type definition
1261 * Test does with user status
1262 * @return bool
1263*/
1264function is_autorize_status($access_type, $user_status = '')
1265{
1266  return (get_access_type_status($user_status) >= $access_type);
1267}
1268
1269/*
1270 * Check if user have access to access_type definition
1271 * Stop action if there are not access
1272 * Test does with user status
1273 * @return none
1274*/
1275function check_status($access_type, $user_status = '')
1276{
1277  if (!is_autorize_status($access_type, $user_status))
1278  {
1279    access_denied();
1280  }
1281}
1282
1283/*
1284 * Return if user is generic
1285 * @return bool
1286*/
1287 function is_generic($user_status = '')
1288{
1289  return get_user_status($user_status) == 'generic';
1290}
1291
1292/*
1293 * Return if user is only a guest
1294 * @return bool
1295*/
1296 function is_a_guest($user_status = '')
1297{
1298  return get_user_status($user_status) == 'guest';
1299}
1300
1301/*
1302 * Return if user is, at least, a classic user
1303 * @return bool
1304*/
1305 function is_classic_user($user_status = '')
1306{
1307  return is_autorize_status(ACCESS_CLASSIC, $user_status);
1308}
1309
1310/*
1311 * Return if user is, at least, an administrator
1312 * @return bool
1313*/
1314 function is_admin($user_status = '')
1315{
1316  return is_autorize_status(ACCESS_ADMINISTRATOR, $user_status);
1317}
1318
1319/*
1320 * Return if user is, at least, a webmaster
1321 * @return bool
1322*/
1323 function is_webmaster($user_status = '')
1324{
1325  return is_autorize_status(ACCESS_WEBMASTER, $user_status);
1326}
1327
1328/*
1329 * Adviser status is depreciated from piwigo 2.2
1330 * @return false
1331*/
1332function is_adviser()
1333{
1334  // TODO for Piwigo 2.4 : trigger a warning. We don't do it on Piwigo 2.3
1335  // to avoid changes for plugin contributors
1336  // trigger_error('call to obsolete function is_adviser', E_USER_WARNING);
1337  return false;
1338}
1339
1340/*
1341 * Return if current user can edit/delete/validate a comment
1342 * @param action edit/delete/validate
1343 * @return bool
1344 */
1345function can_manage_comment($action, $comment_author_id)
1346{
1347  global $user, $conf;
1348 
1349  if (is_a_guest())
1350  {
1351    return false;
1352  }
1353 
1354  if (!in_array($action, array('delete','edit', 'validate')))
1355  {
1356    return false;
1357  }
1358
1359  if (is_admin())
1360  {
1361    return true;
1362  }
1363
1364  if ('edit' == $action and $conf['user_can_edit_comment'])
1365  {
1366    if ($comment_author_id == $user['id']) {
1367      return true;
1368    }
1369  }
1370
1371  if ('delete' == $action and $conf['user_can_delete_comment'])
1372  {
1373    if ($comment_author_id == $user['id']) {
1374      return true;
1375    }
1376  }
1377
1378  return false;
1379}
1380
1381/*
1382 * Return mail address as display text
1383 * @return string
1384*/
1385function get_email_address_as_display_text($email_address)
1386{
1387  global $conf;
1388
1389  if (!isset($email_address) or (trim($email_address) == ''))
1390  {
1391    return '';
1392  }
1393  else
1394  {
1395    return $email_address;
1396  }
1397}
1398
1399/*
1400 * Compute sql where condition with restrict and filter data. "FandF" means
1401 * Forbidden and Filters.
1402 *
1403 * @param array condition_fields: read function body
1404 * @param string prefix_condition: prefixes sql if condition is not empty
1405 * @param boolean force_one_condition: use at least "1 = 1"
1406 *
1407 * @return string sql where/conditions
1408 */
1409function get_sql_condition_FandF(
1410  $condition_fields,
1411  $prefix_condition = null,
1412  $force_one_condition = false
1413  )
1414{
1415  global $user, $filter;
1416
1417  $sql_list = array();
1418
1419  foreach ($condition_fields as $condition => $field_name)
1420  {
1421    switch($condition)
1422    {
1423      case 'forbidden_categories':
1424      {
1425        if (!empty($user['forbidden_categories']))
1426        {
1427          $sql_list[] =
1428            $field_name.' NOT IN ('.$user['forbidden_categories'].')';
1429        }
1430        break;
1431      }
1432      case 'visible_categories':
1433      {
1434        if (!empty($filter['visible_categories']))
1435        {
1436          $sql_list[] =
1437            $field_name.' IN ('.$filter['visible_categories'].')';
1438        }
1439        break;
1440      }
1441      case 'visible_images':
1442        if (!empty($filter['visible_images']))
1443        {
1444          $sql_list[] =
1445            $field_name.' IN ('.$filter['visible_images'].')';
1446        }
1447        // note there is no break - visible include forbidden
1448      case 'forbidden_images':
1449        if (
1450            !empty($user['image_access_list'])
1451            or $user['image_access_type']!='NOT IN'
1452            )
1453        {
1454          $table_prefix=null;
1455          if ($field_name=='id')
1456          {
1457            $table_prefix = '';
1458          }
1459          elseif ($field_name=='i.id')
1460          {
1461            $table_prefix = 'i.';
1462          }
1463          if ( isset($table_prefix) )
1464          {
1465            $sql_list[]=$table_prefix.'level<='.$user['level'];
1466          }
1467          else
1468          {
1469            $sql_list[]=$field_name.' '.$user['image_access_type']
1470                .' ('.$user['image_access_list'].')';
1471          }
1472        }
1473        break;
1474      default:
1475      {
1476        die('Unknow condition');
1477        break;
1478      }
1479    }
1480  }
1481
1482  if (count($sql_list) > 0)
1483  {
1484    $sql = '('.implode(' AND ', $sql_list).')';
1485  }
1486  else
1487  {
1488    $sql = $force_one_condition ? '1 = 1' : '';
1489  }
1490
1491  if (isset($prefix_condition) and !empty($sql))
1492  {
1493    $sql = $prefix_condition.' '.$sql;
1494  }
1495
1496  return $sql;
1497}
1498
1499/**
1500 * search an available activation_key
1501 *
1502 * @return string
1503 */
1504function get_user_activation_key()
1505{
1506  while (true)
1507  {
1508    $key = generate_key(20);
1509    $query = '
1510SELECT COUNT(*)
1511  FROM '.USER_INFOS_TABLE.'
1512  WHERE activation_key = \''.$key.'\'
1513;';
1514    list($count) = pwg_db_fetch_row(pwg_query($query));
1515    if (0 == $count)
1516    {
1517      return $key;
1518    }
1519  }
1520}
1521
1522?>
Note: See TracBrowser for help on using the repository browser.