classes/userfilter/conditions.inc.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2011 Polytechnique.org                              *
   4  *  http://opensource.polytechnique.org/                                   *
   5  *                                                                         *
   6  *  This program is free software; you can redistribute it and/or modify   *
   7  *  it under the terms of the GNU General Public License as published by   *
   8  *  the Free Software Foundation; either version 2 of the License, or      *
   9  *  (at your option) any later version.                                    *
  10  *                                                                         *
  11  *  This program is distributed in the hope that it will be useful,        *
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  14  *  GNU General Public License for more details.                           *
  15  *                                                                         *
  16  *  You should have received a copy of the GNU General Public License      *
  17  *  along with this program; if not, write to the Free Software            *
  18  *  Foundation, Inc.,                                                      *
  19  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                *
  20  ***************************************************************************/
  21
  22 // {{{ abstract class UserFilterCondition
  23 /** This class describe objects which filter users based
  24  *      on various parameters.
  25  * The parameters of the filter must be given to the constructor.
  26  * The buildCondition function is called by UserFilter when
  27  *     actually building the query. That function must call
  28  *     $uf->addWheteverFilter so that the UserFilter makes
  29  *     adequate joins. It must return the 'WHERE' condition to use
  30  *     with the filter.
  31  */
  32 abstract class UserFilterCondition implements PlFilterCondition
  33 {
  34     const OP_EQUALS     = '=';
  35     const OP_GREATER    = '>';
  36     const OP_NOTGREATER = '<=';
  37     const OP_LESSER     = '<';
  38     const OP_NOTLESSER  = '>=';
  39     const OP_NULL       = 'null';
  40     const OP_NOTNULL    = 'not null';
  41     const OP_CONTAINS   = 'contains';
  42     const OP_PREFIX     = 'prefix';
  43     const OP_SUFFIX     = 'suffix';
  44
  45     protected function buildExport($type)
  46     {
  47         $export = array('type' => $type);
  48         return $export;
  49     }
  50
  51     public function export()
  52     {
  53         throw new Exception("This class is not exportable");
  54     }
  55
  56     public static function comparisonFromXDBWildcard($wildcard)
  57     {
  58         switch ($wildcard) {
  59           case XDB::WILDCARD_EXACT:
  60             return self::OP_EQUALS;
  61           case XDB::WILDCARD_PREFIX:
  62             return self::OP_PREFIX;
  63           case XDB::WILDCARD_SUFFIX:
  64             return self::OP_SUFFIX;
  65           case XDB::WILDCARD_CONTAINS:
  66             return self::OP_CONTAINS;
  67         }
  68         throw new Exception("Unknown wildcard mode: $wildcard");
  69     }
  70
  71     public static function xdbWildcardFromComparison($comparison)
  72     {
  73         if (!self::isStringComparison($comparison)) {
  74             throw new Exception("Unknown string coparison: $comparison");
  75         }
  76         switch ($comparison) {
  77           case self::OP_EQUALS:
  78             return XDB::WILDCARD_EXACT;
  79           case self::OP_PREFIX:
  80             return XDB::WILDCARD_PREFIX;
  81           case self::OP_SUFFIX:
  82             return XDB::WILDCARD_SUFFIX;
  83           case self::OP_CONTAINS:
  84             return XDB::WILDCARD_CONTAINS;
  85         }
  86     }
  87
  88     private static function isNumericComparison($comparison)
  89     {
  90         return $comparison == self::OP_EQUALS
  91             || $comparison == self::OP_GREATER
  92             || $comparison == self::OP_NOTGREATER
  93             || $comparison == self::OP_LESSER
  94             || $comparison == self::OP_NOTLESSER;
  95     }
  96
  97     private static function isStringComparison($comparison)
  98     {
  99         return $comparison == self::OP_EQUALS
 100             || $comparison == self::OP_CONTAINS
 101             || $comparison == self::OP_PREFIX
 102             || $comparison == self::OP_SUFFIX;
 103     }
 104
 105     public static function fromExport(array $export)
 106     {
 107         $export = new PlDict($export);
 108         if (!$export->has('type')) {
 109             throw new Exception("Missing type in export");
 110         }
 111         $type = $export->s('type');
 112         $cond = null;
 113         switch ($type) {
 114           case 'and':
 115           case 'or':
 116           case 'not':
 117           case 'true':
 118           case 'false':
 119             $class = 'pfc_' . $type;
 120             $cond = new $class();
 121             break;
 122
 123           case 'host':
 124             if ($export->has('ip')) {
 125                 $cond = new UFC_Ip($export->s('ip'));
 126             }
 127             break;
 128
 129           case 'comment':
 130             if ($export->has('text') && $export->s('comparison') == self::OP_CONTAINS) {
 131                 $cond = new UFC_Comment($export->s('text'));
 132             }
 133             break;
 134
 135           case 'promo':
 136             if ($export->has('promo') && self::isNumericComparison($export->s('comparison'))) {
 137                 $cond = new UFC_Promo($export->s('comparison'),
 138                                       $export->s('grade', UserFilter::DISPLAY),
 139                                       $export->s('promo'));
 140             }
 141             break;
 142
 143           case 'lastname':
 144           case 'name':
 145           case 'firstname':
 146           case 'nickname':
 147           case 'pseudonym':
 148             if ($export->has('text')) {
 149                 $flag = self::xdbWildcardFromComparison($export->s('comparison'));
 150                 if ($export->b('search_in_variants')) {
 151                     $flag |= UFC_Name::VARIANTS;
 152                 }
 153                 if ($export->b('search_in_particle')) {
 154                     $flag |= UFC_Name::PARTICLE;
 155                 }
 156                 $cond = new UFC_Name($type, $export->s('text'), $flag);
 157             }
 158             break;
 159
 160           case 'account_type':
 161           case 'account_perm':
 162           case 'hrpid':
 163           case 'hruid':
 164             $values = $export->v('values', array());
 165             $class = 'ufc_' . str_replace('_', '', $type);
 166             $cond = new $class($values);
 167             break;
 168
 169           case 'school_id':
 170             $values = $export->v('values', array());
 171             $school_type = $export->s('school_type');
 172             $cond = new UFC_SchoolId($school_type, $values);
 173             break;
 174
 175           case 'has_profile':
 176           case 'has_email_redirect':
 177           case 'has_valid_email':
 178             $class = 'ufc_' . str_replace('_', '', $type);
 179             $cond = new $class();
 180             break;
 181
 182           default:
 183             throw new Exception("Unknown condition type: $type");
 184         }
 185         if (is_null($cond)) {
 186             throw new Exception("Unsupported $type definition");
 187         }
 188         if ($cond instanceof PFC_NChildren) {
 189             $children = $export->v('children', array());
 190             foreach ($children as $child) {
 191                 $cond->addChild(self::fromExport($child));
 192             }
 193         } else if ($cond instanceof PFC_OneChild) {
 194             if ($export->has('child')) {
 195                 $cond->setChild(self::fromExport($export->v('child')));
 196             }
 197         }
 198         return $cond;
 199     }
 200 }
 201 // }}}
 202 // {{{ class UFC_HasProfile
 203 /** Filters users who have a profile
 204  */
 205 class UFC_HasProfile extends UserFilterCondition
 206 {
 207     public function buildCondition(PlFilter $uf)
 208     {
 209         $uf->requireProfiles();
 210         return '$PID IS NOT NULL';
 211     }
 212
 213     public function export()
 214     {
 215         return $this->buildExport('has_profile');
 216     }
 217 }
 218 // }}}
 219 // {{{ class UFC_AccountType
 220 /** Filters users who have one of the given account types
 221  */
 222 class UFC_AccountType extends UserFilterCondition
 223 {
 224     private $types;
 225
 226     public function __construct()
 227     {
 228         $this->types = pl_flatten(func_get_args());
 229     }
 230
 231     public function buildCondition(PlFilter $uf)
 232     {
 233         $uf->requireAccounts();
 234         return XDB::format('a.type IN {?}', $this->types);
 235     }
 236
 237     public function export()
 238     {
 239         $export = $this->buildExport('account_type');
 240         $export['values'] = $this->types;
 241         return $export;
 242     }
 243 }
 244 // }}}
 245 // {{{ class UFC_AccountPerm
 246 /** Filters users who have one of the given permissions
 247  */
 248 class UFC_AccountPerm extends UserFilterCondition
 249 {
 250     private $perms;
 251
 252     public function __construct()
 253     {
 254         $this->perms = pl_flatten(func_get_args());
 255     }
 256
 257     public function buildCondition(PlFilter $uf)
 258     {
 259         $uf->requirePerms();
 260         $conds = array();
 261         foreach ($this->perms as $perm) {
 262             $conds[] = XDB::format('FIND_IN_SET({?}, IF(a.user_perms IS NULL, at.perms,
 263                                                         CONCAT(at.perms, \',\', a.user_perms)))',
 264                                    $perm);
 265         }
 266         if (empty($conds)) {
 267             return self::COND_TRUE;
 268         } else {
 269             return implode(' OR ', $conds);
 270         }
 271     }
 272
 273     public function export()
 274     {
 275         $export = $this->buildExport('account_perm');
 276         $export['values'] = $this->perms;
 277         return $export;
 278     }
 279 }
 280 // }}}
 281 // {{{ class UFC_Hruid
 282 /** Filters users based on their hruid
 283  * @param $val Either an hruid, or a list of those
 284  */
 285 class UFC_Hruid extends UserFilterCondition
 286 {
 287     private $hruids;
 288
 289     public function __construct()
 290     {
 291         $this->hruids = pl_flatten(func_get_args());
 292     }
 293
 294     public function buildCondition(PlFilter $uf)
 295     {
 296         $uf->requireAccounts();
 297         return XDB::format('a.hruid IN {?}', $this->hruids);
 298     }
 299
 300     public function export()
 301     {
 302         $export = $this->buildExport('hruid');
 303         $export['values'] = $this->hruids;
 304         return $export;
 305     }
 306 }
 307 // }}}
 308 // {{{ class UFC_Hrpid
 309 /** Filters users based on the hrpid of their profiles
 310  * @param $val Either an hrpid, or a list of those
 311  */
 312 class UFC_Hrpid extends UserFilterCondition
 313 {
 314     private $hrpids;
 315
 316     public function __construct()
 317     {
 318         $this->hrpids = pl_flatten(func_get_args());
 319     }
 320
 321     public function buildCondition(PlFilter $uf)
 322     {
 323         $uf->requireProfiles();
 324         return XDB::format('p.hrpid IN {?}', $this->hrpids);
 325     }
 326
 327     public function export()
 328     {
 329         $export = $this->buildExport('hrpid');
 330         $export['values'] = $this->hrpids;
 331         return $export;
 332     }
 333 }
 334 // }}}
 335 // {{{ class UFC_HasEmailRedirect
 336 /** Filters users, keeping only those with a valid email redirection (only X.org accounts).
 337  */
 338 class UFC_HasEmailRedirect extends UserFilterCondition
 339 {
 340     public function buildCondition(PlFilter $uf)
 341     {
 342         $sub_redirect = $uf->addActiveEmailRedirectFilter();
 343         return 'rf.redirect IS NOT NULL';
 344     }
 345
 346     public function export()
 347     {
 348         $export = $this->buildExport('has_email_redirect');
 349         return $export;
 350     }
 351 }
 352 // }}}
 353 // {{{ class UFC_HasValidEmail
 354 /** Filters users, keeping only those with a valid email address (all accounts).
 355  */
 356 class UFC_HasValidEmail extends UserFilterCondition
 357 {
 358     public function buildCondition(PlFilter $uf)
 359     {
 360         $sub_redirect = $uf->addEmailRedirectFilter();
 361         $uf->requireAccounts();
 362         return 'ra' . $sub_redirect . '.flags = \'active\' OR a.email IS NOT NULL';
 363     }
 364
 365     public function export()
 366     {
 367         $export = $this->buildExport('has_valid_email');
 368         return $export;
 369     }
 370 }
 371 // }}}
 372 // {{{ class UFC_Ip
 373 /** Filters users based on one of their last IPs
 374  * @param $ip IP from which connection are checked
 375  */
 376 class UFC_Ip extends UserFilterCondition
 377 {
 378     private $ip;
 379
 380     public function __construct($ip)
 381     {
 382         $this->ip = $ip;
 383     }
 384
 385     public function buildCondition(PlFilter $uf)
 386     {
 387         $sub = $uf->addLoggerFilter();
 388         $ip = ip_to_uint($this->ip);
 389         return XDB::format($sub . '.ip = {?} OR ' . $sub . '.forward_ip = {?}', $ip, $ip);
 390     }
 391
 392     public function export()
 393     {
 394         $export = $this->buildExport('host');
 395         $export['ip'] = $this->ip;
 396         return $export;
 397     }
 398 }
 399 // }}}
 400 // {{{ class UFC_Comment
 401 class UFC_Comment extends UserFilterCondition
 402 {
 403     private $text;
 404
 405     public function __construct($text)
 406     {
 407         $this->text = $text;
 408     }
 409
 410     public function buildCondition(PlFilter $uf)
 411     {
 412         $uf->requireProfiles();
 413         return $uf->getVisibilityCondition('p.freetext_pub') . ' AND p.freetext ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->text);
 414     }
 415
 416     public function export()
 417     {
 418         $export = $this->buildExport('comment');
 419         $export['comparison'] = self::OP_CONTAINS;
 420         $export['text'] = $this->text;
 421         return $export;
 422     }
 423 }
 424 // }}}
 425 // {{{ class UFC_Promo
 426 /** Filters users based on promotion
 427  * @param $comparison Comparison operator (>, =, ...)
 428  * @param $grade Formation on which to restrict, UserFilter::DISPLAY for "any formation"
 429  * @param $promo Promotion on which the filter is based
 430  */
 431 class UFC_Promo extends UserFilterCondition
 432 {
 433
 434     private $grade;
 435     private $promo;
 436     private $comparison;
 437
 438     public function __construct($comparison, $grade, $promo)
 439     {
 440         $this->grade = $grade;
 441         $this->comparison = $comparison;
 442         $this->promo = $promo;
 443         if ($this->grade != UserFilter::DISPLAY) {
 444             UserFilter::assertGrade($this->grade);
 445         }
 446         if ($this->grade == UserFilter::DISPLAY && $this->comparison != '=') {
 447             // XXX: we might try to guess the grade from the first char of the promo and forbid only '<= 2004', but allow '<= X2004'
 448             Platal::page()->killError("Il n'est pas possible d'appliquer la comparaison '" . $this->comparison . "' aux promotions sans spécifier de formation (X/M/D)");
 449         }
 450     }
 451
 452     public function buildCondition(PlFilter $uf)
 453     {
 454         if ($this->grade == UserFilter::DISPLAY) {
 455             $sub = $uf->addDisplayFilter();
 456             return XDB::format('pd' . $sub . '.promo ' . $this->comparison . ' {?}', $this->promo);
 457         } else {
 458             $sub = $uf->addEducationFilter(true, $this->grade);
 459             $field = 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
 460             return $field . ' IS NOT NULL AND ' . $field . ' ' . $this->comparison . ' ' . XDB::format('{?}', $this->promo);
 461         }
 462     }
 463
 464     public function export()
 465     {
 466         $export = $this->buildExport('promo');
 467         $export['comparison'] = $this->comparison;
 468         if ($this->grade != UserFilter::DISPLAY) {
 469             $export['grade'] = $this->grade;
 470         }
 471         $export['promo'] = $this->promo;
 472         return $export;
 473     }
 474 }
 475 // }}}
 476 // {{{ class UFC_SchoolId
 477 /** Filters users based on their shoold identifier
 478  * @param type Parameter type (Xorg, AX, School)
 479  * @param value Array of school ids
 480  */
 481 class UFC_SchoolId extends UserFilterCondition
 482 {
 483     const AX     = 'ax';
 484     const Xorg   = 'xorg';
 485     const School = 'school';
 486
 487     private $type;
 488     private $id;
 489
 490     static public function assertType($type)
 491     {
 492         if ($type != self::AX && $type != self::Xorg && $type != self::School) {
 493             Platal::page()->killError("Type de matricule invalide: $type");
 494         }
 495     }
 496
 497     /** Construct a UFC_SchoolId
 498      * The first argument is the type, all following arguments can be either ids
 499      * or arrays of ids to use:
 500      * $ufc = new UFC_SchoolId(UFC_SchoolId::AX, $id1, $id2, array($id3, $id4));
 501      */
 502     public function __construct($type)
 503     {
 504         $this->type = $type;
 505         $ids = func_get_args();
 506         array_shift($ids);
 507         $this->ids   = pl_flatten($ids);
 508         self::assertType($type);
 509     }
 510
 511     public function buildCondition(PlFilter $uf)
 512     {
 513         $uf->requireProfiles();
 514         $ids = $this->ids;
 515         $type = $this->type;
 516         if ($type == self::School) {
 517             $type = self::Xorg;
 518             $ids  = array_map(array('Profile', 'getXorgId'), $ids);
 519         }
 520         return XDB::format('p.' . $type . '_id IN {?}', $ids);
 521     }
 522
 523     public function export()
 524     {
 525         $export = $this->buildExport('school_id');
 526         $export['school_type'] = $this->type;
 527         $export['values'] = $this->ids;
 528         return $export;
 529     }
 530 }
 531 // }}}
 532 // {{{ class UFC_EducationSchool
 533 /** Filters users by formation
 534  * @param $val The formation to search (either ID or array of IDs)
 535  */
 536 class UFC_EducationSchool extends UserFilterCondition
 537 {
 538     private $val;
 539
 540     public function __construct()
 541     {
 542         $this->val = pl_flatten(func_get_args());
 543     }
 544
 545     public function buildCondition(PlFilter $uf)
 546     {
 547         $sub = $uf->addEducationFilter();
 548         return XDB::format('pe' . $sub . '.eduid IN {?}', $this->val);
 549     }
 550 }
 551 // }}}
 552 // {{{ class UFC_EducationDegree
 553 class UFC_EducationDegree extends UserFilterCondition
 554 {
 555     private $diploma;
 556
 557     public function __construct()
 558     {
 559         $this->diploma = pl_flatten(func_get_args());
 560     }
 561
 562     public function buildCondition(PlFilter $uf)
 563     {
 564         $sub = $uf->addEducationFilter();
 565         return XDB::format('pe' . $sub . '.degreeid IN {?}', $this->diploma);
 566     }
 567 }
 568 // }}}
 569 // {{{ class UFC_EducationField
 570 class UFC_EducationField extends UserFilterCondition
 571 {
 572     private $val;
 573
 574     public function __construct()
 575     {
 576         $this->val = pl_flatten(func_get_args());
 577     }
 578
 579     public function buildCondition(PlFilter $uf)
 580     {
 581         $sub = $uf->addEducationFilter();
 582         return XDB::format('pe' . $sub . '.fieldid IN {?}', $this->val);
 583     }
 584 }
 585 // }}}
 586 // {{{ class UFC_Name
 587 /** Filters users based on name
 588  * @param $type Type of name field on which filtering is done (firstname, lastname...)
 589  * @param $text Text on which to filter
 590  * @param $mode Flag indicating search type (prefix, suffix, with particule...)
 591  */
 592 class UFC_Name extends UserFilterCondition
 593 {
 594     const EXACT    = XDB::WILDCARD_EXACT;    // 0x000
 595     const PREFIX   = XDB::WILDCARD_PREFIX;   // 0x001
 596     const SUFFIX   = XDB::WILDCARD_SUFFIX;   // 0x002
 597     const CONTAINS = XDB::WILDCARD_CONTAINS; // 0x003
 598     const PARTICLE = 0x004;
 599     const VARIANTS = 0x008;
 600
 601     private $type;
 602     private $text;
 603     private $mode;
 604
 605     public function __construct($type, $text, $mode)
 606     {
 607         $this->type = $type;
 608         $this->text = $text;
 609         $this->mode = $mode;
 610     }
 611
 612     private function buildNameQuery($type, $variant, $where, UserFilter $uf)
 613     {
 614         $sub = $uf->addNameFilter($type, $variant);
 615         return str_replace('$ME', 'pn' . $sub, $where);
 616     }
 617
 618     public function buildCondition(PlFilter $uf)
 619     {
 620         $left = '$ME.name';
 621         if (($this->mode & self::PARTICLE) == self::PARTICLE) {
 622             $left = 'CONCAT($ME.particle, \' \', $ME.name)';
 623         }
 624         $right = XDB::formatWildcards($this->mode & self::CONTAINS, $this->text);
 625
 626         $cond = $left . $right;
 627         $conds = array($this->buildNameQuery($this->type, null, $cond, $uf));
 628         if (($this->mode & self::VARIANTS) != 0 && isset(Profile::$name_variants[$this->type])) {
 629             foreach (Profile::$name_variants[$this->type] as $var) {
 630                 $conds[] = $this->buildNameQuery($this->type, $var, $cond, $uf);
 631             }
 632         }
 633         return implode(' OR ', $conds);
 634     }
 635
 636     public function export()
 637     {
 638         $export = $this->buildExport($this->type);
 639         if ($this->mode & self::VARIANTS) {
 640             $export['search_in_variants'] = true;
 641         }
 642         if ($this->mode & self::PARTICLE) {
 643             $export['search_in_particle'] = true;
 644         }
 645         $export['comparison'] = self::comparisonFromXDBWildcard($this->mode & 0x3);
 646         $export['text'] = $this->text;
 647         return $export;
 648     }
 649 }
 650 // }}}
 651 // {{{ class UFC_NameTokens
 652 /** Selects users based on tokens in their name (for quicksearch)
 653  * @param $tokens An array of tokens to search
 654  * @param $flags Flags the tokens must have (e.g 'public' for public search)
 655  * @param $soundex (bool) Whether those tokens are fulltext or soundex
 656  */
 657 class UFC_NameTokens extends UserFilterCondition
 658 {
 659     /* Flags */
 660     const FLAG_PUBLIC = 'public';
 661
 662     private $tokens;
 663     private $flags;
 664     private $soundex;
 665     private $exact;
 666     private $general_type;
 667
 668     public function __construct($tokens, $flags = array(), $soundex = false, $exact = false, $general_type = '')
 669     {
 670         if (is_array($tokens)) {
 671             $this->tokens = $tokens;
 672         } else {
 673             $this->tokens = array($tokens);
 674         }
 675         if (is_array($flags)) {
 676             $this->flags = $flags;
 677         } else {
 678             $this->flags = array($flags);
 679         }
 680         $this->soundex = $soundex;
 681         $this->exact = $exact;
 682         $this->general_type = $general_type;
 683     }
 684
 685     public function buildCondition(PlFilter $uf)
 686     {
 687         $conds = array();
 688         foreach ($this->tokens as $i => $token) {
 689             $sub = $uf->addNameTokensFilter($token);
 690             if ($this->soundex) {
 691                 $c = XDB::format($sub . '.soundex = {?}', soundex_fr($token));
 692             } else if ($this->exact) {
 693                 $c = XDB::format($sub . '.token = {?}', $token);
 694             } else {
 695                 $c = $sub . '.token ' . XDB::formatWildcards(XDB::WILDCARD_PREFIX, $token);
 696             }
 697             if ($this->flags != null) {
 698                 $c .= XDB::format(' AND ' . $sub . '.flags IN {?}', $this->flags);
 699             }
 700             if ($this->general_type) {
 701                 $c .= XDB::format(' AND ' . $sub . '.general_type = {?}', $this->general_type);
 702             }
 703             $conds[] = $c;
 704         }
 705
 706         return implode(' AND ', $conds);
 707     }
 708 }
 709 // }}}
 710 // {{{ class UFC_Nationality
 711 class UFC_Nationality extends UserFilterCondition
 712 {
 713     private $val;
 714
 715     public function __construct()
 716     {
 717         $this->val = pl_flatten(func_get_args());
 718     }
 719
 720     public function buildCondition(PlFilter $uf)
 721     {
 722         $uf->requireProfiles();
 723         $nat = XDB::formatArray($this->val);
 724         $conds = array(
 725             'p.nationality1 IN ' . $nat,
 726             'p.nationality2 IN ' . $nat,
 727             'p.nationality3 IN ' . $nat,
 728         );
 729         return implode(' OR ', $conds);
 730     }
 731 }
 732 // }}}
 733 // {{{ class UFC_Dead
 734 /** Filters users based on death date
 735  * @param $comparison Comparison operator
 736  * @param $date Date to which death date should be compared (DateTime object, string or timestamp)
 737  */
 738 class UFC_Dead extends UserFilterCondition
 739 {
 740     private $comparison;
 741     private $date;
 742
 743     public function __construct($comparison = null, $date = null)
 744     {
 745         $this->comparison = $comparison;
 746         $this->date = make_datetime($date);
 747     }
 748
 749     public function buildCondition(PlFilter $uf)
 750     {
 751         $uf->requireProfiles();
 752         $str = 'p.deathdate IS NOT NULL';
 753         if (!is_null($this->comparison)) {
 754             $str .= ' AND p.deathdate ' . $this->comparison . ' ' . XDB::format('{?}', $this->date->format('Y-m-d'));
 755         }
 756         return $str;
 757     }
 758 }
 759 // }}}
 760 // {{{ class UFC_Registered
 761 /** Filters users based on registration state
 762  * @param $active Whether we want to use only "active" users (i.e with a valid redirection)
 763  * @param $comparison Comparison operator
 764  * @param $date Date to which users registration date should be compared
 765  */
 766 class UFC_Registered extends UserFilterCondition
 767 {
 768     private $active;
 769     private $comparison;
 770     private $date;
 771
 772     public function __construct($active = false, $comparison = null, $date = null)
 773     {
 774         $this->active = $active;
 775         $this->comparison = $comparison;
 776         $this->date = make_datetime($date);
 777     }
 778
 779     public function buildCondition(PlFilter $uf)
 780     {
 781         $uf->requireAccounts();
 782         if ($this->active) {
 783             $date = '$UID IS NOT NULL AND a.state = \'active\'';
 784         } else {
 785             $date = '$UID IS NOT NULL AND a.state != \'pending\'';
 786         }
 787         if (!is_null($this->comparison)) {
 788             $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'));
 789         }
 790         return $date;
 791     }
 792 }
 793 // }}}
 794 // {{{ class UFC_ProfileUpdated
 795 /** Filters users based on profile update date
 796  * @param $comparison Comparison operator
 797  * @param $date Date to which profile update date must be compared
 798  */
 799 class UFC_ProfileUpdated extends UserFilterCondition
 800 {
 801     private $comparison;
 802     private $date;
 803
 804     public function __construct($comparison = null, $date = null)
 805     {
 806         $this->comparison = $comparison;
 807         $this->date = $date;
 808     }
 809
 810     public function buildCondition(PlFilter $uf)
 811     {
 812         $uf->requireProfiles();
 813         return 'p.last_change ' . $this->comparison . XDB::format(' {?}', date('Y-m-d H:i:s', $this->date));
 814     }
 815 }
 816 // }}}
 817 // {{{ class UFC_Birthday
 818 /** Filters users based on next birthday date
 819  * @param $comparison Comparison operator
 820  * @param $date Date to which users next birthday date should be compared
 821  */
 822 class UFC_Birthday extends UserFilterCondition
 823 {
 824     private $comparison;
 825     private $date;
 826
 827     public function __construct($comparison = null, $date = null)
 828     {
 829         $this->comparison = $comparison;
 830         $this->date = $date;
 831     }
 832
 833     public function buildCondition(PlFilter $uf)
 834     {
 835         $uf->requireProfiles();
 836         return 'p.next_birthday ' . $this->comparison . XDB::format(' {?}', date('Y-m-d', $this->date));
 837     }
 838 }
 839 // }}}
 840 // {{{ class UFC_Sex
 841 /** Filters users based on sex
 842  * @parm $sex One of User::GENDER_MALE or User::GENDER_FEMALE, for selecting users
 843  */
 844 class UFC_Sex extends UserFilterCondition
 845 {
 846     private $sex;
 847     public function __construct($sex)
 848     {
 849         $this->sex = $sex;
 850     }
 851
 852     public function buildCondition(PlFilter $uf)
 853     {
 854         if ($this->sex != User::GENDER_MALE && $this->sex != User::GENDER_FEMALE) {
 855             return self::COND_FALSE;
 856         } else {
 857             $uf->requireProfiles();
 858             return XDB::format('p.sex = {?}', $this->sex == User::GENDER_FEMALE ? 'female' : 'male');
 859         }
 860     }
 861 }
 862 // }}}
 863 // {{{ class UFC_NLSubscribed
 864 /** Filters users based on NL subscription
 865  * @param $nlid NL whose subscribers we are selecting
 866  * @param $issue Select only subscribers who have not yet received that issue
 867  */
 868 class UFC_NLSubscribed extends UserFilterCondition
 869 {
 870     private $nlid;
 871     private $issue_id;
 872     public function __construct($nlid, $issue_id)
 873     {
 874         $this->nlid = $nlid;
 875         $this->issue_id = $issue_id;
 876     }
 877
 878     public function buildCondition(PlFilter $uf)
 879     {
 880         $sub = $uf->addNewsLetterFilter($this->nlid);
 881         return XDB::format($sub . '.last < {?}', $this->issue_id);
 882     }
 883 }
 884 // }}}
 885 // {{{ class UFC_Group
 886 /** Filters users based on group membership
 887  * @param $group Group whose members we are selecting
 888  * @param $anim Whether to restrict selection to animators of that group
 889  */
 890 class UFC_Group extends UserFilterCondition
 891 {
 892     private $group;
 893     private $anim;
 894     public function __construct($group, $anim = false)
 895     {
 896         $this->group = $group;
 897         $this->anim = $anim;
 898     }
 899
 900     public function buildCondition(PlFilter $uf)
 901     {
 902         // Groups are only visible for users with perm 'groups'.
 903         if (!S::user()->checkPerms(User::PERM_GROUPS)) {
 904             return self::COND_FALSE;
 905         }
 906         $sub = $uf->addGroupFilter($this->group);
 907         $where = 'gpm' . $sub . '.perms IS NOT NULL';
 908         if ($this->anim) {
 909             $where .= ' AND gpm' . $sub . '.perms = \'admin\'';
 910         }
 911         return $where;
 912     }
 913 }
 914 // }}}
 915 // {{{ class UFC_GroupFormerMember
 916 /** Filters users based on group former membership
 917  * @param $group Group whose former members we are selecting
 918  */
 919 class UFC_GroupFormerMember extends UserFilterCondition
 920 {
 921     private $group;
 922
 923     public function __construct($group)
 924     {
 925         $this->group = $group;
 926     }
 927
 928     public function buildCondition(PlFilter $uf)
 929     {
 930         // Groups are only visible for users with perm 'groups'.
 931         if (!S::user()->checkPerms(User::PERM_GROUPS)) {
 932             return self::COND_FALSE;
 933         }
 934         $sub = $uf->addGroupFormerMemberFilter();
 935         return XDB::format('gpfm' . $sub . '.asso_id = {?}', $this->group);
 936     }
 937 }
 938 // }}}
 939 // {{{ class UFC_Binet
 940 /** Selects users based on their belonging to a given (list of) binet
 941  * @param $binet either a binet_id or an array of binet_ids
 942  */
 943 class UFC_Binet extends UserFilterCondition
 944 {
 945     private $val;
 946
 947     public function __construct()
 948     {
 949         $this->val = pl_flatten(func_get_args());
 950     }
 951
 952     public function buildCondition(PlFilter $uf)
 953     {
 954         // Binets are private.
 955         if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
 956             return self::COND_TRUE;
 957         }
 958         $sub = $uf->addBinetsFilter();
 959         return XDB::format($sub . '.binet_id IN {?}', $this->val);
 960     }
 961 }
 962 // }}}
 963 // {{{ class UFC_Section
 964 /** Selects users based on section
 965  * @param $section ID of the section
 966  */
 967 class UFC_Section extends UserFilterCondition
 968 {
 969     private $section;
 970
 971     public function __construct()
 972     {
 973         $this->section = pl_flatten(func_get_args());
 974     }
 975
 976     public function buildCondition(PlFilter $uf)
 977     {
 978         // Sections are private.
 979         if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
 980             return self::COND_TRUE;
 981         }
 982         $uf->requireProfiles();
 983         return XDB::format('p.section IN {?}', $this->section);
 984     }
 985 }
 986 // }}}
 987 // {{{ class UFC_Email
 988 /** Filters users based on an email or a list of emails
 989  * @param $emails List of emails whose owner must be selected
 990  */
 991 class UFC_Email extends UserFilterCondition
 992 {
 993     private $emails;
 994     public function __construct()
 995     {
 996         $this->emails = pl_flatten(func_get_args());
 997     }
 998
 999     public function buildCondition(PlFilter $uf)
1000     {
1001         $foreign = array();
1002         $local   = array();
1003         $cond    = array();
1004
1005         if (count($this->emails) == 0) {
1006             return PlFilterCondition::COND_TRUE;
1007         }
1008
1009         foreach ($this->emails as $entry) {
1010             if (User::isForeignEmailAddress($entry)) {
1011                 $foreign[] = $entry;
1012             } else {
1013                 list($local_part, ) = explode('@', $entry);
1014                 $local[] = $local_part;
1015             }
1016         }
1017
1018         if (count($foreign) > 0) {
1019             $sub = $uf->addEmailRedirectFilter($foreign);
1020             $cond[] = XDB::format('ra' . $sub . '.redirect IS NOT NULL OR ra' . $sub . '.redirect IN {?} OR a.email IN {?}', $foreign, $foreign);
1021         }
1022         if (count($local) > 0) {
1023             $sub = $uf->addAliasFilter($local);
1024             $cond[] = 'sa' . $sub . '.email IS NOT NULL';
1025         }
1026         return '(' . implode(') OR (', $cond) . ')';
1027     }
1028 }
1029 // }}}
1030 // {{{ class UFC_Address
1031 abstract class UFC_Address extends UserFilterCondition
1032 {
1033     /** Valid address type ('hq' is reserved for company addresses)
1034      */
1035     const TYPE_HOME = 1;
1036     const TYPE_PRO  = 2;
1037     const TYPE_ANY  = 3;
1038
1039     /** Text for these types
1040      */
1041     protected static $typetexts = array(
1042         self::TYPE_HOME => 'home',
1043         self::TYPE_PRO  => 'pro',
1044     );
1045
1046     protected $type;
1047
1048     /** Flags for addresses
1049      */
1050     const FLAG_CURRENT = 0x0001;
1051     const FLAG_TEMP    = 0x0002;
1052     const FLAG_SECOND  = 0x0004;
1053     const FLAG_MAIL    = 0x0008;
1054     const FLAG_CEDEX   = 0x0010;
1055
1056     // Binary OR of those flags
1057     const FLAG_ANY     = 0x001F;
1058
1059     /** Text of these flags
1060      */
1061     protected static $flagtexts = array(
1062         self::FLAG_CURRENT => 'current',
1063         self::FLAG_TEMP    => 'temporary',
1064         self::FLAG_SECOND  => 'secondary',
1065         self::FLAG_MAIL    => 'mail',
1066         self::FLAG_CEDEX   => 'cedex',
1067     );
1068
1069     protected $flags;
1070
1071     public function __construct($type = null, $flags = null)
1072     {
1073         $this->type  = $type;
1074         $this->flags = $flags;
1075     }
1076
1077     protected function initConds($sub, $vis_cond)
1078     {
1079         $conds = array($vis_cond);
1080
1081         $types = array();
1082         foreach (self::$typetexts as $flag => $type) {
1083             if ($flag & $this->type) {
1084                 $types[] = $type;
1085             }
1086         }
1087         if (count($types)) {
1088             $conds[] = XDB::format($sub . '.type IN {?}', $types);
1089         }
1090
1091         if ($this->flags != self::FLAG_ANY) {
1092             foreach(self::$flagtexts as $flag => $text) {
1093                 if ($flag & $this->flags) {
1094                     $conds[] = 'FIND_IN_SET(' . XDB::format('{?}', $text) . ', ' . $sub . '.flags)';
1095                 }
1096             }
1097         }
1098         return $conds;
1099     }
1100
1101 }
1102 // }}}
1103 // {{{ class UFC_AddressText
1104 /** Select users based on their address, using full text search
1105  * @param $text Text for filter in fulltext search
1106  * @param $textSearchMode Mode for search (one of XDB::WILDCARD_*)
1107  * @param $type Filter on address type
1108  * @param $flags Filter on address flags
1109  * @param $country Filter on address country
1110  * @param $locality Filter on address locality
1111  */
1112 class UFC_AddressText extends UFC_Address
1113 {
1114
1115     private $text;
1116     private $textSearchMode;
1117
1118     public function __construct($text = null, $textSearchMode = XDB::WILDCARD_CONTAINS,
1119         $type = null, $flags = self::FLAG_ANY, $country = null, $locality = null)
1120     {
1121         parent::__construct($type, $flags);
1122         $this->text           = $text;
1123         $this->textSearchMode = $textSearchMode;
1124         $this->country        = $country;
1125         $this->locality       = $locality;
1126     }
1127
1128     private function mkMatch($txt)
1129     {
1130         return XDB::formatWildcards($this->textSearchMode, $txt);
1131     }
1132
1133     public function buildCondition(PlFilter $uf)
1134     {
1135         $sub = $uf->addAddressFilter();
1136         $conds = $this->initConds($sub, $uf->getVisibilityCondition($sub . '.pub'));
1137         if ($this->text != null) {
1138             $conds[] = $sub . '.text' . $this->mkMatch($this->text);
1139         }
1140
1141         if ($this->country != null) {
1142             $subc = $uf->addAddressCountryFilter();
1143             $subconds = array();
1144             $subconds[] = $subc . '.country' . $this->mkMatch($this->country);
1145             $subconds[] = $subc . '.countryFR' . $this->mkMatch($this->country);
1146             $conds[] = implode(' OR ', $subconds);
1147         }
1148
1149         if ($this->locality != null) {
1150             $subl = $uf->addAddressLocalityFilter();
1151             $conds[] = $subl . '.name' . $this->mkMatch($this->locality);
1152         }
1153
1154         return implode(' AND ', $conds);
1155     }
1156 }
1157 // }}}
1158 // {{{ class UFC_AddressField
1159 /** Filters users based on their address,
1160  * @param $val Either a code for one of the fields, or an array of such codes
1161  * @param $fieldtype The type of field to look for
1162  * @param $type Filter on address type
1163  * @param $flags Filter on address flags
1164  */
1165 class UFC_AddressField extends UFC_Address
1166 {
1167     const FIELD_COUNTRY    = 1;
1168     const FIELD_ADMAREA    = 2;
1169     const FIELD_SUBADMAREA = 3;
1170     const FIELD_LOCALITY   = 4;
1171     const FIELD_ZIPCODE    = 5;
1172
1173     /** Data of the filter
1174      */
1175     private $val;
1176     private $fieldtype;
1177
1178     public function __construct($val, $fieldtype, $type = null, $flags = self::FLAG_ANY)
1179     {
1180         parent::__construct($type, $flags);
1181
1182         if (!is_array($val)) {
1183             $val = array($val);
1184         }
1185         $this->val       = $val;
1186         $this->fieldtype = $fieldtype;
1187     }
1188
1189     public function buildCondition(PlFilter $uf)
1190     {
1191         $sub = $uf->addAddressFilter();
1192         $conds = $this->initConds($sub, $uf->getVisibilityCondition($sub . '.pub'));
1193
1194         switch ($this->fieldtype) {
1195         case self::FIELD_COUNTRY:
1196             $field = 'countryId';
1197             break;
1198         case self::FIELD_ADMAREA:
1199             $field = 'administrativeAreaId';
1200             break;
1201         case self::FIELD_SUBADMAREA:
1202             $field = 'subAdministrativeAreaId';
1203             break;
1204         case self::FIELD_LOCALITY:
1205             $field = 'localityId';
1206             break;
1207         case self::FIELD_ZIPCODE:
1208             $field = 'postalCode';
1209             break;
1210         default:
1211             Platal::page()->killError('Invalid address field type: ' . $this->fieldtype);
1212         }
1213         $conds[] = XDB::format($sub . '.' . $field . ' IN {?}', $this->val);
1214
1215         return implode(' AND ', $conds);
1216     }
1217 }
1218 // }}}
1219 // {{{ class UFC_Corps
1220 /** Filters users based on the corps they belong to
1221  * @param $corps Corps we are looking for (abbreviation)
1222  * @param $type Whether we search for original or current corps
1223  */
1224 class UFC_Corps extends UserFilterCondition
1225 {
1226     const CURRENT   = 1;
1227     const ORIGIN    = 2;
1228
1229     private $corps;
1230     private $id;
1231     private $type;
1232
1233     public function __construct($corps, $id = null, $type = self::CURRENT)
1234     {
1235         $this->corps = $corps;
1236         $this->id    = $id;
1237         $this->type  = $type;
1238     }
1239
1240     public function buildCondition(PlFilter $uf)
1241     {
1242         /** Tables shortcuts:
1243          * pc for profile_corps,
1244          * pceo for profile_corps_enum - orginal
1245          * pcec for profile_corps_enum - current
1246          */
1247         $sub = $uf->addCorpsFilter($this->type);
1248         if (is_null($this->id)) {
1249             $cond = $sub . '.abbreviation = ' . $this->corps;
1250         } else {
1251             $cond = $sub . '.id = ' . $this->id;
1252         }
1253         // XXX(x2006barrois): find a way to get rid of that hardcoded
1254         // reference to 'pc'.
1255         $cond .= ' AND ' . $uf->getVisibilityCondition('pc.corps_pub');
1256         return $cond;
1257     }
1258 }
1259 // }}}
1260 // {{{ class UFC_Corps_Rank
1261 /** Filters users based on their rank in the corps
1262  * @param $rank Rank we are looking for (abbreviation)
1263  */
1264 class UFC_Corps_Rank extends UserFilterCondition
1265 {
1266     private $rank;
1267     private $id;
1268
1269     public function __construct($rank, $id = null)
1270     {
1271         $this->rank = $rank;
1272         $this->id   = $id;
1273     }
1274
1275     public function buildCondition(PlFilter $uf)
1276     {
1277         /** Tables shortcuts:
1278          * pc for profile_corps
1279          * pcr for profile_corps_rank
1280          */
1281         $sub = $uf->addCorpsRankFilter();
1282         if (is_null($this->id)) {
1283             $cond = $sub . '.abbreviation = ' . $this->rank;
1284         } else {
1285             $cond = $sub . '.id = ' . $this->id;
1286         }
1287         // XXX(x2006barrois): find a way to get rid of that hardcoded
1288         // reference to 'pc'.
1289         $cond .= ' AND ' . $uf->getVisibilityCondition('pc.corps_pub');
1290         return $cond;
1291     }
1292 }
1293 // }}}
1294 // {{{ class UFC_Job_Company
1295 /** Filters users based on the company they belong to
1296  * @param $type The field being searched (self::JOBID, self::JOBNAME or self::JOBACRONYM)
1297  * @param $value The searched value
1298  */
1299 class UFC_Job_Company extends UserFilterCondition
1300 {
1301     const JOBID = 'id';
1302     const JOBNAME = 'name';
1303     const JOBACRONYM = 'acronym';
1304
1305     private $type;
1306     private $value;
1307
1308     public function __construct($type, $value)
1309     {
1310         $this->assertType($type);
1311         $this->type = $type;
1312         $this->value = $value;
1313     }
1314
1315     private function assertType($type)
1316     {
1317         if ($type != self::JOBID && $type != self::JOBNAME && $type != self::JOBACRONYM) {
1318             Platal::page()->killError("Type de recherche non valide.");
1319         }
1320     }
1321
1322     public function buildCondition(PlFilter $uf)
1323     {
1324         $sub = $uf->addJobCompanyFilter();
1325         $cond  = $sub . '.' . $this->type . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
1326         $jsub = $uf->addJobFilter();
1327         $cond .= ' AND ' . $uf->getVisibilityCondition($jsub . '.pub');
1328         return $cond;
1329     }
1330 }
1331 // }}}
1332 // {{{ class UFC_Job_Terms
1333 /** Filters users based on the job terms they assigned to one of their
1334  * jobs.
1335  * @param $val The ID of the job term, or an array of such IDs
1336  */
1337 class UFC_Job_Terms extends UserFilterCondition
1338 {
1339     private $val;
1340
1341     public function __construct($val)
1342     {
1343         if (!is_array($val)) {
1344             $val = array($val);
1345         }
1346         $this->val = $val;
1347     }
1348
1349     public function buildCondition(PlFilter $uf)
1350     {
1351         $sub = $uf->addJobTermsFilter(count($this->val));
1352         $conditions = array();
1353         foreach ($this->val as $i => $jtid) {
1354             $conditions[] = $sub[$i] . '.jtid_1 = ' . XDB::escape($jtid);
1355         }
1356         $jsub = $uf->addJobFilter();
1357         $conditions[] = $uf->getVisibilityCondition($jsub . '.pub');
1358         return implode(' AND ', $conditions);
1359     }
1360 }
1361 // }}}
1362 // {{{ class UFC_Job_Description
1363 /** Filters users based on their job description
1364  * @param $description The text being searched for
1365  * @param $fields The fields to search for (CV, user-defined)
1366  */
1367 class UFC_Job_Description extends UserFilterCondition
1368 {
1369
1370     private $description;
1371     private $fields;
1372
1373     public function __construct($description, $fields)
1374     {
1375         $this->fields = $fields;
1376         $this->description = $description;
1377     }
1378
1379     public function buildCondition(PlFilter $uf)
1380     {
1381         $conds = array();
1382
1383         $jsub = $uf->addJobFilter();
1384         // CV is private => if only CV requested, and not private,
1385         // don't do anything. Otherwise restrict to standard job visibility.
1386         if ($this->fields == UserFilter::JOB_CV) {
1387            if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
1388                return self::COND_TRUE;
1389            }
1390         }
1391         if ($this->fields & UserFilter::JOB_USERDEFINED) {
1392             $conds[] = $jsub . '.description ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1393         }
1394         if ($this->fields & UserFilter::JOB_CV && $uf->getVisibilityLevel() == ProfileVisibility::VIS_PRIVATE) {
1395             $uf->requireProfiles();
1396             $conds[] = 'p.cv ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
1397         }
1398         if (count($conds) == 0) {
1399             return self::COND_TRUE;
1400         }
1401         return $uf->getVisibilityCondition($jsub . '.pub') . ' AND ( ' . implode(' OR ', $conds) . ' )';
1402     }
1403 }
1404 // }}}
1405 // {{{ class UFC_Networking
1406 /** Filters users based on network identity (IRC, ...)
1407  * @param $type Type of network (-1 for any)
1408  * @param $value Value to search
1409  */
1410 class UFC_Networking extends UserFilterCondition
1411 {
1412     private $type;
1413     private $value;
1414
1415     public function __construct($type, $value)
1416     {
1417         $this->type = $type;
1418         $this->value = $value;
1419     }
1420
1421     public function buildCondition(PlFilter $uf)
1422     {
1423         $sub = $uf->addNetworkingFilter();
1424         $conds = array();
1425         $conds[] = $uf->getVisibilityCondition($sub . '.pub');
1426         $conds[] = $sub . '.address ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
1427         if ($this->type != -1) {
1428             $conds[] = $sub . '.nwid = ' . XDB::format('{?}', $this->type);
1429         }
1430         return implode(' AND ', $conds);
1431     }
1432 }
1433 // }}}
1434 // {{{ class UFC_Phone
1435 /** Filters users based on their phone number
1436  * @param $num_type Type of number (pro/user/home)
1437  * @param $phone_type Type of phone (fixed/mobile/fax)
1438  * @param $number Phone number
1439  */
1440 class UFC_Phone extends UserFilterCondition
1441 {
1442     const NUM_PRO   = 'pro';
1443     const NUM_USER  = 'user';
1444     const NUM_HOME  = 'address';
1445     const NUM_ANY   = 'any';
1446
1447     const PHONE_FIXED   = 'fixed';
1448     const PHONE_MOBILE  = 'mobile';
1449     const PHONE_FAX     = 'fax';
1450     const PHONE_ANY     = 'any';
1451
1452     private $num_type;
1453     private $phone_type;
1454     private $number;
1455
1456     public function __construct($number, $num_type = self::NUM_ANY, $phone_type = self::PHONE_ANY)
1457     {
1458         $phone = new Phone(array('display' => $number));
1459         $phone->format();
1460         $this->number = $phone->search;
1461         $this->num_type = $num_type;
1462         $this->phone_type = $phone_type;
1463     }
1464
1465     public function buildCondition(PlFilter $uf)
1466     {
1467         $sub = $uf->addPhoneFilter();
1468         $conds = array();
1469
1470         $conds[] = $uf->getVisibilityCondition($sub . '.pub');
1471
1472         $conds[] = $sub . '.search_tel = ' . XDB::format('{?}', $this->number);
1473         if ($this->num_type != self::NUM_ANY) {
1474             $conds[] = $sub . '.link_type = ' . XDB::format('{?}', $this->num_type);
1475         }
1476         if ($this->phone_type != self::PHONE_ANY) {
1477             $conds[] = $sub . '.tel_type = ' . XDB::format('{?}', $this->phone_type);
1478         }
1479         return implode(' AND ', $conds);
1480     }
1481 }
1482 // }}}
1483 // {{{ class UFC_Medal
1484 /** Filters users based on their medals
1485  * @param $medal ID of the medal
1486  * @param $grade Grade of the medal (null for 'any')
1487  */
1488 class UFC_Medal extends UserFilterCondition
1489 {
1490     private $medal;
1491     private $grade;
1492
1493     public function __construct($medal, $grade = null)
1494     {
1495         $this->medal = $medal;
1496         $this->grade = $grade;
1497     }
1498
1499     public function buildCondition(PlFilter $uf)
1500     {
1501         $conds = array();
1502
1503         // This will require profiles => table 'p' will be available.
1504         $sub = $uf->addMedalFilter();
1505
1506         $conds[] = $uf->getVisibilityCondition('p.medals_pub');
1507
1508         $conds[] = $sub . '.mid = ' . XDB::format('{?}', $this->medal);
1509         if ($this->grade != null) {
1510             $conds[] = $sub . '.gid = ' . XDB::format('{?}', $this->grade);
1511         }
1512         return implode(' AND ', $conds);
1513     }
1514 }
1515 // }}}
1516 // {{{ class UFC_Photo
1517 /** Filters profiles with photo
1518  */
1519 class UFC_Photo extends UserFilterCondition
1520 {
1521     public function buildCondition(PlFilter $uf)
1522     {
1523         $sub = $uf->addPhotoFilter();
1524         return $sub . '.attach IS NOT NULL AND ' . $uf->getVisibilityCondition($sub . '.pub');
1525     }
1526 }
1527 // }}}
1528 // {{{ class UFC_Mentor
1529 class UFC_Mentor extends UserFilterCondition
1530 {
1531     public function buildCondition(PlFilter $uf)
1532     {
1533         $sub = $uf->addMentorFilter(UserFilter::MENTOR);
1534         return $sub . '.expertise IS NOT NULL';
1535     }
1536 }
1537 // }}}
1538 // {{{ class UFC_Mentor_Expertise
1539 /** Filters users by mentoring expertise
1540  * @param $expertise Domain of expertise
1541  */
1542 class UFC_Mentor_Expertise extends UserFilterCondition
1543 {
1544     private $expertise;
1545
1546     public function __construct($expertise)
1547     {
1548         $this->expertise = $expertise;
1549     }
1550
1551     public function buildCondition(PlFilter $uf)
1552     {
1553         $sub = $uf->addMentorFilter(UserFilter::MENTOR_EXPERTISE);
1554         return $sub . '.expertise ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->expertise);
1555     }
1556 }
1557 // }}}
1558 // {{{ class UFC_Mentor_Country
1559 /** Filters users by mentoring country
1560  * @param $country Two-letters code of country being searched
1561  */
1562 class UFC_Mentor_Country extends UserFilterCondition
1563 {
1564     private $country;
1565
1566     public function __construct()
1567     {
1568         $this->country = pl_flatten(func_get_args());
1569     }
1570
1571     public function buildCondition(PlFilter $uf)
1572     {
1573         $sub = $uf->addMentorFilter(UserFilter::MENTOR_COUNTRY);
1574         return $sub . '.country IN ' . XDB::format('{?}', $this->country);
1575     }
1576 }
1577 // }}}
1578 // {{{ class UFC_Mentor_Terms
1579 /** Filters users based on the job terms they used in mentoring.
1580  * @param $val The ID of the job term, or an array of such IDs
1581  */
1582 class UFC_Mentor_Terms extends UserFilterCondition
1583 {
1584     private $val;
1585
1586     public function __construct($val)
1587     {
1588         $this->val = $val;
1589     }
1590
1591     public function buildCondition(PlFilter $uf)
1592     {
1593         $sub = $uf->addMentorFilter(UserFilter::MENTOR_TERM);
1594         return $sub . '.jtid_1 = ' . XDB::escape($this->val);
1595     }
1596 }
1597 // }}}
1598 // {{{ class UFC_UserRelated
1599 /** Filters users based on a relation toward a user
1600  * @param $user User to which searched users are related
1601  */
1602 abstract class UFC_UserRelated extends UserFilterCondition
1603 {
1604     protected $user;
1605     public function __construct(PlUser $user)
1606     {
1607         $this->user =& $user;
1608     }
1609 }
1610 // }}}
1611 // {{{ class UFC_DeltaTen
1612 class UFC_DeltaTen extends UserFilterCondition
1613 {
1614     public function buildCondition(PlFilter $uf)
1615     {
1616         $sub = $uf->addDeltaTenFilter(UserFilter::DELTATEN);
1617         return $sub . '.message IS NOT NULL';
1618     }
1619 }
1620 // }}}
1621 // {{{ class UFC_DeltaTen_Message
1622 /** Filters users by deltaten message
1623  * @param $message Message for the DeltaTen program
1624  */
1625 class UFC_DeltaTen_Message extends UserFilterCondition
1626 {
1627     private $message;
1628
1629     public function __construct($message)
1630     {
1631         $this->message = $message;
1632     }
1633
1634     public function buildCondition(PlFilter $uf)
1635     {
1636         $sub = $uf->addDeltaTenFilter(UserFilter::DELTATEN_MESSAGE);
1637         return $sub . '.message ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->message);
1638     }
1639 }
1640 // }}}
1641 // {{{ class UFC_Contact
1642 /** Filters users who belong to selected user's contacts
1643  */
1644 class UFC_Contact extends UFC_UserRelated
1645 {
1646     public function buildCondition(PlFilter $uf)
1647     {
1648         $sub = $uf->addContactFilter($this->user->id());
1649         return 'c' . $sub . '.contact IS NOT NULL';
1650     }
1651 }
1652 // }}}
1653 // {{{ class UFC_WatchRegistration
1654 /** Filters users being watched by selected user
1655  */
1656 class UFC_WatchRegistration extends UFC_UserRelated
1657 {
1658     public function buildCondition(PlFilter $uf)
1659     {
1660         if (!$this->user->watchType('registration')) {
1661             return PlFilterCondition::COND_FALSE;
1662         }
1663         $uids = $this->user->watchUsers();
1664         if (count($uids) == 0) {
1665             return PlFilterCondition::COND_FALSE;
1666         } else {
1667             return XDB::format('$UID IN {?}', $uids);
1668         }
1669     }
1670 }
1671 // }}}
1672 // {{{ class UFC_WatchPromo
1673 /** Filters users belonging to a promo watched by selected user
1674  * @param $user Selected user (the one watching promo)
1675  * @param $grade Formation the user is watching
1676  */
1677 class UFC_WatchPromo extends UFC_UserRelated
1678 {
1679     private $grade;
1680     public function __construct(PlUser $user, $grade = UserFilter::GRADE_ING)
1681     {
1682         parent::__construct($user);
1683         $this->grade = $grade;
1684     }
1685
1686     public function buildCondition(PlFilter $uf)
1687     {
1688         $promos = $this->user->watchPromos();
1689         if (count($promos) == 0) {
1690             return PlFilterCondition::COND_FALSE;
1691         } else {
1692             $sube = $uf->addEducationFilter(true, $this->grade);
1693             $field = 'pe' . $sube . '.' . UserFilter::promoYear($this->grade);
1694             return XDB::format($field . ' IN {?}', $promos);
1695         }
1696     }
1697 }
1698 // }}}
1699 // {{{ class UFC_WatchContact
1700 /** Filters users watched by selected user
1701  */
1702 class UFC_WatchContact extends UFC_Contact
1703 {
1704     public function buildCondition(PlFilter $uf)
1705     {
1706         if (!$this->user->watchContacts()) {
1707             return PlFilterCondition::COND_FALSE;
1708         }
1709         return parent::buildCondition($uf);
1710     }
1711 }
1712 // }}}
1713 // {{{ class UFC_MarketingHash
1714 /** Filters users using the hash generated
1715  * to send marketing emails to him.
1716  */
1717 class UFC_MarketingHash extends UserFilterCondition
1718 {
1719     private $hash;
1720
1721     public function __construct($hash)
1722     {
1723         $this->hash = $hash;
1724     }
1725
1726     public function buildCondition(PlFilter $uf)
1727     {
1728         $table = $uf->addMarketingHash();
1729         return XDB::format('rm.hash = {?}', $this->hash);
1730     }
1731 }
1732 // }}}
1733
1734 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
1735 ?>