src/Entity/Security/User.php line 36

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Security;
  5. use App\Common\Entity\DefaultEntity;
  6. use App\Entity\JIT\Comment;
  7. use App\Entity\JIT\Feeling;
  8. use App\Entity\JIT\PContact;
  9. use App\Entity\JIT\Person;
  10. use App\Entity\JIT\Property;
  11. use App\Entity\JIT\Tenancy;
  12. use App\Repository\Security\UserRepository;
  13. use DateTime;
  14. use DateTimeInterface;
  15. use Doctrine\Common\Collections\ArrayCollection;
  16. use Doctrine\Common\Collections\Collection;
  17. use Doctrine\ORM\Mapping as ORM;
  18. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  19. use Symfony\Component\HttpFoundation\File\File;
  20. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  21. use Symfony\Component\Security\Core\User\UserInterface;
  22. use Symfony\Component\String\Slugger\AsciiSlugger;
  23. use Symfony\Component\Validator\Constraints as Assert;
  25. /**
  26.  * @ORM\Entity(repositoryClass=UserRepository::class)
  27.  * @ORM\Table(name="`pr_security_user`")
  28.  * @UniqueEntity(
  29.  *     fields={"username"},
  30.  *     message="_TT_ Ce nom d'utilisateur est déja pris"
  31.  * )
  32.  * @UniqueEntity("email")
  33.  * @UniqueEntity("phone")
  34.  * @ORM\HasLifecycleCallbacks
  35.  */
  36. class User extends DefaultEntity implements UserInterface, PasswordAuthenticatedUserInterface {
  38.     /**
  39.      * @ORM\Id
  40.      * @ORM\GeneratedValue
  41.      * @ORM\Column(type="integer")
  42.      */
  43.     private $id;
  45.     /**
  46.      * @ORM\Column(type="string", length=255)
  47.      */
  48.     private $username;
  50.     /**
  51.      * @ORM\Column(type="string", length=255)
  52.      */
  53.     private $slug;
  55.     /**
  56.      * @ORM\Column(type="string", length=255)
  57.      */
  58.     private $fullname;
  60.     /**
  61.      * @ORM\Column(type="string", length=255, nullable=true)
  62.      */
  63.     private $password;
  65.     /**
  66.      * @ORM\Column(type="string", length=255, nullable=true)
  67.      */
  68.     private $code;
  70.     /**
  71.      * @ORM\Column(type="datetime", nullable=true)
  72.      */
  73.     private $createAt;
  75.     /**
  76.      * @ORM\Column(type="datetime", nullable=true)
  77.      */
  78.     private $lmd;
  80.     /**
  81.      * @ORM\Column(type="datetime", nullable=true)
  82.      */
  83.     private $fad;
  85.     /**
  86.      * @ORM\Column(type="datetime", nullable=true)
  87.      */
  88.     private $lad;
  90.     /**
  91.      * @ORM\Column(type="datetime", nullable=true)
  92.      */
  93.     private $lmp;
  95.     /**
  96.      * @ORM\Column(type="datetime", nullable=true)
  97.      */
  98.     private $lrp;
  100.     /**
  101.      * @ORM\Column(type="text", nullable=true)
  102.      */
  103.     private $description;
  105.     /**
  106.      * @ORM\Column(type="string", length=10, nullable=true)
  107.      */
  108.     private $language;
  110.     /**
  111.      * @ORM\Column(type="string", length=255, nullable=true)
  112.      */
  113.     private $picture;
  115.     /**
  116.      * @ORM\Column(type="boolean", nullable=true)
  117.      */
  118.     private $enabled;
  120.     /**
  121.      * @ORM\Column(type="json", nullable=true)
  122.      */
  123.     private $userroles = [];
  125.     /**
  126.      * @ORM\ManyToOne(targetEntity=Profile::class, inversedBy="users")
  127.      */
  128.     private $profile;
  130.     /**
  131.      * @ORM\Column(type="string", length=255)
  132.      * @Assert\Email(
  133.      *     message = "The email '{{ value }}' is not a valid email."
  134.      * )
  135.      */
  136.     private $email;
  138.     /**
  139.      * @var File
  140.      */
  141.     private $image;
  143.     /**
  144.      * @var string
  145.      */
  146.     private $defaultPassword;
  148.     /**
  149.      * @ORM\Column(type="boolean", nullable=true)
  150.      */
  151.     private $privatePassword;
  153.     /**
  154.      * @ORM\Column(type="string", length=255, nullable=true)
  155.      */
  156.     private $phone;
  157.     private $updateLad;
  159.     /**
  160.      * @ORM\OneToMany(targetEntity=Person::class, mappedBy="account", cascade={"persist","remove"})
  161.      */
  162.     private $persons;
  164.     /**
  165.      * @ORM\OneToMany(targetEntity=PContact::class, mappedBy="account", cascade={"persist","remove"})
  166.      */
  167.     private $pContacts;
  169.     /**
  170.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="user")
  171.      */
  172.     private $comments;
  174.     /**
  175.      * @ORM\OneToMany(targetEntity=Feeling::class, mappedBy="user")
  176.      */
  177.     private $feelings;
  179.     public function __construct() {
  180.         $this->enabled = true;
  181.         $this->persons = new ArrayCollection();
  182.         $this->pContacts = new ArrayCollection();
  183.         $this->comments = new ArrayCollection();
  184.         $this->feelings = new ArrayCollection();
  185.     }
  187.     /**
  188.      * @ORM\PrePersist()
  189.      */
  190.     public function prePersist() {
  191.         parent::prePersist();
  192.         $this->createAt = new DateTime();
  194. //        $this->enabled = false;
  195. //        $this->setUsernameValue(); :: Not her because it is in controller to resolve the problem of unicity
  196.     }
  198.     /**
  199.      * @ORM\PreUpdate()
  200.      */
  201.     public function preUpdate() {
  202.         parent::preUpdate();
  203.         if (!$this->updateLad) {
  204.             $this->lmd = new DateTime();
  205.         }
  207.         $this->setUsernameValue();
  209.         if ($this->password === null) {
  210.             $this->setDefaultPassword();
  211.         }
  212.     }
  214.     public function getId(): ?int {
  215.         return $this->id;
  216.     }
  218.     public function getUsername(): ?string {
  219.         return $this->username;
  220.     }
  222.     public function setUsername(string $username): self {
  223.         $this->username = $username;
  225.         return $this;
  226.     }
  228.     private function setUsernameValue(): void {
  229.         if ($this->username === null) {
  230.             $this->username = $this->generateUsername();
  231.         }
  232.     }
  234.     public function generateUsername(): ?string {
  235.         if ($this->fullname !== null) {
  236.             $worrds = explode(' ', trim($this->fullname));
  238.             $username = "";
  240.             $nbw = count($worrds) - 1;
  241.             if ($nbw >= 1) {
  242.                 $username .= $worrds[$nbw];
  243.             }
  245.             $username .= '.' . $worrds[0];
  247.             return $this->sluggerUsername($username);
  248.         } else {
  249.             return null;
  250.         }
  251.     }
  253.     private function sluggerUsername($username): string {
  254.         $slugger = new AsciiSlugger();
  255.         $table = array(
  256.             'Š' => 'S', 'š' => 's', 'Đ' => 'Dj', 'đ' => 'dj', 'Ž' => 'Z', 'ž' => 'z', 'Č' => 'C', 'č' => 'c', 'Ć' => 'C', 'ć' => 'c',
  257.             'À' => 'A', 'Á' => 'A', 'Â' => 'A', 'Ã' => 'A', 'Ä' => 'A', 'Å' => 'A', 'Æ' => 'A', 'Ç' => 'C', 'È' => 'E', 'É' => 'E',
  258.             'Ê' => 'E', 'Ë' => 'E', 'Ì' => 'I', 'Í' => 'I', 'Î' => 'I', 'Ï' => 'I', 'Ñ' => 'N', 'Ò' => 'O', 'Ó' => 'O', 'Ô' => 'O',
  259.             'Õ' => 'O', 'Ö' => 'O', 'Ø' => 'O', 'Ù' => 'U', 'Ú' => 'U', 'Û' => 'U', 'Ü' => 'U', 'Ý' => 'Y', 'Þ' => 'B', 'ß' => 'Ss',
  260.             'à' => 'a', 'á' => 'a', 'â' => 'a', 'ã' => 'a', 'ä' => 'a', 'å' => 'a', 'æ' => 'a', 'ç' => 'c', 'è' => 'e', 'é' => 'e',
  261.             'ê' => 'e', 'ë' => 'e', 'ì' => 'i', 'í' => 'i', 'î' => 'i', 'ï' => 'i', 'ð' => 'o', 'ñ' => 'n', 'ò' => 'o', 'ó' => 'o',
  262.             'ô' => 'o', 'õ' => 'o', 'ö' => 'o', 'ø' => 'o', 'ù' => 'u', 'ú' => 'u', 'û' => 'u', 'ý' => 'y', 'ý' => 'y', 'þ' => 'b',
  263.             'ÿ' => 'y', 'Ŕ' => 'R', 'ŕ' => 'r',
  264.         );
  266.         $fusername = strtr($username, $table);
  267.         return $slugger->slug(strtolower($fusername), '.');
  268.     }
  270.     public function getSlug(): ?string {
  271.         return $this->slug;
  272.     }
  274.     protected function setSlug(string $slug): void {
  275.         $this->slug = $slug;
  276.     }
  278.     public function getPassword(): ?string {
  279.         return $this->password;
  280.     }
  282.     public function setPassword(?string $password): self {
  283.         $this->password = $password;
  285.         return $this;
  286.     }
  288.     public function setDefaultPassword(): void {
  289.         $this->defaultPassword = $this->password_generate();
  291. //        $passwordEncoder = new \Symfony\Component\Security\Core\Encoder\UserPasswordEncoder($encoderFactory);
  292. //        $this->password = $passwordEncoder->encodePassword($this, $this->defaultPassword);
  293.         $this->password = $this->defaultPassword;
  294.         $this->privatePassword = false;
  295.     }
  297.     public function getDefaultPassword(): ?string {
  298.         return $this->defaultPassword;
  299.     }
  301.     private function password_generate($length = 7): string {
  302.         $data = '1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnopqrstuvwxyz';
  303.         return substr(str_shuffle($data), 0, $length);
  304.     }
  306.     public function getCode(): ?string {
  307.         return $this->code;
  308.     }
  310.     public function setCode(?string $code): self {
  311.         $this->code = $code;
  313.         return $this;
  314.     }
  316.     public function getCreateAt(): ?DateTimeInterface {
  317.         return $this->createAt;
  318.     }
  320.     public function getLmd(): ?DateTimeInterface {
  321.         return $this->lmd;
  322.     }
  324.     protected function setLmd(?DateTimeInterface $lmd): self {
  325.         $this->lmd = $lmd;
  327.         return $this;
  328.     }
  330.     public function getFad(): ?DateTimeInterface {
  331.         return $this->fad;
  332.     }
  334.     public function setFad(?DateTimeInterface $fad): self {
  335.         $this->fad = $fad;
  337.         return $this;
  338.     }
  340.     public function getLad(): ?DateTimeInterface {
  341.         return $this->lad;
  342.     }
  344.     public function setLad(?DateTimeInterface $lad): self {
  345.         $this->lad = $lad;
  347.         return $this;
  348.     }
  350.     public function getUpdateLad() {
  351.         return $this->updateLad;
  352.     }
  354.     public function setUpdateLad($updateLad): void {
  355.         $this->updateLad = $updateLad;
  356.     }
  358.     public function getLmp(): ?DateTimeInterface {
  359.         return $this->lmp;
  360.     }
  362.     public function setLmp(?DateTimeInterface $lmp): self {
  363.         $this->lmp = $lmp;
  365.         return $this;
  366.     }
  368.     public function getLrp(): ?DateTimeInterface {
  369.         return $this->lrp;
  370.     }
  372.     public function setLrp(?DateTimeInterface $lrp): self {
  373.         $this->lrp = $lrp;
  375.         return $this;
  376.     }
  378.     public function getDescription(): ?string {
  379.         return $this->description;
  380.     }
  382.     public function setDescription(?string $description): self {
  383.         $this->description = $description;
  385.         return $this;
  386.     }
  388.     public function getLanguage(): ?string {
  389.         return $this->language;
  390.     }
  392.     public function setLanguage(?string $language): self {
  393.         $this->language = $language;
  395.         return $this;
  396.     }
  398.     public function getPicture(): ?string {
  399.         if ($this->picture !== null) {
  400.             return $this->picture;
  401. //        } else if ($this->gender == 'F') {
  402. //            return 'img_avatar_f.png';
  403.         } else {
  404.             return 'img_avatar_h.png';
  405.         }
  406.     }
  408.     public function getPicture2(): ?string {
  409.         if ($this->picture !== null && $this->picture !== 'img_avatar_h.png' && $this->picture !== 'img_avatar_f.png') {
  410.             return $this->picture;
  411. //        } else if ($this->gender == 'F') {
  412. ////            return 'img_avatar_f.png';
  413. //            $i = $this->id % 36 +1;
  414. //            return 'avatar/avatarf'.$i.'.png';
  415.         } else {
  416.             $i = $this->id % 36 + 1;
  417.             return 'avatar/avatarh' . $i . '.png';
  418.         }
  419.     }
  421.     public function getPicture3(): ?string {
  422.         if ($this->getPerson() !== null) {
  423.             return $this->getPerson()->getImage();
  424.         } else {
  425.             return 'img_avatar_h.png';
  426.         }
  427.     }
  429.     public function setPicture(?string $picture): self {
  430.         $this->picture = $picture;
  432.         return $this;
  433.     }
  435.     public function isEnabled(): ?bool {
  436.         return $this->enabled;
  437.     }
  439.     public function setEnabled(?bool $enabled): self {
  440.         $this->enabled = $enabled;
  442.         return $this;
  443.     }
  445.     public function getUserroles(): ?array {
  446.         return $this->userroles;
  447.     }
  449.     public function setUserroles(?array $userroles): self {
  450.         $this->userroles = $userroles;
  452.         return $this;
  453.     }
  455.     public function addUserrole(string $userrole): self {
  456.         if ($this->userroles === null) {
  457.             $this->userroles = [$userrole];
  458.         } else {
  459.             if (!in_array($userrole, $this->userroles)) {
  460.                 $this->userroles[] = $userrole;
  461.             }
  462.         }
  464.         return $this;
  465.     }
  467.     public function removeUserrole(string $userrole): self {
  468.         if ($this->userroles !== null && in_array($userrole, $this->userroles)) {
  469.             $this->userroles = array_diff($this->userroles, [$userrole]);
  470.         }
  472.         return $this;
  473.     }
  475.     public function getProfile(): ?Profile {
  476.         return $this->profile;
  477.     }
  479.     public function setProfile(?Profile $profile): self {
  480.         $this->profile = $profile;
  482.         return $this;
  483.     }
  485.     public function getFullname(): ?string {
  486.         return $this->fullname;
  487.     }
  489.     public function setFullname(string $fullname): self {
  490.         $this->fullname = $fullname;
  492.         return $this;
  493.     }
  495.     public function getName(): ?string {
  496.         return $this->getFullname();
  497.     }
  499.     public function getEmail(): ?string {
  500.         return $this->email;
  501.     }
  503.     public function setEmail(string $email): self {
  504.         $this->email = $email;
  506.         return $this;
  507.     }
  509.     public function getClass(): ?string {
  510.         return self::class;
  511.     }
  513.     /**
  514.      * @see UserInterface
  515.      */
  516.     public function getRoles(): array {
  517.         $roles = $this->userroles;
  518.         if ($this->profile !== null) {
  519.             $roles = array_merge($roles, $this->profile->getRoles());
  520.         }
  521.         // guarantee every user at least has ROLE_USER
  522.         $roles[] = 'ROLE_USER';
  524.         return array_unique($roles);
  525.     }
  527.     /**
  528.      * @see UserInterface
  529.      */
  530.     public function getSalt() {
  531.         // not needed when using the "bcrypt" algorithm in security.yaml
  532.     }
  534.     /**
  535.      * @see UserInterface
  536.      */
  537.     public function eraseCredentials() {
  538.         // If you store any temporary, sensitive data on the user, clear it here
  539.         // $this->plainPassword = null;
  540.     }
  542.     public function getImage(): ?File {
  543.         return $this->image;
  544.     }
  546.     public function setImage(File $image): self {
  547.         $this->image = $image;
  548.         return $this;
  549.     }
  551.     public function lock(): self {
  552.         $this->enabled = false;
  553.         return $this;
  554.     }
  556.     public function unlock(): self {
  557.         $this->enabled = true;
  558.         return $this;
  559.     }
  561.     public function getPhone(): ?string {
  562.         return $this->phone;
  563.     }
  565.     public function setPhone(?string $phone): self {
  566.         $this->phone = $phone;
  568.         return $this;
  569.     }
  571.     public function getProfileName(): ?string {
  572.         if ($this->profile !== null) {
  573.             return $this->profile->getName();
  574.         }
  576.         return "";
  577.     }
  579.     public function getPrivatePassword() {
  580.         return $this->privatePassword;
  581.     }
  583.     public function setPrivatePassword($privatePassword): void {
  584.         $this->privatePassword = $privatePassword;
  585.     }
  587.     public function getUserIdentifier(): ?string {
  588.         return $this->username;
  589.     }
  591.     /**
  592.      * @return Collection<int, Person>
  593.      */
  594.     public function getPersons(): Collection {
  595.         return $this->persons;
  596.     }
  598.     public function addPerson(Person $person): self {
  599.         if (!$this->persons->contains($person)) {
  600.             $this->persons[] = $person;
  601.             $person->setAccount($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removePerson(Person $person): self {
  608.         if ($this->persons->removeElement($person)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($person->getAccount() === $this) {
  611.                 $person->setAccount(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     public function getPerson(): ?Person {
  619.         if ($this->persons->isEmpty()) {
  620.             return null;
  621.         } else {
  622.             return $this->persons[0];
  623.         }
  624.     }
  626.     public function getPContact(): ?PContact {
  627.         if (!$this->pContacts->isEmpty()) {
  628.             return $this->pContacts[0];
  629.         } else {
  630.             return null;
  631.         }
  632.     }
  634.     /**
  635.      * @return Collection<int, PContact>
  636.      */
  637.     public function getPContacts(): Collection {
  638.         return $this->pContacts;
  639.     }
  641.     public function addPContact(PContact $pContact): self {
  642.         if (!$this->pContacts->contains($pContact)) {
  643.             $this->pContacts[] = $pContact;
  644.             $pContact->setAccount($this);
  645.         }
  647.         return $this;
  648.     }
  650.     public function removePContact(PContact $pContact): self {
  651.         if ($this->pContacts->removeElement($pContact)) {
  652.             // set the owning side to null (unless already changed)
  653.             if ($pContact->getAccount() === $this) {
  654.                 $pContact->setAccount(null);
  655.             }
  656.         }
  658.         return $this;
  659.     }
  661.     /**
  662.      * @return Collection<int, Comment>
  663.      */
  664.     public function getComments(): Collection {
  665.         return $this->comments;
  666.     }
  668.     public function addComment(Comment $comment): self {
  669.         if (!$this->comments->contains($comment)) {
  670.             $this->comments[] = $comment;
  671.             $comment->setUser($this);
  672.         }
  674.         return $this;
  675.     }
  677.     public function removeComment(Comment $comment): self {
  678.         if ($this->comments->removeElement($comment)) {
  679.             // set the owning side to null (unless already changed)
  680.             if ($comment->getUser() === $this) {
  681.                 $comment->setUser(null);
  682.             }
  683.         }
  685.         return $this;
  686.     }
  688.     /**
  689.      * @return Collection<int, Feeling>
  690.      */
  691.     public function getFeelings(): Collection {
  692.         return $this->feelings;
  693.     }
  695.     public function addFeeling(Feeling $feeling): self {
  696.         if (!$this->feelings->contains($feeling)) {
  697.             $this->feelings[] = $feeling;
  698.             $feeling->setUser($this);
  699.         }
  701.         return $this;
  702.     }
  704.     public function removeFeeling(Feeling $feeling): self {
  705.         if ($this->feelings->removeElement($feeling)) {
  706.             // set the owning side to null (unless already changed)
  707.             if ($feeling->getUser() === $this) {
  708.                 $feeling->setUser(null);
  709.             }
  710.         }
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection<int, Person>
  717.      */
  718.     public function getMyEmployees(): Collection {
  719.         $myEmployees = new ArrayCollection();
  721.         foreach ($this->persons as $person) {
  722.             if ($person->isEmployee()) {
  723.                 if (!$myEmployees->contains($person)) {
  724.                     $myEmployees[] = $person;
  725.                 }
  726.             }
  728.             foreach ($person->getMyAgencies() as $agency) {
  729.                 foreach ($agency->getPersons() as $oPerson) {
  730.                     if ($oPerson->isEmployee()) {
  731.                         if (!$myEmployees->contains($oPerson)) {
  732.                             $myEmployees[] = $oPerson;
  733.                         }
  734.                     }
  735.                 }
  736.             }
  737.         }
  739.         return $myEmployees;
  740.     }
  742.     /**
  743.      * @return Collection<int, Person>
  744.      */
  745.     public function getMyOwners(): Collection {
  746.         $myOwners = new ArrayCollection();
  748.         foreach ($this->persons as $person) {
  749.             if ($person->isOwner()) {
  750.                 if (!$myOwners->contains($person)) {
  751.                     $myOwners[] = $person;
  752.                 }
  753.             } else if ($person->isEmployee()) {
  754.                 foreach ($person->getMyOwners() as $oPerson) {
  755.                     if ($oPerson->isOwner()) {
  756.                         if (!$myOwners->contains($oPerson)) {
  757.                             $myOwners[] = $oPerson;
  758.                         }
  759.                     }
  760.                 }
  761.             }
  762.         }
  764.         return $myOwners;
  765.     }
  767.     /**
  768.      * @return Collection<int, Person>
  769.      */
  770.     public function getMyAOwners(): Collection {
  771.         $myOwners = new ArrayCollection();
  773. //        foreach ($this->getMyEmployees() as $person) {
  774. //            if ($person->isOwner()) {
  775. //                if (!$myOwners->contains($person)) {
  776. //                    $myOwners[] = $person;
  777. //                }
  778. //            }
  779. //
  780. //            if ($person->isEmployee()) {
  781. //                foreach ($person->getMyOwners() as $oPerson) {
  782. //                    if ($oPerson->isOwner()) {
  783. //                        if (!$myOwners->contains($oPerson)) {
  784. //                            $myOwners[] = $oPerson;
  785. //                        }
  786. //                    }
  787. //                }
  788. //            }
  789. //        }
  792.         foreach ($this->persons as $person) {
  793.             if ($person->isOwner()) {
  794.                 if (!$myOwners->contains($person)) {
  795.                     $myOwners[] = $person;
  796.                 }
  797.             } else if ($person->isEmployee()) {
  798.                 foreach ($person->getMyOwners() as $oPerson) {
  799.                     if ($oPerson->isOwner()) {
  800.                         if (!$myOwners->contains($oPerson)) {
  801.                             $myOwners[] = $oPerson;
  802.                         }
  803.                     }
  804.                 }
  805.             }
  806.         }
  808.         foreach ($this->getMyEmployees() as $person) {
  809.             foreach ($person->getMyOwners() as $oPerson) {
  810.                 if ($oPerson->isOwner()) {
  811.                     if (!$myOwners->contains($oPerson)) {
  812.                         $myOwners[] = $oPerson;
  813.                     }
  814.                 }
  815.             }
  816.         }
  818.         return $myOwners;
  819.     }
  821.     /**
  822.      * Mes locataires
  823.      * @return Collection<int, Person>
  824.      */
  825.     public function getMyTenants(): Collection {
  826.         $myTenants = new ArrayCollection();
  828.         foreach ($this->persons as $person) {
  829.             if ($person->isTenant()) {
  830.                 if (!$myTenants->contains($person)) {
  831.                     $myTenants[] = $person;
  832.                 }
  833.             } else if ($person->isEmployee() || $person->isOwner()) {
  834.                 foreach ($person->getMyTenants() as $oPerson) {
  835.                     if ($oPerson->isTenant()) {
  836.                         if (!$myTenants->contains($oPerson)) {
  837.                             $myTenants[] = $oPerson;
  838.                         }
  839.                     }
  840.                 }
  841.             }
  842.         }
  844.         return $myTenants;
  845.     }
  847.     /**
  848.      * Tous les locataires de mon agence
  849.      * @return Collection<int, Person>
  850.      */
  851.     public function getMyATenants(): Collection {
  852.         $myTenants = $this->getMyTenants();
  854.         foreach ($this->getMyEmployees() as $person) {
  855.             foreach ($person->getMyTenants() as $oPerson) {
  856.                 if (!$myTenants->contains($oPerson)) {
  857.                     $myTenants[] = $oPerson;
  858.                 }
  859.             }
  860.         }
  862.         return $myTenants;
  863.     }
  865.     /**
  866.      * Affiche toutes les personnes qu'on peut voir
  867.      * @return Collection<int, Person>
  868.      */
  869.     public function getAllPersons(): Collection {
  870.         $persons = $this->getMyEmployees();
  872.         foreach ($this->getMyAOwners() as $person) {
  873.             if (!$persons->contains($person)) {
  874.                 $persons->add($person);
  875.             }
  876.         }
  877.         foreach ($this->getMyATenants() as $person) {
  878.             if (!$persons->contains($person)) {
  879.                 $persons->add($person);
  880.             }
  881.         }
  883.         return $persons;
  884.     }
  886.     /**
  887.      * Affiche toutes les donneurs d'ordre (propriétaires et locataires) qu'on peut voir
  888.      * @return Collection<int, Person>
  889.      */
  890.     public function getAllDnd(): Collection {
  891.         $persons = $this->getMyAOwners();
  893.         foreach ($this->getMyATenants() as $person) {
  894.             if (!$persons->contains($person)) {
  895.                 $persons->add($person);
  896.             }
  897.         }
  899.         return $persons;
  900.     }
  902.     /**
  903.      * @return Collection<int, Agency>
  904.      */
  905.     public function getMyAgencies(): Collection {
  906.         $myAgencies = new ArrayCollection();
  908.         foreach ($this->getPersons() as $person) {
  909.             if ($person->isEmployee()) {
  910.                 foreach ($person->getMyAgencies() as $agency) {
  911.                     if (!$myAgencies->contains($agency)) {
  912.                         $myAgencies[] = $agency;
  913.                     }
  914.                 }
  915.             }
  916.         }
  918.         return $myAgencies;
  919.     }
  921.     /**
  922.      * Retourne toutes les agences auquelles appartient l'utilisateur connecté
  923.      * @return Collection<int, Agency>
  924.      */
  925.     public function getAAgencies(): Collection {
  926.         $AAgencies = new ArrayCollection();
  928.         foreach ($this->getPersons() as $person) {
  929.             $agency = $person->getAgency();
  931.             if ($agency != null && !$AAgencies->contains($agency)) {
  932.                 $AAgencies[] = $agency;
  933.             }
  935.             if ($person->isEmployee()) {
  936.                 foreach ($person->getMyAgencies() as $agency) {
  937.                     if (!$AAgencies->contains($agency)) {
  938.                         $AAgencies[] = $agency;
  939.                     }
  940.                 }
  941.             }
  942.         }
  944.         return $AAgencies;
  945.     }
  947.     public function hasAgency(): bool {
  949.         foreach ($this->persons as $person) {
  950.             if ($person->hasAgency()) {
  951.                 return true;
  952.             }
  953.         }
  955.         return false;
  956.     }
  958.     public function hasAffair(): bool {
  960.         foreach ($this->persons as $person) {
  961.             if ($person->hasAffair()) {
  962.                 return true;
  963.             }
  964.         }
  966.         return false;
  967.     }
  969.     public function isEmployee(): bool {
  971.         foreach ($this->persons as $person) {
  972.             if ($person->isEmployee()) {
  973.                 return true;
  974.             }
  975.         }
  977.         return false;
  978.     }
  980.     public function isOwner(): bool {
  982.         foreach ($this->persons as $person) {
  983.             if ($person->isOwner()) {
  984.                 return true;
  985.             }
  986.         }
  988.         return false;
  989.     }
  991.     public function isTenant(): bool {
  993.         foreach ($this->persons as $person) {
  994.             if ($person->isTenant()) {
  995.                 return true;
  996.             }
  997.         }
  999.         return false;
  1000.     }
  1002.     /**
  1003.      * @return Collection<int, Account>
  1004.      */
  1005.     public function getAccounts(): Collection {
  1006.         $accounts = new ArrayCollection();
  1008.         foreach ($this->getPersons() as $person) {
  1009.             foreach ($person->getAccounts() as $account) {
  1010.                 if (!$accounts->contains($account)) {
  1011.                     $accounts[] = $account;
  1012.                 }
  1013.             }
  1014.         }
  1016.         return $accounts;
  1017.     }
  1019.     /**
  1020.      * @return Collection<int, Tenancy>
  1021.      * Les locations (gérées par/appartenants aux) agences de l'utilisateur connnecté
  1022.      */
  1023.     public function getATenancies(): Collection {
  1024.         $tenancies = new ArrayCollection();
  1025.         if ($this->isEmployee()) {
  1026.             foreach ($this->getAMTenancies() as $person) {
  1027.                 foreach ($person->getATenancies() as $tenancy) {
  1028.                     if (!$tenancies->contains($tenancy)) {
  1029.                         $tenancies->add($tenancy);
  1030.                     }
  1031.                 }
  1032.             }
  1033.         } else if ($this->isOwner()) {
  1034.             foreach ($this->persons as $person) {
  1035.                 foreach ($person->getAOTenancies() as $tenancy) {
  1036.                     if (!$tenancies->contains($tenancy)) {
  1037.                         $tenancies->add($tenancy);
  1038.                     }
  1039.                 }
  1040.             }
  1041.         } else if ($this->isTenant()) {
  1042.             foreach ($this->persons as $person) {
  1043.                 foreach ($person->getATenancies() as $tenancy) {
  1044.                     if (!$tenancies->contains($tenancy)) {
  1045.                         $tenancies->add($tenancy);
  1046.                     }
  1047.                 }
  1048.             }
  1049.         }
  1051.         return $tenancies;
  1052.     }
  1054.     /**
  1055.      * @return Collection<int, Property>
  1056.      * Les proprités gérées/appartenant par les agences de l'utilisateur connnecté
  1057.      */
  1058.     public function getAProperties(): Collection {
  1059.         $properties = new ArrayCollection();
  1060.         if ($this->isProfileAgent()) {
  1061. //            foreach ($this->getMyEmployees() as $person) {
  1062. //                foreach ($person->getAProperties() as $property) {
  1063. //                    if (!$properties->contains($property)) {
  1064. //                        $properties->add($property);
  1065. //                    }
  1066. //                }
  1067. //            }
  1069.             foreach ($this->getAAgencies() as $agency) {
  1070.                 foreach ($agency->getPersons() as $person) {
  1071.                     foreach ($person->getARProperties2() as $property) {
  1072.                         if (!$properties->contains($property)) {
  1073.                             $properties->add($property);
  1074.                         }
  1075.                     }
  1076.                 }
  1077.             }
  1078.         } else if ($this->isProfileOwner()) {
  1079.             foreach ($this->persons as $person) {
  1080.                 foreach ($person->getARProperties2() as $property) {
  1081.                     if (!$properties->contains($property)) {
  1082.                         $properties->add($property);
  1083.                     }
  1084.                 }
  1085.             }
  1086.         }
  1088.         return $properties;
  1089.     }
  1091.     /**
  1092.      * @return Collection<int, Property>
  1093.      * Les proprités vacants gérées par les agences de l'utilisateur connnecté
  1094.      */
  1095.     public function getVProperties(): Collection {
  1096.         $properties = new ArrayCollection();
  1097.         if ($this->isProfileAgent()) {
  1098.             foreach ($this->getAAgencies() as $agency) {
  1099.                 foreach ($agency->getPersons() as $person) {
  1100.                     foreach ($person->getARVProperties2() as $property) {
  1101.                         if (!$properties->contains($property)) {
  1102.                             $properties->add($property);
  1103.                         }
  1104.                     }
  1105.                 }
  1106.             }
  1107.         } else if ($this->isOwner()) {
  1108.             foreach ($this->persons as $person) {
  1109.                 foreach ($person->getARVProperties2() as $property) {
  1110.                     if (!$properties->contains($property)) {
  1111.                         $properties->add($property);
  1112.                     }
  1113.                 }
  1114.             }
  1115.         }
  1117.         return $properties;
  1118.     }
  1120.     /**
  1121.      * @return Collection<int, Property>
  1122.      * Les proprités louables gérées/appartenant par les agences de l'utilisateur connnecté
  1123.      */
  1124.     public function getARProperties(): Collection {
  1125.         $properties = new ArrayCollection();
  1126.         if ($this->isEmployee()) {
  1127.             foreach ($this->getMyEmployees() as $person) {
  1128. //                foreach ($person->getAProperties() as $property) {
  1129. //                    if ($property->isRented() && !$properties->contains($property)) {
  1130. //                        $properties->add($property);
  1131. //                    }
  1132. //                }
  1133.                 foreach ($person->getARProperties() as $property) {
  1134.                     if (!$properties->contains($property)) {
  1135.                         $properties->add($property);
  1136.                     }
  1137.                 }
  1138.             }
  1139.         } else if ($this->isOwner()) {
  1140.             foreach ($this->persons as $person) {
  1141. //                foreach ($person->getProperties() as $property) {
  1142. //                    if ($property->isRented() && !$properties->contains($property)) {
  1143. //                        $properties->add($property);
  1144. //                    }
  1145. //                }
  1146.                 foreach ($person->getARProperties() as $property) {
  1147.                     if (!$properties->contains($property)) {
  1148.                         $properties->add($property);
  1149.                     }
  1150.                 }
  1151.             }
  1152.         }
  1154.         return $properties;
  1155.     }
  1157.     /**
  1158.      * @return Collection<int, Property>
  1159.      * Les proprités principales gérées/appartenant par les agences de l'utilisateur connnecté
  1160.      */
  1161.     public function getAMProperties(): Collection {
  1162.         $properties = new ArrayCollection();
  1163.         if ($this->isProfileAgent()) {
  1164.             foreach ($this->getMyEmployees() as $person) {
  1165.                 foreach ($person->getAProperties() as $property) {
  1166.                     if ($property->isMainProperty() && !$properties->contains($property)) {
  1167.                         $properties->add($property);
  1168.                     }
  1169.                 }
  1170.             }
  1171.         } else if ($this->isProfileOwner()) {
  1172.             foreach ($this->persons as $person) {
  1173.                 foreach ($person->getProperties() as $property) {
  1174.                     if ($property->isMainProperty() && !$properties->contains($property)) {
  1175.                         $properties->add($property);
  1176.                     }
  1177.                 }
  1178.             }
  1179.         }
  1181.         return $properties;
  1182.     }
  1184.     /**
  1185.      * @return Collection<int, Incident>
  1186.      * Les incidents des 3 derniers mois
  1187.      */
  1188.     public function getL3MIncidents(): Collection {
  1189.         $incidents = new ArrayCollection();
  1190.         if ($this->isProfileAgent()) {
  1191.             foreach ($this->getAAgencies() as $agency) {
  1192.                 foreach ($agency->getPersons() as $person) {
  1193.                     foreach ($person->getARProperties2() as $property) {
  1194.                         foreach ($property->getIncidents() as $incident) {
  1195.                             if ($incident->isL3M() && !$incidents->contains($incident)) {
  1196.                                 $incidents->add($incident);
  1197.                             }
  1198.                         }
  1199.                     }
  1201.                     foreach ($person->getIncidents() as $incident) {
  1202.                         if ($incident->isL3M() && !$incidents->contains($incident)) {
  1203.                             $incidents->add($incident);
  1204.                         }
  1205.                     }
  1206.                 }
  1207.             }
  1208.         } else if ($this->isOwner()) {
  1209.             foreach ($this->persons as $person) {
  1210.                 foreach ($person->getProperties() as $property) {
  1211.                     foreach ($property->getIncidents() as $incident) {
  1212.                         if ($incident->isL3M() && !$incidents->contains($incident)) {
  1213.                             $incidents->add($incident);
  1214.                         }
  1215.                     }
  1216.                 }
  1218.                 foreach ($person->getIncidents() as $incident) {
  1219.                     if ($incident->isL3M() && !$incidents->contains($incident)) {
  1220.                         $incidents->add($incident);
  1221.                     }
  1222.                 }
  1223.             }
  1224.         }
  1226.         return $incidents;
  1227.     }
  1229.     public function getYearlyAccounting(): int {
  1230.         $amount = 0;
  1231.         if ($this->isEmployee()) {
  1232.             //Toutes les prestations
  1233.             //Toutes les loyers
  1234.             foreach ($this->getMyEmployees() as $person) {
  1235.                 foreach ($person->getAMTenancies() as $tenancy) {
  1236.                     $amount += $tenancy->getYPrc();
  1237.                 }
  1238.             }
  1239.         } else if ($this->isOwner()) {
  1240.             foreach ($this->persons as $person) {
  1241.                 foreach ($person->getAOTenancies() as $tenancy) {
  1242.                     $amount += $tenancy->getYPrc();
  1243.                 }
  1244.             }
  1245.         } else if ($this->isTenant()) {
  1246.             foreach ($this->persons as $person) {
  1247.                 foreach ($person->getTenancies() as $tenancy) {
  1248.                     $amount += $tenancy->getYPrc();
  1249.                 }
  1250.             }
  1251.         }
  1253.         return $amount;
  1254.     }
  1256.     public function getYearlyCollect(): int {
  1257.         $amount = 0;
  1258.         if ($this->isEmployee()) {
  1259.             //Toutes les prestations
  1260.             //Toutes les loyers
  1261.             foreach ($this->getMyEmployees() as $person) {
  1262.                 foreach ($person->getAMTenancies() as $tenancy) {
  1263.                     $amount += $tenancy->getYPay();
  1264.                 }
  1265.             }
  1266.         } else if ($this->isOwner()) {
  1267.             foreach ($this->persons as $person) {
  1268.                 foreach ($person->getAOTenancies() as $tenancy) {
  1269.                     $amount += $tenancy->getYPay();
  1270.                 }
  1271.             }
  1272.         } else if ($this->isTenant()) {
  1273.             foreach ($this->persons as $person) {
  1274.                 foreach ($person->getTenancies() as $tenancy) {
  1275.                     $amount += $tenancy->getYPay();
  1276.                 }
  1277.             }
  1278.         }
  1280.         return $amount;
  1281.     }
  1283.     public function getUnpayAccounting(): int {
  1284.         $amount = 0;
  1285.         if ($this->isEmployee()) {
  1286.             //Toutes les prestations
  1287.             //Toutes les loyers
  1288.             foreach ($this->getMyEmployees() as $person) {
  1289.                 foreach ($person->getAMTenancies() as $tenancy) {
  1290.                     $amount += $tenancy->getYUPay();
  1291.                 }
  1292.             }
  1293.         } else if ($this->isOwner()) {
  1294.             foreach ($this->persons as $person) {
  1295.                 foreach ($person->getAOTenancies() as $tenancy) {
  1296.                     $amount += $tenancy->getYUPay();
  1297.                 }
  1298.             }
  1299.         } else if ($this->isTenant()) {
  1300.             foreach ($this->persons as $person) {
  1301.                 foreach ($person->getTenancies() as $tenancy) {
  1302.                     $amount += $tenancy->getYUPay();
  1303.                 }
  1304.             }
  1305.         }
  1307.         return $amount;
  1308.     }
  1310.     public function getYAccountingStatistics(): array {
  1311.         $stats = Tenancy::getStatisticsTemplate();
  1312.         if ($this->isEmployee()) {
  1313.             //Toutes les prestations
  1314.             //Toutes les loyers
  1315.             foreach ($this->getMyEmployees() as $person) {
  1316.                 foreach ($person->getAMTenancies() as $tenancy) {
  1317.                     $stats = Tenancy::addStatisticsTemplate($stats, $tenancy->getYStatistics());
  1318.                 }
  1319.             }
  1320.         } else if ($this->isOwner()) {
  1321.             foreach ($this->persons as $person) {
  1322.                 foreach ($person->getAOTenancies() as $tenancy) {
  1323.                     $stats = Tenancy::addStatisticsTemplate($stats, $tenancy->getYStatistics());
  1324.                 }
  1325.             }
  1326.         } else if ($this->isTenant()) {
  1327.             foreach ($this->persons as $person) {
  1328.                 foreach ($person->getTenancies() as $tenancy) {
  1329.                     $stats = Tenancy::addStatisticsTemplate($stats, $tenancy->getYStatistics());
  1330.                 }
  1331.             }
  1332.         }
  1334.         return $stats;
  1335.     }
  1337.     public function getMpropertyStatistics(): array {
  1338.         $stats = Property::getStatisticsTemplate();
  1339.         foreach ($this->getAMProperties() as $property) {
  1340.             $stats = Property::addStatistics($stats, $property->getMStatistics());
  1341.         }
  1343.         return $stats;
  1344.     }
  1346.     public function getCPayInvoice(): int {
  1347.         $amount = 0;
  1348.         if ($this->isEmployee()) {
  1349.             //Toutes les prestations
  1350.             //Toutes les loyers
  1351.             foreach ($this->getMyEmployees() as $person) {
  1352.                 foreach ($person->getAMTenancies() as $tenancy) {
  1353.                     $amount += $tenancy->getYPayInvoices()->count();
  1354.                 }
  1355.             }
  1356.         } else if ($this->isOwner()) {
  1357.             foreach ($this->persons as $person) {
  1358.                 foreach ($person->getAOTenancies() as $tenancy) {
  1359.                     $amount += $tenancy->getYPayInvoices()->count();
  1360.                 }
  1361.             }
  1362.         } else if ($this->isTenant()) {
  1363.             foreach ($this->persons as $person) {
  1364.                 foreach ($person->getTenancies() as $tenancy) {
  1365.                     $amount += $tenancy->getYPayInvoices()->count();
  1366.                 }
  1367.             }
  1368.         }
  1370.         return $amount;
  1371.     }
  1373.     public function getAllDocuments() {
  1374.         
  1375.     }
  1377.     public function getCUnpayInvoice(): int {
  1378.         $amount = 0;
  1379.         if ($this->isEmployee()) {
  1380.             //Toutes les prestations
  1381.             //Toutes les loyers
  1382.             foreach ($this->getMyEmployees() as $person) {
  1383.                 foreach ($person->getAMTenancies() as $tenancy) {
  1384.                     $amount += $tenancy->getYUPayInvoices()->count();
  1385.                 }
  1386.             }
  1387.         } else if ($this->isOwner()) {
  1388.             foreach ($this->persons as $person) {
  1389.                 foreach ($person->getAOTenancies() as $tenancy) {
  1390.                     $amount += $tenancy->getYUPayInvoices()->count();
  1391.                 }
  1392.             }
  1393.         } else if ($this->isTenant()) {
  1394.             foreach ($this->persons as $person) {
  1395.                 foreach ($person->getTenancies() as $tenancy) {
  1396.                     $amount += $tenancy->getYUPayInvoices()->count();
  1397.                 }
  1398.             }
  1399.         }
  1401.         return $amount;
  1402.     }
  1404.     public function isSelfOwner(): bool {
  1405.         return $this->profile !== null && $this->profile->getId() ==  Profile::PROFILE_OWNER;
  1406.     }
  1408.     public function isVisitor(): bool {
  1409.         return $this->profile == null || $this->profile->getId()  == Profile::PROFILE_VISITOR;
  1410.     }
  1412.     public function isProfileOwner(): bool {
  1413.         return $this->profile !== null && $this->profile->getId() == Profile::PROFILE_OWNER;
  1414.     }
  1416.     public function isProfileVisitor(): bool {
  1417.         return $this->profile == null || $this->profile->getId() == Profile::PROFILE_VISITOR;
  1418.     }
  1420.     public function isProfileTenant(): bool {
  1421.         return $this->profile !== null && $this->profile->getId() == Profile::PROFILE_TENANT;
  1422.     }
  1424.     public function isProfileAgent(): bool {
  1425.         return $this->profile !== null && ($this->profile->getId() == Profile::PROFILE_AGENT || $this->profile->getId() == 1 || $this->profile->getId() == 2);
  1426.     }
  1428.     public function isProfileDemarcheur(): bool {
  1429.         return $this->profile !== null && $this->profile->getId() == Profile::PROFILE_DEMARCHEUR;
  1430.     }
  1432. }