modules/search/classes.inc.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2008 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 // {{{ Global variables used for the search Queries
  23
  24 @$globals->search->result_fields = '
  25     u.user_id, u.promo, u.matricule, u.matricule_ax,
  26     if(u.nom_usage=\'\', u.nom, u.nom_usage) AS NomSortKey,
  27     u.nom_usage,u.date,
  28     u.deces!=0 AS dcd,u.deces,
  29     u.perms IN (\'admin\',\'user\', \'disabled\') AS inscrit,
  30     u.perms != \'pending\' AS wasinscrit,
  31     FIND_IN_SET(\'femme\', u.flags) AS sexe,
  32     ede0.name AS eduname0, ede0.url AS eduurl0, edd0.degree AS edudegree0,
  33     edu0.grad_year AS edugrad_year0, f0.field AS edufield0, edu0.program AS eduprogram0,
  34     ede1.name AS eduname1, ede1.url AS eduurl1, edd1.degree AS edudegree1,
  35     edu1.grad_year AS edugrad_year1, f1.field AS edufield1, edu1.program AS eduprogram1,
  36     ede2.name AS eduname2, ede2.url AS eduurl2, edd2.degree AS edudegree2,
  37     edu2.grad_year AS edugrad_year2, f2.field AS edufield2, edu2.program AS eduprogram2,
  38     ede3.name AS eduname3, ede3.url AS eduurl3, edd3.degree AS edudegree3,
  39     edu3.grad_year AS edugrad_year3, f3.field AS edufield3, edu3.program AS eduprogram3,
  40     es.label AS secteur, ef.fonction_fr AS fonction,
  41     IF(n1.nat=\'\',n1.pays,n1.nat) AS nat1, n1.a2 AS iso3166_1,
  42     IF(n2.nat=\'\',n2.pays,n2.nat) AS nat2, n2.a2 AS iso3166_2,
  43     IF(n3.nat=\'\',n3.pays,n3.nat) AS nat3, n3.a2 AS iso3166_3,
  44     (COUNT(em.email) > 0 OR FIND_IN_SET("googleapps", u.mail_storage) > 0) AS actif,';
  45 // hide private information if not logged
  46 if (S::logged())
  47     $globals->search->result_fields .='
  48         q.profile_freetext AS freetext,
  49         adr.city, gp.pays AS countrytxt, gr.name AS region,
  50         e.entreprise,
  51         nw.address AS networking_address,
  52         nwe.name AS networking_name,';
  53 else
  54     $globals->search->result_fields .="
  55         IF(q.profile_freetext_pub='public', q.profile_freetext, '') AS freetext,
  56         IF(adr.pub='public', adr.city, '')   AS city,
  57         IF(adr.pub='public', gp.pays, '')    AS countrytxt,
  58         IF(adr.pub='public', gr.name, '')    AS region,
  59         IF(e.pub='public', e.entreprise, '') AS entreprise,
  60         IF(nw.pub='public', nw.address, '')  AS networking_address,
  61         IF(nw.pub='public', nwe.name, '')    AS networking_name,";
  62 @$globals->search->result_where_statement = '
  63     LEFT JOIN  profile_education             AS edu0 ON (u.user_id = edu0.uid AND edu0.id = 0)
  64     LEFT JOIN  profile_education_enum        AS ede0 ON (ede0.id = edu0.eduid)
  65     LEFT JOIN  profile_education_degree_enum AS edd0 ON (edd0.id = edu0.degreeid)
  66     LEFT JOIN  profile_education_field_enum  AS f0   ON (f0.id = edu0.fieldid)
  67     LEFT JOIN  profile_education             AS edu1 ON (u.user_id = edu1.uid AND edu1.id = 1)
  68     LEFT JOIN  profile_education_enum        AS ede1 ON (ede1.id = edu1.eduid)
  69     LEFT JOIN  profile_education_degree_enum AS edd1 ON (edd1.id = edu1.degreeid)
  70     LEFT JOIN  profile_education_field_enum  AS f1   ON (f1.id = edu1.fieldid)
  71     LEFT JOIN  profile_education             AS edu2 ON (u.user_id = edu2.uid AND edu2.id = 2)
  72     LEFT JOIN  profile_education_enum        AS ede2 ON (ede2.id = edu2.eduid)
  73     LEFT JOIN  profile_education_degree_enum AS edd2 ON (edd2.id = edu2.degreeid)
  74     LEFT JOIN  profile_education_field_enum  AS f2   ON (f2.id = edu2.fieldid)
  75     LEFT JOIN  profile_education             AS edu3 ON (u.user_id = edu3.uid AND edu3.id = 3)
  76     LEFT JOIN  profile_education_enum        AS ede3 ON (ede3.id = edu3.eduid)
  77     LEFT JOIN  profile_education_degree_enum AS edd3 ON (edd3.id = edu3.degreeid)
  78     LEFT JOIN  profile_education_field_enum  AS f3   ON (f3.id = edu3.fieldid)
  79     LEFT JOIN  entreprises                   AS e    ON (e.entrid = 0 AND e.uid = u.user_id)
  80     LEFT JOIN  emploi_secteur                AS es   ON (e.secteur = es.id)
  81     LEFT JOIN  fonctions_def                 AS ef   ON (e.fonction = ef.id)
  82     LEFT JOIN  geoloc_pays                   AS n1   ON (u.nationalite = n1.a2)
  83     LEFT JOIN  geoloc_pays                   AS n2   ON (u.nationalite2 = n2.a2)
  84     LEFT JOIN  geoloc_pays                   AS n3   ON (u.nationalite3 = n3.a2)
  85     LEFT JOIN  adresses                      AS adr  ON (u.user_id = adr.uid AND FIND_IN_SET(\'active\',adr.statut))
  86     LEFT JOIN  geoloc_pays                   AS gp   ON (adr.country = gp.a2)
  87     LEFT JOIN  geoloc_region                 AS gr   ON (adr.country = gr.a2 AND adr.region = gr.region)
  88     LEFT JOIN  emails                        AS em   ON (em.uid = u.user_id AND em.flags = \'active\')
  89     LEFT JOIN  profile_networking            AS nw   ON (nw.uid = u.user_id)
  90     LEFT JOIN  profile_networking_enum       AS nwe  ON (nwe.network_type = nw.network_type)';
  91
  92 // }}}
  93 // {{{ class ThrowError
  94
  95 /** handle errors for end-users queries
  96  * assign the error message and runs the templates
  97  *
  98  * @author Jean-Sebastien Bedo
  99  */
 100 class ThrowError
 101 {
 102     public static $throwHook = array('ThrowError', 'defaultHandler');
 103
 104     /** constuctor
 105      * @param  $explain string  the error (in natural language)
 106      */
 107     public function __construct($explain)
 108     {
 109         call_user_func(ThrowError::$throwHook, $explain);
 110     }
 111
 112     /** defaut error handler
 113      */
 114     private static function defaultHandler($explain)
 115     {
 116         global $globals;
 117         $page =& Platal::page();
 118         $page->changeTpl('search/index.tpl');
 119         $page->setTitle('Polytechnique.org - Annuaire');
 120         $page->assign('baseurl', $globals->baseurl);
 121         $page->trigError($explain);
 122         $page->run();
 123     }
 124 }
 125
 126 // }}}
 127 // {{{ class SField                                     [Base class]
 128
 129 /** classe de base représentant un champ de recherche
 130  * (correspond à un champ du formulaire mais peut être à plusieurs champs de la bdd)
 131  * interface étendue pour chaque type de champ particulier
 132  */
 133 class SField
 134 {
 135     // {{{ properties
 136
 137     /** le nom du champ dans le formulaire HTML */
 138     var $fieldFormName;
 139     /** champs de la bdd correspondant à ce champ sous forme d'un tableau */
 140     var $fieldDbName;
 141     /** champ résultat dans la requête MySQL correspondant à ce champ
 142      * (alias utilisé pour la clause ORDER BY) */
 143     var $fieldResultName;
 144     /** valeur du champ instanciée par l'utilisateur */
 145     var $value;
 146
 147     // }}}
 148     // {{{ constructor
 149
 150     /** constructeur
 151      * (récupère la requête de l'utilisateur pour ce champ) */
 152     function SField($_fieldFormName, $_fieldDbName='', $_fieldResultName='')
 153     {
 154         $this->fieldFormName   = $_fieldFormName;
 155         $this->fieldDbName     = $_fieldDbName;
 156         $this->fieldResultName = $_fieldResultName;
 157         $this->get_request();
 158     }
 159
 160     // }}}
 161     // {{{ function get_request()
 162
 163     /** récupérer la requête de l'utilisateur
 164      * on met une chaîne vide si le champ n'a pas été complété */
 165     function get_request()
 166     {
 167         $this->value = trim(Env::v($this->fieldFormName));
 168     }
 169
 170     // }}}
 171     // {{{ function get_where_statement()
 172
 173     /** récupérer la clause correspondant au champ dans la clause WHERE de la requête
 174      * on parcourt l'ensemble des champs de la bdd de $fieldDbName et on associe
 175      * à chacun d'entre eux une clause spécifique
 176      * la clause totale et la disjonction de ces clauses spécifiques */
 177     function get_where_statement()
 178     {
 179         if ($this->value=='') {
 180             return false;
 181         }
 182         $res = implode(' OR ', array_filter(array_map(array($this, 'get_single_where_statement'), $this->fieldDbName)));
 183         return empty($res) ? '' : "($res)";
 184     }
 185
 186     // }}}
 187     // {{{ function get_order_statement()
 188
 189     /** récupérer la clause correspondant au champ dans la clause ORDER BY de la requête
 190      * utilisé par exemple pour placer d'abord le nom égal à la requête avant les approximations */
 191     function get_order_statement()
 192     {
 193         return false;
 194     }
 195
 196     // }}}
 197     // {{{ function get_select_statement()
 198
 199     function get_select_statement()
 200     {
 201         return false;
 202     }
 203
 204     // }}}
 205     // {{{ function get_url()
 206
 207     /** récupérer le bout d'URL correspondant aux paramètres permettant d'imiter une requête d'un
 208      * utilisateur assignant la valeur $this->value à ce champ */
 209     function get_url()
 210     {
 211         if (empty($this->value)) {
 212             return false;
 213         } else {
 214             return $this->fieldFormName.'='.urlencode($this->value);
 215         }
 216     }
 217
 218     // }}}
 219 }
 220
 221 // }}}
 222 // {{{ class QuickSearch                                [Google Like]
 223
 224 class QuickSearch extends SField
 225 {
 226     // {{{ properties
 227
 228     /** stores tokens */
 229     var $strings;
 230     /** stores numerical ranges */
 231     var $ranges;
 232     /** stores admin searches */
 233     var $email;
 234     var $ip;
 235     /** stores phone number */
 236     var $phone;
 237
 238     // }}}
 239     // {{{ constructor
 240
 241     function QuickSearch($_fieldFormName)
 242     {
 243         $this->fieldFormName = $_fieldFormName;
 244         $this->get_request();
 245         if (preg_match(":[\]\[{}~/§_`|%$^=+]|\*\*:u", $this->value)) {
 246             new ThrowError('Un champ contient un caractère interdit rendant la recherche impossible.');
 247         }
 248     }
 249
 250     // }}}
 251     // {{{ function isempty()
 252
 253     function isempty()
 254     {
 255         return empty($this->strings) && empty($this->ranges) && empty($this->email) && empty($this->ip) && empty($this->phone);
 256     }
 257
 258     // }}}
 259     // {{{ function get_request()
 260
 261     function get_request()
 262     {
 263         parent::get_request();
 264         $s = replace_accent(trim($this->value));
 265         $r = $s = str_replace('*','%',$s);
 266
 267         if (S::has_perms() && strpos($s, '@') !== false) {
 268             $this->email = $s;
 269         } else if (S::has_perms() && preg_match('/[0-9]+\.([0-9]+|%)\.([0-9]+|%)\.([0-9]+|%)/', $s)) {
 270             $this->ip = $s;
 271         }
 272         if ($this->email || $this->ip) {
 273             $this->strings = $this->ranges = array();
 274             return;
 275         }
 276
 277         $s = preg_replace('!\d+!', ' ', $s);
 278         $this->strings = preg_split("![^a-zA-Z%]+!",$s, -1, PREG_SPLIT_NO_EMPTY);
 279         if (count($this->strings) > 5) {
 280             Platal::page()->trigWarning("Tu as indiqué trop d'éléments dans ta recherche, seuls les 5 premiers seront pris en compte");
 281             $this->strings = array_slice($this->strings, 0, 5);
 282         }
 283
 284         $s = preg_replace('! *- *!', '-', $r);
 285         $s = preg_replace('!([<>]) *!', ' \1', $s);
 286         $s = preg_replace('![^0-9\-><]!', ' ', $s);
 287         $s = preg_replace('![<>\-] !', '', $s);
 288         $ranges = preg_split('! +!', $s, -1, PREG_SPLIT_NO_EMPTY);
 289         $this->ranges=Array();
 290         foreach ($ranges as $r) {
 291             if (preg_match('!^([<>]\d{4}|\d{4}(-\d{4})?)$!', $r)) $this->ranges[] = $r;
 292         }
 293
 294         $t = preg_replace('!(\d{4}-\d{4}|>\d{4}|<\d{4})!', '', $s);
 295         $t = preg_replace('![<>\- ]!', '', $t);
 296         if (strlen($t) > 4) {
 297             $this->phone = $t;
 298         }
 299     }
 300
 301     // }}}
 302     // {{{ function get_where_statement()
 303
 304     function get_where_statement()
 305     {
 306         $where = Array();
 307         foreach ($this->strings as $i => $s) {
 308             if (Env::i('with_soundex') && strlen($s) > 1) {
 309                 $t = soundex_fr($s);
 310                 $where[] = "sn$i.soundex = '$t'";
 311             } elseif (Env::i('exact')) {
 312                 $where[] = "sn$i.token = '$s'";
 313             } else {
 314                 $t = str_replace('*', '%', $s).'%';
 315                 $t = str_replace('%%', '%', $t);
 316                 $where[] = "sn$i.token LIKE '$t'";
 317             }
 318         }
 319
 320         $wherep = Array();
 321         foreach ($this->ranges as $r) {
 322             if (preg_match('!^\d{4}$!', $r)) {
 323                 $wherep[] = "u.promo=$r";
 324             } elseif (preg_match('!^(\d{4})-(\d{4})$!', $r, $matches)) {
 325                 $p1=min(intval($matches[1]), intval($matches[2]));
 326                 $p2=max(intval($matches[1]), intval($matches[2]));
 327                 $wherep[] = "(u.promo>=$p1 AND u.promo<=$p2)";
 328             } elseif (preg_match('!^<(\d{4})!', $r, $matches)) {
 329                 $wherep[] = "u.promo<={$matches[1]}";
 330             } elseif (preg_match('!^>(\d{4})!', $r, $matches)) {
 331                 $wherep[] = "u.promo>={$matches[1]}";
 332             }
 333         }
 334         if (!empty($wherep)) {
 335             $where[] = '('.join(' OR ',$wherep).')';
 336         }
 337         if (!empty($this->email)) {
 338             $where[] = 'ems.email = ' . XDB::escape($this->email);
 339         }
 340         if (!empty($this->ip)) {
 341             $ip = ip_to_uint($this->ip);
 342             $where[] = "( ls.ip = $ip OR ls.forward_ip = $ip ) AND ls.suid = 0";
 343         }
 344         if (!empty($this->phone)){
 345             require_once("profil.func.inc.php");
 346             $phone = format_phone_number($this->phone) . "%";
 347             $where[] = 't.search_tel LIKE ' . XDB::escape($phone);
 348         }
 349
 350         return join(" AND ", $where);
 351     }
 352
 353     // }}}
 354     // {{{ get_select_statement
 355     function get_select_statement()
 356     {
 357         $join = "";
 358         $and  = '';
 359         $uniq = '';
 360         foreach ($this->strings as $i => $s) {
 361             if (!S::logged()) {
 362                 $and = "AND FIND_IN_SET('public', sn$i.flags)";
 363             }
 364             $myu  = str_replace('snv', "sn$i", $uniq);
 365             $join .= "INNER JOIN search_name AS sn$i ON (u.user_id = sn$i.uid $and$myu)\n";
 366             $uniq .= " AND sn$i.token != snv.token";
 367         }
 368         if (!empty($this->email)) {
 369             $join .= "LEFT JOIN emails AS ems ON (ems.uid = u.user_id)";
 370         }
 371         if (!empty($this->ip)) {
 372             $join .= "INNER JOIN logger.sessions AS ls ON (ls.uid = u.user_id)\n";
 373         }
 374         if (!empty($this->phone)) {
 375             if (!S::logged()) {
 376                 $join .= "INNER JOIN profile_phones AS t ON (t.uid = u.user_id AND t.pub = 'public')";
 377             } else {
 378                 $join .= "INNER JOIN profile_phones AS t ON (t.uid = u.user_id)";
 379             }
 380         }
 381         return $join;
 382     }
 383     // }}}
 384     // {{{ function get_order_statement()
 385
 386     function get_order_statement()
 387     {
 388         return false;
 389     }
 390
 391     // }}}
 392     // {{{ function get_score_statement
 393
 394     function get_score_statement()
 395     {
 396         $sum = array('0');
 397         foreach ($this->strings as $i => $s) {
 398             $sum[] .= "SUM(sn$i.score + IF('$s'=sn$i.token,5,0))";
 399         }
 400         return join('+', $sum).' AS score';
 401     }
 402
 403     // }}}
 404 }
 405
 406 // }}}
 407 // {{{ class NumericSField                              [Integer fields]
 408
 409 /** classe de champ numérique entier (offset par exemple)
 410  */
 411 class NumericSField extends SField
 412 {
 413     // {{{ constructor
 414
 415     /** constructeur
 416      * (récupère la requête de l'utilisateur pour ce champ) */
 417     function NumericSField($_fieldFormName)
 418     {
 419         $this->fieldFormName = $_fieldFormName;
 420         $this->get_request();
 421     }
 422
 423     // }}}
 424     // {{{ function get_request()
 425
 426     /** récupère la requête de l'utilisateur et échoue s'il ne s'agit pas d'un entier */
 427     function get_request()
 428     {
 429         parent::get_request();
 430         if (empty($this->value)) {
 431             $this->value = 0;
 432         }
 433         if (!preg_match("/^[0-9]+$/", $this->value)) {
 434             new ThrowError('Un champ numérique contient des caractères alphanumériques.');
 435         }
 436     }
 437
 438     // }}}
 439 }
 440
 441 // }}}
 442 // {{{ class RefSField                                  [ ??? ]
 443
 444 class RefSField extends SField
 445 {
 446     // {{{ properties
 447
 448     var $refTable;
 449     var $refAlias;
 450     var $refCondition;
 451     var $exact = true;
 452
 453     // }}}
 454     // {{{ constructor
 455
 456     function RefSField($_fieldFormName, $_fieldDbName='', $_refTable, $_refAlias, $_refCondition, $_exact=true)
 457     {
 458         $this->fieldFormName = $_fieldFormName;
 459         $this->fieldDbName   = $_fieldDbName;
 460         $this->refTable      = $_refTable;
 461         $this->refAlias      = $_refAlias;
 462         $this->refCondition  = $_refCondition;
 463         $this->exact         = $_exact;
 464         $this->get_request();
 465     }
 466
 467     // }}}
 468     // {{{ function get_request()
 469
 470     function get_request() {
 471         parent::get_request();
 472         if ($this->value=='00' || $this->value=='0') {
 473             $this->value='';
 474         }
 475     }
 476
 477     // }}}
 478     // {{{ function too_large()
 479
 480     function too_large()
 481     {
 482         return ($this->value=='');
 483     }
 484
 485     // }}}
 486     // {{{ function compare()
 487
 488     function compare()
 489     {
 490         $val = addslashes($this->value);
 491         if (Env::i('exact')) return "='$val'";
 492         return $this->exact ? "='$val'" : " LIKE '%$val%'";
 493     }
 494
 495     // }}}
 496     // {{{ function get_single_match_statement()
 497
 498     function get_single_match_statement($field)
 499     {
 500         return $field.$this->compare();
 501     }
 502
 503     // }}}
 504     // {{{ function get_single_where_statement()
 505
 506     function get_single_where_statement($field)
 507     {
 508         return $this->refTable=='' ? $this->get_single_match_statement($field) : false;
 509     }
 510
 511     // }}}
 512     // {{{ function get_select_statement()
 513
 514     function get_select_statement()
 515     {
 516         if ($this->value=='' || $this->refTable=='') {
 517             return false;
 518         }
 519         $res = implode(' OR ', array_filter(array_map(array($this, 'get_single_match_statement'), $this->fieldDbName)));
 520         if (is_array($this->refTable)) {
 521            foreach ($this->refTable as $i => $refT)
 522                $last = $i;
 523            $inner = "";
 524             foreach ($this->refTable as $i => $refT)
 525                 $inner .= " INNER JOIN {$refT} AS {$this->refAlias[$i]} ON ({$this->refCondition[$i]} ".(($i == $last)?"AND ($res) ":"").")\n";
 526             return $inner;
 527         } else {
 528             return "INNER JOIN {$this->refTable} AS {$this->refAlias} ON ({$this->refCondition} AND ($res) )";
 529         }
 530     }
 531
 532     // }}}
 533 }
 534
 535 // }}}
 536
 537 // {{{ class RefSFieldMultipleTable
 538 class PhoneSField extends RefSField
 539 {
 540     function PhoneSField($_fieldFormName, $_fieldDbName='', $_refTable, $_refAlias, $_refCondition)
 541     {
 542         $this->RefSField($_fieldFormName, $_fieldDbName, $_refTable, $_refAlias, $_refCondition, true);
 543     }
 544
 545     function get_request()
 546     {
 547         require_once("profil.func.inc.php");
 548         $this->value = trim(Env::v($this->fieldFormName));
 549         $this->value = format_phone_number($this->value);
 550     }
 551
 552     function compare()
 553     {
 554         return " LIKE '" . addslashes($this->value) . "%'";
 555     }
 556 }
 557
 558 class IndexSField extends RefSField
 559 {
 560     function IndexSField($_fieldFormName, $_fieldDbName='', $_refTable, $_refAlias, $_refCondition)
 561     {
 562         $this->RefSField($_fieldFormName, $_fieldDbName, $_refTable, $_refAlias, $_refCondition, true);
 563     }
 564
 565     function get_request()
 566     {
 567         $this->value = trim(Env::v($this->fieldFormName));
 568     }
 569 }
 570
 571 class MapSField extends RefSField
 572 {
 573     var $mapId;
 574
 575     function MapSField($_fieldFormName, $_fieldDbName='', $_refTable, $_refAlias, $_refCondition, $_mapId=false)
 576     {
 577         if ($_mapId === false)
 578             $this->mapId = Env::v($_fieldFormName, '');
 579         else
 580             $this->mapId = $_mapId;
 581         $this->value =  $this->mapId;
 582         $this->RefSField($_fieldFormName, $_fieldDbName, $_refTable, $_refAlias, $_refCondition, true, false);
 583     }
 584
 585     function get_select_statement()
 586     {
 587         if ($this->mapId === '') return false;
 588         $res = implode(' OR ', array_filter(array_map(array($this, 'get_single_match_statement'), $this->fieldDbName)));
 589         foreach ($this->refTable as $i => $refT)
 590             $last = $i;
 591         $inner = "";
 592         foreach ($this->refTable as $i => $refT)
 593             $inner .= " INNER JOIN {$refT} AS {$this->refAlias[$i]} ON ({$this->refCondition[$i]} ".(($i == $last)?"AND ($res) ":"").")";
 594         return $inner;
 595     }
 596     function get_request()
 597     {
 598         $this->value = $this->mapId;
 599     }
 600 }
 601
 602 // {{{ class RefWithSoundexSField                       [ ??? ]
 603
 604 class RefWithSoundexSField extends RefSField
 605 {
 606     // {{{ function compare()
 607
 608     function compare()
 609     {
 610         return "='".soundex_fr($this->value)."'";
 611     }
 612
 613     // }}}
 614 }
 615
 616 // }}}
 617 // {{{ class StringSField                               [String fields]
 618
 619 /** classe de champ texte (nom par exemple)
 620  */
 621 class StringSField extends SField
 622 {
 623     // {{{ function get_request()
 624
 625     /** récupère la requête de l'utilisateur et échoue si la chaîne contient des caractères
 626      * interdits */
 627     function get_request()
 628     {
 629         parent::get_request();
 630         if (preg_match(":[\]\[<>{}~/§_`|%$^=+]|\*\*:u", $this->value)) {
 631             new ThrowError('Un champ contient un caractère interdit rendant la recherche impossible.');
 632         }
 633     }
 634
 635     // }}}
 636     // {{{ function length()
 637
 638     /** donne la longueur de la requête de l'utilisateur
 639      * (au sens strict i.e. pas d'* ni d'espace ou de trait d'union -> les contraintes réellement
 640      * imposées par l'utilisateur) */
 641     function length()
 642     {
 643         $cleaned = replace_accent(strtolower($this->value));
 644         $length  = strlen(ereg_replace('[a-z0-9]', '', $cleaned));
 645         return strlen($this->value) - $length;
 646     }
 647
 648     // }}}
 649     // {{{ function too_large()
 650
 651     function too_large()
 652     {
 653         return ($this->length()<2);
 654     }
 655
 656     // }}}
 657     // {{{ function get_single_where_statement()
 658
 659     /** clause WHERE correspondant à un champ de la bdd et à ce champ de formulaire
 660      * @param field nom de champ de la bdd concerné par la clause */
 661     function get_single_where_statement($field)
 662     {
 663         $val = addslashes($this->value);
 664         if (Env::i('exact')) return "$field = '$val'";
 665         $regexp = strtr($val, '-*', '_%');
 666         return "$field LIKE '$regexp%'";
 667     }
 668
 669     // }}}
 670     // {{{ function get_order_statement()
 671
 672     /** clause ORDER BY correspondant à ce champ de formulaire */
 673     function get_order_statement()
 674     {
 675         if ($this->value!='' && $this->fieldResultName!='') {
 676             return "{$this->fieldResultName}!='".addslashes($this->value)."'";
 677         } else {
 678             return false;
 679         }
 680     }
 681
 682     // }}}
 683 }
 684
 685 // }}}
 686 // {{{ class NameSField                                 [Names : serach 'n%' + '% b']
 687
 688 /** classe pour les noms : on cherche en plus du like 'foo%' le like '% foo' (particules)
 689 +*/
 690 class NameSField extends StringSField
 691 {
 692     // {{{ function get_single_where_statement()
 693
 694     function get_single_where_statement($field)
 695     {
 696         $val = addslashes($this->value);
 697         if (Env::i('exact')) return "$field = '$val'";
 698         $regexp = strtr($val, '-*', '_%');
 699         return "$field LIKE '$regexp%' OR $field LIKE '% $regexp%' OR $field LIKE '%-$regexp%'";
 700     }
 701
 702     // }}}
 703     // {{{ function get_order_statement()
 704
 705     function get_order_statement()
 706     {
 707         if ($this->value!='' && $this->fieldResultName!='') {
 708             return "{$this->fieldResultName} NOT LIKE '".addslashes($this->value)."'";
 709         } else {
 710             return false;
 711         }
 712     }
 713
 714     // }}}
 715 }
 716
 717 // }}}
 718 // {{{ class StringWithSoundexSField                    [Strings + soundex]
 719
 720 /** classe de champ texte avec soundex (nom par exemple)
 721  */
 722 class StringWithSoundexSField extends StringSField
 723 {
 724     // {{{ function get_single_where_statement()
 725
 726     /** clause WHERE correspondant à un champ de la bdd et à ce champ de formulaire
 727      * @param field nom de champ de la bdd concerné par la clause */
 728     function get_single_where_statement($field) {
 729         return $field.'="'.soundex_fr($this->value).'"';
 730     }
 731
 732     // }}}
 733 }
 734
 735 // }}}
 736 // {{{ class PromoSField                                [Prom field]
 737
 738 /** classe de champ de promotion */
 739 class PromoSField extends SField
 740 {
 741     // {{{ properties
 742
 743     /** opérateur de comparaison (<,>,=) de la promo utilisé pour ce champ de formulaire */
 744     var $compareField;
 745
 746     // }}}
 747     // {{{ constructor
 748
 749     /** constructeur
 750      * compareField est un champ de formulaire très simple qui ne sert qu'à la construction de la
 751      * clause WHERE de la promo */
 752     function PromoSField($_fieldFormName, $_compareFieldFormName, $_fieldDbName, $_fieldResultName)
 753     {
 754         parent::SField($_fieldFormName, $_fieldDbName, $_fieldResultName);
 755         $this->compareField = new SField($_compareFieldFormName);
 756     }
 757
 758     // }}}
 759     // {{{ function get_request()
 760
 761     /** récupère la requête utilisateur et échoue si le champ du formulaire ne représente pas une
 762      * promotion (nombre à 4 chiffres) */
 763     function get_request()
 764     {
 765         parent::get_request();
 766         if (preg_match('/^[0-9]{2}$/', $this->value)){
 767             $this->value = intval($this->value) + 1900;
 768         }
 769         if (!(empty($this->value) or preg_match('/^[0-9]{4}$/', $this->value))) {
 770             new ThrowError('La promotion est une année à quatre chiffres.');
 771         }
 772     }
 773
 774     // }}}
 775     // {{{ function is_a_single_promo()
 776
 777     /** teste si la requête est de la forme =promotion -> contrainte forte imposée -> elle suffit
 778      * pour autoriser un affichage des résultats alors que <promotion est insuffisant */
 779     function is_a_single_promo()
 780     {
 781         return ($this->compareField->value=='=' && $this->value!='');
 782     }
 783
 784     // }}}
 785     // {{{ function too_large()
 786
 787     function too_large()
 788     {
 789         return !$this->is_a_single_promo();
 790     }
 791
 792     // }}}
 793     // {{{ function get_single_where_statement()
 794
 795     /** clause WHERE correspondant à ce champ */
 796     function get_single_where_statement($field)
 797     {
 798         return $field.$this->compareField->value.$this->value;
 799     }
 800
 801     // }}}
 802     // {{{ function get_url()
 803
 804     /** récupérer le bout d'URL correspondant aux paramètres permettant d'imiter une requête
 805      * d'un utilisateur assignant la valeur $this->value à ce champ et assignant l'opérateur de
 806      * comparaison adéquat */
 807     function get_url()
 808     {
 809         if (!($u=parent::get_url())) {
 810             return false;
 811         }
 812         return $u.'&amp;'.$this->compareField->get_url();
 813     }
 814
 815     // }}}
 816 }
 817
 818 // }}}
 819 // {{{ class SFieldGroup                                [Group fields]
 820
 821 /** classe groupant des champs de formulaire de recherche */
 822 class SFieldGroup
 823 {
 824     // {{{ properties
 825
 826     /** tableau des classes correspondant aux champs groupés */
 827     var $fields;
 828     /** type de groupe : ET ou OU */
 829     var $and;
 830
 831     // }}}
 832     // {{{ constuctor
 833
 834     /** constructeur */
 835     function SFieldGroup($_and, $_fields)
 836     {
 837         $this->fields = $_fields;
 838         $this->and    = $_and;
 839         foreach ($this->fields as $key=>&$field) {
 840             if (is_null($field)) {
 841                 unset($this->fields[$key]);
 842             }
 843         }
 844     }
 845
 846     // }}}
 847     // {{{ function too_large()
 848
 849     function too_large()
 850     {
 851         $b = true;
 852         for ($i=0 ; $b && $i<count($this->fields) ; $i++) {
 853             if (!is_null($this->fields[$i])) {
 854                 $b = $b && $this->fields[$i]->too_large();
 855             }
 856         }
 857         return $b;
 858     }
 859
 860     // }}}
 861     // {{{ function field_get_select()
 862
 863     function field_get_select($f)
 864     {
 865         return $f->get_select_statement();
 866     }
 867
 868     // }}}
 869     // {{{ function field_get_where()
 870
 871     /** récupérer la clause WHERE d'un objet champ de recherche */
 872     function field_get_where($f)
 873     {
 874         return $f->get_where_statement();
 875     }
 876
 877     // }}}
 878     // {{{ function field_get_order()
 879
 880     /** récupérer la clause ORDER BY d'un objet champ de recherche */
 881     function field_get_order($f)
 882     {
 883         return $f->get_order_statement();
 884     }
 885
 886     // }}}
 887     // {{{ function field_get_url()
 888
 889     /** récupérer le bout d'URL correspondant à un objet champ de recherche */
 890     function field_get_url($f)
 891     {
 892         return $f->get_url();
 893     }
 894
 895     // }}}
 896     // {{{ function get_select_statement()
 897
 898     function get_select_statement()
 899     {
 900         return implode(' ', array_filter(array_map(array($this, 'field_get_select'), $this->fields)));
 901     }
 902
 903     // }}}
 904     // {{{ function get_where_statement()
 905
 906     /** récupérer la clause WHERE du groupe de champs = conjonction (ET) ou disjonction (OU) de
 907      * clauses des champs élémentaires */
 908     function get_where_statement()
 909     {
 910         $joinText = $this->and ? ' AND ' : ' OR ';
 911         $res = implode($joinText, array_filter(array_map(array($this, 'field_get_where'), $this->fields)));
 912         return $res == '' ? '' : "($res)";
 913     }
 914
 915     // }}}
 916     // {{{ function get_order_statement()
 917
 918     /** récupérer la clause ORDER BY du groupe de champs = conjonction (ET) ou disjonction (OU) de
 919      * clauses des champs élémentaires */
 920     function get_order_statement()
 921     {
 922         $order = array_filter(array_map(array($this, 'field_get_order'), $this->fields));
 923         return count($order)>0 ? implode(',', $order) : false;
 924     }
 925
 926     // }}}
 927     // {{{ function get_url()
 928
 929     /** récupérer le bout d'URL correspondant à ce groupe de champs = concaténation des bouts d'URL
 930      * des champs élémentaires */
 931     function get_url($others=Array())
 932     {
 933         $url = array_filter(array_map(array($this, 'field_get_url'), $this->fields));
 934         foreach ($url as $key=>$val) {
 935             if (empty($val)) {
 936                 unset($url[$key]);
 937             }
 938         }
 939         foreach ($others as $key=>$val) {
 940             if (!empty($val)) {
 941                 $url[] = "$key=$val";
 942             }
 943         }
 944         return count($url)>0 ? implode('&amp;', $url) : false;
 945     }
 946
 947     // }}}
 948 }
 949
 950 // }}}
 951
 952 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
 953 ?>