src/Entity/User.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  6. use App\Config\RightConfig;
  7. use App\Repository\UserRepository;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use JsonSerializable;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  15. /**
  16.  * @ORM\Entity(repositoryClass=UserRepository::class)
  17.  * @ORM\Table(name="`users`")
  18.  * @UniqueEntity(fields={"username"}, message="There is already an account with this username")
  19.  * @UniqueEntity(fields={"messengerCode"}, message="This Messenger code is already used")
  20.  * @method string getUserIdentifier()
  21.  */
  22. class User implements UserInterface, JsonSerializable
  23. {
  24.     /**
  25.      * @ORM\Id
  26.      * @ORM\GeneratedValue
  27.      * @ORM\Column(type="integer")
  28.      */
  29.     private $id;
  31.     /**
  32.      * @ORM\Column(type="string", length=180)
  33.      */
  34.     private $username;
  36.     /**
  37.      * @ORM\Column(type="json")
  38.      */
  39.     private $roles = [];
  41.     /**
  42.      * @var string The hashed password
  43.      * @ORM\Column(type="string", nullable=true)
  44.      */
  45.     private $password;
  47.     /**
  48.      * @ORM\Column(type="string", length=255, nullable=true)
  49.      */
  50.     private $civility;
  52.     /**
  53.      * @ORM\Column(type="string", length=255, nullable=true)
  54.      */
  55.     private $firstName;
  58.     /**
  59.      * @ORM\Column(type="string", length=255, nullable=true)
  60.      */
  61.     private $email;
  63.     /**
  64.      * @ORM\Column(type="date", nullable=true)
  65.      */
  66.     private ?\DateTimeInterface $birthDate = null;
  68.     /**
  69.      * @ORM\Column(type="text", nullable=true)
  70.      */
  71.     private $description;
  73.     /**
  74.      * @ORM\Column(type="text", nullable=true)
  75.      */
  76.     private ?string $clientSearchNote = null;
  78.     /**
  79.      * @ORM\Column(type="string", length=20, nullable=true)
  80.      */
  81.     private $phone;
  83.     /**
  84.      * @ORM\Column(type="string", length=30, nullable=true)
  85.      */
  86.     private $second_phone;
  88.     /**
  89.      * @ORM\Column(type="text", nullable=true)
  90.      */
  91.     private $adress;
  93.     /**
  94.      * @ORM\Column(type="string", length=100, nullable=true)
  95.      */
  96.     private $country;
  98.     /**
  99.      * @ORM\Column(type="string", length=100, nullable=true)
  100.      */
  101.     private $region;
  103.     /**
  104.      * @ORM\Column(type="string", length=255, nullable=true)
  105.      */
  106.     private $city;
  108.     /**
  109.      * @ORM\Column(type="string", length=255, nullable=true)
  110.      */
  111.     private $zip;
  113.     /**
  114.      * @ORM\Column(type="string", length=255, nullable=true)
  115.      */
  116.     private $type;
  118.     /**
  119.      * @ORM\Column(type="boolean")
  120.      */
  121.     private $isVerified = false;
  123.     /**
  124.     * @ORM\OneToMany(targetEntity=Link::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
  125.      */
  126.     private $links;
  128.     /**
  129.      * @ORM\Column(type="datetime")
  130.      */
  131.     private $createdAt;
  133.     /**
  134.      * @ORM\Column(type="boolean", options={"default": false})
  135.      */
  136.     private $isBlocked = false;
  138.     /**
  139.      * @ORM\Column(type="datetime", nullable=true)
  140.      */
  141.     private $blockedAt;
  143.     /**
  144.      * @ORM\Column(type="datetime", nullable=true)
  145.      */
  146.     private $unblockedAt;
  148.     /**
  149.      * @ORM\Column(type="string", length=255, nullable=true)
  150.      */
  151.     private $blockReason;
  153.     /**
  154.      * @ORM\Column(type="json", nullable=true)
  155.      *
  156.      * Exemple de structure :
  157.      * {
  158.      *   "monday": [{"start": "09:00", "end": "12:00"}, {"start": "14:00", "end": "16:00"}],
  159.      *   "tuesday": [],
  160.      *   "wednesday": [{"start": "10:00", "end": "15:00"}],
  161.      *   ...
  162.      * }
  163.      */
  164.     private $blockedHours = [];
  166.     /**
  167.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="client")
  168.      */
  169.     private $documents;
  171.     /**
  172.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="user")
  173.      */
  174.     private $userDocuments;
  176.     /**
  177.      * @ORM\OneToMany(targetEntity=Address::class, mappedBy="user")
  178.      */
  179.     private $multiAddress;
  181.     /**
  182.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="user")
  183.      */
  184.     private $comments;
  185.     /**
  186.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="client")
  187.      */
  188.     private $notes;
  190.     /**
  191.      * @ORM\ManyToOne(targetEntity=Supplier::class, inversedBy="contacts")
  192.      */
  193.     private $supplier;
  195.     /**
  196.      * @ORM\OneToMany(targetEntity=Contact::class, mappedBy="linkedClient")
  197.      */
  198.     private $contacts;
  200.     /**
  201.      * @ORM\ManyToOne(targetEntity=Promotion::class, inversedBy="clients")
  202.      */
  203.     private $promotion;
  205.     /**
  206.      * @ORM\OneToMany(targetEntity=Activity::class, mappedBy="currentUser")
  207.      * @ORM\OrderBy({"createdAt" = "DESC"})
  208.      */
  209.     private $activities;
  211.     /**
  212.      * @ORM\ManyToMany(targetEntity=Produit::class, mappedBy="users")
  213.      */
  214.     private $produits;
  215.     /**
  216.      * @ORM\ManyToOne(targetEntity=GroupUser::class, inversedBy="users")
  217.      * @ORM\JoinColumn(nullable=true)
  218.      */
  219.     private $groupUser;
  221.     /**
  222.      * @ORM\ManyToMany(targetEntity=GroupUser::class, inversedBy="usersMultiGroups")
  223.      * @ORM\JoinTable(name="user_user_group",
  224.      *      joinColumns={@ORM\JoinColumn(name="user_id", referencedColumnName="id", onDelete="CASCADE")},
  225.      *      inverseJoinColumns={@ORM\JoinColumn(name="group_user_id", referencedColumnName="id", onDelete="CASCADE")}
  226.      * )
  227.      */
  228.     private $groupUsers;
  230.     /**
  231.      * @ORM\ManyToOne(targetEntity=UserPost::class)
  232.      * @ORM\JoinColumn(name="user_post_id", referencedColumnName="id", nullable=true, onDelete="SET NULL")
  233.      */
  234.     private $userPost;
  236.    /**
  237.      * @ORM\ManyToOne(targetEntity=ClientType::class)
  238.      * @ORM\JoinColumn(name="client_type_id", referencedColumnName="id", nullable=true, onDelete="SET NULL")
  239.      */
  240.     private $clientType;
  242.     /**
  243.      * @ORM\Column(type="boolean")
  244.      */
  245.     private $clientTypeLocked = false;
  247.     /**
  248.      * @ORM\Column(type="boolean", options={"default": true})
  249.      */
  250.     private $internalMessengerSoundEnabled = true;
  252.     /**
  253.      * @ORM\Column(type="boolean", options={"default": false})
  254.      */
  255.     private $internalMessengerBrowserNotificationsEnabled = false;
  257.     /**
  258.      * @ORM\Column(type="string", length=10, nullable=true, unique=true)
  259.      */
  260.     private ?string $messengerCode = null;
  262.     /**
  263.      * @ORM\ManyToMany(targetEntity=Warehouse::class, inversedBy="users")
  264.      * @ORM\JoinTable(name="user_warehouse")
  265.      */
  266.     private Collection $warehouses;
  269.     public function __construct()
  270.     {
  271.         $this->links = new ArrayCollection();
  272.         $this->documents = new ArrayCollection();
  273.         $this->userDocuments = new ArrayCollection();
  274.         $this->contacts = new ArrayCollection();
  275.         $this->multiAddress = new ArrayCollection();
  276.         $this->comments = new ArrayCollection();
  277.         $this->notes = new ArrayCollection();
  278.         $this->activities = new ArrayCollection();
  279.         $this->produits = new ArrayCollection();
  280.         $this->groupUsers = new ArrayCollection();
  281.         $this->warehouses = new ArrayCollection();
  282.         $this->zip="";
  283.     }
  285.     public function getId(): ?int
  286.     {
  287.         return $this->id;
  288.     }
  290.     public function getUsername(): ?string
  291.     {
  292.         return $this->username;
  293.     }
  295.     public function setUsername(string $username): self
  296.     {
  297.         $this->username = $username;
  299.         return $this;
  300.     }
  303.     /**
  304.      * @see UserInterface
  305.      */
  306.     public function getRoles(): array
  307.     {
  308.         $roles = $this->roles;
  309.         // guarantee every user at least has ROLE_USER
  310.         $roles[] = 'ROLE_USER';
  312.         return array_unique($roles);
  313.     }
  315.     public function setRoles(array $roles): self
  316.     {
  317.         $this->roles = $roles;
  319.         return $this;
  320.     }
  322.     /**
  323.      * @see UserInterface
  324.      */
  325.     public function getPassword(): string
  326.     {
  327.         return (string) $this->password;
  328.     }
  330.     public function setPassword(string $password): self
  331.     {
  332.         $this->password = $password;
  334.         return $this;
  335.     }
  337.     /**
  338.      * Returning a salt is only needed, if you are not using a modern
  339.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  340.      *
  341.      * @see UserInterface
  342.      */
  343.     public function getSalt(): ?string
  344.     {
  345.         return null;
  346.     }
  348.     /**
  349.      * @see UserInterface
  350.      */
  351.     public function eraseCredentials()
  352.     {
  353.         // If you store any temporary, sensitive data on the user, clear it here
  354.         // $this->plainPassword = null;
  355.     }
  357.     public function getCivility(): ?string
  358.     {
  359.         return $this->civility;
  360.     }
  362.     public function setCivility(string $civility): self
  363.     {
  364.         $this->civility = $civility;
  366.         return $this;
  367.     }
  369.     public function getFirstName(): ?string
  370.     {
  371.         return $this->firstName;
  372.     }
  374.    public function setFirstName(?string $firstName): self
  375.     {
  376.         $this->firstName = $firstName;
  378.         return $this;
  379.     }
  380.     public function getFullName(): ?string
  381.     {
  382.         return $this->firstName;
  383.     }
  384.     public function getEmail(): ?string
  385.     {
  386.         return $this->email;
  387.     }
  389.     public function setEmail(?string $email): self
  390.     {
  391.         $this->email = $email;
  392.         return $this;
  393.     }
  395.     public function getBirthDate(): ?\DateTimeInterface
  396.     {
  397.         return $this->birthDate;
  398.     }
  400.     public function setBirthDate(?\DateTimeInterface $birthDate): self
  401.     {
  402.         $this->birthDate = $birthDate;
  404.         return $this;
  405.     }
  408.     public function getDescription(): ?string
  409.     {
  410.         return $this->description;
  411.     }
  413.     public function setDescription(string $description): self
  414.     {
  415.         $this->description = $description;
  417.         return $this;
  418.     }
  420.     public function getClientSearchNote(): ?string
  421.     {
  422.         return $this->clientSearchNote;
  423.     }
  425.     public function setClientSearchNote(?string $clientSearchNote): self
  426.     {
  427.         $clientSearchNote = trim((string) $clientSearchNote);
  428.         $this->clientSearchNote = $clientSearchNote !== '' ? $clientSearchNote : null;
  430.         return $this;
  431.     }
  433.     public function getPhone(): ?string
  434.     {
  435.         return $this->phone;
  436.     }
  438.     public function setPhone(string $phone): self
  439.     {
  440.         $this->phone = $phone;
  442.         return $this;
  443.     }
  445.     public function getSecondPhone(): ?string
  446.     {
  447.         return $this->second_phone;
  448.     }
  450.     public function setSecondPhone(?string $second_phone): self
  451.     {
  452.         $this->second_phone = $second_phone;
  454.         return $this;
  455.     }
  457.     public function getAdress(): ?string
  458.     {
  459.         return $this->adress;
  460.     }
  463.      public function setAdress(?string $adress): self
  464.     {
  465.         $this->adress = $adress ?? '';
  466.         return $this;
  467.     }
  470.     public function getCountry(): ?string
  471.     {
  472.         return $this->country;
  473.     }
  475.     public function setCountry(string $country): self
  476.     {
  477.         $this->country = $country;
  479.         return $this;
  480.     }
  482.     public function getRegion(): ?string
  483.     {
  484.         return $this->region;
  485.     }
  487.     public function setRegion(?string $region): self
  488.     {
  489.         $this->region = $region ?? '';
  490.         return $this;
  491.     }
  494.     public function getCity(): ?string
  495.     {
  496.         return $this->city;
  497.     }
  499.     public function setCity(?string $city): self
  500.     {
  501.         $this->city = $city ?? '';
  503.         return $this;
  504.     }
  508.     public function getZip(): ?string
  509.     {
  510.         return $this->zip;
  511.     }
  513.     public function setZip(?string $zip): self
  514.     {
  515.         $this->zip = $zip ?? '';
  517.         return $this;
  518.     }
  520.     public function getType(): ?string
  521.     {
  522.         return $this->type;
  523.     }
  525.     public function setType(string $type): self
  526.     {
  527.         $this->type = $type;
  529.         return $this;
  530.     }
  532.     public function isVerified(): bool
  533.     {
  534.         return $this->isVerified;
  535.     }
  537.     public function setIsVerified(bool $isVerified): self
  538.     {
  539.         $this->isVerified = $isVerified;
  541.         return $this;
  542.     }
  544.     /**
  545.      * @return Collection|Link[]
  546.      */
  547.     public function getLinks(): Collection
  548.     {
  549.         return $this->links;
  550.     }
  552.     public function addLink(Link $link): self
  553.     {
  554.         if( !$this->links->contains($link)) {
  555.             $this->links[] = $link;
  556.             $link->setUser($this);
  557.         }
  559.         return $this;
  560.     }
  562.     public function removeLink(Link $link): self
  563.     {
  564.         if( $this->links->removeElement($link)) {
  565.             // set the owning side to null (unless already changed)
  566.             if( $link->getUser() === $this) {
  567.                 $link->setUser(null);
  568.             }
  569.         }
  571.         return $this;
  572.     }
  574.     public function getCreatedAt(): ?\DateTimeInterface
  575.     {
  576.         return $this->createdAt;
  577.     }
  579.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  580.     {
  581.         $this->createdAt = $createdAt;
  583.         return $this;
  584.     }
  586.     public function getBlockedHours(): ?array
  587.     {
  588.         return $this->blockedHours;
  589.     }
  591.     public function setBlockedHours(?array $blockedHours): self
  592.     {
  593.         $this->blockedHours = $blockedHours;
  594.         return $this;
  595.     }
  597.     public function isBlocked(): bool
  598.     {
  600.         return (bool) $this->isBlocked || $this->isBlockedAt();
  601.     }
  602.     public function isAutoBlocked(): bool
  603.     {
  604.         return $this->isBlacklisted === true;
  605.     }
  607.     public function isManuallyBlocked(): bool
  608.     {
  609.         return $this->isBlocked === true;
  610.     }
  612.     public function canCreateCommande(): bool
  613.     {
  614.         return !$this->isManuallyBlocked();
  615.     }
  618.     // Nouvelle méthode avec tes paramètres (nom différent)
  619.     public function isBlockedAt( ?\DateTimeInterface $now = null,?\DateTimeZone $tz = null): bool {
  620.         $tz  = $tz ?: new \DateTimeZone('Africa/Tunis');
  621.         $now = $now ? (new \DateTimeImmutable($now->format('c')))->setTimezone($tz)
  622.                     : new \DateTimeImmutable('now', $tz);
  624.         // 1) Blocage permanent
  625.         if (!empty($this->isBlocked)) {
  626.             return true;
  627.         }
  629.         // 2) Blocage entre deux dates
  630.         $ba = $this->blockedAt  instanceof \DateTimeInterface ? (new \DateTimeImmutable($this->blockedAt->format('c')))->setTimezone($tz) : null;
  631.         $ua = $this->unblockedAt instanceof \DateTimeInterface ? (new \DateTimeImmutable($this->unblockedAt->format('c')))->setTimezone($tz) : null;
  633.         if ($ba) {
  634.             if ($ua) {
  635.                 if ($now >= $ba && $now < $ua) return true;
  636.             } else {
  637.                 if ($now >= $ba) return true;
  638.             }
  639.         }
  641.         // 3) Plages horaires quotidiennes
  642.         if (empty($this->blockedHours) || !is_array($this->blockedHours)) {
  643.             return false;
  644.         }
  646.         $map = [
  647.             'monday'=>'mon','mon'=>'mon',
  648.             'tuesday'=>'tue','tue'=>'tue',
  649.             'wednesday'=>'wed','wed'=>'wed',
  650.             'thursday'=>'thu','thu'=>'thu',
  651.             'friday'=>'fri','fri'=>'fri',
  652.             'saturday'=>'sat','sat'=>'sat',
  653.             'sunday'=>'sun','sun'=>'sun',
  654.             '1'=>'mon','2'=>'tue','3'=>'wed','4'=>'thu','5'=>'fri','6'=>'sat','7'=>'sun','0'=>'sun',
  655.         ];
  657.         $key = strtolower($now->format('D')); // mon..sun
  658.         $key = $map[$key] ?? $key;
  660.         $ranges = $this->blockedHours[$key] ?? [];
  662.         if (empty($ranges) || !is_array($ranges)) return false;
  664.         $toMin = static function (?string $hm): ?int {
  665.             if (!$hm || !preg_match('/^(\d{1,2}):(\d{2})$/', $hm, $m)) return null;
  666.             return ((int)$m[1]) * 60 + (int)$m[2];
  667.         };
  669.         $nowMin = (int)$now->format('H') * 60 + (int)$now->format('i');
  671.         foreach ($ranges as $r) {
  672.             $start = $toMin($r['start'] ?? null);
  673.             $end   = $toMin($r['end']   ?? null);
  674.             if ($start === null && $end === null) continue;
  676.             if ($start !== null && $end !== null) {
  677.                 if ($start < $end) {
  678.                     if ($nowMin >= $start && $nowMin < $end) return true;
  679.                 } elseif ($start > $end) {
  680.                     if ($nowMin >= $start || $nowMin < $end) return true;
  681.                 } else {
  682.                     continue;
  683.                 }
  684.             }
  685.         }
  686.         return false;
  687.     }
  691.     public function getIsBlocked(): bool
  692.     {
  693.         return $this->isBlocked;
  694.     }
  696.     public function setIsBlocked(bool $blocked): self
  697.     {
  698.         $this->isBlocked = $blocked;
  699.         return $this;
  700.     }
  702.     public function getBlockedAt(): ?\DateTimeInterface
  703.     {
  704.         return $this->blockedAt;
  705.     }
  707.     public function setBlockedAt(?\DateTimeInterface $date): self
  708.     {
  709.         $this->blockedAt = $date;
  710.         return $this;
  711.     }
  713.     public function getUnblockedAt(): ?\DateTimeInterface
  714.     {
  715.         return $this->unblockedAt;
  716.     }
  718.     public function setUnblockedAt(?\DateTimeInterface $date): self
  719.     {
  720.         $this->unblockedAt = $date;
  721.         return $this;
  722.     }
  724.     public function getBlockReason(): ?string
  725.     {
  726.         return $this->blockReason;
  727.     }
  729.     public function setBlockReason(?string $reason): self
  730.     {
  731.         $this->blockReason = $reason;
  732.         return $this;
  733.     }
  736.     /**
  737.      * @return Collection|Document[]
  738.      */
  739.     public function getDocuments(): Collection
  740.     {
  741.         return $this->documents;
  742.     }
  744.     public function addDocument(Document $document): self
  745.     {
  746.         if( !$this->documents->contains($document)) {
  747.             $this->documents[] = $document;
  748.             $document->setClient($this);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeDocument(Document $document): self
  755.     {
  756.         if( $this->documents->removeElement($document)) {
  757.             // set the owning side to null (unless already changed)
  758.             if( $document->getClient() === $this) {
  759.                 $document->setClient(null);
  760.             }
  761.         }
  763.         return $this;
  764.     }
  766.     /**
  767.      * @return Collection|Document[]
  768.      */
  769.     public function getUserDocuments(): Collection
  770.     {
  771.         return $this->userDocuments;
  772.     }
  774.     public function addUserDocument(Document $userDocument): self
  775.     {
  776.         if( !$this->userDocuments->contains($userDocument)) {
  777.             $this->userDocuments[] = $userDocument;
  778.             $userDocument->setUser($this);
  779.         }
  781.         return $this;
  782.     }
  784.     public function removeUserDocument(Document $userDocument): self
  785.     {
  786.         if( $this->userDocuments->removeElement($userDocument)) {
  787.             // set the owning side to null (unless already changed)
  788.             if( $userDocument->getUser() === $this) {
  789.                 $userDocument->setUser(null);
  790.             }
  791.         }
  793.         return $this;
  794.     }
  796.     /**
  797.      * @return Collection|Address[]
  798.      */
  799.     public function getMultiAddress(): Collection
  800.     {
  801.         return $this->multiAddress;
  802.     }
  804.     public function addMultiAddress(Address $multiAddress): self
  805.     {
  806.         if( !$this->multiAddress->contains($multiAddress)) {
  807.             $this->multiAddress[] = $multiAddress;
  808.             $multiAddress->setUser($this);
  809.         }
  811.         return $this;
  812.     }
  814.     public function removeMultiAddress(Address $multiAddress): self
  815.     {
  816.         if( $this->multiAddress->removeElement($multiAddress)) {
  817.             // set the owning side to null (unless already changed)
  818.             if( $multiAddress->getUser() === $this) {
  819.                 $multiAddress->setUser(null);
  820.             }
  821.         }
  823.         return $this;
  824.     }
  826.     /**
  827.      * @return Collection|Comment[]
  828.      */
  829.     public function getComments(): Collection
  830.     {
  831.         return $this->comments;
  832.     }
  834.     public function addComment(Comment $comment): self
  835.     {
  836.         if( !$this->comments->contains($comment)) {
  837.             $this->comments[] = $comment;
  838.             $comment->setUser($this);
  839.         }
  841.         return $this;
  842.     }
  844.     public function removeComment(Comment $comment): self
  845.     {
  846.         if( $this->comments->removeElement($comment)) {
  847.             // set the owning side to null (unless already changed)
  848.             if( $comment->getUser() === $this) {
  849.                 $comment->setUser(null);
  850.             }
  851.         }
  853.         return $this;
  854.     }
  855.     /**
  856.      * @return Collection|Comment[]
  857.      */
  858.     public function getNotes(): Collection
  859.     {
  860.         return $this->notes;
  861.     }
  863.     public function addNote(Comment $note): self
  864.     {
  865.         if( !$this->notes->contains($note)) {
  866.             $this->notes[] = $note;
  867.             $note->setClient($this);
  868.         }
  870.         return $this;
  871.     }
  873.     public function removeNote(Comment $note): self
  874.     {
  875.         if( $this->notes->removeElement($note)) {
  876.             // set the owning side to null (unless already changed)
  877.             if( $note->getUser() === $this) {
  878.                 $note->setUser(null);
  879.             }
  880.         }
  882.         return $this;
  883.     }
  884.     public function getSupplier(): ?Supplier
  885.     {
  886.         return $this->supplier;
  887.     }
  889.     public function setSupplier(?Supplier $supplier): self
  890.     {
  891.         $this->supplier = $supplier;
  893.         return $this;
  894.     }
  896.     /**
  897.      * @return Collection<int, Contact>
  898.      */
  899.     public function getContacts(): Collection
  900.     {
  901.         return $this->contacts;
  902.     }
  904.     public function addContact(Contact $contact): self
  905.     {
  906.         if (!$this->contacts->contains($contact)) {
  907.             $this->contacts[] = $contact;
  908.             $contact->setLinkedClient($this);
  909.         }
  911.         return $this;
  912.     }
  914.     public function removeContact(Contact $contact): self
  915.     {
  916.         if ($this->contacts->removeElement($contact)) {
  917.             if ($contact->getLinkedClient() === $this) {
  918.                 $contact->setLinkedClient(null);
  919.             }
  920.         }
  922.         return $this;
  923.     }
  925.     public function getPromotion(): ?Promotion
  926.     {
  927.         return $this->promotion;
  928.     }
  930.     public function setPromotion(?Promotion $promotion): self
  931.     {
  932.         $this->promotion = $promotion;
  934.         return $this;
  935.     }
  937.     /**
  938.      * @return Collection|Activity[]
  939.      */
  940.     public function getActivities(): Collection
  941.     {
  942.         return $this->activities;
  943.     }
  945.     public function addActivity(Activity $activity): self
  946.     {
  947.         if( !$this->activities->contains($activity)) {
  948.             $this->activities[] = $activity;
  949.             $activity->setCurrentUser($this);
  950.         }
  952.         return $this;
  953.     }
  955.     public function removeActivity(Activity $activity): self
  956.     {
  957.         if( $this->activities->removeElement($activity)) {
  958.             // set the owning side to null (unless already changed)
  959.             if( $activity->getCurrentUser() === $this) {
  960.                 $activity->setCurrentUser(null);
  961.             }
  962.         }
  964.         return $this;
  965.     }
  967.     public function getGroupUser(): ?GroupUser
  968.     {
  969.         return $this->groupUser;
  970.     }
  972.     /**
  973.      * @return Collection|GroupUser[]
  974.      */
  975.     public function getGroupUsers(): Collection
  976.     {
  977.         return $this->groupUsers;
  978.     }
  980.     public function addGroupUser(GroupUser $groupUser): self
  981.     {
  982.         if (!$this->groupUsers->contains($groupUser)) {
  983.             $this->groupUsers[] = $groupUser;
  984.             $groupUser->addUsersMultiGroup($this);
  985.         }
  987.         return $this;
  988.     }
  990.     public function removeGroupUser(GroupUser $groupUser): self
  991.     {
  992.         if ($this->groupUsers->removeElement($groupUser)) {
  993.             $groupUser->removeUsersMultiGroup($this);
  995.             if ($this->groupUser && $this->isSameGroupUser($this->groupUser, $groupUser)) {
  996.                 $this->groupUser = $this->getFirstAssignedGroupUser();
  997.             }
  998.         }
  1000.         return $this;
  1001.     }
  1003.     public function setGroupUsers(iterable $groupUsers): self
  1004.     {
  1005.         foreach ($this->groupUsers->toArray() as $existingGroupUser) {
  1006.             $this->removeGroupUser($existingGroupUser);
  1007.         }
  1009.         foreach ($groupUsers as $groupUser) {
  1010.             if ($groupUser instanceof GroupUser) {
  1011.                 $this->addGroupUser($groupUser);
  1012.             }
  1013.         }
  1015.         return $this;
  1016.     }
  1018.     /**
  1019.      * @return GroupUser[]
  1020.      */
  1021.     public function getEffectiveGroupUsers(): array
  1022.     {
  1023.         $groups = [];
  1024.         $seen = [];
  1026.         $append = static function (?GroupUser $groupUser) use (&$groups, &$seen): void {
  1027.             if (!$groupUser) {
  1028.                 return;
  1029.             }
  1031.             $key = $groupUser->getId() !== null
  1032.                 ? 'id:' . $groupUser->getId()
  1033.                 : 'obj:' . spl_object_hash($groupUser);
  1035.             if (isset($seen[$key])) {
  1036.                 return;
  1037.             }
  1039.             $seen[$key] = true;
  1040.             $groups[] = $groupUser;
  1041.         };
  1043.         $append($this->groupUser);
  1045.         foreach ($this->groupUsers as $groupUser) {
  1046.             $append($groupUser);
  1047.         }
  1049.         return $groups;
  1050.     }
  1052.     /**
  1053.      * @return string[]
  1054.      */
  1055.     public function getEffectiveGroupUserNames(): array
  1056.     {
  1057.         $names = [];
  1059.         foreach ($this->getEffectiveGroupUsers() as $groupUser) {
  1060.             $name = trim((string) $groupUser->getName());
  1061.             if ($name !== '') {
  1062.                 $names[] = $name;
  1063.             }
  1064.         }
  1066.         return array_values(array_unique($names));
  1067.     }
  1069.     public function getEffectiveGroupUserLabel(): string
  1070.     {
  1071.         $names = $this->getEffectiveGroupUserNames();
  1073.         return $names !== [] ? implode(', ', $names) : 'Sans groupe';
  1074.     }
  1076.     public function syncLegacyGroupUserIntoGroupUsers(): self
  1077.     {
  1078.         if ($this->groupUser instanceof GroupUser) {
  1079.             $this->addGroupUser($this->groupUser);
  1080.         }
  1082.         return $this;
  1083.     }
  1085.     public function syncPrimaryGroupUserFromGroupUsers(): self
  1086.     {
  1087.         if ($this->groupUser instanceof GroupUser && !$this->hasAssignedGroupUser($this->groupUser)) {
  1088.             $this->groupUser = null;
  1089.         }
  1091.         if ($this->groupUser === null) {
  1092.             $this->groupUser = $this->getFirstAssignedGroupUser();
  1093.         }
  1095.         return $this;
  1096.     }
  1098.     public function getArrayRight(): array
  1099.     {
  1100.         if (in_array('ROLE_SUPER_ADMIN', (array) $this->getRoles(), true)) {
  1101.             return RightConfig::allCodes();
  1102.         }
  1104.         $rights = [];
  1106.         foreach ($this->getEffectiveGroupUsers() as $groupUser) {
  1107.             foreach ($groupUser->getRights() as $right) {
  1108.                 if ($right && method_exists($right, 'getCode')) {
  1109.                     $rights[] = (string) $right->getCode();
  1110.                 }
  1111.             }
  1112.         }
  1114.         return array_values(array_unique(array_filter($rights)));
  1115.     }
  1117.     public function setGroupUser(?GroupUser $groupUser): self
  1118.     {
  1119.         $this->groupUser = $groupUser;
  1121.         if ($groupUser instanceof GroupUser) {
  1122.             $this->addGroupUser($groupUser);
  1123.         }
  1125.         return $this;
  1126.     }
  1128.     public function getUserPost(): ?UserPost
  1129.     {
  1130.         return $this->userPost;
  1131.     }
  1133.     public function setUserPost(?UserPost $post): self
  1134.     {
  1135.         $this->userPost = $post;
  1136.         return $this;
  1137.     }
  1139.     public function __call($name, $arguments)
  1140.     {
  1141.         // TODO: Implement @method string getUserIdentifier()
  1142.     }
  1144.     private function hasAssignedGroupUser(GroupUser $groupUser): bool
  1145.     {
  1146.         foreach ($this->groupUsers as $assignedGroupUser) {
  1147.             if ($this->isSameGroupUser($assignedGroupUser, $groupUser)) {
  1148.                 return true;
  1149.             }
  1150.         }
  1152.         return false;
  1153.     }
  1155.     private function getFirstAssignedGroupUser(): ?GroupUser
  1156.     {
  1157.         foreach ($this->groupUsers as $groupUser) {
  1158.             if ($groupUser instanceof GroupUser) {
  1159.                 return $groupUser;
  1160.             }
  1161.         }
  1163.         return null;
  1164.     }
  1166.     private function isSameGroupUser(?GroupUser $left, ?GroupUser $right): bool
  1167.     {
  1168.         if (!$left || !$right) {
  1169.             return false;
  1170.         }
  1172.         if ($left->getId() !== null && $right->getId() !== null) {
  1173.             return $left->getId() === $right->getId();
  1174.         }
  1176.         return $left === $right;
  1177.     }
  1179.     #[\ReturnTypeWillChange]
  1180.     public function jsonSerialize()
  1181.     {
  1182.         return array(
  1183.             'adress' => $this->getAdress(),
  1184.             'firstName' => $this->getFirstName(),
  1185.             'username' => $this->getUsername(),
  1186.             'email' => $this->getEmail(),
  1187.             'birthDate' => $this->getBirthDate() ? $this->getBirthDate()->format('Y-m-d') : null,
  1188.             'password' => '',
  1189.             'newPassword' => '',
  1190.             'confirmPassword' => ''
  1191.         );
  1192.     }
  1193.     /**
  1194.      * @return Collection|Produit[]
  1195.      */
  1196.     public function getProduits(): Collection
  1197.     {
  1198.         return $this->produits;
  1199.     }
  1201.     public function addProduit(Produit $produit): self
  1202.     {
  1203.         if( !$this->produits->contains($produit)) {
  1204.             $this->produits[] = $produit;
  1205.             $produit->addUser($this);
  1206.         }
  1207.         return $this;
  1208.     }
  1210.     public function removeProduit(Produit $produit): self
  1211.     {
  1212.         if( $this->produits->contains($produit)) {
  1213.             $this->produits->removeElement($produit);
  1214.             $produit->removeUser($this);
  1215.         }
  1216.         return $this;
  1217.     }
  1219.    public function getClientType(): ?ClientType
  1220.     {
  1221.         return $this->clientType;
  1222.     }
  1224.     public function setClientType(?ClientType $clientType): self
  1225.     {
  1226.         $this->clientType = $clientType;
  1227.         return $this;
  1228.     }
  1230.     public function isClientTypeLocked(): bool
  1231.     {
  1232.         return (bool) $this->clientTypeLocked;
  1233.     }
  1235.     public function setClientTypeLocked(bool $locked): self
  1236.     {
  1237.         $this->clientTypeLocked = $locked;
  1238.         return $this;
  1239.     }
  1241.     public function getClientTypeCode(): ?string
  1242.     {
  1243.         return $this->clientType ? $this->clientType->getCode() : null;
  1244.     }
  1246.     public function isBlacklisted(): bool
  1247.     {
  1248.         return $this->getClientTypeCode() === 'BLACKLIST';
  1249.     }
  1251.     public function getInternalMessengerSoundEnabled(): bool
  1252.     {
  1253.         return (bool) $this->internalMessengerSoundEnabled;
  1254.     }
  1256.     public function setInternalMessengerSoundEnabled(bool $internalMessengerSoundEnabled): self
  1257.     {
  1258.         $this->internalMessengerSoundEnabled = $internalMessengerSoundEnabled;
  1260.         return $this;
  1261.     }
  1263.     public function getInternalMessengerBrowserNotificationsEnabled(): bool
  1264.     {
  1265.         return (bool) $this->internalMessengerBrowserNotificationsEnabled;
  1266.     }
  1268.     public function setInternalMessengerBrowserNotificationsEnabled(bool $internalMessengerBrowserNotificationsEnabled): self
  1269.     {
  1270.         $this->internalMessengerBrowserNotificationsEnabled = $internalMessengerBrowserNotificationsEnabled;
  1272.         return $this;
  1273.     }
  1275.     public function getMessengerCode(): ?string
  1276.     {
  1277.         return $this->messengerCode;
  1278.     }
  1280.     public function setMessengerCode(?string $messengerCode): self
  1281.     {
  1282.         $messengerCode = trim((string) $messengerCode);
  1283.         $this->messengerCode = $messengerCode !== '' ? $messengerCode : null;
  1285.         return $this;
  1286.     }
  1288.     /**
  1289.      * @return Collection|Warehouse[]
  1290.      */
  1291.     public function getWarehouses(): Collection
  1292.     {
  1293.         return $this->warehouses;
  1294.     }
  1296.     public function addWarehouse(Warehouse $warehouse): self
  1297.     {
  1298.         if (!$this->warehouses->contains($warehouse)) {
  1299.             $this->warehouses->add($warehouse);
  1300.         }
  1302.         return $this;
  1303.     }
  1305.     public function removeWarehouse(Warehouse $warehouse): self
  1306.     {
  1307.         $this->warehouses->removeElement($warehouse);
  1309.         return $this;
  1310.     }
  1312. }