src/Entity/User.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Doctrine\Type\ClientType;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use JsonSerializable;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. /**
  15.  * @ORM\Entity(repositoryClass=UserRepository::class)
  16.  * @ORM\Table(name="`users`")
  17.  * @UniqueEntity(fields={"username"}, message="There is already an account with this username")
  18.  * @method string getUserIdentifier()
  19.  */
  20. class User implements UserInterface, JsonSerializable
  21. {
  22.     /**
  23.      * @ORM\Id
  24.      * @ORM\GeneratedValue
  25.      * @ORM\Column(type="integer")
  26.      */
  27.     private $id;
  29.     /**
  30.      * @ORM\Column(type="string", length=180)
  31.      */
  32.     private $username;
  34.     /**
  35.      * @ORM\Column(type="json")
  36.      */
  37.     private $roles = [];
  39.     /**
  40.      * @var string The hashed password
  41.      * @ORM\Column(type="string", nullable=true)
  42.      */
  43.     private $password;
  45.     /**
  46.      * @ORM\Column(type="string", length=255, nullable=true)
  47.      */
  48.     private $civility;
  50.     /**
  51.      * @ORM\Column(type="string", length=255, nullable=true)
  52.      */
  53.     private $firstName;
  56.     /**
  57.      * @ORM\Column(type="string", length=255, nullable=true)
  58.      */
  59.     private $email;
  61.     /**
  62.      * @ORM\Column(type="text", nullable=true)
  63.      */
  64.     private $description;
  66.     /**
  67.      * @ORM\Column(type="string", length=255, nullable=true)
  68.      */
  69.     private $phone;
  71.     /**
  72.      * @ORM\Column(type="string", length=255, nullable=true)
  73.      */
  74.     private $second_phone;
  76.     /**
  77.      * @ORM\Column(type="text", nullable=true)
  78.      */
  79.     private $adress;
  81.     /**
  82.      * @ORM\Column(type="string", length=255, nullable=true)
  83.      */
  84.     private $country;
  86.     /**
  87.      * @ORM\Column(type="string", length=100, nullable=true)
  88.      */
  89.     private $region;
  91.     /**
  92.      * @ORM\Column(type="string", length=255, nullable=true)
  93.      */
  94.     private $city;
  96.     /**
  97.      * @ORM\Column(type="string", length=255, nullable=true)
  98.      */
  99.     private $zip;
  101.     /**
  102.      * @ORM\Column(type="string", length=255, nullable=true)
  103.      */
  104.     private $type;
  106.     /**
  107.      * @ORM\Column(type="boolean")
  108.      */
  109.     private $isVerified = false;
  111.     /**
  112.      * @ORM\OneToMany(targetEntity=Link::class, mappedBy="user",cascade={"persist"})
  113.      */
  114.     private $links;
  116.     /**
  117.      * @ORM\Column(type="datetime")
  118.      */
  119.     private $createdAt;
  121.     /**
  122.      * @ORM\Column(type="boolean", options={"default": false})
  123.      */
  124.     private $isBlocked = false;
  125.     
  126.     /**
  127.      * @ORM\Column(type="datetime", nullable=true)
  128.      */
  129.     private $blockedAt;
  131.     /**
  132.      * @ORM\Column(type="datetime", nullable=true)
  133.      */
  134.     private $unblockedAt;
  136.     /**
  137.      * @ORM\Column(type="string", length=255, nullable=true)
  138.      */
  139.     private $blockReason;
  141.     /**
  142.      * @ORM\Column(type="json", nullable=true)
  143.      *
  144.      * Exemple de structure :
  145.      * {
  146.      *   "monday": [{"start": "09:00", "end": "12:00"}, {"start": "14:00", "end": "16:00"}],
  147.      *   "tuesday": [],
  148.      *   "wednesday": [{"start": "10:00", "end": "15:00"}],
  149.      *   ...
  150.      * }
  151.      */
  152.     private $blockedHours = [];
  153.    
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="client")
  156.      */
  157.     private $documents;
  159.     /**
  160.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="user")
  161.      */
  162.     private $userDocuments;
  164.     /**
  165.      * @ORM\OneToMany(targetEntity=Address::class, mappedBy="user")
  166.      */
  167.     private $multiAddress;
  169.     /**
  170.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="user")
  171.      */
  172.     private $comments;
  173.     /**
  174.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="client")
  175.      */
  176.     private $notes;
  178.     /**
  179.      * @ORM\ManyToOne(targetEntity=Supplier::class, inversedBy="contacts")
  180.      */
  181.     private $supplier;
  183.     /**
  184.      * @ORM\ManyToOne(targetEntity=Promotion::class, inversedBy="clients")
  185.      */
  186.     private $promotion;
  188.     /**
  189.      * @ORM\OneToMany(targetEntity=Activity::class, mappedBy="currentUser")
  190.      * @ORM\OrderBy({"createdAt" = "DESC"})
  191.      */
  192.     private $activities;
  194.     /**
  195.      * @ORM\ManyToMany(targetEntity=Produit::class, mappedBy="users")
  196.      */
  197.     private $produits;
  198.     /**
  199.      * @ORM\ManyToOne(targetEntity=GroupUser::class, inversedBy="users")
  200.      * @ORM\JoinColumn(nullable=true)
  201.      */
  202.     private $groupUser;
  204.     /**
  205.      * @ORM\ManyToOne(targetEntity=UserPost::class)
  206.      * @ORM\JoinColumn(name="user_post_id", referencedColumnName="id", nullable=true, onDelete="SET NULL")
  207.      */
  208.     private $userPost;
  210.     /**
  211.     * @ORM\Column(name="client_type", type="string", length=255, options={"default":"Nouveau client"})
  212.     */
  213.     private $clientType;
  215.     public function __construct()
  216.     {
  217.         $this->links = new ArrayCollection();
  218.         $this->documents = new ArrayCollection();
  219.         $this->userDocuments = new ArrayCollection();
  220.         $this->multiAddress = new ArrayCollection();
  221.         $this->comments = new ArrayCollection();
  222.         $this->notes = new ArrayCollection();
  223.         $this->activities = new ArrayCollection();
  224.         $this->produits = new ArrayCollection();
  225.         $this->zip="";
  226.     }
  228.     public function getId(): ?int
  229.     {
  230.         return $this->id;
  231.     }
  233.     public function getUsername(): ?string
  234.     {
  235.         return $this->username;
  236.     }
  238.     public function setUsername(string $username): self
  239.     {
  240.         $this->username = $username;
  242.         return $this;
  243.     }
  246.     /**
  247.      * @see UserInterface
  248.      */
  249.     public function getRoles(): array
  250.     {
  251.         $roles = $this->roles;
  252.         // guarantee every user at least has ROLE_USER
  253.         $roles[] = 'ROLE_USER';
  255.         return array_unique($roles);
  256.     }
  258.     public function setRoles(array $roles): self
  259.     {
  260.         $this->roles = $roles;
  262.         return $this;
  263.     }
  265.     /**
  266.      * @see UserInterface
  267.      */
  268.     public function getPassword(): string
  269.     {
  270.         return (string) $this->password;
  271.     }
  273.     public function setPassword(string $password): self
  274.     {
  275.         $this->password = $password;
  277.         return $this;
  278.     }
  280.     /**
  281.      * Returning a salt is only needed, if you are not using a modern
  282.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  283.      *
  284.      * @see UserInterface
  285.      */
  286.     public function getSalt(): ?string
  287.     {
  288.         return null;
  289.     }
  291.     /**
  292.      * @see UserInterface
  293.      */
  294.     public function eraseCredentials()
  295.     {
  296.         // If you store any temporary, sensitive data on the user, clear it here
  297.         // $this->plainPassword = null;
  298.     }
  300.     public function getCivility(): ?string
  301.     {
  302.         return $this->civility;
  303.     }
  305.     public function setCivility(string $civility): self
  306.     {
  307.         $this->civility = $civility;
  309.         return $this;
  310.     }
  312.     public function getFirstName(): ?string
  313.     {
  314.         return $this->firstName;
  315.     }
  317.    public function setFirstName(?string $firstName): self
  318.     {
  319.         $this->firstName = $firstName;
  321.         return $this;
  322.     }
  323.     public function getFullName(): ?string
  324.     {
  325.         return $this->firstName;
  326.     }
  327.     public function getEmail(): ?string
  328.     {
  329.         return $this->email;
  330.     }
  332.     public function setEmail(string $email): self
  333.     {
  334.         $this->email = $email;
  336.         return $this;
  337.     }
  339.     public function getDescription(): ?string
  340.     {
  341.         return $this->description;
  342.     }
  344.     public function setDescription(string $description): self
  345.     {
  346.         $this->description = $description;
  348.         return $this;
  349.     }
  351.     public function getPhone(): ?string
  352.     {
  353.         return $this->phone;
  354.     }
  356.     public function setPhone(string $phone): self
  357.     {
  358.         $this->phone = $phone;
  360.         return $this;
  361.     }
  363.     public function getSecondPhone(): ?string
  364.     {
  365.         return $this->second_phone;
  366.     }
  368.     public function setSecondPhone(?string $second_phone): self
  369.     {
  370.         $this->second_phone = $second_phone;
  372.         return $this;
  373.     }
  375.     public function getAdress(): ?string
  376.     {
  377.         return $this->adress;
  378.     }
  381.      public function setAdress(?string $adress): self
  382.     {
  383.         $this->adress = $adress ?? '';
  384.         return $this;
  385.     }
  386.     
  388.     public function getCountry(): ?string
  389.     {
  390.         return $this->country;
  391.     }
  393.     public function setCountry(string $country): self
  394.     {
  395.         $this->country = $country;
  397.         return $this;
  398.     }
  400.     public function getRegion(): ?string
  401.     {
  402.         return $this->region;
  403.     }
  405.     public function setRegion(?string $region): self
  406.     {
  407.         $this->region = $region ?? '';
  408.         return $this;
  409.     }
  412.     public function getCity(): ?string
  413.     {
  414.         return $this->city;
  415.     }
  417.     public function setCity(string $city): self
  418.     {
  419.         $this->city = $city;
  421.         return $this;
  422.     }
  426.     public function getZip(): ?string
  427.     {
  428.         return $this->zip;
  429.     }
  431.     public function setZip(string $zip): self
  432.     {
  433.         $this->zip = $zip;
  435.         return $this;
  436.     }
  438.     public function getType(): ?string
  439.     {
  440.         return $this->type;
  441.     }
  443.     public function setType(string $type): self
  444.     {
  445.         $this->type = $type;
  447.         return $this;
  448.     }
  450.     public function isVerified(): bool
  451.     {
  452.         return $this->isVerified;
  453.     }
  455.     public function setIsVerified(bool $isVerified): self
  456.     {
  457.         $this->isVerified = $isVerified;
  459.         return $this;
  460.     }
  462.     /**
  463.      * @return Collection|Link[]
  464.      */
  465.     public function getLinks(): Collection
  466.     {
  467.         return $this->links;
  468.     }
  470.     public function addLink(Link $link): self
  471.     {
  472.         if( !$this->links->contains($link)) {
  473.             $this->links[] = $link;
  474.             $link->setUser($this);
  475.         }
  477.         return $this;
  478.     }
  480.     public function removeLink(Link $link): self
  481.     {
  482.         if( $this->links->removeElement($link)) {
  483.             // set the owning side to null (unless already changed)
  484.             if( $link->getUser() === $this) {
  485.                 $link->setUser(null);
  486.             }
  487.         }
  489.         return $this;
  490.     }
  492.     public function getCreatedAt(): ?\DateTimeInterface
  493.     {
  494.         return $this->createdAt;
  495.     }
  497.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  498.     {
  499.         $this->createdAt = $createdAt;
  501.         return $this;
  502.     }
  504.     public function getBlockedHours(): ?array
  505.     {
  506.         return $this->blockedHours;
  507.     }
  509.     public function setBlockedHours(?array $blockedHours): self
  510.     {
  511.         $this->blockedHours = $blockedHours;
  512.         return $this;
  513.     }
  515.     public function isBlocked(): bool
  516.     {
  517.        
  518.         return (bool) $this->isBlocked || $this->isBlockedAt(); 
  519.     }
  521.     // Nouvelle méthode avec tes paramètres (nom différent)
  522.     public function isBlockedAt( ?\DateTimeInterface $now = null,?\DateTimeZone $tz = null): bool {
  523.         $tz  = $tz ?: new \DateTimeZone('Africa/Tunis');
  524.         $now = $now ? (new \DateTimeImmutable($now->format('c')))->setTimezone($tz)
  525.                     : new \DateTimeImmutable('now', $tz);
  527.         // 1) Blocage permanent
  528.         if (!empty($this->isBlocked)) {
  529.             return true;
  530.         }
  532.         // 2) Blocage entre deux dates
  533.         $ba = $this->blockedAt  instanceof \DateTimeInterface ? (new \DateTimeImmutable($this->blockedAt->format('c')))->setTimezone($tz) : null;
  534.         $ua = $this->unblockedAt instanceof \DateTimeInterface ? (new \DateTimeImmutable($this->unblockedAt->format('c')))->setTimezone($tz) : null;
  536.         if ($ba) {
  537.             if ($ua) {
  538.                 if ($now >= $ba && $now < $ua) return true;
  539.             } else {
  540.                 if ($now >= $ba) return true;
  541.             }
  542.         }
  544.         // 3) Plages horaires quotidiennes
  545.         if (empty($this->blockedHours) || !is_array($this->blockedHours)) {
  546.             return false;
  547.         }
  549.         $map = [
  550.             'monday'=>'mon','mon'=>'mon',
  551.             'tuesday'=>'tue','tue'=>'tue',
  552.             'wednesday'=>'wed','wed'=>'wed',
  553.             'thursday'=>'thu','thu'=>'thu',
  554.             'friday'=>'fri','fri'=>'fri',
  555.             'saturday'=>'sat','sat'=>'sat',
  556.             'sunday'=>'sun','sun'=>'sun',
  557.             '1'=>'mon','2'=>'tue','3'=>'wed','4'=>'thu','5'=>'fri','6'=>'sat','7'=>'sun','0'=>'sun',
  558.         ];
  560.         $key = strtolower($now->format('D')); // mon..sun
  561.         $key = $map[$key] ?? $key;
  563.         $ranges = $this->blockedHours[$key] ?? [];
  565.         if (empty($ranges) || !is_array($ranges)) return false;
  567.         $toMin = static function (?string $hm): ?int {
  568.             if (!$hm || !preg_match('/^(\d{1,2}):(\d{2})$/', $hm, $m)) return null;
  569.             return ((int)$m[1]) * 60 + (int)$m[2];
  570.         };
  572.         $nowMin = (int)$now->format('H') * 60 + (int)$now->format('i');
  574.         foreach ($ranges as $r) {
  575.             $start = $toMin($r['start'] ?? null);
  576.             $end   = $toMin($r['end']   ?? null);
  577.             if ($start === null && $end === null) continue;
  579.             if ($start !== null && $end !== null) {
  580.                 if ($start < $end) {
  581.                     if ($nowMin >= $start && $nowMin < $end) return true;
  582.                 } elseif ($start > $end) {
  583.                     if ($nowMin >= $start || $nowMin < $end) return true;
  584.                 } else {
  585.                     continue;
  586.                 }
  587.             }
  588.         }
  589.         return false;
  590.     }
  594.     public function getIsBlocked(): bool
  595.     {
  596.         return $this->isBlocked;
  597.     }
  599.     public function setIsBlocked(bool $blocked): self
  600.     {
  601.         $this->isBlocked = $blocked;
  602.         return $this;
  603.     }
  605.     public function getBlockedAt(): ?\DateTimeInterface
  606.     {
  607.         return $this->blockedAt;
  608.     }
  610.     public function setBlockedAt(?\DateTimeInterface $date): self
  611.     {
  612.         $this->blockedAt = $date;
  613.         return $this;
  614.     }
  616.     public function getUnblockedAt(): ?\DateTimeInterface
  617.     {
  618.         return $this->unblockedAt;
  619.     }
  621.     public function setUnblockedAt(?\DateTimeInterface $date): self
  622.     {
  623.         $this->unblockedAt = $date;
  624.         return $this;
  625.     }
  627.     public function getBlockReason(): ?string
  628.     {
  629.         return $this->blockReason;
  630.     }
  632.     public function setBlockReason(?string $reason): self
  633.     {
  634.         $this->blockReason = $reason;
  635.         return $this;
  636.     }
  637.    
  639.     /**
  640.      * @return Collection|Document[]
  641.      */
  642.     public function getDocuments(): Collection
  643.     {
  644.         return $this->documents;
  645.     }
  647.     public function addDocument(Document $document): self
  648.     {
  649.         if( !$this->documents->contains($document)) {
  650.             $this->documents[] = $document;
  651.             $document->setClient($this);
  652.         }
  654.         return $this;
  655.     }
  657.     public function removeDocument(Document $document): self
  658.     {
  659.         if( $this->documents->removeElement($document)) {
  660.             // set the owning side to null (unless already changed)
  661.             if( $document->getClient() === $this) {
  662.                 $document->setClient(null);
  663.             }
  664.         }
  666.         return $this;
  667.     }
  669.     /**
  670.      * @return Collection|Document[]
  671.      */
  672.     public function getUserDocuments(): Collection
  673.     {
  674.         return $this->userDocuments;
  675.     }
  677.     public function addUserDocument(Document $userDocument): self
  678.     {
  679.         if( !$this->userDocuments->contains($userDocument)) {
  680.             $this->userDocuments[] = $userDocument;
  681.             $userDocument->setUser($this);
  682.         }
  684.         return $this;
  685.     }
  687.     public function removeUserDocument(Document $userDocument): self
  688.     {
  689.         if( $this->userDocuments->removeElement($userDocument)) {
  690.             // set the owning side to null (unless already changed)
  691.             if( $userDocument->getUser() === $this) {
  692.                 $userDocument->setUser(null);
  693.             }
  694.         }
  696.         return $this;
  697.     }
  699.     /**
  700.      * @return Collection|Address[]
  701.      */
  702.     public function getMultiAddress(): Collection
  703.     {
  704.         return $this->multiAddress;
  705.     }
  707.     public function addMultiAddress(Address $multiAddress): self
  708.     {
  709.         if( !$this->multiAddress->contains($multiAddress)) {
  710.             $this->multiAddress[] = $multiAddress;
  711.             $multiAddress->setUser($this);
  712.         }
  714.         return $this;
  715.     }
  717.     public function removeMultiAddress(Address $multiAddress): self
  718.     {
  719.         if( $this->multiAddress->removeElement($multiAddress)) {
  720.             // set the owning side to null (unless already changed)
  721.             if( $multiAddress->getUser() === $this) {
  722.                 $multiAddress->setUser(null);
  723.             }
  724.         }
  726.         return $this;
  727.     }
  729.     /**
  730.      * @return Collection|Comment[]
  731.      */
  732.     public function getComments(): Collection
  733.     {
  734.         return $this->comments;
  735.     }
  737.     public function addComment(Comment $comment): self
  738.     {
  739.         if( !$this->comments->contains($comment)) {
  740.             $this->comments[] = $comment;
  741.             $comment->setUser($this);
  742.         }
  744.         return $this;
  745.     }
  747.     public function removeComment(Comment $comment): self
  748.     {
  749.         if( $this->comments->removeElement($comment)) {
  750.             // set the owning side to null (unless already changed)
  751.             if( $comment->getUser() === $this) {
  752.                 $comment->setUser(null);
  753.             }
  754.         }
  756.         return $this;
  757.     }
  758.     /**
  759.      * @return Collection|Comment[]
  760.      */
  761.     public function getNotes(): Collection
  762.     {
  763.         return $this->notes;
  764.     }
  766.     public function addNote(Comment $note): self
  767.     {
  768.         if( !$this->notes->contains($note)) {
  769.             $this->notes[] = $note;
  770.             $note->setClient($this);
  771.         }
  773.         return $this;
  774.     }
  776.     public function removeNote(Comment $note): self
  777.     {
  778.         if( $this->notes->removeElement($note)) {
  779.             // set the owning side to null (unless already changed)
  780.             if( $note->getUser() === $this) {
  781.                 $note->setUser(null);
  782.             }
  783.         }
  785.         return $this;
  786.     }
  787.     public function getSupplier(): ?Supplier
  788.     {
  789.         return $this->supplier;
  790.     }
  792.     public function setSupplier(?Supplier $supplier): self
  793.     {
  794.         $this->supplier = $supplier;
  796.         return $this;
  797.     }
  799.     public function getPromotion(): ?Promotion
  800.     {
  801.         return $this->promotion;
  802.     }
  804.     public function setPromotion(?Promotion $promotion): self
  805.     {
  806.         $this->promotion = $promotion;
  808.         return $this;
  809.     }
  811.     /**
  812.      * @return Collection|Activity[]
  813.      */
  814.     public function getActivities(): Collection
  815.     {
  816.         return $this->activities;
  817.     }
  819.     public function addActivity(Activity $activity): self
  820.     {
  821.         if( !$this->activities->contains($activity)) {
  822.             $this->activities[] = $activity;
  823.             $activity->setCurrentUser($this);
  824.         }
  826.         return $this;
  827.     }
  829.     public function removeActivity(Activity $activity): self
  830.     {
  831.         if( $this->activities->removeElement($activity)) {
  832.             // set the owning side to null (unless already changed)
  833.             if( $activity->getCurrentUser() === $this) {
  834.                 $activity->setCurrentUser(null);
  835.             }
  836.         }
  838.         return $this;
  839.     }
  841.     public function getGroupUser(): ?GroupUser
  842.     {
  843.         return $this->groupUser;
  844.     }
  846.     public function setGroupUser(?GroupUser $groupUser): self
  847.     {
  848.         $this->groupUser = $groupUser;
  850.         return $this;
  851.     }
  853.     public function getUserPost(): ?UserPost
  854.     {
  855.         return $this->userPost;
  856.     }
  858.     public function setUserPost(?UserPost $post): self
  859.     {
  860.         $this->userPost = $post;
  861.         return $this;
  862.     }
  864.     public function __call($name, $arguments)
  865.     {
  866.         // TODO: Implement @method string getUserIdentifier()
  867.     }
  869.     public function jsonSerialize()
  870.     {
  871.         return array(
  872.             'adress' => $this->getAdress(),
  873.             'firstName' => $this->getFirstName(),
  874.             'username' => $this->getUsername(),
  875.             'email' => $this->getEmail(),
  876.             'password' => '',
  877.             'newPassword' => '',
  878.             'confirmPassword' => ''
  879.         );
  880.     }
  881.     /**
  882.      * @return Collection|Produit[]
  883.      */
  884.     public function getProduits(): Collection
  885.     {
  886.         return $this->produits;
  887.     }
  889.     public function addProduit(Produit $produit): self
  890.     {
  891.         if( !$this->produits->contains($produit)) {
  892.             $this->produits[] = $produit;
  893.             $produit->addUser($this);
  894.         }
  895.         return $this;
  896.     }
  898.     public function removeProduit(Produit $produit): self
  899.     {
  900.         if( $this->produits->contains($produit)) {
  901.             $this->produits->removeElement($produit);
  902.             $produit->removeUser($this);
  903.         }
  904.         return $this;
  905.     }
  907.     public function getClientType(): ?string
  908.     {
  909.         return $this->clientType;
  910.     }
  912.     public function setClientType(string $clientType): self
  913.     {
  914.         // Validate if the provided value is one of the valid ENUM values
  915.         if (!in_array($clientType, ClientType::getValidValues(), true)) {
  916.             throw new \InvalidArgumentException("Invalid client type: $clientType");
  917.         }
  919.         $this->clientType = $clientType;
  921.         return $this;
  922.     }
  923. }