include/ufbuilder.inc.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 // {{{ class UserFilterBuilder
  23 class UserFilterBuilder
  24 {
  25     private $envprefix;
  26     private $fields;
  27     private $valid = true;
  28     private $ufc = null;
  29     private $orders = array();
  30
  31     /** Constructor
  32      * @param $fields An array of UFB_Field objects
  33      * @param $envprefix Prefix to use for parts of the query
  34      */
  35     public function __construct($fields, $envprefix = '')
  36     {
  37         $this->fields = $fields;
  38         $this->envprefix   = $envprefix;
  39     }
  40
  41     /** Builds the UFC; returns as soon as a field says it is invalid
  42      */
  43     private function buildUFC()
  44     {
  45         if ($this->ufc != null) {
  46             return;
  47         }
  48         $this->ufc = new PFC_And();
  49
  50         foreach ($this->fields as $field) {
  51             $this->valid = $field->apply(&$this);
  52             if (!$this->valid) {
  53                 return;
  54             }
  55         }
  56     }
  57
  58     public function addCond(PlFilterCondition &$cond)
  59     {
  60         $this->ufc->addChild($cond);
  61     }
  62
  63     public function addOrder(PlFilterOrder &$order)
  64     {
  65         $this->order[] = $order;
  66     }
  67
  68     public function isValid()
  69     {
  70         $this->buildUFC();
  71         return $this->valid;
  72     }
  73
  74     public function isEmpty()
  75     {
  76         $this->buildUFC();
  77         foreach ($this->fields as $field) {
  78             if (! $field->isEmpty()) {
  79                 return false;
  80             }
  81         }
  82         return true;
  83     }
  84
  85     /** Returns the built UFC
  86      * @return The UFC, or PFC_False() if an error happened
  87      */
  88     public function getUFC()
  89     {
  90         $this->buildUFC();
  91         if ($this->valid) {
  92             return $this->ufc;
  93         } else {
  94             return new PFC_False();
  95         }
  96     }
  97
  98     /** Returns adequate orders
  99      */
 100     public function getOrders()
 101     {
 102         $this->buildUFC();
 103         return $this->orders;
 104     }
 105
 106     /** Wrappers around Env::i/s/..., to add envprefix
 107      */
 108     public function s($key, $def = '')
 109     {
 110         return Env::s($this->envprefix . $key, $def);
 111     }
 112
 113     public function t($key, $def = '')
 114     {
 115         return Env::t($this->envprefix . $key, $def);
 116     }
 117
 118     public function i($key, $def = 0)
 119     {
 120         return Env::i($this->envprefix . $key, $def);
 121     }
 122
 123     public function v($key, $def = null)
 124     {
 125         return Env::v($this->envprefix . $key, $def);
 126     }
 127
 128     public function b($key, $def = false)
 129     {
 130         return Env::b($this->envprefix . $key, $def);
 131     }
 132
 133     public function has($key)
 134     {
 135         return Env::has($this->envprefix . $key);
 136     }
 137
 138     public function blank($key, $strict = false)
 139     {
 140         return Env::blank($key, $strict);
 141     }
 142
 143     public function isOn($key)
 144     {
 145         return $this->has($key) && $this->t($key) == 'on';
 146     }
 147 }
 148 // }}}
 149
 150 // {{{ class UFB_QuickSearch
 151 class UFB_QuickSearch extends UserFilterBuilder
 152 {
 153     public function __construct($envprefix = '')
 154     {
 155         $fields = array(
 156             new UFBF_Quick('quick', 'Recherche rapide'),
 157         );
 158         parent::__construct($fields, $envprefix);
 159     }
 160 }
 161 // }}}
 162
 163 // {{{ class UFB_AdvancedSearch
 164 class UFB_AdvancedSearch extends UserFilterBuilder
 165 {
 166     public function __construct($envprefix = '')
 167     {
 168         $fields = array(
 169             new UFBF_Name('name', 'Nom'),
 170             new UFBF_Promo('promo1', 'Promotion', 'egal1'),
 171             new UFBF_Promo('promo2', 'Promotion', 'egal2'),
 172             new UFBF_Sex('woman', 'Sexe'),
 173             new UFBF_Registered('subscriber', 'Inscrit'),
 174             new UFBF_Dead('alive', 'En vie'),
 175
 176             new UFBF_Town('city', 'Ville / Code Postal'),
 177             new UFBF_Country('countryTxt', 'country', 'Pays'),
 178             new UFBF_AdminArea('region', 'Région'),
 179
 180             new UFBF_JobCompany('entreprise', 'Entreprise'),
 181             new UFBF_JobSector('sector', 'Poste'),
 182             new UFBF_JobDescription('jobdescription', 'Fonction'),
 183             new UFBF_JobCv('cv', 'CV'),
 184
 185             new UFBF_Nationality('nationaliteTxt', 'nationalite', 'Nationalité'),
 186             new UFBF_Binet('binetTxt', 'binet', 'Binet'),
 187             new UFBF_Group('groupexTxt', 'groupex', 'Groupe X'),
 188             new UFBF_Section('sectionTxt', 'section', 'Section'),
 189
 190             new UFBF_EducationSchool('schoolTxt', 'school', "École d'application"),
 191             new UFBF_EducationDegree('diplomaTxt', 'diploma', 'Diplôme'),
 192             new UFBF_EducationField('fieldTxt', 'field', "Domaine d'études"),
 193
 194             new UFBF_Comment('free', 'Commentaire'),
 195             new UFBF_Phone('phone_number', 'Téléphone'),
 196             new UFBF_Networking('networking_address', 'networking_type', 'Networking et sites webs'),
 197         );
 198         parent::__construct($fields, $envprefix);
 199     }
 200 }
 201 // }}}
 202
 203 // {{{ class UFB_MentorSearch
 204 class UFB_MentorSearch extends UserFilterBuilder
 205 {
 206     public function __construct($envprefix = '')
 207     {
 208         $fields = array(
 209             new UFBF_MentorCountry('pays_sel'),
 210             new UFBF_MentorSectorization('sector', '', UFC_Mentor_Sectorization::SECTOR),
 211             new UFBF_MentorSectorization('subSector', '', UFC_Mentor_Sectorization::SUBSECTOR),
 212             new UFBF_MentorExpertise('expertise'),
 213         );
 214         parent::__construct($fields, $envprefix);
 215     }
 216 }
 217 // }}}
 218
 219 // {{{ class UFB_Field
 220 abstract class UFB_Field
 221 {
 222     protected $envfield;
 223     protected $formtext;
 224
 225     protected $empty = false;
 226     protected $val = null;
 227
 228     /** Constructor
 229      * @param $envfield Name of the field in the environment
 230      * @param $formtext User-friendly name of that field
 231      */
 232     public function __construct($envfield, $formtext = '')
 233     {
 234         $this->envfield = $envfield;
 235         if ($formtext != '') {
 236             $this->formtext = $formtext;
 237         } else {
 238             $formtext = ucfirst($envfield);
 239         }
 240     }
 241
 242     /** Prints the given error message to the user, and returns false
 243      * in order to be used as return $this->raise('ERROR');
 244      *
 245      * All %s in the $msg will be replaced with the formtext.
 246      */
 247     protected function raise($msg)
 248     {
 249         Platal::page()->trigError(str_replace('%s', $this->formtext, $msg));
 250         return false;
 251     }
 252
 253     public function apply(UserFilterBuilder &$ufb) {
 254         if (!$this->check($ufb)) {
 255             return false;
 256         }
 257
 258         if (!$this->empty) {
 259             $ufc = $this->buildUFC($ufb);
 260             if ($ufc != null) {
 261                 $ufb->addCond($ufc);
 262             }
 263         }
 264         return true;
 265     }
 266
 267     public function isEmpty()
 268     {
 269         return $this->empty;
 270     }
 271
 272     /** Create the UFC associated to the field; won't be called
 273      * if the field is "empty"
 274      * @param &$ufb UFB to which fields must be added
 275      * @return UFC
 276      */
 277     abstract protected function buildUFC(UserFilterBuilder &$ufb);
 278
 279     /** This function is intended to run consistency checks on the value
 280      * @return boolean Whether the input is valid
 281      */
 282     abstract protected function check(UserFilterBuilder &$ufb);
 283 }
 284 // }}}
 285
 286 // {{{ class UFBF_Text
 287 abstract class UFBF_Text extends UFB_Field
 288 {
 289     private $minlength;
 290     private $maxlength;
 291
 292     public function __construct($envfield, $formtext = '', $minlength = 2, $maxlength = 255)
 293     {
 294         parent::__construct($envfield, $formtext);
 295         $this->minlength      = $minlength;
 296         $this->maxlength      = $maxlength;
 297     }
 298
 299     protected function check(UserFilterBuilder &$ufb)
 300     {
 301         if ($ufb->blank($this->envfield)) {
 302             $this->empty = true;
 303             return true;
 304         }
 305
 306         $this->val = $ufb->t($this->envfield);
 307         if (strlen($this->val) < $this->minlength) {
 308             return $this->raise("Le champ %s est trop court (minimum {$this->minlength}).");
 309         } else if (strlen($this->val) > $this->maxlength) {
 310             return $this->raise("Le champ %s est trop long (maximum {$this->maxlength}).");
 311         } else if (preg_match(":[\]\[<>{}~/§_`|%$^=+]|\*\*:u", $this->val)) {
 312             return $this->raise('Le champ %s contient un caractère interdit rendant la recherche impossible.');
 313         }
 314
 315         return true;
 316     }
 317 }
 318 // }}}
 319
 320 // {{{ class UFBF_Range
 321 /** Subclass to use for fields which only allow integers within a range
 322  */
 323 abstract class UFBF_Range extends UFB_Field
 324 {
 325
 326     private $min;
 327     private $max;
 328
 329     public function __construct($envfield, $formtext = '', $min = 0, $max = 65535)
 330     {
 331         parent::__construct($envfield, $formtext);
 332         $this->min = $min;
 333         $this->max = $max;
 334     }
 335
 336     protected function check(UserFilterBuilder &$ufb)
 337     {
 338         if ($ufb->blank($this->envfield)) {
 339             $this->empty = true;
 340             return true;
 341         }
 342
 343         $this->val = $ufb->i($this->envfield);
 344         if ($this->val < $this->min) {
 345             return $this->raise("Le champs %s est inférieur au minimum ({$this->min}).");
 346         } else if ($this->val > $this->max) {
 347             return $this->raise("Le champ %s est supérieur au maximum ({$this->max}).");
 348         }
 349         return true;
 350     }
 351 }
 352 // }}}
 353
 354 // {{{ class UFBF_Index
 355 /** Subclass to use for indexed fields
 356  */
 357 abstract class UFBF_Index extends UFB_Field
 358 {
 359     protected function check(UserFilterBuilder &$ufb)
 360     {
 361         if ($ufb->blank($this->envfield)) {
 362             $this->empty = true;
 363         }
 364         $this->val = $ufb->i($this->envfield);
 365         return true;
 366     }
 367 }
 368 // }}}
 369
 370 // {{{ class UFBF_Enum
 371 /** Subclass to use for fields whose value must belong to a specific set of values
 372  */
 373 abstract class UFBF_Enum extends UFB_Field
 374 {
 375     protected $allowedvalues;
 376
 377     public function __construct($envfield, $formtext = '', $allowedvalues = array(), $strict = false)
 378     {
 379         parent::__construct($envfield, $formtext);
 380         $this->allowedvalues = $allowedvalues;
 381         $this->strict = $strict;
 382     }
 383
 384     protected function check(UserFilterBuilder &$ufb)
 385     {
 386         if ($ufb->blank($this->envfield)) {
 387             $this->empty = true;
 388             return true;
 389         }
 390
 391         $this->val = $ufb->v($this->envfield);
 392         if (! in_array($this->val, $this->allowedvalues)) {
 393             if ($this->strict) {
 394                 return $this->raise("La valeur {$this->val} n'est pas valide pour le champ %s.");
 395             } else {
 396                 $this->empty = true;
 397             }
 398         }
 399         return true;
 400     }
 401 }
 402 // }}}
 403
 404 // {{{ class UFBF_Bool
 405 abstract class UFBF_Bool extends UFB_Field
 406 {
 407     protected function check(UserFilterBuilder &$ufb)
 408     {
 409         if ($ufb->blank($this->envfield)) {
 410             $this->empty = true;
 411             return true;
 412         }
 413
 414         $this->val = $ufb->b($this->envfield);
 415         return true;
 416     }
 417 }
 418 // }}}
 419
 420 // {{{ class UFBF_Mixed
 421 /** A class for building UFBFs when the user can input either a text or an ID
 422  */
 423 abstract class UFBF_Mixed extends UFB_Field
 424 {
 425     /** Name of the DirEnum on which class is based
 426      */
 427     protected $direnum;
 428
 429     protected $envfieldindex;
 430
 431     public function __construct($envfieldtext, $envfieldindex, $formtext = '')
 432     {
 433         parent::__construct($envfieldtext, $formtext);
 434         $this->envfieldindex = $envfieldindex;
 435     }
 436
 437     protected function check(UserFilterBuilder &$ufb)
 438     {
 439         if ($ufb->blank($this->envfieldindex) && $ufb->blank($this->envfield)) {
 440             $this->empty = true;
 441             return true;
 442         }
 443
 444         if (!$ufb->blank($this->envfieldindex)) {
 445             $index = $ufb->v($this->envfieldindex);
 446             if (is_int($index)) {
 447                 $index = intval($index);
 448             } else {
 449                 $index = strtoupper($index);
 450             }
 451             $this->val = array($index);
 452         } else {
 453             $indexes = DirEnum::getIDs($this->direnum, $ufb->t($this->envfield),
 454                 $ufb->b('exact') ? XDB::WILDCARD_EXACT : XDB::WILDCARD_CONTAINS);
 455             if (count($indexes) == 0) {
 456                 return false;
 457             }
 458             $this->val = $indexes;
 459         }
 460         return true;
 461     }
 462 }
 463 // }}}
 464
 465 // {{{ class UFBF_Quick
 466 class UFBF_Quick extends UFB_Field
 467 {
 468     protected function check(UserFilterBuilder &$ufb)
 469     {
 470         if ($ufb->blank($this->envfield)) {
 471             $this->empty = true;
 472             return true;
 473         }
 474
 475         $this->val = str_replace('*', '%', replace_accent($ufb->t($this->envfield)));
 476
 477         return true;
 478     }
 479
 480     protected function buildUFC(UserFilterBuilder &$ufb)
 481     {
 482
 483         $r = $s = $this->val;
 484
 485         /** Admin: Email, IP
 486          */
 487         if (S::admin() && strpos($s, '@') !== false) {
 488             return new UFC_Email($s);
 489         } else if (S::admin() && preg_match('/[0-9]+\.([0-9]+|%)\.([0-9]+|%)\.([0-9]+|%)/', $s)) {
 490             $this->conds->addChild(new UFC_Ip($s));
 491             return;
 492         }
 493
 494         $conds = new PFC_And();
 495
 496         /** Name
 497          */
 498         $s = preg_replace('!\d+!', ' ', $s);
 499         $strings = preg_split("![^a-zA-Z%]+!",$s, -1, PREG_SPLIT_NO_EMPTY);
 500         if (count($strings) > 5) {
 501             Platal::page()->trigWarning("Tu as indiqué trop d'éléments dans ta recherche, seuls les 5 premiers seront pris en compte");
 502             $strings = array_slice($strings, 0, 5);
 503         }
 504
 505         if (count($strings)) {
 506             if (S::logged()) {
 507                 $flags = array();
 508             } else {
 509                 $flags = array('public');
 510             }
 511             if ($ufb->b('with_soundex')) {
 512                 $soundex = true;
 513                 $st = array();
 514                 foreach ($strings as $string) {
 515                     $st[] = soundex_fr($string);
 516                 }
 517             } else {
 518                 $soundex = false;
 519                 $st = $strings;
 520             }
 521             $exact =$ufb->b('exact');
 522             $conds->addChild(new UFC_NameTokens($st, $flags, $soundex, $exact));
 523
 524             $ufb->addOrder(new UFO_Score());
 525         }
 526
 527         /** Promo ranges
 528          */
 529         $s = preg_replace('! *- *!', '-', $r);
 530         $s = preg_replace('!([<>]) *!', ' \1', $s);
 531         $s = preg_replace('![^0-9\-><]!', ' ', $s);
 532         $s = preg_replace('![<>\-] !', '', $s);
 533         $ranges = preg_split('! +!', $s, -1, PREG_SPLIT_NO_EMPTY);
 534         foreach ($ranges as $r) {
 535             if (preg_match('!^\d{4}$!', $r)) {
 536                 $conds->addChild(new UFC_Promo('=', UserFilter::DISPLAY, 'X' . $r));
 537             } elseif (preg_match('!^(\d{4})-(\d{4})$!', $r, $matches)) {
 538                 $p1=min(intval($matches[1]), intval($matches[2]));
 539                 $p2=max(intval($matches[1]), intval($matches[2]));
 540                 $conds->addChild(new PFC_And(
 541                     new UFC_Promo('>=', UserFilter::DISPLAY, 'X' . $p1),
 542                     new UFC_Promo('<=', UserFilter::DISPLAY, 'X' . $p2)
 543                 ));
 544             } elseif (preg_match('!^<(\d{4})!', $r, $matches)) {
 545                 $conds->addChild(new UFC_Promo('<=', UserFilter::DISPLAY, 'X' . $matches[1]));
 546             } elseif (preg_match('!^>(\d{4})!', $r, $matches)) {
 547                 $conds->addChild(new UFC_Promo('>=', UserFilter::DISPLAY, 'X' . $matches[1]));
 548             }
 549         }
 550
 551         /** Phone number
 552          */
 553         $t = preg_replace('!(\d{4}-\d{4}|>\d{4}|<\d{4})!', '', $s);
 554         $t = preg_replace('![<>\- ]!', '', $t);
 555         if (strlen($t) > 4) {
 556             $conds->addChild(new UFC_Phone($t));
 557         }
 558
 559         return $conds;
 560     }
 561 }
 562 // }}}
 563
 564 // {{{ class UFBF_Name
 565 class UFBF_Name extends UFBF_Text
 566 {
 567     protected function check(UserFilterBuilder &$ufb)
 568     {
 569         if (!parent::check($ufb)) {
 570             return false;
 571         }
 572
 573         $this->val = preg_split('/[[:space:]]/', $this->val);
 574         if (count($this->val) == 0) {
 575             $this->empty = true;
 576         }
 577         return true;
 578     }
 579
 580     protected function buildUFC(UserFilterBuilder &$ufb)
 581     {
 582         return new UFC_NameTokens($this->val, array(), $ufb->b('with_soundex'), $ufb->b('exact'));
 583     }
 584 }
 585 // }}}
 586
 587 // {{{ class UFBF_Promo
 588 class UFBF_Promo extends UFB_Field
 589 {
 590     private static $validcomps = array('<', '<=', '=', '>=', '>');
 591     private $comp;
 592     private $envfieldcomp;
 593
 594     public function __construct($envfield, $fromtext = '', $envfieldcomp)
 595     {
 596         parent::__construct($envfield, $fromtext);
 597         $this->envfieldcomp = $envfieldcomp;
 598     }
 599
 600     protected function check(UserFilterBuilder &$ufb)
 601     {
 602         if ($ufb->blank($this->envfield) || $ufb->blank($this->envfieldcomp)) {
 603             $this->empty = true;
 604             return true;
 605         }
 606
 607         $this->val  = $ubf->i($this->envfield);
 608         $this->comp = $ubf->v($this->envfieldcomp);
 609
 610         if (!in_array($this->comp, self::$validcomps)) {
 611             return $this->raise("Le critère {$this->comp} n'est pas valide pour le champ %s");
 612         }
 613
 614         if (preg_match('/^[0-9]{2}$/', $this->val)) {
 615             $this->val += 1900;
 616         }
 617         if ($this->val < 1900 || $this->val > 9999) {
 618             return $this->raise("Le champ %s doit être une année à 4 chiffres.");
 619         }
 620         return true;
 621     }
 622
 623     protected function buildUFC(UserFilterBuilder &$ufb) {
 624         return new UFC_Promo($this->comp, UserFilter::DISPLAY, 'X' . $this->val);
 625     }
 626 }
 627 // }}}
 628
 629 // {{{ class UFBF_Sex
 630 class UFBF_Sex extends UFBF_Enum
 631 {
 632     public function __construct($envfield, $formtext = '')
 633     {
 634         parent::__construct($envfield, $formtext, array(1, 2));
 635     }
 636
 637     private static function getVal($id)
 638     {
 639         switch($id) {
 640         case 1:
 641             return User::GENDER_MALE;
 642             break;
 643         case 2:
 644             return User::GENDER_FEMALE;
 645             break;
 646         }
 647     }
 648
 649     protected function buildUFC(UserFilterBuilder &$ufb)
 650     {
 651         return new UFC_Sex(self::getVal($this->val));
 652     }
 653 }
 654 // }}}
 655
 656 // {{{ class UFBF_Registered
 657 class UFBF_Registered extends UFBF_Enum
 658 {
 659     public function __construct($envfield, $formtext = '')
 660     {
 661         parent::__construct($envfield, $formtext, array(1, 2));
 662     }
 663
 664     protected function buildUFC(UserFilterBuilder &$ufb)
 665     {
 666         if ($this->val == 1) {
 667             return new UFC_Registered();
 668         } else if ($this->val == 2) {
 669             return new PFC_Not(UFC_Registered());
 670         }
 671     }
 672 }
 673 // }}}
 674
 675 // {{{ class UFBF_Dead
 676 class UFBF_Dead extends UFBF_Enum
 677 {
 678     public function __construct($envfield, $formtext = '')
 679     {
 680         parent::__construct($envfield, $formtext, array(1, 2));
 681     }
 682
 683     protected function buildUFC(UserFilterBuilder &$ufb)
 684     {
 685         if ($this->val == 1) {
 686             return new PFC_Not(UFC_Dead());
 687         } else if ($this->val == 2) {
 688             return new UFC_Dead();
 689         }
 690     }
 691 }
 692 // }}}
 693
 694 // {{{ class UFBF_Town
 695 /** Retrieves a town, either from a postal code or a town name
 696  */
 697 class UFBF_Town extends UFBF_Text
 698 {
 699     const TYPE_TEXT = 1;
 700     const TYPE_ZIP  = 2;
 701     const TYPE_ANY  = 3;
 702
 703     private $type;
 704     private $onlycurrentfield;
 705
 706     public function __construct($envfield, $formtext = '', $type = self::TYPE_ANY, $onlycurrentfield = 'only_current')
 707     {
 708         $this->type = $type;
 709         $this->onlycurrentfield = $onlycurrentfield;
 710         parent::__construct($envfield, $formtext, 2, 30);
 711     }
 712
 713     protected function buildUFC(UserFilterBuilder &$ufb)
 714     {
 715         if ($ufb->isOn($this->onlycurrentfield)) {
 716             $flags = UFC_Address::FLAG_CURRENT;
 717         } else {
 718             $flags = UFC_Address::FLAG_ANY;
 719         }
 720
 721         if (preg_match('/[0-9]/', $this->val)) {
 722             if ($this->type & self::TYPE_ZIP) {
 723                 return new UFC_AddressField($this->val, UFC_AddressField::FIELD_ZIPCODE, UFC_Address::TYPE_ANY, $flags);
 724             } else {
 725                 return new PFC_False();
 726             }
 727         } else {
 728             $byname = new UFC_AddressText(null, UFC_Address::CONTAINS, UFC_Address::TYPE_ANY, $flags, null, $this->val);
 729             $byzip  = new UFC_AddressField($this->val, UFC_AddressField::FIELD_ZIPCODE, UFC_Address::TYPE_ANY, $flags);
 730             if ($this->type & self::TYPE_ANY) {
 731                 return new PFC_Or($byname, $byzip);
 732             } else if ($this->type & self::TYPE_TEXT) {
 733                 return $byname;
 734             } else {
 735                 return $byzip;
 736             }
 737         }
 738     }
 739 }
 740 // }}}
 741
 742 // {{{ class UFBF_Country
 743 class UFBF_Country extends UFBF_Mixed
 744 {
 745     protected $direnum = DirEnum::COUNTRIES;
 746     protected $onlycurrentfield;
 747
 748     public function __construct($envfieldtext, $envfieldindex, $formtext = '', $onlycurrentfield = 'only_current')
 749     {
 750         parent::__construct($envfieldtext, $envfieldindex, $formtext);
 751         $this->onlycurrentfield = $onlycurrentfield;
 752     }
 753
 754     protected function buildUFC(UserFilterBuilder &$ufb)
 755     {
 756         if ($ufb->isOn($this->onlycurrentfield)) {
 757             $flags = UFC_Address::FLAG_CURRENT;
 758         } else {
 759             $flags = UFC_Address::FLAG_ANY;
 760         }
 761
 762         return new UFC_AddressField($this->val, UFC_AddressField::FIELD_COUNTRY, UFC_Address::TYPE_ANY, $flags);
 763     }
 764 }
 765 // }}}
 766
 767 // {{{ class UFBF_AdminArea
 768 class UFBF_AdminArea extends UFBF_Mixed
 769 {
 770     protected $direnum = DirEnum::ADMINAREAS;
 771     protected $onlycurrentfield;
 772
 773     public function __construct($envfieldtext, $envfieldindex, $formtext = '', $onlycurrentfield = 'only_current')
 774     {
 775         parent::__construct($envfieldtext, $envfieldindex, $formtext);
 776         $this->onlycurrentfield = $onlycurrentfield;
 777     }
 778
 779
 780     protected function buildUFC(UserFilterBuilder &$ufb)
 781     {
 782         if ($ufb->isOn($this->onlycurrentfield)) {
 783             $flags = UFC_Address::FLAG_CURRENT;
 784         } else {
 785             $flags = UFC_Address::FLAG_ANY;
 786         }
 787
 788         return new UFC_AddressField($this->val, UFC_AddressField::FIELD_ADMAREA, UFC_Address::TYPE_ANY, $flags);
 789     }
 790 }
 791 // }}}
 792
 793 // {{{ class UFBF_JobCompany
 794 class UFBF_JobCompany extends UFBF_Text
 795 {
 796     private $onlymentorfield;
 797
 798     public function __construct($envfield, $formtext = '', $onlymentorfield = 'only_referent')
 799     {
 800         parent::__construct($envfield, $formtext);
 801         $this->onlymentorfield = $onlymentorfield;
 802     }
 803
 804     public function check(UserFilterBuilder &$ufb) {
 805         if (parent::check($ufb)) {
 806             # No company check for mentors
 807            if ($ufb->isOn($this->onlymentorfield)) {
 808                 $this->empty = true;
 809            }
 810            return true;
 811         } else {
 812             return false;
 813         }
 814     }
 815
 816     protected function buildUFC(UserFilterBuilder &$ufb)
 817     {
 818         return new UFC_Job_Company(UFC_Job_Company::JOBNAME, $this->val);
 819     }
 820 }
 821 // }}}
 822
 823 // {{{ class UFBF_JobSector
 824 class UFBF_JobSector extends UFBF_Mixed
 825 {
 826     protected $direnum = DirEnum::SECTORS;
 827     private $onlymentorfield;
 828
 829     public function __construct($envfieldtext, $envfieldindex, $formtext = '', $onlymentorfield = 'only_referent')
 830     {
 831         parent::__construct($envfieldtext, $envfieldindex, $formtext);
 832         $this->onlymentorfield = $onlymentorfield;
 833     }
 834
 835     protected function buildUFC(UserFilterBuilder &$ufb)
 836     {
 837         if ($ufb->isOn($this->onlymentorfield)) {
 838             return new UFC_Mentor_Sectorization($this->val, UserFilter::JOB_SUBSECTOR);
 839         } else {
 840             return new UFC_Job_Sectorization($this->val, UserFilter::JOB_SUBSUBSECTOR);
 841         }
 842     }
 843 }
 844 // }}}
 845
 846 // {{{ class UFBF_JobDescription
 847 class UFBF_JobDescription extends UFBF_Text
 848 {
 849     private $onlymentorfield;
 850
 851     public function __construct($envfield, $formtext = '', $onlymentorfield = 'only_referent')
 852     {
 853         parent::__construct($envfield, $formtext);
 854         $this->onlymentorfield = $onlymentorfield;
 855     }
 856
 857     protected function buildUFC(UserFilterBuilder &$ufb)
 858     {
 859         if ($ufb->isOn($this->onlymentorfield)) {
 860             return new UFC_Mentor_Expertise($this->val);
 861         } else {
 862             return new UFC_Job_Description($this->val, UserFilter::JOB_USERDEFINED);
 863         }
 864     }
 865 }
 866 // }}}
 867
 868 // {{{ class UFBF_JobCv
 869 class UFBF_JobCv extends UFBF_Text
 870 {
 871     private $onlymentorfield;
 872
 873     public function __construct($envfield, $formtext = '', $onlymentorfield = 'only_referent')
 874     {
 875         parent::__construct($envfield, $formtext);
 876         $this->onlymentorfield = $onlymentorfield;
 877     }
 878
 879     protected function buildUFC(UserFilterBuilder &$ufb)
 880     {
 881         if ($ufb->isOn($this->onlymentorfield)) {
 882             return new UFC_Mentor_Expertise($this->val);
 883         } else {
 884             return new UFC_Job_Description($this->val, UserFilter::JOB_CV);
 885         }
 886     }
 887 }
 888 // }}}
 889
 890 // {{{ class UFBF_Nationality
 891 class UFBF_Nationality extends UFBF_Mixed
 892 {
 893     protected $direnum = DirEnum::NATIONALITIES;
 894
 895     protected function buildUFC(UserFilterBuilder &$ufb)
 896     {
 897         return new UFC_Nationality($this->val);
 898     }
 899 }
 900 // }}}
 901
 902 // {{{ class UFBF_Binet
 903 class UFBF_Binet extends UFBF_Mixed
 904 {
 905     protected $direnum = DirEnum::BINETS;
 906
 907     protected function buildUFC(UserFilterBuilder &$ufb)
 908     {
 909         return new UFC_Binet($this->val);
 910     }
 911 }
 912 // }}}
 913
 914 // {{{ class UFBF_Group
 915 class UFBF_Group extends UFBF_Mixed
 916 {
 917     protected $direnum = DirEnum::GROUPESX;
 918
 919     protected function buildUFC(UserFilterBuilder &$ufb)
 920     {
 921         if (count($this->val) == 1) {
 922             return new UFC_Group($this->val[0]);
 923         }
 924
 925         $or = new PFC_Or();
 926         foreach ($this->val as $grp) {
 927             $or->addChild(new UFC_Group($grp));
 928         }
 929         return $or;
 930     }
 931 }
 932 // }}}
 933
 934 // {{{ class UFBF_Section
 935 class UFBF_Section extends UFBF_Index
 936 {
 937     protected $direnum = DirEnum::SECTIONS;
 938
 939     protected function buildUFC(UserFilterBuilder &$ufb)
 940     {
 941         return new UFC_Section($this->val);
 942     }
 943 }
 944 // }}}
 945
 946 // {{{ class UFBF_EducationSchool
 947 class UFBF_EducationSchool extends UFBF_Mixed
 948 {
 949     protected $direnum = DirEnum::EDUSCHOOLS;
 950
 951     protected function buildUFC(UserFilterBuilder &$ufb)
 952     {
 953         return new UFC_EducationSchool($this->val);
 954     }
 955 }
 956 // }}}
 957
 958 // {{{ class UFBF_EducationDegree
 959 class UFBF_EducationDegree extends UFBF_Mixed
 960 {
 961     protected $direnum = DirEnum::EDUDEGREES;
 962
 963     protected function buildUFC(UserFilterBuilder &$ufb)
 964     {
 965         return new UFC_EducationDegree($this->val);
 966     }
 967 }
 968 // }}}
 969
 970 // {{{ class UFBF_EducationField
 971 class UFBF_EducationField extends UFBF_Mixed
 972 {
 973     protected $direnum = DirEnum::EDUFIELDS;
 974
 975     protected function buildUFC(UserFilterBuilder &$ufb)
 976     {
 977         return new UFC_EducationField($this->val);
 978     }
 979 }
 980 // }}}
 981
 982 // {{{ class UFBF_Comment
 983 class UFBF_Comment extends UFBF_Text
 984 {
 985     protected function buildUFC(UserFilterBuilder &$ufb)
 986     {
 987         return new UFC_Comment($this->val);
 988     }
 989 }
 990 // }}}
 991
 992 // {{{ class UFBF_Phone
 993 class UFBF_Phone extends UFBF_Text
 994 {
 995     protected function buildUFC(UserFilterBuilder &$ufb)
 996     {
 997         return new UFC_Phone($this->val);
 998     }
 999 }
