src/Entity/Person.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Club1895\Club1895Profile;
  6. use App\Entity\Enum\PersonGender;
  7. use App\Entity\Enum\ProfilingType;
  8. use App\Entity\Traits\Identifiable;
  9. use App\Repository\PersonRepository;
  10. use DateInterval;
  11. use DateTime;
  12. use DateTimeImmutable;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use LogicException;
  17. use Symfony\Component\Validator\Constraints\NotBlank;
  19. #[ORM\Entity(repositoryClass: PersonRepository::class)]
  20. class Person implements BenefactorPersonInterface, EmailableInterface
  21. {
  22.     use Identifiable;
  24.     #[ORM\OneToOne(inversedBy: 'person', targetEntity: User::class, cascade: ['persist', 'remove'])]
  25.     private $user;
  27.     #[ORM\Column(type: 'string', length: 150, nullable: true)]
  28.     private $lastName;
  30.     #[ORM\Column(type: 'string', length: 150)]
  31.     #[NotBlank]
  32.     private $firstName;
  34.     #[ORM\Column(type: 'string', length: 10, nullable: true, enumType: PersonGender::class)]
  35.     private ?PersonGender $gender;
  37.     #[ORM\Column(type: 'string', length: 150, nullable: true)]
  38.     private $birthName;
  40.     #[ORM\Column(type: 'date_immutable', nullable: true)]
  41.     private $birthDate;
  43.     #[ORM\Column(type: 'string', length: 150, nullable: true)]
  44.     private $birthPlace;
  46.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  47.     private $birthCity;
  49.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  50.     private $birthCountry;
  52.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  53.     private $nationality;
  55.     #[ORM\Column(type: 'string', length: 150, nullable: true)]
  56.     private $profession;
  58.     #[ORM\Column(type: 'string', length: 150, nullable: true)]
  59.     private $school;
  61.     #[ORM\Embedded(PersonMeta::class, 'meta_')]
  62.     private $meta;
  64.     #[ORM\ManyToOne(targetEntity: Family::class, cascade: ['persist'], inversedBy: 'persons')]
  65.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  66.     private $family;
  68.     #[ORM\ManyToOne(targetEntity: ContactEmail::class, cascade: ['persist'], inversedBy: 'firstEmailPersons')]
  69.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  70.     private $firstEmail;
  72.     #[ORM\ManyToOne(targetEntity: ContactEmail::class, cascade: ['persist'], inversedBy: 'secondEmailPersons')]
  73.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  74.     private $secondEmail;
  76.     #[ORM\ManyToOne(targetEntity: ContactPhone::class, cascade: ['persist'], inversedBy: 'firstPhonePersons')]
  77.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  78.     private $firstPhone;
  80.     #[ORM\ManyToOne(targetEntity: ContactPhone::class, cascade: ['persist'], inversedBy: 'secondPhonePersons')]
  81.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  82.     private $secondPhone;
  84.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: ContactEmail::class, cascade: ['remove'])]
  85.     private $ownedEmails;
  87.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: ContactPhone::class, cascade: ['remove'])]
  88.     private $ownedPhones;
  90.     #[ORM\ManyToMany(targetEntity: self::class, inversedBy: 'tutors')]
  91.     #[ORM\JoinTable(name: 'tutors')]
  92.     #[ORM\JoinColumn('tutor_id', 'id')]
  93.     #[ORM\InverseJoinColumn('ward_id', 'id')]
  94.     private $wards;
  96.     #[ORM\ManyToMany(targetEntity: self::class, mappedBy: 'wards', cascade: ['persist'])]
  97.     private $tutors;
  99.     #[ORM\OneToMany(mappedBy: 'person', targetEntity: SectionPerson::class, cascade: ['persist', 'remove'])]
  100.     private $sectionPersons;
  102.     #[ORM\OneToMany(mappedBy: 'person', targetEntity: Coach::class, cascade: ['remove'])]
  103.     private $coaches;
  105.     #[ORM\OneToMany(mappedBy: 'signatory', targetEntity: Registration::class)]
  106.     private $signedRegistrations;
  108.     #[ORM\ManyToMany(targetEntity: Tag::class, mappedBy: 'persons')]
  109.     private $tags;
  111.     #[ORM\OneToMany(mappedBy: 'person', targetEntity: Registration::class, cascade: ['persist', 'remove'])]
  112.     private $registrations;
  114.     #[ORM\OneToMany(mappedBy: 'person', targetEntity: ProfilingPerson::class, cascade: ['persist', 'remove'])]
  115.     private $profilingPersons;
  117.     #[ORM\Column(type: 'boolean')]
  118.     private $isNew = true;
  120.     #[ORM\Column(type: 'integer', nullable: true)]
  121.     private $oldId;
  123.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: FilePerson::class, cascade: ['remove'])]
  124.     private $files;
  126.     #[ORM\Column(type: 'boolean')]
  127.     private $isCoach = false;
  129.     #[ORM\OneToMany(mappedBy: 'person', targetEntity: Debt::class)]
  130.     private $debts;
  132.     #[ORM\OneToMany(mappedBy: 'person', targetEntity: Donation::class)]
  133.     private Collection $donations;
  135.     #[ORM\Column(options: ['default' => false])]
  136.     private ?bool $benefactor = false;
  138.     #[ORM\OneToMany(mappedBy: 'relatedPerson', targetEntity: LegalPerson::class)]
  139.     private Collection $legalPersons;
  141.     #[ORM\OneToOne(mappedBy: 'person', cascade: ['persist', 'remove'])]
  142.     private ?Club1895Profile $club1895Profile = null;
  144.     #[ORM\Column(nullable: true)]
  145.     private ?bool $club1895Interested = null;
  147.     public function __construct()
  148.     {
  149.         $this->meta = new PersonMeta();
  150.         $this->wards = new ArrayCollection();
  151.         $this->tutors = new ArrayCollection();
  152.         $this->sectionPersons = new ArrayCollection();
  153.         $this->coaches = new ArrayCollection();
  154.         $this->signedRegistrations = new ArrayCollection();
  155.         $this->tags = new ArrayCollection();
  156.         $this->registrations = new ArrayCollection();
  157.         $this->profilingPersons = new ArrayCollection();
  158.         $this->files = new ArrayCollection();
  159.         $this->debts = new ArrayCollection();
  160.         $this->ownedEmails = new ArrayCollection();
  161.         $this->ownedPhones = new ArrayCollection();
  162.         $this->donations = new ArrayCollection();
  163.         $this->legalPersons = new ArrayCollection();
  164.     }
  166.     public function __toString(): string
  167.     {
  168.         return $this->getFullName(true);
  169.     }
  171.     public function getUser(): ?User
  172.     {
  173.         return $this->user;
  174.     }
  176.     public function setUser(?User $user): self
  177.     {
  178.         $this->user = $user;
  180.         return $this;
  181.     }
  183.     public function getLastName(): ?string
  184.     {
  185.         return $this->lastName ?? $this->getBirthName();
  186.     }
  188.     public function setLastName(?string $lastName): self
  189.     {
  190.         $this->lastName = $lastName;
  192.         return $this;
  193.     }
  195.     public function getFirstName(): ?string
  196.     {
  197.         return $this->firstName;
  198.     }
  200.     public function setFirstName(string $firstName): self
  201.     {
  202.         $this->firstName = $firstName;
  204.         return $this;
  205.     }
  207.     public function getGender(): ?PersonGender
  208.     {
  209.         return $this->gender;
  210.     }
  212.     public function setGender(?PersonGender $gender): self
  213.     {
  214.         $this->gender = $gender;
  216.         return $this;
  217.     }
  219.     public function getBirthDate(): ?DateTimeImmutable
  220.     {
  221.         return $this->birthDate;
  222.     }
  224.     public function getAge(): ?int
  225.     {
  226.         if (null === $this->getBirthDate()) {
  227.             return 18;
  228.         }
  230.         return $this->getBirthDate()?->diff(new DateTimeImmutable())->y;
  231.     }
  233.     public function setBirthDate(?DateTimeImmutable $birthDate): self
  234.     {
  235.         $this->birthDate = $birthDate;
  237.         return $this;
  238.     }
  240.     public function getBirthPlace(): ?string
  241.     {
  242.         return $this->birthPlace;
  243.     }
  245.     public function setBirthPlace(?string $birthPlace): self
  246.     {
  247.         $this->birthPlace = $birthPlace;
  249.         return $this;
  250.     }
  252.     public function getNationality(): ?string
  253.     {
  254.         return $this->nationality;
  255.     }
  257.     public function setNationality(?string $nationality): self
  258.     {
  259.         $this->nationality = $nationality;
  261.         return $this;
  262.     }
  264.     public function getProfession(): ?string
  265.     {
  266.         return $this->profession;
  267.     }
  269.     public function setProfession(?string $profession): self
  270.     {
  271.         $this->profession = $profession;
  273.         return $this;
  274.     }
  276.     public function getSchool(): ?string
  277.     {
  278.         return $this->school;
  279.     }
  281.     public function setSchool(?string $school): self
  282.     {
  283.         $this->school = $school;
  285.         return $this;
  286.     }
  288.     public function getFamily(): ?Family
  289.     {
  290.         return $this->family;
  291.     }
  293.     public function setFamily(?Family $family): self
  294.     {
  295.         $this->family = $family;
  297.         return $this;
  298.     }
  300.     public function getMeta(): ?PersonMeta
  301.     {
  302.         return $this->meta;
  303.     }
  305.     public function setMeta(PersonMeta $meta): self
  306.     {
  307.         $this->meta = $meta;
  309.         return $this;
  310.     }
  312.     public function getFirstEmail(): ?ContactEmail
  313.     {
  314.         return $this->firstEmail;
  315.     }
  317.     public function setFirstEmail(?ContactEmail $firstEmail): self
  318.     {
  319.         $this->firstEmail = $firstEmail;
  320.         if ($firstEmail && null === $firstEmail->getOwner()) {
  321.             $firstEmail->setOwner($this);
  322.         }
  324.         return $this;
  325.     }
  327.     public function getSecondEmail(): ?ContactEmail
  328.     {
  329.         return $this->secondEmail;
  330.     }
  332.     public function setSecondEmail(?ContactEmail $secondEmail): self
  333.     {
  334.         $this->secondEmail = $secondEmail;
  335.         if ($secondEmail && null === $secondEmail->getOwner()) {
  336.             $secondEmail->setOwner($this);
  337.         }
  339.         return $this;
  340.     }
  342.     public function getEmail(bool $ownedOnly = false): ?ContactEmail
  343.     {
  344.         if ($ownedOnly) {
  345.             if ($this->getFirstEmail()?->getOwner() === $this) {
  346.                 return $this->getFirstEmail();
  347.             } elseif ($this->getSecondEmail()?->getOwner() === $this) {
  348.                 return $this->getSecondEmail();
  349.             } else {
  350.                 return null;
  351.             }
  352.         }
  354.         return $this->getFirstEmail() ?? $this->getSecondEmail();
  355.     }
  357.     /**
  358.      * @return Collection<int, ContactEmail>
  359.      */
  360.     public function getEmails(): Collection
  361.     {
  362.         $emails = new ArrayCollection();
  363.         if ($this->getFirstEmail()) {
  364.             $emails->add($this->getFirstEmail());
  365.         }
  366.         if ($this->getSecondEmail()) {
  367.             $emails->add($this->getSecondEmail());
  368.         }
  370.         return $emails;
  371.     }
  373.     public function getValidEmail(): ?string
  374.     {
  375.         $contactEmail = $this->getEmail();
  376.         if ($contactEmail) {
  377.             return $contactEmail->getEmail();
  378.         }
  379.         foreach ($this->getTutors() as $tutor) {
  380.             if ($contactEmail = $tutor->getEmail()) {
  381.                 return $contactEmail->getEmail();
  382.             }
  383.         }
  385.         return $this->getFamily()?->getResponsiblePerson()?->getEmail()?->getEmail();
  386.     }
  388.     public function getSimpleEmail(): ?string
  389.     {
  390.         return $this->getEmail()?->getEmail();
  391.     }
  393.     public function getFirstPhone(): ?ContactPhone
  394.     {
  395.         return $this->firstPhone;
  396.     }
  398.     public function setFirstPhone(?ContactPhone $firstPhone): self
  399.     {
  400.         $this->firstPhone = $firstPhone;
  401.         if ($firstPhone && null === $firstPhone->getOwner()) {
  402.             $firstPhone->setOwner($this);
  403.         }
  405.         return $this;
  406.     }
  408.     public function getSecondPhone(): ?ContactPhone
  409.     {
  410.         return $this->secondPhone;
  411.     }
  413.     public function setSecondPhone(?ContactPhone $secondPhone): self
  414.     {
  415.         $this->secondPhone = $secondPhone;
  416.         if ($secondPhone && null === $secondPhone->getOwner()) {
  417.             $secondPhone->setOwner($this);
  418.         }
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, ContactPhone>
  425.      */
  426.     public function getPhones(): Collection
  427.     {
  428.         $phones = new ArrayCollection();
  429.         if ($this->getFirstPhone()) {
  430.             $phones->add($this->getFirstPhone());
  431.         }
  432.         if ($this->getSecondPhone()) {
  433.             $phones->add($this->getSecondPhone());
  434.         }
  436.         return $phones;
  437.     }
  439.     /**
  440.      * @return Collection<int, ContactInterface>
  441.      */
  442.     public function getContacts(): Collection
  443.     {
  444.         $contacts = new ArrayCollection();
  445.         foreach ($this->getEmails() as $email) {
  446.             $contacts->add($email);
  447.         }
  448.         foreach ($this->getPhones() as $phone) {
  449.             $contacts->add($phone);
  450.         }
  452.         return $contacts;
  453.     }
  455.     /**
  456.      * @return Collection<int, self>
  457.      */
  458.     public function getWards(): Collection
  459.     {
  460.         return $this->wards;
  461.     }
  463.     public function addWard(self $ward): self
  464.     {
  465.         if (!$this->wards->contains($ward)) {
  466.             $this->wards[] = $ward;
  467.         }
  469.         return $this;
  470.     }
  472.     public function removeWard(self $ward): self
  473.     {
  474.         $this->wards->removeElement($ward);
  476.         return $this;
  477.     }
  479.     /**
  480.      * @param array|Person[] $wards
  481.      * @return Person
  482.      */
  483.     public function setWards(array $wards): Person
  484.     {
  485.         $collection = new ArrayCollection();
  486.         foreach ($wards as $ward) {
  487.             if (!$collection->contains($ward)) {
  488.                 $collection->add($ward);
  489.             }
  490.         }
  491.         $this->wards = $collection;
  493.         return $this;
  494.     }
  496.     /**
  497.      * @return Collection<int, self>
  498.      */
  499.     public function getTutors(): Collection
  500.     {
  501.         return $this->tutors;
  502.     }
  504.     public function addTutor(self $tutor): self
  505.     {
  506.         if (!$this->tutors->contains($tutor)) {
  507.             $this->tutors[] = $tutor;
  508.             $tutor->addWard($this);
  509.         }
  511.         return $this;
  512.     }
  514.     public function removeTutor(self $tutor): self
  515.     {
  516.         if ($this->tutors->removeElement($tutor)) {
  517.             $tutor->removeWard($this);
  518.         }
  520.         return $this;
  521.     }
  523.     /**
  524.      * @param array|Person[] $tutors
  525.      * @return Person
  526.      */
  527.     public function setTutors(array $tutors): Person
  528.     {
  529.         $collection = new ArrayCollection();
  530.         foreach ($tutors as $tutor) {
  531.             if (!$collection->contains($tutor)) {
  532.                 $collection->add($tutor);
  533.             }
  534.         }
  535.         $this->tutors = $collection;
  537.         return $this;
  538.     }
  540.     public function getBirthCity(): ?string
  541.     {
  542.         return $this->birthCity;
  543.     }
  545.     public function setBirthCity(?string $birthCity): self
  546.     {
  547.         $this->birthCity = $birthCity;
  549.         return $this;
  550.     }
  552.     public function getBirthCountry(): ?string
  553.     {
  554.         return $this->birthCountry;
  555.     }
  557.     public function setBirthCountry(?string $birthCountry): self
  558.     {
  559.         $this->birthCountry = $birthCountry;
  561.         return $this;
  562.     }
  564.     /**
  565.      * @param Section|null $section
  566.      * @return Collection<int, SectionPerson>
  567.      */
  568.     public function getSectionPersons(?Section $section = null): Collection
  569.     {
  570.         if ($section) {
  571.             return $this->sectionPersons->filter(
  572.                 fn(SectionPerson $sectionPerson) => $sectionPerson->getSection() === $section
  573.             );
  574.         }
  576.         return $this->sectionPersons;
  577.     }
  579.     public function addSectionPerson(SectionPerson $sectionPerson): self
  580.     {
  581.         if (!$this->sectionPersons->contains($sectionPerson)) {
  582.             $this->sectionPersons[] = $sectionPerson;
  583.             $sectionPerson->setPerson($this);
  584.         }
  586.         return $this;
  587.     }
  589.     public function removeSectionPerson(SectionPerson $sectionPerson): self
  590.     {
  591.         if ($this->sectionPersons->removeElement($sectionPerson)) {
  592.             // set the owning side to null (unless already changed)
  593.             if ($sectionPerson->getPerson() === $this) {
  594.                 $sectionPerson->setPerson(null);
  595.             }
  596.         }
  598.         return $this;
  599.     }
  601.     /**
  602.      * @return Collection<int, Coach>
  603.      */
  604.     public function getCoaches(): Collection
  605.     {
  606.         return $this->coaches;
  607.     }
  609.     public function addCoach(Coach $coach): self
  610.     {
  611.         if (!$this->coaches->contains($coach)) {
  612.             $this->coaches[] = $coach;
  613.             $coach->setPerson($this);
  614.         }
  616.         return $this;
  617.     }
  619.     public function removeCoach(Coach $coach): self
  620.     {
  621.         if ($this->coaches->removeElement($coach)) {
  622.             // set the owning side to null (unless already changed)
  623.             if ($coach->getPerson() === $this) {
  624.                 $coach->setPerson(null);
  625.             }
  626.         }
  628.         return $this;
  629.     }
  631.     /**
  632.      * @return Collection<int, Registration>
  633.      */
  634.     public function getSignedRegistrations(): Collection
  635.     {
  636.         return $this->signedRegistrations;
  637.     }
  639.     public function addSignedRegistration(Registration $signedRegistration): self
  640.     {
  641.         if (!$this->signedRegistrations->contains($signedRegistration)) {
  642.             $this->signedRegistrations[] = $signedRegistration;
  643.             $signedRegistration->setSignatory($this);
  644.         }
  646.         return $this;
  647.     }
  649.     public function removeSignedRegistration(Registration $signedRegistration): self
  650.     {
  651.         if ($this->signedRegistrations->removeElement($signedRegistration)) {
  652.             // set the owning side to null (unless already changed)
  653.             if ($signedRegistration->getSignatory() === $this) {
  654.                 $signedRegistration->setSignatory(null);
  655.             }
  656.         }
  658.         return $this;
  659.     }
  661.     /**
  662.      * @return Collection<int, Tag>
  663.      */
  664.     public function getTags(): Collection
  665.     {
  666.         return $this->tags;
  667.     }
  669.     public function addTag(Tag $tag): self
  670.     {
  671.         if (!$this->tags->contains($tag)) {
  672.             $this->tags[] = $tag;
  673.             $tag->addPerson($this);
  674.         }
  676.         return $this;
  677.     }
  679.     public function removeTag(Tag $tag): self
  680.     {
  681.         if ($this->tags->removeElement($tag)) {
  682.             $tag->removePerson($this);
  683.         }
  685.         return $this;
  686.     }
  688.     /**
  689.      * @param array $tags
  690.      * @return Person
  691.      */
  692.     public function setTags(array $tags): Person
  693.     {
  694.         $collection = new ArrayCollection();
  695.         foreach ($tags as $tag) {
  696.             $collection->add($tag);
  697.         }
  698.         $this->tags = $collection;
  700.         return $this;
  701.     }
  703.     /**
  704.      * @param Section|null $section
  705.      * @return Collection<int, Registration>
  706.      */
  707.     public function getRegistrations(?Section $section = null): Collection
  708.     {
  709.         if (null === $section) {
  710.             return $this->registrations;
  711.         }
  713.         return $this->registrations->filter(fn(Registration $r) => $r->getSection() === $section);
  714.     }
  716.     public function getPreviousSeasonRegistrations()
  717.     {
  719.     }
  721.     public function addRegistration(Registration $registration): self
  722.     {
  723.         if (!$this->registrations->contains($registration)) {
  724.             $this->registrations[] = $registration;
  725.             $registration->setPerson($this);
  726.         }
  728.         return $this;
  729.     }
  731.     public function removeRegistration(Registration $registration): self
  732.     {
  733.         if ($this->registrations->removeElement($registration)) {
  734.             // set the owning side to null (unless already changed)
  735.             if ($registration->getPerson() === $this) {
  736.                 $registration->setPerson(null);
  737.             }
  738.         }
  740.         return $this;
  741.     }
  743.     /**
  744.      * @param Section|null $section
  745.      * @return Collection<int, Registration>
  746.      */
  747.     public function getActiveRegistrations(?Section $section = null): Collection
  748.     {
  749.         return $this->getRegistrations($section)->filter(fn(Registration $r) => $r->getSeason()->getIsActive());
  750.     }
  752.     /**
  753.      * @return Collection<int, ProfilingPerson>
  754.      */
  755.     public function getProfilingPersons(): Collection
  756.     {
  757.         return $this->profilingPersons;
  758.     }
  760.     public function getSectionLevelPerson(Section $section, bool $activeSeason = true): ?ProfilingPerson
  761.     {
  762.         foreach ($this->getProfilingPersons() as $profilingPerson) {
  763.             if ($profilingPerson->getType() === ProfilingType::Level
  764.                 && $profilingPerson->getSeason()?->getSection() === $section) {
  765.                 if ($activeSeason && $profilingPerson->getSeason()?->getIsActive()) {
  766.                     return $profilingPerson;
  767.                 }
  769.                 if (!$activeSeason && $profilingPerson->getSeason()?->getNextSeason()?->getIsActive()) {
  770.                     return $profilingPerson;
  771.                 }
  772.             }
  773.         }
  775.         return null;
  776.     }
  778.     public function getSectionProfilingPerson(Section $section): ?ProfilingPerson
  779.     {
  780.         foreach ($this->getProfilingPersons() as $profilingPerson) {
  781.             if ($profilingPerson->getType() === ProfilingType::Profiling
  782.                 && $profilingPerson->getSeason()?->getIsActive()
  783.                 && $profilingPerson->getSeason()?->getSection() === $section) {
  784.                 return $profilingPerson;
  785.             }
  786.         }
  788.         return null;
  789.     }
  791.     public function addProfilingPerson(ProfilingPerson $profilingPerson): self
  792.     {
  793.         if (!$this->profilingPersons->contains($profilingPerson)) {
  794.             $this->profilingPersons[] = $profilingPerson;
  795.             $profilingPerson->setPerson($this);
  796.         }
  798.         return $this;
  799.     }
  801.     public function removeProfilingPerson(ProfilingPerson $profilingPerson): self
  802.     {
  803.         if ($this->profilingPersons->removeElement($profilingPerson)) {
  804.             // set the owning side to null (unless already changed)
  805.             if ($profilingPerson->getPerson() === $this) {
  806.                 $profilingPerson->setPerson(null);
  807.             }
  808.         }
  810.         return $this;
  811.     }
  813.     public function getBirthName(): ?string
  814.     {
  815.         return $this->birthName;
  816.     }
  818.     public function setBirthName(?string $birthName): self
  819.     {
  820.         $this->birthName = $birthName;
  822.         return $this;
  823.     }
  825.     public function getFullName(bool $capitalize = false): string
  826.     {
  827.         return sprintf(
  828.             '%s %s',
  829.             $this->getFirstName(),
  830.             $capitalize ? mb_strtoupper($this->getLastName()) : $this->getLastName()
  831.         );
  832.     }
  834.     /**
  835.      * @return bool
  836.      * @throws LogicException
  837.      */
  838.     public function isMinor(): bool
  839.     {
  840.         if (null === $this->getBirthDate()) {
  841.             return false;
  842.         }
  844.         $date = (new DateTime())->sub(new DateInterval('P18Y'));
  846.         return $this->getBirthDate() > $date;
  847.     }
  849.     public function isIsNew(): ?bool
  850.     {
  851.         return $this->isNew;
  852.     }
  854.     public function setIsNew(bool $isNew): self
  855.     {
  856.         $this->isNew = $isNew;
  858.         return $this;
  859.     }
  861.     public function getOldId(): ?int
  862.     {
  863.         return $this->oldId;
  864.     }
  866.     public function setOldId(?int $oldId): self
  867.     {
  868.         $this->oldId = $oldId;
  870.         return $this;
  871.     }
  873.     /**
  874.      * @return Collection<int, FilePerson>
  875.      */
  876.     public function getFiles(): Collection
  877.     {
  878.         return $this->files;
  879.     }
  881.     public function addFile(FilePerson $file): self
  882.     {
  883.         if (!$this->files->contains($file)) {
  884.             $this->files[] = $file;
  885.             $file->setOwner($this);
  886.         }
  888.         return $this;
  889.     }
  891.     public function removeFile(FilePerson $file): self
  892.     {
  893.         if ($this->files->removeElement($file)) {
  894.             // set the owning side to null (unless already changed)
  895.             if ($file->getOwner() === $this) {
  896.                 $file->setOwner(null);
  897.             }
  898.         }
  900.         return $this;
  901.     }
  903.     public function isIsCoach(): ?bool
  904.     {
  905.         return $this->isCoach;
  906.     }
  908.     public function setIsCoach(bool $isCoach): self
  909.     {
  910.         $this->isCoach = $isCoach;
  912.         return $this;
  913.     }
  915.     /**
  916.      * @param Section|null $section
  917.      * @return Collection<int, Debt>
  918.      */
  919.     public function getDebts(?Section $section = null): Collection
  920.     {
  921.         if ($section) {
  922.             return $this->debts->filter(fn(Debt $debt) => $debt->getSection()?->getId() === $section->getId());
  923.         }
  925.         return $this->debts;
  926.     }
  928.     public function addDebt(Debt $debt): self
  929.     {
  930.         if (!$this->debts->contains($debt)) {
  931.             $this->debts[] = $debt;
  932.             $debt->setPerson($this);
  933.         }
  935.         return $this;
  936.     }
  938.     public function removeDebt(Debt $debt): self
  939.     {
  940.         if ($this->debts->removeElement($debt)) {
  941.             // set the owning side to null (unless already changed)
  942.             if ($debt->getPerson() === $this) {
  943.                 $debt->setPerson(null);
  944.             }
  945.         }
  947.         return $this;
  948.     }
  950.     /**
  951.      * @return Collection<int, ContactEmail>
  952.      */
  953.     public function getOwnedEmails(): Collection
  954.     {
  955.         return $this->ownedEmails;
  956.     }
  958.     public function addOwnedEmail(ContactEmail $ownedEmail): self
  959.     {
  960.         if (!$this->ownedEmails->contains($ownedEmail)) {
  961.             $this->ownedEmails[] = $ownedEmail;
  962.             $ownedEmail->setOwner($this);
  963.         }
  965.         return $this;
  966.     }
  968.     public function removeOwnedEmail(ContactEmail $ownedEmail): self
  969.     {
  970.         if ($this->ownedEmails->removeElement($ownedEmail)) {
  971.             // set the owning side to null (unless already changed)
  972.             if ($ownedEmail->getOwner() === $this) {
  973.                 $ownedEmail->setOwner(null);
  974.             }
  975.         }
  977.         return $this;
  978.     }
  980.     /**
  981.      * @return Collection<int, ContactPhone>
  982.      */
  983.     public function getOwnedPhones(): Collection
  984.     {
  985.         return $this->ownedPhones;
  986.     }
  988.     public function addOwnedPhone(ContactPhone $ownedPhone): self
  989.     {
  990.         if (!$this->ownedPhones->contains($ownedPhone)) {
  991.             $this->ownedPhones[] = $ownedPhone;
  992.             $ownedPhone->setOwner($this);
  993.         }
  995.         return $this;
  996.     }
  998.     public function removeOwnedPhone(ContactPhone $ownedPhone): self
  999.     {
  1000.         if ($this->ownedPhones->removeElement($ownedPhone)) {
  1001.             // set the owning side to null (unless already changed)
  1002.             if ($ownedPhone->getOwner() === $this) {
  1003.                 $ownedPhone->setOwner(null);
  1004.             }
  1005.         }
  1007.         return $this;
  1008.     }
  1010.     /**
  1011.      * @return Collection<int, Donation>
  1012.      */
  1013.     public function getDonations(): Collection
  1014.     {
  1015.         return $this->donations;
  1016.     }
  1018.     public function addDonation(Donation $donation): self
  1019.     {
  1020.         if (!$this->donations->contains($donation)) {
  1021.             $this->donations->add($donation);
  1022.             $donation->setPerson($this);
  1023.         }
  1025.         return $this;
  1026.     }
  1028.     public function removeDonation(Donation $donation): self
  1029.     {
  1030.         if ($this->donations->removeElement($donation)) {
  1031.             // set the owning side to null (unless already changed)
  1032.             if ($donation->getPerson() === $this) {
  1033.                 $donation->setPerson(null);
  1034.             }
  1035.         }
  1037.         return $this;
  1038.     }
  1040.     public function isBenefactor(): ?bool
  1041.     {
  1042.         return $this->benefactor;
  1043.     }
  1045.     public function setBenefactor(bool $benefactor): self
  1046.     {
  1047.         $this->benefactor = $benefactor;
  1049.         return $this;
  1050.     }
  1052.     /**
  1053.      * @return Collection<int, LegalPerson>
  1054.      */
  1055.     public function getLegalPersons(): Collection
  1056.     {
  1057.         return $this->legalPersons;
  1058.     }
  1060.     public function addLegalPerson(LegalPerson $legalPerson): self
  1061.     {
  1062.         if (!$this->legalPersons->contains($legalPerson)) {
  1063.             $this->legalPersons->add($legalPerson);
  1064.             $legalPerson->setRelatedPerson($this);
  1065.         }
  1067.         return $this;
  1068.     }
  1070.     public function removeLegalPerson(LegalPerson $legalPerson): self
  1071.     {
  1072.         if ($this->legalPersons->removeElement($legalPerson)) {
  1073.             // set the owning side to null (unless already changed)
  1074.             if ($legalPerson->getRelatedPerson() === $this) {
  1075.                 $legalPerson->setRelatedPerson(null);
  1076.             }
  1077.         }
  1079.         return $this;
  1080.     }
  1082.     public function getClub1895Profile(): ?Club1895Profile
  1083.     {
  1084.         return $this->club1895Profile;
  1085.     }
  1087.     public function setClub1895Profile(Club1895Profile $club1895Profile): self
  1088.     {
  1089.         // set the owning side of the relation if necessary
  1090.         if ($club1895Profile->getPerson() !== $this) {
  1091.             $club1895Profile->setPerson($this);
  1092.         }
  1094.         $this->club1895Profile = $club1895Profile;
  1096.         return $this;
  1097.     }
  1099.     public function isClub1895Interested(): ?bool
  1100.     {
  1101.         return $this->club1895Interested;
  1102.     }
  1104.     public function setClub1895Interested(?bool $club1895Interested): self
  1105.     {
  1106.         $this->club1895Interested = $club1895Interested;
  1108.         return $this;
  1109.     }
  1110. }