fix accompanying period/remove person

src/Bundle/ChillPersonBundle/Entity/AccompanyingPeriod.php

@@ -118,7 +118,7 @@ class AccompanyingPeriod
      *
      * @ORM\OneToMany(targetEntity=AccompanyingPeriodParticipation::class,
      *     mappedBy="accompanyingPeriod",
-     *     cascade={"persist", "remove", "merge", "detach"})
+     *     cascade={"persist", "refresh", "remove", "merge", "detach"})
      */
     private $participations;
 
@@ -344,50 +344,68 @@ class AccompanyingPeriod
     }
 
     /**
-     * This private function scan Participations Collection,
+     * Get the participation containing a person
-     * searching for a given Person
      */
-    private function participationsContainsPerson(Person $person): ?AccompanyingPeriodParticipation
+    public function getParticipationsContainsPerson(Person $person): Collection
     {
-        foreach ($this->participations as $participation) {
+        return $this->getParticipations($person)->filter(
-            /** @var AccompanyingPeriodParticipation $participation */
+            function(AccompanyingPeriodParticipation $participation) use ($person) {
-            if ($person === $participation->getPerson()) {
+                if ($person === $participation->getPerson()) {
-                return $participation;
+                    return $participation;
-        }}
+                }
-
+            });
-        return null;
     }
 
     /**
-     * This public function is the same but return only true or false
+     * Get the opened participation containing a person
+     *
+     * "Open" means that the closed date is NULL
+     */
+    public function getOpenParticipationContainsPerson(Person $person): ?AccompanyingPeriodParticipation
+    {
+        $collection = $this->getParticipationsContainsPerson($person)->filter(
+            function(AccompanyingPeriodParticipation $participation) use ($person) {
+                if (NULL === $participation->getEndDate()) {
+                    return $participation;
+                }
+            });
+
+        return $collection->count() > 0 ? $collection->first() : NULL;
+    }
+
+    /**
+     * Return true if the accompanying period contains a person. 
+     *
+     * **Note**: this participation can be opened or not.
      */
     public function containsPerson(Person $person): bool
     {
-        return ($this->participationsContainsPerson($person) === null) ? false : true;
+        return $this->getParticipationsContainsPerson($person)->count() > 0;
     }
 
     /**
      * Add Person
      */
-    public function addPerson(Person $person = null): self
+    public function addPerson(Person $person = null): AccompanyingPeriodParticipation
     {
         $participation = new AccompanyingPeriodParticipation($this, $person);
         $this->participations[] = $participation;
 
-        return $this;
+        return $participation;
     }
 
     /**
      * Remove Person
      */
-    public function removePerson(Person $person): void
+    public function removePerson(Person $person): ?AccompanyingPeriodParticipation
     {
-        $participation = $this->participationsContainsPerson($person);
+        $participation = $this->getOpenParticipationContainsPerson($person);
 
-        if (! null === $participation) {
+        if ($participation instanceof AccompanyingPeriodParticipation) {
             $participation->setEndDate(new \DateTimeImmutable('now'));
-            $this->participations->removeElement($participation);
         }
+
+        return $participation;
     }
 
 

src/Bundle/ChillPersonBundle/Entity/Person.php

@@ -390,7 +390,7 @@ class Person implements HasCenterInterface
      *
      * @deprecated since 1.1 use `getOpenedAccompanyingPeriod instead
      */
-    public function getCurrentAccompanyingPeriod() : AccompanyingPeriod
+    public function getCurrentAccompanyingPeriod() : ?AccompanyingPeriod
     {
         return $this->getOpenedAccompanyingPeriod();
     }

src/Bundle/ChillPersonBundle/Tests/Entity/AccompanyingPeriodTest.php

@@ -27,7 +27,6 @@ use Chill\PersonBundle\Entity\Person;
 
 class AccompanyingPeriodTest extends \PHPUnit\Framework\TestCase
 {
-
     public function testClosingIsAfterOpeningConsistency()
     {
         $datetime1 = new \DateTime('now');
@@ -77,22 +76,33 @@ class AccompanyingPeriodTest extends \PHPUnit\Framework\TestCase
         $this->assertFalse($period->isOpen());
     }
 
-    public function testCanBeReOpened()
+    public function testPersonPeriod()
     {
-        $person = new Person(\DateTime::createFromFormat('Y-m-d', '2010-01-01'));
+        $person = new Person();
-        $person->close($person->getAccompanyingPeriods()[0]
+        $person2 = new Person();
-                ->setClosingDate(\DateTime::createFromFormat('Y-m-d', '2010-12-31')));
+        $person3 = new Person();
+        $period = new AccompanyingPeriod(new \DateTime());
 
-        $firstAccompanygingPeriod = $person->getAccompanyingPeriodsOrdered()[0];
+        $period->addPerson($person);
+        $period->addPerson($person2);
+        $period->addPerson($person3);
 
-        $this->assertTrue($firstAccompanygingPeriod->canBeReOpened());
+        $this->assertEquals(3, $period->getParticipations()->count());
+        $this->assertTrue($period->containsPerson($person));
+        $this->assertFalse($period->containsPerson(new Person()));
 
-        $lastAccompanyingPeriod = (new AccompanyingPeriod(\DateTime::createFromFormat('Y-m-d', '2011-01-01')))
+        $participation = $period->getOpenParticipationContainsPerson($person);
-                ->setClosingDate(\DateTime::createFromFormat('Y-m-d', '2011-12-31'))
+        $participations = $period->getParticipationsContainsPerson($person);
-                ;
+        $this->assertNotNull($participation);
-        $person->addAccompanyingPeriod($lastAccompanyingPeriod);
+        $this->assertSame($person, $participation->getPerson());
+        $this->assertEquals(1, $participations->count());
 
-        $this->assertFalse($firstAccompanygingPeriod->canBeReOpened());
+        $participationL = $period->removePerson($person);
+        $this->assertSame($participationL, $participation);
+        $this->assertTrue($participation->getEndDate() instanceof \DateTimeInterface);
+
+        $participation = $period->getOpenParticipationContainsPerson($person);
+        return;
+        $this->assertNull($participation);
     }
-
 }