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.     private ?TypeAbonnement $typeabonnement = null;
  118.       // Getters and setters
  119.       public function getIsVerified(): bool
  120.       {
  121.           return $this->isVerified;
  122.       }
  123.   
  124.       public function setIsVerified(bool $isVerified): self
  125.       {
  126.           $this->isVerified = $isVerified;
  127.   
  128.           return $this;
  129.       }
  130.  public function getConfirmationToken(): ?string
  131.                                                                          {
  132.                                                                              return $this->confirmationToken;
  133.                                                                          }
  135.     public function setConfirmationToken(?string $confirmationToken): self
  136.     {
  137.         $this->confirmationToken = $confirmationToken;
  139.         return $this;
  140.     }
  141.    
  143.     public function getResetToken(): ?string
  144.     {
  145.         return $this->resetToken;
  146.     }
  148.     public function setResetToken(?string $resetToken): self
  149.     {
  150.         $this->resetToken = $resetToken;
  151.         return $this;
  152.     }
  154.     public function getResetTokenExpiresAt(): ?\DateTimeInterface
  155.     {
  156.         return $this->resetTokenExpiresAt;
  157.     }
  159.     public function setResetTokenExpiresAt(?\DateTimeInterface $expiresAt): self
  160.     {
  161.         $this->resetTokenExpiresAt = $expiresAt;
  162.         return $this;
  163.     }
  165.     public function __construct()
  166.     {
  167.         $this->livraisons = new ArrayCollection();
  168.         $this->creditsTransaction = new ArrayCollection();
  169.         $this->abonnements = new ArrayCollection();
  170.         $this->financements = new ArrayCollection();
  171.         $this->pointages = new ArrayCollection();
  172.     }
  174.     public function getId(): ?int
  175.     {
  176.         return $this->id;
  177.     }
  179.     public function getEmail(): ?string
  180.     {
  181.         return $this->email;
  182.     }
  184.     public function setEmail(string $email): self
  185.     {
  186.         $this->email = $email;
  188.         return $this;
  189.     }
  191.    
  193.     /**
  194.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  195.      */
  196.     public function getUsername(): string
  197.     {
  198.         return (string) $this->username;
  199.     }
  201.     public function getRoles(): array
  202.     {
  203.         // Assure que ROLE_USER est toujours présent
  204.         if (!in_array('ROLE_USER', $this->roles, true)) {
  205.             $this->roles[] = 'ROLE_USER';
  206.         }
  207.         return array_unique($this->roles);
  208.     }
  210.     public function setRoles(array $roles): self
  211.     {
  212.         $this->roles = $roles;
  214.         return $this;
  215.     }
  217.     /**
  218.      * @see PasswordAuthenticatedUserInterface
  219.      */
  220.     public function getPassword(): string
  221.     {
  222.         return $this->password;
  223.     }
  225.     public function setPassword(string $password): self
  226.     {
  227.         $this->password = $password;
  229.         return $this;
  230.     }
  232.     /**
  233.      * Returning a salt is only needed, if you are not using a modern
  234.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  235.      *
  236.      * @see UserInterface
  237.      */
  238.     public function getSalt(): ?string
  239.     {
  240.         return null;
  241.     }
  243.     /**
  244.      * @see UserInterface
  245.      */
  246.     public function eraseCredentials(): void
  247.     {
  248.         // If you store any temporary, sensitive data on the user, clear it here
  249.         // $this->plainPassword = null;
  250.     }
  252.     public function setUsername(string $username)
  253.     {
  254.         $this->username = $username;
  256.         return $this;
  257.     }
  259.     public function getNom(): ?string
  260.     {
  261.         return $this->nom;
  262.     }
  264.     public function setNom(string $nom)
  265.     {
  266.         $this->nom = $nom;
  268.         return $this;
  269.     }
  271.     public function getPrenom(): ?string
  272.     {
  273.         return $this->prenom;
  274.     }
  276.     public function setPrenom(string $prenom)
  277.     {
  278.         $this->prenom = $prenom;
  280.         return $this;
  281.     }
  283.     public function getAdresse(): ?string
  284.     {
  285.         return $this->adresse;
  286.     }
  288.     public function setAdresse(string $adresse)
  289.     {
  290.         $this->adresse = $adresse;
  292.         return $this;
  293.     }
  295.     /**
  296.      * @return Collection<int, Livraisons>
  297.      */
  298.     public function getLivraisons(): Collection
  299.     {
  300.         return $this->livraisons;
  301.     }
  303.     public function addLivraison(Livraisons $livraison)
  304.     {
  305.         if (!$this->livraisons->contains($livraison)) {
  306.             $this->livraisons->add($livraison);
  307.             $livraison->setIdClient($this);
  308.         }
  310.         return $this;
  311.     }
  313.     public function removeLivraison(Livraisons $livraison)
  314.     {
  315.         if ($this->livraisons->removeElement($livraison)) {
  316.             // set the owning side to null (unless already changed)
  317.             if ($livraison->getIdClient() === $this) {
  318.                 $livraison->setIdClient(null);
  319.             }
  320.         }
  322.         return $this;
  323.     }
  325.     public function getCredits(): ?int
  326.     {
  327.         return $this->credits;
  328.     }
  330.     public function setCredits(?int $credits)
  331.     {
  332.         $this->credits = $credits;
  334.         return $this;
  335.     }
  338.     public function __toString(): string
  339.     {
  340.         return $this->prenom.' '.$this->nom; // Return a string representation
  341.     }
  343.     public function getTelephone1(): ?string
  344.     {
  345.         return $this->telephone1;
  346.     }
  348.     public function setTelephone1(string $telephone1): self
  349.     {
  350.         $this->telephone1 = $telephone1;
  352.         return $this;
  353.     }
  355.    
  357.     /**
  358.      * @return Collection<int, Credits>
  359.      */
  360.     public function getCreditsTransaction(): Collection
  361.     {
  362.         return $this->creditsTransaction;
  363.     }
  365.     public function addCreditsTransaction(Credits $creditsTransaction): static
  366.     {
  367.         if (!$this->creditsTransaction->contains($creditsTransaction)) {
  368.             $this->creditsTransaction->add($creditsTransaction);
  369.             $creditsTransaction->setUserCredit($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removeCreditsTransaction(Credits $creditsTransaction): static
  376.     {
  377.         if ($this->creditsTransaction->removeElement($creditsTransaction)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($creditsTransaction->getUserCredit() === $this) {
  380.                 $creditsTransaction->setUserCredit(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     /**
  388.      * @return Collection<int, Abonnement>
  389.      */
  390.     public function getAbonnements(): Collection
  391.     {
  392.         return $this->abonnements;
  393.     }
  395.     public function addAbonnement(Abonnement $abonnement): static
  396.     {
  397.         if (!$this->abonnements->contains($abonnement)) {
  398.             $this->abonnements->add($abonnement);
  399.             $abonnement->setUserabonnee($this);
  400.         }
  402.         return $this;
  403.     }
  405.     public function removeAbonnement(Abonnement $abonnement): static
  406.     {
  407.         if ($this->abonnements->removeElement($abonnement)) {
  408.             // set the owning side to null (unless already changed)
  409.             if ($abonnement->getUserabonnee() === $this) {
  410.                 $abonnement->setUserabonnee(null);
  411.             }
  412.         }
  414.         return $this;
  415.     }
  417.     public function isIsVerified(): ?bool
  418.     {
  419.         return $this->isVerified;
  420.     }
  422.     public function getPointfidelite(): ?int
  423.     {
  424.         return $this->pointfidelite;
  425.     }
  427.     public function setPointfidelite(?int $pointfidelite): static
  428.     {
  429.         $this->pointfidelite = $pointfidelite;
  431.         return $this;
  432.     }
  435.     
  437.     public function isOkAbonnement(): bool
  438.     {
  439.         // Retrieve the user's subscription
  440.         $abonnement = $this->getAbonnements();
  442.         if (!$abonnement) {
  443.             return false; // No subscription found
  444.         }
  446.         // Check if the subscription has expired
  447.         $now = new \DateTime();
  449.         foreach ($abonnement as $subscription) {
  450.           //  $dateResiliation = $subscription->getDateResiliation();
  451.             // Faites quelque chose avec $dateResiliation
  452.         
  453.             if ($subscription->getStatutabonnement() == 'ongoing') {
  454.                 $typeabonnement=$subscription->getTypeabonnement();
  455.                 break;
  456.             }
  457.              }
  458.              
  460.              if (!isset($typeabonnement) || ($subscription->getDateresiliation() < new \DateTimeImmutable())) {
  461.                 return false;
  462.             }
  463.             
  465.     
  466.            if (in_array($typeabonnement->getId(), [1, 2, 3]) 
  467.            && $subscription->getNombrelivraison() === $typeabonnement->getCaracteristiquestypeabonnement()->getNbreliv()) {
  468.            return false;
  469.        }
  470.        
  471.    
  472.    
  473.         return true; // Subscription is valid
  474.     }
  476.     public function getActiveAbonnement(): ?Abonnement
  477.     {
  478.         $now = new \DateTimeImmutable();
  479.     
  480.         foreach ($this->abonnements as $abonnement) {
  481.             if ($abonnement->getDateResiliation() > $now ) {
  482.                 return $abonnement;
  483.             }
  484.         }
  485.     
  486.         return null; // Aucun abonnement actif
  487.     }
  489.     public function getNombreEmployes():  int
  490. {
  491.     
  493.     // Récupérer le nombre total (plus performant que count($users))
  494.     $count = $userRepository->createQueryBuilder('u')
  495.         ->select('COUNT(u.id)')
  496.         ->join('u.entreprise', 'e')
  497.         ->where('e.createdBy = :creator')
  498.         ->setParameter('creator', $this->getUser())
  499.         ->getQuery()
  500.         ->getSingleScalarResult();
  502.     return (int)$count;
  503.     
  504. }
  508.     public function getUserIdentifier(): string
  509.     {
  510.         return $this->email ?? $this->username; // Retourne d'abord l'email, sinon le username
  511.     }
  513.   
  515.     public function getEntreprise(): ?Entreprise
  516.     {
  517.         return $this->entreprise;
  518.     }
  520.     public function setEntreprise(?Entreprise $entreprise): static
  521.     {
  522.         $this->entreprise = $entreprise;
  524.         return $this;
  525.     }
  527.     /**
  528.      * @return Collection<int, Pointage>
  529.      */
  530.     public function getPointages(): Collection
  531.     {
  532.         return $this->pointages;
  533.     }
  535.     public function addPointage(Pointage $pointage): static
  536.     {
  537.         if (!$this->pointages->contains($pointage)) {
  538.             $this->pointages->add($pointage);
  539.             $pointage->setEmploye($this);
  540.         }
  542.         return $this;
  543.     }
  545.     public function removePointage(Pointage $pointage): static
  546.     {
  547.         if ($this->pointages->removeElement($pointage)) {
  548.             // set the owning side to null (unless already changed)
  549.             if ($pointage->getEmploye() === $this) {
  550.                 $pointage->setEmploye(null);
  551.             }
  552.         }
  554.         return $this;
  555.     }
  557.     public function getTypeabonnement(): ?TypeAbonnement
  558.     {
  559.         return $this->typeabonnement;
  560.     }
  562.     public function setTypeabonnement(?TypeAbonnement $typeabonnement): static
  563.     {
  564.         $this->typeabonnement = $typeabonnement;
  566.         return $this;
  567.     }
  569.     public function getFinancement(): ?Financement
  570.     {
  571.         return $this->financement;
  572.     }
  574.     public function setFinancement(?Financement $financement): static
  575.     {
  576.         $this->financement = $financement;
  578.         return $this;
  579.     }
  581.     /**
  582.      * @return Collection<int, Financement>
  583.      */
  584.     public function getFinancements(): Collection
  585.     {
  586.         return $this->financements;
  587.     }
  589.     public function addFinancement(Financement $financement): static
  590.     {
  591.         if (!$this->financements->contains($financement)) {
  592.             $this->financements->add($financement);
  593.             $financement->setUsersfinancement($this);
  594.         }
  596.         return $this;
  597.     }
  599.     public function removeFinancement(Financement $financement): static
  600.     {
  601.         if ($this->financements->removeElement($financement)) {
  602.             // set the owning side to null (unless already changed)
  603.             if ($financement->getUsersfinancement() === $this) {
  604.                 $financement->setUsersfinancement(null);
  605.             }
  606.         }
  608.         return $this;
  609.     }
  610.     // src/Entity/User.php
  611. public function getNomComplet(): string
  612. {
  613.     return $this->prenom . ' ' . $this->nom;
  614. }
  616. }