src/Entity/Users.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UsersRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Symfony\Component\Serializer\Annotation\Ignore;
  14. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Symfony\Component\Validator\Constraints as Assert;
  16. use Doctrine\DBAL\Types\Types;
  17. use Serializable;
  19. #[ORM\Entity(repositoryClass: UsersRepository::class)]
  20. #[Vich\Uploadable]
  21. #[UniqueEntity(fields: ['email'], message: 'Il y a déjà un compte avec cet email !')]
  22. class Users implements UserInterface, PasswordAuthenticatedUserInterface, Serializable
  23. {
  24.     #[ORM\Id]
  25.     #[ORM\GeneratedValue]
  26.     #[ORM\Column]
  27.     private ?int $id = null;
  29.     #[ORM\Column(length: 180, unique: true)]
  30.     private ?string $email = null;
  32.     #[ORM\Column]
  33.     private array $roles = [];
  35.     /**
  36.      * @var string The hashed password
  37.      */
  38.     #[ORM\Column]
  39.     private ?string $password = null;
  41.     #[ORM\Column(length: 100, nullable: true)]
  42.     private ?string $nom = null;
  44.     #[ORM\Column(length: 125, nullable: true)]
  45.     private ?string $prenom = null;
  47.     #[ORM\Column(length: 30, nullable: true)]
  48.     private ?string $telephone = null;
  50.     #[ORM\Column(length: 255, nullable: true)]
  51.     private ?string $adresse = null;
  53.     #[ORM\Column(length: 10, nullable: true)]
  54.     private ?string $code_postal = null;
  56.     #[ORM\Column(length: 200, nullable: true)]
  57.     private ?string $ville = null;
  59.     #[ORM\Column(length: 100, nullable: true)]
  60.     private ?string $pseudo = null;
  62.     #[ORM\Column(length: 255, nullable: true)]
  63.     private ?string $description = null;
  65.     #[ORM\Column(length: 255, nullable: true)]
  66.     private ?string $file = null;
  68.     #[Vich\UploadableField(mapping: 'featured_profils', fileNameProperty: 'file')]  
  69.     #[Assert\File(maxSize:'2M', maxSizeMessage:  'La taille du fichier ne doit pas dépasser 2 Mo.')]
  70.     private $imageFile;
  72.     #[ORM\Column(type: 'boolean')]
  73.     private $is_verified = false;
  75.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  76.     private ?string $resetToken;
  78.     #[ORM\Column(type: 'datetime_immutable', options: ['default' => 'CURRENT_TIMESTAMP'])]
  79.     private ?\DateTimeImmutable $created_at = null;
  81.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  82.     private ?\DateTimeInterface $updated_at = null;
  84.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Subscription::class)]
  85.     private Collection $subscriptions;
  87.     #[ORM\Column(length: 255, nullable: true)]
  88.     private ?string $stripeId = null;
  90.     #[ORM\OneToMany(mappedBy: 'userId', targetEntity: DemandeDeTravail::class)]
  91.     private Collection $demandeDeTravails;
  93.     #[ORM\OneToMany(mappedBy: 'userId', targetEntity: OffreDeTravail::class)]
  94.     private Collection $offreDeTravails;
  96.     #[ORM\OneToMany(mappedBy: 'userIdAuteur', targetEntity: Evaluation::class)]
  97.     private Collection $evaluations;
  99.     #[ORM\OneToMany(mappedBy: 'expediteurId', targetEntity: Message::class)]
  100.     private Collection $messages;
  102.     #[ORM\OneToMany(mappedBy: 'userId', targetEntity: Notification::class)]
  103.     private Collection $notifications;
  105.     public function __construct()
  106.     {
  107.         $this->created_at = new \DateTimeImmutable();
  108.         $this->subscriptions = new ArrayCollection();
  109.         $this->demandeDeTravails = new ArrayCollection();
  110.         $this->offreDeTravails = new ArrayCollection();
  111.         $this->evaluations = new ArrayCollection();
  112.         $this->messages = new ArrayCollection();
  113.         $this->notifications = new ArrayCollection();
  114.     }
  116.     public function getId(): ?int
  117.     {
  118.         return $this->id;
  119.     }
  121.     public function getEmail(): ?string
  122.     {
  123.         return $this->email;
  124.     }
  126.     public function setEmail(string $email): self
  127.     {
  128.         $this->email = $email;
  130.         return $this;
  131.     }
  133.     /**
  134.      * A visual identifier that represents this user.
  135.      *
  136.      * @see UserInterface
  137.      */
  138.     public function getUserIdentifier(): string
  139.     {
  140.         return (string) $this->email;
  141.     }
  143.     /**
  144.      * @see UserInterface
  145.      */
  146.     public function getRoles(): array
  147.     {
  148.         $roles = $this->roles;
  149.         // guarantee every user at least has ROLE_USER
  150.         $roles[] = 'ROLE_USER';
  152.         return array_unique($roles);
  153.     }
  155.     public function setRoles(array $roles): self
  156.     {
  157.         $this->roles = $roles;
  159.         return $this;
  160.     }
  162.     /**
  163.      * @see PasswordAuthenticatedUserInterface
  164.      */
  165.     public function getPassword(): string
  166.     {
  167.         return $this->password;
  168.     }
  170.     public function setPassword(string $password): self
  171.     {
  172.         $this->password = $password;
  174.         return $this;
  175.     }
  177.     /**
  178.      * @see UserInterface
  179.      */
  180.     public function eraseCredentials()
  181.     {
  182.         // If you store any temporary, sensitive data on the user, clear it here
  183.         // $this->plainPassword = null;
  184.     }
  186.     public function getNom(): ?string
  187.     {
  188.         return $this->nom;
  189.     }
  191.     public function setNom(?string $nom): self
  192.     {
  193.         $this->nom = $nom;
  195.         return $this;
  196.     }
  198.     public function getPrenom(): ?string
  199.     {
  200.         return $this->prenom;
  201.     }
  203.     public function setPrenom(?string $prenom): self
  204.     {
  205.         $this->prenom = $prenom;
  207.         return $this;
  208.     }
  210.     public function getTelephone(): ?string
  211.     {
  212.         return $this->telephone;
  213.     }
  215.     public function setTelephone(?string $telephone): self
  216.     {
  217.         $this->telephone = $telephone;
  219.         return $this;
  220.     }
  222.     public function getAdresse(): ?string
  223.     {
  224.         return $this->adresse;
  225.     }
  227.     public function setAdresse(?string $adresse): self
  228.     {
  229.         $this->adresse = $adresse;
  231.         return $this;
  232.     }
  234.     public function getCodePostal(): ?string
  235.     {
  236.         return $this->code_postal;
  237.     }
  239.     public function setCodePostal(?string $code_postal): self
  240.     {
  241.         $this->code_postal = $code_postal;
  243.         return $this;
  244.     }
  246.     public function getVille(): ?string
  247.     {
  248.         return $this->ville;
  249.     }
  251.     public function setVille(?string $ville): self
  252.     {
  253.         $this->ville = $ville;
  255.         return $this;
  256.     }
  258.     public function getPseudo(): ?string
  259.     {
  260.         return $this->pseudo;
  261.     }
  263.     public function setPseudo(?string $pseudo): self
  264.     {
  265.         $this->pseudo = $pseudo;
  267.         return $this;
  268.     }
  270.     public function getDescription(): ?string
  271.     {
  272.         return $this->description;
  273.     }
  275.     public function setDescription(?string $description): self
  276.     {
  277.         $this->description = $description;
  279.         return $this;
  280.     }
  282.     public function getFile(): ?string
  283.     {
  284.         return $this->file;
  285.     }
  287.     public function setFile(?string $file): self
  288.     {
  289.         $this->file = $file;
  291.         return $this;
  292.     }
  294.     public function getImageFile(File $image = null)
  295.     {
  296.         return $this->imageFile;
  297.     }
  299.     public function setImageFile(File $image = null)
  300.     {        
  301.         $this->imageFile = $image;
  303.          if($image) {
  304.             $this->file = $image->getFilename();
  305.              $this->updated_at = new \DateTime('now');
  306.          }
  308.     }
  310.     public function getIsVerified(): ?bool
  311.     {
  312.         return $this->is_verified;
  313.     }
  315.     public function setIsVerified(?bool $is_verified): self
  316.     {
  317.         $this->is_verified = $is_verified;
  319.         return $this;
  320.     }
  322.     public function getResetToken(): ?string
  323.     {
  324.         return $this->resetToken;
  325.     }
  327.     public function setResetToken(?string $resetToken): self
  328.     {
  329.         $this->resetToken = $resetToken;
  331.         return $this;
  332.     }
  334.     public function getCreatedAt(): ?\DateTimeImmutable
  335.     {
  336.         return $this->created_at;
  337.     }
  339.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  340.     {
  341.         $this->created_at = $created_at;
  343.         return $this;
  344.     }
  346.     public function getUpdatedAt(): ?\DateTimeInterface
  347.     {
  348.         return $this->updated_at;
  349.     }
  351.     public function setUpdatedAt(?\DateTimeInterface $updated_at): self
  352.     {
  353.         $this->updated_at = $updated_at;
  355.         return $this;
  356.     }
  357.     
  358.      /**
  359.      * @return Collection<int, Subscription>
  360.      */
  361.     public function getSubscriptions(): Collection
  362.     {
  363.         return $this->subscriptions;
  364.     }
  366.     public function addSubscription(Subscription $subscription): self
  367.     {
  368.         if (!$this->subscriptions->contains($subscription)) {
  369.             $this->subscriptions->add($subscription);
  370.             $subscription->setUser($this);
  371.         }
  373.         return $this;
  374.     }
  376.     public function removeSubscription(Subscription $subscription): self
  377.     {
  378.         if ($this->subscriptions->removeElement($subscription)) {
  379.             // set the owning side to null (unless already changed)
  380.             if ($subscription->getUser() === $this) {
  381.                 $subscription->setUser(null);
  382.             }
  383.         }
  385.         return $this;
  386.     }
  388.     public function hasActiveSubscription(): bool
  389.     {
  390.         foreach ($this->subscriptions as $subscription) {
  391.             if ($subscription->isActive()) {
  392.                 return true; // L'utilisateur a au moins un abonnement actif
  393.             }
  394.         }
  396.         return false; // Aucun abonnement actif trouvé
  397.     }
  399.     public function getStripeId(): ?string
  400.     {
  401.         return $this->stripeId;
  402.     }
  404.     public function setStripeId(?string $stripeId): self
  405.     {
  406.         $this->stripeId = $stripeId;
  408.         return $this;
  409.     }
  411.     /**
  412.      * @see \Serializable::serialize()
  413.      */
  414.     public function serialize()
  415.     {
  416.         return serialize(array(
  417.             $this->id,
  418.             $this->email,
  419.             $this->password,
  420.             $this->file,
  421.             // see section on salt below
  422.             // $this->salt,
  423.         ));
  424.     }
  426.     /**
  427.      * @see \Serializable::unserialize()
  428.      */
  429.     public function unserialize($serialized)
  430.     {
  431.         [
  432.             $this->id,
  433.             $this->email,
  434.             $this->password,
  435.             $this->file,
  436.             // voir la section sur le sel ci-dessous
  437.             // $this->salt
  438.         ] = unserialize($serialized, ['allowed_classes' => false]);
  439.     }
  441.     /**
  442.      * @return Collection<int, DemandeDeTravail>
  443.      */
  444.     public function getDemandeDeTravails(): Collection
  445.     {
  446.         return $this->demandeDeTravails;
  447.     }
  449.     public function addDemandeDeTravail(DemandeDeTravail $demandeDeTravail): static
  450.     {
  451.         if (!$this->demandeDeTravails->contains($demandeDeTravail)) {
  452.             $this->demandeDeTravails->add($demandeDeTravail);
  453.             $demandeDeTravail->setUserId($this);
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeDemandeDeTravail(DemandeDeTravail $demandeDeTravail): static
  460.     {
  461.         if ($this->demandeDeTravails->removeElement($demandeDeTravail)) {
  462.             // set the owning side to null (unless already changed)
  463.             if ($demandeDeTravail->getUserId() === $this) {
  464.                 $demandeDeTravail->setUserId(null);
  465.             }
  466.         }
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return Collection<int, OffreDeTravail>
  473.      */
  474.     public function getOffreDeTravails(): Collection
  475.     {
  476.         return $this->offreDeTravails;
  477.     }
  479.     public function addOffreDeTravail(OffreDeTravail $offreDeTravail): static
  480.     {
  481.         if (!$this->offreDeTravails->contains($offreDeTravail)) {
  482.             $this->offreDeTravails->add($offreDeTravail);
  483.             $offreDeTravail->setUserId($this);
  484.         }
  486.         return $this;
  487.     }
  489.     public function removeOffreDeTravail(OffreDeTravail $offreDeTravail): static
  490.     {
  491.         if ($this->offreDeTravails->removeElement($offreDeTravail)) {
  492.             // set the owning side to null (unless already changed)
  493.             if ($offreDeTravail->getUserId() === $this) {
  494.                 $offreDeTravail->setUserId(null);
  495.             }
  496.         }
  498.         return $this;
  499.     }
  501.     /**
  502.      * @return Collection<int, Evaluation>
  503.      */
  504.     public function getEvaluations(): Collection
  505.     {
  506.         return $this->evaluations;
  507.     }
  509.     public function addEvaluation(Evaluation $evaluation): static
  510.     {
  511.         if (!$this->evaluations->contains($evaluation)) {
  512.             $this->evaluations->add($evaluation);
  513.             $evaluation->setUserIdAuteur($this);
  514.         }
  516.         return $this;
  517.     }
  519.     public function removeEvaluation(Evaluation $evaluation): static
  520.     {
  521.         if ($this->evaluations->removeElement($evaluation)) {
  522.             // set the owning side to null (unless already changed)
  523.             if ($evaluation->getUserIdAuteur() === $this) {
  524.                 $evaluation->setUserIdAuteur(null);
  525.             }
  526.         }
  528.         return $this;
  529.     }
  531.     /**
  532.      * @return Collection<int, Message>
  533.      */
  534.     public function getMessages(): Collection
  535.     {
  536.         return $this->messages;
  537.     }
  539.     public function addMessage(Message $message): static
  540.     {
  541.         if (!$this->messages->contains($message)) {
  542.             $this->messages->add($message);
  543.             $message->setExpediteurId($this);
  544.         }
  546.         return $this;
  547.     }
  549.     public function removeMessage(Message $message): static
  550.     {
  551.         if ($this->messages->removeElement($message)) {
  552.             // set the owning side to null (unless already changed)
  553.             if ($message->getExpediteurId() === $this) {
  554.                 $message->setExpediteurId(null);
  555.             }
  556.         }
  558.         return $this;
  559.     }
  561.     /**
  562.      * @return Collection<int, Notification>
  563.      */
  564.     public function getNotifications(): Collection
  565.     {
  566.         return $this->notifications;
  567.     }
  569.     public function addNotification(Notification $notification): static
  570.     {
  571.         if (!$this->notifications->contains($notification)) {
  572.             $this->notifications->add($notification);
  573.             $notification->setUserId($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removeNotification(Notification $notification): static
  580.     {
  581.         if ($this->notifications->removeElement($notification)) {
  582.             // set the owning side to null (unless already changed)
  583.             if ($notification->getUserId() === $this) {
  584.                 $notification->setUserId(null);
  585.             }
  586.         }
  588.         return $this;
  589.     }
  590. }