classes/user.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2014 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         $login = trim(strtolower($login));
  95         if (strstr($login, '@') === false) {
  96             $res = XDB::fetchOneCell('SELECT  uid
  97                                         FROM  email_source_account
  98                                        WHERE  email = {?}',
  99                                      $login);
 100         } else {
 101             list($email, $domain) = explode('@', $login);
 102             $res = XDB::fetchOneCell('SELECT  s.uid
 103                                         FROM  email_source_account  AS s
 104                                   INNER JOIN  email_virtual_domains AS m ON (s.domain = m.id)
 105                                   INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
 106                                        WHERE  s.email = {?} AND d.name = {?}',
 107                                      $email, $domain);
 108         }
 109
 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, a.firstname, a.lastname,
 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                                       (er.redirect IS NULL AND a.state = \'active\' AND FIND_IN_SET(\'mail\', at.perms)) AS lost,
 167                                       a.email, a.full_name, a.directory_name, a.display_name, a.sex = \'female\' AS gender,
 168                                       IF(a.state = \'active\', CONCAT(at.perms, \',\', IF(a.user_perms IS NULL, \'\', a.user_perms)), \'\') AS perms,
 169                                       a.user_perms, a.email_format, a.is_admin, a.state, a.type, at.description AS type_description, a.skin,
 170                                       FIND_IN_SET(\'watch\', a.flags) AS watch, a.comment,
 171                                       a.weak_password IS NOT NULL AS weak_access, g.g_account_name IS NOT NULL AS googleapps,
 172                                       a.token IS NOT NULL AS token_access, a.token, a.last_version,
 173                                       s.start AS lastlogin, s.host, fp.last_seen AS banana_last
 174                                       ' . $fields . '
 175                                 FROM  accounts               AS a
 176                           INNER JOIN  account_types          AS at ON (at.type = a.type)
 177                            LEFT JOIN  email_source_account   AS ef ON (ef.uid = a.uid AND ef.type = \'forlife\')
 178                            LEFT JOIN  email_virtual_domains  AS mf ON (ef.domain = mf.id)
 179                            LEFT JOIN  email_virtual_domains  AS df ON (df.aliasing = mf.id AND
 180                                                                        df.name LIKE CONCAT(\'%\', {?}) AND df.name NOT LIKE \'alumni.%\')
 181                            LEFT JOIN  email_source_account   AS eb ON (eb.uid = a.uid AND FIND_IN_SET(\'bestalias\',eb.flags))
 182                            LEFT JOIN  email_virtual_domains  AS mb ON (a.best_domain = mb.id)
 183                            LEFT JOIN  email_redirect_account AS er ON (er.uid = a.uid AND er.flags = \'active\' AND er.broken_level < 3
 184                                                                        AND er.type != \'imap\' AND er.type != \'homonym\')
 185                            LEFT JOIN  homonyms_list          AS h  ON (h.uid = a.uid)
 186                            LEFT JOIN  gapps_accounts         AS g  ON (a.uid = g.l_userid AND g.g_status = \'active\')
 187                            LEFT JOIN  log_last_sessions      AS ls ON (ls.uid = a.uid)
 188                            LEFT JOIN  log_sessions           AS s  ON (s.id = ls.id)
 189                            LEFT JOIN  forum_profiles         AS fp ON (fp.uid = a.uid)
 190                                    ' . $joins . '
 191                                WHERE  a.uid IN (' . implode(', ', $uids) . ')
 192                             GROUP BY  a.uid
 193                                    ' . $order, $globals->mail->domain2, $globals->mail->domain2);
 194     }
 195
 196     // Implementation of the data loader.
 197     protected function loadMainFields()
 198     {
 199         if ($this->hruid !== null && $this->forlife !== null
 200             && $this->bestalias !== null && $this->display_name !== null
 201             && $this->full_name !== null && $this->perms !== null
 202             && $this->gender !== null && $this->email_format !== null) {
 203             return;
 204         }
 205         $this->fillFromArray(self::loadMainFieldsFromUIDs(array($this->uid))->next());
 206     }
 207
 208     // Specialization of the buildPerms method
 209     // This function build 'generic' permissions for the user. It does not take
 210     // into account page specific permissions (e.g X.net group permissions)
 211     protected function buildPerms()
 212     {
 213         if (!is_null($this->perm_flags)) {
 214             return;
 215         }
 216         if ($this->perms === null) {
 217              $this->loadMainFields();
 218         }
 219         $this->perm_flags = self::makePerms($this->perms, $this->is_admin);
 220     }
 221
 222     public function setPerms($perms)
 223     {
 224         $this->perms = $perms;
 225         $this->perm_flags = null;
 226     }
 227
 228     /** Retrieve the 'general' read visibility.
 229      * This is the maximum level of fields that may be viewed by the current user on other profiles.
 230      *
 231      * Rules are:
 232      *  - Everyone can view 'public'
 233      *  - directory_ax gives access to 'AX' level
 234      *  - directory_private gives access to 'private' level
 235      *  - admin gives access to 'hidden' level
 236      */
 237     public function readVisibility()
 238     {
 239         $level = Visibility::VIEW_NONE;
 240         if ($this->is_admin) {
 241             $level = Visibility::VIEW_ADMIN;
 242         } elseif ($this->checkPerms('directory_private')) {
 243             $level = Visibility::VIEW_PRIVATE;
 244         } elseif ($this->checkPerms('directory_ax')) {
 245             $level = Visibility::VIEW_AX;
 246         } else {
 247             $level = Visibility::VIEW_PUBLIC;
 248         }
 249         return Visibility::get($level);
 250     }
 251
 252     /** Retrieve the 'general' edit visibility.
 253      * This is the maximum level of fields that may be edited by the current user on other profiles.
 254      *
 255      * Rules are:
 256      *  - Only admins can edit the 'hidden' fields
 257      *  - If someone has 'directory_edit' (which is actually directory_ax_edit): AX level
 258      *  - Otherwise, nothing.
 259      */
 260     public function editVisibility()
 261     {
 262         $level = Visibility::VIEW_NONE;
 263         if ($this->is_admin) {
 264             $level = Visibility::VIEW_ADMIN;
 265         } elseif ($this->checkPerms('directory_edit')) {
 266             $level = Visibility::VIEW_AX;
 267         }
 268         return Visibility::get($level);
 269     }
 270
 271     // We do not want to store the password in the object.
 272     // So, fetch it 'on demand'
 273     public function password()
 274     {
 275         return XDB::fetchOneCell('SELECT  a.password
 276                                     FROM  accounts AS a
 277                                    WHERE  a.uid = {?}', $this->id());
 278     }
 279
 280     public function isActive()
 281     {
 282         return $this->state == 'active';
 283     }
 284
 285     /** Overload PlUser::promo(): there no promo defined for a user in the current
 286      * schema. The promo is a field from the profile.
 287      */
 288     public function promo()
 289     {
 290         if (!$this->hasProfile()) {
 291             return '';
 292         }
 293         return $this->profile()->promo();
 294     }
 295
 296     public function category()
 297     {
 298         $promo = $this->promo();
 299         if (!empty($promo)) {
 300             return $promo;
 301         } else {
 302             return $this->type_description;
 303         }
 304     }
 305
 306     public function firstName()
 307     {
 308         if (!$this->hasProfile()) {
 309             return $this->firstname;
 310         }
 311         return $this->profile()->firstName();
 312     }
 313
 314     public function lastName()
 315     {
 316         if (!$this->hasProfile()) {
 317             return $this->lastname;
 318         }
 319         return $this->profile()->lastName();
 320     }
 321
 322     public function displayName()
 323     {
 324         if (!$this->hasProfile()) {
 325             return $this->display_name;
 326         }
 327         return $this->profile()->yourself;
 328     }
 329
 330     public function fullName($with_promo = false)
 331     {
 332         if (!$this->hasProfile()) {
 333             return $this->full_name;
 334         }
 335         return $this->profile()->fullName($with_promo);
 336     }
 337
 338     public function shortName($with_promo = false)
 339     {
 340         if (!$this->hasProfile()) {
 341             return $this->full_name;
 342         }
 343         return $this->profile()->shortName($with_promo);
 344     }
 345
 346     public function directoryName()
 347     {
 348         if (!$this->hasProfile()) {
 349             return $this->directory_name;
 350         }
 351         return $this->profile()->directory_name;
 352     }
 353
 354     static public function compareDirectoryName($a, $b)
 355     {
 356         return strcasecmp(replace_accent($a->directoryName()), replace_accent($b->directoryName()));
 357     }
 358
 359     /** Return the main profile attached with this account if any.
 360      */
 361     public function profile($forceFetch = false, $fields = 0x0000, $visibility = null)
 362     {
 363         if (!$this->_profile_fetched || $forceFetch) {
 364             $this->_profile_fetched = true;
 365             $this->_profile = Profile::get($this, $fields, $visibility);
 366         } else if ($this->_profile !== null && $visibility !== null && !$this->_profile->visibility->equals($visibility)) {
 367             return Profile::get($this, $fields, $visibility);
 368         }
 369         return $this->_profile;
 370     }
 371
 372     public function setPrefetchedProfile(Profile $profile)
 373     {
 374         $this->_profile_fetched = true;
 375         $this->_profile = $profile;
 376     }
 377
 378     /** Return true if the user has an associated profile.
 379      */
 380     public function hasProfile()
 381     {
 382         return !is_null($this->profile());
 383     }
 384
 385     /** Return true if given a reference to the profile of this user.
 386      */
 387     public function isMyProfile($other)
 388     {
 389         if (!$other) {
 390             return false;
 391         } else if ($other instanceof Profile) {
 392             $profile = $this->profile();
 393             return $profile && $profile->id() == $other->id();
 394         }
 395         return false;
 396     }
 397
 398     /** Check if the user can edit to given profile.
 399      */
 400     public function canEdit(Profile $profile)
 401     {
 402         if ($this->checkPerms(User::PERM_EDIT_DIRECTORY)) {
 403             return true;
 404         }
 405         return XDB::fetchOneCell('SELECT  pid
 406                                     FROM  account_profiles
 407                                    WHERE  uid = {?} AND pid = {?}',
 408                                  $this->id(), $profile->id());
 409     }
 410
 411     /** Determines main email domain for this user.
 412      */
 413     public function mainEmailDomain()
 414     {
 415         if (array_key_exists($this->type, self::$sub_mail_domains)) {
 416             return self::$sub_mail_domains[$this->type] . Platal::globals()->mail->domain;
 417         }
 418     }
 419
 420     /** Determines alternate email domain for this user.
 421      */
 422     public function alternateEmailDomain()
 423     {
 424         if (array_key_exists($this->type, self::$sub_mail_domains)) {
 425             return self::$sub_mail_domains[$this->type] . Platal::globals()->mail->domain2;
 426         }
 427     }
 428
 429     public function forlifeEmailAlternate()
 430     {
 431         if (!empty($this->forlife_alternate)) {
 432             return $this->forlife_alternate;
 433         }
 434         return $this->email;
 435     }
 436
 437     /** Fetch existing auxiliary alias.
 438      */
 439     public function emailAlias()
 440     {
 441         $aliases = $this->emailAliases();
 442         if (count($aliases)) {
 443             return $aliases[0];
 444         }
 445         return null;
 446     }
 447
 448     /** Fetch existing auxiliary aliases.
 449      */
 450     public function emailAliases()
 451     {
 452         return XDB::fetchColumn('SELECT  CONCAT(s.email, \'@\', d.name)
 453                                    FROM  email_source_account  AS s
 454                              INNER JOIN  email_virtual_domains AS m ON (s.domain = m.id)
 455                              INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
 456                                   WHERE  s.uid = {?} AND s.type = \'alias_aux\'
 457                                ORDER BY  d.name',
 458                                 $this->id());
 459     }
 460
 461     /** Get all group aliases the user belongs to.
 462      */
 463     public function emailGroupAliases($domain = null)
 464     {
 465         if (is_null($domain)) {
 466             return XDB::fetchColumn('SELECT  CONCAT(v.email, \'@\', dv.name) AS alias
 467                                        FROM  email_virtual         AS v
 468                                  INNER JOIN  email_virtual_domains AS dv ON (v.domain = dv.id)
 469                                  INNER JOIN  email_source_account  AS s  ON (s.uid = {?})
 470                                  INNER JOIN  email_virtual_domains AS ms ON (s.domain = ms.id)
 471                                  INNER JOIN  email_virtual_domains AS ds ON (ds.aliasing = ms.id)
 472                                       WHERE  v.redirect = CONCAT(s.email, \'@\', ds.name) AND v.type = \'alias\'',
 473                                     $this->id());
 474         } else {
 475             return XDB::fetchAllAssoc('alias',
 476                                       'SELECT  CONCAT(v.email, \'@\', dv.name) AS alias, MAX(v.redirect = CONCAT(s.email, \'@\', ds.name)) AS sub
 477                                          FROM  email_virtual         AS v
 478                                    INNER JOIN  email_virtual_domains AS dv ON (v.domain = dv.id AND dv.name = {?})
 479                                    INNER JOIN  email_source_account  AS s  ON (s.uid = {?})
 480                                    INNER JOIN  email_virtual_domains AS ms ON (s.domain = ms.id)
 481                                    INNER JOIN  email_virtual_domains AS ds ON (ds.aliasing = ms.id)
 482                                         WHERE  v.type = \'alias\'
 483                                      GROUP BY  v.email
 484                                      ORDER BY  v.email',
 485                                       $domain, $this->id());
 486         }
 487     }
 488
 489     /** Get marketing informations
 490      */
 491     private function fetchMarketingData()
 492     {
 493         if (isset($this->pending_registration_date)) {
 494             return;
 495         }
 496         $infos = XDB::fetchOneAssoc('SELECT  rp.date AS pending_registration_date, rp.email AS pending_registration_email,
 497                                              rm.last AS last_marketing_date, rm.email AS last_marketing_email
 498                                        FROM  accounts           AS a
 499                                   LEFT JOIN  register_pending   AS rp ON (rp.uid = a.uid)
 500                                   LEFT JOIN  register_marketing AS rm ON (rm.uid = a.uid AND rm.last != \'0000-00-00\')
 501                                       WHERE  a.uid = {?}
 502                                    ORDER BY  rm.last DESC', $this->id());
 503         if (is_null($infos)) {
 504             $infos = array(
 505                 'pending_registration_date'  => null,
 506                 'pending_registration_email' => null,
 507                 'last_marketing_date'        => null,
 508                 'last_marketing_email'       => null
 509             );
 510         }
 511         $this->fillFromArray($infos);
 512     }
 513
 514     public function pendingRegistrationDate()
 515     {
 516         $this->fetchMarketingData();
 517         return $this->pending_registration_date;
 518     }
 519
 520     public function pendingRegistrationEmail()
 521     {
 522         $this->fetchMarketingData();
 523         return $this->pending_registration_email;
 524     }
 525
 526     public function lastMarketingDate()
 527     {
 528         $this->fetchMarketingData();
 529         return $this->last_marketing_date;
 530     }
 531
 532     public function lastMarketingEmail()
 533     {
 534         $this->fetchMarketingData();
 535         return $this->last_marketing_email;
 536     }
 537
 538     public function lastKnownEmail()
 539     {
 540         $this->fetchMarketingData();
 541         if ($this->pending_registration_email > $this->last_marketing_date) {
 542             return $this->pending_registration_email;
 543         }
 544         return $this->last_marketing_email;
 545     }
 546
 547
 548     /** Format of the emails sent by the site
 549      */
 550     public function setEmailFormat($format)
 551     {
 552         Platal::assert($format == self::FORMAT_HTML || $format == self::FORMAT_TEXT,
 553                        "Invalid email format \"$format\"");
 554         XDB::execute("UPDATE  accounts
 555                          SET  email_format = {?}
 556                        WHERE  uid = {?}",
 557                      $format, $this->uid);
 558         $this->email_format = $format;
 559     }
 560
 561     /** Get watch informations
 562      */
 563     private function fetchWatchData()
 564     {
 565         if (isset($this->watch_actions)) {
 566             return;
 567         }
 568         $watch = XDB::fetchOneAssoc('SELECT  flags AS watch_flags, actions AS watch_actions,
 569                                              UNIX_TIMESTAMP(last) AS watch_last
 570                                        FROM  watch
 571                                       WHERE  uid = {?}', $this->id());
 572         $watch['watch_flags'] = new PlFlagSet($watch['watch_flags']);
 573         $watch['watch_actions'] = new PlFlagSet($watch['watch_actions']);
 574         $watch['watch_promos'] = XDB::fetchColumn('SELECT  promo
 575                                                      FROM  watch_promo
 576                                                     WHERE  uid = {?}', $this->id());
 577         $watch['watch_groups'] = XDB::fetchColumn("SELECT  w.groupid
 578                                                      FROM  watch_group AS w
 579                                                INNER JOIN  groups      AS g ON (w.groupid = g.id AND NOT FIND_IN_SET('private', pub))
 580                                                     WHERE  w.uid = {?}", $this->id());
 581         $watch['watch_users'] = XDB::fetchColumn('SELECT  ni_id
 582                                                     FROM  watch_nonins
 583                                                    WHERE  uid = {?}', $this->id());
 584         $this->fillFromArray($watch);
 585     }
 586
 587     public function watchType($type)
 588     {
 589         $this->fetchWatchData();
 590         return $this->watch_actions->hasFlag($type);
 591     }
 592
 593     public function watchContacts()
 594     {
 595         $this->fetchWatchData();
 596         return $this->watch_flags->hasFlag('contacts');
 597     }
 598
 599     public function watchEmail()
 600     {
 601         $this->fetchWatchData();
 602         return $this->watch_flags->hasFlag('mail');
 603     }
 604
 605     public function watchPromos()
 606     {
 607         $this->fetchWatchData();
 608         return $this->watch_promos;
 609     }
 610
 611     public function watchGroups()
 612     {
 613         $this->fetchWatchData();
 614         return $this->watch_groups;
 615     }
 616
 617     public function watchUsers()
 618     {
 619         $this->fetchWatchData();
 620         return $this->watch_users;
 621     }
 622
 623     public function watchLast()
 624     {
 625         $this->fetchWatchData();
 626         return $this->watch_last;
 627     }
 628
 629     public function invalidWatchCache()
 630     {
 631         unset($this->watch_actions);
 632         unset($this->watch_users);
 633         unset($this->watch_last);
 634         unset($this->watch_promos);
 635         unset($this->watch_groups);
 636     }
 637
 638
 639     // Contacts
 640     private $contacts = null;
 641     private function fetchContacts()
 642     {
 643         if (is_null($this->contacts)) {
 644             $this->contacts = XDB::fetchAllAssoc('contact', 'SELECT  *
 645                                                                FROM  contacts
 646                                                               WHERE  uid = {?}',
 647                                                  $this->id());
 648         }
 649     }
 650
 651     public function iterContacts()
 652     {
 653         $this->fetchContacts();
 654         return Profile::iterOverPIDs(array_keys($this->contacts));
 655     }
 656
 657     public function getContacts()
 658     {
 659         $this->fetchContacts();
 660         return Profile::getBulkProfilesWithPIDs(array_keys($this->contacts));
 661     }
 662
 663     public function isContact(Profile $profile)
 664     {
 665         $this->fetchContacts();
 666         return isset($this->contacts[$profile->id()]);
 667     }
 668
 669     public function isWatchedUser(Profile $profile)
 670     {
 671         return in_array($profile->id(), $this->watchUsers());
 672     }
 673
 674     // Groupes X
 675     private $groups = null;
 676     public function groups($institutions = false, $onlyPublic = false)
 677     {
 678         if (is_null($this->groups)) {
 679             $this->groups = XDB::fetchAllAssoc('asso_id', 'SELECT  gm.asso_id, gm.perms, gm.comm,
 680                                                                    g.diminutif, g.nom, g.site, g.cat,
 681                                                                    g.pub
 682                                                              FROM  group_members AS gm
 683                                                        INNER JOIN  groups AS g ON (g.id = gm.asso_id)
 684                                                             WHERE  uid = {?}',
 685                                                 $this->id());
 686         }
 687         if (!$institutions && !$onlyPublic) {
 688             return $this->groups;
 689         } else {
 690             $result = array();
 691             foreach ($this->groups as $id=>$data) {
 692                 if ($institutions) {
 693                     if ($data['cat'] != Group::CAT_GROUPESX && $data['cat'] != Group::CAT_INSTITUTIONS) {
 694                         continue;
 695                     }
 696                 }
 697                 if ($onlyPublic) {
 698                     if ($data['pub'] != 'public') {
 699                         continue;
 700                     }
 701                 }
 702                 $result[$id] = $data;
 703             }
 704             return $result;
 705         }
 706     }
 707
 708     public function groupCount()
 709     {
 710         return XDB::fetchOneCell('SELECT  COUNT(DISTINCT(asso_id))
 711                                     FROM  group_members
 712                                    WHERE  uid = {?}',
 713                                  $this->id());
 714     }
 715
 716     public function inGroup($asso_id)
 717     {
 718         $res = XDB::fetchOneCell('SELECT  COUNT(*)
 719                                     FROM  group_members
 720                                    WHERE  uid = {?} AND asso_id = {?}',
 721                                  $this->id(), $asso_id);
 722         return ($res > 0);
 723     }
 724
 725     /**
 726      * Clears a user.
 727      *  *always deletes in: account_lost_passwords, register_marketing,
 728      *      register_pending, register_subs, watch_nonins, watch, watch_promo, watch_group,
 729      *  *always keeps in: account_types, accounts, email_virtual, carvas,
 730      *      group_members, homonyms_list, newsletter_ins, register_mstats, email_source_account
 731      *  *deletes if $clearAll: account_auth_openid, announce_read, contacts,
 732      *      email_redirect_account, email_redirect_account, email_send_save, forum_innd, forum_profiles,
 733      *      forum_subs, gapps_accounts, gapps_nicknames, group_announces_read,
 734      *      group_member_sub_requests, reminder, requests, requests_hidden,
 735      *      email_virtual, ML
 736      *  *modifies if $clearAll: accounts
 737      *
 738      * Use cases:
 739      *  *$clearAll == false: when a user dies, her family still needs to keep in
 740      *      touch with the community.
 741      *  *$clearAll == true: in every other case we want the account to be fully
 742      *      deleted so that it can not be used anymore.
 743      */
 744     public function clear($clearAll = true)
 745     {
 746         $tables = array('account_lost_passwords', 'register_marketing',
 747                         'register_pending', 'register_subs', 'watch_nonins',
 748                         'watch', 'watch_promo', 'watch_group');
 749
 750         foreach ($tables as $t) {
 751             XDB::execute('DELETE FROM  ' . $t . '
 752                                 WHERE  uid = {?}',
 753                                 $this->id());
 754         }
 755
 756         if ($clearAll) {
 757             global $globals;
 758
 759             $groupIds = XDB::iterator('SELECT  asso_id
 760                                          FROM  group_members
 761                                         WHERE  uid = {?}',
 762                                       $this->id());
 763             while ($groupId = $groupIds->next()) {
 764                 $group = Group::get($groupId);
 765                 if (!empty($group) && $group->notif_unsub) {
 766                     $mailer = new PlMailer('xnetgrp/unsubscription-notif.mail.tpl');
 767                     $admins = $group->iterAdmins();
 768                     while ($admin = $admins->next()) {
 769                         $mailer->addTo($admin);
 770                     }
 771                     $mailer->assign('group', $group->shortname);
 772                     $mailer->assign('user', $this);
 773                     $mailer->assign('selfdone', false);
 774                     $mailer->send();
 775                 }
 776             }
 777
 778             $tables = array('account_auth_openid', 'announce_read', 'contacts',
 779                             'email_send_save',
 780                             'forum_innd', 'forum_profiles', 'forum_subs',
 781                             'group_announces_read', 'group_members',
 782                             'group_member_sub_requests', 'reminder', 'requests',
 783                             'requests_hidden');
 784             foreach ($tables as $t) {
 785                 XDB::execute('DELETE FROM  ' . $t . '
 786                                     WHERE  uid = {?}',
 787                              $this->id());
 788             }
 789             XDB::execute('DELETE FROM  email_redirect_account
 790                                 WHERE  uid = {?} AND type != \'homonym\'',
 791                          $this->id());
 792             XDB::execute('DELETE FROM  email_virtual
 793                                 WHERE  redirect = {?}',
 794                          $this->forlifeEmail());
 795
 796             foreach (array('gapps_accounts', 'gapps_nicknames') as $t) {
 797                 XDB::execute('DELETE FROM  ' . $t . '
 798                                     WHERE  l_userid = {?}',
 799                              $this->id());
 800             }
 801
 802             XDB::execute("UPDATE  accounts
 803                              SET  registration_date = 0, state = 'pending', password = NULL,
 804                                   weak_password = NULL, token = NULL, is_admin = 0
 805                            WHERE  uid = {?}",
 806                          $this->id());
 807
 808             if ($globals->mailstorage->googleapps_domain) {
 809                 require_once 'googleapps.inc.php';
 810
 811                 if (GoogleAppsAccount::account_status($this->id())) {
 812                     $account = new GoogleAppsAccount($this);
 813                     $account->suspend();
 814                 }
 815             }
 816         }
 817
 818         $mmlist = new MMList(S::user());
 819         $mmlist->kill($this->hruid, $clearAll);
 820     }
 821
 822     // Merge all infos in other user and then clean this one
 823     public function mergeIn(User $newuser) {
 824         if ($this->profile()) {
 825             // Don't disable user with profile in this way.
 826             global $globals;
 827             Platal::page()->trigError('Impossible de fusionner les comptes ' . $this->hruid . ' et ' . $newuser->hruid .
 828                                       '. Contacte support@' . $globals->mail->domain . '.');
 829             return false;
 830         }
 831
 832         if ($this->forlifeEmail()) {
 833             // If the new user is not registered and does not have already an email address,
 834             // we need to give him the old user's email address if he has any.
 835             if (!$newuser->perms) {
 836                 XDB::execute('UPDATE  accounts
 837                                  SET  email = {?}
 838                                WHERE  uid = {?} AND email IS NULL',
 839                              $this->forlifeEmail(), $newuser->id());
 840
 841                 // Reftech new user so its forlifeEmail will be correct.
 842                 $newuser = self::getSilentWithUID($newuser->id());
 843             }
 844
 845             // Change email used in mailing lists.
 846             if ($this->forlifeEmail() != $newuser->forlifeEmail()) {
 847                 // The super user is the user who has the right to do the modification.
 848                 $super_user = S::user();
 849                 // group mailing lists
 850                 $group_domains = XDB::fetchColumn('SELECT  g.mail_domain
 851                                                      FROM  groups        AS g
 852                                                INNER JOIN  group_members AS gm ON(g.id = gm.asso_id)
 853                                                     WHERE  g.mail_domain != \'\' AND gm.uid = {?}',
 854                                                   $this->id());
 855                 foreach ($group_domains as $mail_domain) {
 856                     $mmlist = new MMList($super_user, $mail_domain);
 857                     $mmlist->replace_email_in_all($this->forlifeEmail(), $newuser->forlifeEmail());
 858                 }
 859                 // main domain lists
 860                 $mmlist = new MMList($super_user);
 861                 $mmlist->replace_email_in_all($this->forlifeEmail(), $newuser->forlifeEmail());
 862             }
 863         }
 864
 865         // Updates user in following tables.
 866         foreach (array('group_announces', 'payment_transactions', 'log_sessions', 'group_events') as $table) {
 867             XDB::execute('UPDATE  ' . $table . '
 868                              SET  uid = {?}
 869                            WHERE  uid = {?}',
 870                          $newuser->id(), $this->id());
 871         }
 872
 873         // Merges user in following tables, ie updates when possible, then deletes remaining occurences of the old user.
 874         foreach (array('group_announces_read', 'group_event_participants', 'group_member_sub_requests', 'group_members', 'email_redirect_account') as $table) {
 875             XDB::execute('UPDATE IGNORE  ' . $table . '
 876                                     SET  uid = {?}
 877                                   WHERE  uid = {?}',
 878                          $newuser->id(), $this->id());
 879             XDB::execute('DELETE FROM  ' . $table . '
 880                                 WHERE  uid = {?}',
 881                          $this->id());
 882         }
 883
 884         // Eventually updates last session id and deletes old user's accounts entry.
 885         $lastSession = XDB::fetchOneCell('SELECT  id
 886                                             FROM  log_sessions
 887                                            WHERE  uid = {?}
 888                                         ORDER BY  start DESC
 889                                            LIMIT  1',
 890                                          $newuser->id());
 891         XDB::execute('UPDATE  log_last_sessions
 892                          SET  id = {?}
 893                        WHERE  uid = {?}',
 894                      $lastSession, $newuser->id());
 895         XDB::execute('DELETE FROM  accounts
 896                             WHERE  uid = {?}',
 897                      $this->id());
 898
 899         return true;
 900     }
 901
 902     // Return permission flags for a given permission level.
 903     public static function makePerms($perms, $is_admin)
 904     {
 905         $flags = new PlFlagSet($perms);
 906         if ($is_admin) {
 907             $flags->addFlag(PERMS_ADMIN);
 908         }
 909
 910         // Access to private directory implies access to 'less'-private version.
 911         if ($flags->hasFlag('directory_private')) {
 912             $flags->addFlag('directory_ax');
 913         }
 914         return $flags;
 915     }
 916
 917     // Implementation of the default user callback.
 918     public static function _default_user_callback($login, $results)
 919     {
 920         $result_count = count($results);
 921         if ($result_count == 0 || !S::admin()) {
 922             Platal::page()->trigError("Il n'y a pas d'utilisateur avec l'identifiant : $login");
 923         } else {
 924             Platal::page()->trigError("Il y a $result_count utilisateurs avec cet identifiant : " . join(', ', $results));
 925         }
 926     }
 927
 928     public static function makeHomonymHrmid($alias)
 929     {
 930         return 'h.' . $alias . '.' . Platal::globals()->mail->domain;
 931     }
 932
 933     public static function isMainMailDomain($domain)
 934     {
 935         global $globals;
 936
 937         $is_main_domain = false;
 938         foreach (self::$sub_mail_domains as $sub_domain) {
 939             $is_main_domain = $is_main_domain || $domain == ($sub_domain . $globals->mail->domain) || $domain == ($sub_domain . $globals->mail->domain2);
 940         }
 941         return $is_main_domain;
 942     }
 943
 944     public static function isAliasMailDomain($domain)
 945     {
 946         global $globals;
 947
 948         return $domain == $globals->mail->alias_dom || $domain == $globals->mail->alias_dom2;
 949     }
 950
 951     // Implementation of the static email locality checker.
 952     public static function isForeignEmailAddress($email)
 953     {
 954         if (strpos($email, '@') === false) {
 955             return false;
 956         }
 957
 958         list(, $domain) = explode('@', $email);
 959         return !(self::isMainMailDomain($domain) || self::isAliasMailDomain($domain));
 960     }
 961
 962     /* Tries to find pending accounts with an hruid close to $login. */
 963     public static function getPendingAccounts($login, $iterator = false)
 964     {
 965         if (strpos($login, '@') === false) {
 966             return null;
 967         }
 968
 969         list($login, $domain) = explode('@', $login);
 970
 971         if ($domain && !self::isMainMailDomain($domain)) {
 972             return null;
 973         }
 974
 975         $sql = "SELECT  uid, full_name
 976                   FROM  accounts
 977                  WHERE  state = 'pending' AND REPLACE(hruid, '-', '') LIKE
 978                         CONCAT('%', REPLACE(REPLACE(REPLACE({?}, ' ', ''), '-', ''), '\'', ''), '%')
 979               ORDER BY  full_name";
 980         if ($iterator) {
 981             return XDB::iterator($sql, $login);
 982         } else {
 983             $res = XDB::query($sql, $login);
 984             return $res->fetchAllAssoc();
 985         }
 986     }
 987
 988
 989     public static function iterOverUIDs($uids, $respect_order = true)
 990     {
 991         return new UserIterator(self::loadMainFieldsFromUIDs($uids, $respect_order));
 992     }
 993
 994     /** Fetch a set of users from a list of UIDs
 995      * @param $data The list of uids to fetch, or an array of arrays
 996      * @param $orig If $data is an array of arrays, the subfield where uids are stored
 997      * @param $dest If $data is an array of arrays, the subfield to fill with Users
 998      * @param $fetchProfile Whether to fetch Profiles as well
 999      * @return either an array of $uid => User, or $data with $data[$i][$dest] = User
1000      */
1001     public static function getBulkUsersWithUIDs(array $data, $orig = null, $dest = null, $fetchProfile = true)
1002     {
1003         // Fetch the list of uids
1004         if (is_null($orig)) {
1005             $uids = $data;
1006         } else {
1007             if (is_null($dest)) {
1008                 $dest = $orig;
1009             }
1010             $uids = array();
1011             foreach ($data as $key=>$entry) {
1012                 if (isset($entry[$orig])) {
1013                     $uids[] = $entry[$orig];
1014                 }
1015             }
1016         }
1017
1018         // Fetch users
1019         if (count($uids) == 0) {
1020             return $data;
1021         }
1022         $users = self::iterOverUIDs($uids, true);
1023
1024         $table = array();
1025         if ($fetchProfile) {
1026             $profiles = Profile::iterOverUIDS($uids, true);
1027             if ($profiles != null) {
1028                 $profile = $profiles->next();
1029             } else {
1030                 $profile = null;
1031             }
1032         }
1033
1034         /** We iterate through the users, moving in
1035          * profiles when they match the user ID :
1036          * there can be users without a profile, but not
1037          * the other way around.
1038          */
1039         while (($user = $users->next())) {
1040             if ($fetchProfile) {
1041                 if ($profile != null && $profile->owner_id == $user->id()) {
1042                     $user->_profile = $profile;
1043                     $profile = $profiles->next();
1044                 }
1045                 $user->_profile_fetched = true;
1046             }
1047             $table[$user->id()] = $user;
1048         }
1049
1050         // Build the result with respect to input order.
1051         if (is_null($orig)) {
1052             return $table;
1053         } else {
1054             foreach ($data as $key=>$entry) {
1055                 if (isset($entry[$orig])) {
1056                     $entry[$dest] = $table[$entry[$orig]];
1057                     $data[$key] = $entry;
1058                 }
1059             }
1060             return $data;
1061         }
1062     }
1063
1064     public static function getBulkUsersFromDB($fetchProfile = true)
1065     {
1066         $args = func_get_args();
1067         $uids = call_user_func_array(array('XDB', 'fetchColumn'), $args);
1068         return self::getBulkUsersWithUIDs($uids, null, null, $fetchProfile);
1069     }
1070 }
1071
1072 /** Iterator over a set of Users
1073  * @param an XDB::Iterator obtained from a User::loadMainFieldsFromUIDs
1074  */
1075 class UserIterator implements PlIterator
1076 {
1077     private $dbiter;
1078
1079     public function __construct($dbiter)
1080     {
1081         $this->dbiter = $dbiter;
1082     }
1083
1084     public function next()
1085     {
1086         $data = $this->dbiter->next();
1087         if ($data == null) {
1088             return null;
1089         } else {
1090             return User::getSilentWithValues(null, $data);
1091         }
1092     }
1093
1094     public function total()
1095     {
1096         return $this->dbiter->total();
1097     }
1098
1099     public function first()
1100     {
1101         return $this->dbiter->first();
1102     }
1103
1104     public function last()
1105     {
1106         return $this->dbiter->last();
1107     }
1108 }
1109
1110 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker fenc=utf-8:
1111 ?>