include/profilefields.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 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_SECTOR  => 'ProfileMentoringSectors',
  37         Profile::FETCH_MENTOR_COUNTRY => 'ProfileMentoringCountries',
  38     );
  39
  40     /** The profile to which this field belongs
  41      */
  42     public $pid;
  43
  44     /** Fetches data from the database for the given pids, compatible with
  45      * the visibility context.
  46      * @param $pids An array of pids
  47      * @param $visibility The level of visibility fetched fields must have
  48      * @return a PlIterator yielding data suitable for a "new ProfileBlah($data)"
  49      * XXX MUST be reimplemented for each kind of ProfileField
  50      */
  51     public static function fetchData(array $pids, ProfileVisibility $visibility)
  52     {
  53         return PlIteratorUtils::emptyIterator();
  54     }
  55
  56     public static function buildForPID($cls, $pid, ProfileVisibility $visibility)
  57     {
  58         $res = self::buildFromPIDs($cls, array($pid), $visibility);
  59         return array_pop($res);
  60     }
  61
  62     /** Build a list of ProfileFields from a set of pids
  63      * @param $cls The name of the field to create ('ProfileMedals', ...)
  64      * @param $pids An array of pids
  65      * @param $visibility An array of allowed visibility contexts
  66      * @return An array of $pid => ProfileField
  67      */
  68     public static function buildFromPIDs($cls, array $pids, ProfileVisibility $visibility)
  69     {
  70         $it = new ProfileFieldIterator($cls, $pids, $visibility);
  71         $res = array();
  72         while ($pf = $it->next()) {
  73             $res[$pf->pid] = $pf;
  74         }
  75         return $res;
  76     }
  77
  78     public static function getForPID($cls, $pid, ProfileVisibility $visibility)
  79     {
  80         $it = new ProfileFieldIterator($cls, array($pid), $visibility);
  81         return $it->next();
  82     }
  83 }
  84 // }}}
  85
  86 // {{{ class ProfileFieldIterator
  87 class ProfileFieldIterator implements PlIterator
  88 {
  89     private $data;
  90     private $cls;
  91
  92     public function __construct($cls, array $pids, ProfileVisibility $visibility)
  93     {
  94         $this->data = call_user_func(array($cls, 'fetchData'), $pids, $visibility);
  95         $this->cls = $cls;
  96     }
  97
  98     public function next()
  99     {
 100         $d = $this->data->next();
 101         if ($d == null) {
 102             return null;
 103         } else {
 104             $cls = $this->cls;
 105             return new $cls($d);
 106         }
 107     }
 108
 109     public function total()
 110     {
 111         return $this->data->total();
 112     }
 113
 114     public function first()
 115     {
 116         return $this->data->first();
 117     }
 118
 119     public function last()
 120     {
 121         return $this->data->last();
 122     }
 123 }
 124 // }}}
 125
 126 // {{{ class Phone
 127 class Phone
 128 {
 129     const TYPE_FAX    = 'fax';
 130     const TYPE_FIXED  = 'fixed';
 131     const TYPE_MOBILE = 'mobile';
 132     public $type;
 133
 134     public $search;
 135     public $display;
 136     public $comment = '';
 137
 138     const LINK_JOB     = 'pro';
 139     const LINK_ADDRESS = 'address';
 140     const LINK_PROFILE = 'user';
 141     const LINK_COMPANY = 'hq';
 142     public $link_type;
 143     public $link_id;
 144
 145     public $id;
 146
 147     /** Fields are :
 148      * $type, $search, $display, $link_type, $link_id, $comment, $pid, $id
 149      */
 150     public function __construct($data)
 151     {
 152         foreach ($data as $key => $val) {
 153             $this->$key = $val;
 154         }
 155     }
 156
 157     /** Returns the unique ID of a phone
 158      * This ID will allow to link it to an address, a user or a job
 159      * The format is address_addressId_phoneId (where phoneId is the id
 160      * of the phone in the list of those associated with the address)
 161      */
 162     public function uid() {
 163         return $this->link_type . '_' . $this->link_id . '_' . $this->id;
 164     }
 165
 166     public function hasFlags($flags) {
 167         return $this->hasType($flags) && $this->hasLink($flags);
 168     }
 169
 170     /** Returns true if this phone's type matches the flags
 171      */
 172     public function hasType($flags) {
 173         $flags = $flags & Profile::PHONE_TYPE_ANY;
 174         return (
 175             ($flags == Profile::PHONE_TYPE_ANY)
 176             ||
 177             (($flags & Profile::PHONE_TYPE_FAX) && $this->type == self::TYPE_FAX)
 178             ||
 179             (($flags & Profile::PHONE_TYPE_FIXED) && $this->type == self::TYPE_FIXED)
 180             ||
 181             (($flags & Profile::PHONE_TYPE_MOBILE) && $this->type == self::TYPE_MOBILE)
 182         );
 183     }
 184
 185     /** User accessible version of the type
 186      */
 187     public function displayType($short = false)
 188     {
 189         switch ($this->type) {
 190           case Phone::TYPE_FIXED:
 191             return $short ? 'Tél' : 'Fixe';
 192           case Phone::TYPE_FAX:
 193             return 'Fax';
 194           case Phone::TYPE_MOBILE:
 195             return $short ? 'Mob' : 'Mobile';
 196           default:
 197             return $this->type;
 198         }
 199     }
 200
 201     /** Returns true if this phone's link matches the flags
 202      */
 203     public function hasLink($flags) {
 204         $flags = $flags & Profile::PHONE_LINK_ANY;
 205         return (
 206             ($flags == Profile::PHONE_LINK_ANY)
 207             ||
 208             (($flags & Profile::PHONE_LINK_COMPANY) && $this->link_type == self::LINK_COMPANY)
 209             ||
 210             (($flags & Profile::PHONE_LINK_JOB) && $this->link_type == self::LINK_JOB)
 211             ||
 212             (($flags & Profile::PHONE_LINK_ADDRESS) && $this->link_type == self::LINK_ADDRESS)
 213             ||
 214             (($flags & Profile::PHONE_LINK_PROFILE) && $this->link_type == self::LINK_PROFILE)
 215         );
 216     }
 217 }
 218 // }}}
 219 // {{{ class Company
 220 class Company
 221 {
 222     public $id;
 223     public $name;
 224     public $acronym;
 225     public $url;
 226     public $phone = null;
 227     public $address = null;
 228
 229     /** Fields are:
 230      * $id, $name, $acronym, $url
 231      */
 232     public function __construct($data)
 233     {
 234         foreach ($data as $key => $val) {
 235             $this->$key = $val;
 236         }
 237     }
 238
 239     public function setPhone(Phone &$phone)
 240     {
 241         if ($phone->link_type == Phone::LINK_COMPANY && $phone->link_id == $this->id) {
 242             $this->phone = $phone;
 243         }
 244     }
 245
 246     public function setAddress(Address &$address)
 247     {
 248         if ($address->link_type == Address::LINK_COMPANY && $address->link_id == $this->id) {
 249             $this->address = $address;
 250         }
 251     }
 252
 253 }
 254 // }}}
 255 // {{{ class Job
 256 class Job
 257 {
 258     public $pid;
 259     public $id;
 260
 261     public $company = null;
 262     private $phones = array();
 263     private $address = null;
 264
 265     public $jobid;
 266
 267     public $description;
 268     public $user_site;
 269     public $user_email;
 270
 271     public $sector;
 272     public $subsector;
 273     public $subsubsector;
 274
 275     /** Fields are:
 276      * pid, id, company_id, description, url, email
 277      */
 278     public function __construct($data)
 279     {
 280         foreach ($data as $key => $val) {
 281             $this->$key = $val;
 282         }
 283         $this->company = CompanyList::get($this->jobid);
 284     }
 285
 286     public function phones()
 287     {
 288         return $this->phones;
 289     }
 290
 291     public function address()
 292     {
 293         return $this->address;
 294     }
 295
 296     public function addPhone(Phone &$phone)
 297     {
 298         if ($phone->link_type == Phone::LINK_JOB && $phone->link_id == $this->id && $phone->pid == $this->pid) {
 299             $this->phones[$phone->uid()] = $phone;
 300         }
 301     }
 302
 303     public function setAddress(Address $address)
 304     {
 305         if ($address->link_type == Address::LINK_JOB && $address->link_id == $this->id && $address->pid == $this->pid) {
 306             $this->address = $address;
 307         }
 308     }
 309 }
 310 // }}}
 311 // {{{ class Address
 312 class Address
 313 {
 314     const LINK_JOB     = 'job';
 315     const LINK_COMPANY = 'hq';
 316     const LINK_PROFILE = 'home';
 317
 318     public $flags;
 319     public $id; // The ID of the address among those associated with its link
 320     public $link_id; // The ID of the object to which the address is linked (profile, job, company)
 321     public $link_type;
 322
 323     public $text;
 324     public $postalCode;
 325     public $latitude;
 326     public $longitude;
 327
 328     public $locality;
 329     public $subAdministrativeArea;
 330     public $administrativeArea;
 331     public $country;
 332
 333     public $comment;
 334
 335     private $phones = array();
 336
 337     /** Fields are:
 338      * pîd, id, link_id, link_type, flags, text, postcode, country
 339      */
 340     public function __construct($data)
 341     {
 342         foreach ($data as $key => $val) {
 343             $this->$key = $val;
 344         }
 345         $this->flags = new PlFlagSet($this->flags);
 346     }
 347
 348     public function uid() {
 349         $uid = $this->link_type . '_';
 350         if ($this->link_type != self::LINK_COMPANY) {
 351             $uid .= $this->pid . '_';
 352         }
 353         $uid .= $this->link_id . '_' . $this->id;
 354     }
 355
 356     public function addPhone(Phone &$phone)
 357     {
 358         if (
 359             $phone->link_type == Phone::LINK_ADDRESS && $phone->link_id == $this->id &&
 360             ($this->link_type == self::LINK_COMPANY || $phone->pid == $this->pid) ) {
 361             $this->phones[$phone->uid()] = $phone;
 362         }
 363     }
 364
 365     public function phones()
 366     {
 367         return $this->phones;
 368     }
 369
 370     public function hasFlag($flag)
 371     {
 372         if (!$this->flags instanceof PlFlagSet) {
 373             $this->flags = new PlFlagSet($this->flags);
 374         }
 375         return $this->flags->hasFlag($flag);
 376     }
 377 }
 378 // }}}
 379 // {{{ class Education
 380 class Education
 381 {
 382     public $id;
 383     public $pid;
 384
 385     public $entry_year;
 386     public $grad_year;
 387     public $program;
 388     public $flags;
 389
 390     public $school;
 391     public $school_short;
 392     public $school_url;
 393     public $country;
 394
 395     public $degree;
 396     public $degree_short;
 397     public $degree_level;
 398
 399     public $field;
 400
 401     public function __construct(array $data)
 402     {
 403         foreach ($data as $key => $val) {
 404             $this->$key = $val;
 405         }
 406         $this->flags      = new PlFlagSet($this->flags);
 407     }
 408 }
 409 // }}}
 410
 411 // {{{ class ProfileEducation                         [ Field ]
 412 class ProfileEducation extends ProfileField
 413 {
 414     private $educations = array();
 415
 416     public function __construct(PlInnerSubIterator $it)
 417     {
 418         $this->pid = $it->value();
 419         while ($edu = $it->next()) {
 420             $this->educations[$edu['id']] = new Education($edu);
 421         }
 422     }
 423
 424     public function get($flags, $limit)
 425     {
 426         $educations = array();
 427         $year = getdate();
 428         $year = $year['year'];
 429         $nb = 0;
 430         foreach ($this->educations as $id => $edu) {
 431             if (
 432                 (($flags & Profile::EDUCATION_MAIN) && $edu->flags->hasFlag('primary'))
 433                 ||
 434                 (($flags & Profile::EDUCATION_EXTRA) && !$edu->flags->hasFlag('primary'))
 435                 ||
 436                 (($flags & Profile::EDUCATION_FINISHED) && $edu->grad_year <= $year)
 437                 ||
 438                 (($flags & Profile::EDUCATION_CURRENT) && $edu->grad_year > $year)
 439                 ||
 440                 ($flags & Profile::EDUCATION_ALL)
 441             ) {
 442                 $educations[$id] = $edu;
 443                 ++$nb;
 444             }
 445             if ($limit != null && $nb >= $limit) {
 446                 break;
 447             }
 448         }
 449         return $educations;
 450     }
 451
 452     public static function fetchData(array $pids, ProfileVisibility $visibility)
 453     {
 454         $data = XDB::iterator('SELECT  pe.id, pe.pid,
 455                                        pe.entry_year, pe.grad_year, pe.program, pe.flags,
 456                                        pee.name AS school, pee.abbreviation AS school_short,
 457                                        pee.url AS school_url, gc.countryFR AS country,
 458                                        pede.degree, pede.abbreviation AS degree_short, pede.level AS degree_level,
 459                                        pefe.field
 460                                  FROM  profile_education AS pe
 461                             LEFT JOIN  profile_education_enum AS pee ON (pee.id = pe.eduid)
 462                             LEFT JOIN  geoloc_countries AS gc ON (gc.iso_3166_1_a2 = pee.country)
 463                             LEFT JOIN  profile_education_degree_enum AS pede ON (pede.id = pe.degreeid)
 464                             LEFT JOIN  profile_education_field_enum AS pefe ON (pefe.id = pe.fieldid)
 465                                 WHERE  pe.pid IN {?}
 466                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids) . ',
 467                                        NOT FIND_IN_SET(\'primary\', pe.flags), pe.entry_year, pe.id',
 468                                 $pids);
 469
 470         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 471     }
 472 }
 473 // }}}
 474 // {{{ class ProfileMedals                            [ Field ]
 475 class ProfileMedals extends ProfileField
 476 {
 477     public $medals = array();
 478
 479     public function __construct(PlInnerSubIterator $it)
 480     {
 481         $this->pid = $it->value();
 482         while ($medal = $it->next()) {
 483             $this->medals[$medal['mid']] = $medal;
 484         }
 485     }
 486
 487     public static function fetchData(array $pids, ProfileVisibility $visibility)
 488     {
 489         $data = XDB::iterator('SELECT  pm.pid, pm.mid, pm.gid, pme.text, pme.img, pmge.text AS grade
 490                                  FROM  profile_medals AS pm
 491                             LEFT JOIN  profiles AS p ON (pm.pid = p.pid)
 492                             LEFT JOIN  profile_medal_enum AS pme ON (pme.id = pm.mid)
 493                             LEFT JOIN  profile_medal_grade_enum AS pmge ON (pmge.mid = pm.mid AND pmge.gid = pm.gid)
 494                                 WHERE  pm.pid IN {?} AND p.medals_pub IN {?}
 495                              ORDER BY  ' . XDB::formatCustomOrder('pm.pid', $pids),
 496                                 $pids, $visibility->levels());
 497
 498         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 499     }
 500 }
 501 // }}}
 502 // {{{ class ProfileNetworking                        [ Field ]
 503 class ProfileNetworking extends ProfileField
 504 {
 505     private $networks = array();
 506
 507     public function __construct(PlInnerSubIterator $it)
 508     {
 509         $this->pid = $it->value();
 510         while ($network = $it->next()) {
 511             $network['network_type'] = new PlFlagSet($network['network_type']);
 512             $this->networks[$network['id']] = $network;
 513         }
 514     }
 515
 516     public static function fetchData(array $pids, ProfileVisibility $visibility)
 517     {
 518         $data = XDB::iterator('SELECT  pid, id, address, pne.nwid, pne.network_type, pne.link, pne.name
 519                                  FROM  profile_networking AS pn
 520                             LEFT JOIN  profile_networking_enum AS pne USING(nwid)
 521                                 WHERE  pid IN {?} AND pub IN {?}
 522                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids) . ',
 523                                        pn.nwid, id',
 524                                $pids, $visibility->levels());
 525
 526         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 527     }
 528
 529     public function get($flags, $limit = null)
 530     {
 531         if (!$flags) {
 532             $flags = Profile::NETWORKING_ALL;
 533         }
 534         $nws = array();
 535         $nb = 0;
 536         foreach ($this->networks as $id => $nw) {
 537             if (($flags & Profile::NETWORKING_WEB) && $nw['network_type']->hasFlag('web') ||
 538                 ($flags & Profile::NETWORKING_IM) && $nw['network_type']->hasFlag('im') ||
 539                 ($flags & Profile::NETWORKING_SOCIAL) && $nw['network_type']->hasFlag('social') ||
 540                 ($flags & Profile::NETWORKING_ALL)) {
 541                 $nws[$id] = $nw;
 542                 ++$nb;
 543                 if (isset($limit) && $nb >= $limit) {
 544                     break;
 545                 }
 546             }
 547         }
 548         return $nws;
 549     }
 550 }
 551 // }}}
 552 // {{{ class ProfileCorps                             [ Field ]
 553 class ProfileCorps extends ProfileField
 554 {
 555     public $original;
 556     public $current;
 557
 558     public $original_name;
 559     public $original_abbrev;
 560     public $original_still_exists;
 561
 562     public $current_name;
 563     public $current_abbrev;
 564     public $current_still_exists;
 565     public $current_rank;
 566     public $current_rank_abbrev;
 567
 568     public function __construct(array $data)
 569     {
 570         foreach ($data as $key => $val) {
 571             $this->$key = $val;
 572         }
 573     }
 574
 575     public static function fetchData(array $pids, ProfileVisibility $visibility)
 576     {
 577         $data = XDB::iterator('SELECT  pc.pid, pc.original_corpsid AS original, pc.current_corpsid AS current,
 578                                        pceo.name AS original_name, pceo.abbreviation AS original_abbrev,
 579                                        pceo.still_exists AS original_still_exists,
 580                                        pcec.name AS current_name, pcec.abbreviation AS current_abbrev,
 581                                        pcec.still_exists AS current_still_exists,
 582                                        pcrec.name AS current_rank, pcrec.abbreviation AS current_rank_abbrev,
 583                                        rankid
 584                                  FROM  profile_corps AS pc
 585                             LEFT JOIN  profile_corps_enum AS pceo ON (pceo.id = pc.original_corpsid)
 586                             LEFT JOIN  profile_corps_enum AS pcec ON (pcec.id = pc.current_corpsid)
 587                             LEFT JOIN  profile_corps_rank_enum AS pcrec ON (pcrec.id = pc.rankid)
 588                                 WHERE  pc.pid IN {?} AND pc.corps_pub IN {?} AND pceo.id != 1
 589                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids),
 590                                 $pids, $visibility->levels());
 591
 592         return $data;
 593     }
 594 }
 595 // }}}
 596 // {{{ class ProfileMentoringSectors                  [ Field ]
 597 class ProfileMentoringSectors extends ProfileField
 598 {
 599     public $sectors = array();
 600
 601     public function __construct(PlInnerSubIterator $it)
 602     {
 603         $this->pid = $it->value();
 604         while ($sector = $it->next()) {
 605             $this->sectors[] = $sector;
 606         }
 607     }
 608
 609     public static function fetchData(array $pids, ProfileVisibility $visibility)
 610     {
 611         $data = XDB::iterator('SELECT  pms.pid, pjse.name AS sector, pjsse.name AS subsector
 612                                  FROM  profile_mentor_sector AS pms
 613                             LEFT JOIN  profile_job_sector_enum AS pjse ON (pjse.id = pms.sectorid)
 614                             LEFT JOIN  profile_job_subsector_enum AS pjsse ON (pjsse.id = pms.subsectorid)
 615                                 WHERE  pms.pid IN {?}
 616                              ORDER BY  ' . XDB::formatCustomOrder('pms.pid', $pids),
 617                                 $pids);
 618
 619         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 620     }
 621 }
 622 // }}}
 623 // {{{ class ProfileMentoringCountries                [ Field ]
 624 class ProfileMentoringCountries extends ProfileField
 625 {
 626     public $countries = array();
 627
 628     public function __construct(PlInnerSubIterator $it)
 629     {
 630         $this->pid = $it->value();
 631         while ($country = $it->next()) {
 632             $this->countries[$country['id']] = $country['name'];
 633         }
 634     }
 635
 636     public static function fetchData(array $pids, ProfileVisibility $visibility)
 637     {
 638         $data = XDB::iterator('SELECT  pmc.pid, pmc.country AS id, gc.countryFR AS name
 639                                  FROM  profile_mentor_country AS pmc
 640                             LEFT JOIN  geoloc_countries AS gc ON (gc.iso_3166_1_a2 = pmc.country)
 641                                 WHERE  pmc.pid IN {?}
 642                              ORDER BY  ' . XDB::formatCustomOrder('pmc.pid', $pids),
 643                                 $pids);
 644
 645         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 646     }
 647 }
 648 // }}}
 649
 650 /** Loading of data for a Profile :
 651  * 1) load jobs, addresses, phones
 652  * 2) attach phones to addresses, jobs and profiles
 653  * 3) attach addresses to jobs and profiles
 654  */
 655
 656 // {{{ Database schema (profile_address, profile_phones, profile_jobs)
 657 /** The database for this is very unclear, so here is a little schema :
 658  * profile_job describes a Job, links to:
 659  * - a Profile, through `pid`
 660  * - a Company, through `jobid`
 661  * The `id` field is the id of this job in the list of the jobs of its profile
 662  *
 663  * profile_addresses describes an Address, which
 664  * related to either a Profile, a Job or a Company:
 665  * - for a Profile:
 666  *   - `type` is set to 'home'
 667  *   - `pid` is set to the related profile pid
 668  *   - `id` is the id of the address in the list of those related to that profile
 669  *   - `jobid` is empty
 670  *
 671  * - for a Company:
 672  *   - `type` is set to 'hq'
 673  *   - `pid` is set to 0
 674  *   - `jobid` is set to the id of the company
 675  *   - `id` is set to 0 (only one address per Company)
 676  *
 677  * - for a Job:
 678  *   - `type` is set to 'job'
 679  *   - `pid` is set to the pid of the Profile of the related Job
 680  *   - `jobid` is set to the Company of the job (this information is redundant
 681  *              with that of the row of profile_job for the related job)
 682  *   - `id` is the id of the job to which we refer (i.e `profile_job.id`)
 683  *
 684  * profile_phone describes a Phone, which can be related to an Address,
 685  * a Job, a Profile or a Company:
 686  * - for a Profile:
 687  *   - `link_type` is set to 'user'
 688  *   - `link_id` is set to 0
 689  *   - `pid` is set to the id of the related Profile
 690  *
 691  * - for a Company:
 692  *   - `link_type` is set to 'hq'
 693  *   - `link_id` is set to the id of the related Company
 694  *   - `pid` is set to 0
 695  *
 696  * - for an Address (this is only possible for a *personal* address)
 697  *   - `link_type` is set to 'address'
 698  *   - `link_id` is set to the related Address `id`
 699  *   - `pid` is set to the related Address `pid`
 700  *
 701  * - for a Job:
 702  *   - `link_type` is set to 'pro'
 703  *   - `link_id` is set to the related Job `id` (not `jobid`)
 704  *   - `pid` is set to the related Job `pid`
 705  *
 706  *
 707  * The possible relations are as follow:
 708  * An Address can be linked to a Company, a Profile, a Job
 709  * A Job is linked to a Company and a Profile
 710  * A Phone can be linked to a Company, a Profile, a Job, or a Profile-related Address
 711  */
 712 // }}}
 713
 714 // {{{ class ProfileAddresses                         [ Field ]
 715 class ProfileAddresses extends ProfileField
 716 {
 717     private $addresses = array();
 718
 719     public function __construct(PlIterator $it)
 720     {
 721         if ($it instanceof PlInnerSubIterator) {
 722             $this->pid = $it->value();
 723         }
 724
 725         while ($addr = $it->next()) {
 726             $this->addresses[] = new Address($addr);
 727         }
 728     }
 729
 730     public function get($flags, $limit = null)
 731     {
 732         $res = array();
 733         $nb = 0;
 734         foreach ($this->addresses as $addr) {
 735             if (
 736                 (($flags & Profile::ADDRESS_MAIN) && $addr->hasFlag('current'))
 737                 ||
 738                 (($flags & Profile::ADDRESS_POSTAL) && $addr->hasFlag('mail'))
 739                 ||
 740                 (($flags & Profile::ADDRESS_PERSO) && $addr->link_type == Address::LINK_PROFILE)
 741                 ||
 742                 (($flags & Profile::ADDRESS_PRO) && $addr->link_type == Address::LINK_JOB)
 743             ) {
 744                 $res[] = $addr;
 745                 $nb++;
 746             }
 747             if ($limit != null && $nb == $limit) {
 748                 break;
 749             }
 750         }
 751         return $res;
 752     }
 753
 754     public static function fetchData(array $pids, ProfileVisibility $visibility)
 755     {
 756         $data = XDB::iterator('SELECT  pa.id, pa.pid, pa.flags, pa.type AS link_type,
 757                                        IF(pa.type = \'home\', pid, IF(pa.type = \'job\', pa.id, jobid)) AS link_id,
 758                                        pa.text, pa.postalCode, pa.latitude, pa.longitude, pa.comment,
 759                                        gl.name AS locality, gas.name AS subAdministrativeArea,
 760                                        ga.name AS administrativeArea, gc.countryFR AS country
 761                                  FROM  profile_addresses AS pa
 762                             LEFT JOIN  geoloc_localities AS gl ON (gl.id = pa.localityId)
 763                             LEFT JOIN  geoloc_administrativeareas AS ga ON (ga.id = pa.administrativeAreaId)
 764                             LEFT JOIN  geoloc_administrativeareas AS gas ON (gas.id = pa.subAdministrativeAreaId)
 765                             LEFT JOIN  geoloc_countries AS gc ON (gc.iso_3166_1_a2 = pa.countryId)
 766                                 WHERE  pa.pid in {?} AND pa.pub IN {?}
 767                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids),
 768                                $pids, $visibility->levels());
 769
 770         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 771     }
 772
 773     public function addPhones(ProfilePhones $phones)
 774     {
 775         $p = $phones->get(Profile::PHONE_LINK_ADDRESS | Profile::PHONE_TYPE_ANY);
 776         foreach ($p as $phone) {
 777             if ($phone->link_type == Phone::LINK_ADDRESS && array_key_exists($phone->link_id, $this->addresses)) {
 778                 $this->addresses[$phone->link_id]->addPhone($phone);
 779             }
 780         }
 781     }
 782 }
 783 // }}}
 784 // {{{ class ProfilePhones                            [ Field ]
 785 class ProfilePhones extends ProfileField
 786 {
 787     private $phones = array();
 788
 789     public function __construct(PlInnerSubIterator $it)
 790     {
 791         $this->pid = $it->value();
 792         while ($phone = $it->next()) {
 793             $this->phones[] = new Phone($phone);
 794         }
 795     }
 796
 797     public function get($flags, $limit = null)
 798     {
 799         $phones = array();
 800         $nb = 0;
 801         foreach ($this->phones as $id => $phone) {
 802             if ($phone->hasFlags($flags)) {
 803                 $phones[$id] = $phone;
 804                 ++$nb;
 805                 if ($limit != null && $nb == $limit) {
 806                     break;
 807                 }
 808             }
 809         }
 810         return $phones;
 811     }
 812
 813     public static function fetchData(array $pids, ProfileVisibility $visibility)
 814     {
 815         $data = XDB::iterator('SELECT  tel_type AS type, search_tel AS search, display_tel AS display, link_type, comment, pid, link_id, tel_id AS id
 816                                  FROM  profile_phones
 817                                 WHERE  pid IN {?} AND pub IN {?}
 818                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids),
 819                                  $pids, $visibility->levels());
 820         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 821     }
 822 }
 823 // }}}
 824 // {{{ class ProfileJobs                              [ Field ]
 825 class ProfileJobs extends ProfileField
 826 {
 827     private $jobs = array();
 828
 829     public function __construct(PlInnerSubIterator $jobs)
 830     {
 831         $this->pid = $jobs->value();
 832         while ($job = $jobs->next()) {
 833             $this->jobs[$job['id']] = new Job($job);
 834         }
 835     }
 836
 837     public static function fetchData(array $pids, ProfileVisibility $visibility)
 838     {
 839         CompanyList::preload($pids);
 840         $data = XDB::iterator('SELECT  pj.id, pj.pid, pj.description, pj.url as user_site,
 841                                        IF(pj.email_pub IN {?}, pj.email, NULL) AS user_email,
 842                                        pj.jobid, pjse.name AS sector, pjsse.name AS subsector,
 843                                        pjssse.name AS subsubsector
 844                                  FROM  profile_job AS pj
 845                             LEFT JOIN  profile_job_sector_enum AS pjse ON (pjse.id = pj.sectorid)
 846                             LEFT JOIN  profile_job_subsector_enum AS pjsse ON (pjsse.id = pj.subsectorid)
 847                             LEFT JOIN  profile_job_subsubsector_enum AS pjssse ON (pjssse.id = pj.subsubsectorid)
 848                                 WHERE  pj.pid IN {?} AND pj.pub IN {?}
 849                              ORDER BY  ' . XDB::formatCustomOrder('pid', $pids) . ',
 850                                        pj.id',
 851                                  $visibility->levels(), $pids, $visibility->levels());
 852         return PlIteratorUtils::subIterator($data, PlIteratorUtils::arrayValueCallback('pid'));
 853     }
 854
 855     public function get($flags, $limit = null)
 856     {
 857         $jobs = array();
 858         $nb = 0;
 859         foreach ($this->jobs as $id => $job) {
 860             $jobs[$id] = $job;
 861             ++$nb;
 862             if ($limit != null && $nb >= $limit) {
 863                 break;
 864             }
 865         }
 866         return $jobs;
 867     }
 868
 869     public function addPhones(ProfilePhones $phones)
 870     {
 871         $p = $phones->get(Profile::PHONE_LINK_JOB | Profile::PHONE_TYPE_ANY);
 872         foreach ($p as $phone) {
 873             if ($phone->link_type == Phone::LINK_JOB && array_key_exists($phone->link_id, $this->jobs)) {
 874                 $this->jobs[$phone->link_id]->addPhone($phone);
 875             }
 876         }
 877     }
 878
 879     public function addAddresses(ProfileAddresses $addresses)
 880     {
 881         $a = $addresses->get(Profile::ADDRESS_PRO);
 882         foreach ($a as $address) {
 883             if ($address->link_type == Address::LINK_JOB && array_key_exists($address->link_id, $this->jobs)) {
 884                 $this->jobs[$address->link_id]->setAddress($address);
 885             }
 886         }
 887     }
 888
 889     public function addCompanies(array $companies)
 890     {
 891         foreach ($this->jobs as $job) {
 892             $this->company = $companies[$job->jobid];
 893         }
 894     }
 895 }
 896 // }}}
 897
 898 // {{{ class CompanyList
 899 class CompanyList
 900 {
 901     static private $fullload = false;
 902     static private $companies = array();
 903
 904     static public function preload($pids = array())
 905     {
 906         if (self::$fullload) {
 907             return;
 908         }
 909         // Load raw data
 910         if (count($pids)) {
 911             $join = 'LEFT JOIN profile_job ON (profile_job.jobid = pje.id)';
 912             $where = 'WHERE profile_job.pid IN ' . XDB::formatArray($pids);
 913         } else {
 914             $join = '';
 915             $where = '';
 916         }
 917
 918         $it = XDB::iterator('SELECT  pje.id, pje.name, pje.acronym, pje.url,
 919                                      pa.flags, pa.text, pa.postalCode, pa.countryId,
 920                                      pa.type, pa.pub
 921                                FROM  profile_job_enum AS pje
 922                           LEFT JOIN  profile_addresses AS pa ON (pje.id = pa.jobid AND pa.type = \'hq\')
 923                                   ' . $join . '
 924                                   ' . $where);
 925         $newcompanies = array();
 926         while ($row = $it->next()) {
 927             $cp = new Company($row);
 928             $addr = new Address($row);
 929             $cp->setAddress($addr);
 930             if (!array_key_exists($row['id'], self::$companies)) {
 931                 $newcompanies[] = $row['id'];
 932             }
 933             self::$companies[$row['id']] = $cp;
 934         }
 935
 936         // TODO: determine whether there can be phones attached to a hq's address
 937         // Add phones to hq
 938         if (count($newcompanies)) {
 939             $it = XDB::iterator('SELECT  search_tel AS search, display_tel AS display, comment, link_id, tel_type AS type, link_type, tel_id AS id
 940                                    FROM  profile_phones
 941                                   WHERE  link_id IN {?} AND link_type = \'hq\'',
 942                                     $newcompanies);
 943             while ($row = $it->next()) {
 944                 $p = new Phone($row);
 945                 self::$companies[$row['link_id']]->setPhone($p);
 946             }
 947         }
 948
 949         if (count($pids) == 0) {
 950             self::$fullload = true;
 951         }
 952     }
 953
 954     static public function get($id)
 955     {
 956         if (!array_key_exists($id, self::$companies)) {
 957             self::preload();
 958         }
 959         return self::$companies[$id];
 960     }
 961 }
 962
 963 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
 964 ?>