classes/user.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2011 Polytechnique.org                              *
   4  *  http://opensource.polytechnique.org/                                   *
   5  *                                                                         *
   6  *  This program is free software; you can redistribute it and/or modify   *
   7  *  it under the terms of the GNU General Public License as published by   *
   8  *  the Free Software Foundation; either version 2 of the License, or      *
   9  *  (at your option) any later version.                                    *
  10  *                                                                         *
  11  *  This program is distributed in the hope that it will be useful,        *
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  14  *  GNU General Public License for more details.                           *
  15  *                                                                         *
  16  *  You should have received a copy of the GNU General Public License      *
  17  *  along with this program; if not, write to the Free Software            *
  18  *  Foundation, Inc.,                                                      *
  19  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                *
  20  ***************************************************************************/
  21
  22 class User extends PlUser
  23 {
  24     const PERM_API_USER_READONLY = 'api_user_readonly';
  25     const PERM_DIRECTORY_AX      = 'directory_ax';
  26     const PERM_DIRECTORY_PRIVATE = 'directory_private';
  27     const PERM_EDIT_DIRECTORY    = 'edit_directory';
  28     const PERM_FORUMS            = 'forums';
  29     const PERM_GROUPS            = 'groups';
  30     const PERM_LISTS             = 'lists';
  31     const PERM_MAIL              = 'mail';
  32     const PERM_PAYMENT           = 'payment';
  33
  34     public static $sub_mail_domains = array(
  35         'x'      => '',
  36         'master' => 'master.',
  37         'phd'    => 'doc.',
  38         'all'    => 'alumni.'
  39     );
  40
  41     private $_profile_fetched = false;
  42     private $_profile = null;
  43
  44     // Additional fields (non core)
  45     protected $promo = null;
  46
  47     // Implementation of the login to uid method.
  48     protected function getLogin($login)
  49     {
  50         global $globals;
  51
  52         if (!$login) {
  53             throw new UserNotFoundException();
  54         }
  55
  56         if ($login instanceof User) {
  57             return $login->id();
  58         }
  59
  60         if ($login instanceof Profile) {
  61             $this->_profile = $login;
  62             $this->_profile_fetched = true;
  63             $res = XDB::query('SELECT  ap.uid
  64                                  FROM  account_profiles AS ap
  65                                 WHERE  ap.pid = {?} AND FIND_IN_SET(\'owner\', perms)',
  66                               $login->id());
  67             if ($res->numRows()) {
  68                 return $res->fetchOneCell();
  69             }
  70             throw new UserNotFoundException();
  71         }
  72
  73         // If $data is an integer, fetches directly the result.
  74         if (is_numeric($login)) {
  75             $res = XDB::query('SELECT  uid
  76                                  FROM  accounts
  77                                 WHERE  uid = {?}', $login);
  78             if ($res->numRows()) {
  79                 return $res->fetchOneCell();
  80             }
  81
  82             throw new UserNotFoundException();
  83         }
  84
  85         // Checks whether $login is a valid hruid or not.
  86         $res = XDB::query('SELECT  uid
  87                              FROM  accounts
  88                             WHERE  hruid = {?}', $login);
  89         if ($res->numRows()) {
  90             return $res->fetchOneCell();
  91         }
  92
  93         // From now, $login can only by an email alias, or an email redirection.
  94         // If it doesn't look like a valid address, appends the plat/al's main domain.
  95         $login = trim(strtolower($login));
  96         if (strstr($login, '@') === false) {
  97             $email = $login;
  98             $domain = $this->mainEmailDomain();
  99         } else {
 100             list($email, $domain) = explode('@', $login);
 101         }
 102
 103         // Checks if $login is a valid alias on any domain.
 104         $res = XDB::fetchOneCell('SELECT  s.uid
 105                                     FROM  email_source_account  AS s
 106                               INNER JOIN  email_virtual_domains AS m ON (s.domain = m.id)
 107                               INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
 108                                    WHERE  s.email = {?} AND d.name = {?}',
 109                                  $email, $domain);
 110         if ($res) {
 111             return $res;
 112         }
 113
 114         // Looks for an account with the given email.
 115         $res = XDB::query('SELECT  uid
 116                              FROM  accounts
 117                             WHERE  email = {?}', $login);
 118         if ($res->numRows() == 1) {
 119             return $res->fetchOneCell();
 120         }
 121
 122         // Otherwise, we do suppose $login is an email redirection.
 123         $res = XDB::query('SELECT  uid
 124                              FROM  email_redirect_account
 125                             WHERE  redirect = {?}', $login);
 126         if ($res->numRows() == 1) {
 127             return $res->fetchOneCell();
 128         }
 129
 130         throw new UserNotFoundException($res->fetchColumn(1));
 131     }
 132
 133     protected static function loadMainFieldsFromUIDs(array $uids, $respect_order = true)
 134     {
 135         if (empty($uids)) {
 136             return PlIteratorUtils::emptyIterator();
 137         }
 138
 139         global $globals;
 140         $joins = '';
 141         $fields = array();
 142         if ($globals->asso('id')) {
 143             $joins .= XDB::format("LEFT JOIN group_members AS gpm ON (gpm.uid = a.uid AND gpm.asso_id = {?})\n", $globals->asso('id'));
 144             $fields[] = 'gpm.perms AS group_perms';
 145             $fields[] = 'gpm.comm AS group_comm';
 146             $fields[] = 'gpm.position AS group_position';
 147         }
 148         if (count($fields) > 0) {
 149             $fields = ', ' . implode(', ', $fields);
 150         } else {
 151             $fields = '';
 152         }
 153
 154         if ($respect_order) {
 155             $order = 'ORDER BY ' . XDB::formatCustomOrder('a.uid', $uids);
 156         } else {
 157             $order = '';
 158         }
 159
 160         $uids = array_map(array('XDB', 'escape'), $uids);
 161
 162         return XDB::iterator('SELECT  a.uid, a.hruid, a.registration_date, h.uid IS NOT NULL AS homonym,
 163                                       IF(ef.email IS NULL, NULL, CONCAT(ef.email, \'@\', mf.name)) AS forlife,
 164                                       IF(ef.email IS NULL, NULL, CONCAT(ef.email, \'@\', df.name)) AS forlife_alternate,
 165                                       IF(eb.email IS NULL, NULL, CONCAT(eb.email, \'@\', mb.name)) AS bestalias,
 166                                       IF(eb.email IS NULL, NULL, CONCAT(eb.email, \'@\', db.name)) AS bestalias_alternate,
 167                                       (er.redirect IS NULL AND a.state = \'active\') AS lost,
 168                                       a.email, a.full_name, a.directory_name, a.display_name, a.sex = \'female\' AS gender,
 169                                       IF(a.state = \'active\', CONCAT(at.perms, \',\', IF(a.user_perms IS NULL, \'\', a.user_perms)), \'\') AS perms,
 170                                       a.user_perms, a.email_format, a.is_admin, a.state, a.type, at.description AS type_description, a.skin,
 171                                       FIND_IN_SET(\'watch\', a.flags) AS watch, a.comment,
 172                                       a.weak_password IS NOT NULL AS weak_access, g.g_account_name IS NOT NULL AS googleapps,
 173                                       a.token IS NOT NULL AS token_access, a.token, a.last_version,
 174                                       UNIX_TIMESTAMP(s.start) AS lastlogin, s.host, UNIX_TIMESTAMP(fp.last_seen) AS banana_last
 175                                       ' . $fields . '
 176                                 FROM  accounts               AS a
 177                           INNER JOIN  account_types          AS at ON (at.type = a.type)
 178                            LEFT JOIN  email_source_account   AS ef ON (ef.uid = a.uid AND ef.type = \'forlife\')
 179                            LEFT JOIN  email_virtual_domains  AS mf ON (ef.domain = mf.id)
 180                            LEFT JOIN  email_virtual_domains  AS df ON (df.aliasing = mf.id AND
 181                                                                        df.name LIKE CONCAT(\'%\', {?}) AND df.name NOT LIKE \'alumni.%\')
 182                            LEFT JOIN  email_source_account   AS eb ON (eb.uid = a.uid AND eb.flags = \'bestalias\')
 183                            LEFT JOIN  email_virtual_domains  AS mb ON (eb.domain = mb.id)
 184                            LEFT JOIN  email_virtual_domains  AS db ON (db.aliasing = mb.id AND
 185                                                                        db.name LIKE CONCAT(\'%\', {?}) AND db.name NOT LIKE \'alumni.%\')
 186                            LEFT JOIN  email_redirect_account AS er ON (er.uid = a.uid AND er.flags = \'active\' AND er.broken_level < 3
 187                                                                        AND er.type != \'imap\' AND er.type != \'homonym\')
 188                            LEFT JOIN  homonyms_list          AS h  ON (h.uid = a.uid)
 189                            LEFT JOIN  gapps_accounts         AS g  ON (a.uid = g.l_userid AND g.g_status = \'active\')
 190                            LEFT JOIN  log_last_sessions      AS ls ON (ls.uid = a.uid)
 191                            LEFT JOIN  log_sessions           AS s  ON (s.id = ls.id)
 192                            LEFT JOIN  forum_profiles         AS fp ON (fp.uid = a.uid)
 193                                    ' . $joins . '
 194                                WHERE  a.uid IN (' . implode(', ', $uids) . ')
 195                             GROUP BY  a.uid
 196                                    ' . $order, $globals->mail->domain2, $globals->mail->domain2);
 197     }
 198
 199     // Implementation of the data loader.
 200     protected function loadMainFields()
 201     {
 202         if ($this->hruid !== null && $this->forlife !== null
 203             && $this->bestalias !== null && $this->display_name !== null
 204             && $this->full_name !== null && $this->perms !== null
 205             && $this->gender !== null && $this->email_format !== null) {
 206             return;
 207         }
 208         $this->fillFromArray(self::loadMainFieldsFromUIDs(array($this->uid))->next());
 209     }
 210
 211     // Specialization of the buildPerms method
 212     // This function build 'generic' permissions for the user. It does not take
 213     // into account page specific permissions (e.g X.net group permissions)
 214     protected function buildPerms()
 215     {
 216         if (!is_null($this->perm_flags)) {
 217             return;
 218         }
 219         if ($this->perms === null) {
 220              $this->loadMainFields();
 221         }
 222         $this->perm_flags = self::makePerms($this->perms, $this->is_admin);
 223     }
 224
 225     public function setPerms($perms)
 226     {
 227         $this->perms = $perms;
 228         $this->perm_flags = null;
 229     }
 230
 231     // We do not want to store the password in the object.
 232     // So, fetch it 'on demand'
 233     public function password()
 234     {
 235         return XDB::fetchOneCell('SELECT  a.password
 236                                     FROM  accounts AS a
 237                                    WHERE  a.uid = {?}', $this->id());
 238     }
 239
 240     public function isActive()
 241     {
 242         return $this->state == 'active';
 243     }
 244
 245     /** Overload PlUser::promo(): there no promo defined for a user in the current
 246      * schema. The promo is a field from the profile.
 247      */
 248     public function promo()
 249     {
 250         if (!$this->hasProfile()) {
 251             return '';
 252         }
 253         return $this->profile()->promo();
 254     }
 255
 256     public function category()
 257     {
 258         $promo = $this->promo();
 259         if (!empty($promo)) {
 260             return $promo;
 261         } else {
 262             return $this->type_description;
 263         }
 264     }
 265
 266     public function firstName()
 267     {
 268         if (!$this->hasProfile()) {
 269             return $this->displayName();
 270         }
 271         return $this->profile()->firstName();
 272     }
 273
 274     public function lastName()
 275     {
 276         if (!$this->hasProfile()) {
 277             return '';
 278         }
 279         return $this->profile()->lastName();
 280     }
 281
 282     public function displayName()
 283     {
 284         if (!$this->hasProfile()) {
 285             return $this->display_name;
 286         }
 287         return $this->profile()->yourself;
 288     }
 289
 290     public function fullName($with_promo = false)
 291     {
 292         if (!$this->hasProfile()) {
 293             return $this->full_name;
 294         }
 295         return $this->profile()->fullName($with_promo);
 296     }
 297
 298     public function directoryName()
 299     {
 300         if (!$this->hasProfile()) {
 301             return $this->directory_name;
 302         }
 303         return $this->profile()->directory_name;
 304     }
 305
 306     /** Return the main profile attached with this account if any.
 307      */
 308     public function profile($forceFetch = false, $fields = 0x0000, $visibility = null)
 309     {
 310         if (!$this->_profile_fetched || $forceFetch) {
 311             $this->_profile_fetched = true;
 312             $this->_profile = Profile::get($this, $fields, $visibility);
 313         }
 314         return $this->_profile;
 315     }
 316
 317     /** Return true if the user has an associated profile.
 318      */
 319     public function hasProfile()
 320     {
 321         return !is_null($this->profile());
 322     }
 323
 324     /** Return true if given a reference to the profile of this user.
 325      */
 326     public function isMyProfile($other)
 327     {
 328         if (!$other) {
 329             return false;
 330         } else if ($other instanceof Profile) {
 331             $profile = $this->profile();
 332             return $profile && $profile->id() == $other->id();
 333         }
 334         return false;
 335     }
 336
 337     /** Check if the user can edit to given profile.
 338      */
 339     public function canEdit(Profile $profile)
 340     {
 341         if ($this->checkPerms(User::PERM_EDIT_DIRECTORY)) {
 342             return true;
 343         }
 344         return XDB::fetchOneCell('SELECT  pid
 345                                     FROM  account_profiles
 346                                    WHERE  uid = {?} AND pid = {?}',
 347                                  $this->id(), $profile->id());
 348     }
 349
 350     /** Determines main email domain for this user.
 351      */
 352     public function mainEmailDomain()
 353     {
 354         if (array_key_exists($this->type, self::$sub_mail_domains)) {
 355             return self::$sub_mail_domains[$this->type] . Platal::globals()->mail->domain;
 356         }
 357     }
 358
 359     /** Determines alternate email domain for this user.
 360      */
 361     public function alternateEmailDomain()
 362     {
 363         if (array_key_exists($this->type, self::$sub_mail_domains)) {
 364             return self::$sub_mail_domains[$this->type] . Platal::globals()->mail->domain2;
 365         }
 366     }
 367
 368     /** Fetch existing auxiliary alias.
 369      */
 370     public function emailAlias()
 371     {
 372         $aliases = $this->emailAliases();
 373         if (count($aliases)) {
 374             return $aliases[0];
 375         }
 376         return null;
 377     }
 378
 379     /** Fetch existing auxiliary aliases.
 380      */
 381     public function emailAliases()
 382     {
 383         return XDB::fetchColumn('SELECT  CONCAT(s.email, \'@\', d.name)
 384                                    FROM  email_source_account  AS s
 385                              INNER JOIN  email_virtual_domains AS m ON (s.domain = m.id)
 386                              INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
 387                                   WHERE  s.uid = {?} AND s.type = \'alias_aux\'
 388                                ORDER BY  d.name',
 389                                 $this->id());
 390     }
 391
 392     /** Get all group aliases the user belongs to.
 393      */
 394     public function emailGroupAliases($domain = null)
 395     {
 396         if (is_null($domain)) {
 397             return XDB::fetchColumn('SELECT  CONCAT(v.email, \'@\', dv.name) AS alias
 398                                        FROM  email_virtual         AS v
 399                                  INNER JOIN  email_virtual_domains AS dv ON (v.domain = dv.id)
 400                                  INNER JOIN  email_source_account  AS s  ON (s.uid = {?})
 401                                  INNER JOIN  email_virtual_domains AS ms ON (s.domain = ms.id)
 402                                  INNER JOIN  email_virtual_domains AS ds ON (ds.aliasing = ms.id)
 403                                       WHERE  v.redirect = CONCAT(s.email, \'@\', ds.name) AND v.type = \'alias\'',
 404                                     $this->id());
 405         } else {
 406             return XDB::fetchAllAssoc('alias',
 407                                       'SELECT  CONCAT(v.email, \'@\', dv.name) AS alias, MAX(v.redirect = CONCAT(s.email, \'@\', ds.name)) AS sub
 408                                          FROM  email_virtual         AS v
 409                                    INNER JOIN  email_virtual_domains AS dv ON (v.domain = dv.id AND dv.name = {?})
 410                                    INNER JOIN  email_source_account  AS s  ON (s.uid = {?})
 411                                    INNER JOIN  email_virtual_domains AS ms ON (s.domain = ms.id)
 412                                    INNER JOIN  email_virtual_domains AS ds ON (ds.aliasing = ms.id)
 413                                         WHERE  v.type = \'alias\'
 414                                      GROUP BY  v.email
 415                                      ORDER BY  v.email',
 416                                       $domain, $this->id());
 417         }
 418     }
 419
 420     /** Get marketing informations
 421      */
 422     private function fetchMarketingData()
 423     {
 424         if (isset($this->pending_registration_date)) {
 425             return;
 426         }
 427         $infos = XDB::fetchOneAssoc('SELECT  rp.date AS pending_registration_date, rp.email AS pending_registration_email,
 428                                              rm.last AS last_marketing_date, rm.email AS last_marketing_email
 429                                        FROM  accounts           AS a
 430                                   LEFT JOIN  register_pending   AS rp ON (rp.uid = a.uid)
 431                                   LEFT JOIN  register_marketing AS rm ON (rm.uid = a.uid AND rm.last != \'0000-00-00\')
 432                                       WHERE  a.uid = {?}
 433                                    ORDER BY  rm.last DESC', $this->id());
 434         if (is_null($infos)) {
 435             $infos = array(
 436                 'pending_registration_date'  => null,
 437                 'pending_registration_email' => null,
 438                 'last_marketing_date'        => null,
 439                 'last_marketing_email'       => null
 440             );
 441         }
 442         $this->fillFromArray($infos);
 443     }
 444
 445     public function pendingRegistrationDate()
 446     {
 447         $this->fetchMarketingData();
 448         return $this->pending_registration_date;
 449     }
 450
 451     public function pendingRegistrationEmail()
 452     {
 453         $this->fetchMarketingData();
 454         return $this->pending_registration_email;
 455     }
 456
 457     public function lastMarketingDate()
 458     {
 459         $this->fetchMarketingData();
 460         return $this->last_marketing_date;
 461     }
 462
 463     public function lastMarketingEmail()
 464     {
 465         $this->fetchMarketingData();
 466         return $this->last_marketing_email;
 467     }
 468
 469     public function lastKnownEmail()
 470     {
 471         $this->fetchMarketingData();
 472         if ($this->pending_registration_email > $this->last_marketing_date) {
 473             return $this->pending_registration_email;
 474         }
 475         return $this->last_marketing_email;
 476     }
 477
 478
 479     /** Format of the emails sent by the site
 480      */
 481     public function setEmailFormat($format)
 482     {
 483         Platal::assert($format == self::FORMAT_HTML || $format == self::FORMAT_TEXT,
 484                        "Invalid email format \"$format\"");
 485         XDB::execute("UPDATE  accounts
 486                          SET  email_format = {?}
 487                        WHERE  uid = {?}",
 488                      $format, $this->uid);
 489         $this->email_format = $format;
 490     }
 491
 492     /** Get watch informations
 493      */
 494     private function fetchWatchData()
 495     {
 496         if (isset($this->watch_actions)) {
 497             return;
 498         }
 499         $watch = XDB::fetchOneAssoc('SELECT  flags AS watch_flags, actions AS watch_actions,
 500                                              UNIX_TIMESTAMP(last) AS watch_last
 501                                        FROM  watch
 502                                       WHERE  uid = {?}', $this->id());
 503         $watch['watch_flags'] = new PlFlagSet($watch['watch_flags']);
 504         $watch['watch_actions'] = new PlFlagSet($watch['watch_actions']);
 505         $watch['watch_promos'] = XDB::fetchColumn('SELECT  promo
 506                                                      FROM  watch_promo
 507                                                     WHERE  uid = {?}', $this->id());
 508         $watch['watch_users'] = XDB::fetchColumn('SELECT  ni_id
 509                                                     FROM  watch_nonins
 510                                                    WHERE  uid = {?}', $this->id());
 511         $this->fillFromArray($watch);
 512     }
 513
 514     public function watchType($type)
 515     {
 516         $this->fetchWatchData();
 517         return $this->watch_actions->hasFlag($type);
 518     }
 519
 520     public function watchContacts()
 521     {
 522         $this->fetchWatchData();
 523         return $this->watch_flags->hasFlag('contacts');
 524     }
 525
 526     public function watchEmail()
 527     {
 528         $this->fetchWatchData();
 529         return $this->watch_flags->hasFlag('mail');
 530     }
 531
 532     public function watchPromos()
 533     {
 534         $this->fetchWatchData();
 535         return $this->watch_promos;
 536     }
 537
 538     public function watchUsers()
 539     {
 540         $this->fetchWatchData();
 541         return $this->watch_users;
 542     }
 543
 544     public function watchLast()
 545     {
 546         $this->fetchWatchData();
 547         return $this->watch_last;
 548     }
 549
 550     public function invalidWatchCache()
 551     {
 552         unset($this->watch_actions);
 553         unset($this->watch_users);
 554         unset($this->watch_last);
 555         unset($this->watch_promos);
 556     }
 557
 558
 559     // Contacts
 560     private $contacts = null;
 561     private function fetchContacts()
 562     {
 563         if (is_null($this->contacts)) {
 564             $this->contacts = XDB::fetchAllAssoc('contact', 'SELECT  *
 565                                                                FROM  contacts
 566                                                               WHERE  uid = {?}',
 567                                                  $this->id());
 568         }
 569     }
 570
 571     public function iterContacts()
 572     {
 573         $this->fetchContacts();
 574         return Profile::iterOverPIDs(array_keys($this->contacts));
 575     }
 576
 577     public function getContacts()
 578     {
 579         $this->fetchContacts();
 580         return Profile::getBulkProfilesWithPIDs(array_keys($this->contacts));
 581     }
 582
 583     public function isContact(Profile $profile)
 584     {
 585         $this->fetchContacts();
 586         return isset($this->contacts[$profile->id()]);
 587     }
 588
 589     public function isWatchedUser(Profile $profile)
 590     {
 591         return in_array($profile->id(), $this->watchUsers());
 592     }
 593
 594     // Groupes X
 595     private $groups = null;
 596     public function groups($institutions = false, $onlyPublic = false)
 597     {
 598         if (is_null($this->groups)) {
 599             $this->groups = XDB::fetchAllAssoc('asso_id', 'SELECT  gm.asso_id, gm.perms, gm.comm,
 600                                                                    g.diminutif, g.nom, g.site, g.cat,
 601                                                                    g.pub
 602                                                              FROM  group_members AS gm
 603                                                        INNER JOIN  groups AS g ON (g.id = gm.asso_id)
 604                                                             WHERE  uid = {?}',
 605                                                 $this->id());
 606         }
 607         if (!$institutions && !$onlyPublic) {
 608             return $this->groups;
 609         } else {
 610             $result = array();
 611             foreach ($this->groups as $id=>$data) {
 612                 if ($institutions) {
 613                     if ($data['cat'] != Group::CAT_GROUPESX && $data['cat'] != Group::CAT_INSTITUTIONS) {
 614                         continue;
 615                     }
 616                 }
 617                 if ($onlyPublic) {
 618                     if ($data['pub'] != 'public') {
 619                         continue;
 620                     }
 621                 }
 622                 $result[$id] = $data;
 623             }
 624             return $result;
 625         }
 626     }
 627
 628     /**
 629      * Clears a user.
 630      *  *always deletes in: account_lost_passwords, register_marketing,
 631      *      register_pending, register_subs, watch_nonins, watch, watch_promo
 632      *  *always keeps in: account_types, accounts, email_virtual, carvas,
 633      *      group_members, homonyms_list, newsletter_ins, register_mstats, email_source_account
 634      *  *deletes if $clearAll: account_auth_openid, announce_read, contacts,
 635      *      email_redirect_account, email_redirect_account, email_send_save, forum_innd, forum_profiles,
 636      *      forum_subs, gapps_accounts, gapps_nicknames, group_announces_read,
 637      *      group_member_sub_requests, reminder, requests, requests_hidden,
 638      *      email_virtual, ML
 639      *  *modifies if $clearAll: accounts
 640      *
 641      * Use cases:
 642      *  *$clearAll == false: when a user dies, her family still needs to keep in
 643      *      touch with the community.
 644      *  *$clearAll == true: in every other case we want the account to be fully
 645      *      deleted so that it can not be used anymore.
 646      */
 647     public function clear($clearAll = true)
 648     {
 649         $tables = array('account_lost_passwords', 'register_marketing',
 650                         'register_pending', 'register_subs', 'watch_nonins',
 651                         'watch', 'watch_promo');
 652
 653         foreach ($tables as $t) {
 654             XDB::execute('DELETE FROM  ' . $t . '
 655                                 WHERE  uid = {?}',
 656                                 $this->id());
 657         }
 658
 659         if ($clearAll) {
 660             global $globals;
 661
 662             $groupIds = XDB::iterator('SELECT  asso_id
 663                                          FROM  group_members
 664                                         WHERE  uid = {?}',
 665                                       $this->id());
 666             while ($groupId = $groupIds->next()) {
 667                 $group = Group::get($groupId);
 668                 if (!empty($group) && $group->notif_unsub) {
 669                     $mailer = new PlMailer('xnetgrp/unsubscription-notif.mail.tpl');
 670                     $admins = $group->iterAdmins();
 671                     while ($admin = $admins->next()) {
 672                         $mailer->addTo($admin);
 673                     }
 674                     $mailer->assign('group', $group->shortname);
 675                     $mailer->assign('user', $this);
 676                     $mailer->assign('selfdone', false);
 677                     $mailer->send();
 678                 }
 679             }
 680
 681             $tables = array('account_auth_openid', 'announce_read', 'contacts',
 682                             'email_send_save', 'email_virtual',
 683                             'forum_innd', 'forum_profiles', 'forum_subs',
 684                             'group_announces_read', 'group_members',
 685                             'group_member_sub_requests', 'reminder', 'requests',
 686                             'requests_hidden');
 687             foreach ($tables as $t) {
 688                 XDB::execute('DELETE FROM  ' . $t . '
 689                                     WHERE  uid = {?}',
 690                              $this->id());
 691             }
 692             XDB::execute('DELETE FROM  email_redirect_account
 693                                 WHERE  uid = {?} AND type != \'homonym\'',
 694                          $this->id());
 695
 696             foreach (array('gapps_accounts', 'gapps_nicknames') as $t) {
 697                 XDB::execute('DELETE FROM  ' . $t . '
 698                                     WHERE  l_userid = {?}',
 699                              $this->id());
 700             }
 701
 702             XDB::execute("UPDATE  accounts
 703                              SET  registration_date = 0, state = 'pending', password = NULL,
 704                                   weak_password = NULL, token = NULL, is_admin = 0
 705                            WHERE  uid = {?}",
 706                          $this->id());
 707
 708             if ($globals->mailstorage->googleapps_domain) {
 709                 require_once 'googleapps.inc.php';
 710
 711                 if (GoogleAppsAccount::account_status($this->id())) {
 712                     $account = new GoogleAppsAccount($this);
 713                     $account->suspend();
 714                 }
 715             }
 716         }
 717
 718         $mmlist = new MMList(S::user());
 719         $mmlist->kill($this->hruid, $clearAll);
 720     }
 721
 722     // Merge all infos in other user and then clean this one
 723     public function mergeIn(User $newuser) {
 724         if ($this->profile()) {
 725             // Don't disable user with profile in this way.
 726             global $globals;
 727             Platal::page()->trigError('Impossible de fusionner les comptes ' . $this->hruid . ' et ' . $newuser->hruid .
 728                                       '. Contacte support@' . $globals->mail->domain . '.');
 729             return false;
 730         }
 731
 732         if ($this->forlifeEmail()) {
 733             // If the new user is not registered and does not have already an email address,
 734             // we need to give him the old user's email address if he has any.
 735             if (!$newuser->perms) {
 736                 XDB::execute('UPDATE  accounts
 737                                  SET  email = {?}
 738                                WHERE  uid = {?} AND email IS NULL',
 739                              $this->forlifeEmail(), $newuser->id());
 740
 741                 // Reftech new user so its forlifeEmail will be correct.
 742                 $newuser = getSilentWithUID($newuser->id());
 743             }
 744
 745             // Change email used in mailing lists.
 746             if ($this->forlifeEmail() != $newuser->forlifeEmail()) {
 747                 // group mailing lists
 748                 $group_domains = XDB::fetchColumn('SELECT  g.mail_domain
 749                                                      FROM  groups        AS g
 750                                                INNER JOIN  group_members AS gm ON(g.id = gm.asso_id)
 751                                                     WHERE  g.mail_domain != \'\' AND gm.uid = {?}',
 752                                                   $this->id());
 753                 foreach ($group_domains as $mail_domain) {
 754                     $mmlist = new MMList($this, $mail_domain);
 755                     $mmlist->replace_email_in_all($this->forlifeEmail(), $newuser->forlifeEmail());
 756                 }
 757                 // main domain lists
 758                 $mmlist = new MMList($this);
 759                 $mmlist->replace_email_in_all($this->forlifeEmail(), $newuser->forlifeEmail());
 760             }
 761         }
 762
 763         // Updates user in following tables.
 764         foreach (array('group_announces', 'payment_transactions', 'log_sessions', 'group_events') as $table) {
 765             XDB::execute('UPDATE  ' . $table . '
 766                              SET  uid = {?}
 767                            WHERE  uid = {?}',
 768                          $newuser->id(), $this->id());
 769         }
 770
 771         // Merges user in following tables, ie updates when possible, then deletes remaining occurences of the old user.
 772         foreach (array('group_announces_read', 'group_event_participants', 'group_member_sub_requests', 'group_members', 'email_redirect_account') as $table) {
 773             XDB::execute('UPDATE IGNORE  ' . $table . '
 774                                     SET  uid = {?}
 775                                   WHERE  uid = {?}',
 776                          $newuser->id(), $this->id());
 777             XDB::execute('DELETE FROM  ' . $table . '
 778                                 WHERE  uid = {?}',
 779                          $this->id());
 780         }
 781
 782         // Eventually updates last session id and deletes old user's accounts entry.
 783         $lastSession = XDB::fetchOneCell('SELECT  id
 784                                             FROM  log_sessions
 785                                            WHERE  uid = {?}
 786                                         ORDER BY  start DESC
 787                                            LIMIT  1',
 788                                          $newuser->id());
 789         XDB::execute('UPDATE  log_last_sessions
 790                          SET  id = {?}
 791                        WHERE  uid = {?}',
 792                      $lastSession, $newuser->id());
 793         XDB::execute('DELETE FROM  accounts
 794                             WHERE  uid = {?}',
 795                      $this->id());
 796
 797         return true;
 798     }
 799
 800     // Return permission flags for a given permission level.
 801     public static function makePerms($perms, $is_admin)
 802     {
 803         $flags = new PlFlagSet($perms);
 804         $flags->addFlag(PERMS_USER);
 805         if ($is_admin) {
 806             $flags->addFlag(PERMS_ADMIN);
 807         }
 808
 809         // Access to private directory implies access to 'less'-private version.
 810         if ($flags->hasFlag('directory_private')) {
 811             $flags->addFlag('directory_ax');
 812         }
 813         return $flags;
 814     }
 815
 816     // Implementation of the default user callback.
 817     public static function _default_user_callback($login, $results)
 818     {
 819         $result_count = count($results);
 820         if ($result_count == 0 || !S::admin()) {
 821             Platal::page()->trigError("Il n'y a pas d'utilisateur avec l'identifiant : $login");
 822         } else {
 823             Platal::page()->trigError("Il y a $result_count utilisateurs avec cet identifiant : " . join(', ', $results));
 824         }
 825     }
 826
 827     public static function isMainMailDomain($domain)
 828     {
 829         global $globals;
 830
 831         $is_main_domain = false;
 832         foreach (self::$sub_mail_domains as $sub_domain) {
 833             $is_main_domain = $is_main_domain || $domain != ($sub_domain . $globals->mail->domain) && $domain != ($sub_domain . $globals->mail->domain2);
 834         }
 835         return $is_main_domain;
 836     }
 837
 838     public static function isAliasMailDomain($domain)
 839     {
 840         global $globals;
 841
 842         return $domain == $globals->mail->alias_dom || $domain == $globals->mail->alias_dom2;
 843     }
 844
 845     // Implementation of the static email locality checker.
 846     public static function isForeignEmailAddress($email)
 847     {
 848         if (strpos($email, '@') === false) {
 849             return false;
 850         }
 851
 852         list(, $domain) = explode('@', $email);
 853         return !(self::isMainMailDomain($domain) || self::isAliasMailDomain($domain));
 854     }
 855
 856     /* Tries to find pending accounts with an hruid close to $login. */
 857     public static function getPendingAccounts($login, $iterator = false)
 858     {
 859         if (strpos($login, '@') === false) {
 860             return null;
 861         }
 862
 863         list($login, $domain) = explode('@', $login);
 864
 865         if ($domain && !self::isMainMailDomain($domain)) {
 866             return null;
 867         }
 868
 869         $sql = "SELECT  uid, full_name
 870                   FROM  accounts
 871                  WHERE  state = 'pending' AND REPLACE(hruid, '-', '') LIKE
 872                         CONCAT('%', REPLACE(REPLACE(REPLACE({?}, ' ', ''), '-', ''), '\'', ''), '%')
 873               ORDER BY  full_name";
 874         if ($iterator) {
 875             return XDB::iterator($sql, $login);
 876         } else {
 877             $res = XDB::query($sql, $login);
 878             return $res->fetchAllAssoc();
 879         }
 880     }
 881
 882
 883     public static function iterOverUIDs($uids, $respect_order = true)
 884     {
 885         return new UserIterator(self::loadMainFieldsFromUIDs($uids, $respect_order));
 886     }
 887
 888     /** Fetch a set of users from a list of UIDs
 889      * @param $data The list of uids to fetch, or an array of arrays
 890      * @param $orig If $data is an array of arrays, the subfield where uids are stored
 891      * @param $dest If $data is an array of arrays, the subfield to fill with Users
 892      * @param $fetchProfile Whether to fetch Profiles as well
 893      * @return either an array of $uid => User, or $data with $data[$i][$dest] = User
 894      */
 895     public static function getBulkUsersWithUIDs(array $data, $orig = null, $dest = null, $fetchProfile = true)
 896     {
 897         // Fetch the list of uids
 898         if (is_null($orig)) {
 899             $uids = $data;
 900         } else {
 901             if (is_null($dest)) {
 902                 $dest = $orig;
 903             }
 904             $uids = array();
 905             foreach ($data as $key=>$entry) {
 906                 if (isset($entry[$orig])) {
 907                     $uids[] = $entry[$orig];
 908                 }
 909             }
 910         }
 911
 912         // Fetch users
 913         if (count($uids) == 0) {
 914             return $data;
 915         }
 916         $users = self::iterOverUIDs($uids, true);
 917
 918         $table = array();
 919         if ($fetchProfile) {
 920             $profiles = Profile::iterOverUIDS($uids, true);
 921             if ($profiles != null) {
 922                 $profile = $profiles->next();
 923             } else {
 924                 $profile = null;
 925             }
 926         }
 927
 928         /** We iterate through the users, moving in
 929          * profiles when they match the user ID :
 930          * there can be users without a profile, but not
 931          * the other way around.
 932          */
 933         while (($user = $users->next())) {
 934             if ($fetchProfile) {
 935                 if ($profile != null && $profile->owner_id == $user->id()) {
 936                     $user->_profile = $profile;
 937                     $profile = $profiles->next();
 938                 }
 939                 $user->_profile_fetched = true;
 940             }
 941             $table[$user->id()] = $user;
 942         }
 943
 944         // Build the result with respect to input order.
 945         if (is_null($orig)) {
 946             return $table;
 947         } else {
 948             foreach ($data as $key=>$entry) {
 949                 if (isset($entry[$orig])) {
 950                     $entry[$dest] = $table[$entry[$orig]];
 951                     $data[$key] = $entry;
 952                 }
 953             }
 954             return $data;
 955         }
 956     }
 957
 958     public static function getBulkUsersFromDB($fetchProfile = true)
 959     {
 960         $args = func_get_args();
 961         $uids = call_user_func_array(array('XDB', 'fetchColumn'), $args);
 962         return self::getBulkUsersWithUIDs($uids, null, null, $fetchProfile);
 963     }
 964 }
 965
 966 /** Iterator over a set of Users
 967  * @param an XDB::Iterator obtained from a User::loadMainFieldsFromUIDs
 968  */
 969 class UserIterator implements PlIterator
 970 {
 971     private $dbiter;
 972
 973     public function __construct($dbiter)
 974     {
 975         $this->dbiter = $dbiter;
 976     }
 977
 978     public function next()
 979     {
 980         $data = $this->dbiter->next();
 981         if ($data == null) {
 982             return null;
 983         } else {
 984             return User::getSilentWithValues(null, $data);
 985         }
 986     }
 987
 988     public function total()
 989     {
 990         return $this->dbiter->total();
 991     }
 992
 993     public function first()
 994     {
 995         return $this->dbiter->first();
 996     }
 997
 998     public function last()
 999     {
1000         return $this->dbiter->last();
1001     }
1002 }
1003
1004 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
1005 ?>