src/Entity/User.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Symfony\Component\Uid\Uuid;
  14. use Symfony\Component\Validator\Constraints as Assert;
  15. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  17. #[ORM\Entity(repositoryClass: UserRepository::class)]
  18. #[ORM\Table(name: '`user`')]
  19. #[ApiResource]
  20. #[UniqueEntity(
  21.     fields: ['email'],
  22.     message: 'Cet e-mail est déjà utilisé. Veuillez en essayer un autre.'
  23. )]
  24. #[UniqueEntity(fields: ['username'], message: 'This username is already taken.')]
  25. class User implements UserInterface, PasswordAuthenticatedUserInterface
  26. {
  27.     #[ORM\Id]
  28.     #[ORM\GeneratedValue]
  29.     #[ORM\Column]
  30.     private ?int $id = null;
  32.     #[ORM\Column(length: 180, unique: true)]
  33.     private ?string $email = null;
  35.     #[ORM\Column(length: 180, nullable: true)]
  36.     private ?string $username = null;
  38.     #[ORM\Column(length: 255)]
  39.     private ?string $nom = null;
  41.     #[ORM\Column(length: 255)]
  42.     private ?string $prenom = null;
  44.     #[ORM\Column(length: 255,nullable: true)]
  45.     private ?string $telephone1 = null;
  48.     #[ORM\Column(length: 400, nullable: true)]
  49.     private ?string $adresse = null;
  52.     #[ORM\ManyToOne(targetEntity: Entreprise::class, inversedBy: 'employes')]
  53.     #[ORM\JoinColumn(nullable: true)]
  54.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  55.     private $entreprise;
  57.     #[ORM\OneToMany(mappedBy: 'employe', targetEntity: Pointage::class)]
  58.     private $pointages;
  62.     #[ORM\Column]
  63.     private array $roles = ['ROLE_USER'];
  65.    
  67.     #[ORM\Column(type: 'string', length: 255)]
  68.    // #[Assert\NotBlank]
  69.     //#[Assert\Length(min: 6, max: 4096)]
  70.     private ?string $password = null;
  72.     // Ce champ est uniquement utilisé pour la confirmation en mémoire
  73.     #[Assert\NotBlank(groups: ['registration'])]
  74.     #[Assert\EqualTo(propertyPath: 'password', message: 'Les mots de passe doivent correspondre.')]
  75.     private ?string $plainPassword = null;
  77.     
  79.     #[ORM\Column(nullable: true)]
  80.     private ?int $credits = null;
  83.     #[ORM\Column(type: 'string', nullable: true)]
  84.     private ?string $resetToken = null;
  86.     #[ORM\Column(type: 'datetime', nullable: true)]
  87.     private ?\DateTimeInterface $resetTokenExpiresAt = null;
  89.     #[ORM\OneToMany(mappedBy: 'userCredit', targetEntity: Credits::class)]
  90.     private Collection $creditsTransaction;
  92.     
  94.     #[ORM\OneToMany(mappedBy: 'userabonnee', targetEntity: Abonnement::class, cascade: ['remove'])]
  95.        private Collection $abonnements;
  97.     #[ORM\Column(type: "boolean", options: ["default" => false])]
  98.     private bool $isVerified = false;
  100.     #[ORM\Column(nullable: true)]
  101.     private ?int $pointfidelite = 0;
  103.     
  105.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  106.     private ?string $confirmationToken = null;
  108.     
  110.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Livraisons::class)]
  111.     private Collection $livraisons;
  113.     #[ORM\OneToMany(mappedBy: 'usersfinancement', targetEntity: Financement::class)]
  114.     private Collection $financements;
  116.     
  117.     #[ORM\Column(length: 50, nullable: true)]
  118. private ?string $contractType = null;
  121. #[ORM\Column(length: 50, nullable: true)]
  122. private ?string $employeeId = null;
  125. public function getEmployeeId(): ?string
  126. {
  127.     return $this->employeeId;
  128. }
  130. public function setEmployeeId(?string $employeeId): self
  131. {
  132.     $this->employeeId = $employeeId;
  133.     return $this;
  134. }
  137.     private ?TypeAbonnement $typeabonnement = null;
  138. #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  142. public function getContractType(): ?string
  143. {
  144.     return $this->contractType;
  145. }
  147. public function setContractType(?string $contractType): self
  148. {
  149.     $this->contractType = $contractType;
  150.     return $this;
  151. }
  154. private ?\DateTimeImmutable $hireDate = null;
  156. public function getHireDate(): ?\DateTimeImmutable
  157. {
  158.     return $this->hireDate;
  159. }
  161. public function setHireDate(?\DateTimeImmutable $hireDate): self
  162. {
  163.     $this->hireDate = $hireDate;
  164.     return $this;
  165. }
  168.     #[ORM\Column(type: 'float', nullable: true)]
  169. private ?float $salary = null;
  171. public function getSalary(): ?float
  172. {
  173.     return $this->salary;
  174. }
  176. public function setSalary(?float $salary): self
  177. {
  178.     $this->salary = $salary;
  179.     return $this;
  180. }
  184.       // Getters and setters
  185.       public function getIsVerified(): bool
  186.       {
  187.           return $this->isVerified;
  188.       }
  189.   
  190.       public function setIsVerified(bool $isVerified): self
  191.       {
  192.           $this->isVerified = $isVerified;
  193.   
  194.           return $this;
  195.       }
  196.  public function getConfirmationToken(): ?string
  197.                                                                          {
  198.                                                                              return $this->confirmationToken;
  199.                                                                          }
  201.     public function setConfirmationToken(?string $confirmationToken): self
  202.     {
  203.         $this->confirmationToken = $confirmationToken;
  205.         return $this;
  206.     }
  207.    
  209.     public function getResetToken(): ?string
  210.     {
  211.         return $this->resetToken;
  212.     }
  214.     public function setResetToken(?string $resetToken): self
  215.     {
  216.         $this->resetToken = $resetToken;
  217.         return $this;
  218.     }
  220.     public function getResetTokenExpiresAt(): ?\DateTimeInterface
  221.     {
  222.         return $this->resetTokenExpiresAt;
  223.     }
  225.     public function setResetTokenExpiresAt(?\DateTimeInterface $expiresAt): self
  226.     {
  227.         $this->resetTokenExpiresAt = $expiresAt;
  228.         return $this;
  229.     }
  231.     public function __construct()
  232.     {
  233.         $this->livraisons = new ArrayCollection();
  234.         $this->creditsTransaction = new ArrayCollection();
  235.         $this->abonnements = new ArrayCollection();
  236.         $this->financements = new ArrayCollection();
  237.         $this->pointages = new ArrayCollection();
  238.     }
  240.     public function getId(): ?int
  241.     {
  242.         return $this->id;
  243.     }
  245.     public function getEmail(): ?string
  246.     {
  247.         return $this->email;
  248.     }
  250.     public function setEmail(string $email): self
  251.     {
  252.         $this->email = $email;
  254.         return $this;
  255.     }
  257.    
  259.     /**
  260.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  261.      */
  262.     public function getUsername(): string
  263.     {
  264.         return (string) $this->username;
  265.     }
  267.     public function getRoles(): array
  268.     {
  269.         // Assure que ROLE_USER est toujours présent
  270.         if (!in_array('ROLE_USER', $this->roles, true)) {
  271.             $this->roles[] = 'ROLE_USER';
  272.         }
  273.         return array_unique($this->roles);
  274.     }
  276.     public function setRoles(array $roles): self
  277.     {
  278.         $this->roles = $roles;
  280.         return $this;
  281.     }
  283.     /**
  284.      * @see PasswordAuthenticatedUserInterface
  285.      */
  286.     public function getPassword(): string
  287.     {
  288.         return $this->password;
  289.     }
  291.     public function setPassword(string $password): self
  292.     {
  293.         $this->password = $password;
  295.         return $this;
  296.     }
  298.     /**
  299.      * Returning a salt is only needed, if you are not using a modern
  300.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  301.      *
  302.      * @see UserInterface
  303.      */
  304.     public function getSalt(): ?string
  305.     {
  306.         return null;
  307.     }
  309.     /**
  310.      * @see UserInterface
  311.      */
  312.     public function eraseCredentials(): void
  313.     {
  314.         // If you store any temporary, sensitive data on the user, clear it here
  315.         // $this->plainPassword = null;
  316.     }
  318.     public function setUsername(string $username)
  319.     {
  320.         $this->username = $username;
  322.         return $this;
  323.     }
  325.     public function getNom(): ?string
  326.     {
  327.         return $this->nom;
  328.     }
  330.     public function setNom(string $nom)
  331.     {
  332.         $this->nom = $nom;
  334.         return $this;
  335.     }
  337.     public function getPrenom(): ?string
  338.     {
  339.         return $this->prenom;
  340.     }
  342.     public function setPrenom(string $prenom)
  343.     {
  344.         $this->prenom = $prenom;
  346.         return $this;
  347.     }
  349.     public function getAdresse(): ?string
  350.     {
  351.         return $this->adresse;
  352.     }
  354.     public function setAdresse(string $adresse)
  355.     {
  356.         $this->adresse = $adresse;
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, Livraisons>
  363.      */
  364.     public function getLivraisons(): Collection
  365.     {
  366.         return $this->livraisons;
  367.     }
  369.     public function addLivraison(Livraisons $livraison)
  370.     {
  371.         if (!$this->livraisons->contains($livraison)) {
  372.             $this->livraisons->add($livraison);
  373.             $livraison->setIdClient($this);
  374.         }
  376.         return $this;
  377.     }
  379.     public function removeLivraison(Livraisons $livraison)
  380.     {
  381.         if ($this->livraisons->removeElement($livraison)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($livraison->getIdClient() === $this) {
  384.                 $livraison->setIdClient(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  391.     public function getCredits(): ?int
  392.     {
  393.         return $this->credits;
  394.     }
  396.     public function setCredits(?int $credits)
  397.     {
  398.         $this->credits = $credits;
  400.         return $this;
  401.     }
  404.     public function __toString(): string
  405.     {
  406.         return $this->prenom.' '.$this->nom; // Return a string representation
  407.     }
  409.     public function getTelephone1(): ?string
  410.     {
  411.         return $this->telephone1;
  412.     }
  414.     public function setTelephone1(string $telephone1): self
  415.     {
  416.         $this->telephone1 = $telephone1;
  418.         return $this;
  419.     }
  421.    
  423.     /**
  424.      * @return Collection<int, Credits>
  425.      */
  426.     public function getCreditsTransaction(): Collection
  427.     {
  428.         return $this->creditsTransaction;
  429.     }
  431.     public function addCreditsTransaction(Credits $creditsTransaction): static
  432.     {
  433.         if (!$this->creditsTransaction->contains($creditsTransaction)) {
  434.             $this->creditsTransaction->add($creditsTransaction);
  435.             $creditsTransaction->setUserCredit($this);
  436.         }
  438.         return $this;
  439.     }
  441.     public function removeCreditsTransaction(Credits $creditsTransaction): static
  442.     {
  443.         if ($this->creditsTransaction->removeElement($creditsTransaction)) {
  444.             // set the owning side to null (unless already changed)
  445.             if ($creditsTransaction->getUserCredit() === $this) {
  446.                 $creditsTransaction->setUserCredit(null);
  447.             }
  448.         }
  450.         return $this;
  451.     }
  453.     /**
  454.      * @return Collection<int, Abonnement>
  455.      */
  456.     public function getAbonnements(): Collection
  457.     {
  458.         return $this->abonnements;
  459.     }
  461.     public function addAbonnement(Abonnement $abonnement): static
  462.     {
  463.         if (!$this->abonnements->contains($abonnement)) {
  464.             $this->abonnements->add($abonnement);
  465.             $abonnement->setUserabonnee($this);
  466.         }
  468.         return $this;
  469.     }
  471.     public function removeAbonnement(Abonnement $abonnement): static
  472.     {
  473.         if ($this->abonnements->removeElement($abonnement)) {
  474.             // set the owning side to null (unless already changed)
  475.             if ($abonnement->getUserabonnee() === $this) {
  476.                 $abonnement->setUserabonnee(null);
  477.             }
  478.         }
  480.         return $this;
  481.     }
  483.     public function isIsVerified(): ?bool
  484.     {
  485.         return $this->isVerified;
  486.     }
  488.     public function getPointfidelite(): ?int
  489.     {
  490.         return $this->pointfidelite;
  491.     }
  493.     public function setPointfidelite(?int $pointfidelite): static
  494.     {
  495.         $this->pointfidelite = $pointfidelite;
  497.         return $this;
  498.     }
  500. public function isOkAbonnement(): bool
  501. {
  502.     $abonnements = $this->getAbonnements();
  504.     if (count($abonnements) === 0) {
  505.         return false;
  506.     }
  508.     foreach ($abonnements as $subscription) {
  509.         if (strtolower(trim($subscription->getStatutabonnement())) !== 'ongoing') {
  510.             continue;
  511.         }
  513.         $dateResiliation = $subscription->getDateresiliation();
  515.         if ($dateResiliation !== null) {
  516.             // On compare uniquement la DATE (pas l'heure)
  517.             $today = (new \DateTime())->setTime(0, 0, 0);
  518.             $endDate = (clone $dateResiliation)->setTime(23, 59, 59);
  520.             if ($endDate < $today) {
  521.                 continue; // abonnement expiré
  522.             }
  523.         }
  525.         $typeAbonnement = $subscription->getTypeabonnement();
  526.         if (!$typeAbonnement) {
  527.             continue;
  528.         }
  530.         $caracteristiques = $typeAbonnement->getCaracteristiquestypeabonnement();
  531.         if (!$caracteristiques) {
  532.             return true; // pas de limite
  533.         }
  535.         $maxLivraisons = $caracteristiques->getNbreliv();
  536.         if ($maxLivraisons !== null &&
  537.             $subscription->getNombrelivraison() >= $maxLivraisons
  538.         ) {
  539.             return false;
  540.         }
  542.         // ✅ abonnement valide trouvé
  543.         return true;
  544.     }
  546.     return false;
  547. }
  550.    
  552.     public function isOkAbonnementOLD(): bool
  553.     {
  554.         // Retrieve the user's subscription
  555.         $abonnement = $this->getAbonnements();
  557.         if (!$abonnement) {
  558.             return false; // No subscription found
  559.         }
  561.         // Check if the subscription has expired
  562.         $now = new \DateTime();
  564.         foreach ($abonnement as $subscription) {
  565.           //  $dateResiliation = $subscription->getDateResiliation();
  566.             // Faites quelque chose avec $dateResiliation
  567.         
  568.             if ($subscription->getStatutabonnement() == 'ongoing') {
  569.                 $typeabonnement=$subscription->getTypeabonnement();
  570.                 break;
  571.             }
  572.              }
  573.              
  575.              if (!isset($typeabonnement) || ($subscription->getDateresiliation() < new \DateTimeImmutable())) {
  576.                 return false;
  577.             }
  578.             
  580.     
  581.            if (in_array($typeabonnement->getId(), [1, 2, 3]) 
  582.            && $subscription->getNombrelivraison() === $typeabonnement->getCaracteristiquestypeabonnement()->getNbreliv()) {
  583.            return false;
  584.        }
  585.        
  586.    
  587.    
  588.         return true; // Subscription is valid
  589.     }
  591.     public function getActiveAbonnement(): ?Abonnement
  592.     {
  593.         $now = new \DateTimeImmutable();
  594.     
  595.         foreach ($this->abonnements as $abonnement) {
  596.             if ($abonnement->getDateResiliation() > $now ) {
  597.                 return $abonnement;
  598.             }
  599.         }
  600.     
  601.         return null; // Aucun abonnement actif
  602.     }
  604.     public function getNombreEmployes():  int
  605. {
  606.     
  608.     // Récupérer le nombre total (plus performant que count($users))
  609.     $count = $userRepository->createQueryBuilder('u')
  610.         ->select('COUNT(u.id)')
  611.         ->join('u.entreprise', 'e')
  612.         ->where('e.createdBy = :creator')
  613.         ->setParameter('creator', $this->getUser())
  614.         ->getQuery()
  615.         ->getSingleScalarResult();
  617.     return (int)$count;
  618.     
  619. }
  623.     public function getUserIdentifier(): string
  624.     {
  625.         return $this->email ?? $this->username; // Retourne d'abord l'email, sinon le username
  626.     }
  628.   
  630.     public function getEntreprise(): ?Entreprise
  631.     {
  632.         return $this->entreprise;
  633.     }
  635.     public function setEntreprise(?Entreprise $entreprise): static
  636.     {
  637.         $this->entreprise = $entreprise;
  639.         return $this;
  640.     }
  642.     /**
  643.      * @return Collection<int, Pointage>
  644.      */
  645.     public function getPointages(): Collection
  646.     {
  647.         return $this->pointages;
  648.     }
  650.     public function addPointage(Pointage $pointage): static
  651.     {
  652.         if (!$this->pointages->contains($pointage)) {
  653.             $this->pointages->add($pointage);
  654.             $pointage->setEmploye($this);
  655.         }
  657.         return $this;
  658.     }
  660.     public function removePointage(Pointage $pointage): static
  661.     {
  662.         if ($this->pointages->removeElement($pointage)) {
  663.             // set the owning side to null (unless already changed)
  664.             if ($pointage->getEmploye() === $this) {
  665.                 $pointage->setEmploye(null);
  666.             }
  667.         }
  669.         return $this;
  670.     }
  672.     public function getTypeabonnement(): ?TypeAbonnement
  673.     {
  674.         return $this->typeabonnement;
  675.     }
  677.     public function setTypeabonnement(?TypeAbonnement $typeabonnement): static
  678.     {
  679.         $this->typeabonnement = $typeabonnement;
  681.         return $this;
  682.     }
  684.     public function getFinancement(): ?Financement
  685.     {
  686.         return $this->financement;
  687.     }
  689.     public function setFinancement(?Financement $financement): static
  690.     {
  691.         $this->financement = $financement;
  693.         return $this;
  694.     }
  696.     /**
  697.      * @return Collection<int, Financement>
  698.      */
  699.     public function getFinancements(): Collection
  700.     {
  701.         return $this->financements;
  702.     }
  704.     public function addFinancement(Financement $financement): static
  705.     {
  706.         if (!$this->financements->contains($financement)) {
  707.             $this->financements->add($financement);
  708.             $financement->setUsersfinancement($this);
  709.         }
  711.         return $this;
  712.     }
  714.     public function removeFinancement(Financement $financement): static
  715.     {
  716.         if ($this->financements->removeElement($financement)) {
  717.             // set the owning side to null (unless already changed)
  718.             if ($financement->getUsersfinancement() === $this) {
  719.                 $financement->setUsersfinancement(null);
  720.             }
  721.         }
  723.         return $this;
  724.     }
  725.     // src/Entity/User.php
  726. public function getNomComplet(): string
  727. {
  728.     return $this->prenom . ' ' . $this->nom;
  729. }
  731. }