mirror of
https://gitlab.com/Chill-Projet/chill-bundles.git
synced 2025-06-29 13:36:13 +00:00
1184 lines
28 KiB
PHP
1184 lines
28 KiB
PHP
<?php
|
|
|
|
namespace Chill\PersonBundle\Entity;
|
|
|
|
/*
|
|
* Chill is a software for social workers
|
|
*
|
|
* Copyright (C) 2014-2015, Champs Libres Cooperative SCRLFS,
|
|
* <http://www.champs-libres.coop>, <info@champs-libres.coop>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
use ArrayIterator;
|
|
use Chill\MainBundle\Entity\Center;
|
|
use Chill\MainBundle\Entity\Country;
|
|
use Chill\PersonBundle\Entity\MaritalStatus;
|
|
use Chill\MainBundle\Entity\HasCenterInterface;
|
|
use Chill\MainBundle\Entity\Address;
|
|
use DateTime;
|
|
use Doctrine\ORM\Mapping as ORM;
|
|
use Doctrine\Common\Collections\Collection;
|
|
use Doctrine\Common\Collections\ArrayCollection;
|
|
use Doctrine\Common\Collections\Criteria;
|
|
use Symfony\Component\Validator\Context\ExecutionContextInterface;
|
|
use Symfony\Component\Serializer\Annotation\DiscriminatorMap;
|
|
|
|
/**
|
|
* Person Class
|
|
*
|
|
* @ORM\Entity
|
|
* @ORM\Table(name="chill_person_person",
|
|
* indexes={@ORM\Index(
|
|
* name="person_names",
|
|
* columns={"firstName", "lastName"}
|
|
* )})
|
|
* @ORM\HasLifecycleCallbacks()
|
|
* @DiscriminatorMap(typeProperty="type", mapping={
|
|
* "person"=Person::class
|
|
* })
|
|
*/
|
|
class Person implements HasCenterInterface
|
|
{
|
|
/**
|
|
* The person's id
|
|
* @var integer
|
|
*
|
|
* @ORM\Id
|
|
* @ORM\Column(name="id", type="integer")
|
|
* @ORM\GeneratedValue(strategy="AUTO")
|
|
*/
|
|
private $id;
|
|
|
|
/**
|
|
* The person's first name
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="string", length=255)
|
|
*/
|
|
private $firstName;
|
|
|
|
/**
|
|
* The person's last name
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="string", length=255)
|
|
*/
|
|
private $lastName;
|
|
|
|
/**
|
|
* @var Collection
|
|
*
|
|
* @ORM\OneToMany(
|
|
* targetEntity="Chill\PersonBundle\Entity\PersonAltName",
|
|
* mappedBy="person",
|
|
* cascade={"persist", "remove", "merge", "detach"},
|
|
* orphanRemoval=true)
|
|
*/
|
|
private $altNames;
|
|
|
|
/**
|
|
* The person's birthdate
|
|
* @var \DateTime
|
|
*
|
|
* @ORM\Column(type="date", nullable=true)
|
|
*/
|
|
private $birthdate; //to change in birthdate
|
|
|
|
/**
|
|
* The person's place of birth
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="string", length=255, name="place_of_birth")
|
|
*/
|
|
private $placeOfBirth = '';
|
|
|
|
/**
|
|
* The person's country of birth
|
|
* @var Country
|
|
*
|
|
* @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Country")
|
|
*
|
|
* sf4 check: option inversedBy="birthsIn" return error mapping !!
|
|
*
|
|
* @ORM\JoinColumn(nullable=true)
|
|
*/
|
|
private $countryOfBirth;
|
|
|
|
/**
|
|
* The person's nationality
|
|
* @var Country
|
|
*
|
|
* @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Country")
|
|
*
|
|
* sf4 check: option inversedBy="nationals" return error mapping !!
|
|
*
|
|
* @ORM\JoinColumn(nullable=true)
|
|
*/
|
|
private $nationality;
|
|
|
|
/**
|
|
* The person's gender
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="string", length=9, nullable=true)
|
|
*/
|
|
private $gender;
|
|
|
|
const MALE_GENDER = 'man';
|
|
const FEMALE_GENDER = 'woman';
|
|
const BOTH_GENDER = 'both';
|
|
|
|
/**
|
|
* The marital status of the person
|
|
* @var MaritalStatus
|
|
*
|
|
* @ORM\ManyToOne(targetEntity="Chill\PersonBundle\Entity\MaritalStatus")
|
|
* @ORM\JoinColumn(nullable=true)
|
|
*/
|
|
private $maritalStatus;
|
|
|
|
/**
|
|
* Contact information for contacting the person
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="text", nullable=true)
|
|
*/
|
|
private $contactInfo = '';
|
|
|
|
/**
|
|
* The person's email
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="text", nullable=true)
|
|
*/
|
|
private $email = '';
|
|
|
|
/**
|
|
* The person's phonenumber
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="text", length=40, nullable=true)
|
|
*/
|
|
private $phonenumber = '';
|
|
|
|
/**
|
|
* The person's mobile phone number
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="text", length=40, nullable=true)
|
|
*/
|
|
private $mobilenumber = '';
|
|
|
|
/**
|
|
* @var Collection
|
|
*
|
|
* @ORM\OneToMany(
|
|
* targetEntity="Chill\PersonBundle\Entity\PersonPhone",
|
|
* mappedBy="person",
|
|
* cascade={"persist", "remove", "merge", "detach"},
|
|
* orphanRemoval=true
|
|
* )
|
|
*/
|
|
private $otherPhoneNumbers;
|
|
|
|
//TO-ADD caseOpeningDate
|
|
//TO-ADD nativeLanguag
|
|
|
|
/**
|
|
* The person's spoken languages
|
|
* @var ArrayCollection
|
|
*
|
|
* @ORM\ManyToMany(targetEntity="Chill\MainBundle\Entity\Language")
|
|
* @ORM\JoinTable(
|
|
* name="persons_spoken_languages",
|
|
* joinColumns={@ORM\JoinColumn(name="person_id", referencedColumnName="id")},
|
|
* inverseJoinColumns={@ORM\JoinColumn(name="language_id", referencedColumnName="id")}
|
|
* )
|
|
*/
|
|
private $spokenLanguages;
|
|
|
|
/**
|
|
* The person's center
|
|
* @var Center
|
|
*
|
|
* @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Center")
|
|
* @ORM\JoinColumn(nullable=false)
|
|
*/
|
|
private $center;
|
|
|
|
/**
|
|
* The person's accompanying periods (when the person was accompanied by the center)
|
|
* @var Collection
|
|
*
|
|
* @ORM\OneToMany(targetEntity=AccompanyingPeriodParticipation::class,
|
|
* mappedBy="person",
|
|
* cascade={"persist", "remove", "merge", "detach"})
|
|
*/
|
|
private $accompanyingPeriodParticipations;
|
|
|
|
/**
|
|
* A remark over the person
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="text")
|
|
*/
|
|
private $memo = ''; // TO-CHANGE in remark
|
|
|
|
/**
|
|
* @var boolean
|
|
* @deprecated
|
|
*
|
|
* @ORM\Column(type="boolean")
|
|
*/
|
|
private $proxyAccompanyingPeriodOpenState = false; //TO-DELETE ?
|
|
|
|
/**
|
|
* Array where customfield's data are stored
|
|
* @var array
|
|
*
|
|
* @ORM\Column(type="json_array")
|
|
*/
|
|
private $cFData;
|
|
|
|
/**
|
|
* Addresses
|
|
* @var Collection
|
|
*
|
|
* @ORM\ManyToMany(
|
|
* targetEntity="Chill\MainBundle\Entity\Address",
|
|
* cascade={"persist", "remove", "merge", "detach"})
|
|
* @ORM\JoinTable(name="chill_person_persons_to_addresses")
|
|
* @ORM\OrderBy({"validFrom" = "DESC"})
|
|
*/
|
|
private $addresses;
|
|
|
|
/**
|
|
* @var string
|
|
*
|
|
* @ORM\Column(type="text", nullable=true)
|
|
*/
|
|
private $fullnameCanonical;
|
|
|
|
/**
|
|
* Person constructor.
|
|
*
|
|
* @param \DateTime|null $opening
|
|
*/
|
|
public function __construct(\DateTime $opening = null)
|
|
{
|
|
$this->accompanyingPeriodParticipations = new ArrayCollection();
|
|
$this->spokenLanguages = new ArrayCollection();
|
|
$this->addresses = new ArrayCollection();
|
|
$this->altNames = new ArrayCollection();
|
|
$this->otherPhoneNumbers = new ArrayCollection();
|
|
|
|
if ($opening === null) {
|
|
$opening = new \DateTime();
|
|
}
|
|
|
|
$this->open(new AccompanyingPeriod($opening));
|
|
}
|
|
|
|
/**
|
|
* This private function scan accompanyingPeriodParticipations Collection,
|
|
* searching for a given AccompanyingPeriod
|
|
*/
|
|
private function participationsContainAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): ?AccompanyingPeriodParticipation
|
|
{
|
|
foreach ($this->accompanyingPeriodParticipations as $participation) {
|
|
/** @var AccompanyingPeriodParticipation $participation */
|
|
if ($accompanyingPeriod === $participation->getAccompanyingPeriod()) {
|
|
return $participation;
|
|
}}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This public function is the same but return only true or false
|
|
*/
|
|
public function containsAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): bool
|
|
{
|
|
return ($this->participationsContainAccompanyingPeriod($accompanyingPeriod)) ? false : true;
|
|
}
|
|
|
|
/**
|
|
* Add AccompanyingPeriodParticipation
|
|
*
|
|
* @uses AccompanyingPeriod::addPerson
|
|
*/
|
|
public function addAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): self
|
|
{
|
|
$participation = new AccompanyingPeriodParticipation($accompanyingPeriod, $this);
|
|
$this->accompanyingPeriodParticipations->add($participation);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Remove AccompanyingPeriod
|
|
*/
|
|
public function removeAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod) : void
|
|
{
|
|
$participation = $this->participationsContainAccompanyingPeriod($accompanyingPeriod);
|
|
|
|
if (! null === $participation) {
|
|
$participation->setEndDate(\DateTimeImmutable::class);
|
|
$this->accompanyingPeriodParticipations->removeElement($participation);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* set the Person file as open at the given date.
|
|
*
|
|
* For updating a opening's date, you should update AccompanyingPeriod instance
|
|
* directly.
|
|
*
|
|
* For closing a file, @see this::close
|
|
*
|
|
* To check if the Person and its accompanying period is consistent, use validation.
|
|
*/
|
|
public function open(AccompanyingPeriod $accompanyingPeriod) : void
|
|
{
|
|
$this->proxyAccompanyingPeriodOpenState = true;
|
|
$this->addAccompanyingPeriod($accompanyingPeriod);
|
|
}
|
|
|
|
/**
|
|
* Set the Person file as closed at the given date.
|
|
*
|
|
* For update a closing date, you should update AccompanyingPeriod instance
|
|
* directly.
|
|
*
|
|
* To check if the Person and its accompanying period are consistent, use validation.
|
|
*
|
|
* @throws \Exception if two lines of the accompanying period are open.
|
|
*/
|
|
public function close(AccompanyingPeriod $accompanyingPeriod = null) : void
|
|
{
|
|
$this->proxyAccompanyingPeriodOpenState = false;
|
|
}
|
|
|
|
/**
|
|
* Return the opened accompanying period.
|
|
*/
|
|
public function getOpenedAccompanyingPeriod() : ?AccompanyingPeriod
|
|
{
|
|
if ($this->isOpen() === false) {
|
|
return null;
|
|
}
|
|
|
|
foreach ($this->accompanyingPeriodParticipations as $participation) {
|
|
/** @var AccompanyingPeriodParticipation $participation */
|
|
if ($participation->getAccompanyingPeriod()->isOpen()) {
|
|
return $participation->getAccompanyingPeriod();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the opened accompanying period.
|
|
*
|
|
* @deprecated since 1.1 use `getOpenedAccompanyingPeriod instead
|
|
*/
|
|
public function getCurrentAccompanyingPeriod() : ?AccompanyingPeriod
|
|
{
|
|
return $this->getOpenedAccompanyingPeriod();
|
|
}
|
|
|
|
/**
|
|
* Get AccompanyingPeriods array
|
|
*/
|
|
public function getAccompanyingPeriods(): array
|
|
{
|
|
$accompanyingPeriods = [];
|
|
foreach ($this->accompanyingPeriodParticipations as $participation)
|
|
{
|
|
/** @var AccompanyingPeriodParticipation $participation */
|
|
$accompanyingPeriods[] = $participation->getAccompanyingPeriod();
|
|
}
|
|
return $accompanyingPeriods;
|
|
}
|
|
|
|
/**
|
|
* Get AccompanyingPeriodParticipations Collection
|
|
*/
|
|
public function getAccompanyingPeriodParticipations(): Collection
|
|
{
|
|
return $this->accompanyingPeriodParticipations;
|
|
}
|
|
|
|
/**
|
|
* Return a collection of participation, where the participation
|
|
* is still opened, not a draft, and the period is still opened
|
|
*/
|
|
public function getOpenedParticipations(): Collection
|
|
{
|
|
// create a criteria for filtering easily
|
|
$criteria = Criteria::create();
|
|
$criteria
|
|
->andWhere(Criteria::expr()->eq('endDate', NULL))
|
|
->orWhere(Criteria::expr()->gt('endDate', new \DateTime('now')))
|
|
;
|
|
|
|
return $this->getAccompanyingPeriodParticipations()
|
|
->matching($criteria)
|
|
->filter(function (AccompanyingPeriodParticipation $app) {
|
|
$period = $app->getAccompanyingPeriod();
|
|
return (
|
|
NULL === $period->getClosingDate()
|
|
|| new \DateTime('now') < $period->getClosingDate()
|
|
)
|
|
&& AccompanyingPeriod::STEP_DRAFT !== $period->getStep();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the accompanying periods of a give person with the chronological order.
|
|
*/
|
|
public function getAccompanyingPeriodsOrdered(): array
|
|
{
|
|
$periods = $this->getAccompanyingPeriods();
|
|
|
|
//order by date :
|
|
usort($periods, function($a, $b) {
|
|
$dateA = $a->getOpeningDate();
|
|
$dateB = $b->getOpeningDate();
|
|
|
|
if ($dateA == $dateB) {
|
|
$dateEA = $a->getClosingDate();
|
|
$dateEB = $b->getClosingDate();
|
|
|
|
if ($dateEA == $dateEB) {
|
|
return 0;
|
|
}
|
|
|
|
if ($dateEA < $dateEB) {
|
|
return -1;
|
|
} else {
|
|
return +1;
|
|
}
|
|
}
|
|
|
|
if ($dateA < $dateB) {
|
|
return -1 ;
|
|
} else {
|
|
return 1;
|
|
}
|
|
});
|
|
|
|
return $periods;
|
|
}
|
|
|
|
/**
|
|
* Check if the person is opened
|
|
*/
|
|
public function isOpen() : bool
|
|
{
|
|
foreach ($this->getAccompanyingPeriods() as $period) {
|
|
if ($period->isOpen()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get id
|
|
*
|
|
* @return integer
|
|
*/
|
|
public function getId()
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
/**
|
|
* Set firstName
|
|
*
|
|
* @param string $firstName
|
|
* @return Person
|
|
*/
|
|
public function setFirstName($firstName)
|
|
{
|
|
$this->firstName = $firstName;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get firstName
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getFirstName()
|
|
{
|
|
return $this->firstName;
|
|
}
|
|
|
|
/**
|
|
* Set lastName
|
|
*
|
|
* @param string $lastName
|
|
* @return Person
|
|
*/
|
|
public function setLastName($lastName)
|
|
{
|
|
$this->lastName = $lastName;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get lastName
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getLastName()
|
|
{
|
|
return $this->lastName;
|
|
}
|
|
|
|
/**
|
|
* @return Collection
|
|
*/
|
|
public function getAltNames(): Collection
|
|
{
|
|
return $this->altNames;
|
|
}
|
|
|
|
/**
|
|
* @param Collection $altNames
|
|
* @return $this
|
|
*/
|
|
public function setAltNames(Collection $altNames)
|
|
{
|
|
$this->altNames = $altNames;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param PersonAltName $altName
|
|
* @return $this
|
|
*/
|
|
public function addAltName(PersonAltName $altName)
|
|
{
|
|
if (FALSE === $this->altNames->contains($altName)) {
|
|
$this->altNames->add($altName);
|
|
$altName->setPerson($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param PersonAltName $altName
|
|
* @return $this
|
|
*/
|
|
public function removeAltName(PersonAltName $altName)
|
|
{
|
|
if ($this->altNames->contains($altName)) {
|
|
$altName->setPerson(null);
|
|
$this->altNames->removeElement($altName);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set birthdate
|
|
*
|
|
* @param \DateTime $birthdate
|
|
* @return Person
|
|
*/
|
|
public function setBirthdate($birthdate)
|
|
{
|
|
$this->birthdate = $birthdate;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get birthdate
|
|
*
|
|
* @return \DateTime
|
|
*/
|
|
public function getBirthdate()
|
|
{
|
|
return $this->birthdate;
|
|
}
|
|
|
|
/**
|
|
* Set placeOfBirth
|
|
*
|
|
* @param string $placeOfBirth
|
|
* @return Person
|
|
*/
|
|
public function setPlaceOfBirth($placeOfBirth)
|
|
{
|
|
if ($placeOfBirth === null) {
|
|
$placeOfBirth = '';
|
|
}
|
|
|
|
$this->placeOfBirth = $placeOfBirth;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get placeOfBirth
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getPlaceOfBirth()
|
|
{
|
|
return $this->placeOfBirth;
|
|
}
|
|
|
|
/**
|
|
* Set gender
|
|
*
|
|
* @param string $gender
|
|
* @return Person
|
|
*/
|
|
public function setGender($gender)
|
|
{
|
|
$this->gender = $gender;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get gender
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getGender()
|
|
{
|
|
return $this->gender;
|
|
}
|
|
|
|
/**
|
|
* return gender as a Numeric form.
|
|
* This is used for translations
|
|
* @return int
|
|
*/
|
|
public function getGenderNumeric()
|
|
{
|
|
if ($this->getGender() == self::FEMALE_GENDER) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set memo
|
|
*
|
|
* @param string $memo
|
|
* @return Person
|
|
*/
|
|
public function setMemo($memo)
|
|
{
|
|
if ($memo === null) {
|
|
$memo = '';
|
|
}
|
|
|
|
if ($this->memo !== $memo) {
|
|
$this->memo = $memo;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get memo
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getMemo()
|
|
{
|
|
return $this->memo;
|
|
}
|
|
|
|
/**
|
|
* Set maritalStatus
|
|
*
|
|
* @param MaritalStatus $maritalStatus
|
|
* @return Person
|
|
*/
|
|
public function setMaritalStatus(MaritalStatus $maritalStatus = null)
|
|
{
|
|
$this->maritalStatus = $maritalStatus;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get maritalStatus
|
|
*
|
|
* @return MaritalStatus
|
|
*/
|
|
public function getMaritalStatus()
|
|
{
|
|
return $this->maritalStatus;
|
|
}
|
|
|
|
/**
|
|
* Set contactInfo
|
|
*
|
|
* @param string $contactInfo
|
|
* @return Person
|
|
*/
|
|
public function setcontactInfo($contactInfo)
|
|
{
|
|
if ($contactInfo === null) {
|
|
$contactInfo = '';
|
|
}
|
|
|
|
$this->contactInfo = $contactInfo;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get contactInfo
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getcontactInfo()
|
|
{
|
|
return $this->contactInfo;
|
|
}
|
|
|
|
/**
|
|
* Set email
|
|
*
|
|
* @param string $email
|
|
* @return Person
|
|
*/
|
|
public function setEmail($email)
|
|
{
|
|
if ($email === null) {
|
|
$email = '';
|
|
}
|
|
|
|
$this->email = $email;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get email
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getEmail()
|
|
{
|
|
return $this->email;
|
|
}
|
|
|
|
/**
|
|
* Set countryOfBirth
|
|
*
|
|
* @param Chill\MainBundle\Entity\Country $countryOfBirth
|
|
* @return Person
|
|
*/
|
|
public function setCountryOfBirth(Country $countryOfBirth = null)
|
|
{
|
|
$this->countryOfBirth = $countryOfBirth;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get countryOfBirth
|
|
*
|
|
* @return Chill\MainBundle\Entity\Country
|
|
*/
|
|
public function getCountryOfBirth()
|
|
{
|
|
return $this->countryOfBirth;
|
|
}
|
|
|
|
/**
|
|
* Set nationality
|
|
*
|
|
* @param Chill\MainBundle\Entity\Country $nationality
|
|
* @return Person
|
|
*/
|
|
public function setNationality(Country $nationality = null)
|
|
{
|
|
$this->nationality = $nationality;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get nationality
|
|
*
|
|
* @return Chill\MainBundle\Entity\Country
|
|
*/
|
|
public function getNationality()
|
|
{
|
|
return $this->nationality;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getLabel()
|
|
{
|
|
return $this->getFirstName()." ".$this->getLastName();
|
|
}
|
|
|
|
/**
|
|
* Get center
|
|
*
|
|
* @return Center
|
|
*/
|
|
public function getCenter()
|
|
{
|
|
return $this->center;
|
|
}
|
|
|
|
/**
|
|
* Set the center
|
|
*
|
|
* @param Center $center
|
|
* @return \Chill\PersonBundle\Entity\Person
|
|
*/
|
|
public function setCenter(Center $center)
|
|
{
|
|
$this->center = $center;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set cFData
|
|
*
|
|
* @param array $cFData
|
|
*
|
|
* @return Report
|
|
*/
|
|
public function setCFData($cFData)
|
|
{
|
|
$this->cFData = $cFData;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get cFData
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getCFData()
|
|
{
|
|
if ($this->cFData === null) {
|
|
$this->cFData = [];
|
|
}
|
|
return $this->cFData;
|
|
}
|
|
|
|
/**
|
|
* Set phonenumber
|
|
*
|
|
* @param string $phonenumber
|
|
* @return Person
|
|
*/
|
|
public function setPhonenumber($phonenumber = '')
|
|
{
|
|
$this->phonenumber = $phonenumber;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get phonenumber
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getPhonenumber()
|
|
{
|
|
return $this->phonenumber;
|
|
}
|
|
|
|
/**
|
|
* Set mobilenumber
|
|
*
|
|
* @param string $mobilenumber
|
|
* @return Person
|
|
*/
|
|
public function setMobilenumber($mobilenumber = '')
|
|
{
|
|
$this->mobilenumber = $mobilenumber;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get mobilenumber
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getMobilenumber()
|
|
{
|
|
return $this->mobilenumber;
|
|
}
|
|
|
|
/**
|
|
* @return Collection
|
|
*/
|
|
public function getOtherPhoneNumbers(): Collection
|
|
{
|
|
return $this->otherPhoneNumbers;
|
|
}
|
|
|
|
/**
|
|
* @param Collection $otherPhoneNumbers
|
|
* @return $this
|
|
*/
|
|
public function setOtherPhoneNumbers(Collection $otherPhoneNumbers)
|
|
{
|
|
$this->otherPhoneNumbers = $otherPhoneNumbers;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param PersonPhone $otherPhoneNumber
|
|
* @return $this
|
|
*/
|
|
public function addOtherPhoneNumber(PersonPhone $otherPhoneNumber)
|
|
{
|
|
if (false === $this->otherPhoneNumbers->contains($otherPhoneNumber)) {
|
|
$otherPhoneNumber->setPerson($this);
|
|
$this->otherPhoneNumbers->add($otherPhoneNumber);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param PersonPhone $otherPhoneNumber
|
|
* @return $this
|
|
*/
|
|
public function removeOtherPhoneNumber(PersonPhone $otherPhoneNumber)
|
|
{
|
|
if ($this->otherPhoneNumbers->contains($otherPhoneNumber)) {
|
|
$this->otherPhoneNumbers->removeElement($otherPhoneNumber);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function __toString()
|
|
{
|
|
return $this->getLabel();
|
|
}
|
|
|
|
/**
|
|
* Set spokenLanguages
|
|
*
|
|
* @param type $spokenLanguages
|
|
* @return Person
|
|
*/
|
|
public function setSpokenLanguages($spokenLanguages)
|
|
{
|
|
$this->spokenLanguages = $spokenLanguages;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get spokenLanguages
|
|
*
|
|
* @return ArrayCollection
|
|
*/
|
|
public function getSpokenLanguages()
|
|
{
|
|
return $this->spokenLanguages;
|
|
}
|
|
|
|
/**
|
|
* @param Address $address
|
|
* @return $this
|
|
*/
|
|
public function addAddress(Address $address)
|
|
{
|
|
$this->addresses[] = $address;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param Address $address
|
|
*/
|
|
public function removeAddress(Address $address)
|
|
{
|
|
$this->addresses->removeElement($address);
|
|
}
|
|
|
|
/**
|
|
* By default, the addresses are ordered by date, descending (the most
|
|
* recent first)
|
|
*/
|
|
public function getAddresses(): Collection
|
|
{
|
|
return $this->addresses;
|
|
}
|
|
|
|
public function getLastAddress(DateTime $from = null)
|
|
{
|
|
$from ??= new DateTime('now');
|
|
|
|
/** @var ArrayIterator $addressesIterator */
|
|
$addressesIterator = $this->getAddresses()
|
|
->filter(static fn (Address $address): bool => $address->getValidFrom() <= $from)
|
|
->getIterator();
|
|
|
|
$addressesIterator->uasort(
|
|
static fn (Address $left, Address $right): int => $right->getValidFrom() <=> $left->getValidFrom()
|
|
);
|
|
|
|
return [] === ($addresses = iterator_to_array($addressesIterator)) ?
|
|
null :
|
|
current($addresses);
|
|
}
|
|
|
|
/**
|
|
* Validation callback that checks if the accompanying periods are valid
|
|
*
|
|
* This method add violation errors.
|
|
*/
|
|
public function isAccompanyingPeriodValid(ExecutionContextInterface $context)
|
|
{
|
|
$r = $this->checkAccompanyingPeriodsAreNotCollapsing();
|
|
|
|
if ($r !== true) {
|
|
if ($r['result'] === self::ERROR_PERIODS_ARE_COLLAPSING) {
|
|
$context->buildViolation('Two accompanying periods have days in commun')
|
|
->atPath('accompanyingPeriods')
|
|
->addViolation();
|
|
}
|
|
|
|
if ($r['result'] === self::ERROR_ADDIND_PERIOD_AFTER_AN_OPEN_PERIOD) {
|
|
$context->buildViolation('A period is opened and a period is added after it')
|
|
->atPath('accompanyingPeriods')
|
|
->addViolation();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the person has two addresses with the
|
|
* same validFrom date (in format 'Y-m-d')
|
|
*/
|
|
public function hasTwoAdressWithSameValidFromDate()
|
|
{
|
|
$validYMDDates = array();
|
|
|
|
foreach ($this->addresses as $ad) {
|
|
$validDate = $ad->getValidFrom()->format('Y-m-d');
|
|
|
|
if (in_array($validDate, $validYMDDates)) {
|
|
return true;
|
|
}
|
|
$validYMDDates[] = $validDate;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Validation callback that checks if the addresses are valid (do not have
|
|
* two addresses with the same validFrom date)
|
|
*
|
|
* This method add violation errors.
|
|
*/
|
|
public function isAddressesValid(ExecutionContextInterface $context)
|
|
{
|
|
if ($this->hasTwoAdressWithSameValidFromDate()) {
|
|
$context
|
|
->buildViolation('Two addresses has the same validFrom date')
|
|
->atPath('addresses')
|
|
->addViolation()
|
|
;
|
|
}
|
|
}
|
|
|
|
|
|
const ERROR_PERIODS_ARE_COLLAPSING = 1; // when two different periods
|
|
// have days in commun
|
|
const ERROR_ADDIND_PERIOD_AFTER_AN_OPEN_PERIOD = 2; // where there exist
|
|
// a period opened and another one after it
|
|
|
|
/**
|
|
* Function used for validation that check if the accompanying periods of
|
|
* the person are not collapsing (i.e. have not shared days) or having
|
|
* a period after an open period.
|
|
*
|
|
* @return true | array True if the accompanying periods are not collapsing,
|
|
* an array with data for displaying the error
|
|
*/
|
|
public function checkAccompanyingPeriodsAreNotCollapsing()
|
|
{
|
|
$periods = $this->getAccompanyingPeriodsOrdered();
|
|
$periodsNbr = sizeof($periods);
|
|
$i = 0;
|
|
|
|
while($i < $periodsNbr - 1) {
|
|
$periodI = $periods[$i];
|
|
$periodAfterI = $periods[$i + 1];
|
|
|
|
if($periodI->isOpen()) {
|
|
return array(
|
|
'result' => self::ERROR_ADDIND_PERIOD_AFTER_AN_OPEN_PERIOD,
|
|
'dateOpening' => $periodAfterI->getOpeningDate(),
|
|
'dateClosing' => $periodAfterI->getClosingDate(),
|
|
'date' => $periodI->getOpeningDate()
|
|
);
|
|
} elseif ($periodI->getClosingDate() >= $periodAfterI->getOpeningDate()) {
|
|
return array(
|
|
'result' => self::ERROR_PERIODS_ARE_COLLAPSING,
|
|
'dateOpening' => $periodI->getOpeningDate(),
|
|
|
|
'dateClosing' => $periodI->getClosingDate(),
|
|
'date' => $periodAfterI->getOpeningDate()
|
|
);
|
|
}
|
|
$i++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function getFullnameCanonical() : string
|
|
{
|
|
return $this->fullnameCanonical;
|
|
}
|
|
|
|
public function setFullnameCanonical($fullnameCanonical) : Person
|
|
{
|
|
$this->fullnameCanonical = $fullnameCanonical;
|
|
return $this;
|
|
}
|
|
}
|