src/Entity/User.php line 14

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\UserRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\DBAL\Types\Types;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  9. use Symfony\Component\Security\Core\User\UserInterface;
  10. #[ORM\Entity(repositoryClassUserRepository::class)]
  11. class User implements UserInterfacePasswordAuthenticatedUserInterface
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column()]
  16.     private ?int  $id null;
  17.     #[ORM\Column(length180uniquetrue)]
  18.     private ?string $email null;
  19.     #[ORM\Column]
  20.     private array $roles = [];
  21.     /**
  22.      * @var string The hashed password
  23.      */
  24.     #[ORM\Column]
  25.     private ?string $password null;
  26.     #[ORM\Column(length200uniquetrue)]
  27.     private ?string $username null;
  28.     #[ORM\Column]
  29.     private ?int $etat null;
  30.     #[ORM\Column(typeTypes::DATETIME_MUTABLE)]
  31.     private ?\DateTimeInterface $createdAt null;
  32.     #[ORM\Column(typeTypes::DATETIME_MUTABLEnullabletrue)]
  33.     private ?\DateTimeInterface $updatedAt null;
  34.     #[ORM\OneToMany(mappedBy'user'targetEntityEleveur::class)]
  35.     private Collection $eleveurs;
  36.     #[ORM\OneToMany(mappedBy'user'targetEntityInseminateur::class)]
  37.     private Collection $inseminateurs;
  38.     #[ORM\OneToMany(mappedBy'user'targetEntityAgentOep::class)]
  39.     private Collection $agentOeps;
  40.     #[ORM\OneToMany(mappedBy'user'targetEntityAgent::class)]
  41.     private Collection $agents;
  42.     #[ORM\OneToMany(mappedBy'user'targetEntityConsultation::class)]
  43.     private Collection $consultations;
  44.     #[ORM\OneToMany(mappedBy'user'targetEntityPartenaire::class)]
  45.     private Collection $partenaires;
  46.     public function __construct()
  47.     {
  48.         $this->eleveurs = new ArrayCollection();
  49.         $this->inseminateurs = new ArrayCollection();
  50.         $this->agentOeps = new ArrayCollection();
  51.         $this->agents = new ArrayCollection();
  52.         $this->consultations = new ArrayCollection();
  53.         $this->partenaires = new ArrayCollection();
  54.     }
  55.     public function getId(): ?int
  56.     {
  57.         return $this->id;
  58.     }
  59.     public function getEmail(): ?string
  60.     {
  61.         return $this->email;
  62.     }
  63.     public function setEmail(string $email): self
  64.     {
  65.         $this->email $email;
  66.         return $this;
  67.     }
  68.     /**
  69.      * A visual identifier that represents this user.
  70.      *
  71.      * @see UserInterface
  72.      */
  73.     public function getUserIdentifier(): string
  74.     {
  75.         return (string) $this->email;
  76.     }
  77.     /**
  78.      * @see UserInterface
  79.      */
  80.     public function getRoles(): array
  81.     {
  82.         $roles $this->roles;
  83.         // guarantee every user at least has ROLE_USER
  84.        // $roles[] = 'ROLE_USER';
  85.         return array_unique($roles);
  86.     }
  87.     public function setRoles(array $roles): self
  88.     {
  89.         $this->roles $roles;
  90.         return $this;
  91.     }
  92.     /**
  93.      * @see PasswordAuthenticatedUserInterface
  94.      */
  95.     public function getPassword(): string
  96.     {
  97.         return $this->password;
  98.     }
  99.     public function setPassword(string $password): self
  100.     {
  101.         $this->password $password;
  102.         return $this;
  103.     }
  104.     /**
  105.      * @see UserInterface
  106.      */
  107.     public function eraseCredentials()
  108.     {
  109.         // If you store any temporary, sensitive data on the user, clear it here
  110.         // $this->plainPassword = null;
  111.     }
  112.     public function getUsername(): ?string
  113.     {
  114.         return $this->username;
  115.     }
  116.     public function setUsername(string $username): self
  117.     {
  118.         $this->username $username;
  119.         return $this;
  120.     }
  121.     public function getEtat(): ?int
  122.     {
  123.         return $this->etat;
  124.     }
  125.     public function setEtat(int $etat): self
  126.     {
  127.         $this->etat $etat;
  128.         return $this;
  129.     }
  130.     public function getCreatedAt(): ?\DateTimeInterface
  131.     {
  132.         return $this->createdAt;
  133.     }
  134.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  135.     {
  136.         $this->createdAt $createdAt;
  137.         return $this;
  138.     }
  139.     public function getUpdatedAt(): ?\DateTimeInterface
  140.     {
  141.         return $this->updatedAt;
  142.     }
  143.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  144.     {
  145.         $this->updatedAt $updatedAt;
  146.         return $this;
  147.     }
  148.     /**
  149.      * @return Collection<int, Eleveur>
  150.      */
  151.     public function getEleveurs(): Collection
  152.     {
  153.         return $this->eleveurs;
  154.     }
  155.     public function addEleveur(Eleveur $eleveur): self
  156.     {
  157.         if (!$this->eleveurs->contains($eleveur)) {
  158.             $this->eleveurs[] = $eleveur;
  159.             $eleveur->setUser($this);
  160.         }
  161.         return $this;
  162.     }
  163.     public function removeEleveur(Eleveur $eleveur): self
  164.     {
  165.         if ($this->eleveurs->removeElement($eleveur)) {
  166.             // set the owning side to null (unless already changed)
  167.             if ($eleveur->getUser() === $this) {
  168.                 $eleveur->setUser(null);
  169.             }
  170.         }
  171.         return $this;
  172.     }
  173.     /**
  174.      * @return Collection<int, Inseminateur>
  175.      */
  176.     public function getInseminateurs(): Collection
  177.     {
  178.         return $this->inseminateurs;
  179.     }
  180.     public function addInseminateur(Inseminateur $inseminateur): self
  181.     {
  182.         if (!$this->inseminateurs->contains($inseminateur)) {
  183.             $this->inseminateurs[] = $inseminateur;
  184.             $inseminateur->setUser($this);
  185.         }
  186.         return $this;
  187.     }
  188.     public function removeInseminateur(Inseminateur $inseminateur): self
  189.     {
  190.         if ($this->inseminateurs->removeElement($inseminateur)) {
  191.             // set the owning side to null (unless already changed)
  192.             if ($inseminateur->getUser() === $this) {
  193.                 $inseminateur->setUser(null);
  194.             }
  195.         }
  196.         return $this;
  197.     }
  198.     /**
  199.      * @return Collection<int, AgentOep>
  200.      */
  201.     public function getAgentOeps(): Collection
  202.     {
  203.         return $this->agentOeps;
  204.     }
  205.     public function addAgentOep(AgentOep $agentOep): self
  206.     {
  207.         if (!$this->agentOeps->contains($agentOep)) {
  208.             $this->agentOeps[] = $agentOep;
  209.             $agentOep->setUser($this);
  210.         }
  211.         return $this;
  212.     }
  213.     public function removeAgentOep(AgentOep $agentOep): self
  214.     {
  215.         if ($this->agentOeps->removeElement($agentOep)) {
  216.             // set the owning side to null (unless already changed)
  217.             if ($agentOep->getUser() === $this) {
  218.                 $agentOep->setUser(null);
  219.             }
  220.         }
  221.         return $this;
  222.     }
  223.     /**
  224.      * @return Collection<int, Agent>
  225.      */
  226.     public function getAgents(): Collection
  227.     {
  228.         return $this->agents;
  229.     }
  230.     public function addAgent(Agent $agent): self
  231.     {
  232.         if (!$this->agents->contains($agent)) {
  233.             $this->agents[] = $agent;
  234.             $agent->setUser($this);
  235.         }
  236.         return $this;
  237.     }
  238.     public function removeAgent(Agent $agent): self
  239.     {
  240.         if ($this->agents->removeElement($agent)) {
  241.             // set the owning side to null (unless already changed)
  242.             if ($agent->getUser() === $this) {
  243.                 $agent->setUser(null);
  244.             }
  245.         }
  246.         return $this;
  247.     }
  248.     /**
  249.      * @return Collection<int, Consultation>
  250.      */
  251.     public function getConsultations(): Collection
  252.     {
  253.         return $this->consultations;
  254.     }
  255.     public function addConsultation(Consultation $consultation): self
  256.     {
  257.         if (!$this->consultations->contains($consultation)) {
  258.             $this->consultations[] = $consultation;
  259.             $consultation->setUser($this);
  260.         }
  261.         return $this;
  262.     }
  263.     public function removeConsultation(Consultation $consultation): self
  264.     {
  265.         if ($this->consultations->removeElement($consultation)) {
  266.             // set the owning side to null (unless already changed)
  267.             if ($consultation->getUser() === $this) {
  268.                 $consultation->setUser(null);
  269.             }
  270.         }
  271.         return $this;
  272.     }
  273.     /**
  274.      * @return Collection<int, Partenaire>
  275.      */
  276.     public function getPartenaires(): Collection
  277.     {
  278.         return $this->partenaires;
  279.     }
  280.     public function addPartenaire(Partenaire $partenaire): self
  281.     {
  282.         if (!$this->partenaires->contains($partenaire)) {
  283.             $this->partenaires[] = $partenaire;
  284.             $partenaire->setUser($this);
  285.         }
  286.         return $this;
  287.     }
  288.     public function removePartenaire(Partenaire $partenaire): self
  289.     {
  290.         if ($this->partenaires->removeElement($partenaire)) {
  291.             // set the owning side to null (unless already changed)
  292.             if ($partenaire->getUser() === $this) {
  293.                 $partenaire->setUser(null);
  294.             }
  295.         }
  296.         return $this;
  297.     }
  298. }