1000 // }}}
1001
1002 // {{{ class UFBF_Networking
1003 class UFBF_Networking extends UFBF_Text
1004 {
1005     private $networktypefield;
1006     private $nwtype;
1007
1008     public function __construct($envfield, $networktypefield, $formtext = '')
1009     {
1010         parent::__construct($envfield, $formtext);
1011         $this->networktypefield  = $networktypefield;
1012     }
1013
1014     public function check(UserFilterBuilder &$ufb)
1015     {
1016         if (parent::check($ufb)) {
1017             $this->nwtype = $ufb->i($this->networktypefield);
1018             return true;
1019         } else {
1020             return false;
1021         }
1022     }
1023
1024     public function buildUFC(UserFilterBuilder &$ufb)
1025     {
1026         return new UFC_Networking($this->nwtype, $this->val);
1027     }
1028 }
1029 // }}}
1030
1031 // {{{ class UFBF_MentorCountry
1032 class UFBF_MentorCountry extends UFBF_Index
1033 {
1034     protected function buildUFC(UserFilterBuilder &$ufb)
1035     {
1036         return new UFC_Mentor_Country($this->val);
1037     }
1038 }
1039 // }}}
1040
1041 // {{{ class UFBF_MentorSectorization
1042 class UFBF_MentorSectorization extends UFBF_Index
1043 {
1044     protected $type;
1045
1046     public function __construct($envfield, $formtext = '', $type = UFC_Mentor_Sectorization::SECTOR)
1047     {
1048         parent::__construct($envfield, $formtext);
1049         $this->type = $type;
1050     }
1051
1052     protected function buildUFC(UserFilterBuilder &$ufb)
1053     {
1054         return new UFC_Mentor_Sectorization($this->val, $this->type);
1055     }
1056 }
1057 // }}}
1058
1059 // {{{ class UFBF_MentorExpertise
1060 class UFBF_MentorExpertise extends UFBF_Text
1061 {
1062     protected function buildUFC(UserFilterBuilder &$ufb)
1063     {
1064         return new UFC_Mentor_Expertise($this->val);
1065     }
1066 }
1067 // }}}
1068
1069 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
1070 ?>