classes/userfilter.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2010 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
  23 /******************
  24  * CONDITIONS
  25  ******************/
  26
  27 // {{{ interface UserFilterCondition
  28 /** This interface describe objects which filter users based
  29  *      on various parameters.
  30  * The parameters of the filter must be given to the constructor.
  31  * The buildCondition function is called by UserFilter when
  32  *     actually building the query. That function must call
  33  *     $uf->addWheteverFilter so that the UserFilter makes
  34  *     adequate joins. It must return the 'WHERE' condition to use
  35  *     with the filter.
  36  */
  37 interface UserFilterCondition extends PlFilterCondition
  38 {
  39 }
  40 // }}}
  41
  42 // {{{ class UFC_HasProfile
  43 /** Filters users who have a profile
  44  */
  45 class UFC_HasProfile implements UserFilterCondition
  46 {
  47     public function buildCondition(PlFilter &$uf)
  48     {
  49         $uf->requireProfiles();
  50         return '$PID IS NOT NULL';
  51     }
  52 }
  53 // }}}
  54
  55 // {{{ class UFC_Hruid
  56 /** Filters users based on their hruid
  57  * @param $val Either an hruid, or a list of those
  58  */
  59 class UFC_Hruid implements UserFilterCondition
  60 {
  61     private $hruids;
  62
  63     public function __construct()
  64     {
  65         $this->hruids = pl_flatten(func_get_args());
  66     }
  67
  68     public function buildCondition(PlFilter &$uf)
  69     {
  70         $uf->requireAccounts();
  71         return XDB::format('a.hruid IN {?}', $this->hruids);
  72     }
  73 }
  74 // }}}
  75
  76 // {{{ class UFC_Hrpid
  77 /** Filters users based on the hrpid of their profiles
  78  * @param $val Either an hrpid, or a list of those
  79  */
  80 class UFC_Hrpid implements UserFilterCondition
  81 {
  82     private $hrpids;
  83
  84     public function __construct()
  85     {
  86         $this->hrpids = pl_flatten(func_get_args());
  87     }
  88
  89     public function buildCondition(PlFilter &$uf)
  90     {
  91         $uf->requireProfiles();
  92         return XDB::format('p.hrpid IN {?}', $this->hrpids);
  93     }
  94 }
  95 // }}}
  96
  97 // {{{ class UFC_Ip
  98 /** Filters users based on one of their last IPs
  99  * @param $ip IP from which connection are checked
 100  */
 101 class UFC_Ip implements UserFilterCondition
 102 {
 103     private $ip;
 104
 105     public function __construct($ip)
 106     {
 107         $this->ip = $ip;
 108     }
 109
 110     public function buildCondition(PlFilter &$uf)
 111     {
 112         $sub = $uf->addLoggerFilter();
 113         $ip = ip_to_uint($this->ip);
 114         return XDB::format($sub . '.ip = {?} OR ' . $sub . '.forward_ip = {?}', $ip, $ip);
 115     }
 116 }
 117 // }}}
 118
 119 // {{{ class UFC_Comment
 120 class UFC_Comment implements UserFilterCondition
 121 {
 122     private $text;
 123
 124     public function __construct($text)
 125     {
 126         $this->text = $text;
 127     }
 128
 129     public function buildCondition(PlFilter &$uf)
 130     {
 131         $uf->requireProfiles();
 132         return $uf->getVisibilityCondition('p.freetext_pub') . ' AND p.freetext ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->text);
 133     }
 134 }
 135 // }}}
 136
 137 // {{{ class UFC_Promo
 138 /** Filters users based on promotion
 139  * @param $comparison Comparison operator (>, =, ...)
 140  * @param $grade Formation on which to restrict, UserFilter::DISPLAY for "any formation"
 141  * @param $promo Promotion on which the filter is based
 142  */
 143 class UFC_Promo implements UserFilterCondition
 144 {
 145
 146     private $grade;
 147     private $promo;
 148     private $comparison;
 149
 150     public function __construct($comparison, $grade, $promo)
 151     {
 152         $this->grade = $grade;
 153         $this->comparison = $comparison;
 154         $this->promo = $promo;
 155         if ($this->grade != UserFilter::DISPLAY) {
 156             UserFilter::assertGrade($this->grade);
 157         }
 158         if ($this->grade == UserFilter::DISPLAY && $this->comparison != '=') {
 159             // XXX: we might try to guess the grade from the first char of the promo and forbid only '<= 2004', but allow '<= X2004'
 160             Platal::page()->killError("Il n'est pas possible d'appliquer la comparaison '" . $this->comparison . "' aux promotions sans spécifier de formation (X/M/D)");
 161         }
 162     }
 163
 164     public function buildCondition(PlFilter &$uf)
 165     {
 166         if ($this->grade == UserFilter::DISPLAY) {
 167             $sub = $uf->addDisplayFilter();
 168             return XDB::format('pd' . $sub . '.promo ' . $this->comparison . ' {?}', $this->promo);
 169         } else {
 170             $sub = $uf->addEducationFilter(true, $this->grade);
 171             $field = 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
 172             return $field . ' IS NOT NULL AND ' . $field . ' ' . $this->comparison . ' ' . XDB::format('{?}', $this->promo);
 173         }
 174     }
 175 }
 176 // }}}
 177
 178 // {{{ class UFC_SchoolId
 179 /** Filters users based on their shoold identifier
 180  * @param type Parameter type (Xorg, AX, School)
 181  * @param value School id value
 182  */
 183 class UFC_SchoolId implements UserFilterCondition
 184 {
 185     const AX     = 'ax';
 186     const Xorg   = 'xorg';
 187     const School = 'school';
 188
 189     private $type;
 190     private $id;
 191
 192     static public function assertType($type)
 193     {
 194         if ($type != self::AX && $type != self::Xorg && $type != self::School) {
 195             Platal::page()->killError("Type de matricule invalide: $type");
 196         }
 197     }
 198
 199     public function __construct($type, $id)
 200     {
 201         $this->type = $type;
 202         $this->id   = $id;
 203         self::assertType($type);
 204     }
 205
 206     public function buildCondition(PlFilter &$uf)
 207     {
 208         $uf->requireProfiles();
 209         $id = $this->id;
 210         $type = $this->type;
 211         if ($type == self::School) {
 212             $type = self::Xorg;
 213             $id   = Profile::getXorgId($id);
 214         }
 215         return XDB::format('p.' . $type . '_id = {?}', $id);
 216     }
 217 }
 218 // }}}
 219
 220 // {{{ class UFC_EducationSchool
 221 /** Filters users by formation
 222  * @param $val The formation to search (either ID or array of IDs)
 223  */
 224 class UFC_EducationSchool implements UserFilterCondition
 225 {
 226     private $val;
 227
 228     public function __construct()
 229     {
 230         $this->val = pl_flatten(func_get_args());
 231     }
 232
 233     public function buildCondition(PlFilter &$uf)
 234     {
 235         $sub = $uf->addEducationFilter();
 236         return XDB::format('pe' . $sub . '.eduid IN {?}', $this->val);
 237     }
 238 }
 239 // }}}
 240
 241 // {{{ class UFC_EducationDegree
 242 class UFC_EducationDegree implements UserFilterCondition
 243 {
 244     private $diploma;
 245
 246     public function __construct()
 247     {
 248         $this->diploma = pl_flatten(func_get_args());
 249     }
 250
 251     public function buildCondition(PlFilter &$uf)
 252     {
 253         $sub = $uf->addEducationFilter();
 254         return XDB::format('pe' . $sub . '.degreeid IN {?}', $this->diploma);
 255     }
 256 }
 257 // }}}
 258
 259 // {{{ class UFC_EducationField
 260 class UFC_EducationField implements UserFilterCondition
 261 {
 262     private $val;
 263
 264     public function __construct()
 265     {
 266         $this->val = pl_flatten(func_get_args());
 267     }
 268
 269     public function buildCondition(PlFilter &$uf)
 270     {
 271         $sub = $uf->addEducationFilter();
 272         return XDB::format('pe' . $sub . '.fieldid IN {?}', $this->val);
 273     }
 274 }
 275 // }}}
 276
 277 // {{{ class UFC_Name
 278 /** Filters users based on name
 279  * @param $type Type of name field on which filtering is done (firstname, lastname...)
 280  * @param $text Text on which to filter
 281  * @param $mode Flag indicating search type (prefix, suffix, with particule...)
 282  */
 283 class UFC_Name implements UserFilterCondition
 284 {
 285     const EXACT    = XDB::WILDCARD_EXACT;    // 0x000
 286     const PREFIX   = XDB::WILDCARD_PREFIX;   // 0x001
 287     const SUFFIX   = XDB::WILDCARD_SUFFIX;   // 0x002
 288     const CONTAINS = XDB::WILDCARD_CONTAINS; // 0x003
 289     const PARTICLE = 0x004;
 290     const VARIANTS = 0x008;
 291
 292     private $type;
 293     private $text;
 294     private $mode;
 295
 296     public function __construct($type, $text, $mode)
 297     {
 298         $this->type = $type;
 299         $this->text = $text;
 300         $this->mode = $mode;
 301     }
 302
 303     private function buildNameQuery($type, $variant, $where, UserFilter &$uf)
 304     {
 305         $sub = $uf->addNameFilter($type, $variant);
 306         return str_replace('$ME', 'pn' . $sub, $where);
 307     }
 308
 309     public function buildCondition(PlFilter &$uf)
 310     {
 311         $left = '$ME.name';
 312         if (($this->mode & self::PARTICLE) == self::PARTICLE) {
 313             $left = 'CONCAT($ME.particle, \' \', $ME.name)';
 314         }
 315         $right = XDB::formatWildcards($this->mode & self::CONTAINS, $this->text);
 316
 317         $cond = $left . $right;
 318         $conds = array($this->buildNameQuery($this->type, null, $cond, $uf));
 319         if (($this->mode & self::VARIANTS) != 0 && isset(Profile::$name_variants[$this->type])) {
 320             foreach (Profile::$name_variants[$this->type] as $var) {
 321                 $conds[] = $this->buildNameQuery($this->type, $var, $cond, $uf);
 322             }
 323         }
 324         return implode(' OR ', $conds);
 325     }
 326 }
 327 // }}}
 328
 329 // {{{ class UFC_NameTokens
 330 /** Selects users based on tokens in their name (for quicksearch)
 331  * @param $tokens An array of tokens to search
 332  * @param $flags Flags the tokens must have (e.g 'public' for public search)
 333  * @param $soundex (bool) Whether those tokens are fulltext or soundex
 334  */
 335 class UFC_NameTokens implements UserFilterCondition
 336 {
 337     /* Flags */
 338     const FLAG_PUBLIC = 'public';
 339
 340     private $tokens;
 341     private $flags;
 342     private $soundex;
 343     private $exact;
 344
 345     public function __construct($tokens, $flags = array(), $soundex = false, $exact = false)
 346     {
 347         if (is_array($tokens)) {
 348             $this->tokens = $tokens;
 349         } else {
 350             $this->tokens = array($tokens);
 351         }
 352         if (is_array($flags)) {
 353             $this->flags = $flags;
 354         } else {
 355             $this->flags = array($flags);
 356         }
 357         $this->soundex = $soundex;
 358         $this->exact = $exact;
 359     }
 360
 361     public function buildCondition(PlFilter &$uf)
 362     {
 363         $conds = array();
 364         foreach ($this->tokens as $i => $token) {
 365             $sub = $uf->addNameTokensFilter($token);
 366             if ($this->soundex) {
 367                 $c = XDB::format($sub . '.soundex = {?}', $token);
 368             } else if ($this->exact) {
 369                 $c = XDB::format($sub . '.token = {?}', $token);
 370             } else {
 371                 $c = $sub . '.token ' . XDB::formatWildcards(XDB::WILDCARD_PREFIX, $token);
 372             }
 373             if ($this->flags != null) {
 374                 $c .= XDB::format(' AND ' . $sub . '.flags IN {?}', $this->flags);
 375             }
 376             $conds[] = $c;
 377         }
 378
 379         return implode(' AND ', $conds);
 380     }
 381 }
 382 // }}}
 383
 384 // {{{ class UFC_Nationality
 385 class UFC_Nationality implements UserFilterCondition
 386 {
 387     private $val;
 388
 389     public function __construct()
 390     {
 391         $this->val = pl_flatten(func_get_args());
 392     }
 393
 394     public function buildCondition(PlFilter &$uf)
 395     {
 396         $uf->requireProfiles();
 397         $nat = XDB::formatArray($this->val);
 398         $conds = array(
 399             'p.nationality1 IN ' . $nat,
 400             'p.nationality2 IN ' . $nat,
 401             'p.nationality3 IN ' . $nat,
 402         );
 403         return implode(' OR ', $conds);
 404     }
 405 }
 406 // }}}
 407
 408 // {{{ class UFC_Dead
 409 /** Filters users based on death date
 410  * @param $comparison Comparison operator
 411  * @param $date Date to which death date should be compared (DateTime object, string or timestamp)
 412  */
 413 class UFC_Dead implements UserFilterCondition
 414 {
 415     private $comparison;
 416     private $date;
 417
 418     public function __construct($comparison = null, $date = null)
 419     {
 420         $this->comparison = $comparison;
 421         $this->date = make_datetime($date);
 422     }
 423
 424     public function buildCondition(PlFilter &$uf)
 425     {
 426         $uf->requireProfiles();
 427         $str = 'p.deathdate IS NOT NULL';
 428         if (!is_null($this->comparison)) {
 429             $str .= ' AND p.deathdate ' . $this->comparison . ' ' . XDB::format('{?}', $this->date->format('Y-m-d'));
 430         }
 431         return $str;
 432     }
 433 }
 434 // }}}
 435
 436 // {{{ class UFC_Registered
 437 /** Filters users based on registration state
 438  * @param $active Whether we want to use only "active" users (i.e with a valid redirection)
 439  * @param $comparison Comparison operator
 440  * @param $date Date to which users registration date should be compared
 441  */
 442 class UFC_Registered implements UserFilterCondition
 443 {
 444     private $active;
 445     private $comparison;
 446     private $date;
 447
 448     public function __construct($active = false, $comparison = null, $date = null)
 449     {
 450         $this->active = $active;
 451         $this->comparison = $comparison;
 452         $this->date = make_datetime($date);
 453     }
 454
 455     public function buildCondition(PlFilter &$uf)
 456     {
 457         $uf->requireAccounts();
 458         if ($this->active) {
 459             $date = '$UID IS NOT NULL AND a.state = \'active\'';
 460         } else {
 461             $date = '$UID IS NOT NULL AND a.state != \'pending\'';
 462         }
 463         if (!is_null($this->comparison)) {
 464             $date .= ' AND a.registration_date != \'0000-00-00 00:00:00\' AND a.registration_date ' . $this->comparison . ' ' . XDB::format('{?}', $this->date->format('Y-m-d'));
 465         }
 466         return $date;
 467     }
 468 }
 469 // }}}
 470
 471 // {{{ class UFC_ProfileUpdated
 472 /** Filters users based on profile update date
 473  * @param $comparison Comparison operator
 474  * @param $date Date to which profile update date must be compared
 475  */
 476 class UFC_ProfileUpdated implements UserFilterCondition
 477 {
 478     private $comparison;
 479     private $date;
 480
 481     public function __construct($comparison = null, $date = null)
 482     {
 483         $this->comparison = $comparison;
 484         $this->date = $date;
 485     }
 486
 487     public function buildCondition(PlFilter &$uf)
 488     {
 489         $uf->requireProfiles();
 490         return 'p.last_change ' . $this->comparison . XDB::format(' {?}', date('Y-m-d H:i:s', $this->date));
 491     }
 492 }
 493 // }}}
 494
 495 // {{{ class UFC_Birthday
 496 /** Filters users based on next birthday date
 497  * @param $comparison Comparison operator
 498  * @param $date Date to which users next birthday date should be compared
 499  */
 500 class UFC_Birthday implements UserFilterCondition
 501 {
 502     private $comparison;
 503     private $date;
 504
 505     public function __construct($comparison = null, $date = null)
 506     {
 507         $this->comparison = $comparison;
 508         $this->date = $date;
 509     }
 510
 511     public function buildCondition(PlFilter &$uf)
 512     {
 513         $uf->requireProfiles();
 514         return 'p.next_birthday ' . $this->comparison . XDB::format(' {?}', date('Y-m-d', $this->date));
 515     }
 516 }
 517 // }}}
 518
 519 // {{{ class UFC_Sex
 520 /** Filters users based on sex
 521  * @parm $sex One of User::GENDER_MALE or User::GENDER_FEMALE, for selecting users
 522  */
 523 class UFC_Sex implements UserFilterCondition
 524 {
 525     private $sex;
 526     public function __construct($sex)
 527     {
 528         $this->sex = $sex;
 529     }
 530
 531     public function buildCondition(PlFilter &$uf)
 532     {
 533         if ($this->sex != User::GENDER_MALE && $this->sex != User::GENDER_FEMALE) {
 534             return self::COND_FALSE;
 535         } else {
 536             $uf->requireProfiles();
 537             return XDB::format('p.sex = {?}', $this->sex == User::GENDER_FEMALE ? 'female' : 'male');
 538         }
 539     }
 540 }
 541 // }}}
 542
 543 // {{{ class UFC_Group
 544 /** Filters users based on group membership
 545  * @param $group Group whose members we are selecting
 546  * @param $anim Whether to restrict selection to animators of that group
 547  */
 548 class UFC_Group implements UserFilterCondition
 549 {
 550     private $group;
 551     private $anim;
 552     public function __construct($group, $anim = false)
 553     {
 554         $this->group = $group;
 555         $this->anim = $anim;
 556     }
 557
 558     public function buildCondition(PlFilter &$uf)
 559     {
 560         // Groups have AX visibility.
 561         if ($uf->getVisibilityLevel() == ProfileVisibility::VIS_PUBLIC) {
 562             return PlFilter::COND_TRUE;
 563         }
 564         $sub = $uf->addGroupFilter($this->group);
 565         $where = 'gpm' . $sub . '.perms IS NOT NULL';
 566         if ($this->anim) {
 567             $where .= ' AND gpm' . $sub . '.perms = \'admin\'';
 568         }
 569         return $where;
 570     }
 571 }
 572 // }}}
 573
 574 // {{{ class UFC_Binet
 575 /** Selects users based on their belonging to a given (list of) binet
 576  * @param $binet either a binet_id or an array of binet_ids
 577  */
 578 class UFC_Binet implements UserFilterCondition
 579 {
 580     private $val;
 581
 582     public function __construct()
 583     {
 584         $this->val = pl_flatten(func_get_args());
 585     }
 586
 587     public function buildCondition(PlFilter &$uf)
 588     {
 589         // Binets are private.
 590         if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
 591             return PlFilter::COND_TRUE;
 592         }
 593         $sub = $uf->addBinetsFilter();
 594         return XDB::format($sub . '.binet_id IN {?}', $this->val);
 595     }
 596 }
 597 // }}}
 598
 599 // {{{ class UFC_Section
 600 /** Selects users based on section
 601  * @param $section ID of the section
 602  */
 603 class UFC_Section implements UserFilterCondition
 604 {
 605     private $section;
 606
 607     public function __construct()
 608     {
 609         $this->section = pl_flatten(func_get_args());
 610     }
 611
 612     public function buildCondition(PlFilter &$uf)
 613     {
 614         // Sections are private.
 615         if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
 616             return PlFilter::COND_TRUE;
 617         }
 618         $uf->requireProfiles();
 619         return XDB::format('p.section IN {?}', $this->section);
 620     }
 621 }
 622 // }}}
 623
 624 // {{{ class UFC_Email
 625 /** Filters users based on an email or a list of emails
 626  * @param $emails List of emails whose owner must be selected
 627  */
 628 class UFC_Email implements UserFilterCondition
 629 {
 630     private $emails;
 631     public function __construct()
 632     {
 633         $this->emails = pl_flatten(func_get_args());
 634     }
 635
 636     public function buildCondition(PlFilter &$uf)
 637     {
 638         $foreign = array();
 639         $virtual = array();
 640         $aliases = array();
 641         $cond = array();
 642
 643         if (count($this->emails) == 0) {
 644             return PlFilterCondition::COND_TRUE;
 645         }
 646
 647         foreach ($this->emails as $entry) {
 648             if (User::isForeignEmailAddress($entry)) {
 649                 $foreign[] = $entry;
 650             } else if (User::isVirtualEmailAddress($entry)) {
 651                 $virtual[] = $entry;
 652             } else {
 653                 @list($user, $domain) = explode('@', $entry);
 654                 $aliases[] = $user;
 655             }
 656         }
 657
 658         if (count($foreign) > 0) {
 659             $sub = $uf->addEmailRedirectFilter($foreign);
 660             $cond[] = XDB::format('e' . $sub . '.email IS NOT NULL OR a.email IN {?}', $foreign);
 661         }
 662         if (count($virtual) > 0) {
 663             $sub = $uf->addVirtualEmailFilter($virtual);
 664             $cond[] = 'vr' . $sub . '.redirect IS NOT NULL';
 665         }
 666         if (count($aliases) > 0) {
 667             $sub = $uf->addAliasFilter($aliases);
 668             $cond[] = 'al' . $sub . '.alias IS NOT NULL';
 669         }
 670         return '(' . implode(') OR (', $cond) . ')';
 671     }
 672 }
 673 // }}}
 674
 675 // {{{ class UFC_Address
 676 abstract class UFC_Address implements UserFilterCondition
 677 {
 678     /** Valid address type ('hq' is reserved for company addresses)
 679      */
 680     const TYPE_HOME = 1;
 681     const TYPE_PRO  = 2;
 682     const TYPE_ANY  = 3;
 683
 684     /** Text for these types
 685      */
 686     protected static $typetexts = array(
 687         self::TYPE_HOME => 'home',
 688         self::TYPE_PRO  => 'pro',
 689     );
 690
 691     protected $type;
 692
 693     /** Flags for addresses
 694      */
 695     const FLAG_CURRENT = 0x0001;
 696     const FLAG_TEMP    = 0x0002;
 697     const FLAG_SECOND  = 0x0004;
 698     const FLAG_MAIL    = 0x0008;
 699     const FLAG_CEDEX   = 0x0010;
 700
 701     // Binary OR of those flags
 702     const FLAG_ANY     = 0x001F;
 703
 704     /** Text of these flags
 705      */
 706     protected static $flagtexts = array(
 707         self::FLAG_CURRENT => 'current',
 708         self::FLAG_TEMP    => 'temporary',
 709         self::FLAG_SECOND  => 'secondary',
 710         self::FLAG_MAIL    => 'mail',
 711         self::FLAG_CEDEX   => 'cedex',
 712     );
 713
 714     protected $flags;
 715
 716     public function __construct($type = null, $flags = null)
 717     {
 718         $this->type  = $type;
 719         $this->flags = $flags;
 720     }
 721
 722     protected function initConds($sub, $vis_cond)
 723     {
 724         $conds = array($vis_cond);
 725
 726         $types = array();
 727         foreach (self::$typetexts as $flag => $type) {
 728             if ($flag & $this->type) {
 729                 $types[] = $type;
 730             }
 731         }
 732         if (count($types)) {
 733             $conds[] = XDB::format($sub . '.type IN {?}', $types);
 734         }
 735
 736         if ($this->flags != self::FLAG_ANY) {
 737             foreach(self::$flagtexts as $flag => $text) {
 738                 if ($flag & $this->flags) {
 739                     $conds[] = 'FIND_IN_SET(' . XDB::format('{?}', $text) . ', ' . $sub . '.flags)';
 740                 }
 741             }
 742         }
 743         return $conds;
 744     }
 745
 746 }
 747 // }}}
 748
 749 // {{{ class UFC_AddressText
 750 /** Select users based on their address, using full text search
 751  * @param $text Text for filter in fulltext search
 752  * @param $textSearchMode Mode for search (one of XDB::WILDCARD_*)
 753  * @param $type Filter on address type
 754  * @param $flags Filter on address flags
 755  * @param $country Filter on address country
 756  * @param $locality Filter on address locality
 757  */
 758 class UFC_AddressText extends UFC_Address
 759 {
 760
 761     private $text;
 762     private $textSearchMode;
 763
 764     public function __construct($text = null, $textSearchMode = XDB::WILDCARD_CONTAINS,
 765         $type = null, $flags = self::FLAG_ANY, $country = null, $locality = null)
 766     {
 767         parent::__construct($type, $flags);
 768         $this->text           = $text;
 769         $this->textSearchMode = $textSearchMode;
 770         $this->country        = $country;
 771         $this->locality       = $locality;
 772     }
 773
 774     private function mkMatch($txt)
 775     {
 776         return XDB::formatWildcards($this->textSearchMode, $txt);
 777     }
 778
 779     public function buildCondition(PlFilter &$uf)
 780     {
 781         $sub = $uf->addAddressFilter();
 782         $conds = $this->initConds($sub, $uf->getVisibilityCondition($sub . '.pub'));
 783         if ($this->text != null) {
 784             $conds[] = $sub . '.text' . $this->mkMatch($this->text);
 785         }
 786
 787         if ($this->country != null) {
 788             $subc = $uf->addAddressCountryFilter();
 789             $subconds = array();
 790             $subconds[] = $subc . '.country' . $this->mkMatch($this->country);
 791             $subconds[] = $subc . '.countryFR' . $this->mkMatch($this->country);
 792             $conds[] = implode(' OR ', $subconds);
 793         }
 794
 795         if ($this->locality != null) {
 796             $subl = $uf->addAddressLocalityFilter();
 797             $conds[] = $subl . '.name' . $this->mkMatch($this->locality);
 798         }
 799
 800         return implode(' AND ', $conds);
 801     }
 802 }
 803 // }}}
 804
 805 // {{{ class UFC_AddressField
 806 /** Filters users based on their address,
 807  * @param $val Either a code for one of the fields, or an array of such codes
 808  * @param $fieldtype The type of field to look for
 809  * @param $type Filter on address type
 810  * @param $flags Filter on address flags
 811  */
 812 class UFC_AddressField extends UFC_Address
 813 {
 814     const FIELD_COUNTRY    = 1;
 815     const FIELD_ADMAREA    = 2;
 816     const FIELD_SUBADMAREA = 3;
 817     const FIELD_LOCALITY   = 4;
 818     const FIELD_ZIPCODE    = 5;
 819
 820     /** Data of the filter
 821      */
 822     private $val;
 823     private $fieldtype;
 824
 825     public function __construct($val, $fieldtype, $type = null, $flags = self::FLAG_ANY)
 826     {
 827         parent::__construct($type, $flags);
 828
 829         if (!is_array($val)) {
 830             $val = array($val);
 831         }
 832         $this->val       = $val;
 833         $this->fieldtype = $fieldtype;
 834     }
 835
 836     public function buildCondition(PlFilter &$uf)
 837     {
 838         $sub = $uf->addAddressFilter();
 839         $conds = $this->initConds($sub, $uf->getVisibilityCondition($sub . '.pub'));
 840
 841         switch ($this->fieldtype) {
 842         case self::FIELD_COUNTRY:
 843             $field = 'countryId';
 844             break;
 845         case self::FIELD_ADMAREA:
 846             $field = 'administrativeAreaId';
 847             break;
 848         case self::FIELD_SUBADMAREA:
 849             $field = 'subAdministrativeAreaId';
 850             break;
 851         case self::FIELD_LOCALITY:
 852             $field = 'localityId';
 853             break;
 854         case self::FIELD_ZIPCODE:
 855             $field = 'postalCode';
 856             break;
 857         default:
 858             Platal::page()->killError('Invalid address field type: ' . $this->fieldtype);
 859         }
 860         $conds[] = XDB::format($sub . '.' . $field . ' IN {?}', $this->val);
 861
 862         return implode(' AND ', $conds);
 863     }
 864 }
 865 // }}}
 866
 867 // {{{ class UFC_Corps
 868 /** Filters users based on the corps they belong to
 869  * @param $corps Corps we are looking for (abbreviation)
 870  * @param $type Whether we search for original or current corps
 871  */
 872 class UFC_Corps implements UserFilterCondition
 873 {
 874     const CURRENT   = 1;
 875     const ORIGIN    = 2;
 876
 877     private $corps;
 878     private $type;
 879
 880     public function __construct($corps, $type = self::CURRENT)
 881     {
 882         $this->corps = $corps;
 883         $this->type  = $type;
 884     }
 885
 886     public function buildCondition(PlFilter &$uf)
 887     {
 888         /** Tables shortcuts:
 889          * pc for profile_corps,
 890          * pceo for profile_corps_enum - orginal
 891          * pcec for profile_corps_enum - current
 892          */
 893         $sub = $uf->addCorpsFilter($this->type);
 894         $cond = $sub . '.abbreviation = ' . $corps;
 895         $cond .= ' AND ' . $uf->getVisibilityCondition($sub . '.corps_pub');
 896         return $cond;
 897     }
 898 }
 899 // }}}
 900
 901 // {{{ class UFC_Corps_Rank
 902 /** Filters users based on their rank in the corps
 903  * @param $rank Rank we are looking for (abbreviation)
 904  */
 905 class UFC_Corps_Rank implements UserFilterCondition
 906 {
 907     private $rank;
 908     public function __construct($rank)
 909     {
 910         $this->rank = $rank;
 911     }
 912
 913     public function buildCondition(PlFilter &$uf)
 914     {
 915         /** Tables shortcuts:
 916          * pc for profile_corps
 917          * pcr for profile_corps_rank
 918          */
 919         $sub = $uf->addCorpsRankFilter();
 920         $cond = $sub . '.abbreviation = ' . $rank;
 921         // XXX(x2006barrois): find a way to get rid of that hardcoded
 922         // reference to 'pc'.
 923         $cond .= ' AND ' . $uf->getVisibilityCondition('pc.corps_pub');
 924         return $cond;
 925     }
 926 }
 927 // }}}
 928
 929 // {{{ class UFC_Job_Company
 930 /** Filters users based on the company they belong to
 931  * @param $type The field being searched (self::JOBID, self::JOBNAME or self::JOBACRONYM)
 932  * @param $value The searched value
 933  */
 934 class UFC_Job_Company implements UserFilterCondition
 935 {
 936     const JOBID = 'id';
 937     const JOBNAME = 'name';
 938     const JOBACRONYM = 'acronym';
 939
 940     private $type;
 941     private $value;
 942
 943     public function __construct($type, $value)
 944     {
 945         $this->assertType($type);
 946         $this->type = $type;
 947         $this->value = $value;
 948     }
 949
 950     private function assertType($type)
 951     {
 952         if ($type != self::JOBID && $type != self::JOBNAME && $type != self::JOBACRONYM) {
 953             Platal::page()->killError("Type de recherche non valide.");
 954         }
 955     }
 956
 957     public function buildCondition(PlFilter &$uf)
 958     {
 959         $sub = $uf->addJobCompanyFilter();
 960         $cond  = $sub . '.' . $this->type . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
 961         $jsub = $uf->addJobFilter();
 962         $cond .= ' AND ' . $uf->getVisibilityCondition($jsub . '.pub');
 963         return $cond;
 964     }
 965 }
 966 // }}}
 967
 968 // {{{ class UFC_Job_Sectorization
 969 /** Filters users based on the ((sub)sub)sector they work in
 970  * @param $val The ID of the sector, or an array of such IDs
 971  * @param $type The kind of search (subsubsector/subsector/sector)
 972  */
 973 class UFC_Job_Sectorization implements UserFilterCondition
 974 {
 975     private $val;
 976     private $type;
 977
 978     public function __construct($val, $type = UserFilter::JOB_SECTOR)
 979     {
 980         self::assertType($type);
 981         if (!is_array($val)) {
 982             $val = array($val);
 983         }
 984         $this->val = $val;
 985         $this->type = $type;
 986     }
 987
 988     private static function assertType($type)
 989     {
 990         if ($type != UserFilter::JOB_SECTOR && $type != UserFilter::JOB_SUBSECTOR && $type != UserFilter::JOB_SUBSUBSECTOR) {
 991             Platal::page()->killError("Type de secteur non valide.");
 992         }
 993     }
 994
 995     public function buildCondition(PlFilter &$uf)
 996     {
 997         $sub = $uf->addJobSectorizationFilter($this->type);
 998         $cond = $sub . '.id = ' . XDB::format('{?}', $this->val);
 999         $jsub = $uf->addJobFilter();
1000         $cond .= ' AND ' . $uf->getVisibilityCondition($jsub . '.pub');
1001         return $cond;
1002     }
1003 }
1004 // }}}
1005
1006 // {{{ class UFC_Job_Terms
1007 /** Filters users based on the job terms they assigned to one of their
1008  * jobs.
1009  * @param $val The ID of the job term, or an array of such IDs
1010  */
1011 class UFC_Job_Terms implements UserFilterCondition
1012 {
1013     private $val;
1014
1015     public function __construct($val)
1016     {
1017         if (!is_array($val)) {
1018             $val = array($val);
1019         }
1020         $this->val = $val;
1021     }
1022
1023     public function buildCondition(PlFilter &$uf)
1024     {
1025         $sub = $uf->addJobTermsFilter(count($this->val));
1026         $conditions = array();
1027         foreach ($this->val as $i => $jtid) {
1028             $conditions[] = $sub[$i] . ' = ' . XDB::escape($jtid);
1029         }
1030         $jsub = $uf->addJobFilter();
1031         $conditions[] = $uf->getVisibilityCondition($jsub . '.pub');
1032         return implode(' AND ', $conditions);
1033     }
1034 }
1035 // }}}
1036
1037 // {{{ class UFC_Job_Description
1038 /** Filters users based on their job description
1039  * @param $description The text being searched for
1040  * @param $fields The fields to search for (user-defined, ((sub|)sub|)sector)
1041  */
1042 class UFC_Job_Description implements UserFilterCondition
1043 {
1044
1045     private $description;
1046     private $fields;
1047
1048     public function __construct($description, $fields)
1049     {
1050         $this->fields = $fields;
1051         $this->description = $description;
1052     }
1053
1054     public function buildCondition(PlFilter &$uf)
1055     {
1056         $conds = array();
1057
1058         $jsub = $uf->addJobFilter();
1059         // CV is private => if only CV requested, and not private,
1060         // don't do anything. Otherwise restrict to standard job visibility.
1061         if ($this->fields == UserFilter::JOB_CV) {
1062            if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
1063                return PlFilter::COND_TRUE;
1064            }
1065         } else {
1066             $conds[] = $uf->getVisibilityCondition($jsub . '.pub');
1067         }
1068
1069         if ($this->fields & UserFilter::JOB_USERDEFINED) {
1070             $conds[] = $jsub . '.description ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1071         }
1072         if ($this->fields & UserFilter::JOB_CV && $uf->getVisibilityLevel == ProfileVisibility::VIS_PRIVATE) {
1073             $uf->requireProfiles();
1074             $conds[] = 'p.cv ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1075         }
1076         if ($this->fields & UserFilter::JOB_SECTOR) {
1077             $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SECTOR);
1078             $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1079         }
1080         if ($this->fields & UserFilter::JOB_SUBSECTOR) {
1081             $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSECTOR);
1082             $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1083         }
1084         if ($this->fields & UserFilter::JOB_SUBSUBSECTOR) {
1085             $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSUBSECTOR);
1086             $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1087             $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_ALTERNATES);
1088             $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1089         }
1090         return implode(' OR ', $conds);
1091     }
1092 }
1093 // }}}
1094
1095 // {{{ class UFC_Networking
1096 /** Filters users based on network identity (IRC, ...)
1097  * @param $type Type of network (-1 for any)
1098  * @param $value Value to search
1099  */
1100 class UFC_Networking implements UserFilterCondition
1101 {
1102     private $type;
1103     private $value;
1104
1105     public function __construct($type, $value)
1106     {
1107         $this->type = $type;
1108         $this->value = $value;
1109     }
1110
1111     public function buildCondition(PlFilter &$uf)
1112     {
1113         $sub = $uf->addNetworkingFilter();
1114         $conds = array();
1115         $conds[] = $uf->getVisibilityCondition($sub . '.pub');
1116         $conds[] = $sub . '.address ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
1117         if ($this->type != -1) {
1118             $conds[] = $sub . '.nwid = ' . XDB::format('{?}', $this->type);
1119         }
1120         return implode(' AND ', $conds);
1121     }
1122 }
1123 // }}}
1124
1125 // {{{ class UFC_Phone
1126 /** Filters users based on their phone number
1127  * @param $num_type Type of number (pro/user/home)
1128  * @param $phone_type Type of phone (fixed/mobile/fax)
1129  * @param $number Phone number
1130  */
1131 class UFC_Phone implements UserFilterCondition
1132 {
1133     const NUM_PRO   = 'pro';
1134     const NUM_USER  = 'user';
1135     const NUM_HOME  = 'address';
1136     const NUM_ANY   = 'any';
1137
1138     const PHONE_FIXED   = 'fixed';
1139     const PHONE_MOBILE  = 'mobile';
1140     const PHONE_FAX     = 'fax';
1141     const PHONE_ANY     = 'any';
1142
1143     private $num_type;
1144     private $phone_type;
1145     private $number;
1146
1147     public function __construct($number, $num_type = self::NUM_ANY, $phone_type = self::PHONE_ANY)
1148     {
1149         $phone = new Phone(array('display' => $number));
1150         $phone->format();
1151         $this->number = $phone->search();
1152         $this->num_type = $num_type;
1153         $this->phone_type = $phone_type;
1154     }
1155
1156     public function buildCondition(PlFilter &$uf)
1157     {
1158         $sub = $uf->addPhoneFilter();
1159         $conds = array();
1160
1161         $conds[] = $uf->getVisibilityCondition($sub . '.pub');
1162
1163         $conds[] = $sub . '.search_tel = ' . XDB::format('{?}', $this->number);
1164         if ($this->num_type != self::NUM_ANY) {
1165             $conds[] = $sub . '.link_type = ' . XDB::format('{?}', $this->num_type);
1166         }
1167         if ($this->phone_type != self::PHONE_ANY) {
1168             $conds[] = $sub . '.tel_type = ' . XDB::format('{?}', $this->phone_type);
1169         }
1170         return implode(' AND ', $conds);
1171     }
1172 }
1173 // }}}
1174
1175 // {{{ class UFC_Medal
1176 /** Filters users based on their medals
1177  * @param $medal ID of the medal
1178  * @param $grade Grade of the medal (null for 'any')
1179  */
1180 class UFC_Medal implements UserFilterCondition
1181 {
1182     private $medal;
1183     private $grade;
1184
1185     public function __construct($medal, $grade = null)
1186     {
1187         $this->medal = $medal;
1188         $this->grade = $grade;
1189     }
1190
1191     public function buildCondition(PlFilter &$uf)
1192     {
1193         $conds = array();
1194
1195         // This will require profiles => table 'p' will be available.
1196         $sub = $uf->addMedalFilter();
1197
1198         $conds[] = $uf->getVisibilityCondition('p.medals_pub');
1199
1200         $conds[] = $sub . '.mid = ' . XDB::format('{?}', $this->medal);
1201         if ($this->grade != null) {
1202             $conds[] = $sub . '.gid = ' . XDB::format('{?}', $this->grade);
1203         }
1204         return implode(' AND ', $conds);
1205     }
1206 }
1207 // }}}
1208
1209 // {{{ class UFC_Photo
1210 /** Filters profiles with photo
1211  */
1212 class UFC_Photo implements UserFilterCondition
1213 {
1214     public function buildCondition(PlFilter &$uf)
1215     {
1216         $sub = $uf->addPhotoFilter();
1217         return $sub . '.attach IS NOT NULL AND ' . $uf->getVisibilityCondition($sub . '.pub');
1218     }
1219 }
1220 // }}}
1221
1222 // {{{ class UFC_Mentor
1223 class UFC_Mentor implements UserFilterCondition
1224 {
1225     public function buildCondition(PlFilter &$uf)
1226     {
1227         $sub = $uf->addMentorFilter(UserFilter::MENTOR);
1228         return $sub . '.expertise IS NOT NULL';
1229     }
1230 }
1231 // }}}
1232
1233
1234 // {{{ class UFC_Mentor_Expertise
1235 /** Filters users by mentoring expertise
1236  * @param $expertise Domain of expertise
1237  */
1238 class UFC_Mentor_Expertise implements UserFilterCondition
1239 {
1240     private $expertise;
1241
1242     public function __construct($expertise)
1243     {
1244         $this->expertise = $expertise;
1245     }
1246
1247     public function buildCondition(PlFilter &$uf)
1248     {
1249         $sub = $uf->addMentorFilter(UserFilter::MENTOR_EXPERTISE);
1250         return $sub . '.expertise ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->expertise);
1251     }
1252 }
1253 // }}}
1254
1255 // {{{ class UFC_Mentor_Country
1256 /** Filters users by mentoring country
1257  * @param $country Two-letters code of country being searched
1258  */
1259 class UFC_Mentor_Country implements UserFilterCondition
1260 {
1261     private $country;
1262
1263     public function __construct()
1264     {
1265         $this->country = pl_flatten(func_get_args());
1266     }
1267
1268     public function buildCondition(PlFilter &$uf)
1269     {
1270         $sub = $uf->addMentorFilter(UserFilter::MENTOR_COUNTRY);
1271         return $sub . '.country IN ' . XDB::format('{?}', $this->country);
1272     }
1273 }
1274 // }}}
1275
1276 // {{{ class UFC_Mentor_Terms
1277 /** Filters users based on the job terms they used in mentoring.
1278  * @param $val The ID of the job term, or an array of such IDs
1279  */
1280 class UFC_Mentor_Terms implements UserFilterCondition
1281 {
1282     private $val;
1283
1284     public function __construct($val)
1285     {
1286         $this->val = $val;
1287     }
1288
1289     public function buildCondition(PlFilter &$uf)
1290     {
1291         $sub = $uf->addMentorFilter(UserFilter::MENTOR_TERM);
1292         return $sub . '.jtid_1 = ' . XDB::escape($this->val);
1293     }
1294 }
1295 // }}}
1296
1297 // {{{ class UFC_Mentor_Sectorization
1298 /** Filters users based on mentoring (sub|)sector
1299  * @param $sector ID of (sub)sector
1300  * @param $type Whether we are looking for a sector or a subsector
1301  */
1302 class UFC_Mentor_Sectorization implements UserFilterCondition
1303 {
1304     const SECTOR    = 1;
1305     const SUBSECTOR = 2;
1306     private $sector;
1307     private $type;
1308
1309     public function __construct($sector, $type = self::SECTOR)
1310     {
1311         $this->sector = $sector;
1312         $this->type = $type;
1313     }
1314
1315     public function buildCondition(PlFilter &$uf)
1316     {
1317         $sub = $uf->addMentorFilter(UserFilter::MENTOR_SECTOR);
1318         if ($this->type == self::SECTOR) {
1319             $field = 'sectorid';
1320         } else {
1321             $field = 'subsectorid';
1322         }
1323         return $sub . '.' . $field . ' = ' . XDB::format('{?}', $this->sector);
1324     }
1325 }
1326 // }}}
1327
1328 // {{{ class UFC_UserRelated
1329 /** Filters users based on a relation toward a user
1330  * @param $user User to which searched users are related
1331  */
1332 abstract class UFC_UserRelated implements UserFilterCondition
1333 {
1334     protected $user;
1335     public function __construct(PlUser &$user)
1336     {
1337         $this->user =& $user;
1338     }
1339 }
1340 // }}}
1341
1342 // {{{ class UFC_Contact
1343 /** Filters users who belong to selected user's contacts
1344  */
1345 class UFC_Contact extends UFC_UserRelated
1346 {
1347     public function buildCondition(PlFilter &$uf)
1348     {
1349         $sub = $uf->addContactFilter($this->user->id());
1350         return 'c' . $sub . '.contact IS NOT NULL';
1351     }
1352 }
1353 // }}}
1354
1355 // {{{ class UFC_WatchRegistration
1356 /** Filters users being watched by selected user
1357  */
1358 class UFC_WatchRegistration extends UFC_UserRelated
1359 {
1360     public function buildCondition(PlFilter &$uf)
1361     {
1362         if (!$this->user->watchType('registration')) {
1363             return PlFilterCondition::COND_FALSE;
1364         }
1365         $uids = $this->user->watchUsers();
1366         if (count($uids) == 0) {
1367             return PlFilterCondition::COND_FALSE;
1368         } else {
1369             return XDB::format('$UID IN {?}', $uids);
1370         }
1371     }
1372 }
1373 // }}}
1374
1375 // {{{ class UFC_WatchPromo
1376 /** Filters users belonging to a promo watched by selected user
1377  * @param $user Selected user (the one watching promo)
1378  * @param $grade Formation the user is watching
1379  */
1380 class UFC_WatchPromo extends UFC_UserRelated
1381 {
1382     private $grade;
1383     public function __construct(PlUser &$user, $grade = UserFilter::GRADE_ING)
1384     {
1385         parent::__construct($user);
1386         $this->grade = $grade;
1387     }
1388
1389     public function buildCondition(PlFilter &$uf)
1390     {
1391         $promos = $this->user->watchPromos();
1392         if (count($promos) == 0) {
1393             return PlFilterCondition::COND_FALSE;
1394         } else {
1395             $sube = $uf->addEducationFilter(true, $this->grade);
1396             $field = 'pe' . $sube . '.' . UserFilter::promoYear($this->grade);
1397             return XDB::format($field . ' IN {?}', $promos);
1398         }
1399     }
1400 }
1401 // }}}
1402
1403 // {{{ class UFC_WatchContact
1404 /** Filters users watched by selected user
1405  */
1406 class UFC_WatchContact extends UFC_Contact
1407 {
1408     public function buildCondition(PlFilter &$uf)
1409     {
1410         if (!$this->user->watchContacts()) {
1411             return PlFilterCondition::COND_FALSE;
1412         }
1413         return parent::buildCondition($uf);
1414     }
1415 }
1416 // }}}
1417
1418 // {{{ class UFC_MarketingHash
1419 /** Filters users using the hash generated
1420  * to send marketing emails to him.
1421  */
1422 class UFC_MarketingHash implements UserFilterCondition
1423 {
1424     private $hash;
1425
1426     public function __construct($hash)
1427     {
1428         $this->hash = $hash;
1429     }
1430
1431     public function buildCondition(PlFilter &$uf)
1432     {
1433         $table = $uf->addMarketingHash();
1434         return XDB::format('rm.hash = {?}', $this->hash);
1435     }
1436 }
1437 // }}}
1438
1439 /******************
1440  * ORDERS
1441  ******************/
1442
1443 // {{{ class UFO_Promo
1444 /** Orders users by promotion
1445  * @param $grade Formation whose promotion users should be sorted by (restricts results to users of that formation)
1446  * @param $desc Whether sort is descending
1447  */
1448 class UFO_Promo extends PlFilterGroupableOrder
1449 {
1450     private $grade;
1451
1452     public function __construct($grade = null, $desc = false)
1453     {
1454         parent::__construct($desc);
1455         $this->grade = $grade;
1456     }
1457
1458     protected function getSortTokens(PlFilter &$uf)
1459     {
1460         if (UserFilter::isGrade($this->grade)) {
1461             $sub = $uf->addEducationFilter($this->grade);
1462             return 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
1463         } else {
1464             $sub = $uf->addDisplayFilter();
1465             return 'pd' . $sub . '.promo';
1466         }
1467     }
1468 }
1469 // }}}
1470
1471 // {{{ class UFO_Name
1472 /** Sorts users by name
1473  * @param $type Type of name on which to sort (firstname...)
1474  * @param $variant Variant of that name to use (marital, ordinary...)
1475  * @param $particle Set to true if particles should be included in the sorting order
1476  * @param $desc If sort order should be descending
1477  */
1478 class UFO_Name extends PlFilterOrder
1479 {
1480     private $type;
1481     private $variant;
1482     private $particle;
1483
1484     public function __construct($type, $variant = null, $particle = false, $desc = false)
1485     {
1486         parent::__construct($desc);
1487         $this->type = $type;
1488         $this->variant = $variant;
1489         $this->particle = $particle;
1490     }
1491
1492     protected function getSortTokens(PlFilter &$uf)
1493     {
1494         if (Profile::isDisplayName($this->type)) {
1495             $sub = $uf->addDisplayFilter();
1496             $token = 'pd' . $sub . '.' . $this->type;
1497             if ($uf->accountsRequired()) {
1498                 $account_token = Profile::getAccountEquivalentName($this->type);
1499                 return 'IFNULL(' . $token . ', a.' . $account_token . ')';
1500             } else {
1501                 return $token;
1502             }
1503         } else {
1504             $sub = $uf->addNameFilter($this->type, $this->variant);
1505             if ($this->particle) {
1506                 return 'CONCAT(pn' . $sub . '.particle, \' \', pn' . $sub . '.name)';
1507             } else {
1508                 return 'pn' . $sub . '.name';
1509             }
1510         }
1511     }
1512 }
1513 // }}}
1514
1515 // {{{ class UFO_Score
1516 class UFO_Score extends PlFilterOrder
1517 {
1518     protected function getSortTokens(PlFilter &$uf)
1519     {
1520         $toks = $uf->getNameTokens();
1521         $scores = array();
1522
1523         // If there weren't any sort tokens, we shouldn't sort by score, sort by NULL instead
1524         if (count($toks) == 0) {
1525             return 'NULL';
1526         }
1527
1528         foreach ($toks as $sub => $token) {
1529             $scores[] = XDB::format('SUM(' . $sub . '.score + IF (' . $sub . '.token = {?}, 5, 0) )', $token);
1530         }
1531         return implode(' + ', $scores);
1532     }
1533 }
1534 // }}}
1535
1536 // {{{ class UFO_Registration
1537 /** Sorts users based on registration date
1538  */
1539 class UFO_Registration extends PlFilterOrder
1540 {
1541     protected function getSortTokens(PlFilter &$uf)
1542     {
1543         $uf->requireAccounts();
1544         return 'a.registration_date';
1545     }
1546 }
1547 // }}}
1548
1549 // {{{ class UFO_Birthday
1550 /** Sorts users based on next birthday date
1551  */
1552 class UFO_Birthday extends PlFilterOrder
1553 {
1554     protected function getSortTokens(PlFilter &$uf)
1555     {
1556         $uf->requireProfiles();
1557         return 'p.next_birthday';
1558     }
1559 }
1560 // }}}
1561
1562 // {{{ class UFO_ProfileUpdate
1563 /** Sorts users based on last profile update
1564  */
1565 class UFO_ProfileUpdate extends PlFilterOrder
1566 {
1567     protected function getSortTokens(PlFilter &$uf)
1568     {
1569         $uf->requireProfiles();
1570         return 'p.last_change';
1571     }
1572 }
1573 // }}}
1574
1575 // {{{ class UFO_Death
1576 /** Sorts users based on death date
1577  */
1578 class UFO_Death extends PlFilterOrder
1579 {
1580     protected function getSortTokens(PlFilter &$uf)
1581     {
1582         $uf->requireProfiles();
1583         return 'p.deathdate';
1584     }
1585 }
1586 // }}}
1587
1588 // {{{ class UFO_Uid
1589 /** Sorts users based on their uid
1590  */
1591 class UFO_Uid extends PlFilterOrder
1592 {
1593     protected function getSortTokens(PlFilter &$uf)
1594     {
1595         $uf->requireAccounts();
1596         return '$UID';
1597     }
1598 }
1599 // }}}
1600
1601 // {{{ class UFO_Hruid
1602 /** Sorts users based on their hruid
1603  */
1604 class UFO_Hruid extends PlFilterOrder
1605 {
1606     protected function getSortTokens(PlFilter &$uf)
1607     {
1608         $uf->requireAccounts();
1609         return 'a.hruid';
1610     }
1611 }
1612 // }}}
1613
1614 // {{{ class UFO_Pid
1615 /** Sorts users based on their pid
1616  */
1617 class UFO_Pid extends PlFilterOrder
1618 {
1619     protected function getSortTokens(PlFilter &$uf)
1620     {
1621         $uf->requireProfiles();
1622         return '$PID';
1623     }
1624 }
1625 // }}}
1626
1627 // {{{ class UFO_Hrpid
1628 /** Sorts users based on their hrpid
1629  */
1630 class UFO_Hrpid extends PlFilterOrder
1631 {
1632     protected function getSortTokens(PlFilter &$uf)
1633     {
1634         $uf->requireProfiles();
1635         return 'p.hrpid';
1636     }
1637 }
1638 // }}}
1639
1640
1641 /***********************************
1642   *********************************
1643           USER FILTER CLASS
1644   *********************************
1645  ***********************************/
1646
1647 // {{{ class UserFilter
1648 /** This class provides a convenient and centralized way of filtering users.
1649  *
1650  * Usage:
1651  * $uf = new UserFilter(new UFC_Blah($x, $y), new UFO_Coin($z, $t));
1652  *
1653  * Resulting UserFilter can be used to:
1654  * - get a list of User objects matching the filter
1655  * - get a list of UIDs matching the filter
1656  * - get the number of users matching the filter
1657  * - check whether a given User matches the filter
1658  * - filter a list of User objects depending on whether they match the filter
1659  *
1660  * Usage for UFC and UFO objects:
1661  * A UserFilter will call all private functions named XXXJoins.
1662  * These functions must return an array containing the list of join
1663  * required by the various UFC and UFO associated to the UserFilter.
1664  * Entries in those returned array are of the following form:
1665  *   'join_tablealias' => array('join_type', 'joined_table', 'join_criter')
1666  * which will be translated into :
1667  *   join_type JOIN joined_table AS join_tablealias ON (join_criter)
1668  * in the final query.
1669  *
1670  * In the join_criter text, $ME is replaced with 'join_tablealias', $PID with
1671  * profile.pid, and $UID with accounts.uid.
1672  *
1673  * For each kind of "JOIN" needed, a function named addXXXFilter() should be defined;
1674  * its parameter will be used to set various private vars of the UserFilter describing
1675  * the required joins ; such a function shall return the "join_tablealias" to use
1676  * when referring to the joined table.
1677  *
1678  * For example, if data from profile_job must be available to filter results,
1679  * the UFC object will call $uf-addJobFilter(), which will set the 'with_pj' var and
1680  * return 'pj', the short name to use when referring to profile_job; when building
1681  * the query, calling the jobJoins function will return an array containing a single
1682  * row:
1683  *   'pj' => array('left', 'profile_job', '$ME.pid = $UID');
1684  *
1685  * The 'register_optional' function can be used to generate unique table aliases when
1686  * the same table has to be joined several times with different aliases.
1687  */
1688 class UserFilter extends PlFilter
1689 {
1690     protected $joinMethods = array();
1691
1692     protected $joinMetas = array(
1693                                 '$PID' => 'p.pid',
1694                                 '$UID' => 'a.uid',
1695                                 );
1696
1697     private $root;
1698     private $sort = array();
1699     private $grouper = null;
1700     private $query = null;
1701     private $orderby = null;
1702
1703     // Store the current 'search' visibility.
1704     private $profile_visibility = null;
1705
1706     private $lastusercount = null;
1707     private $lastprofilecount = null;
1708
1709     public function __construct($cond = null, $sort = null)
1710     {
1711         if (empty($this->joinMethods)) {
1712             $class = new ReflectionClass('UserFilter');
1713             foreach ($class->getMethods() as $method) {
1714                 $name = $method->getName();
1715                 if (substr($name, -5) == 'Joins' && $name != 'buildJoins') {
1716                     $this->joinMethods[] = $name;
1717                 }
1718             }
1719         }
1720         if (!is_null($cond)) {
1721             if ($cond instanceof PlFilterCondition) {
1722                 $this->setCondition($cond);
1723             }
1724         }
1725         if (!is_null($sort)) {
1726             if ($sort instanceof PlFilterOrder) {
1727                 $this->addSort($sort);
1728             } else if (is_array($sort)) {
1729                 foreach ($sort as $s) {
1730                     $this->addSort($s);
1731                 }
1732             }
1733         }
1734
1735         // This will set the visibility to the default correct level.
1736         $this->profile_visibility = new ProfileVisibility();
1737     }
1738
1739     public function getVisibilityLevels()
1740     {
1741         return $this->profile_visibility->levels();
1742     }
1743
1744     public function getVisibilityLevel()
1745     {
1746         return $this->profile_visibility->level();
1747     }
1748
1749     public function restrictVisibilityTo($level)
1750     {
1751         $this->profile_visibility->setLevel($level);
1752     }
1753
1754     public function getVisibilityCondition($field)
1755     {
1756         return $field . ' IN ' . XDB::formatArray($this->getVisibilityLevels());
1757     }
1758
1759     private function buildQuery()
1760     {
1761         // The root condition is built first because some orders need info
1762         // available only once all UFC have set their conditions (UFO_Score)
1763         if (is_null($this->query)) {
1764             $where = $this->root->buildCondition($this);
1765             $where = str_replace(array_keys($this->joinMetas),
1766                                  $this->joinMetas,
1767                                  $where);
1768         }
1769         if (is_null($this->orderby)) {
1770             $orders = array();
1771             foreach ($this->sort as $sort) {
1772                 $orders = array_merge($orders, $sort->buildSort($this));
1773             }
1774             if (count($orders) == 0) {
1775                 $this->orderby = '';
1776             } else {
1777                 $this->orderby = 'ORDER BY  ' . implode(', ', $orders);
1778             }
1779             $this->orderby = str_replace(array_keys($this->joinMetas),
1780                                          $this->joinMetas,
1781                                          $this->orderby);
1782         }
1783         if (is_null($this->query)) {
1784             if ($this->with_accounts) {
1785                 $from = 'accounts AS a';
1786             } else {
1787                 $this->requireProfiles();
1788                 $from = 'profiles AS p';
1789             }
1790             $joins = $this->buildJoins();
1791             $this->query = 'FROM  ' . $from . '
1792                                ' . $joins . '
1793                            WHERE  (' . $where . ')';
1794         }
1795     }
1796
1797     public function hasGroups()
1798     {
1799         return $this->grouper != null;
1800     }
1801
1802     public function getGroups()
1803     {
1804         return $this->getUIDGroups();
1805     }
1806
1807     public function getUIDGroups()
1808     {
1809         $this->requireAccounts();
1810         $this->buildQuery();
1811         $token = $this->grouper->getGroupToken($this);
1812
1813         $groups = XDB::fetchAllRow('SELECT ' . $token . ', COUNT(a.uid)
1814                                    ' . $this->query . '
1815                                    GROUP BY  ' . $token,
1816                                    0);
1817         return $groups;
1818     }
1819
1820     public function getPIDGroups()
1821     {
1822         $this->requireProfiles();
1823         $this->buildQuery();
1824         $token = $this->grouper->getGroupToken($this);
1825
1826         $groups = XDB::fetchAllRow('SELECT ' . $token . ', COUNT(p.pid)
1827                                    ' . $this->query . '
1828                                    GROUP BY  ' . $token,
1829                                    0);
1830         return $groups;
1831     }
1832
1833     private function getUIDList($uids = null, PlLimit &$limit)
1834     {
1835         $this->requireAccounts();
1836         $this->buildQuery();
1837         $lim = $limit->getSql();
1838         $cond = '';
1839         if (!empty($uids)) {
1840             $cond = XDB::format(' AND a.uid IN {?}', $uids);
1841         }
1842         $fetched = XDB::fetchColumn('SELECT SQL_CALC_FOUND_ROWS  a.uid
1843                                     ' . $this->query . $cond . '
1844                                    GROUP BY  a.uid
1845                                     ' . $this->orderby . '
1846                                     ' . $lim);
1847         $this->lastusercount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
1848         return $fetched;
1849     }
1850
1851     private function getPIDList($pids = null, PlLimit &$limit)
1852     {
1853         $this->requireProfiles();
1854         $this->buildQuery();
1855         $lim = $limit->getSql();
1856         $cond = '';
1857         if (!is_null($pids)) {
1858             $cond = XDB::format(' AND p.pid IN {?}', $pids);
1859         }
1860         $fetched = XDB::fetchColumn('SELECT  SQL_CALC_FOUND_ROWS  p.pid
1861                                     ' . $this->query . $cond . '
1862                                    GROUP BY  p.pid
1863                                     ' . $this->orderby . '
1864                                     ' . $lim);
1865         $this->lastprofilecount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
1866         return $fetched;
1867     }
1868
1869     private static function defaultLimit($limit) {
1870         if ($limit == null) {
1871             return new PlLimit();
1872         } else {
1873             return $limit;
1874         }
1875     }
1876
1877     /** Check that the user match the given rule.
1878      */
1879     public function checkUser(PlUser &$user)
1880     {
1881         $this->requireAccounts();
1882         $this->buildQuery();
1883         $count = (int)XDB::fetchOneCell('SELECT  COUNT(*)
1884                                         ' . $this->query . XDB::format(' AND a.uid = {?}', $user->id()));
1885         return $count == 1;
1886     }
1887
1888     /** Check that the profile match the given rule.
1889      */
1890     public function checkProfile(Profile &$profile)
1891     {
1892         $this->requireProfiles();
1893         $this->buildQuery();
1894         $count = (int)XDB::fetchOneCell('SELECT  COUNT(*)
1895                                         ' . $this->query . XDB::format(' AND p.pid = {?}', $profile->id()));
1896         return $count == 1;
1897     }
1898
1899     /** Default filter is on users
1900      */
1901     public function filter(array $users, $limit = null)
1902     {
1903         return $this->filterUsers($users, self::defaultLimit($limit));
1904     }
1905
1906     /** Filter a list of users to extract the users matching the rule.
1907      */
1908     public function filterUsers(array $users, $limit = null)
1909     {
1910         $limit = self::defaultLimit($limit);
1911         $this->requireAccounts();
1912         $this->buildQuery();
1913         $table = array();
1914         $uids  = array();
1915         foreach ($users as $user) {
1916             if ($user instanceof PlUser) {
1917                 $uid = $user->id();
1918             } else {
1919                 $uid = $user;
1920             }
1921             $uids[] = $uid;
1922             $table[$uid] = $user;
1923         }
1924         $fetched = $this->getUIDList($uids, $limit);
1925         $output = array();
1926         foreach ($fetched as $uid) {
1927             $output[] = $table[$uid];
1928         }
1929         return $output;
1930     }
1931
1932     /** Filter a list of profiles to extract the users matching the rule.
1933      */
1934     public function filterProfiles(array $profiles, $limit = null)
1935     {
1936         $limit = self::defaultLimit($limit);
1937         $this->requireProfiles();
1938         $this->buildQuery();
1939         $table = array();
1940         $pids  = array();
1941         foreach ($profiles as $profile) {
1942             if ($profile instanceof Profile) {
1943                 $pid = $profile->id();
1944             } else {
1945                 $pid = $profile;
1946             }
1947             $pids[] = $pid;
1948             $table[$pid] = $profile;
1949         }
1950         $fetched = $this->getPIDList($pids, $limit);
1951         $output = array();
1952         foreach ($fetched as $pid) {
1953             $output[] = $table[$pid];
1954         }
1955         return $output;
1956     }
1957
1958     public function getUIDs($limit = null)
1959     {
1960         $limit = self::defaultLimit($limit);
1961         return $this->getUIDList(null, $limit);
1962     }
1963
1964     public function getUID($pos = 0)
1965     {
1966         $uids =$this->getUIDList(null, new PlLimit(1, $pos));
1967         if (count($uids) == 0) {
1968             return null;
1969         } else {
1970             return $uids[0];
1971         }
1972     }
1973
1974     public function getPIDs($limit = null)
1975     {
1976         $limit = self::defaultLimit($limit);
1977         return $this->getPIDList(null, $limit);
1978     }
1979
1980     public function getPID($pos = 0)
1981     {
1982         $pids =$this->getPIDList(null, new PlLimit(1, $pos));
1983         if (count($pids) == 0) {
1984             return null;
1985         } else {
1986             return $pids[0];
1987         }
1988     }
1989
1990     public function getUsers($limit = null)
1991     {
1992         return User::getBulkUsersWithUIDs($this->getUIDs($limit));
1993     }
1994
1995     public function getUser($pos = 0)
1996     {
1997         $uid = $this->getUID($pos);
1998         if ($uid == null) {
1999             return null;
2000         } else {
2001             return User::getWithUID($uid);
2002         }
2003     }
2004
2005     public function iterUsers($limit = null)
2006     {
2007         return User::iterOverUIDs($this->getUIDs($limit));
2008     }
2009
2010     public function getProfiles($limit = null, $fields = 0x0000, $visibility = null)
2011     {
2012         return Profile::getBulkProfilesWithPIDs($this->getPIDs($limit), $fields, $visibility);
2013     }
2014
2015     public function getProfile($pos = 0, $fields = 0x0000, $visibility = null)
2016     {
2017         $pid = $this->getPID($pos);
2018         if ($pid == null) {
2019             return null;
2020         } else {
2021             return Profile::get($pid, $fields, $visibility);
2022         }
2023     }
2024
2025     public function iterProfiles($limit = null, $fields = 0x0000, $visibility = null)
2026     {
2027         return Profile::iterOverPIDs($this->getPIDs($limit), true, $fields, $visibility);
2028     }
2029
2030     public function get($limit = null)
2031     {
2032         return $this->getUsers($limit);
2033     }
2034
2035
2036     public function getTotalCount()
2037     {
2038         return $this->getTotalUserCount();
2039     }
2040
2041     public function getTotalUserCount()
2042     {
2043         if (is_null($this->lastusercount)) {
2044             $this->requireAccounts();
2045             $this->buildQuery();
2046             return (int)XDB::fetchOneCell('SELECT  COUNT(DISTINCT a.uid)
2047                                           ' . $this->query);
2048         } else {
2049             return $this->lastusercount;
2050         }
2051     }
2052
2053     public function getTotalProfileCount()
2054     {
2055         if (is_null($this->lastprofilecount)) {
2056             $this->requireProfiles();
2057             $this->buildQuery();
2058             return (int)XDB::fetchOneCell('SELECT  COUNT(DISTINCT p.pid)
2059                                           ' . $this->query);
2060         } else {
2061             return $this->lastprofilecount;
2062         }
2063     }
2064
2065     public function setCondition(PlFilterCondition &$cond)
2066     {
2067         $this->root =& $cond;
2068         $this->query = null;
2069     }
2070
2071     public function addSort(PlFilterOrder &$sort)
2072     {
2073         if (count($this->sort) == 0 && $sort instanceof PlFilterGroupableOrder)
2074         {
2075             $this->grouper = $sort;
2076         }
2077         $this->sort[] = $sort;
2078         $this->orderby = null;
2079     }
2080
2081     static public function getLegacy($promo_min, $promo_max)
2082     {
2083         if ($promo_min != 0) {
2084             $min = new UFC_Promo('>=', self::GRADE_ING, intval($promo_min));
2085         } else {
2086             $min = new PFC_True();
2087         }
2088         if ($promo_max != 0) {
2089             $max = new UFC_Promo('<=', self::GRADE_ING, intval($promo_max));
2090         } else {
2091             $max = new PFC_True();
2092         }
2093         return new UserFilter(new PFC_And($min, $max));
2094     }
2095
2096     static public function sortByName()
2097     {
2098         return array(new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
2099     }
2100
2101     static public function sortByPromo()
2102     {
2103         return array(new UFO_Promo(), new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
2104     }
2105
2106     static private function getDBSuffix($string)
2107     {
2108         if (is_array($string)) {
2109             if (count($string) == 1) {
2110                 return self::getDBSuffix(array_pop($string));
2111             }
2112             return md5(implode('|', $string));
2113         } else {
2114             return preg_replace('/[^a-z0-9]/i', '', $string);
2115         }
2116     }
2117
2118
2119     /** Stores a new (and unique) table alias in the &$table table
2120      * @param   &$table Array in which the table alias must be stored
2121      * @param   $val    Value which will then be used to build the join
2122      * @return          Name of the newly created alias
2123      */
2124     private $option = 0;
2125     private function register_optional(array &$table, $val)
2126     {
2127         if (is_null($val)) {
2128             $sub   = $this->option++;
2129             $index = null;
2130         } else {
2131             $sub   = self::getDBSuffix($val);
2132             $index = $val;
2133         }
2134         $sub = '_' . $sub;
2135         $table[$sub] = $index;
2136         return $sub;
2137     }
2138
2139     /** PROFILE VS ACCOUNT
2140      */
2141     private $with_profiles  = false;
2142     private $with_accounts  = false;
2143     public function requireAccounts()
2144     {
2145         $this->with_accounts = true;
2146     }
2147
2148     public function accountsRequired()
2149     {
2150         return $this->with_accounts;
2151     }
2152
2153     public function requireProfiles()
2154     {
2155         $this->with_profiles = true;
2156     }
2157
2158     public function profilesRequired()
2159     {
2160         return $this->with_profiles;
2161     }
2162
2163     protected function accountJoins()
2164     {
2165         $joins = array();
2166         if ($this->with_profiles && $this->with_accounts) {
2167             $joins['ap'] = PlSqlJoin::left('account_profiles', '$ME.uid = $UID AND FIND_IN_SET(\'owner\', ap.perms)');
2168             $joins['p'] = PlSqlJoin::left('profiles', '$PID = ap.pid');
2169         }
2170         return $joins;
2171     }
2172
2173     /** DISPLAY
2174      */
2175     const DISPLAY = 'display';
2176     private $pd = false;
2177     public function addDisplayFilter()
2178     {
2179         $this->requireProfiles();
2180         $this->pd = true;
2181         return '';
2182     }
2183
2184     protected function displayJoins()
2185     {
2186         if ($this->pd) {
2187             return array('pd' => PlSqlJoin::left('profile_display', '$ME.pid = $PID'));
2188         } else {
2189             return array();
2190         }
2191     }
2192
2193     /** LOGGER
2194      */
2195
2196     private $with_logger = false;
2197     public function addLoggerFilter()
2198     {
2199         $this->with_logger = true;
2200         $this->requireAccounts();
2201         return 'ls';
2202     }
2203     protected function loggerJoins()
2204     {
2205         $joins = array();
2206         if ($this->with_logger) {
2207             $joins['ls'] = PlSqlJoin::left('log_sessions', '$ME.uid = $UID');
2208         }
2209         return $joins;
2210     }
2211
2212     /** NAMES
2213      */
2214
2215     static public function assertName($name)
2216     {
2217         if (!DirEnum::getID(DirEnum::NAMETYPES, $name)) {
2218             Platal::page()->kill('Invalid name type: ' . $name);
2219         }
2220     }
2221
2222     private $pn  = array();
2223     public function addNameFilter($type, $variant = null)
2224     {
2225         $this->requireProfiles();
2226         if (!is_null($variant)) {
2227             $ft  = $type . '_' . $variant;
2228         } else {
2229             $ft = $type;
2230         }
2231         $sub = '_' . $ft;
2232         self::assertName($ft);
2233
2234         if (!is_null($variant) && $variant == 'other') {
2235             $sub .= $this->option++;
2236         }
2237         $this->pn[$sub] = DirEnum::getID(DirEnum::NAMETYPES, $ft);
2238         return $sub;
2239     }
2240
2241     protected function nameJoins()
2242     {
2243         $joins = array();
2244         foreach ($this->pn as $sub => $type) {
2245             $joins['pn' . $sub] = PlSqlJoin::left('profile_name', '$ME.pid = $PID AND $ME.typeid = {?}', $type);
2246         }
2247         return $joins;
2248     }
2249
2250     /** NAMETOKENS
2251      */
2252     private $name_tokens = array();
2253     private $nb_tokens = 0;
2254
2255     public function addNameTokensFilter($token)
2256     {
2257         $this->requireProfiles();
2258         $sub = 'sn' . (1 + $this->nb_tokens);
2259         $this->nb_tokens++;
2260         $this->name_tokens[$sub] = $token;
2261         return $sub;
2262     }
2263
2264     protected function nameTokensJoins()
2265     {
2266         /* We don't return joins, since with_sn forces the SELECT to run on search_name first */
2267         $joins = array();
2268         foreach ($this->name_tokens as $sub => $token) {
2269             $joins[$sub] = PlSqlJoin::left('search_name', '$ME.pid = $PID');
2270         }
2271         return $joins;
2272     }
2273
2274     public function getNameTokens()
2275     {
2276         return $this->name_tokens;
2277     }
2278
2279     /** NATIONALITY
2280      */
2281
2282     private $with_nat = false;
2283     public function addNationalityFilter()
2284     {
2285         $this->with_nat = true;
2286         return 'ngc';
2287     }
2288
2289     protected function nationalityJoins()
2290     {
2291         $joins = array();
2292         if ($this->with_nat) {
2293             $joins['ngc'] = PlSqlJoin::left('geoloc_countries', '$ME.iso_3166_1_a2 = p.nationality1 OR $ME.iso_3166_1_a2 = p.nationality2 OR $ME.iso_3166_1_a2 = p.nationality3');
2294         }
2295         return $joins;
2296     }
2297
2298     /** EDUCATION
2299      */
2300     const GRADE_ING = 'Ing.';
2301     const GRADE_PHD = 'PhD';
2302     const GRADE_MST = 'M%';
2303     static public function isGrade($grade)
2304     {
2305         return ($grade !== 0) && ($grade == self::GRADE_ING || $grade == self::GRADE_PHD || $grade == self::GRADE_MST);
2306     }
2307
2308     static public function assertGrade($grade)
2309     {
2310         if (!self::isGrade($grade)) {
2311             Platal::page()->killError("Diplôme non valide: $grade");
2312         }
2313     }
2314
2315     static public function promoYear($grade)
2316     {
2317         // XXX: Definition of promotion for phds and masters might change in near future.
2318         return ($grade == UserFilter::GRADE_ING) ? 'entry_year' : 'grad_year';
2319     }
2320
2321     private $pepe     = array();
2322     private $with_pee = false;
2323     public function addEducationFilter($x = false, $grade = null)
2324     {
2325         $this->requireProfiles();
2326         if (!$x) {
2327             $index = $this->option;
2328             $sub   = $this->option++;
2329         } else {
2330             self::assertGrade($grade);
2331             $index = $grade;
2332             $sub   = $grade[0];
2333             $this->with_pee = true;
2334         }
2335         $sub = '_' . $sub;
2336         $this->pepe[$index] = $sub;
2337         return $sub;
2338     }
2339
2340     protected function educationJoins()
2341     {
2342         $joins = array();
2343         if ($this->with_pee) {
2344             $joins['pee'] = PlSqlJoin::inner('profile_education_enum', 'pee.abbreviation = \'X\'');
2345         }
2346         foreach ($this->pepe as $grade => $sub) {
2347             if ($this->isGrade($grade)) {
2348                 $joins['pe' . $sub] = PlSqlJoin::left('profile_education', '$ME.eduid = pee.id AND $ME.pid = $PID');
2349                 $joins['pede' . $sub] = PlSqlJoin::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid AND $ME.abbreviation LIKE {?}', $grade);
2350             } else {
2351                 $joins['pe' . $sub] = PlSqlJoin::left('profile_education', '$ME.pid = $PID');
2352                 $joins['pee' . $sub] = PlSqlJoin::inner('profile_education_enum', '$ME.id = pe' . $sub . '.eduid');
2353                 $joins['pede' . $sub] = PlSqlJoin::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid');
2354             }
2355         }
2356         return $joins;
2357     }
2358
2359
2360     /** GROUPS
2361      */
2362     private $gpm = array();
2363     public function addGroupFilter($group = null)
2364     {
2365         $this->requireAccounts();
2366         if (!is_null($group)) {
2367             if (is_int($group) || ctype_digit($group)) {
2368                 $index = $sub = $group;
2369             } else {
2370                 $index = $group;
2371                 $sub   = self::getDBSuffix($group);
2372             }
2373         } else {
2374             $sub = 'group_' . $this->option++;
2375             $index = null;
2376         }
2377         $sub = '_' . $sub;
2378         $this->gpm[$sub] = $index;
2379         return $sub;
2380     }
2381
2382     protected function groupJoins()
2383     {
2384         $joins = array();
2385         foreach ($this->gpm as $sub => $key) {
2386             if (is_null($key)) {
2387                 $joins['gpa' . $sub] = PlSqlJoin::inner('groups');
2388                 $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
2389             } else if (is_int($key) || ctype_digit($key)) {
2390                 $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
2391             } else {
2392                 $joins['gpa' . $sub] = PlSqlJoin::inner('groups', '$ME.diminutif = {?}', $key);
2393                 $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
2394             }
2395         }
2396         return $joins;
2397     }
2398
2399     /** BINETS
2400      */
2401
2402     private $with_bi = false;
2403     private $with_bd = false;
2404     public function addBinetsFilter($with_enum = false)
2405     {
2406         $this->requireProfiles();
2407         $this->with_bi = true;
2408         if ($with_enum) {
2409             $this->with_bd = true;
2410             return 'bd';
2411         } else {
2412             return 'bi';
2413         }
2414     }
2415
2416     protected function binetsJoins()
2417     {
2418         $joins = array();
2419         if ($this->with_bi) {
2420             $joins['bi'] = PlSqlJoin::left('profile_binets', '$ME.pid = $PID');
2421         }
2422         if ($this->with_bd) {
2423             $joins['bd'] = PlSqlJoin::left('profile_binet_enum', '$ME.id = bi.binet_id');
2424         }
2425         return $joins;
2426     }
2427
2428     /** EMAILS
2429      */
2430     private $e = array();
2431     public function addEmailRedirectFilter($email = null)
2432     {
2433         $this->requireAccounts();
2434         return $this->register_optional($this->e, $email);
2435     }
2436
2437     private $ve = array();
2438     public function addVirtualEmailFilter($email = null)
2439     {
2440         $this->addAliasFilter(self::ALIAS_FORLIFE);
2441         return $this->register_optional($this->ve, $email);
2442     }
2443
2444     const ALIAS_BEST    = 'bestalias';
2445     const ALIAS_FORLIFE = 'forlife';
2446     private $al = array();
2447     public function addAliasFilter($alias = null)
2448     {
2449         $this->requireAccounts();
2450         return $this->register_optional($this->al, $alias);
2451     }
2452
2453     protected function emailJoins()
2454     {
2455         global $globals;
2456         $joins = array();
2457         foreach ($this->e as $sub=>$key) {
2458             if (is_null($key)) {
2459                 $joins['e' . $sub] = PlSqlJoin::left('emails', '$ME.uid = $UID AND $ME.flags != \'filter\'');
2460             } else {
2461                 if (!is_array($key)) {
2462                     $key = array($key);
2463                 }
2464                 $joins['e' . $sub] = PlSqlJoin::left('emails', '$ME.uid = $UID AND $ME.flags != \'filter\'
2465                                                                AND $ME.email IN {?}', $key);
2466             }
2467         }
2468         foreach ($this->al as $sub=>$key) {
2469             if (is_null($key)) {
2470                 $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\')');
2471             } else if ($key == self::ALIAS_BEST) {
2472                 $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND  FIND_IN_SET(\'bestalias\', $ME.flags)');
2473             } else if ($key == self::ALIAS_FORLIFE) {
2474                 $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type = \'a_vie\'');
2475             } else {
2476                 if (!is_array($key)) {
2477                     $key = array($key);
2478                 }
2479                 $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\')
2480                                                                   AND $ME.alias IN {?}', $key);
2481             }
2482         }
2483         foreach ($this->ve as $sub=>$key) {
2484             if (is_null($key)) {
2485                 $joins['v' . $sub] = PlSqlJoin::left('virtual', '$ME.type = \'user\'');
2486             } else {
2487                 if (!is_array($key)) {
2488                     $key = array($key);
2489                 }
2490                 $joins['v' . $sub] = PlSqlJoin::left('virtual', '$ME.type = \'user\' AND $ME.alias IN {?}', $key);
2491             }
2492             $joins['vr' . $sub] = PlSqlJoin::left('virtual_redirect',
2493                                                   '$ME.vid = v' . $sub . '.vid
2494                                                    AND ($ME.redirect IN (CONCAT(al_forlife.alias, \'@\', {?}),
2495                                                                          CONCAT(al_forlife.alias, \'@\', {?}),
2496                                                                          a.email))',
2497                                                   $globals->mail->domain, $globals->mail->domain2);
2498         }
2499         return $joins;
2500     }
2501
2502
2503     /** ADDRESSES
2504      */
2505     private $with_pa = false;
2506     public function addAddressFilter()
2507     {
2508         $this->requireProfiles();
2509         $this->with_pa = true;
2510         return 'pa';
2511     }
2512
2513     private $with_pac = false;
2514     public function addAddressCountryFilter()
2515     {
2516         $this->requireProfiles();
2517         $this->addAddressFilter();
2518         $this->with_pac = true;
2519         return 'gc';
2520     }
2521
2522     private $with_pal = false;
2523     public function addAddressLocalityFilter()
2524     {
2525         $this->requireProfiles();
2526         $this->addAddressFilter();
2527         $this->with_pal = true;
2528         return 'gl';
2529     }
2530
2531     protected function addressJoins()
2532     {
2533         $joins = array();
2534         if ($this->with_pa) {
2535             $joins['pa'] = PlSqlJoin::left('profile_addresses', '$ME.pid = $PID');
2536         }
2537         if ($this->with_pac) {
2538             $joins['gc'] = PlSqlJoin::left('geoloc_countries', '$ME.iso_3166_1_a2 = pa.countryID');
2539         }
2540         if ($this->with_pal) {
2541             $joins['gl'] = PlSqlJoin::left('geoloc_localities', '$ME.id = pa.localityID');
2542         }
2543         return $joins;
2544     }
2545
2546
2547     /** CORPS
2548      */
2549
2550     private $pc = false;
2551     private $pce = array();
2552     private $pcr = false;
2553     public function addCorpsFilter($type)
2554     {
2555         $this->requireProfiles();
2556         $this->pc = true;
2557         if ($type == UFC_Corps::CURRENT) {
2558             $pce['pcec'] = 'current_corpsid';
2559             return 'pcec';
2560         } else if ($type == UFC_Corps::ORIGIN) {
2561             $pce['pceo'] = 'original_corpsid';
2562             return 'pceo';
2563         }
2564     }
2565
2566     public function addCorpsRankFilter()
2567     {
2568         $this->requireProfiles();
2569         $this->pc = true;
2570         $this->pcr = true;
2571         return 'pcr';
2572     }
2573
2574     protected function corpsJoins()
2575     {
2576         $joins = array();
2577         if ($this->pc) {
2578             $joins['pc'] = PlSqlJoin::left('profile_corps', '$ME.pid = $PID');
2579         }
2580         if ($this->pcr) {
2581             $joins['pcr'] = PlSqlJoin::left('profile_corps_rank_enum', '$ME.id = pc.rankid');
2582         }
2583         foreach($this->pce as $sub => $field) {
2584             $joins[$sub] = PlSqlJoin::left('profile_corps_enum', '$ME.id = pc.' . $field);
2585         }
2586         return $joins;
2587     }
2588
2589     /** JOBS
2590      */
2591
2592     const JOB_SECTOR        = 0x0001;
2593     const JOB_SUBSECTOR     = 0x0002;
2594     const JOB_SUBSUBSECTOR  = 0x0004;
2595     const JOB_ALTERNATES    = 0x0008;
2596     const JOB_USERDEFINED   = 0x0010;
2597     const JOB_CV            = 0x0020;
2598
2599     const JOB_SECTORIZATION = 0x000F;
2600     const JOB_ANY           = 0x003F;
2601
2602     /** Joins :
2603      * pj => profile_job
2604      * pje => profile_job_enum
2605      * pjse => profile_job_sector_enum
2606      * pjsse => profile_job_subsector_enum
2607      * pjssse => profile_job_subsubsector_enum
2608      * pja => profile_job_alternates
2609      * pjt => profile_job_terms
2610      */
2611     private $with_pj = false;
2612     private $with_pje = false;
2613     private $with_pjse = false;
2614     private $with_pjsse = false;
2615     private $with_pjssse = false;
2616     private $with_pja = false;
2617     private $with_pjt = 0;
2618
2619     public function addJobFilter()
2620     {
2621         $this->requireProfiles();
2622         $this->with_pj = true;
2623         return 'pj';
2624     }
2625
2626     public function addJobCompanyFilter()
2627     {
2628         $this->addJobFilter();
2629         $this->with_pje = true;
2630         return 'pje';
2631     }
2632
2633     public function addJobSectorizationFilter($type)
2634     {
2635         $this->addJobFilter();
2636         if ($type == self::JOB_SECTOR) {
2637             $this->with_pjse = true;
2638             return 'pjse';
2639         } else if ($type == self::JOB_SUBSECTOR) {
2640             $this->with_pjsse = true;
2641             return 'pjsse';
2642         } else if ($type == self::JOB_SUBSUBSECTOR) {
2643             $this->with_pjssse = true;
2644             return 'pjssse';
2645         } else if ($type == self::JOB_ALTERNATES) {
2646             $this->with_pja = true;
2647             return 'pja';
2648         }
2649     }
2650
2651     /**
2652      * Adds a filter on job terms of profile.
2653      * @param $nb the number of job terms to use
2654      * @return an array of the fields to filter (one for each term).
2655      * Code using this function should used returned field as is (contains table and field name).
2656      */
2657     public function addJobTermsFilter($nb = 1)
2658     {
2659         $this->with_pjt = $nb;
2660         $jobtermstable = array();
2661         for ($i = 1; $i <= $nb; ++$i) {
2662             $jobtermstable[] = 'pjtr_'.$i.'.jtid_1';
2663         }
2664         return $jobtermstable;
2665     }
2666
2667     protected function jobJoins()
2668     {
2669         $joins = array();
2670         if ($this->with_pj) {
2671             $joins['pj'] = PlSqlJoin::left('profile_job', '$ME.pid = $PID');
2672         }
2673         if ($this->with_pje) {
2674             $joins['pje'] = PlSqlJoin::left('profile_job_enum', '$ME.id = pj.jobid');
2675         }
2676         if ($this->with_pjse) {
2677             $joins['pjse'] = PlSqlJoin::left('profile_job_sector_enum', '$ME.id = pj.sectorid');
2678         }
2679         if ($this->with_pjsse) {
2680             $joins['pjsse'] = PlSqlJoin::left('profile_job_subsector_enum', '$ME.id = pj.subsectorid');
2681         }
2682         if ($this->with_pjssse) {
2683             $joins['pjssse'] = PlSqlJoin::left('profile_job_subsubsector_enum', '$ME.id = pj.subsubsectorid');
2684         }
2685         if ($this->with_pja) {
2686             $joins['pja'] = PlSqlJoin::left('profile_job_alternates', '$ME.subsubsectorid = pj.subsubsectorid');
2687         }
2688         if ($this->with_pjt > 0) {
2689             for ($i = 1; $i <= $this->with_pjt; ++$i) {
2690                 $joins['pjt_'.$i] = PlSqlJoin::left('profile_job_term', '$ME.pid = $PID');
2691                 $joins['pjtr_'.$i] = PlSqlJoin::left('profile_job_term_relation', '$ME.jtid_2 = pjt_'.$i.'.jtid');
2692             }
2693         }
2694         return $joins;
2695     }
2696
2697     /** NETWORKING
2698      */
2699
2700     private $with_pnw = false;
2701     public function addNetworkingFilter()
2702     {
2703         $this->requireAccounts();
2704         $this->with_pnw = true;
2705         return 'pnw';
2706     }
2707
2708     protected function networkingJoins()
2709     {
2710         $joins = array();
2711         if ($this->with_pnw) {
2712             $joins['pnw'] = PlSqlJoin::left('profile_networking', '$ME.pid = $PID');
2713         }
2714         return $joins;
2715     }
2716
2717     /** PHONE
2718      */
2719
2720     private $with_ptel = false;
2721
2722     public function addPhoneFilter()
2723     {
2724         $this->requireAccounts();
2725         $this->with_ptel = true;
2726         return 'ptel';
2727     }
2728
2729     protected function phoneJoins()
2730     {
2731         $joins = array();
2732         if ($this->with_ptel) {
2733             $joins['ptel'] = PlSqlJoin::left('profile_phones', '$ME.pid = $PID');
2734         }
2735         return $joins;
2736     }
2737
2738     /** MEDALS
2739      */
2740
2741     private $with_pmed = false;
2742     public function addMedalFilter()
2743     {
2744         $this->requireProfiles();
2745         $this->with_pmed = true;
2746         return 'pmed';
2747     }
2748
2749     protected function medalJoins()
2750     {
2751         $joins = array();
2752         if ($this->with_pmed) {
2753             $joins['pmed'] = PlSqlJoin::left('profile_medals', '$ME.pid = $PID');
2754         }
2755         return $joins;
2756     }
2757
2758     /** MENTORING
2759      */
2760
2761     private $pms = array();
2762     private $mjtr = false;
2763     const MENTOR = 1;
2764     const MENTOR_EXPERTISE = 2;
2765     const MENTOR_COUNTRY = 3;
2766     const MENTOR_SECTOR = 4;
2767     const MENTOR_TERM = 5;
2768
2769     public function addMentorFilter($type)
2770     {
2771         $this->requireAccounts();
2772         switch($type) {
2773         case self::MENTOR:
2774             $this->pms['pm'] = 'profile_mentor';
2775             return 'pm';
2776         case self::MENTOR_EXPERTISE:
2777             $this->pms['pme'] = 'profile_mentor';
2778             return 'pme';
2779         case self::MENTOR_COUNTRY:
2780             $this->pms['pmc'] = 'profile_mentor_country';
2781             return 'pmc';
2782         case self::MENTOR_SECTOR:
2783             $this->pms['pms'] =  'profile_mentor_sector';
2784             return 'pms';
2785         case self::MENTOR_TERM:
2786             $this->pms['pmt'] = 'profile_mentor_term';
2787             $this->mjtr = true;
2788             return 'mjtr';
2789         default:
2790             Platal::page()->killError("Undefined mentor filter.");
2791         }
2792     }
2793
2794     protected function mentorJoins()
2795     {
2796         $joins = array();
2797         foreach ($this->pms as $sub => $tab) {
2798             $joins[$sub] = PlSqlJoin::left($tab, '$ME.pid = $PID');
2799         }
2800         if ($this->mjtr) {
2801             $joins['mjtr'] = PlSqlJoin::left('profile_job_term_relation', '$ME.jtid_2 = pmt.jtid');
2802         }
2803         return $joins;
2804     }
2805
2806     /** CONTACTS
2807      */
2808     private $cts = array();
2809     public function addContactFilter($uid = null)
2810     {
2811         $this->requireProfiles();
2812         return $this->register_optional($this->cts, is_null($uid) ? null : 'user_' . $uid);
2813     }
2814
2815     protected function contactJoins()
2816     {
2817         $joins = array();
2818         foreach ($this->cts as $sub=>$key) {
2819             if (is_null($key)) {
2820                 $joins['c' . $sub] = PlSqlJoin::left('contacts', '$ME.contact = $PID');
2821             } else {
2822                 $joins['c' . $sub] = PlSqlJoin::left('contacts', '$ME.uid = {?} AND $ME.contact = $PID', substr($key, 5));
2823             }
2824         }
2825         return $joins;
2826     }
2827
2828
2829     /** CARNET
2830      */
2831     private $wn = array();
2832     public function addWatchRegistrationFilter($uid = null)
2833     {
2834         $this->requireAccounts();
2835         return $this->register_optional($this->wn, is_null($uid) ? null : 'user_' . $uid);
2836     }
2837
2838     private $wp = array();
2839     public function addWatchPromoFilter($uid = null)
2840     {
2841         $this->requireAccounts();
2842         return $this->register_optional($this->wp, is_null($uid) ? null : 'user_' . $uid);
2843     }
2844
2845     private $w = array();
2846     public function addWatchFilter($uid = null)
2847     {
2848         $this->requireAccounts();
2849         return $this->register_optional($this->w, is_null($uid) ? null : 'user_' . $uid);
2850     }
2851
2852     protected function watchJoins()
2853     {
2854         $joins = array();
2855         foreach ($this->w as $sub=>$key) {
2856             if (is_null($key)) {
2857                 $joins['w' . $sub] = PlSqlJoin::left('watch');
2858             } else {
2859                 $joins['w' . $sub] = PlSqlJoin::left('watch', '$ME.uid = {?}', substr($key, 5));
2860             }
2861         }
2862         foreach ($this->wn as $sub=>$key) {
2863             if (is_null($key)) {
2864                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.ni_id = $UID');
2865             } else {
2866                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
2867             }
2868         }
2869         foreach ($this->wn as $sub=>$key) {
2870             if (is_null($key)) {
2871                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.ni_id = $UID');
2872             } else {
2873                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
2874             }
2875         }
2876         foreach ($this->wp as $sub=>$key) {
2877             if (is_null($key)) {
2878                 $joins['wp' . $sub] = PlSqlJoin::left('watch_promo');
2879             } else {
2880                 $joins['wp' . $sub] = PlSqlJoin::left('watch_promo', '$ME.uid = {?}', substr($key, 5));
2881             }
2882         }
2883         return $joins;
2884     }
2885
2886
2887     /** PHOTOS
2888      */
2889     private $with_photo;
2890     public function addPhotoFilter()
2891     {
2892         $this->requireProfiles();
2893         $this->with_photo = true;
2894         return 'photo';
2895     }
2896
2897     protected function photoJoins()
2898     {
2899         if ($this->with_photo) {
2900             return array('photo' => PlSqlJoin::left('profile_photos', '$ME.pid = $PID'));
2901         } else {
2902             return array();
2903         }
2904     }
2905
2906
2907     /** MARKETING
2908      */
2909     private $with_rm;
2910     public function addMarketingHash()
2911     {
2912         $this->requireAccounts();
2913         $this->with_rm = true;
2914     }
2915
2916     protected function marketingJoins()
2917     {
2918         if ($this->with_rm) {
2919             return array('rm' => PlSqlJoin::left('register_marketing', '$ME.uid = $UID'));
2920         } else {
2921             return array();
2922         }
2923     }
2924 }
2925 // }}}
2926
2927 // {{{ class ProfileFilter
2928 class ProfileFilter extends UserFilter
2929 {
2930     public function get($limit = null)
2931     {
2932         return $this->getProfiles($limit);
2933     }
2934
2935     public function filter(array $profiles, $limit = null)
2936     {
2937         return $this->filterProfiles($profiles, self::defaultLimit($limit));
2938     }
2939
2940     public function getTotalCount()
2941     {
2942         return $this->getTotalProfileCount();
2943     }
2944
2945     public function getGroups()
2946     {
2947         return $this->getPIDGroups();
2948     }
2949 }
2950 // }}}
2951
2952 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
2953 ?>