src/Entity/User.php line 24

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\DateType;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\HttpFoundation\File\File;
  15. use  Symfony\Component\Validator\Constraints as Assert;
  18. #[ORM\Entity(repositoryClass: UserRepository::class)]
  19. #[UniqueEntity(
  20.     fields: ['email'],
  21.     errorPath: 'email',
  22.     message: 'Cet e-mail est déjà utilisée.',
  23. )]
  24. class User implements UserInterface, PasswordAuthenticatedUserInterface
  25. {
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     private ?int $id = null;
  31.     #[ORM\Column(name: 'email', type: 'string', length: 255)]
  32.     #[Assert\Email(
  33.         message: 'The email {{ value }} is not a valid email.',
  35.     )]
  37.     private ?string $email = null;
  39.     #[ORM\Column]
  40.     private array $roles = [];
  42.     /**
  43.      * @var string|null The hashed password
  44.      */
  45.     #[ORM\Column(type: 'string')]
  46.     private ?string $password = null;
  48.     #[ORM\Column(length: 255)]
  49.     private ?string $nom = null;
  51.     #[ORM\Column(length: 255)]
  52.     private ?string $prenom = null;
  54.     #[ORM\Column(length: 255)]
  55.     private ?string $sexe = null;
  58.     #[ORM\Column(nullable: true)]
  59.     private ?int $qs = null;
  61.     #[ORM\Column(nullable: true)]
  62.     private ?int $active = null;
  64.     #[ORM\Column(type: 'string' , nullable: true)]
  65.     private $brochureFilename;
  66.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  67.     private ?\DateTimeInterface $date_naissance = null;
  69.     #[ORM\ManyToOne(inversedBy: 'users')]
  70.     private ?Coach $coach = null;
  72.     #[ORM\Column(length: 255, nullable: true)]
  73.     private ?string $photo = null;
  76.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  77.     private ?\DateTimeInterface $date_ajout = null;
  79.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserObjectif::class)]
  80.     private Collection $userObjectif;
  82.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserSport::class)]
  83.     private Collection $userSport;
  85.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  86.     private ?int $apt = null;
  88.     #[ORM\ManyToOne(inversedBy: 'users')]
  89.     private ?Offre $offre = null;
  91.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CarnetEntainement::class)]
  92.     private Collection $carnetEntainements;
  95.     public function __construct()
  96.     {
  97.         $this->date_ajout = new \DateTimeImmutable();
  98.         $this->userObjectif = new ArrayCollection();
  99.         $this->userSport = new ArrayCollection();
  100.         $this->carnetEntainements = new ArrayCollection();
  101.     }
  103.     public function getId(): ?int
  104.     {
  105.         return $this->id;
  106.     }
  108.     public function getEmail(): ?string
  109.     {
  110.         return $this->email;
  111.     }
  113.     public function setEmail(string $email): self
  114.     {
  115.         $this->email = $email;
  117.         return $this;
  118.     }
  120.     /**
  121.      * A visual identifier that represents this user.
  122.      *
  123.      * @see UserInterface
  124.      */
  125.     public function getUserIdentifier(): string
  126.     {
  127.         return (string) $this->email;
  128.     }
  130.     /**
  131.      * @see UserInterface
  132.      */
  133.     public function getRoles(): array
  134.     {
  135.         $roles = $this->roles;
  136.         // guarantee every user at least has ROLE_USER
  137.         $roles[] = 'ROLE_USER';
  139.         return array_unique($roles);
  140.     }
  142.     public function setRoles(array $roles): self
  143.     {
  144.         $this->roles = $roles;
  146.         return $this;
  147.     }
  149.     /**
  150.      * @see PasswordAuthenticatedUserInterface
  151.      */
  152.     public function getPassword(): string
  153.     {
  154.         return $this->password;
  155.     }
  157.     public function setPassword(string $password): self
  158.     {
  159.         $this->password = $password;
  161.         return $this;
  162.     }
  164.     /**
  165.      * @see UserInterface
  166.      */
  167.     public function eraseCredentials()
  168.     {
  169.         // If you store any temporary, sensitive data on the user, clear it here
  170.         // $this->plainPassword = null;
  171.     }
  173.     public function getNom(): ?string
  174.     {
  175.         return $this->nom;
  176.     }
  178.     public function setNom(string $nom): self
  179.     {
  180.         $this->nom = $nom;
  182.         return $this;
  183.     }
  185.     public function getPrenom(): ?string
  186.     {
  187.         return $this->prenom;
  188.     }
  190.     public function setPrenom(string $prenom): self
  191.     {
  192.         $this->prenom = $prenom;
  194.         return $this;
  195.     }
  197.     public function getSexe(): ?string
  198.     {
  199.         return $this->sexe;
  200.     }
  202.     public function setSexe(string $sexe): self
  203.     {
  204.         $this->sexe = $sexe;
  206.         return $this;
  207.     }
  211.     public function getQs(): ?int
  212.     {
  213.         return $this->qs;
  214.     }
  216.     public function setQs(?int $qs): self
  217.     {
  218.         $this->qs = $qs;
  220.         return $this;
  221.     }
  223.     public function getActive(): ?int
  224.     {
  225.         return $this->active;
  226.     }
  228.     public function setActive(?int $active): self
  229.     {
  230.         $this->active = $active;
  232.         return $this;
  233.     }
  237.     public function getDateNaissance(): ?\DateTimeInterface
  238.     {
  239.         return $this->date_naissance;
  240.     }
  242.     public function setDateNaissance(?\DateTimeInterface $date_naissance): static
  243.     {
  244.         $this->date_naissance = $date_naissance;
  246.         return $this;
  247.     }
  248.     public function getBrochureFilename(): ?string
  249.     {
  250.         return $this->brochureFilename;
  251.     }
  253.     public function setBrochureFilename(string $brochureFilename): self
  254.     {
  255.         $this->brochureFilename = $brochureFilename;
  257.         return $this;
  258.     }
  260.     public function getCoach(): ?Coach
  261.     {
  262.         return $this->coach;
  263.     }
  265.     public function setCoach(?Coach $coach): static
  266.     {
  267.         $this->coach = $coach;
  269.         return $this;
  270.     }
  272.     public function getPhoto(): ?string
  273.     {
  274.         return $this->photo;
  275.     }
  277.     public function setPhoto(?string $photo): static
  278.     {
  279.         $this->photo = $photo;
  281.         return $this;
  282.     }
  285.     public function getDateAjout(): ?\DateTimeInterface
  286.     {
  287.         return $this->date_ajout;
  288.     }
  290.     public function setDateAjout(\DateTimeInterface $date_ajout): static
  291.     {
  292.         $this->date_ajout = $date_ajout;
  294.         return $this;
  295.     }
  297.     /**
  298.      * @return Collection<int, UserObjectif>
  299.      */
  300.     public function getUserObjectif(): Collection
  301.     {
  302.         return $this->userObjectif;
  303.     }
  305.     public function addUserObjectif(UserObjectif $userObjectif): static
  306.     {
  307.         if (!$this->userObjectif->contains($userObjectif)) {
  308.             $this->userObjectif->add($userObjectif);
  309.             $userObjectif->setUser($this);
  310.         }
  312.         return $this;
  313.     }
  315.     public function removeUserObjectif(UserObjectif $userObjectif): static
  316.     {
  317.         if ($this->userObjectif->removeElement($userObjectif)) {
  318.             // set the owning side to null (unless already changed)
  319.             if ($userObjectif->getUser() === $this) {
  320.                 $userObjectif->setUser(null);
  321.             }
  322.         }
  324.         return $this;
  325.     }
  327.     /**
  328.      * @return Collection<int, UserSport>
  329.      */
  330.     public function getUserSport(): Collection
  331.     {
  332.         return $this->userSport;
  333.     }
  335.     public function addUserSport(UserSport $userSport): static
  336.     {
  337.         if (!$this->userSport->contains($userSport)) {
  338.             $this->userSport->add($userSport);
  339.             $userSport->setUser($this);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removeUserSport(UserSport $userSport): static
  346.     {
  347.         if ($this->userSport->removeElement($userSport)) {
  348.             // set the owning side to null (unless already changed)
  349.             if ($userSport->getUser() === $this) {
  350.                 $userSport->setUser(null);
  351.             }
  352.         }
  354.         return $this;
  355.     }
  357.     public function getApt(): ?int
  358.     {
  359.         return $this->apt;
  360.     }
  362.     public function setApt(?int $apt): static
  363.     {
  364.         $this->apt = $apt;
  366.         return $this;
  367.     }
  369.     public function getOffre(): ?Offre
  370.     {
  371.         return $this->offre;
  372.     }
  374.     public function setOffre(?Offre $offre): static
  375.     {
  376.         $this->offre = $offre;
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, CarnetEntainement>
  383.      */
  384.     public function getCarnetEntainements(): Collection
  385.     {
  386.         return $this->carnetEntainements;
  387.     }
  389.     public function addCarnetEntainement(CarnetEntainement $carnetEntainement): static
  390.     {
  391.         if (!$this->carnetEntainements->contains($carnetEntainement)) {
  392.             $this->carnetEntainements->add($carnetEntainement);
  393.             $carnetEntainement->setUser($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeCarnetEntainement(CarnetEntainement $carnetEntainement): static
  400.     {
  401.         if ($this->carnetEntainements->removeElement($carnetEntainement)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($carnetEntainement->getUser() === $this) {
  404.                 $carnetEntainement->setUser(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  417. }