include/profilefields.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 // {{{ class ProfileField
  23 /** To store a "field" from the profile
  24  * Provides functions for loading a batch of such data
  25  */
  26 abstract class ProfileField
  27 {
  28     public static $fields = array(
  29         Profile::FETCH_ADDRESSES      => 'ProfileAddresses',
  30         Profile::FETCH_CORPS          => 'ProfileCorps',
  31         Profile::FETCH_EDU            => 'ProfileEducation',
  32         Profile::FETCH_JOBS           => 'ProfileJobs',
  33         Profile::FETCH_MEDALS         => 'ProfileMedals',
  34         Profile::FETCH_NETWORKING     => 'ProfileNetworking',
  35         Profile::FETCH_PHONES         => 'ProfilePhones',
  36         Profile::FETCH_MENTOR_COUNTRY => 'ProfileMentoringCountries',
  37         Profile::FETCH_JOB_TERMS      => 'ProfileJobTerms',
  38         Profile::FETCH_MENTOR_TERMS   => 'ProfileMentoringTerms',
  39     );
  40
  41     /** The profile to which this field belongs
  42      */
  43     public $pid;
  44
  45     /** Fetches data from the database for the given pids, compatible with
  46      * the visibility context.
  47      * @param $pids An array of pids
  48      * @param $visibility The level of visibility fetched fields must have
  49      * @return a PlIterator yielding data suitable for a "new ProfileBlah($data)"
  50      *
  51      * MUST be reimplemented for each kind of ProfileField.
  52      */
  53     public static function fetchData(array $pids, ProfileVisibility $visibility)
  54     {
  55         return PlIteratorUtils::emptyIterator();
  56     }
  57
  58     public static function buildForPID($cls, $pid, ProfileVisibility $visibility)
  59     {
  60         $res = self::buildFromPIDs($cls, array($pid), $visibility);
  61         return array_pop($res);
  62     }
  63
  64     /** Build a list of ProfileFields from a set of pids
  65      * @param $cls The name of the field to create ('ProfileMedals', ...)
  66      * @param $pids An array of pids
  67      * @param $visibility An array of allowed visibility contexts
  68      * @return An array of $pid => ProfileField
  69      */
  70     public static function buildFromPIDs($cls, array $pids, ProfileVisibility $visibility)
  71     {
  72         $it = new ProfileFieldIterator($cls, $pids, $visibility);
  73         $res = array();
  74         while ($pf = $it->next()) {
  75             $res[$pf->pid] = $pf;
  76         }
  77         return $res;
  78     }
  79
  80     public static function getForPID($cls, $pid, ProfileVisibility $visibility)
  81     {
  82         $it = new ProfileFieldIterator($cls, array($pid), $visibility);
  83         return $it->next();
  84     }
  85 }
  86 // }}}
  87
  88 // {{{ class ProfileFieldIterator
  89 class ProfileFieldIterator implements PlIterator
  90 {
  91     private $data;
  92     private $cls;
  93
  94     public function __construct($cls, array $pids, ProfileVisibility $visibility)
  95     {
  96         if (is_numeric($cls) && isset(ProfileField::$fields[$cls])) {
  97             $cls = ProfileField::$fields[$cls];
  98         }
  99         $this->data = call_user_func(array($cls, 'fetchData'), $pids, $visibility);
 100         $this->cls = $cls;
 101     }
 102
 103     public function next()
 104     {
 105         $d = $this->data->next();
 106         if ($d == null) {
 107             return null;
 108         } else {
 109             $cls = $this->cls;
 110             return new $cls($d);
 111         }
 112     }
 113
 114     public function total()
 115     {
 116         return $this->data->total();
 117     }
 118
 119     public function first()
 120     {
 121         return $this->data->first();
 122     }
 123
 124     public function last()
 125     {
 126         return $this->data->last();
 127     }
 128 }
 129 // }}}
 130
 131 // {{{ class Company
 132 class Company
 133 {
 134     public $id;
 135     public $name;
 136     public $acronym;
 137     public $url;
 138     public $phone = null;
 139     public $address = null;
 140
 141     /** Fields are:
 142      * $id, $name, $acronym, $url
 143      */
 144     public function __construct($data)
 145     {
 146         foreach ($data as $key => $val) {
 147             $this->$key = $val;
 148         }
 149     }
 150
 151     public function setPhone(Phone $phone)
 152     {
 153         if ($phone->link_type == Phone::LINK_COMPANY && $phone->link_id == $this->id) {
 154             $this->phone = $phone;
 155         }
 156     }
 157
 158     public function setAddress(Address $address)
 159     {
 160         if ($address->type == Address::LINK_COMPANY && $address->jobid == $this->id) {
 161             $this->address = $address;
 162         }
 163     }
 164
 165 }
 166 // }}}
 167 // {{{ class Job
 168 /** profile_job describes a Job, links to:
 169  * - a Profile, through `pid`
 170  * - a Company, through `jobid`
 171  * The `id` field is the id of this job in the list of the jobs of its profile
 172  *
 173  * For the documentation of the phone table, please see classes/phone.php.
 174  * For the documentation of the address table, please see classes/address.php.
 175  *
 176  * The possible relations are as follow:
 177  * A Job is linked to a Company and a Profile
 178  */
 179 class Job
 180 {
 181     public $pid;
 182     public $id;
 183
 184     public $company = null;
 185     public $phones = array();
 186     public $address = null;
 187     public $terms = array();
 188
 189     public $jobid;
 190
 191     public $description;
 192     public $user_site;
 193     public $user_email;
 194
 195     /** Fields are:
 196      * pid, id, company_id, description, url, email
 197      */
 198     public function __construct($data)
 199     {
 200         foreach ($data as $key => $val) {
 201             $this->$key = $val;
 202         }
 203         $this->company = CompanyList::get($this->jobid);
 204         if (is_null($this->company)) {
 205             $entreprises = ProfileValidate::get_typed_requests($this->pid, 'entreprise');
 206             foreach ($entreprises as $entreprise) {
 207                 if ($entreprise->id == $this->id) {
 208                     $this->company = new Company(array('name' => $entreprise->name));
 209                 }
 210             }
 211         }
 212     }
 213
 214     public function phones()
 215     {
 216         return $this->phones;
 217     }
 218
 219     public function address()
 220     {
 221         return $this->address;
 222     }
 223
 224     public function addPhone(Phone $phone)
 225     {
 226         if ($phone->link_type == Phone::LINK_JOB && $phone->link_id == $this->id && $phone->pid == $this->pid) {
 227             $this->phones[$phone->uniqueId()] = $phone;
 228         }
 229     }
 230
 231     public function setAddress(Address $address)
 232     {
 233         if ($address->type == Address::LINK_JOB && $address->id == $this->id && $address->pid == $this->pid) {
 234             $this->address = $address;
 235         }
 236     }
 237
 238     public function addTerm(JobTerm $term)
 239     {
 240         $this->terms[$term->jtid] = $term;
 241     }
 242 }
 243 // }}}
 244 // {{{ class JobTerm
 245 class JobTerm
 246 {
 247     public $jtid;
 248     public $full_name;
 249     public $pid;
 250     public $jid;
 251
 252     /** Fields are:
 253      * pid, jid, jtid, full_name
 254      */
 255     public function __construct($data)
 256     {
 257         foreach ($data as $key => $val) {
 258             $this->$key = $val;
 259         }
 260     }
 261 }
 262 // }}}
 263 // {{{ class Education
 264 class Education
 265 {
 266     public $id;
 267     public $pid;
 268
 269     public $entry_year;
 270     public $grad_year;
 271     public $program;
 272     public $flags;
 273
 274     public $school;
 275     public $school_short;
 276     public $school_url;
 277     public $country;
 278
 279     public $degree;
 280     public $degree_short;
 281     public $degree_level;
 282
 283     public $field;
 284
 285     public function __construct(array $data)
 286     {
 287         foreach ($data as $key => $val) {
 288             $this->$key = $val;
 289         }
 290         $this->flags      = new PlFlagSet($this->flags);
 291     }
 292 }
 293 // }}}
 294
 295 // {{{ class ProfileEducation                         [ Field ]
 296 class ProfileEducation extends ProfileField
 297 {
 298     private $educations = array();
 299
 300     public function __construct(PlInnerSubIterator $it)
 301     {
 302         $this->pid = $it->value();
 303         while ($edu = $it->next()) {
 304             $this->educations[$edu['id']] = new Education($edu);
 305         }
 306     }
 307
 308     public function get($flags, $limit)
 309     {
 310         $educations = array();
 311         $year = getdate();
 312         $year = $year['year'];
 313         $nb = 0;
 314         foreach ($this->educations as $id => $edu) {
 315             if (
 316                 (($flags & Profile::EDUCATION_MAIN) && $edu->flags->hasFlag('primary'))
 317                 ||
 318                 (($flags & Profile::EDUCATION_EXTRA) && !$edu->flags->hasFlag('primary'))
 319                 ||
 320                 (($flags & Profile::EDUCATION_FINISHED) && $edu->grad_year <= $year)
 321                 ||
 322                 (($flags & Profile::EDUCATION_CURRENT) && $edu->grad_year > $year)
 323                 ||
 324                 ($flags & Profile::EDUCATION_ALL)
 325             ) {
 326                 $educations[$id] = $edu;
 327                 ++$nb;
 328             }
 329             if ($limit != null && $nb >= $limit) {
 330                 break;
 331             }
 332         }
 333         return $educations;
 334     }
 335
 336     public static function fetchData(array $pids, ProfileVisibility $visibility)
 337     {
 338         $data = XDB::iterator('SELECT  pe.id, pe.pid,
 339                                        pe.entry_year, pe.grad_year, pe.program, pe.flags,
 340                                        pee.name AS school, pee.abbreviation AS school_short,
 341                                        pee.url AS school_url, gc.country,
 342                                        pede.degree, pede.abbreviation AS degree_short, pede.level AS degree_level,
 343                                        pefe.field
 344                                  FROM  profile_education AS pe
 345                             LEFT JOIN  profile_education_enum AS pee ON (pee.id = pe.eduid)
 346                             LEFT JOIN  geoloc_countries AS gc ON (gc.iso_3166_1_a2 = pee.country)
 347                             LEFT JOIN  profile_education_degree_enum AS pede ON (pede.id = pe.degreeid)
 348                             LEFT JOIN  profile_education_field_enum AS pefe ON (pefe.id = pe.fieldid)
 349                                 WHERE  pe.pid IN {?}
 350                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids) . ',
 351                                        NOT FIND_IN_SET(\'primary\', pe.flags), pe.entry_year, pe.id',
 352                                 $pids);
 353
 354         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 355     }
 356 }
 357 // }}}
 358 // {{{ class ProfileMedals                            [ Field ]
 359 class ProfileMedals extends ProfileField
 360 {
 361     public $medals = array();
 362
 363     public function __construct(PlInnerSubIterator $it)
 364     {
 365         $this->pid = $it->value();
 366         while ($medal = $it->next()) {
 367             $this->medals[$medal['mid']] = $medal;
 368         }
 369     }
 370
 371     public static function fetchData(array $pids, ProfileVisibility $visibility)
 372     {
 373         $data = XDB::iterator('SELECT  pm.pid, pm.mid, pm.gid, pme.text, pme.img, pmge.text AS grade
 374                                  FROM  profile_medals AS pm
 375                             LEFT JOIN  profiles AS p ON (pm.pid = p.pid)
 376                             LEFT JOIN  profile_medal_enum AS pme ON (pme.id = pm.mid)
 377                             LEFT JOIN  profile_medal_grade_enum AS pmge ON (pmge.mid = pm.mid AND pmge.gid = pm.gid)
 378                                 WHERE  pm.pid IN {?} AND p.medals_pub IN {?}
 379                              ORDER BY  ' . XDB::formatCustomOrder('pm.pid', $pids),
 380                                 $pids, $visibility->levels());
 381
 382         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 383     }
 384 }
 385 // }}}
 386 // {{{ class ProfileNetworking                        [ Field ]
 387 class ProfileNetworking extends ProfileField
 388 {
 389     private $networks = array();
 390
 391     public function __construct(PlInnerSubIterator $it)
 392     {
 393         $this->pid = $it->value();
 394         while ($network = $it->next()) {
 395             $network['network_type'] = new PlFlagSet($network['network_type']);
 396             $this->networks[$network['id']] = $network;
 397         }
 398     }
 399
 400     public static function fetchData(array $pids, ProfileVisibility $visibility)
 401     {
 402         $data = XDB::iterator('SELECT  pid, id, address, pne.nwid, pne.network_type, pne.link, pne.name
 403                                  FROM  profile_networking AS pn
 404                             LEFT JOIN  profile_networking_enum AS pne USING(nwid)
 405                                 WHERE  pid IN {?} AND pub IN {?}
 406                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids) . ',
 407                                        pn.nwid, id',
 408                                $pids, $visibility->levels());
 409
 410         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 411     }
 412
 413     public function get($flags, $limit = null)
 414     {
 415         $nws = array();
 416         $nb = 0;
 417         foreach ($this->networks as $id => $nw) {
 418             if (($flags & Profile::NETWORKING_WEB) && $nw['network_type']->hasFlag('web') ||
 419                 ($flags & Profile::NETWORKING_IM) && $nw['network_type']->hasFlag('im') ||
 420                 ($flags & Profile::NETWORKING_SOCIAL) && $nw['network_type']->hasFlag('social') ||
 421                 ($flags == Profile::NETWORKING_ALL)) {
 422                 $nws[$id] = $nw;
 423                 ++$nb;
 424                 if (isset($limit) && $nb >= $limit) {
 425                     break;
 426                 }
 427             }
 428         }
 429         return $nws;
 430     }
 431 }
 432 // }}}
 433 // {{{ class ProfileCorps                             [ Field ]
 434 class ProfileCorps extends ProfileField
 435 {
 436     public $original;
 437     public $current;
 438
 439     public $original_name;
 440     public $original_abbrev;
 441     public $original_still_exists;
 442
 443     public $current_name;
 444     public $current_abbrev;
 445     public $current_still_exists;
 446     public $current_rank;
 447     public $current_rank_abbrev;
 448
 449     public function __construct(array $data)
 450     {
 451         foreach ($data as $key => $val) {
 452             $this->$key = $val;
 453         }
 454     }
 455
 456     public static function fetchData(array $pids, ProfileVisibility $visibility)
 457     {
 458         $data = XDB::iterator('SELECT  pc.pid, pc.original_corpsid AS original, pc.current_corpsid AS current,
 459                                        pceo.name AS original_name, pceo.abbreviation AS original_abbrev,
 460                                        pceo.still_exists AS original_still_exists,
 461                                        pcec.name AS current_name, pcec.abbreviation AS current_abbrev,
 462                                        pcec.still_exists AS current_still_exists,
 463                                        pcrec.name AS current_rank, pcrec.abbreviation AS current_rank_abbrev,
 464                                        rankid
 465                                  FROM  profile_corps AS pc
 466                             LEFT JOIN  profile_corps_enum AS pceo ON (pceo.id = pc.original_corpsid)
 467                             LEFT JOIN  profile_corps_enum AS pcec ON (pcec.id = pc.current_corpsid)
 468                             LEFT JOIN  profile_corps_rank_enum AS pcrec ON (pcrec.id = pc.rankid)
 469                                 WHERE  pc.pid IN {?} AND pc.corps_pub IN {?} AND pceo.id != 1
 470                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids),
 471                                 $pids, $visibility->levels());
 472
 473         return $data;
 474     }
 475 }
 476 // }}}
 477 // {{{ class ProfileMentoringCountries                [ Field ]
 478 class ProfileMentoringCountries extends ProfileField
 479 {
 480     public $countries = array();
 481
 482     public function __construct(PlInnerSubIterator $it)
 483     {
 484         $this->pid = $it->value();
 485         while ($country = $it->next()) {
 486             $this->countries[$country['id']] = $country['name'];
 487         }
 488     }
 489
 490     public static function fetchData(array $pids, ProfileVisibility $visibility)
 491     {
 492         $data = XDB::iterator('SELECT  pmc.pid, pmc.country AS id, gc.country AS name
 493                                  FROM  profile_mentor_country AS pmc
 494                             LEFT JOIN  geoloc_countries AS gc ON (gc.iso_3166_1_a2 = pmc.country)
 495                                 WHERE  pmc.pid IN {?}
 496                              ORDER BY  ' . XDB::formatCustomOrder('pmc.pid', $pids),
 497                                 $pids);
 498
 499         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 500     }
 501 }
 502 // }}}
 503 // {{{ class ProfileAddresses                         [ Field ]
 504 class ProfileAddresses extends ProfileField
 505 {
 506     private $addresses = array();
 507
 508     public function __construct(PlInnerSubIterator $it)
 509     {
 510         $this->pid = $it->value();
 511         while ($address = $it->next()) {
 512             $this->addresses[] = new Address($address);
 513         }
 514     }
 515
 516     public function get($flags, $limit = null)
 517     {
 518         $addresses = array();
 519         $nb = 0;
 520         foreach ($this->addresses as $address) {
 521             if ((($flags & Profile::ADDRESS_MAIN) && $address->hasFlag('current'))
 522                 || (($flags & Profile::ADDRESS_POSTAL) && $address->hasFlag('mail'))
 523                 || (($flags & Profile::ADDRESS_PERSO) && $address->type == Address::LINK_PROFILE)
 524                 || (($flags & Profile::ADDRESS_PRO) && $address->type == Address::LINK_JOB)
 525             ) {
 526                 $addresses[] = $address;
 527                 ++$nb;
 528             }
 529             if ($limit != null && $nb == $limit) {
 530                 break;
 531             }
 532         }
 533         return $addresses;
 534     }
 535
 536     public static function fetchData(array $pids, ProfileVisibility $visibility)
 537     {
 538         $it = Address::iterate($pids, array(), array(), $visibility->levels());
 539         return PlIteratorUtils::subIterator($it->value(), PlIteratorUtils::arrayValueCallback('pid'));
 540     }
 541
 542     public function addPhones(ProfilePhones $phones)
 543     {
 544         $p = $phones->get(Profile::PHONE_LINK_ADDRESS | Profile::PHONE_TYPE_ANY);
 545         foreach ($p as $phone) {
 546             /* We must iterate on the addresses because id is not uniq thus,
 547              * $this->addresse[$phone->link_id] is invalid.
 548              */
 549             foreach ($this->addresses as $address) {
 550                 if ($address->type == Address::LINK_PROFILE && $address->id == $phone->link_id) {
 551                     $address->addPhone($phone);
 552                 }
 553             }
 554         }
 555     }
 556 }
 557 // }}}
 558 // {{{ class ProfilePhones                            [ Field ]
 559 class ProfilePhones extends ProfileField
 560 {
 561     private $phones = array();
 562
 563     public function __construct(PlInnerSubIterator $it)
 564     {
 565         $this->pid = $it->value();
 566         while ($phone = $it->next()) {
 567             $this->phones[] = new Phone($phone);
 568         }
 569     }
 570
 571     public function get($flags, $limit = null)
 572     {
 573         $phones = array();
 574         $nb = 0;
 575         foreach ($this->phones as $id => $phone) {
 576             if ($phone->hasFlags($flags)) {
 577                 $phones[$id] = $phone;
 578                 ++$nb;
 579                 if ($limit != null && $nb == $limit) {
 580                     break;
 581                 }
 582             }
 583         }
 584         return $phones;
 585     }
 586
 587     public static function fetchData(array $pids, ProfileVisibility $visibility)
 588     {
 589         $it = Phone::iterate($pids, array(), array(), $visibility->levels());
 590         return PlIteratorUtils::subIterator($it->value(), PlIteratorUtils::arrayValueCallback('pid'));
 591     }
 592 }
 593 // }}}
 594 // {{{ class ProfileJobs                              [ Field ]
 595 class ProfileJobs extends ProfileField
 596 {
 597     private $jobs = array();
 598
 599     public function __construct(PlInnerSubIterator $jobs)
 600     {
 601         $this->pid = $jobs->value();
 602         while ($job = $jobs->next()) {
 603             $this->jobs[$job['id']] = new Job($job);
 604         }
 605     }
 606
 607     public static function fetchData(array $pids, ProfileVisibility $visibility)
 608     {
 609         CompanyList::preload($pids);
 610         $data = XDB::iterator('SELECT  id, pid, description, url as user_site, jobid,
 611                                        IF(email_pub IN {?}, email, NULL) AS user_email
 612                                  FROM  profile_job
 613                                 WHERE  pid IN {?} AND pub IN {?}
 614                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids) . ', id',
 615                                  $visibility->levels(), $pids, $visibility->levels());
 616         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 617     }
 618
 619     public function get($flags, $limit = null)
 620     {
 621         $jobs = array();
 622         $nb = 0;
 623         foreach ($this->jobs as $id => $job) {
 624             $jobs[$id] = $job;
 625             ++$nb;
 626             if ($limit != null && $nb >= $limit) {
 627                 break;
 628             }
 629         }
 630         return $jobs;
 631     }
 632
 633     public function addPhones(ProfilePhones $phones)
 634     {
 635         $p = $phones->get(Profile::PHONE_LINK_JOB | Profile::PHONE_TYPE_ANY);
 636         foreach ($p as $phone) {
 637             if ($phone->link_type == Phone::LINK_JOB && array_key_exists($phone->link_id, $this->jobs)) {
 638                 $this->jobs[$phone->link_id]->addPhone($phone);
 639             }
 640         }
 641     }
 642
 643     public function addAddresses(ProfileAddresses $addresses)
 644     {
 645         $a = $addresses->get(Profile::ADDRESS_PRO);
 646         foreach ($a as $address) {
 647             if ($address->type == Address::LINK_JOB && array_key_exists($address->jobid, $this->jobs)) {
 648                 $this->jobs[$address->id]->setAddress($address);
 649             }
 650         }
 651     }
 652
 653     public function addCompanies(array $companies)
 654     {
 655         foreach ($this->jobs as $job) {
 656             $this->company = $companies[$job->jobid];
 657         }
 658     }
 659
 660     public function addJobTerms(ProfileJobTerms $jobterms)
 661     {
 662         $terms = $jobterms->get();
 663         foreach ($terms as $term) {
 664             if ($this->pid == $term->pid && array_key_exists($term->jid, $this->jobs)) {
 665                 $this->jobs[$term->jid]->addTerm($term);
 666             }
 667         }
 668     }
 669 }
 670 // }}}
 671 // {{{ class ProfileJobTerms                          [ Field ]
 672 class ProfileJobTerms extends ProfileField
 673 {
 674     private $jobterms = array();
 675
 676     public function __construct(PlInnerSubIterator $it)
 677     {
 678         $this->pid = $it->value();
 679         while ($term = $it->next()) {
 680             $this->jobterms[] = new JobTerm($term);
 681         }
 682     }
 683
 684     public function get()
 685     {
 686         return $this->jobterms;
 687     }
 688
 689     public static function fetchData(array $pids, ProfileVisibility $visibility)
 690     {
 691         $data = XDB::iterator('SELECT  jt.jtid, jte.full_name, jt.pid, jt.jid
 692                                  FROM  profile_job_term AS jt
 693                            INNER JOIN  profile_job AS j ON (jt.pid = j.pid AND jt.jid = j.id)
 694                             LEFT JOIN  profile_job_term_enum AS jte USING(jtid)
 695                                 WHERE  jt.pid IN {?} AND j.pub IN {?}
 696                              ORDER BY  ' . XDB::formatCustomOrder('jt.pid', $pids),
 697                                  $pids, $visibility->levels());
 698         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 699     }
 700 }
 701 // }}}
 702 // {{{ class ProfileMentoringTerms                    [ Field ]
 703 class ProfileMentoringTerms extends ProfileJobTerms
 704 {
 705     public static function fetchData(array $pids, ProfileVisibility $visibility)
 706     {
 707         $data = XDB::iterator('SELECT  mt.jtid, jte.full_name, mt.pid
 708                                  FROM  profile_mentor_term AS mt
 709                             LEFT JOIN  profile_job_term_enum AS jte USING(jtid)
 710                                 WHERE  mt.pid IN {?}
 711                              ORDER BY  ' . XDB::formatCustomOrder('mt.pid', $pids),
 712                                 $pids);
 713         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 714     }
 715 }
 716 // }}}
 717 // {{{ class CompanyList
 718 class CompanyList
 719 {
 720     static private $fullload = false;
 721     static private $companies = array();
 722
 723     static public function preload($pids = array())
 724     {
 725         if (self::$fullload) {
 726             return;
 727         }
 728         // Load raw data
 729         if (count($pids)) {
 730             $join = 'LEFT JOIN profile_job ON (profile_job.jobid = pje.id)';
 731             $where = 'WHERE profile_job.pid IN ' . XDB::formatArray($pids);
 732         } else {
 733             $join = '';
 734             $where = '';
 735         }
 736
 737         $it = XDB::iterator('SELECT  pje.id, pje.name, pje.acronym, pje.url,
 738                                      pa.flags, pa.text, pa.postalCode, pa.countryId,
 739                                      pa.type, pa.pub
 740                                FROM  profile_job_enum AS pje
 741                           LEFT JOIN  profile_addresses AS pa ON (pje.id = pa.jobid AND pa.type = \'hq\')
 742                                   ' . $join . '
 743                                   ' . $where);
 744         $newcompanies = array();
 745         while ($row = $it->next()) {
 746             $cp = new Company($row);
 747             $addr = new Address($row);
 748             $cp->setAddress($addr);
 749             if (!array_key_exists($row['id'], self::$companies)) {
 750                 $newcompanies[] = $row['id'];
 751             }
 752             self::$companies[$row['id']] = $cp;
 753         }
 754
 755         // Add phones to hq
 756         if (count($newcompanies)) {
 757             $it = Phone::iterate(array(), array(Phone::LINK_COMPANY), $newcompanies);
 758             while ($phone = $it->next()) {
 759                 self::$companies[$phone->link_id]->setPhone($phone);
 760             }
 761         }
 762
 763         if (count($pids) == 0) {
 764             self::$fullload = true;
 765         }
 766     }
 767
 768     static public function get($id)
 769     {
 770         if (!array_key_exists($id, self::$companies)) {
 771             self::preload();
 772         }
 773         if (isset(self::$companies[$id])) {
 774             return self::$companies[$id];
 775         }
 776         return null;
 777     }
 778 }
 779
 780 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
 781 ?>