Adapt entity AccompanyingPeriodParticipation attributes and methods (dont break UI)

src/Bundle/ChillPersonBundle/Entity/AccompanyingPeriod.php

@@ -35,7 +35,7 @@ use Chill\MainBundle\Entity\User;
 /**
  * AccompanyingPeriod Class
  *
- * @ORM\Entity(repositoryClass=AccompanyingPeriodRepository::class)
+ * @ORM\Entity(repositoryClass="Chill\PersonBundle\Repository\AccompanyingPeriodRepository")
  * @ORM\Table(name="chill_person_accompanying_period")
  */
 class AccompanyingPeriod
@@ -79,9 +79,10 @@ class AccompanyingPeriod
      * @var Collection
      *
      * @ORM\OneToMany(targetEntity=AccompanyingPeriodParticipation::class,
-     *     mappedBy="accompanyingPeriod")
+     *     mappedBy="accompanyingPeriod",
+     *     cascade={"persist", "remove", "merge", "detach"})
      */
-    private $persons;
+    private $participations;
     
     /**
      * @var AccompanyingPeriod\ClosingMotive
@@ -175,7 +176,7 @@ class AccompanyingPeriod
      */
     public function __construct(\DateTime $dateOpening) {
         $this->setOpeningDate($dateOpening);
-        $this->persons = new ArrayCollection();
+        $this->participations = new ArrayCollection();
         $this->scopes = new ArrayCollection();
     }
 
@@ -280,37 +281,63 @@ class AccompanyingPeriod
     {
         return $this->remark;
     }
-
-    public function getPersons(): Collection
-    {
-        return $this->persons;
-    }
     
-    public function containsPerson(Person $person): bool
+    /**
+     * Get Participations Collection
+     */
+    public function getParticipations(): Collection
     {
-        foreach ($this->persons as $p) {
-            if ($p === $person) { return true; }
-        }
-
-        return false;
+        return $this->participations;
     }
     
     /**
-     * For consistency, you should use Person::addAccompanyingPeriod instead.
-     * @see Person::addAccompanyingPeriod
+     * This private function scan Participations Collection,
+     * searching for a given Person
+     */
+    private function participationsContainsPerson(Person $person): ?AccompanyingPeriodParticipation
+    {
+        foreach ($this->participations as $participation) {
+            /** @var AccompanyingPeriodParticipation $participation */
+            if ($person === $participation->getPerson()) {
+                return $participation;
+        }}
+
+        return null;
+    }
+    
+    /**
+     * This public function is the same but return only true or false
+     */
+    public function containsPerson(Person $person): bool
+    {
+        return ($this->participationsContainsPerson($person) === null) ? false : true;
+    }
+    
+    /**
+     * Add Person
      */
     public function addPerson(Person $person = null): self
     {
-        $this->persons[] = $person;
+        $participation = new AccompanyingPeriodParticipation($this, $person);
+        $this->participations[] = $participation;
     
         return $this;
     }
     
+    /**
+     * Remove Person
+     */
     public function removePerson(Person $person): void
     {
-        $this->persons->removeElement($person);
+        $participation = $this->participationsContainsPerson($person);
+        
+        if (! null === $participation) {
+            $participation->setEndDate(new \DateTimeImmutable('now'));
+            $this->participations->removeElement($participation);
+        }
     }
     
+    
     public function getClosingMotive(): ?ClosingMotive
     {
         return $this->closingMotive;
@@ -335,11 +362,12 @@ class AccompanyingPeriod
             return false;
         }
         
-        foreach ($this->getPersons() as $p) {
-            if ($p === $person) {
-                $periods = $p->getAccompanyingPeriodsOrdered();
-                return end($periods) === $this;
-            }
+        $participation = $this->participationsContainsPerson($person);
+        if (!null === $participation)
+        {
+            $person = $participation->getPerson();
+            $periods = $person->getAccompanyingPeriodsOrdered();
+            return end($periods) === $this;
         }
         
         return false;

src/Bundle/ChillPersonBundle/Entity/AccompanyingPeriodParticipation.php

@@ -44,22 +44,81 @@ class AccompanyingPeriodParticipation
     private $id;
     
     /**
-     * @ORM\ManyToOne(targetEntity=Person::class,
-     *     inversedBy="accompanyingPeriods")
+     * @ORM\ManyToOne(targetEntity=Person::class, inversedBy="accompanyingPeriodParticipations")
      * @ORM\JoinColumn(name="person_id", referencedColumnName="id", nullable=false)
      */
     private $person;
     
     /**
-     * @ORM\ManyToOne(targetEntity=AccompanyingPeriod::class,
-     *     inversedBy="persons")
+     * @ORM\ManyToOne(targetEntity=AccompanyingPeriod::class, inversedBy="participations")
      * @ORM\JoinColumn(name="accompanyingperiod_id", referencedColumnName="id", nullable=false)
      */
     private $accompanyingPeriod;
     
+    /**
+     * @ORM\Column(type="date", nullable=false)
+     */
+    private $startDate;
+    
+    /**
+     * @ORM\Column(type="date", nullable=true)
+     */
+    private $endDate = null;
+    
+    public function __construct(AccompanyingPeriod $accompanyingPeriod, Person $person)
+    {
+        $this->startDate = new \DateTimeImmutable('now');
+        $this->accompanyingPeriod = $accompanyingPeriod;
+        $this->person = $person;
+    }
     
     public function getId(): ?int
     {
         return $this->id;
     }
+    
+    public function getPerson(): ?Person
+    {
+        return $this->person;
+    }
+    
+    public function setPerson(?Person $person): self
+    {
+        $this->person = $person;
+        
+        return $this;
+    }
+    
+    public function getAccompanyingPeriod(): ?AccompanyingPeriod
+    {
+        return $this->accompanyingPeriod;
+    }
+    
+    public function setAccompanyingPeriod(?AccompanyingPeriod $accompanyingPeriod): self
+    {
+        $this->accompanyingPeriod = $accompanyingPeriod;
+        
+        return $this;
+    }
+    
+    public function getStartDate(): ?\DateTimeInterface
+    {
+        return $this->startDate;
+    }
+    
+    /*
+     * public function setStartDate(\DateTimeInterface $startDate): self { $this->startDate = $startDate; return $this; }
+     */
+    
+    public function getEndDate(): ?\DateTimeInterface
+    {
+        return $this->endDate;
+    }
+    
+    public function setEndDate(?\DateTimeInterface $endDate): self
+    {
+        $this->endDate = $endDate;
+        
+        return $this;
+    }
 }

