src/Entity/Person.php line 29

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Controller\Admin\ChangesController;
  6. use App\Helper\CompareHelper;
  7. use App\Repository\PersonRepository;
  8. use App\Repository\ReferenceRepository;
  9. use App\Service\UploaderHelper;
  10. use App\Validator\UncertainNumber;
  11. use App\Validator\PersonFormAge;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Gedmo\Mapping\Annotation as Gedmo;
  17. use Gedmo\Timestampable\Traits\TimestampableEntity;
  18. use phpDocumentor\Reflection\Types\Boolean;
  19. use Psr\Log\LoggerInterface;
  20. //use Symfony\Component\Validator\Constraints\NotBlank as Assert;
  21. use Symfony\Component\Serializer\Annotation\Groups;
  22. use Symfony\Component\Validator\Constraints as Assert;
  23. use Symfony\Component\Validator\Context\ExecutionContextInterface;
  25. /**
  26.  * @ORM\Entity(repositoryClass=PersonRepository::class)
  27.  * @ORM\Table(name="person", indexes={@ORM\Index(name="IDX_34DCD176A54DED42", columns={"folk_id"})})
  28.  */
  29. class Person extends ChangeableEntity
  30. {
  31.     use TimestampableEntity;
  32.     /**
  33.      * @ORM\Id()
  34.      * @ORM\GeneratedValue(strategy="IDENTITY")
  35.      * @ORM\Column(type="integer")
  36.      * @Groups("participant")
  37.      */
  38.     protected $id;
  40.     /**
  41.      * @ORM\Column(type="string", length=255, nullable=false)
  42.      * @Assert\NotBlank(message="das muss schon sein....")
  43.      * @Groups({"main", "info", "participant"})
  44.      */
  45.     private $name;
  47.     /**
  48.      * @ORM\Column(type="integer", nullable=true)
  49.      * @Groups("info")
  50.      */
  51.     private $born;
  53.     /**
  54.      * @ORM\Column(type="integer", nullable=true)
  55.      * @Groups("info")
  56.      */
  57.     private $died;
  59.     /**
  60.      * @ORM\Column(type="integer", nullable=true)
  61.      * @Groups("info")
  62.      */
  63.     private $bornEstimated;
  65.     /**
  66.      * @ORM\Column(type="integer", nullable=true)
  67.      * @Groups("info")
  68.      */
  69.     private $diedEstimated;
  71.     /**
  72.      * @ORM\Column(type="string", length=5, nullable=true)
  73.      * @Groups("info")
  74.      */
  75.     private $gender;
  77.     /**
  78.      * @ORM\Column(type="string", length=255, nullable=true)
  79.      * @Groups({"info", "participant"})
  80.      */
  81.     private $alternateNames;
  83.     /**
  84.      * @ORM\Column(type="string", length=255, nullable=true)
  85.      */
  86.     private $url;
  88.     /**
  89.      * @ORM\Column(type="string", length=255, nullable=true)
  90.      * @Groups({"info", "participant"})
  91.      */
  92.     private $image;
  94.     /**
  95.      * @ORM\Column(type="boolean")
  96.      */
  97.     private $isAbstract = false;
  99.     /**
  100.      * @ORM\Column(type="integer", nullable=true)
  101.      */
  102.     private $leafStart;
  104.     /**
  105.      * @ORM\Column(type="integer", nullable=true)
  106.      */
  107.     private $leafOut;
  109.     /**
  110.      * @ORM\Column(type="integer", nullable=true)
  111.      */
  112.     private $leafLevel;
  115.     /**
  116.      * @ORM\ManyToOne(targetEntity=Folk::class)
  117.      * @Groups("info")
  118.      */
  119.     private $folk;
  121.     /**
  122.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="getChangedPeoples")
  123.      */
  124.     private $owner = null;
  126.     /**
  127.      * @ORM\ManyToOne(targetEntity=Person::class)
  128.      * @ORM\JoinColumn(onDelete="SET NULL")
  129.      */
  130.     private $livedAtTimeOfPerson;
  132.     /**
  133.      * @ORM\OneToMany(targetEntity=EventPerson::class, mappedBy="person", cascade={"persist"})
  134.      */
  135.     private $events;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity=PersonReference::class, mappedBy="person", orphanRemoval=true)
  139.      */
  140.     private $personReferences;
  142.     /**
  143.      * @ORM\Column(type="boolean")
  144.      */
  145.     protected $approved = false;
  148.     /**
  149.      * @ORM\Column(type="integer", nullable=true)
  150.      */
  151.     private $bornCalculated;
  153.     /**
  154.      * @ORM\Column(type="integer", nullable=true)
  155.      */
  156.     private $diedCalculated;
  159.     /**
  160.      * @PersonFormAge
  161.      * @UncertainNumber()
  162.      */
  163.     protected $uncertainBorn;
  164.     /**
  165.      * @UncertainNumber()
  166.      */
  167.     protected $uncertainDied;
  169.     /**
  170.      * @ORM\Column(type="text", nullable=true)
  171.      */
  172.     private $description;
  174.     /**
  175.      * @ORM\ManyToMany(targetEntity=Job::class, inversedBy="people")
  176.      */
  177.     private $job;
  180.     /**
  181.      * @ORM\ManyToMany(targetEntity=Folk::class, inversedBy="people")
  182.      */
  183.     private $progenitor;
  185.     /**
  186.      * @ORM\OneToMany(targetEntity=PersonLink::class, mappedBy="parent", cascade={"persist"})
  187.      */
  188.     private $children;
  190.     /**
  191.      * @ORM\OneToMany(targetEntity=PersonLink::class, mappedBy="child", cascade={"persist"})
  192.      */
  193.     private $parents;
  195.     /**
  196.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="taggedPersonsForDelete")
  197.      */
  198.     protected $taggedForDeleteBy;
  200.     /**
  201.      * @ORM\ManyToOne(targetEntity=Person::class, inversedBy="updates")
  202.      */
  203.     protected $updateOf;
  205.     /**
  206.      * @ORM\OneToMany(targetEntity=Person::class, mappedBy="updateOf")
  207.      */
  208.     protected $updates;
  210.     /**
  211.      * @ORM\OneToMany(targetEntity=PersonVersion::class, mappedBy="person", orphanRemoval=true)
  212.      */
  213.     private $personVersions;
  216.     public function __construct()
  217.     {
  218.         $this->events = new ArrayCollection();
  219.         $this->personReferences = new ArrayCollection();
  220.         $this->job = new ArrayCollection();
  221.         $this->progenitor = new ArrayCollection();
  222.         $this->children = new ArrayCollection();
  223.         $this->parents = new ArrayCollection();
  225.        // $this->eventsParticipated = new ArrayCollection();
  226.         $this->personVersions = new ArrayCollection();
  227.     }
  229.     public function __clone()
  230.     {
  231.         $this->id = null;
  232.     }
  234.     public function getId(): ?int
  235.     {
  236.         return $this->id;
  237.     }
  239.     public function getUniqueName(bool $unique = true): ?string
  240.     {
  241.         $parentName = '';
  242.         if($unique) {
  243.             if($this->getFather()) {
  244.                 $parentName = ' (' . $this->getFather()->getName(false) .')';
  245.             } else if ($this->getMother()) {
  246.                 $parentName = ' ('.$this->getMother()->getName(false).')';
  247.             }
  248.         }
  249.         return $this->name . $parentName;
  250.     }
  252.     public function getName(?User $user = null): ?string
  253.     {
  254.         if($user && $user->getPreferedVersion()) {
  255.             $ret = $this->name;
  256.             foreach($this->getPersonVersions() as $version){
  257.                 if($version->getId() == $user->getPreferedVersion()) {
  259.                     if($version->getName()) {
  260.                         $ret = $version->getName();
  261.                     }
  262.                     break;
  263.                 }
  264.             }
  265.         }
  266.         return $this->name;
  267.     }
  269.     public function getNameWidthAddition(?User $user): ?string
  270.     {
  272.         return $this->getName($user) . $this->getAlternateNames() ? ' (' . $this->getAlternateNames() .')' : '';
  273.     }
  275.     public function getShortName(): ?string
  276.     {
  277.         if(strpos($this->name, " ") === false)
  278.             return $this->name;
  279.         return strstr ($this->name, " ", true);
  280.     }
  282.     public function getNameWithBreak(): ?string
  283.     {
  285.         if($this->getAlternateNames() === null)
  286.             return $this->name;
  288.         return $this->name . "\n" . $this->getAlternateNames();
  289.     }
  291.     public function setName(string $name): self
  292.     {
  293.         $this->name = $name;
  295.         return $this;
  296.     }
  298.     public function getBorn(bool $estimateIfNull = false, bool $calculatedIfNull = false, $formatted = false)
  299.     {
  301.         $ret = $this->born;
  302.         $estimated = '';
  303.         if(!$this->born && $estimateIfNull === true) {
  304.             $ret =  $this->getBornEstimated(1);
  305.             if($ret === null && $calculatedIfNull === true) {
  306.                 $ret = $this->getBornCalculated();
  307.                 $estimated = ' (c)';
  308.             } else {
  309.                 $estimated = '?';
  310.             }
  311.         }
  313.         if($ret && $formatted) {
  314.             $ret = $ret < 0 ? -$ret . ' BC' : $ret . 'AD';
  315.             $ret.= $estimated;
  316.         }
  318.         return $ret;
  319.     }
  321.     public function getDied(bool $estimateIfNull = false, bool $calculatedIfNull = false, $formatted = false)
  322.     {
  323.         $ret = $this->died;
  324.         $estimated = '';
  325.         if(!$this->died && $estimateIfNull === true)
  326.         {
  327.             $ret = $this->getDiedEstimated(1);
  328.             if($ret === null && $calculatedIfNull) {
  329.                 $ret = $this->getDiedCalculated();
  330.                 $estimated = ' (c)';
  331.             } else {
  332.                 $estimated = '?';
  333.             }
  334.         }
  335.         if($ret && $formatted) {
  336.             $ret = $ret < 0 ? -$ret . ' BC' : $ret . ' AD';
  337.             $ret.= $estimated;
  338.         }
  339.         return $ret;
  340.     }
  342.     public function setBorn(?int $born): self
  343.     {
  344.         $this->born = $born;
  346.         return $this;
  347.     }
  349.     public function setAge(?int $age) : self
  350.     {
  351.         return $this;
  352.     }
  354.     public function getAge(bool $estimateIfNull = false, bool $calculatedIfNull = false): ?int
  355.     {
  356.         $b = $this->getBorn($estimateIfNull, $calculatedIfNull);
  357.         $d = $this->getDied($estimateIfNull, $calculatedIfNull);
  359.         if($b && $d && $b <= $d){
  360.             return ($d - $b);
  361.         }
  362.         return null;
  363.     }
  365.     public function setDied(?int $died): self
  366.     {
  367.         $this->died = $died;
  369.         return $this;
  370.     }
  372.     public function getBornEstimated($recursion = 10, bool $calculationIfNull = false, $formatted = false): ?int
  373.     {
  374.         if(!$this->bornEstimated && $recursion > 0)
  375.         {
  376.             if($calculationIfNull && $this->getBornCalculated()) {
  377.                 return $this->getBornCalculated();
  378.             }
  379.             if( $this->livedAtTimeOfPerson) {
  380.                 if ($this->livedAtTimeOfPerson->getBorn() !== null) {
  381.                     return $this->livedAtTimeOfPerson->getBorn();
  382.                 }
  383.                 // beware, don't use recursion  (getBorn(true)  here!
  384.                 return $this->livedAtTimeOfPerson->getBornEstimated($recursion - 1, $calculationIfNull, $formatted);
  385.             }
  386.         }
  387.         if ($formatted) {
  388.             return $this->bornEstimated . ' ?';
  389.         }
  390.         return $this->bornEstimated;
  391.     }
  393.     public function setBornEstimated(?int $bornEstimated): self
  394.     {
  395.         $this->bornEstimated = $bornEstimated;
  397.         return $this;
  398.     }
  400.     public function getDiedEstimated($recursion = 10, bool $calculationIfNull = false, $formatted = false): ?int
  401.     {
  402.         if(!$this->diedEstimated && $recursion > 0)
  403.         {
  404.             if($calculationIfNull && $this->getDiedCalculated()) {
  405.                 return $this->getDiedCalculated();
  406.             }
  408.             if($this->livedAtTimeOfPerson) {
  409.                 if( $this->livedAtTimeOfPerson->getDied() !== null)
  410.                     return $this->livedAtTimeOfPerson->getDied();
  411.                 // beware, don't use recursion  (getDied(true)  here!
  412.                 return $this->livedAtTimeOfPerson->getDiedEstimated($recursion - 1);
  413.             }
  414.         }
  415.         if ($formatted) {
  416.             return $this->diedEstimated . ' ?';
  417.         }
  418.         return $this->diedEstimated;
  419.     }
  421.     public function setDiedEstimated(?int $diedEstimated): self
  422.     {
  423.         $this->diedEstimated = $diedEstimated;
  425.         return $this;
  426.     }
  428.     public function getGender(): ?string
  429.     {
  430.         return $this->gender;
  431.     }
  433.     public function setGender(?string $gender): self
  434.     {
  435.         $this->gender = $gender;
  437.         return $this;
  438.     }
  440.     public function getAlternateNames(): ?string
  441.     {
  442.         return $this->alternateNames;
  443.     }
  445.     public function setAlternateNames(?string $alternateNames): self
  446.     {
  447.         $this->alternateNames = $alternateNames;
  449.         return $this;
  450.     }
  452.     public function getUrl(): ?string
  453.     {
  454.         return $this->url;
  455.     }
  457.     public function setUrl(?string $url): self
  458.     {
  459.         $this->url = $url;
  461.         return $this;
  462.     }
  464.     public function getImage($fullPath = true): ?string
  465.     {
  466.         if(!$fullPath)
  467.         {
  468.             return $this->image;
  469.         }
  470.         if($this->image !== null) {
  471.             return UploaderHelper::PERSON_IMAGE.'/'. $this->image;
  472.         } else {
  474.             if(!empty($this->getJob())){
  475.                 /* @var Job $job*/
  477.                 $job = $this->getJob()[0];
  479.                 return UploaderHelper::PERSON_IMAGE.'/'. $job->getName() .'.png';
  480.             }
  481.             return UploaderHelper::PERSON_IMAGE.'/'. 'default_'. $this->getGender() .'.png';
  482.         }
  483.         return null;
  484.     }
  486.     public function setImage(?string $image): self
  487.     {
  488.         $this->image = $image;
  490.         return $this;
  491.     }
  493.     public function getIsAbstract(): ?bool
  494.     {
  495.         return $this->isAbstract;
  496.     }
  498.     public function setIsAbstract(bool $isAbstract): self
  499.     {
  500.         $this->isAbstract = $isAbstract;
  502.         return $this;
  503.     }
  505.     public function getLeafStart(): ?int
  506.     {
  507.         return $this->leafStart;
  508.     }
  510.     public function setLeafStart(?int $leafStart): self
  511.     {
  512.         $this->leafStart = $leafStart;
  514.         return $this;
  515.     }
  517.     public function getLeafOut(): ?int
  518.     {
  519.         return $this->leafOut;
  520.     }
  522.     public function setLeafOut(?int $leafOut): self
  523.     {
  524.         $this->leafOut = $leafOut;
  526.         return $this;
  527.     }
  529.     public function getLeafLevel(): ?int
  530.     {
  531.         return $this->leafLevel;
  532.     }
  534.     public function setLeafLevel(?int $leafLevel): self
  535.     {
  536.         $this->leafLevel = $leafLevel;
  538.         return $this;
  539.     }
  542.     function filter_callback(Person $person, bool $isOrigin) : bool{
  543.         if ($person->getUpdateOf() == null) {
  544.             return $isOrigin;
  545.         }
  546.         return !$isOrigin;
  547.     }
  549.     public function getUpdate(?User $user) : self{
  551.         if ($user && !in_array('ROLE_ACCEPT_CHANGES', $user->getRoles())) {
  552.             $arr = $this->updates->toArray();
  554.             $arr = array_filter($arr, function(Person $person) use ($user){
  555.                 return ($person->getOwner() == $user);
  556.             });
  557.             if(!empty($arr)) {
  558.                 return array_slice($arr, 0, 1)[0];;
  559.             }
  560.         }
  561.         return $this;
  562.     }
  566.     public function getFolk()
  567.     {
  568.         return $this->folk;
  569.     }
  571.     public function setFolk(?Folk $folk): self
  572.     {
  573.         $this->folk = $folk;
  575.         return $this;
  576.     }
  578.     public function getOwner(): ?User
  579.     {
  580.         return $this->owner;
  581.     }
  583.     public function setOwner(?User $owner): self
  584.     {
  585.         $this->owner = $owner;
  587.         return $this;
  588.     }
  590.     public function isPublished() : bool
  591.     {
  592.         return $this->owner === null;
  593.     }
  595.     public function __toString()
  596.     {
  597.         return $this->name;
  598.     }
  600.     /**
  601.      * @param ExecutionContextInterface $context
  602.      * @param $payload
  603.      * @Assert\Callback
  604.      */
  605.     public function validate(ExecutionContextInterface $context, $payload)
  606.     {
  607.         if (stripos($this->getName(), 'Hans') !== false) {
  608.             $context->buildViolation('No Hans allowed!')
  609.                 ->atPath('name')
  610.                 ->addViolation();
  611.         };
  612.     }
  614.     public function getLivedAtTimeOfPerson(): ?self
  615.     {
  616.         return $this->livedAtTimeOfPerson;
  617.     }
  619.     public function setLivedAtTimeOfPerson(?self $livedAtTimeOfPerson): self
  620.     {
  621.         $this->livedAtTimeOfPerson = $livedAtTimeOfPerson;
  623.         return $this;
  624.     }
  626.     public function getReferenceList(?User $user, $type = null): array
  627.     {
  628.         $list = [];
  629.         if($this->getUpdateOf()){
  630.             return $this->getUpdateOf()->getReferenceList($type);
  631.         }
  633.         if($type == null)
  634.         {
  635.             $list = $this->getPersonReferences();
  636.         }
  637.         else {
  638.             /* @var  Reference $personReference */
  639.             foreach ($this->getPersonReferences() as $personReference) {
  641.                 if (!$type || $personReference->getType() == $type) {
  642.                     $list[] = $personReference;
  643.                 }
  644.             }
  645.         }
  646.         foreach ($list as $key => $personReference) {
  648.             if($personReference->getTaggedForDeleteBy() == $user){
  649.                 unset($list[$key]);
  650.             }
  651.             if($personReference->getApproved() == false && $personReference->getOwner() != $user){
  652.                 unset($list[$key]);
  653.             }
  654.         }
  656.         $list = array_values($list);
  657.         /** @var Reference $ref*/
  658.        return $list;
  660.     }
  664.     /**
  665.      * @return Collection|Event[]
  666.      */
  667.     public function getEvents(): Collection
  668.     {
  669.         return $this->events;
  670.     }
  672.     public function addEvent(Event $event, ?User $user): self
  673.     {
  674.         $eventPerson = new EventPerson();
  675.         $eventPerson->setApproved($user->acceptsChanges() ? 1 : 0);
  676.         $eventPerson->setEvent($event);
  677.         $eventPerson->setOwner($user);
  678.         $eventPerson->setPerson($this);
  680.         //$event->addParticipant($eventPerson);
  682.         if (!$this->events->contains($eventPerson)) {
  683.             $this->events[] = $eventPerson;
  684.         }
  686.         return $this;
  687.     }
  689.     public function removeEvent(Event $event): self
  690.     {
  691.         if ($this->events->contains($event)) {
  692.             $this->events->removeElement($event);
  693.             $event->removeParticipant($this);
  694.         }
  695.         return $this;
  696.     }
  698.     /**
  699.      * //return Collection|PersonReference[]|array
  700.      */
  701.     public function getPersonReferences(bool $asName = false)
  702.     {
  703.         $arr = [];
  705.         if($this->getUpdateOf()){
  706.             return $this->getUpdateOf()->getPersonReferences($asName);
  707.         };
  709.         /** @var PersonReference $personReference */
  710.         foreach($this->personReferences as $personReference){
  711.             if($asName) {
  712.                 $arr[] = $personReference->getReference()->generatUrl();
  713.             } else {
  714.                 $arr[] = $personReference;
  715.             }
  716.         }
  717.         return $arr;
  718.     }
  720.     public function getPersonReferencesAsName() {
  721.         return $this->getPersonReferences(true);
  722.     }
  724.     public function addPersonReference(PersonReference $personReference): self
  725.     {
  726.         if (!$this->personReferences->contains($personReference)) {
  727.             $this->personReferences[] = $personReference;
  728.             $personReference->setPerson($this);
  729.         }
  731.         return $this;
  732.     }
  734.     public function removePersonReference(PersonReference $personReference): self
  735.     {
  736.         if ($this->personReferences->contains($personReference)) {
  737.             $this->personReferences->removeElement($personReference);
  738.             // set the owning side to null (unless already changed)
  739.             if ($personReference->getPerson() === $this) {
  740.                 $personReference->setPerson(null);
  741.             }
  742.         }
  744.         return $this;
  745.     }
  747. /*
  748.     public function getDifference(Person $p){
  750.         $originSet = [];
  751.         foreach(get_object_vars($this) as $key => $value) {
  752.             $originSet[$key] = $value;
  753.         }
  754. dd($originSet);
  755.         $changes = [];
  756.         foreach($originSet as $key => $value)
  757.         {
  758.             $getFunctionName = 'get' . ucfirst($key);
  759.             $success = false;
  760.             try {
  761.                 if (method_exists($this, $getFunctionName)) {
  763.                     $function = call_user_func(
  764.                         array($this, $getFunctionName)
  765.                     );
  766.                     dump($key, $function, $value);
  767.                 }
  768.             }
  769.             catch (\Exception $ex){
  770.                 dd("Exception " . $ex);
  771.             }
  772.         }
  774.     }*/
  775.     /**
  776.      * @return mixed
  777.      * /
  778.     public function getBornUncertain()
  779.     {
  780.         return $this->bornUncertain;
  781.     }
  783.     /**
  784.      * @param mixed $bornUncertain
  785.      * /
  786.     public function setBornUncertain($bornUncertain): void
  787.     {
  788.         $this->bornUncertain = $bornUncertain;
  789.     }*/
  791.     /**
  792.      * @return mixed
  793.      */
  794.     public function getUncertainBorn()
  795.     {
  796.         return $this->uncertainBorn;
  797.     }
  799.     /**
  800.      * @param mixed $uncertainBorn
  801.      */
  802.     public function setUncertainBorn($uncertainBorn): void
  803.     {
  804.         $this->uncertainBorn = $uncertainBorn;
  805.     }
  807.     public function getBornCalculated(): ?int
  808.     {
  809.         return $this->bornCalculated;
  810.     }
  812.     public function setBornCalculated(?int $bornCalculated): self
  813.     {
  814.         $this->bornCalculated = $bornCalculated;
  816.         return $this;
  817.     }
  819.     public function getDiedCalculated(): ?int
  820.     {
  821.         return $this->diedCalculated;
  822.     }
  824.     public function setDiedCalculated(?int $diedCalculated): self
  825.     {
  826.         $this->diedCalculated = $diedCalculated;
  828.         return $this;
  829.     }
  831.     /**
  832.      * @return mixed
  833.      */
  834.     public function getUncertainDied()
  835.     {
  836.         return $this->uncertainDied;
  837.     }
  839.     /**
  840.      * @param mixed $uncertainDied
  841.      */
  842.     public function setUncertainDied($uncertainDied): void
  843.     {
  844.         $this->uncertainDied = $uncertainDied;
  845.     }
  847.     public function getDescription(): ?string
  848.     {
  849.         return $this->description;
  850.     }
  852.     public function setDescription(?string $description): self
  853.     {
  854.         $this->description = $description;
  856.         return $this;
  857.     }
  859.     /**
  860.      * @return Collection|Job[]
  861.      */
  862.     public function getJob()//: Collection
  863.     {
  864.         //return $this->job;
  865.         $arr = [];
  866.         /** @var Job $job */
  867.         foreach ($this->job as $job){
  868.             $arr[] = $job;
  869.         }
  870.         return $arr;
  871.     }
  873.     public function getJobAsName(): array
  874.     {
  875.         $arr = [];
  876.         foreach($this->getJob() as $job){
  877.             $arr = $job->getName();
  878.         }
  879.         return $arr;
  880.     }
  882.     public function addJob(Job $job): self
  883.     {
  884.         if (!$this->job->contains($job)) {
  885.             $this->job[] = $job;
  886.         }
  888.         return $this;
  889.     }
  891.     public function removeJob(Job $job): self
  892.     {
  893.         if ($this->job->contains($job)) {
  894.             $this->job->removeElement($job);
  895.         }
  896.         return $this;
  897.     }
  899.     /**
  900.      * @return Collection|Folk[]
  901.      */
  902.     public function getProgenitor(): Collection
  903.     {
  904.         return $this->progenitor;
  905.     }
  907.     public function addProgenitor(Folk $progenitor): self
  908.     {
  909.         if (!$this->progenitor->contains($progenitor)) {
  910.             $this->progenitor[] = $progenitor;
  911.         }
  913.         return $this;
  914.     }
  916.     public function removeProgenitor(Folk $progenitor): self
  917.     {
  918.         if ($this->progenitor->contains($progenitor)) {
  919.             $this->progenitor->removeElement($progenitor);
  920.         }
  922.         return $this;
  923.     }
  925.     public function showInList(User $user = null) :bool{
  927.         $ret = true;
  929.        /* if($user && in_array('ROLE_ACCEPT_CHANGES', $user->getRoles())) {
  930.             // dont show if is update of ...
  931.             $ret = $this->getUpdateOf(false) == null;
  932.         } else */{
  933.             $ret = !$this->hasUserUpdate($user, false);
  934.         }
  935.         return $ret;
  936.     }
  938.     public function hasUserUpdate(User $user = null): bool
  939.     {
  941.         $ret = false;
  942.         if ($user && !in_array('ROLE_ACCEPT_CHANGES', $user->getRoles())) {
  944.             $arr = array_filter($this->getUpdates()->toArray(), function(Person $update) use ($user) {
  945.                 return ($update->getOwner() == $user);
  946.             });
  947.             $ret = !empty($arr);
  949.         }
  950.         return $ret;
  951.     }
  952. /*
  953. public function getUpdated(User $user = null) : Person{
  954.     $ret = $this;
  955.     if($this->getUpdateOf() && $this->getUpdateOf()->getPerson() !==null) {
  956.         if (!in_array('ROLE_ACCEPT_CHANGES', $user->getRoles())) {
  957.             $ret = $this->getUpdateOf()->getPerson();
  958.         }
  959.     }
  960.     return $ret;
  961. }*/
  963.     public function getUserUpdates(User $user = null): ?array {
  965.         $ret = [];
  966.         if(!$user)
  967.             return $ret;
  968.         if (!in_array('ROLE_ACCEPT_CHANGES', $user->getRoles())) {
  969.             foreach ($this->getUpdates() as $change) {
  971.                 if ($change->getApproved() == 0 &&  $user !== $change->getOwner()) {
  972.                     continue;
  973.                 }
  974.                 $ret[] = $change;
  975.             }
  976.         } else {
  977.             foreach ($this->getUpdates() as $change) {
  978.                 $ret[] = $change;
  979.             }
  980.         }
  981.         return $ret;
  982.     }
  984.     public function hasUpdate(User $user = null, bool $showForAdmin = true): bool {
  986.         $ret = false;
  988.         if($user)
  989.         {
  990.             if($showForAdmin && $user->acceptsChanges() && $this->getUpdates()->count() > 0)
  991.             {
  992.                 $ret = true;
  993.             }
  994.             else
  995.             {
  996.                 foreach ($this->getUpdates() as $update) {
  998.                     if ($update->getOwner() == $user) {
  999.                         $ret = true;
  1000.                         break;
  1001.                     }
  1002.                 }
  1003.             }
  1004.         }
  1005.         return $ret;
  1006.     }
  1007. /*
  1008.     private function isChangeViewAllowed(EntityChange $change, User $user = null) : bool {
  1009.         $ret = false;
  1011.         if($user) {
  1012.             if ($change->getChangedBy() == $user) {
  1013.                 $ret = true;
  1014.             } else {
  1015.                 if (in_array('ROLE_ACCEPT_CHANGES', $user->getRoles())) {
  1016.                     $ret = true;
  1017.                 }
  1018.             }
  1019.         }
  1021.         return $ret;
  1022.     }
  1024.     public function getVisibleChanges(User $user = null) : array  {
  1025.         $ret = [];
  1027.         foreach ($this->getChanges() as $change) {
  1028.             if($this->isChangeViewAllowed($change, $user)) {
  1029.                 if (in_array($change->getModificationType(), ['edit'])) {
  1030.                     if ($change->getUpdatedPerson()) {
  1031.                         $ret[] = $change;
  1032.                     }
  1033.                 }
  1034.             }
  1035.         }
  1036.         return $ret;
  1038.     }
  1041.     public function updateFromChange(EntityManagerInterface $em, EntityChange $change){
  1043.         $p= $change->getUpdatedPerson();
  1044.         $em->refresh($p);
  1046.         $this->setName($p->getName());
  1047.         $this->setDescription($p->getDescription());
  1048.         $this->setAlternateNames($p->getAlternateNames()?? "");
  1050.         $this->setBorn($p->getBorn());
  1051.         $this->setBornEstimated($p->getBornEstimated());
  1052.         $this->setBornCalculated($p->getBornCalculated());
  1053.         $this->setDied($p->getDied());
  1054.         $this->setDiedEstimated($p->getDiedEstimated());
  1055.         $this->setDiedCalculated($p->getDiedCalculated());
  1057.         $this->setFather($p->getFather());
  1058.         $this->setMother($p->getMother());
  1061.     }*/
  1063.     /**
  1064.      * @return Collection|PersonLink[]
  1065.      */
  1066.     public function getParents(): Collection
  1067.     {
  1068.         return $this->parents;
  1069.     }
  1071.     public function getFather() : ?self {
  1073.          $arr = array_filter($this->getParents()->toArray(), function(PersonLink $personLink) {
  1074.              return ($personLink->getParent()->getGender() == 'm');
  1075.          });
  1077.          if(empty($arr)){
  1078.              return null;
  1079.          }
  1080.         return array_slice($arr, 0, 1)[0]->getParent();
  1081.     }
  1083.     public function setFatherParent(EntityManagerInterface $em, ?Person $person, User $user) : ?self {
  1085.         return $this->setParent($em,'m', $user, $person);
  1086.     }
  1088.     public function setMotherParent(EntityManagerInterface $em, ?Person $person, User $user) : ?self {
  1090.         return $this->setParent($em, 'w', $user, $person);
  1091.     }
  1093.     private function setParent(EntityManagerInterface $em, string $gender, User $user, ?Person $person) : ?self {
  1095.         foreach($this->getParents() as $parentLink) {
  1096.             if ($parentLink->getParent()->getGender() == $gender) {
  1098.                 $parentLink->setTaggedForDeleteBy(null);
  1099.                 $parentLink->setChild($this);
  1100.                 $parentLink->setParent($person);
  1102.                 if($user->acceptsChanges()) {
  1103.                     $parentLink->setApproved(1);
  1104.                 } else {
  1105.                     $parentLink->setApproved(0);
  1106.                 }
  1107.                 $this->addParent($parentLink);
  1108.                 return $this;
  1109.             }
  1110.         }
  1111.         if($person) {
  1112.             $link = new PersonLink();
  1113.             if($user->acceptsChanges()) {
  1114.                 $link->setApproved(1);
  1115.             } else {
  1116.                 $link->setApproved(0);
  1117.             }
  1118.             $link->setOwner($user);
  1119.             $link->setParent($person)->setChild($this);
  1120.             $this->addParent($link);
  1121.             $person->addChild($link);
  1122.         }
  1124.         return $this;
  1125.     }
  1126.     public function getMother() : ?self {
  1128.         $arr = array_filter($this->getParents()->toArray(), function(PersonLink $personLink) {
  1129.             return ($personLink->getParent()->getGender() == 'w');
  1130.         });
  1132.         if(empty($arr)){
  1133.             return null;
  1134.         }
  1135.         return array_slice($arr, 0, 1)[0]->getParent();
  1136.     }
  1137.     public function addParent(PersonLink $parent): self
  1138.     {
  1139.         if (!$this->parents->contains($parent)) {
  1140.             $this->parents[] = $parent;
  1141.             $parent->setChild($this);
  1142.         }
  1144.         return $this;
  1145.     }
  1147.     public function removeParent(PersonLink $parent): self
  1148.     {
  1149.         if ($this->parents->contains($parent)) {
  1150.             $this->parents->removeElement($parent);
  1151.             // set the owning side to null (unless already changed)
  1152.             if ($parent->getChild() === $this) {
  1153.                 $parent->setChild(null);
  1154.             }
  1155.         }
  1157.         return $this;
  1158.     }
  1160.     /**
  1161.      * @param User|null $user
  1162.      * @return Collection|PersonLinks[]
  1163.      */
  1164.     public function getChildLinks(?User $user = null): Collection
  1165.     {
  1166.         if($user && $this->updateOf)
  1167.         {
  1168.             return new ArrayCollection(array_merge(
  1169.                 $this->children->toArray(),
  1170.                 $this->updateOf->getChildLinks($user)->toArray()
  1171.             ));
  1172.         }
  1173.         return $this->children;
  1174.     }
  1176.     /**
  1177.      * @param User|null $user
  1178.      * @param bool $excludeTaggedForDelete
  1179.      * @return Collection|Person[]
  1180.      */
  1181.     public function getChildren(bool $asName = false/*?User $user = null, bool $excludeTaggedForDelete = true*/): Collection
  1182.     {
  1183.         /*if($user && $this->updateOf)
  1184.         {
  1185.             return new ArrayCollection(array_merge(
  1186.                 $this->children->toArray(),
  1187.                 $this->updateOf->getChildren($user)->toArray()
  1188.             ));
  1189.         }*/
  1190.         $arr = [];
  1192.         /** @var PersonLink $childLink */
  1193.         foreach($this->children as $childLink){
  1195.             if($asName)
  1196.             {
  1197.                 $arr[] = $childLink->getChild()->getName();
  1198.             } else
  1199.             //if(!$excludeTaggedForDelete || !$childLink->getTaggedForDeleteBy())
  1200.             {
  1201.                 $arr[] = $childLink->getChild();
  1202.             }
  1203.         }
  1204.         return new ArrayCollection ($arr);
  1205.     }
  1207.     public function getChildrenAsName(): Collection{
  1208.         return $this->getChildren(true);
  1209.     }
  1211.     public function addChild(PersonLink $child): self
  1212.     {
  1213.         if (!$this->children->contains($child)) {
  1214.             $this->children[] = $child;
  1215.             $child->setParent($this);
  1216.         }
  1217.         return $this;
  1218.     }
  1220.     public function removeChild(PersonLink $child): self
  1221.     {
  1222.         if ($this->children->contains($child)) {
  1223.             $this->children->removeElement($child);
  1224.             // set the owning side to null (unless already changed)
  1225.             if ($child->getParent() === $this) {
  1226.                 $child->setParent(null);
  1227.             }
  1228.         }
  1229.         return $this;
  1230.     }
  1232.     public function hasChild(?User $user, Person $person) : bool {
  1234.         $filtered = array_filter(
  1235.             $this->getChildren()->toArray(),
  1236.             function ($key) use ($person, $user) {
  1237.                 return in_array($key, [$person]);
  1238.             }
  1239.         );
  1240.         return sizeof($filtered) > 0;
  1241.     }
  1243.     /**
  1244.      * @return Collection|PersonVersion[]
  1245.      */
  1246.     public function getPersonVersions(): Collection
  1247.     {
  1248.         return $this->personVersions;
  1249.     }
  1251.     public function addPersonVersion(PersonVersion $personVersion): self
  1252.     {
  1253.         if (!$this->personVersions->contains($personVersion)) {
  1254.             $this->personVersions[] = $personVersion;
  1255.             $personVersion->setPerson($this);
  1256.         }
  1258.         return $this;
  1259.     }
  1261.     public function removePersonVersion(PersonVersion $personVersion): self
  1262.     {
  1263.         if ($this->personVersions->contains($personVersion)) {
  1264.             $this->personVersions->removeElement($personVersion);
  1265.             // set the owning side to null (unless already changed)
  1266.             if ($personVersion->getPerson() === $this) {
  1267.                 $personVersion->setPerson(null);
  1268.             }
  1269.         }
  1271.         return $this;
  1272.     }
  1274.     public function hasVersions() : bool {
  1276.         $v = [];
  1277.         foreach($this->getPersonVersions() as $version){
  1279.             $v[$version->getPerson()->getName()] = 1;
  1280.         }
  1281.         return (sizeof($v) > 1);
  1282.     }
  1284.     public function getOtherVersionNames() : array {
  1286.         $result = [];
  1287.         foreach($this->getPersonVersions() as $version){
  1288.             $result[$version->getPerson()->getName()][] = $version->getVersion()->getName();
  1289.         }
  1290.         return $result;
  1291.     }
  1293.     /*public function getChanges() : array
  1294.     {
  1295.         $compareHelper = new CompareHelper();
  1296.         $changes = [];
  1297.         foreach($this->getUpdates() as $update) {
  1298.             $compareHelper->cmp($this, $update, $changes);
  1299.         }
  1300.         //dd($changes);
  1301.         return $changes;
  1302.     }*/
  1304.     public function getChangesAsString(?self $otherPerson) : string {
  1305.         $s = "";
  1306.         $compareHelper = new CompareHelper();
  1307.         if($otherPerson)
  1308.         {
  1309.             if($this->getName() == $otherPerson->getName()) {
  1310.                 $s = $this->getName();
  1311.             } else {
  1312.                 $s = '<br>Name: <s>'. $this->getName() .'</s><i class="fa fa-arrow-circle-right"></i>'. $otherPerson->getName();
  1313.             }
  1314.             if($this->getAlternateNames() != $otherPerson->getAlternateNames()) {
  1315.                 $s.='<br>Alternate Name: <s>'. $this->getAlternateNames() .'</s><i class="fa fa-arrow-circle-right"></i>'. $otherPerson->getAlternateNames();
  1316.             }
  1317.             if($this->getBorn() != $otherPerson->getBorn()) {
  1318.                 $s.='<br>Born: <s>'. $this->getBorn() .'</s><i class="fa fa-arrow-circle-right"></i>'. $otherPerson->getBorn();
  1319.             }
  1320.             if($this->getDied() != $otherPerson->getDied()) {
  1321.                 $s.='<br>Died: <s>'. $this->getDied() .'</s><i class="fa fa-arrow-circle-right"></i>'. $otherPerson->getDied();
  1322.             } if($this->getAge() != $otherPerson->getAge()) {
  1323.                 $s.='<br>Age: <s>'. $this->getAge() .'</s><i class="fa fa-arrow-circle-right"></i>'. $otherPerson->getAge();
  1324.             }
  1325.             if($this->getLivedAtTimeOfPerson() != $otherPerson->getLivedAtTimeOfPerson()) {
  1326.                 $s.='<br>lived at times: <s>'. ($this->getLivedAtTimeOfPerson() ? $this->getLivedAtTimeOfPerson()->getName() :'')
  1327.                     .'</s><i class="fa fa-arrow-circle-right"></i>'. ($otherPerson->getLivedAtTimeOfPerson() ? $otherPerson->getLivedAtTimeOfPerson()->getName():'');
  1328.             }
  1329.             $referenceChanges = $compareHelper->cmpStringArray($this->getPersonReferencesAsName(), $otherPerson->getPersonReferencesAsName());
  1331.         } else {
  1333.             $s.= '<br>Name: '. $this->getName() . ' ' .  $this->getAlternateNames();
  1334.             $s.= '<br>Birth/Death: '. $this->getBorn() . ' - ' .  $this->getDied() . ' (' . $this->getAge() . ')';
  1335.             $s.='<br>Lived at times:  '. $this->getLivedAtTimeOfPerson();
  1338.             $referenceChanges = $compareHelper->cmpStringArray([], $this->getPersonReferencesAsName());
  1339.         }
  1342.         $s.= $compareHelper->generateDiffHtml("References", $referenceChanges);
  1344.         return $s;
  1345.     }
  1346. }