source: extensions/UserAdvManager/trunk/include/functions.inc.php @ 18205

Revision 18205, 96.4 KB checked in by flop25, 7 years ago (diff)

no more need of confirmMail.php / tpl
better handle on init
bug pending :
-no login on key validation (like previously)
-no confirmation msg on key validation : $pageinfos[] doesn't seems to work on identification page

  • Property svn:eol-style set to LF
Line 
1<?php
2include_once (UAM_PATH.'include/constants.php');
3load_language('plugin.lang', UAM_PATH);
4
5
6/**
7 * Triggered on get_admin_plugin_menu_links
8 *
9 * Plugin's administration menu
10 */
11function UAM_admin_menu($menu)
12{
13// +-----------------------------------------------------------------------+
14// |                      Getting plugin name                              |
15// +-----------------------------------------------------------------------+
16  $plugin =  PluginInfos(UAM_PATH);
17  $name = $plugin['name'];
18 
19  array_push($menu,
20    array(
21                'NAME' => $name,
22                'URL' => get_root_url().'admin.php?page=plugin-'.basename(UAM_PATH)
23    )
24  );
25
26  return $menu;
27}
28
29
30/**
31 * Triggered on loc_begin_admin_page
32 *
33 * Check options compatibility
34 */
35function UAM_check_compat()
36{
37  global $conf, $page;
38 
39  $conf_UAM = unserialize($conf['UserAdvManager']);
40 
41  // Check mandatory email address for email exclusion
42  if (!$conf['obligatory_user_mail_address'] and $conf_UAM[10] = 'true')
43  {
44    array_push($page['warnings'], l10n('UAM_mail_exclusion_error'));
45  }
46}
47
48
49/**
50 * Triggered on loc_begin_index
51 *
52 * Initiating GhostTracker - Perform user logout after registration if not validated
53 */
54function UAM_Init()
55{
56  global $conf, $user;
57
58  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
59
60  $conf_UAM = unserialize($conf['UserAdvManager']);
61
62  // Admins, Guests and Adult_Content users are not tracked for Ghost Tracker or Users Tracker
63  // -----------------------------------------------------------------------------------------
64  if (!is_admin() and !is_a_guest() and $user['username'] != "16" and $user['username'] != "18")
65  {
66    if ((isset($conf_UAM[15]) and $conf_UAM[15] == 'true') or (isset($conf_UAM[18]) and $conf_UAM[18] == 'true'))
67    {
68
69                                                $userid = get_userid($user['username']);
70         
71      // Looking for existing entry in last visit table
72      // ----------------------------------------------
73      $query = '
74SELECT *
75FROM '.USER_LASTVISIT_TABLE.'
76WHERE user_id = '.$userid.'
77;';
78       
79      $count = pwg_db_num_rows(pwg_query($query));
80         
81      if ($count == 0)
82      {
83        // If not, data are inserted in table
84        // ----------------------------------
85        $query = '
86INSERT INTO '.USER_LASTVISIT_TABLE.' (user_id, lastvisit, reminder)
87VALUES ('.$userid.', now(), "false")
88;';
89        pwg_query($query);
90      }
91      else if ($count > 0)
92      {
93        // If yes, data are updated in table
94        // ---------------------------------
95        $query = '
96UPDATE '.USER_LASTVISIT_TABLE.'
97SET lastvisit = now(), reminder = "false"
98WHERE user_id = '.$userid.'
99LIMIT 1
100;';
101        pwg_query($query);
102      }
103    }
104
105    // Perform user logout after registration if not validated
106    if ((isset($conf_UAM[39]) and $conf_UAM[39] == 'true') and !UAM_UsrReg_Verif($user['id']) and !is_admin() and !is_webmaster() )
107    {
108      invalidate_user_cache();
109      logout_user();
110      if ( $conf['guest_access'] )
111      {
112        redirect( make_index_url().'?UAM_msg=rejected', 0);
113      }
114      else
115      {
116        redirect( get_root_url().'identification.php?UAM_msg=rejected' , 0);
117      }
118    }
119  }
120}
121
122
123/**
124 * Triggered on register_user
125 *
126 * Additional controls on user registration
127 */
128function UAM_Adduser($register_user)
129{
130  global $conf;
131
132  $conf_UAM = unserialize($conf['UserAdvManager']);
133
134  // Exclusion of Adult_Content users
135  // --------------------------------
136  if ($register_user['username'] != "16" and $register_user['username'] != "18")
137  {
138    $passwd = (isset($_POST['password'])) ? $_POST['password'] : '';
139
140    if (isset($conf_UAM[1]) and $conf_UAM[1] == 'local')
141    {
142      // This is to set user to "waiting" group or status and without ConfirMail until admin validation
143      // ----------------------------------------------------------------------------------------------
144      SetPermission($register_user['id']);// Set to "waiting" group or status until admin validation
145     
146      // This is to set UAM_validated field to false in #_users table - Usefull if no "waiting" group or status is set
147      // -------------------------------------------------------------------------------------------------------------
148      SetUnvalidated($register_user['id']);
149
150      // This is to send the validation key by email to admins for their manual validation without having to connect the gallery
151      // -----------------------------------------------------------------------------------------------------------------------
152      SendMail2User(1, $register_user['id'], $register_user['username'], $passwd, $register_user['email'], true);
153    }
154    // Sending registration confirmation by email
155    // ------------------------------------------
156    elseif (isset($conf_UAM[1]) and $conf_UAM[1] == 'true')
157    {
158      if (is_admin() and isset($conf_UAM[19]) and $conf_UAM[19] == 'true')
159      {
160        SendMail2User(1, $register_user['id'], $register_user['username'], $passwd, $register_user['email'], true); 
161      }
162      elseif (is_admin() and isset($conf_UAM[19]) and $conf_UAM[19] == 'false')
163      {
164        SendMail2User(1, $register_user['id'], $register_user['username'], $passwd, $register_user['email'], false);
165      }
166      elseif (!is_admin())
167      {
168        SendMail2User(1, $register_user['id'], $register_user['username'], $passwd, $register_user['email'], true);
169      }
170    }
171  }
172}
173
174
175/**
176 * Triggered on delete_user
177 *
178 * Database cleanup on user deletion
179 */
180function UAM_Deluser($user_id)
181{
182  // Cleanup for ConfirmMail table
183  // -----------------------------
184  DeleteConfirmMail($user_id);
185  // Cleanup for LastVisit table
186  // ---------------------------
187  DeleteLastVisit($user_id);
188  // Cleanup Redirection settings
189  // ----------------------------
190  DeleteRedir($user_id);
191}
192
193
194/**
195 * Triggered on register_user_check
196 *
197 * Additional controls on user registration check
198 */
199function UAM_RegistrationCheck($errors, $user)
200{
201  global $conf;
202
203  // Exclusion of Adult_Content users
204  // --------------------------------
205  if ($user['username'] != "16" and $user['username'] != "18")
206  {
207    load_language('plugin.lang', UAM_PATH);
208
209    $PasswordCheck = 0;
210
211    $conf_UAM = unserialize($conf['UserAdvManager']);
212
213    // Password enforcement control
214    // ----------------------------
215    if (isset($conf_UAM[12]) and $conf_UAM[12] == 'true' and !empty($conf_UAM[13]))
216    {
217      if (!empty($user['password']) and !is_admin())
218      {
219        $PasswordCheck = testpassword($user['password']);
220 
221        if ($PasswordCheck < $conf_UAM[13])
222        {
223          $message = get_l10n_args('UAM_reg_err_login4_%s', $PasswordCheck);
224          $lang['reg_err_pass'] = l10n_args($message).$conf_UAM[13];
225          array_push($errors, $lang['reg_err_pass']);
226        }
227      }
228      else if (!empty($user['password']) and is_admin() and isset($conf_UAM[14]) and $conf_UAM[14] == 'true')
229      {
230        $PasswordCheck = testpassword($user['password']);
231 
232        if ($PasswordCheck < $conf_UAM[13])
233        {
234          $message = get_l10n_args('UAM_reg_err_login4_%s', $PasswordCheck);
235          $lang['reg_err_pass'] = l10n_args($message).$conf_UAM[13];
236          array_push($errors, $lang['reg_err_pass']);
237        }
238      }
239    }
240
241    // Username without forbidden keys
242    // -------------------------------
243    if (isset($conf_UAM[5]) and $conf_UAM[5] == 'true' and !empty($user['username']) and ValidateUsername($user['username']) and !is_admin())
244    {
245      $lang['reg_err_login1'] = l10n('UAM_reg_err_login2')."'".$conf_UAM[6]."'";
246      array_push($errors, $lang['reg_err_login1']);
247    }
248
249    // Email without forbidden domains
250    // -------------------------------
251    if (isset($conf_UAM[10]) and $conf_UAM[10] == 'true' and !empty($user['email']) and ValidateEmailProvider($user['email']) and !is_admin())
252    {
253      $lang['reg_err_login1'] = l10n('UAM_reg_err_login5')."'".$conf_UAM[11]."'";
254      array_push($errors, $lang['reg_err_login1']);
255    }
256    return $errors;
257  }
258}
259
260
261/**
262 * Triggered on loc_begin_profile
263 */
264function UAM_Profile_Init()
265{
266  global $conf, $user, $template;
267
268  $conf_UAM = unserialize($conf['UserAdvManager']);
269
270  // Update first redirection parameter
271  // ----------------------------------
272  if ((isset($conf_UAM[20]) and $conf_UAM[20] == 'true'))
273  {
274    $user_idsOK = array();
275    if (!UAM_check_profile($user['id'], $user_idsOK))
276    {
277      $user_idsOK[] = $user['id'];
278
279      $query = '
280UPDATE '.CONFIG_TABLE.'
281SET value = "'.implode(',', $user_idsOK).'"
282WHERE param = "UserAdvManager_Redir";';
283         
284      pwg_query($query);
285    }
286  }
287
288  // Special message display for password reset
289  // ------------------------------------------
290  if ((isset($conf_UAM[38]) and $conf_UAM[38] == 'true'))
291  {
292    if (UAM_check_pwgreset($user['id']))
293    {
294      $template->append('errors', l10n('UAM_Password_Reset_Msg'));
295    }
296  }
297
298  // Controls on profile page submission
299  // -----------------------------------
300  if (isset($_POST['validate']) and !is_admin())
301  {
302    // Email without forbidden domains
303    // -------------------------------
304    if (isset($conf_UAM[10]) and $conf_UAM[10] == 'true' and !empty($_POST['mail_address']))
305    {
306      if (ValidateEmailProvider($_POST['mail_address']))
307      {
308        $template->append('errors', l10n('UAM_reg_err_login5')."'".$conf_UAM[11]."'");
309        unset($_POST['validate']);
310      }
311    }
312
313    // Password reset control
314    // ----------------------
315    if (isset($conf_UAM[38]) and $conf_UAM[38] == 'true' and UAM_check_pwgreset($user['id']))
316    {
317      // if password not changed then pwdreset field = true else pwdreset field = false
318      // ------------------------------------------------------------------------------
319      if (!empty($_POST['use_new_pwd']))
320      {
321        $query = '
322UPDATE '.USERS_TABLE.'
323SET UAM_pwdreset = "false"
324WHERE id = '.$user['id'].'
325LIMIT 1
326;';
327        pwg_query($query);
328      }
329    }
330
331    $typemail = 3; // Only information email send to user on user profile update if checked
332
333    if (!empty($_POST['use_new_pwd']))
334    {
335      $typemail = 2; // Confirmation email on user profile update - With information email
336
337      // Password enforcement control
338      // ----------------------------
339      if (isset($conf_UAM[12]) and $conf_UAM[12] == 'true' and !empty($conf_UAM[13]))
340      {
341        $PasswordCheck = testpassword($_POST['use_new_pwd']);
342
343        if ($PasswordCheck < $conf_UAM[13])
344        {
345          $message = get_l10n_args('UAM_reg_err_login4_%s', $PasswordCheck);
346          $template->append('errors', l10n_args($message).$conf_UAM[13]);
347          unset($_POST['use_new_pwd']);
348          unset($_POST['validate']);
349        }
350      }
351    }
352
353    // Sending registration confirmation by email
354    // ------------------------------------------
355    if ((isset($conf_UAM[1]) and $conf_UAM[1] == 'true') or (isset($conf_UAM[1]) and $conf_UAM[1] == 'local'))
356    {
357      $confirm_mail_need = false;
358
359      if (!empty($_POST['mail_address']))
360      {
361        $query = '
362SELECT '.$conf['user_fields']['email'].' AS email
363FROM '.USERS_TABLE.'
364WHERE '.$conf['user_fields']['id'].' = \''.$user['id'].'\'
365;';
366
367        list($current_email) = pwg_db_fetch_row(pwg_query($query));
368
369        // This is to send a new validation key
370        // ------------------------------------
371        if ($_POST['mail_address'] != $current_email and (isset($conf_UAM[1]) and $conf_UAM[1] == 'true'))
372        {
373          SetPermission($user['id']);// Set to "waiting" group or status until user validation
374          SetUnvalidated($user['id']); // Set UAM_validated field to false in #_users table
375          $confirm_mail_need = true;
376        }
377
378        // This is to set the user to "waiting" group or status until admin validation
379        // ---------------------------------------------------------------------------
380        elseif ($_POST['mail_address'] != $current_email and (isset($conf_UAM[1]) and $conf_UAM[1] == 'local'))
381        {
382          SetPermission($user['id']);// Set to "waiting" group or status until admin validation
383          SetUnvalidated($user['id']); // Set UAM_validated field to false in #_users table
384          $confirm_mail_need = false;
385        }       
386      }
387       
388      if (((!empty($_POST['use_new_pwd']) and (isset($conf_UAM[0]) and $conf_UAM[0] == 'true')) or $confirm_mail_need))
389      {
390        $query = '
391SELECT '.$conf['user_fields']['username'].'
392FROM '.USERS_TABLE.'
393WHERE '.$conf['user_fields']['id'].' = \''.$user['id'].'\'
394;';
395       
396        list($username) = pwg_db_fetch_row(pwg_query($query));
397        SendMail2User($typemail, $user['id'], $username, $_POST['use_new_pwd'], $_POST['mail_address'], $confirm_mail_need);
398      }
399    }
400  }
401}
402
403
404/**
405 * Triggered on login_success
406 *
407 * Triggers scheduled tasks at login
408 * Redirects a visitor (except for admins, webmasters and generic statuses) to his profile.php page (Thx to LucMorizur)
409 *
410 */
411function UAM_LoginTasks()
412{
413  global $conf, $user;
414 
415  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
416 
417  $conf_UAM = unserialize($conf['UserAdvManager']);
418 
419  // Performing GhostTracker scheduled tasks
420  // ---------------------------------------
421  if ((isset($conf_UAM[21]) and $conf_UAM[21] == 'true'))
422  {
423    UAM_GT_ScheduledTasks();
424  }
425
426  // Performing User validation scheduled tasks
427  // ------------------------------------------
428  if ((isset($conf_UAM[30]) and $conf_UAM[30] == 'true'))
429  {
430    UAM_USR_ScheduledTasks();
431  }
432
433  // Avoid login into public galleries until registration confirmation is done
434  if ((isset($conf_UAM[39]) and $conf_UAM[39] == 'false') or ((isset($conf_UAM[39]) and $conf_UAM[39] == 'true') and UAM_UsrReg_Verif($user['id'])))
435  {
436    // Performing redirection to profile page on first login
437    // -----------------------------------------------------
438    if ((isset($conf_UAM[20]) and $conf_UAM[20] == 'true'))
439    {
440      $query ='
441SELECT user_id, status
442FROM '.USER_INFOS_TABLE.'
443WHERE user_id = '.$user['id'].'
444;';
445      $data = pwg_db_fetch_assoc(pwg_query($query));
446
447      if ($data['status'] <> "admin" and $data['status'] <> "webmaster" and $data['status'] <> "generic") // Exclusion of specific accounts
448      {
449        $user_idsOK = array();
450        if (!UAM_check_profile($user['id'], $user_idsOK))
451          redirect(PHPWG_ROOT_PATH.'profile.php');
452      }
453    }
454
455    // Performing redirection to profile page for password reset
456    // ---------------------------------------------------------
457    if ((isset($conf_UAM[38]) and $conf_UAM[38] == 'true'))
458    {
459      $query ='
460SELECT user_id, status
461FROM '.USER_INFOS_TABLE.'
462WHERE user_id = '.$user['id'].'
463;';
464      $data = pwg_db_fetch_assoc(pwg_query($query));
465
466      if ($data['status'] <> "webmaster" and $data['status'] <> "generic") // Exclusion of specific accounts
467      {
468        if (UAM_check_pwgreset($user['id']))
469        {
470          redirect(PHPWG_ROOT_PATH.'profile.php');
471        }
472      }
473    }
474  }
475  elseif ((isset($conf_UAM[39]) and $conf_UAM[39] == 'true') and !UAM_UsrReg_Verif($user['id']) and !is_admin() and !is_webmaster())
476  {
477    // Logged-in user cleanup, session destruction and redirected to custom page
478    // -------------------------------------------------------------------------
479    invalidate_user_cache();
480    logout_user();
481    if ( $conf['guest_access'] )
482    {
483      redirect( make_index_url().'?UAM_msg=rejected', 0);
484    }
485    else
486    {
487      redirect( get_root_url().'identification.php?UAM_msg=rejected' , 0);
488    }
489  }
490}
491
492
493/**
494 * Adds a new module settable in PWG_Stuffs - Triggered on get_stuffs_modules in main.inc.php
495 * Useful to inform unvalidated user for their status
496 *
497 */
498function register_UAM_stuffs_module($modules)
499{
500  array_push($modules, array(
501    'path' => UAM_PATH.'/stuffs_module',
502    'name' => l10n('UAM_Stuffs_Title'),
503    'description' => l10n('UAM_Stuffs_Desc'),
504    )
505  );
506  return $modules;
507}
508
509
510/**
511 * Triggered on UAM_LoginTasks()
512 *
513 * Executes optional post-login tasks for Ghost users
514 *
515 */
516function UAM_GT_ScheduledTasks()
517{
518  global $conf, $user, $page;
519
520  if (!defined('PHPWG_ROOT_PATH'))
521  {
522    die('Hacking attempt!');
523  }
524         
525  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
526
527  $conf_UAM = unserialize($conf['UserAdvManager']);
528 
529  $collection = array();
530  $reminder = false;
531 
532  $page['filtered_users'] = get_ghosts_autotasks();
533
534  foreach($page['filtered_users'] as $listed_user)
535  {
536    array_push($collection, $listed_user['id']);
537  }
538
539  // Auto group, status or privacy level downgrade and autodeletion if user already reminded
540  // ---------------------------------------------------------------------------------------
541  if ((isset($conf_UAM[21]) and $conf_UAM[21] == 'true') and ((isset($conf_UAM[25]) and $conf_UAM[25] <> -1) or (isset($conf_UAM[26]) and $conf_UAM[26] <> -1) or (isset($conf_UAM[37]) and $conf_UAM[37] <> -1)))
542  {
543    if (count($collection) > 0)
544         {
545      // Process if a non-admin nor webmaster user is logged
546      // ---------------------------------------------------
547      if (in_array($user['id'], $collection))
548                        {
549        // Check lastvisit reminder state
550        // ------------------------------
551        $query = '
552SELECT reminder
553FROM '.USER_LASTVISIT_TABLE.'
554WHERE user_id = '.$user['id'].';';
555
556        $result = pwg_db_fetch_assoc(pwg_query($query));
557
558        if (isset($result['reminder']) and $result['reminder'] == 'true')
559        {
560          $reminder = true;
561        }
562        else
563        {
564          $reminder = false;
565        }
566
567        // If user already reminded for ghost account
568        // ------------------------------------------
569        if ($reminder)
570        {
571          // Delete account
572          // --------------
573          delete_user($user['id']);
574
575          // Logged-in user cleanup, session destruction and redirected to custom page
576          // -------------------------------------------------------------------------
577          invalidate_user_cache();
578          logout_user();
579          redirect(UAM_PATH.'GT_del_account.php');
580        }
581                }
582      else // Process if an admin or webmaster user is logged
583      {
584        foreach ($collection as $user_id)
585        {
586          // Check lastvisit reminder state
587          // ------------------------------
588          $query = '
589SELECT reminder
590FROM '.USER_LASTVISIT_TABLE.'
591WHERE user_id = '.$user_id.';';
592
593          $result = pwg_db_fetch_assoc(pwg_query($query));
594
595          if (isset($result['reminder']) and $result['reminder'] == 'true')
596          {
597            $reminder = true;
598          }
599          else
600          {
601            $reminder = false;
602          }
603
604          // If never reminded before
605          // ------------------------
606          if (!$reminder)
607          {
608            // Reset of lastvisit date
609            // -----------------------
610            list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
611
612                        $query = '
613UPDATE '.USER_LASTVISIT_TABLE.'
614SET lastvisit="'.$dbnow.'"
615WHERE user_id = '.$user_id.'
616;';
617            pwg_query($query);
618
619          // Auto change group and / or status
620          // ---------------------------------
621            // Delete user from all groups
622            // ---------------------------
623            if ($conf_UAM[2] <> -1 and $conf_UAM[3] <> -1)
624            {
625                        $query = '
626DELETE FROM '.USER_GROUP_TABLE.'
627WHERE user_id = '.$user_id.'
628  AND (
629    group_id = '.$conf_UAM[2].'
630  OR
631    group_id = '.$conf_UAM[3].'
632  )
633;';
634                        pwg_query($query);
635                                                                                                }
636
637            // Change user status
638            // ------------------
639            if ($conf_UAM[26] <> -1)
640            {
641              $query = '
642UPDATE '.USER_INFOS_TABLE.'
643SET status = "'.$conf_UAM[26].'"
644WHERE user_id = '.$user_id.'
645;';
646              pwg_query($query);
647            }
648
649            // Change user group
650            // -----------------
651            if ($conf_UAM[25] <> -1)
652            {
653              $query = '
654INSERT INTO '.USER_GROUP_TABLE.'
655  (user_id, group_id)
656VALUES
657  ('.$user_id.', "'.$conf_UAM[25].'")
658;';
659              pwg_query($query);
660            }
661
662            // Change user privacy level
663            // -------------------------
664            if ($conf_UAM[37] <> -1)
665            {
666              $query = '
667UPDATE '.USER_INFOS_TABLE.'
668SET level = "'.$conf_UAM[37].'"
669WHERE user_id = '.$user_id.'
670;';
671              pwg_query($query);
672            }
673
674            // Auto send email notification on group / status downgrade
675            // --------------------------------------------------------
676            if (isset($conf_UAM[22]) and $conf_UAM[22] == 'true')
677            {
678              // Set reminder true
679              // -----------------
680              $query = '
681UPDATE '.USER_LASTVISIT_TABLE.'
682SET reminder = "true"
683WHERE user_id = '.$user_id.'
684;';
685              pwg_query($query);
686           
687              // Reset confirmed user status to unvalidated
688              // ------------------------------------------
689                                                                                                $query = '
690UPDATE '.USER_CONFIRM_MAIL_TABLE.'
691SET date_check = NULL
692WHERE user_id = '.$user_id.'
693;';
694                                                                                                pwg_query($query);
695
696              // Get users information for email notification
697              // --------------------------------------------
698                                                                                                $query = '
699SELECT id, username, mail_address
700FROM '.USERS_TABLE.'
701WHERE id = '.$user_id.'
702;';
703                                                                                                $data = pwg_db_fetch_assoc(pwg_query($query));
704           
705              demotion_mail($user_id, $data['username'], $data['mail_address']);
706            }
707          }
708          elseif ($reminder) // If user already reminded for ghost account
709          {
710            // Delete account
711            // --------------
712            delete_user($user_id);
713          }
714        }
715      }
716    }
717  }
718}
719
720
721/**
722 * Triggered on UAM_LoginTasks()
723 *
724 * Executes optional post-login tasks for unvalidated users
725 *
726 */
727function UAM_USR_ScheduledTasks()
728{
729  global $conf, $user, $page;
730
731  if (!defined('PHPWG_ROOT_PATH'))
732  {
733    die('Hacking attempt!');
734  }
735         
736  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
737
738  $conf_UAM = unserialize($conf['UserAdvManager']);
739 
740  $collection = array();
741  $reminder = false;
742 
743  $page['filtered_users'] = get_unvalid_user_autotasks();
744
745  foreach($page['filtered_users'] as $listed_user)
746  {
747    array_push($collection, $listed_user['id']);
748  }
749
750  // Unvalidated accounts auto email sending and autodeletion if user already reminded
751  // ---------------------------------------------------------------------------------
752  if ((isset($conf_UAM[30]) and $conf_UAM[30] == 'true'))
753  {
754    if (count($collection) > 0)
755                {
756      // Process if a non-admin nor webmaster user is logged
757      // ---------------------------------------------------
758      if (in_array($user['id'], $collection))
759                {
760        // Check ConfirmMail reminder state
761        // --------------------------------
762        $query = '
763SELECT reminder
764FROM '.USER_CONFIRM_MAIL_TABLE.'
765WHERE user_id = '.$user['id'].';';
766
767        $result = pwg_db_fetch_assoc(pwg_query($query));
768
769        if (isset($result['reminder']) and $result['reminder'] == 'true')
770        {
771          $reminder = true;
772        }
773        else
774        {
775          $reminder = false;
776        }
777
778        // If never reminded before, send reminder and set reminder True
779        // -------------------------------------------------------------
780        if (!$reminder and isset($conf_UAM[32]) and $conf_UAM[32] == 'true')
781        {
782                        $typemail = 1;
783         
784          // Get current user informations
785          // -----------------------------
786          $query = '
787SELECT id, username, mail_address
788FROM '.USERS_TABLE.'
789WHERE id = '.$user['id'].'
790;';
791          $data = pwg_db_fetch_assoc(pwg_query($query));
792
793          ResendMail2User($typemail,$user['id'],stripslashes($data['username']),$data['mail_address'],true);
794        }
795
796        // If already reminded before, delete user
797        // ---------------------------------------
798        if ($reminder)
799        {
800          // delete account
801          delete_user($user['id']);
802
803          // Logged-in user cleanup, session destruction and redirected to custom page
804          // -------------------------------------------------------------------------
805          invalidate_user_cache();
806          logout_user();
807          redirect(UAM_PATH.'USR_del_account.php');
808        }
809                }
810      else // Process if an admin or webmaster user is logged
811      {
812        foreach ($collection as $user_id)
813        {
814          // Check reminder state
815          // --------------------
816          $query = '
817SELECT reminder
818FROM '.USER_CONFIRM_MAIL_TABLE.'
819WHERE user_id = '.$user_id.';';
820
821          $result = pwg_db_fetch_assoc(pwg_query($query));
822
823          if (isset($result['reminder']) and $result['reminder'] == 'true')
824          {
825            $reminder = true;
826          }
827          else
828          {
829            $reminder = false;
830          }
831
832          // If never reminded before, send reminder and set reminder True
833          // -------------------------------------------------------------
834          if (!$reminder and isset($conf_UAM[32]) and $conf_UAM[32] == 'true')
835          {
836            $typemail = 1;
837         
838            // Get current user informations
839            // -----------------------------
840            $query = '
841SELECT id, username, mail_address
842FROM '.USERS_TABLE.'
843WHERE id = '.$user_id.'
844;';
845            $data = pwg_db_fetch_assoc(pwg_query($query));
846
847            ResendMail2User($typemail,$user_id,stripslashes($data['username']),$data['mail_address'],true);
848          }
849          elseif ($reminder) // If user already reminded for account validation
850          {
851            // Delete account
852            // --------------
853            delete_user($user_id);
854          }
855        }
856      }
857    }
858  }
859}
860
861
862/**
863 * Triggered on init
864 *
865 * Check for forbidden email domains in admin's users management panel
866 */
867function UAM_InitPage()
868{
869  load_language('plugin.lang', UAM_PATH);
870  global $conf, $template, $page, $lang, $errors;
871
872  $conf_UAM = unserialize($conf['UserAdvManager']);
873
874// Admin user management
875// ---------------------
876  if (script_basename() == 'admin' and isset($_GET['page']) and $_GET['page'] == 'user_list')
877  {
878    if (isset($_POST['submit_add']))
879    {
880      // Email without forbidden domains
881      // -------------------------------
882      if (isset($conf_UAM[10]) and $conf_UAM[10] == 'true' and !empty($_POST['email']) and ValidateEmailProvider($_POST['email']))
883      {
884        $template->append('errors', l10n('UAM_reg_err_login5')."'".$conf_UAM[11]."'");
885        unset($_POST['submit_add']);
886      }
887    }
888  }
889  if( isset($_GET['UAM_msg']))
890  {
891    UAM_DisplayMsg();
892  }
893  elseif (isset($_GET['key']) and isset($_GET['userid']))
894  {
895    UAM_ConfirmMail();
896  }
897
898}
899
900/**
901 * Triggered on init
902 *
903 * Display a message according to $_GET['UAM_msg']
904 */
905function UAM_DisplayMsg()
906{
907  if( isset($_GET['UAM_msg']))
908  {
909    global $user, $lang, $conf, $page;
910    $conf_UAM = unserialize($conf['UserAdvManager']);
911   
912    if (isset($conf_UAM[40]) and $conf_UAM[40] <> '' and $_GET['UAM_msg']="rejected")
913    {
914      // Management of Extension flags ([mygallery], [myurl])
915      // ---------------------------------------------------
916      $patterns[] = '#\[mygallery\]#i';
917      $replacements[] = $conf['gallery_title'];
918      $patterns[] = '#\[myurl\]#i';
919      $replacements[] = get_gallery_home_url();
920   
921      if (function_exists('get_user_language_desc'))
922      {
923        $custom_text = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[40]));
924      }
925      else $custom_text = l10n(preg_replace($patterns, $replacements, $conf_UAM[40]));
926      $page["errors"][]=$custom_text;
927    }
928  }
929}
930/**
931 * Triggered on init
932 *
933 * Check the key and display a message
934 */
935function UAM_ConfirmMail()
936{
937
938  if (isset($_GET['key']) and isset($_GET['userid']))
939  {
940 
941    global $user, $lang, $conf, $page;
942   
943    $key = $_GET['key'];
944    $userid = $_GET['userid'];
945   
946    $conf_UAM_ConfirmMail = unserialize($conf['UserAdvManager_ConfirmMail']);
947    $conf_UAM = unserialize($conf['UserAdvManager']);
948 
949    $query = '
950  SELECT '.USERS_TABLE.'.username
951  FROM '.USERS_TABLE.'
952  WHERE ('.USERS_TABLE.'.id ='.$userid.')
953  ;';
954    $result = pwg_db_fetch_assoc(pwg_query($query));
955 
956    if (VerifyConfirmMail($key))
957    {
958      if (isset($conf_UAM[1]) and $conf_UAM[1] == 'local')
959      {
960        validation_mail($userid);
961      }
962  // We have to get the user's language in database
963  // ----------------------------------------------
964      $query = '
965  SELECT language
966  FROM '.USER_INFOS_TABLE.'
967  WHERE '.USER_INFOS_TABLE.'.user_id ='.$userid.'
968  ;';
969      $data = pwg_db_fetch_assoc(pwg_query($query));
970 
971  // Check if user is already registered (profile changing) - If not (new registration), language is set to current gallery language
972  // -------------------------------------------------------------------------------------------------------------------------------
973      if (empty($data))
974      {
975  // And switch gallery to this language before using personalized and multilangual contents
976  // ---------------------------------------------------------------------------------------
977        $language = pwg_get_session_var('lang_switch', $user['language']);
978        switch_lang_to($language);
979      }
980      else
981      {
982  // And switch gallery to this language before using personalized and multilangual contents
983  // ---------------------------------------------------------------------------------------
984        switch_lang_to($data['language']);
985        load_language('plugin.lang', UAM_PATH);
986      }
987 
988      if (isset($conf_UAM_ConfirmMail[5]) and $conf_UAM_ConfirmMail[5] <> '')
989      {
990        // Management of Extension flags ([username], [mygallery], [myurl])
991        // ----------------------------------------------------------------
992        $patterns[] = '#\[username\]#i';
993        $replacements[] = $result['username'];
994        $patterns[] = '#\[mygallery\]#i';
995        $replacements[] = $conf['gallery_title'];
996        $patterns[] = '#\[myurl\]#i';
997        $replacements[] = get_gallery_home_url();
998 
999        if (function_exists('get_user_language_desc'))
1000        {
1001          $custom_text = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[5]));
1002        }
1003        else
1004        {
1005          $custom_text = l10n(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[5]));
1006        }
1007        $page['infos'][]=$custom_text;
1008        //print_r($custom_text);
1009      }
1010      //log_user($userid, true);
1011    } 
1012    else
1013    {
1014      if (isset($conf_UAM_ConfirmMail[6]) and $conf_UAM_ConfirmMail[6] <> '')
1015      {
1016        // Management of Extension flags ([username], [mygallery], [myurl])
1017        // ----------------------------------------------------------------
1018        $patterns[] = '#\[username\]#i';
1019        $replacements[] = $result['username'];
1020        $patterns[] = '#\[mygallery\]#i';
1021        $replacements[] = $conf['gallery_title'];
1022        $patterns[] = '#\[myurl\]#i';
1023        $replacements[] = get_gallery_home_url();
1024     
1025        if (function_exists('get_user_language_desc'))
1026        {
1027          $custom_text = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[6]));
1028        }
1029        else
1030        {
1031          $custom_text = l10n(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[6]));
1032        }
1033       
1034        $page['errors'][]=$custom_text;
1035      }
1036    }
1037  }
1038}
1039/**
1040 * Triggered on render_lost_password_mail_content
1041 *
1042 * Adds a customized text in lost password email content
1043 * Added text is inserted before users login name and new password
1044 *
1045 * @param : Standard Piwigo email content
1046 *
1047 * @return : Customized content added to standard content
1048 *
1049 */
1050function UAM_lost_password_mail_content($infos)
1051{
1052  global $conf;
1053 
1054  load_language('plugin.lang', UAM_PATH);
1055 
1056  $conf_UAM = unserialize($conf['UserAdvManager']);
1057 
1058  if (isset($conf_UAM[28]) and $conf_UAM[28] == 'true')
1059  {
1060    // Management of Extension flags ([mygallery], [myurl])
1061    $patterns[] = '#\[mygallery\]#i';
1062    $replacements[] = $conf['gallery_title'];
1063    $patterns[] = '#\[myurl\]#i';
1064    $replacements[] = get_gallery_home_url();
1065   
1066    $infos = preg_replace($patterns, $replacements, $conf_UAM[29])."\n"."\n".$infos;
1067  }
1068  return $infos;
1069}
1070
1071
1072/**
1073 * Function called from main.inc.php to send validation email
1074 *
1075 * @param : Type of email, user id, username, email address, confirmation (optional)
1076 *
1077 */
1078function SendMail2User($typemail, $id, $username, $password, $email, $confirm)
1079{
1080  global $conf;
1081
1082  $conf_UAM = unserialize($conf['UserAdvManager']);
1083
1084                include_once(PHPWG_ROOT_PATH.'include/functions_mail.inc.php');
1085
1086                $infos1_perso = "";
1087  $infos2_perso = "";
1088  $subject = "";
1089
1090// We have to get the user's language in database
1091// ----------------------------------------------
1092  $query ='
1093SELECT user_id, language
1094FROM '.USER_INFOS_TABLE.'
1095WHERE user_id = '.$id.'
1096;';
1097  $data = pwg_db_fetch_assoc(pwg_query($query));
1098
1099// Check if user is already registered (profile changing) - If not (new registration), language is set to current gallery language
1100// -------------------------------------------------------------------------------------------------------------------------------
1101  if (empty($data))
1102  {
1103// And switch gallery to this language before using personalized and multilangual contents
1104// ---------------------------------------------------------------------------------------
1105    $language = pwg_get_session_var( 'lang_switch', $user['language'] );
1106    switch_lang_to($language);
1107  }
1108  else
1109  {
1110// And switch gallery to this language before using personalized and multilangual contents
1111// ---------------------------------------------------------------------------------------
1112    //$language = $data['language']; // Usefull for debugging
1113    switch_lang_to($data['language']);
1114    load_language('plugin.lang', UAM_PATH);
1115  }
1116
1117  switch($typemail)
1118  {
1119    case 1: // Confirmation email on user registration - Without information email (already managed by Piwigo)
1120      if (isset($conf_UAM[41]) and $conf_UAM[41] <> '')
1121      {
1122        // Management of Extension flags ([username], [mygallery])
1123        // -------------------------------------------------------
1124        $patterns[] = '#\[username\]#i';
1125        $replacements[] = $username;
1126        $patterns[] = '#\[mygallery\]#i';
1127        $replacements[] = $conf['gallery_title'];
1128   
1129        if (function_exists('get_user_language_desc'))
1130        {
1131          $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[41]))."\n\n";
1132        }
1133        else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[41]))."\n\n"; 
1134      }
1135
1136      break;
1137     
1138    case 2: // Confirmation email on user profile update - With information email if modification done in user profile
1139      if (isset($conf_UAM[41]) and $conf_UAM[41] <> '')
1140      {
1141        // Management of Extension flags ([username], [mygallery])
1142        // -------------------------------------------------------
1143        $patterns[] = '#\[username\]#i';
1144        $replacements[] = $username;
1145        $patterns[] = '#\[mygallery\]#i';
1146        $replacements[] = $conf['gallery_title'];
1147   
1148        if (function_exists('get_user_language_desc'))
1149        {
1150          $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[41]))."\n\n";
1151        }
1152        else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[41]))."\n\n"; 
1153      }
1154
1155      $password = $password <> '' ? $password : l10n('UAM_empty_pwd');
1156
1157      if (isset($conf_UAM[8]) and $conf_UAM[8] <> '')
1158      {
1159        // Management of Extension flags ([username], [mygallery], [myurl])
1160        // ----------------------------------------------------------------
1161        $patterns[] = '#\[username\]#i';
1162        $replacements[] = $username;
1163        $patterns[] = '#\[mygallery\]#i';
1164        $replacements[] = $conf['gallery_title'];
1165        $patterns[] = '#\[myurl\]#i';
1166        $replacements[] = get_gallery_home_url();
1167   
1168        if (function_exists('get_user_language_desc'))
1169        {
1170          $infos1_perso = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[8]))."\n\n";
1171        }
1172        else $infos1_perso = l10n(preg_replace($patterns, $replacements, $conf_UAM[8]))."\n\n"; 
1173      }
1174
1175      if (isset($conf_UAM[0]) and $conf_UAM[0] == 'true')
1176      {
1177        if (isset($conf_UAM[34]) and $conf_UAM[34] == 'true') // Allow display of clear password in email
1178        {
1179          $infos1 = array(
1180            get_l10n_args('UAM_infos_mail %s', stripslashes($username)),
1181            get_l10n_args('UAM_User: %s', stripslashes($username)),
1182            get_l10n_args('UAM_Password: %s', $password),
1183            get_l10n_args('Email: %s', $email),
1184            get_l10n_args('', ''),
1185          );
1186        }
1187        else // Do not allow display of clear password in email
1188        {
1189          $infos1 = array(
1190            get_l10n_args('UAM_infos_mail %s', stripslashes($username)),
1191            get_l10n_args('UAM_User: %s', stripslashes($username)),
1192            get_l10n_args('Email: %s', $email),
1193            get_l10n_args('', ''),
1194          );
1195        }
1196      }
1197
1198      break;
1199       
1200    case 3: // Only information email send to user if checked
1201      if (isset($conf_UAM[43]) and $conf_UAM[43] <> '')
1202      {
1203        // Management of Extension flags ([username], [mygallery])
1204        // -------------------------------------------------------
1205        $patterns[] = '#\[username\]#i';
1206        $replacements[] = $username;
1207        $patterns[] = '#\[mygallery\]#i';
1208        $replacements[] = $conf['gallery_title'];
1209   
1210        if (function_exists('get_user_language_desc'))
1211        {
1212          $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[43]))."\n\n";
1213        }
1214        else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[43]))."\n\n"; 
1215      }
1216
1217      $password = $password <> '' ? $password : l10n('UAM_no_update_pwd');
1218
1219      if (isset($conf_UAM[8]) and $conf_UAM[8] <> '')
1220      {
1221        // Management of Extension flags ([username], [mygallery], [myurl])
1222        // ----------------------------------------------------------------
1223        $patterns[] = '#\[username\]#i';
1224        $replacements[] = $username;
1225        $patterns[] = '#\[mygallery\]#i';
1226        $replacements[] = $conf['gallery_title'];
1227        $patterns[] = '#\[myurl\]#i';
1228        $replacements[] = get_gallery_home_url();
1229   
1230        if (function_exists('get_user_language_desc'))
1231        {
1232          $infos1_perso = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[8]))."\n\n";
1233        }
1234        else $infos1_perso = l10n(preg_replace($patterns, $replacements, $conf_UAM[8]))."\n\n"; 
1235      }
1236
1237      if (isset($conf_UAM[0]) and $conf_UAM[0] == 'true')
1238      {
1239        if (isset($conf_UAM[34]) and $conf_UAM[34] == 'true') // Allow display of clear password in email
1240        {
1241          $infos1 = array(
1242            get_l10n_args('UAM_infos_mail %s', stripslashes($username)),
1243            get_l10n_args('UAM_User: %s', stripslashes($username)),
1244            get_l10n_args('UAM_Password: %s', $password),
1245            get_l10n_args('Email: %s', $email),
1246            get_l10n_args('', ''),
1247          );
1248        }
1249        else // Do not allow display of clear password in email
1250        {
1251          $infos1 = array(
1252            get_l10n_args('UAM_infos_mail %s', stripslashes($username)),
1253            get_l10n_args('UAM_User: %s', stripslashes($username)),
1254            get_l10n_args('Email: %s', $email),
1255            get_l10n_args('', ''),
1256          );
1257        }
1258      }
1259
1260      break;
1261  }
1262
1263  if (isset($conf_UAM[1]) and ($conf_UAM[1] == 'true' or $conf_UAM[1] == 'local')  and $confirm) // Add confirmation link ?
1264  {
1265    $infos2 = array
1266    (
1267      get_l10n_args('UAM_Link: %s', AddConfirmMail($id, $email)),
1268      get_l10n_args('', ''),
1269    );
1270
1271    if (isset($conf_UAM[9]) and $conf_UAM[9] <> '') // Add personal text in confirmation email ?
1272    {
1273      // Management of Extension flags ([username], [mygallery], [myurl], [Kdays])
1274      // -------------------------------------------------------------------------
1275      $patterns[] = '#\[username\]#i';
1276      $replacements[] = $username;
1277      $patterns[] = '#\[mygallery\]#i';
1278      $replacements[] = $conf['gallery_title'];
1279      $patterns[] = '#\[myurl\]#i';
1280      $replacements[] = get_gallery_home_url();
1281     
1282      if (isset($conf_UAM_ConfirmMail[0]) and $conf_UAM_ConfirmMail[0] == 'true') // [Kdays] replacement only if related option is active
1283      {
1284        $patterns[] = '#\[Kdays\]#i';
1285        $replacements[] = $conf_UAM_ConfirmMail[1];
1286      }
1287     
1288      if (function_exists('get_user_language_desc'))
1289      {
1290        $infos2_perso = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[9]))."\n\n";
1291      }
1292      else $infos2_perso = l10n(preg_replace($patterns, $replacements, $conf_UAM[9]))."\n\n";
1293    }
1294  }
1295
1296// Sending the email with subject and contents
1297// -------------------------------------------
1298                if (isset($conf_UAM[1]) and $conf_UAM[1] == 'local')
1299                {
1300                switch_lang_to(get_default_language());
1301               
1302                load_language('plugin.lang', UAM_PATH);
1303                $subject = get_l10n_args('UAM_Subject admin validation for %s',$username);
1304
1305                  $content = array(
1306                get_l10n_args('UAM_Manual_validation_needed_for %s', stripslashes($username)),
1307    get_l10n_args('', ''),
1308    get_l10n_args('UAM_Link: %s', AddConfirmMail($id, $email)),
1309    );
1310
1311    UAM_mail_notification_admins($subject, $content);
1312                }
1313                else
1314                {
1315                pwg_mail($email, array(
1316                'subject' => $subject,
1317                'content' => (isset($infos1) ? $infos1_perso.l10n_args($infos1)."\n\n" : "").(isset($infos2) ? $infos2_perso.l10n_args($infos2)."\n\n" : "").get_absolute_root_url(),
1318                ));
1319                }
1320// Switching back to default language
1321// ----------------------------------
1322switch_lang_back();
1323}
1324
1325
1326/**
1327 * Function called from SendMail2User in functions.inc.php to notify admins on user registration validation with validation key
1328 *
1329 * @param:
1330 *   - keyargs_subject: mail subject on l10n_args format
1331 *   - keyargs_content: mail content on l10n_args format
1332 *
1333 * @return boolean (Ok or not)
1334 */
1335function UAM_mail_notification_admins($keyargs_subject, $keyargs_content)
1336{
1337  global $conf, $user;
1338 
1339  // Check arguments
1340  if (empty($keyargs_subject) or empty($keyargs_content))
1341  {
1342    return false;
1343  }
1344
1345  $return = true;
1346
1347  $admins = array();
1348
1349  $query = '
1350SELECT
1351    u.'.$conf['user_fields']['username'].' AS username,
1352    u.'.$conf['user_fields']['email'].' AS mail_address
1353  FROM '.USERS_TABLE.' AS u
1354    JOIN '.USER_INFOS_TABLE.' AS i ON i.user_id =  u.'.$conf['user_fields']['id'].'
1355  WHERE i.status in (\'webmaster\',  \'admin\')
1356    AND '.$conf['user_fields']['email'].' IS NOT NULL
1357    AND i.user_id <> '.$user['id'].'
1358  ORDER BY username
1359;';
1360
1361  $datas = pwg_query($query);
1362  if (!empty($datas))
1363  {
1364    while ($admin = pwg_db_fetch_assoc($datas))
1365    {
1366      if (!empty($admin['mail_address']))
1367      {
1368        array_push($admins, format_email($admin['username'], $admin['mail_address']));
1369      }
1370    }
1371  }
1372
1373  if (count($admins) > 0)
1374  {
1375    $content = l10n_args($keyargs_content)."\n";
1376
1377    $return = pwg_mail(
1378      implode(', ', $admins),
1379      array(
1380        'subject' => '['.$conf['gallery_title'].'] '.l10n_args($keyargs_subject),
1381        'content' => $content,
1382        'content_format' => 'text/plain',
1383        'email_format' => 'text/plain',
1384        )
1385      );
1386  }
1387
1388  return $return;
1389}
1390
1391
1392/**
1393 * Function called from UAM_admin.php to resend validation email with or without new validation key
1394 *
1395 * @param : Type of email, user id, username, email address, confirmation (optional)
1396 *
1397 */
1398function ResendMail2User($typemail, $user_id, $username, $email, $confirm)
1399{
1400  global $conf;
1401 
1402  $subject = "";
1403
1404  $conf_UAM = unserialize($conf['UserAdvManager']);
1405
1406  $conf_UAM_ConfirmMail = unserialize($conf['UserAdvManager_ConfirmMail']);
1407 
1408                include_once(PHPWG_ROOT_PATH.'include/functions_mail.inc.php');
1409 
1410// We have to get the user's language in database
1411// ----------------------------------------------
1412  $query ='
1413SELECT user_id, language
1414FROM '.USER_INFOS_TABLE.'
1415WHERE user_id = '.$user_id.'
1416;';
1417  $data = pwg_db_fetch_assoc(pwg_query($query));
1418  $language = $data['language'];
1419 
1420// And switch gallery to this language before using personalized and multilangual contents
1421// ---------------------------------------------------------------------------------------
1422  switch_lang_to($data['language']);
1423   
1424  load_language('plugin.lang', UAM_PATH);
1425
1426  switch($typemail)
1427  {
1428    case 1: //Generating email content for remind with a new key
1429      if (isset($conf_UAM[42]) and $conf_UAM[42] <> '')
1430      {
1431        // Management of Extension flags ([username], [mygallery])
1432        // -------------------------------------------------------
1433        $patterns[] = '#\[username\]#i';
1434        $replacements[] = $username;
1435        $patterns[] = '#\[mygallery\]#i';
1436        $replacements[] = $conf['gallery_title'];
1437   
1438        if (function_exists('get_user_language_desc'))
1439        {
1440          $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[42]))."\n\n";
1441        }
1442        else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[42]))."\n\n"; 
1443      }
1444     
1445      if (isset($conf_UAM_ConfirmMail[2]) and $conf_UAM_ConfirmMail[2] <> '' and isset($conf_UAM_ConfirmMail[3]) and $conf_UAM_ConfirmMail[3] == 'true' and $confirm)
1446      {
1447                // Management of Extension flags ([username], [mygallery], [myurl], [Kdays])
1448        // -------------------------------------------------------------------------
1449        $patterns[] = '#\[username\]#i';
1450        $replacements[] = $username;
1451        $patterns[] = '#\[mygallery\]#i';
1452        $replacements[] = $conf['gallery_title'];
1453        $patterns[] = '#\[myurl\]#i';
1454        $replacements[] = get_gallery_home_url();
1455
1456        if (isset($conf_UAM_ConfirmMail[0]) and $conf_UAM_ConfirmMail[0] == 'true') // [Kdays] replacement only if related option is active
1457        {
1458          $patterns[] = '#\[Kdays\]#i';
1459          $replacements[] = $conf_UAM_ConfirmMail[1];
1460        }
1461
1462        if (function_exists('get_user_language_desc'))
1463        {
1464          $infos1 = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[2]))."\n\n";
1465        }
1466                                else $infos1 = l10n(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[2]))."\n\n";
1467
1468        $infos2 = array
1469        (
1470          get_l10n_args('UAM_Link: %s', ResetConfirmMail($user_id)),
1471          get_l10n_args('', ''),
1472        );       
1473                                                }
1474
1475// Set reminder true
1476// -----------------     
1477      $query = '
1478UPDATE '.USER_CONFIRM_MAIL_TABLE.'
1479SET reminder = "true"
1480WHERE user_id = '.$user_id.'
1481;';
1482      pwg_query($query);
1483     
1484                                break;
1485     
1486    case 2: //Generating email content for remind without a new key
1487      if (isset($conf_UAM[42]) and $conf_UAM[42] <> '')
1488      {
1489        // Management of Extension flags ([username], [mygallery])
1490        // -------------------------------------------------------
1491        $patterns[] = '#\[username\]#i';
1492        $replacements[] = $username;
1493        $patterns[] = '#\[mygallery\]#i';
1494        $replacements[] = $conf['gallery_title'];
1495   
1496        if (function_exists('get_user_language_desc'))
1497        {
1498          $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[42]))."\n\n";
1499        }
1500        else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[42]))."\n\n"; 
1501      }
1502     
1503      if (isset($conf_UAM_ConfirmMail[4]) and $conf_UAM_ConfirmMail[4] <> '' and isset($conf_UAM_ConfirmMail[3]) and $conf_UAM_ConfirmMail[3] == 'true' and !$confirm)
1504      {
1505        // Management of Extension flags ([username], [mygallery], [myurl], [Kdays])
1506        // -------------------------------------------------------------------------
1507        $patterns[] = '#\[username\]#i';
1508        $replacements[] = $username;
1509        $patterns[] = '#\[mygallery\]#i';
1510        $replacements[] = $conf['gallery_title'];
1511        $patterns[] = '#\[myurl\]#i';
1512        $replacements[] = get_gallery_home_url();
1513
1514        if (isset($conf_UAM_ConfirmMail[0]) and $conf_UAM_ConfirmMail[0] == 'true') // [Kdays] replacement only if related option is active
1515        {
1516          $patterns[] = '#\[Kdays\]#i';
1517          $replacements[] = $conf_UAM_ConfirmMail[1];
1518        }
1519       
1520        if (function_exists('get_user_language_desc'))
1521        {
1522          $infos1 = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[4]))."\n\n";
1523        }
1524        else $infos1 = l10n(preg_replace($patterns, $replacements, $conf_UAM_ConfirmMail[4]))."\n\n";
1525      }
1526     
1527// Set reminder true
1528// -----------------
1529      $query = '
1530UPDATE '.USER_CONFIRM_MAIL_TABLE.'
1531SET reminder = "true"
1532WHERE user_id = '.$user_id.'
1533;';
1534      pwg_query($query);
1535     
1536    break;
1537        }
1538 
1539  pwg_mail($email, array(
1540    'subject' => $subject,
1541    'content' => ($infos1."\n\n").(isset($infos2) ? l10n_args($infos2)."\n\n" : "").get_absolute_root_url(),
1542  ));
1543
1544                // Switching back to default language
1545                // ----------------------------------
1546                switch_lang_back();
1547}
1548
1549
1550/**
1551 * Function called from UAM_admin.php to send a reminder mail for ghost users
1552 *
1553 * @param : User id, username, email address
1554 *
1555 */
1556function ghostreminder($user_id, $username, $email)
1557{
1558  global $conf;
1559
1560  $conf_UAM = unserialize($conf['UserAdvManager']);
1561  $subject = "";
1562 
1563                include_once(PHPWG_ROOT_PATH.'include/functions_mail.inc.php');
1564
1565// We have to get the user's language in database
1566// ----------------------------------------------
1567  $query ='
1568SELECT user_id, language
1569FROM '.USER_INFOS_TABLE.'
1570WHERE user_id = '.$user_id.'
1571;';
1572  $data = pwg_db_fetch_assoc(pwg_query($query));
1573  $language = $data['language'];
1574
1575// And switch gallery to this language before using personalized and multilangual contents
1576// ---------------------------------------------------------------------------------------
1577  switch_lang_to($data['language']);
1578   
1579  load_language('plugin.lang', UAM_PATH);
1580
1581  if (isset($conf_UAM[45]) and $conf_UAM[45] <> '')
1582  {
1583    // Management of Extension flags ([username], [mygallery])
1584    // -------------------------------------------------------
1585    $patterns[] = '#\[username\]#i';
1586    $replacements[] = $username;
1587    $patterns[] = '#\[mygallery\]#i';
1588    $replacements[] = $conf['gallery_title'];
1589
1590    if (function_exists('get_user_language_desc'))
1591    {
1592      $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[45]))."\n\n";
1593    }
1594    else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[45]))."\n\n"; 
1595  }
1596
1597  if (isset($conf_UAM[17]) and $conf_UAM[17] <> '' and isset($conf_UAM[15]) and $conf_UAM[15] == 'true')
1598  {
1599    // Management of Extension flags ([username], [mygallery], [myurl], [days])
1600    // ------------------------------------------------------------------------
1601    $patterns[] = '#\[username\]#i';
1602    $replacements[] = $username;
1603    $patterns[] = '#\[mygallery\]#i';
1604    $replacements[] = $conf['gallery_title'];
1605    $patterns[] = '#\[myurl\]#i';
1606    $replacements[] = get_gallery_home_url();
1607    $patterns[] = '#\[days\]#i';
1608    $replacements[] = $conf_UAM[16];
1609
1610    if (function_exists('get_user_language_desc'))
1611    {
1612      $infos1 = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[17]))."\n\n";
1613    }
1614    else
1615    {
1616      $infos1 = l10n(preg_replace($patterns, $replacements, $conf_UAM[17]))."\n\n";
1617    }
1618
1619    resetlastvisit($user_id);
1620  }
1621
1622  pwg_mail($email, array(
1623    'subject' => $subject,
1624    'content' => $infos1.get_absolute_root_url(),
1625  ));
1626
1627                // Switching back to default language
1628                // ----------------------------------
1629                switch_lang_back();
1630}
1631
1632
1633/**
1634 * Function called from functions.inc.php to send notification email when user have been downgraded
1635 *
1636 * @param : user id, username, email address
1637 *
1638 */
1639function demotion_mail($id, $username, $email)
1640{
1641  global $conf;
1642
1643  $conf_UAM = unserialize($conf['UserAdvManager']);
1644 
1645                include_once(PHPWG_ROOT_PATH.'include/functions_mail.inc.php');
1646 
1647                $custom_txt = "";
1648                $subject = "";
1649
1650// We have to get the user's language in database
1651// ----------------------------------------------
1652  $query = '
1653SELECT user_id, language
1654FROM '.USER_INFOS_TABLE.'
1655WHERE user_id = '.$id.'
1656;';
1657  $data = pwg_db_fetch_assoc(pwg_query($query));
1658
1659// Check if user is already registered (profile changing) - If not (new registration), language is set to current gallery language
1660// -------------------------------------------------------------------------------------------------------------------------------
1661  if (empty($data))
1662  {
1663// And switch gallery to this language before using personalized and multilangual contents
1664// ---------------------------------------------------------------------------------------
1665    $language = pwg_get_session_var( 'lang_switch', $user['language'] );
1666    switch_lang_to($language);
1667  }
1668  else
1669  {
1670// And switch gallery to this language before using personalized and multilangual contents
1671// ---------------------------------------------------------------------------------------
1672    $language = $data['language']; // Usefull for debugging
1673    switch_lang_to($data['language']);
1674    load_language('plugin.lang', UAM_PATH);
1675  }
1676
1677  if (isset($conf_UAM[44]) and $conf_UAM[44] <> '')
1678  {
1679    // Management of Extension flags ([username], [mygallery])
1680    // -------------------------------------------------------
1681    $patterns[] = '#\[username\]#i';
1682    $replacements[] = $username;
1683    $patterns[] = '#\[mygallery\]#i';
1684    $replacements[] = $conf['gallery_title'];
1685
1686    if (function_exists('get_user_language_desc'))
1687    {
1688      $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[44]))."\n\n";
1689    }
1690    else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[44]))."\n\n"; 
1691  }
1692     
1693  if (isset($conf_UAM[24]) and $conf_UAM[24] <> '')
1694  {
1695    // Management of Extension flags ([username], [mygallery], [myurl])
1696    // ----------------------------------------------------------------
1697    $patterns[] = '#\[username\]#i';
1698    $replacements[] = stripslashes($username);
1699    $patterns[] = '#\[mygallery\]#i';
1700    $replacements[] = $conf['gallery_title'];
1701    $patterns[] = '#\[myurl\]#i';
1702    $replacements[] = get_gallery_home_url();
1703
1704    if (function_exists('get_user_language_desc'))
1705    {
1706      $custom_txt = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[24]))."\n\n";
1707    }
1708    else $custom_txt = l10n(preg_replace($patterns, $replacements, $conf_UAM[24]))."\n\n"; 
1709  }
1710
1711  $infos1 = array(
1712    get_l10n_args('UAM_User: %s', stripslashes($username)),
1713    get_l10n_args('Email: %s', $email),
1714    get_l10n_args('', ''),
1715  );
1716
1717  $infos2 = array
1718  (
1719    get_l10n_args('UAM_Link: %s', ResetConfirmMail($id)),
1720    get_l10n_args('', ''),
1721  ); 
1722
1723  resetlastvisit($id);
1724
1725// Sending the email with subject and contents
1726// -------------------------------------------
1727  pwg_mail($email, array(
1728    'subject' => $subject,
1729    'content' => ($custom_txt.l10n_args($infos1)."\n\n".l10n_args($infos2)."\n\n").get_absolute_root_url(),
1730  ));
1731
1732                // Switching back to default language
1733                // ----------------------------------
1734                switch_lang_back();
1735}
1736
1737
1738/**
1739 * Function called from UAM_admin.php to send notification email when user registration have been manually validated by admin
1740 *
1741 * @param : user id
1742 *
1743 */
1744function validation_mail($id)
1745{
1746  global $conf;
1747
1748  $conf_UAM = unserialize($conf['UserAdvManager']);
1749 
1750                include_once(PHPWG_ROOT_PATH.'include/functions_mail.inc.php');
1751 
1752                $custom_txt = "";
1753  $subject = "";
1754
1755// We have to get the user's language in database
1756// ----------------------------------------------
1757  $query ='
1758SELECT user_id, language
1759FROM '.USER_INFOS_TABLE.'
1760WHERE user_id = '.$id.'
1761;';
1762  $data = pwg_db_fetch_assoc(pwg_query($query));
1763
1764// Check if user is already registered (profile changing) - If not (new registration), language is set to current gallery language
1765// -------------------------------------------------------------------------------------------------------------------------------
1766  if (empty($data))
1767  {
1768// And switch gallery to this language before using personalized and multilangual contents
1769// ---------------------------------------------------------------------------------------
1770    $language = pwg_get_session_var( 'lang_switch', $user['language'] );
1771    switch_lang_to($language);
1772  }
1773  else
1774  {
1775// And switch gallery to this language before using personalized and multilangual contents
1776// ---------------------------------------------------------------------------------------
1777    $language = $data['language']; // Usefull for debugging
1778    switch_lang_to($data['language']);
1779    load_language('plugin.lang', UAM_PATH);
1780  }
1781
1782// Retreive users email and user name from id
1783// ------------------------------------------
1784  $query ='
1785SELECT id, username, mail_address
1786FROM '.USERS_TABLE.'
1787WHERE id = '.$id.'
1788;';
1789  $result = pwg_db_fetch_assoc(pwg_query($query));
1790
1791  if (isset($conf_UAM[46]) and $conf_UAM[46] <> '')
1792  {
1793    // Management of Extension flags ([username], [mygallery])
1794    // -------------------------------------------------------
1795    $patterns[] = '#\[username\]#i';
1796    $replacements[] = $result['username'];
1797    $patterns[] = '#\[mygallery\]#i';
1798    $replacements[] = $conf['gallery_title'];
1799
1800    if (function_exists('get_user_language_desc'))
1801    {
1802      $subject = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[46]))."\n\n";
1803    }
1804    else $subject = l10n(preg_replace($patterns, $replacements, $conf_UAM[46]))."\n\n";
1805  }
1806     
1807  if (isset($conf_UAM[27]) and $conf_UAM[27] <> '')
1808  {
1809    // Management of Extension flags ([username], [mygallery], [myurl])
1810    // ----------------------------------------------------------------
1811    $patterns[] = '#\[username\]#i';
1812    $replacements[] = $result['username'];
1813    $patterns[] = '#\[mygallery\]#i';
1814    $replacements[] = $conf['gallery_title'];
1815    $patterns[] = '#\[myurl\]#i';
1816    $replacements[] = get_gallery_home_url();
1817    if (function_exists('get_user_language_desc'))
1818    {
1819      $custom_txt = get_user_language_desc(preg_replace($patterns, $replacements, $conf_UAM[27]))."\n\n";
1820    }
1821    else $custom_txt = l10n(preg_replace($patterns, $replacements, $conf_UAM[27]))."\n\n";
1822  }
1823
1824  $infos = array(
1825    get_l10n_args('UAM_User: %s', stripslashes($result['username'])),
1826    get_l10n_args('Email: %s', $result['mail_address']),
1827    get_l10n_args('', ''),
1828  );
1829
1830// Sending the email with subject and contents
1831// -------------------------------------------
1832  pwg_mail($result['mail_address'], array(
1833    'subject' => $subject,
1834    'content' => (l10n_args($infos)."\n\n".$custom_txt),
1835  ));
1836
1837                // Switching back to default language
1838                // ----------------------------------
1839                switch_lang_back();
1840}
1841
1842
1843/**
1844 * Function called from functions AddConfirmMail and ResetConfirmMail for validation key generation
1845 *
1846 * @return : validation key
1847 *
1848 */
1849function FindAvailableConfirmMailID()
1850{
1851  while (true)
1852  {
1853    $id = generate_key(16);
1854    $query = '
1855SELECT COUNT(*)
1856  FROM '.USER_CONFIRM_MAIL_TABLE.'
1857WHERE id = "'.$id.'"
1858;';
1859    list($count) = pwg_db_fetch_row(pwg_query($query));
1860
1861    if ($count == 0)
1862      return $id;
1863  }
1864}
1865
1866
1867/**
1868 * Function called from functions SendMail2User to process unvalidated users and generate validation key link
1869 *
1870 * @param : User id, email address
1871 *
1872 * @return : Build validation key in URL
1873 *
1874 */
1875function AddConfirmMail($user_id, $email)
1876{
1877  global $conf;
1878
1879  $conf_UAM = unserialize($conf['UserAdvManager']);
1880  $Confirm_Mail_ID = FindAvailableConfirmMailID();
1881
1882  list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
1883 
1884  if (isset($Confirm_Mail_ID))
1885  {
1886    $query = '
1887SELECT status
1888  FROM '.USER_INFOS_TABLE.'
1889WHERE user_id = '.$user_id.'
1890;';
1891    list($status) = pwg_db_fetch_row(pwg_query($query));
1892   
1893    $query = '
1894INSERT INTO '.USER_CONFIRM_MAIL_TABLE.'
1895  (id, user_id, mail_address, status, date_check)
1896VALUES
1897  ("'.$Confirm_Mail_ID.'", '.$user_id.', "'.$email.'", "'.$status.'", null)
1898;';
1899    pwg_query($query);
1900
1901    // Delete user from all groups
1902    // ---------------------------
1903    $query = '
1904DELETE FROM '.USER_GROUP_TABLE.'
1905WHERE user_id = '.$user_id.'
1906  AND (
1907    group_id = '.$conf_UAM[2].'
1908  OR
1909    group_id = '.$conf_UAM[3].'
1910  )
1911;';
1912    pwg_query($query);
1913
1914    // Set user unvalidated status
1915    // ---------------------------
1916    if (!is_admin() and $conf_UAM[7] <> -1)
1917    {
1918      $query = '
1919UPDATE '.USER_INFOS_TABLE.'
1920SET status = "'.$conf_UAM[7].'"
1921WHERE user_id = '.$user_id.'
1922;';
1923      pwg_query($query);
1924    }
1925
1926    // Set user unvalidated group
1927    // --------------------------
1928    if (!is_admin() and $conf_UAM[2] <> -1)
1929    {
1930      $query = '
1931INSERT INTO '.USER_GROUP_TABLE.'
1932  (user_id, group_id)
1933VALUES
1934  ('.$user_id.', '.$conf_UAM[2].')
1935;';
1936      pwg_query($query);
1937    }
1938
1939    // Set user unvalidated privacy level
1940    // ----------------------------------
1941    if (!is_admin() and $conf_UAM[35] <> -1)
1942    {
1943      $query = '
1944UPDATE '.USER_INFOS_TABLE.'
1945SET level = "'.$conf_UAM[35].'"
1946WHERE user_id = '.$user_id.'
1947;';
1948      pwg_query($query);
1949    }
1950   
1951    // Set UAM_validated field to false in #_users table
1952    // -------------------------------------------------
1953    SetUnvalidated($user_id);
1954   
1955    if ( $conf['guest_access'] )
1956    {
1957      return( get_absolute_root_url().'?key='.$Confirm_Mail_ID.'&userid='.$user_id);
1958    }
1959    else
1960    {
1961      return( get_absolute_root_url().'identification.php?key='.$Confirm_Mail_ID.'&userid='.$user_id);
1962    }
1963  }
1964}
1965
1966
1967/**
1968 * Function called from UAM_Adduser() to set group/status/level to new users if manual validation is set
1969 *
1970 * @param : User id
1971 *
1972 *
1973 */
1974function SetPermission($user_id)
1975{
1976  global $conf;
1977 
1978  $conf_UAM = unserialize($conf['UserAdvManager']);
1979
1980// Groups cleanup
1981// --------------
1982  $query = '
1983DELETE FROM '.USER_GROUP_TABLE.'
1984WHERE user_id = '.$user_id.'
1985  AND (
1986    group_id = '.$conf_UAM[2].'
1987  OR
1988    group_id = '.$conf_UAM[3].'
1989  )
1990;';
1991  pwg_query($query);
1992
1993  if (!is_admin() and $conf_UAM[7] <> -1) // Set status
1994  {
1995    $query = '
1996UPDATE '.USER_INFOS_TABLE.'
1997SET status = "'.$conf_UAM[7].'"
1998WHERE user_id = '.$user_id.'
1999;';
2000    pwg_query($query);
2001  }
2002
2003  if (!is_admin() and $conf_UAM[2] <> -1) // Set group
2004  {
2005    $query = '
2006INSERT INTO '.USER_GROUP_TABLE.'
2007  (user_id, group_id)
2008VALUES
2009  ('.$user_id.', '.$conf_UAM[2].')
2010;';
2011    pwg_query($query);
2012  }
2013
2014  if (!is_admin() and $conf_UAM[35] <> -1) // Set privacy level
2015  {
2016    $query = '
2017INSERT INTO '.USER_INFOS_TABLE.'
2018  (user_id, level)
2019VALUES
2020  ('.$user_id.', "'.$conf_UAM[35].'")
2021;';
2022    pwg_query($query);
2023  }
2024}
2025
2026
2027/**
2028 * Function called from UAM_admin.php to reset validation key
2029 *
2030 * @param : User id
2031 *
2032 * @return : Build validation key in URL
2033 *
2034 */
2035function ResetConfirmMail($user_id)
2036{
2037  global $conf;
2038 
2039  $Confirm_Mail_ID = FindAvailableConfirmMailID();
2040
2041  list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
2042 
2043  if (isset($Confirm_Mail_ID))
2044  { 
2045    $query = '
2046UPDATE '.USER_CONFIRM_MAIL_TABLE.'
2047SET id = "'.$Confirm_Mail_ID.'"
2048WHERE user_id = '.$user_id.'
2049;';
2050    pwg_query($query);
2051
2052    $query = '
2053UPDATE '.USER_INFOS_TABLE.'
2054SET registration_date = "'.$dbnow.'"
2055WHERE user_id = '.$user_id.'
2056;';
2057    pwg_query($query);
2058   
2059    if ( $conf['guest_access'] )
2060    {
2061      return( get_absolute_root_url().'?key='.$Confirm_Mail_ID.'&userid='.$user_id);
2062    }
2063    else
2064    {
2065      return( get_absolute_root_url().'identification.php?key='.$Confirm_Mail_ID.'&userid='.$user_id);
2066    }
2067  }
2068}
2069
2070
2071/**
2072 * Function called from functions.inc.php to reset last visit date after sending a reminder
2073 *
2074 * @param : User id
2075 *
2076 */
2077function resetlastvisit($user_id)
2078{
2079  global $conf;
2080
2081  list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
2082
2083  $query = '
2084UPDATE '.USER_LASTVISIT_TABLE.'
2085SET lastvisit = "'.$dbnow.'", reminder = "true"
2086WHERE user_id = '.$user_id.'
2087;';
2088  pwg_query($query);
2089}
2090
2091
2092/**
2093 * Function called from main.inc.php - Triggered on user deletion
2094 *
2095 */
2096function DeleteConfirmMail($user_id)
2097{
2098  $query = '
2099DELETE FROM '.USER_CONFIRM_MAIL_TABLE.'
2100WHERE user_id = '.$user_id.'
2101;';
2102  pwg_query($query);
2103}
2104
2105/**
2106 * Function called from main.inc.php - Triggered on user deletion
2107 *
2108 */
2109function DeleteLastVisit($user_id)
2110{
2111  $query = '
2112DELETE FROM '.USER_LASTVISIT_TABLE.'
2113WHERE user_id = '.$user_id.'
2114;';
2115  pwg_query($query);
2116}
2117
2118
2119/**
2120 * Function called from main.inc.php - Triggered on user deletion
2121 *
2122 * @param : User id
2123 *
2124 */
2125function DeleteRedir($user_id)
2126{
2127  $tab = array();
2128
2129  $query = '
2130SELECT value
2131FROM '.CONFIG_TABLE.'
2132WHERE param = "UserAdvManager_Redir"
2133;';
2134
2135  $tab = pwg_db_fetch_row(pwg_query($query));
2136 
2137  $values = explode(',', $tab[0]);
2138
2139  unset($values[array_search($user_id, $values)]);
2140     
2141  $query = '
2142UPDATE '.CONFIG_TABLE.'
2143SET value = "'.implode(',', $values).'"
2144WHERE param = "UserAdvManager_Redir";';
2145
2146  pwg_query($query);
2147}
2148
2149
2150/**
2151 * Function called from ConfirmMail.php to verify validation key used by user according time limit
2152 * Return true is key validation is OK else return false
2153 *
2154 * @param : User id
2155 *
2156 * @return : Bool
2157 *
2158 */
2159function VerifyConfirmMail($id)
2160{
2161  global $conf;
2162
2163  include_once(PHPWG_ROOT_PATH.'admin/include/functions.php');
2164 
2165  $conf_UAM = unserialize($conf['UserAdvManager']);
2166
2167  $conf_UAM_ConfirmMail = unserialize($conf['UserAdvManager_ConfirmMail']);
2168
2169  $query = '
2170SELECT COUNT(*)
2171FROM '.USER_CONFIRM_MAIL_TABLE.'
2172WHERE id = "'.$id.'"
2173;';
2174  list($count) = pwg_db_fetch_row(pwg_query($query));
2175
2176  if ($count == 1)
2177  {
2178    $query = '
2179SELECT user_id, status, date_check
2180FROM '.USER_CONFIRM_MAIL_TABLE.'
2181WHERE id = "'.$id.'"
2182;';
2183    $data = pwg_db_fetch_assoc(pwg_query($query));
2184
2185    if (!empty($data) and isset($data['user_id']) and is_null($data['date_check']))
2186    {
2187      $query = '
2188SELECT registration_date
2189FROM '.USER_INFOS_TABLE.'
2190WHERE user_id = '.$data['user_id'].'
2191;';
2192      list($registration_date) = pwg_db_fetch_row(pwg_query($query));
2193
2194//              Time limit process             
2195// ******************************************** 
2196      if (!empty($registration_date))
2197      {
2198                                                                // Verify Confirmmail with time limit ON
2199                                // -------------------------------------
2200                                                                if (isset ($conf_UAM_ConfirmMail[1]))
2201                                                                {
2202                                                                                // Dates formating and compare
2203                                        // ---------------------------
2204                                                                                $today = date("d-m-Y"); // Get today's date
2205                                                                                list($day, $month, $year) = explode('-', $today); // explode date of today                                               
2206                                                                        $daytimestamp = mktime(0, 0, 0, $month, $day, $year);// Generate UNIX timestamp
2207
2208                                                                list($regdate, $regtime) = explode(' ', $registration_date); // Explode date and time from registration date
2209                                                                                list($regyear, $regmonth, $regday) = explode('-', $regdate); // Explode date from registration date
2210                                                                                $regtimestamp = mktime(0, 0, 0, $regmonth, $regday, $regyear);// Generate UNIX timestamp
2211
2212                                                                                $deltasecs = $daytimestamp - $regtimestamp;// Compare the 2 UNIX timestamps     
2213                                                                                $deltadays = floor($deltasecs / 86400);// Convert result from seconds to days
2214
2215                                                                                // Condition with the value set for time limit
2216                                        // -------------------------------------------
2217                                                                                if ($deltadays <= $conf_UAM_ConfirmMail[1]) // If Nb of days is less than the limit set
2218                                                                                {
2219                                                                                                list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
2220
2221                                        // Update ConfirmMail table
2222                                        // ------------------------
2223                                                                                                $query = '
2224UPDATE '.USER_CONFIRM_MAIL_TABLE.'
2225SET date_check="'.$dbnow.'", reminder="false"
2226WHERE id = "'.$id.'"
2227;';
2228                                                                                                pwg_query($query);
2229
2230                                        // Update LastVisit table - Force reminder field to false
2231                                        // Usefull when a user has been automatically downgraded and revalidate its registration
2232                                        // -------------------------------------------------------------------------------------
2233                                                                                                $query = '
2234UPDATE '.USER_LASTVISIT_TABLE.'
2235SET reminder="false"
2236WHERE user_id = "'.$data['user_id'].'"
2237;';
2238                                                                                                pwg_query($query);
2239     
2240                                                                                                if ($conf_UAM[2] <> -1) // Delete user from unvalidated users group
2241                                                                                                {
2242                                                                                                                $query = '
2243DELETE FROM '.USER_GROUP_TABLE.'
2244WHERE user_id = '.$data['user_id'].'
2245  AND group_id = '.$conf_UAM[2].'
2246;';
2247                                                                                                                pwg_query($query);
2248                                                                                                }
2249
2250                                                                                                if ($conf_UAM[3] <> -1) // Add user to validated users group
2251                                                                                                {
2252                                                                                                                $query = '
2253INSERT INTO '.USER_GROUP_TABLE.'
2254  (user_id, group_id)
2255VALUES
2256  ('.$data['user_id'].', '.$conf_UAM[3].')
2257;';
2258                                                                                                                pwg_query($query);
2259                                                                                                }
2260
2261                                                                                                if ($conf_UAM[4] <> -1) // Change user's status
2262                                                                                                {
2263                                                                                                                $query = '
2264UPDATE '.USER_INFOS_TABLE.'
2265SET status = "'.$conf_UAM[4].'"
2266WHERE user_id = '.$data['user_id'].'
2267;';
2268                                                                                                                pwg_query($query);
2269                                                                                                }
2270
2271                                                                                                if ($conf_UAM[36] <> -1) // Change user's privacy level
2272                                                                                                {
2273                                                                                                                $query = '
2274UPDATE '.USER_INFOS_TABLE.'
2275SET level = "'.$conf_UAM[36].'"
2276WHERE user_id = '.$data['user_id'].'
2277;';
2278                                                                                                                pwg_query($query);
2279                                                                                                }
2280
2281                                                                                                // Set UAM_validated field to True in #_users table
2282                                                                                                $query = '
2283UPDATE '.USERS_TABLE.'
2284SET UAM_validated = "true"
2285WHERE id = '.$data['user_id'].'
2286;';
2287                                                                                                pwg_query($query);
2288
2289                                                                                                // Refresh user's category cache
2290                                                // -----------------------------
2291                                                                                                invalidate_user_cache();
2292
2293                                                                                                return true;
2294                                                                                }
2295                                                                                elseif ($deltadays > $conf_UAM_ConfirmMail[1]) // If timelimit exeeds
2296                                                                                {
2297                                                                                                return false;
2298                                                                                }
2299                                                                }
2300                                                                // Verify Confirmmail with time limit OFF
2301                                // --------------------------------------
2302                                                                else
2303                                                                {
2304                                                                                list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
2305
2306                                // Update ConfirmMail table
2307                                // ------------------------
2308                                                                                $query = '
2309UPDATE '.USER_CONFIRM_MAIL_TABLE.'
2310SET date_check="'.$dbnow.'"
2311WHERE id = "'.$id.'"
2312;';
2313                                                                                pwg_query($query);
2314
2315                                // Update LastVisit table - Force reminder field to false
2316                                // Usefull when a user has been automatically downgraded and revalidate its registration
2317                                // -------------------------------------------------------------------------------------
2318                                                                                $query = '
2319UPDATE '.USER_LASTVISIT_TABLE.'
2320SET reminder="false"
2321WHERE user_id = "'.$data['user_id'].'"
2322;';
2323                                pwg_query($query);
2324
2325                                                                                if ($conf_UAM[2] <> -1) // Delete user from unvalidated users group
2326                                                                                {
2327                                                                                                $query = '
2328DELETE FROM '.USER_GROUP_TABLE.'
2329WHERE user_id = '.$data['user_id'].'
2330AND group_id = '.$conf_UAM[2].'
2331;';
2332                                                                                                pwg_query($query);
2333                                                                                }
2334
2335                                                                                if ($conf_UAM[3] <> -1)
2336                                                                                {
2337                                                                                                $query = '
2338DELETE FROM '.USER_GROUP_TABLE.'
2339WHERE user_id = '.$data['user_id'].'
2340AND group_id = '.$conf_UAM[3].'
2341;';
2342                                                                                                pwg_query($query);
2343
2344                                                                                                $query = '
2345INSERT INTO '.USER_GROUP_TABLE.'
2346  (user_id, group_id)
2347VALUES
2348  ('.$data['user_id'].', '.$conf_UAM[3].')
2349;';
2350                                                                                                pwg_query($query);
2351                                                                                }
2352
2353                                                                                if ($conf_UAM[4] <> -1) // Change user's status
2354                                                                                {
2355                                                                                                $query = '
2356UPDATE '.USER_INFOS_TABLE.'
2357SET status = "'.$conf_UAM[4].'"
2358WHERE user_id = '.$data['user_id'].'
2359;';
2360                                                                                                pwg_query($query);
2361                                                                                }
2362
2363                                                                                if ($conf_UAM[36] <> -1) // Change user's privacy level
2364                                                                                {
2365                                                                                                $query = '
2366UPDATE '.USER_INFOS_TABLE.'
2367SET level = "'.$conf_UAM[36].'"
2368WHERE user_id = '.$data['user_id'].'
2369;';
2370                                                                                                pwg_query($query);
2371                                                                                }
2372
2373                                                                                // Set UAM_validated field to True in #_users table
2374                                                                                $query = '
2375UPDATE '.USERS_TABLE.'
2376SET UAM_validated = "true"
2377WHERE id = '.$data['user_id'].'
2378;';
2379                                                                                pwg_query($query);
2380
2381                                                                                // Refresh user's category cache
2382                                // -----------------------------
2383                                                                                invalidate_user_cache();
2384
2385                                                                                return true;
2386                                                                }
2387                                                }
2388                                }
2389    else if (!empty($data) and !is_null($data['date_check']))
2390    {
2391      return false;
2392    }
2393                }
2394  else
2395    return false;
2396}
2397
2398
2399/**
2400 * Function called from UAM_admin.php for manual validation by admin
2401 *
2402 * @param : User id
2403 *
2404 */
2405function ManualValidation($id)
2406{
2407                global $conf;
2408
2409                $conf_UAM = unserialize($conf['UserAdvManager']);
2410
2411                if (isset($conf_UAM[1]) and $conf_UAM[1] == 'true') // Set date of validation
2412                {
2413                                list($dbnow) = pwg_db_fetch_row(pwg_query('SELECT NOW();'));
2414
2415                                $query = '
2416UPDATE '.USER_CONFIRM_MAIL_TABLE.'
2417SET date_check="'.$dbnow.'"
2418WHERE user_id = '.$id.'
2419;';
2420                                pwg_query($query);
2421                }
2422
2423                if ($conf_UAM[2] <> -1) // Delete user from waiting group
2424                {
2425                                $query = '
2426DELETE FROM '.USER_GROUP_TABLE.'
2427WHERE user_id = '.$id.'
2428                AND group_id = '.$conf_UAM[2].'
2429;';
2430                                pwg_query($query);
2431                }
2432 
2433                if ($conf_UAM[3] <> -1) // Set user's valid group
2434                {
2435                                $query = '
2436DELETE FROM '.USER_GROUP_TABLE.'
2437WHERE user_id = '.$id.'
2438                AND group_id = '.$conf_UAM[3].'
2439;';
2440                                pwg_query($query);
2441       
2442                                $query = '
2443INSERT INTO '.USER_GROUP_TABLE.'
2444                (user_id, group_id)
2445VALUES
2446                ('.$id.', '.$conf_UAM[3].')
2447;';
2448                                pwg_query($query);
2449                }
2450
2451                if ($conf_UAM[4] <> -1) // Set user's valid status
2452                {
2453                                $query = '
2454UPDATE '.USER_INFOS_TABLE.'
2455SET status = "'.$conf_UAM[4].'"
2456WHERE user_id = '.$id.'
2457;';
2458                                pwg_query($query);
2459                }
2460
2461                if ($conf_UAM[36] <> -1) // Set user's valid privacy level
2462                {
2463                                $query = '
2464UPDATE '.USER_INFOS_TABLE.'
2465SET level = "'.$conf_UAM[36].'"
2466WHERE user_id = '.$id.'
2467;';
2468                                pwg_query($query);
2469                }
2470
2471                // Set UAM_validated field to True in #_users table
2472                $query = '
2473UPDATE '.USERS_TABLE.'
2474SET UAM_validated = "true"
2475WHERE id = '.$id.'
2476;';
2477                pwg_query($query);
2478}
2479
2480
2481/**
2482 * Function called from functions.inc.php - Check if username matches forbidden characters
2483 *
2484 * @param : User login
2485 *
2486 * @return : Bool
2487 *
2488 */
2489function ValidateUsername($login)
2490{
2491  global $conf;
2492
2493  $conf_UAM = unserialize($conf['UserAdvManager']);
2494
2495  if (isset($login) and isset($conf_UAM[6]) and $conf_UAM[6] <> '')
2496  {
2497    $conf_CharExclusion = preg_split("/,/",$conf_UAM[6]);
2498    for ($i = 0 ; $i < count($conf_CharExclusion) ; $i++)
2499    {
2500      //Detect meta-characters (# ! ^ $ ( ) [ ] { } ? + * . \ -) for special pattern
2501      if ($conf_CharExclusion[$i] == "#"
2502       or $conf_CharExclusion[$i] == "$"
2503       or $conf_CharExclusion[$i] == "!"
2504       or $conf_CharExclusion[$i] == "^"
2505       or $conf_CharExclusion[$i] == "*"
2506       or $conf_CharExclusion[$i] == "?"
2507       or $conf_CharExclusion[$i] == "+"
2508       or $conf_CharExclusion[$i] == "."
2509       or $conf_CharExclusion[$i] == "\\"
2510       or $conf_CharExclusion[$i] == "|"
2511       or $conf_CharExclusion[$i] == "["
2512       or $conf_CharExclusion[$i] == "]"
2513       or $conf_CharExclusion[$i] == "("
2514       or $conf_CharExclusion[$i] == ")"
2515       or $conf_CharExclusion[$i] == "{"
2516       or $conf_CharExclusion[$i] == "}"
2517       or $conf_CharExclusion[$i] == "-")
2518      {
2519        $pattern = '/[][^$.\*+?(){}#|-]/i';
2520      }
2521      else
2522      {
2523        $pattern = '/'.$conf_CharExclusion[$i].'/i';
2524      }
2525
2526      if (preg_match($pattern, $login))
2527      {
2528        return true;
2529      }
2530    }
2531  }
2532  else
2533  {
2534    return false;
2535  }
2536}
2537
2538
2539/**
2540 * Function called from main.inc.php - Check if user's email is in excluded email providers list
2541 * Doesn't work on call - Must be copied in main.inc.php to work
2542 *
2543 * @param : Email address
2544 *
2545 * @return : Bool
2546 *
2547 */
2548function ValidateEmailProvider($email)
2549{
2550  global $conf;
2551
2552  $conf_UAM = unserialize($conf['UserAdvManager']);
2553 
2554                if (isset($email) and isset($conf_UAM[11]) and $conf_UAM[11] <> '')
2555                {
2556                                $conf_MailExclusion = preg_split("/[\s,]+/",$conf_UAM[11]);
2557                                for ($i = 0 ; $i < count($conf_MailExclusion) ; $i++)
2558                                {
2559                                                $pattern = '/'.$conf_MailExclusion[$i].'/i';
2560                                                if (preg_match($pattern, $email))
2561      {
2562                return true;
2563      }
2564                                }
2565                }
2566  else
2567  {
2568    return false;
2569  }
2570}
2571
2572
2573/**
2574 * Function called from UAM_admin.php - Get unvalidated users according time limit
2575 *
2576 * @return : List of users
2577 *
2578 */
2579function get_unvalid_user_list()
2580{
2581                global $conf, $page;
2582         
2583                // Get ConfirmMail configuration
2584  // -----------------------------
2585  $conf_UAM_ConfirmMail = unserialize($conf['UserAdvManager_ConfirmMail']);
2586  // Get UAM configuration
2587  // ---------------------
2588  $conf_UAM = unserialize($conf['UserAdvManager']);
2589 
2590  $users = array();
2591
2592                // Search users depending expiration date
2593  // --------------------------------------
2594  $query = '
2595SELECT DISTINCT u.'.$conf['user_fields']['id'].' AS id,
2596                u.'.$conf['user_fields']['username'].' AS username,
2597                u.'.$conf['user_fields']['email'].' AS email,
2598                ui.status,
2599                ui.enabled_high,
2600                ui.level,
2601                ui.registration_date
2602FROM '.USERS_TABLE.' AS u
2603  INNER JOIN '.USER_INFOS_TABLE.' AS ui
2604    ON u.'.$conf['user_fields']['id'].' = ui.user_id
2605  LEFT JOIN '.USER_GROUP_TABLE.' AS ug
2606    ON u.'.$conf['user_fields']['id'].' = ug.user_id
2607WHERE u.'.$conf['user_fields']['id'].' >= 3
2608  AND (TO_DAYS(NOW()) - TO_DAYS(ui.registration_date) >= "'.$conf_UAM_ConfirmMail[1].'"
2609  OR TO_DAYS(NOW()) - TO_DAYS(ui.registration_date) < "'.$conf_UAM_ConfirmMail[1].'")
2610                AND u.UAM_validated = "false"
2611ORDER BY ui.registration_date ASC
2612;';
2613
2614                $result = pwg_query($query);
2615     
2616  while ($row = pwg_db_fetch_assoc($result))
2617  {
2618                $user = $row;
2619    $user['groups'] = array();
2620
2621    array_push($users, $user);
2622                }
2623
2624                // Add groups list
2625  // ---------------
2626  $user_ids = array();
2627  foreach ($users as $i => $user)
2628  {
2629                $user_ids[$i] = $user['id'];
2630                }
2631
2632                $user_nums = array_flip($user_ids);
2633
2634  if (count($user_ids) > 0)
2635  {
2636                $query = '
2637SELECT user_id, group_id
2638  FROM '.USER_GROUP_TABLE.'
2639WHERE user_id IN ('.implode(',', $user_ids).')
2640;';
2641       
2642                                $result = pwg_query($query);
2643       
2644    while ($row = pwg_db_fetch_assoc($result))
2645    {
2646                array_push(
2647                $users[$user_nums[$row['user_id']]]['groups'],
2648        $row['group_id']
2649                                                );
2650                                }
2651                }
2652
2653                return $users;
2654}
2655
2656
2657/**
2658 * Function called from functions.inc.php - Get all users who haven't validate their registration in configured time
2659 * to delete or remail them automatically
2660 *
2661 * @return : List of users
2662 *
2663 */
2664function get_unvalid_user_autotasks()
2665{
2666                global $conf, $page;
2667         
2668                // Get ConfirmMail configuration
2669  // -----------------------------
2670  $conf_UAM_ConfirmMail = unserialize($conf['UserAdvManager_ConfirmMail']);
2671 
2672  $users = array();
2673
2674                // search users depending expiration date
2675  // --------------------------------------
2676  $query = '
2677SELECT DISTINCT u.'.$conf['user_fields']['id'].' AS id,
2678                ui.registration_date
2679FROM '.USERS_TABLE.' AS u
2680  INNER JOIN '.USER_INFOS_TABLE.' AS ui
2681    ON u.'.$conf['user_fields']['id'].' = ui.user_id
2682WHERE u.'.$conf['user_fields']['id'].' >= 3
2683  AND (TO_DAYS(NOW()) - TO_DAYS(ui.registration_date) >= "'.$conf_UAM_ConfirmMail[1].'")
2684ORDER BY ui.registration_date ASC;';
2685
2686                $result = pwg_query($query);
2687
2688  while ($row = pwg_db_fetch_assoc($result))
2689  {
2690    array_push($users, $row);
2691                }
2692
2693                return $users;
2694}
2695
2696
2697/**
2698 * Function called from UAM_admin.php - Get ghost users
2699 *
2700 * @return : List of users
2701 *
2702 */
2703function get_ghost_user_list()
2704{
2705                global $conf, $page;
2706
2707  $conf_UAM = unserialize($conf['UserAdvManager']);
2708
2709  $users = array();
2710
2711                // Search users depending expiration date
2712  // --------------------------------------
2713  $query = '
2714SELECT DISTINCT u.'.$conf['user_fields']['id'].' AS id,
2715                u.'.$conf['user_fields']['username'].' AS username,
2716                u.'.$conf['user_fields']['email'].' AS email,
2717                lv.lastvisit,
2718                lv.reminder
2719FROM '.USERS_TABLE.' AS u
2720  INNER JOIN '.USER_LASTVISIT_TABLE.' AS lv
2721    ON u.'.$conf['user_fields']['id'].' = lv.user_id
2722WHERE (TO_DAYS(NOW()) - TO_DAYS(lv.lastvisit) >= "'.$conf_UAM[16].'")
2723ORDER BY lv.lastvisit ASC;';
2724
2725                $result = pwg_query($query);
2726     
2727  while ($row = pwg_db_fetch_assoc($result))
2728  {
2729                $user = $row;
2730    $user['groups'] = array();
2731
2732    array_push($users, $user);
2733                }
2734
2735                // Add groups list
2736  // ---------------
2737  $user_ids = array();
2738  foreach ($users as $i => $user)
2739  {
2740        $user_ids[$i] = $user['id'];
2741                }
2742
2743                return $users;
2744}
2745
2746
2747/**
2748 * Function called from functions.inc.php - Get all ghost users to delete or downgrade automatically on any user login
2749 *
2750 * @return : List of users to delete or downgrade automatically
2751 *
2752 */
2753function get_ghosts_autotasks()
2754{
2755                global $conf, $page;
2756
2757  $conf_UAM = unserialize($conf['UserAdvManager']);
2758 
2759  $users = array();
2760 
2761                // Search users depending expiration date and reminder sent
2762  // --------------------------------------------------------
2763  $query = '
2764SELECT DISTINCT u.'.$conf['user_fields']['id'].' AS id,
2765                lv.lastvisit
2766FROM '.USERS_TABLE.' AS u
2767  INNER JOIN '.USER_LASTVISIT_TABLE.' AS lv
2768    ON u.'.$conf['user_fields']['id'].' = lv.user_id
2769WHERE (TO_DAYS(NOW()) - TO_DAYS(lv.lastvisit) >= "'.$conf_UAM[16].'")
2770ORDER BY lv.lastvisit ASC;';
2771
2772                $result = pwg_query($query);
2773     
2774                while ($row = pwg_db_fetch_assoc($result))
2775  {
2776    array_push($users, $row);
2777                }
2778 
2779                return $users;
2780}
2781
2782
2783/**
2784 * Function called from UAM_admin.php - Get all users to display the number of days since their last visit
2785 *
2786 * @return : List of users
2787 *
2788 */
2789function get_user_list()
2790{
2791                global $conf, $page;
2792 
2793  $users = array();
2794
2795                // Search users depending expiration date with exclusion of Adult_Content generic users
2796  // ------------------------------------------------------------------------------------
2797  $query = '
2798SELECT DISTINCT u.'.$conf['user_fields']['id'].' AS id,
2799                u.'.$conf['user_fields']['username'].' AS username,
2800                u.'.$conf['user_fields']['email'].' AS email,
2801                ug.lastvisit
2802FROM '.USERS_TABLE.' AS u
2803  INNER JOIN '.USER_LASTVISIT_TABLE.' AS ug
2804    ON u.'.$conf['user_fields']['id'].' = ug.user_id
2805WHERE u.'.$conf['user_fields']['id'].' >= 3
2806  AND u.username NOT LIKE "16"
2807  AND u.username NOT LIKE "18"
2808ORDER BY ug.lastvisit DESC
2809;';
2810
2811                $result = pwg_query($query);
2812     
2813  while ($row = pwg_db_fetch_assoc($result))
2814  {
2815                $user = $row;
2816    $user['groups'] = array();
2817
2818    array_push($users, $user);
2819                }
2820
2821                // Add groups list
2822  // ---------------
2823  $user_ids = array();
2824  foreach ($users as $i => $user)
2825  {
2826                        $user_ids[$i] = $user['id'];
2827                }
2828
2829                return $users;
2830}
2831
2832
2833/**
2834 * Function called from UAM_admin.php - to determine who is expired or not and giving a different display color
2835 *
2836 * @param : user id
2837 *
2838 * @return : Bool
2839 *
2840 */
2841function expiration($id)
2842{
2843        global $conf, $page;
2844         
2845                // Get ConfirmMail configuration
2846  // -----------------------------
2847  $conf_UAM_ConfirmMail = unserialize($conf['UserAdvManager_ConfirmMail']);
2848         
2849                // Get UAM configuration
2850  // ---------------------
2851  $conf_UAM = unserialize($conf['UserAdvManager']);
2852       
2853                $query = '
2854SELECT registration_date
2855  FROM '.USER_INFOS_TABLE.'
2856WHERE user_id = '.$id.'
2857;';
2858                list($registration_date) = pwg_db_fetch_row(pwg_query($query));
2859
2860//              Time limit process             
2861// ******************************************** 
2862                if (!empty($registration_date))
2863  {
2864                                // Dates formating and compare
2865                // ---------------------------
2866                                $today = date("d-m-Y"); // Get today's date
2867                                list($day, $month, $year) = explode('-', $today); // explode date of today                                               
2868                        $daytimestamp = mktime(0, 0, 0, $month, $day, $year);// Generate UNIX timestamp
2869               
2870                list($regdate, $regtime) = explode(' ', $registration_date); // Explode date and time from registration date
2871                                list($regyear, $regmonth, $regday) = explode('-', $regdate); // Explode date from registration date
2872                                $regtimestamp = mktime(0, 0, 0, $regmonth, $regday, $regyear);// Generate UNIX timestamp
2873                       
2874                                $deltasecs = $daytimestamp - $regtimestamp;// Compare the 2 UNIX timestamps     
2875                                $deltadays = floor($deltasecs / 86400);// Convert result from seconds to days
2876
2877                                // Condition with the value set for time limit
2878    // -------------------------------------------
2879                                if ($deltadays <= $conf_UAM_ConfirmMail[1]) // If Nb of days is less than the limit set
2880                                {
2881                                                return false;
2882                                }
2883                                else
2884                                {
2885                                                return true;
2886                                }
2887                }
2888}
2889
2890
2891/**
2892 * Returns a password's score for password complexity check
2893 *
2894 * @param : password filled by user
2895 *
2896 * @return : Score calculation
2897 *
2898 * Thanx to MathieuGut from http://m-gut.developpez.com
2899 */
2900function testpassword($password) // $password given by user
2901{
2902
2903  // Variables initiation
2904  // --------------------
2905  $points = 0;
2906  $point_lowercase = 0;
2907  $point_uppercase = 0;
2908  $point_numbers = 0;
2909  $point_characters = 0;
2910
2911  // Getting password lengh
2912  // ----------------------
2913  $length = strlen($password);
2914
2915  // Loop to read password characters
2916  for($i = 0; $i < $length; $i++)
2917  {
2918    // Select each letters
2919    // $i is 0 at first turn
2920    // ---------------------
2921    $letters = $password[$i];
2922
2923    if ($letters>='a' && $letters<='z')
2924    {
2925      // Adding 1 point to score for a lowercase
2926      // ---------------------------------------
2927                                $points = $points + 1;
2928
2929                                // Adding bonus points for lowercase
2930      // ---------------------------------
2931                  $point_lowercase = 1;
2932    }
2933    else if ($letters>='A' && $letters <='Z')
2934    {
2935      // Adding 2 points to score for uppercase
2936      // --------------------------------------
2937      $points = $points + 2;
2938               
2939      // Adding bonus points for uppercase
2940      // ---------------------------------
2941      $point_uppercase = 2;
2942    }
2943    else if ($letters>='0' && $letters<='9')
2944    {
2945      // Adding 3 points to score for numbers
2946      // ------------------------------------
2947      $points = $points + 3;
2948               
2949      // Adding bonus points for numbers
2950      // -------------------------------
2951      $point_numbers = 3;
2952    }
2953    else
2954    {
2955      // Adding 5 points to score for special characters
2956      // -----------------------------------------------
2957      $points = $points + 5;
2958               
2959      // Adding bonus points for special characters
2960      // ------------------------------------------
2961      $point_characters = 5;
2962    }
2963  }
2964
2965  // Calculating the coefficient points/length
2966  // -----------------------------------------
2967  $step1 = $points / $length;
2968
2969  // Calculation of the diversity of character types...
2970  // --------------------------------------------------
2971  $step2 = $point_lowercase + $point_uppercase + $point_numbers + $point_characters;
2972
2973  // Multiplying the coefficient of diversity with that of the length
2974  // ----------------------------------------------------------------
2975  $score = $step1 * $step2;
2976
2977  // Multiplying the result by the length of the string
2978  // --------------------------------------------------
2979  $finalscore = $score * $length;
2980
2981  return $finalscore;
2982}
2983
2984
2985/**
2986 * UAM_check_profile - Thx to LucMorizur
2987 * checks if a user id is registered as having already
2988 * visited his profile page.
2989 *
2990 * @uid        : the user id
2991 *
2992 * @user_idsOK : (returned) array of all users ids having already visited
2993 *               their profile.php pages
2994 *
2995 * @returns    : true or false whether the users has already visited his
2996 *               profile.php page or not
2997 *
2998 */
2999function UAM_check_profile($uid, &$user_idsOK)
3000{
3001  $t = array();
3002  $v = false;
3003 
3004  $query = '
3005SELECT value
3006FROM '.CONFIG_TABLE.'
3007WHERE param = "UserAdvManager_Redir"
3008;';
3009 
3010  if ($v = (($t = pwg_db_fetch_row(pwg_query($query))) !== false))
3011  {
3012    $user_idsOK = explode(',', $t[0]);
3013    $v = (in_array($uid, $user_idsOK));
3014  }
3015  return $v;
3016}
3017
3018
3019/**
3020 * UAM_check_pwdreset
3021 * checks if a user id is registered as having already
3022 * changed his password.
3023 *
3024 * @uid        : the user id
3025 *
3026 * @returns    : true or false whether the users has already changed his password
3027 *
3028 */
3029function UAM_check_pwgreset($uid)
3030{
3031  $query = '
3032SELECT UAM_pwdreset
3033FROM '.USERS_TABLE.'
3034WHERE id='.$uid.'
3035;';
3036
3037  $result = pwg_db_fetch_assoc(pwg_query($query));
3038 
3039  if($result['UAM_pwdreset'] == 'true')
3040  {
3041    return true;
3042  }
3043  else return false; 
3044}
3045
3046
3047/**
3048 * UAM_UsrReg_Verif
3049 * Check if the user who logged-in have validate his registration
3050 *
3051 * @returns : True if validation is OK else False
3052 */
3053function UAM_UsrReg_Verif($user_id)
3054{
3055  global $conf;
3056
3057  $query = '
3058SELECT UAM_validated
3059FROM '.USERS_TABLE.'
3060WHERE id='.$user_id.'
3061;';
3062
3063  $result = pwg_db_fetch_assoc(pwg_query($query));
3064
3065  if($result['UAM_validated'] == 'true')
3066  {
3067    return true;
3068  }
3069  else return false;
3070}
3071
3072
3073/**
3074 * SetUnvalidated
3075 * Set UAM_validated field to false in #_users table
3076 *
3077 **/
3078function SetUnvalidated($user_id)
3079{
3080  $query ='
3081UPDATE '.USERS_TABLE.'
3082SET UAM_validated = "false"
3083WHERE id = '.$user_id.'
3084LIMIT 1
3085;';
3086
3087  pwg_query($query);
3088}
3089
3090
3091/**
3092 * UAM_Set_PwdReset
3093 * Action in user_list to set a password reset for a user
3094 */
3095function UAM_Set_PwdReset($uid)
3096{
3097  $query ='
3098UPDATE '.USERS_TABLE.'
3099SET UAM_pwdreset = "true"
3100WHERE id = '.$uid.'
3101LIMIT 1
3102;';
3103
3104  pwg_query($query);
3105}
3106
3107
3108/**
3109 * UAM_loc_visible_user_list
3110 * Adds a new feature in user_list to allow password reset for selected users by admin
3111 *
3112 */
3113function UAM_loc_visible_user_list($visible_user_list)
3114{
3115  global $template;
3116 
3117  $template->append('plugin_user_list_column_titles', l10n('UAM_PwdReset'));
3118 
3119  $user_ids = array();
3120 
3121  foreach ($visible_user_list as $i => $user)
3122  {
3123    $user_ids[$i] = $user['id'];
3124  }
3125 
3126  $user_nums = array_flip($user_ids);
3127
3128  // Query to get informations in database
3129  // -------------------------------------
3130  if (!empty($user_ids))
3131  {
3132    $query = '
3133SELECT DISTINCT id, UAM_pwdreset
3134  FROM '.USERS_TABLE.'
3135  WHERE id IN ('.implode(',', $user_ids).')
3136;';
3137    $result = pwg_query($query);
3138   
3139    while ($row = mysql_fetch_array($result))
3140    {
3141      if ($row['UAM_pwdreset'] == 'false')
3142      {
3143        $pwdreset = l10n('UAM_PwdReset_Done');
3144      }
3145      else if ($row['UAM_pwdreset'] == 'true')
3146      {
3147        $pwdreset = l10n('UAM_PwdReset_Todo');
3148      }
3149      else $pwdreset = l10n('UAM_PwdReset_NA');
3150     
3151                  $visible_user_list[$user_nums[$row['id']]]['plugin_columns'][] = $pwdreset; // Shows users password state in user_list
3152    }
3153  }
3154  return $visible_user_list;
3155}
3156
3157
3158/**
3159 * UAM specific database dump (only for MySql !)
3160 * Creates an SQL dump of UAM specific tables and configuration settings
3161 *
3162 * @returns  : Boolean to manage appropriate message display
3163 *
3164 */
3165function UAM_dump($download)
3166{
3167  global $conf;
3168
3169  $plugin =  PluginInfos(UAM_PATH);
3170  $version = $plugin['version'];
3171
3172  // Initial backup folder creation and file initialisation
3173  // ------------------------------------------------------
3174  if (!is_dir(UAM_PATH.'/include/backup'))
3175    mkdir(UAM_PATH.'/include/backup');
3176
3177  $Backup_File = UAM_PATH.'/include/backup/UAM_dbbackup.sql';
3178
3179  $fp = fopen($Backup_File, 'w');
3180
3181  // Writing plugin version
3182  $insertions = "-- ".$version." --\n\n";
3183  fwrite($fp, $insertions);
3184
3185  // Saving UAM specific tables
3186  // --------------------------
3187  $ListTables = array(USER_CONFIRM_MAIL_TABLE, USER_LASTVISIT_TABLE);
3188  $j=0;
3189
3190  while($j < count($ListTables))
3191  {
3192    $sql = 'SHOW CREATE TABLE '.$ListTables[$j];
3193    $res = pwg_query($sql);
3194
3195    if ($res)
3196    {
3197      $insertions = "-- -------------------------------------------------------\n";
3198      $insertions .= "-- Create ".$ListTables[$j]." table\n";
3199      $insertions .= "-- ------------------------------------------------------\n\n";
3200
3201      $insertions .= "DROP TABLE IF EXISTS ".$ListTables[$j].";\n\n";
3202
3203      $array = mysql_fetch_array($res);
3204      $array[1] .= ";\n\n";
3205      $insertions .= $array[1];
3206
3207      $req_table = pwg_query('SELECT * FROM '.$ListTables[$j]) or die(mysql_error());
3208      $nb_fields = mysql_num_fields($req_table);
3209      while ($line = mysql_fetch_array($req_table))
3210      {
3211        $insertions .= 'INSERT INTO '.$ListTables[$j].' VALUES (';
3212        for ($i=0; $i<$nb_fields; $i++)
3213        {
3214          $insertions .= '\'' . pwg_db_real_escape_string($line[$i]) . '\', ';
3215        }
3216        $insertions = substr($insertions, 0, -2);
3217        $insertions .= ");\n";
3218      }
3219      $insertions .= "\n\n";
3220    }
3221
3222    fwrite($fp, $insertions);   
3223    $j++;
3224  }
3225 
3226  // Saving UAM configuration
3227  // ------------------------
3228  $insertions = "-- -------------------------------------------------------\n";
3229  $insertions .= "-- Insert UAM configuration in ".CONFIG_TABLE."\n";
3230  $insertions .= "-- ------------------------------------------------------\n\n";
3231
3232  fwrite($fp, $insertions);
3233
3234  $pattern = "UserAdvManager%";
3235  $req_table = pwg_query('SELECT * FROM '.CONFIG_TABLE.' WHERE param LIKE "'.$pattern.'";') or die(mysql_error());
3236  $nb_fields = mysql_num_fields($req_table);
3237
3238  while ($line = mysql_fetch_array($req_table))
3239  {
3240    $insertions = 'INSERT INTO '.CONFIG_TABLE.' VALUES (';
3241    for ($i=0; $i<$nb_fields; $i++)
3242    {
3243      $insertions .= '\'' . pwg_db_real_escape_string($line[$i]) . '\', ';
3244    }
3245    $insertions = substr($insertions, 0, -2);
3246    $insertions .= ");\n";
3247
3248    fwrite($fp, $insertions);
3249  }
3250
3251  fclose($fp);
3252
3253  // Download generated dump file
3254  // ----------------------------
3255  if ($download == 'true')
3256  {
3257    if (@filesize($Backup_File))
3258    {
3259      $http_headers = array(
3260        'Content-Length: '.@filesize($Backup_File),
3261        'Content-Type: text/x-sql',
3262        'Content-Disposition: attachment; filename="UAM_dbbackup.sql";',
3263        'Content-Transfer-Encoding: binary',
3264        );
3265
3266      foreach ($http_headers as $header)
3267      {
3268        header($header);
3269      }
3270
3271      @readfile($Backup_File);
3272      exit();
3273    }
3274  }
3275
3276  return true;
3277}
3278
3279
3280/**
3281 * UAM_Restore_backup_file
3282 * Restore backup database file
3283 *
3284 * @returns : Boolean
3285 */
3286function UAM_Restore_backup_file() 
3287{
3288  global $prefixeTable, $dblayer, $conf;
3289 
3290  define('DEFAULT_PREFIX_TABLE', 'piwigo_');
3291 
3292  $Backup_File = UAM_PATH.'/include/backup/UAM_dbbackup.sql';
3293
3294  // Cleanup database before restoring
3295  // ---------------------------------
3296
3297  // Delete UserAdvManager global config in #_config table
3298  $q = '
3299DELETE FROM '.CONFIG_TABLE.'
3300WHERE param="UserAdvManager"
3301;';
3302
3303  pwg_query($q);
3304
3305  // Delete UserAdvManager_ConfirmMail global config in #_config table
3306  $q = '
3307DELETE FROM '.CONFIG_TABLE.'
3308WHERE param="UserAdvManager_ConfirmMail"
3309;';
3310
3311  pwg_query($q);
3312
3313  // Delete UserAdvManager_Redir config in #_config table
3314  $q = '
3315DELETE FROM '.CONFIG_TABLE.'
3316WHERE param="UserAdvManager_Redir"
3317;';
3318
3319  pwg_query($q);
3320
3321  // Delete UserAdvManager_Version config in #_config table
3322  $q = '
3323DELETE FROM '.CONFIG_TABLE.'
3324WHERE param="UserAdvManager_Version"
3325;';
3326
3327  pwg_query($q);
3328
3329  // Restore sql backup file - DROP TABLE queries are executed
3330  // ---------------------------------------------------------
3331  UAM_execute_sqlfile(
3332    $Backup_File,
3333    DEFAULT_PREFIX_TABLE,
3334    $prefixeTable,
3335    $dblayer
3336  );
3337}
3338
3339
3340/**
3341 * loads an sql file and executes all queries / Based on Piwigo's original install file
3342 *
3343 * Before executing a query, $replaced is... replaced by $replacing. This is
3344 * useful when the SQL file contains generic words.
3345 *
3346 * @param string filepath
3347 * @param string replaced
3348 * @param string replacing
3349 * @return void
3350 */
3351function UAM_execute_sqlfile($filepath, $replaced, $replacing, $dblayer)
3352{
3353  $sql_lines = file($filepath);
3354  $query = '';
3355  foreach ($sql_lines as $sql_line)
3356  {
3357    $sql_line = trim($sql_line);
3358    if (preg_match('/(^--|^$)/', $sql_line))
3359    {
3360      continue;
3361    }
3362   
3363    $query.= ' '.$sql_line;
3364   
3365    // if we reached the end of query, we execute it and reinitialize the
3366    // variable "query"
3367    if (preg_match('/;$/', $sql_line))
3368    {
3369      $query = trim($query);
3370      $query = str_replace($replaced, $replacing, $query);
3371      if ('mysql' == $dblayer)
3372      {
3373        if (preg_match('/^(CREATE TABLE .*)[\s]*;[\s]*/im', $query, $matches))
3374        {
3375          $query = $matches[1].' DEFAULT CHARACTER SET utf8'.';';
3376        }
3377      }
3378      pwg_query($query);
3379      $query = '';
3380    }
3381  }
3382}
3383
3384
3385/**
3386 * Delete obsolete files on plugin upgrade
3387 * Obsolete files are listed in file obsolete.list
3388 *
3389 */
3390function clean_obsolete_files()
3391{
3392  if (file_exists(UAM_PATH.'obsolete.list')
3393    and $old_files = file(UAM_PATH.'obsolete.list', FILE_IGNORE_NEW_LINES)
3394    and !empty($old_files))
3395  {
3396    array_push($old_files, 'obsolete.list');
3397    foreach($old_files as $old_file)
3398    {
3399      $path = UAM_PATH.$old_file;
3400      if (is_file($path))
3401      {
3402        @unlink($path);
3403      }
3404      elseif (is_dir($path))
3405      {
3406        @rmdir($path);
3407      }
3408    }
3409  }
3410}
3411
3412
3413/**
3414 * Function called from maintain.inc.php - to check if database upgrade is needed
3415 *
3416 * @param : table name
3417 *
3418 * @return : boolean
3419 *
3420 */
3421function table_exist($table)
3422{
3423  $query = 'DESC '.$table.';';
3424  return (bool)($res=pwg_query($query));
3425}
3426
3427
3428/**
3429 * Function called from UAM_admin.php and main.inc.php to get the plugin version and name
3430 *
3431 * @param : plugin directory
3432 *
3433 * @return : plugin's version and name
3434 *
3435 */
3436function PluginInfos($dir)
3437{
3438  $path = $dir;
3439
3440  $plg_data = implode( '', file($path.'main.inc.php') );
3441  if ( preg_match("|Plugin Name: (.*)|", $plg_data, $val) )
3442  {
3443    $plugin['name'] = trim( $val[1] );
3444  }
3445  if (preg_match("|Version: (.*)|", $plg_data, $val))
3446  {
3447    $plugin['version'] = trim($val[1]);
3448  }
3449  if ( preg_match("|Plugin URI: (.*)|", $plg_data, $val) )
3450  {
3451    $plugin['uri'] = trim($val[1]);
3452  }
3453  if ($desc = load_language('description.txt', $path.'/', array('return' => true)))
3454  {
3455    $plugin['description'] = trim($desc);
3456  }
3457  elseif ( preg_match("|Description: (.*)|", $plg_data, $val) )
3458  {
3459    $plugin['description'] = trim($val[1]);
3460  }
3461  if ( preg_match("|Author: (.*)|", $plg_data, $val) )
3462  {
3463    $plugin['author'] = trim($val[1]);
3464  }
3465  if ( preg_match("|Author URI: (.*)|", $plg_data, $val) )
3466  {
3467    $plugin['author uri'] = trim($val[1]);
3468  }
3469  if (!empty($plugin['uri']) and strpos($plugin['uri'] , 'extension_view.php?eid='))
3470  {
3471    list( , $extension) = explode('extension_view.php?eid=', $plugin['uri']);
3472    if (is_numeric($extension)) $plugin['extension'] = $extension;
3473  }
3474// IMPORTANT SECURITY !
3475// --------------------
3476  $plugin = array_map('htmlspecialchars', $plugin);
3477
3478  return $plugin ;
3479}
3480
3481
3482/**
3483 * Useful for debugging - 4 vars can be set
3484 * Output result to log.txt file
3485 *
3486 */
3487function UAMLog($var1, $var2, $var3, $var4)
3488{
3489   $fo=fopen (UAM_PATH.'log.txt','a') ;
3490   fwrite($fo,"======================\n") ;
3491   fwrite($fo,'le ' . date('D, d M Y H:i:s') . "\r\n");
3492   fwrite($fo,$var1 ."\r\n") ;
3493   fwrite($fo,$var2 ."\r\n") ;
3494   fwrite($fo,$var3 ."\r\n") ;
3495   fwrite($fo,$var4 ."\r\n") ;
3496   fclose($fo) ;
3497}
3498
3499?>
Note: See TracBrowser for help on using the repository browser.