src/Bundle/ChillPersonBundle/Entity/Person.php

@@ -209,7 +209,7 @@ class Person implements HasCenterInterface
      *     mappedBy="person",
      *     cascade={"persist", "remove", "merge", "detach"})
      */
-    private $accompanyingPeriods;
+    private $accompanyingPeriodParticipations;
 
     /**
      * A remark over the person
@@ -262,7 +262,7 @@ class Person implements HasCenterInterface
      */
     public function __construct(\DateTime $opening = null)
     {
-        $this->accompanyingPeriods = new ArrayCollection();
+        $this->accompanyingPeriodParticipations = new ArrayCollection();
         $this->spokenLanguages = new ArrayCollection();
         $this->addresses = new ArrayCollection();
         $this->altNames = new ArrayCollection();
@@ -273,16 +273,39 @@ class Person implements HasCenterInterface
 
         $this->open(new AccompanyingPeriod($opening));
     }
-
+    
     /**
-     * Add AccompanyingPeriod
+     * 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
     {
-        $accompanyingPeriod->addPerson($this);
-        $this->accompanyingPeriods->add($accompanyingPeriod);
+        $participation = new AccompanyingPeriodParticipation($accompanyingPeriod, $this);
+        $this->accompanyingPeriodParticipations->add($participation);
         
         return $this;
     }
@@ -292,7 +315,12 @@ class Person implements HasCenterInterface
      */
     public function removeAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod) : void
     {
-        $this->accompanyingPeriods->remove($accompanyingPeriod);
+        $participation = $this->participationsContainAccompanyingPeriod($accompanyingPeriod);
+        
+        if (! null === $participation) {
+            $participation->setEndDate(\DateTimeImmutable::class);
+            $this->accompanyingPeriodParticipations->removeElement($participation);
+        }
     }
 
     /**
@@ -335,9 +363,10 @@ class Person implements HasCenterInterface
             return null;
         }
 
-        foreach ($this->accompanyingPeriods as $period) {
-            if ($period->isOpen()) {
-                return $period;
+        foreach ($this->accompanyingPeriodParticipations as $participation) {
+            /** @var AccompanyingPeriodParticipation $participation */
+            if ($participation->getAccompanyingPeriod()->isOpen()) {
+                return $participation->getAccompanyingPeriod();
             }
         }
     }
@@ -353,19 +382,33 @@ class Person implements HasCenterInterface
     }
 
     /**
-     * Get AccompanyingPeriods Collection
+     * Get AccompanyingPeriods array
      */
-    public function getAccompanyingPeriods() : Collection
+    public function getAccompanyingPeriods(): array
     {
-        return $this->accompanyingPeriods;
+        $accompanyingPeriods = [];
+        foreach ($this->accompanyingPeriodParticipations as $participation)
+        {
+            /** @var AccompanyingPeriodParticipation $participation */
+            $accompanyingPeriods[] = $participation->getAccompanyingPeriod();
+        }
+        return $accompanyingPeriods;
+    }
+    
+    /**
+     * Get AccompanyingPeriodParticipations Collection
+     */
+    public function getAccompanyingPeriodParticipations(): Collection
+    {
+        return $this->accompanyingPeriodParticipations;
     }
 
     /**
      * Get the accompanying periods of a give person with the chronological order.
      */
-    public function getAccompanyingPeriodsOrdered() : array
+    public function getAccompanyingPeriodsOrdered(): array
     {
-        $periods = $this->getAccompanyingPeriods()->toArray();
+        $periods = $this->getAccompanyingPeriods();
 
         //order by date :
         usort($periods, function($a, $b) {
@@ -504,7 +547,7 @@ class Person implements HasCenterInterface
      * @param PersonAltName $altName
      * @return $this
      */
-    public function removeAltName(PersonAltName $altName) 
+    public function removeAltName(PersonAltName $altName)
     {
         if ($this->altNames->contains($altName)) {
             $altName->setPerson(null);