src/Entity/User.php line 14

  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\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  12. #[ORM\Entity(repositoryClass: UserRepository::class)]
  13. #[ORM\Table(name: 'ujr_users')]
  14. class User implements UserInterface, PasswordAuthenticatedUserInterface
  15. {
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column]
  19.     private ?int $id = null;
  21.     #[ORM\Column(length: 180, unique: true)]
  22.     private ?string $email = null;
  24.     #[ORM\Column]
  25.     private array $roles = [];
  27.     /**
  28.      * @var string The hashed password
  29.      */
  30.     #[ORM\Column]
  31.     private ?string $password = null;
  33.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Directeur::class)]
  34.     private Collection $directeurs;
  36.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ResponsableStructure::class)]
  37.     private Collection $responsableStructures;
  39.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Chercheur::class)]
  40.     private Collection $chercheurs;
  42.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Projet::class)]
  43.     private Collection $projets;
  45.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Tag::class)]
  46.     private Collection $tags;
  48.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Publication::class)]
  49.     private Collection $publications;
  51.     #[ORM\Column(length: 255, nullable: true)]
  52.     private ?string $username = null;
  54.     #[ORM\Column(nullable: true)]
  55.     private ?int $etat = null;
  57.     public function __construct()
  58.     {
  59.         $this->directeurs = new ArrayCollection();
  60.         $this->responsableStructures = new ArrayCollection();
  61.         $this->chercheurs = new ArrayCollection();
  62.         $this->projets = new ArrayCollection();
  63.         $this->tags = new ArrayCollection();
  64.         $this->publications = new ArrayCollection();
  65.     }
  67.     public function getId(): ?int
  68.     {
  69.         return $this->id;
  70.     }
  72.     public function getEmail(): ?string
  73.     {
  74.         return $this->email;
  75.     }
  77.     public function setEmail(string $email): self
  78.     {
  79.         $this->email = $email;
  81.         return $this;
  82.     }
  84.     /**
  85.      * A visual identifier that represents this user.
  86.      *
  87.      * @see UserInterface
  88.      */
  89.     public function getUserIdentifier(): string
  90.     {
  91.         return (string) $this->email;
  92.     }
  94.     /**
  95.      * @see UserInterface
  96.      */
  97.     public function getRoles(): array
  98.     {
  99.         $roles = $this->roles;
  100.         // guarantee every user at least has ROLE_USER
  101.         $roles[] = 'ROLE_USER';
  103.         return array_unique($roles);
  104.     }
  106.     public function setRoles(array $roles): self
  107.     {
  108.         $this->roles = $roles;
  110.         return $this;
  111.     }
  113.     /**
  114.      * @see PasswordAuthenticatedUserInterface
  115.      */
  116.     public function getPassword(): string
  117.     {
  118.         return $this->password;
  119.     }
  121.     public function setPassword(string $password): self
  122.     {
  123.         $this->password = $password;
  125.         return $this;
  126.     }
  128.     /**
  129.      * @see UserInterface
  130.      */
  131.     public function eraseCredentials()
  132.     {
  133.         // If you store any temporary, sensitive data on the user, clear it here
  134.         // $this->plainPassword = null;
  135.     }
  137.     /**
  138.      * @return Collection<int, Directeur>
  139.      */
  140.     public function getDirecteurs(): Collection
  141.     {
  142.         return $this->directeurs;
  143.     }
  145.     public function addDirecteur(Directeur $directeur): self
  146.     {
  147.         if (!$this->directeurs->contains($directeur)) {
  148.             $this->directeurs->add($directeur);
  149.             $directeur->setUser($this);
  150.         }
  152.         return $this;
  153.     }
  155.     public function removeDirecteur(Directeur $directeur): self
  156.     {
  157.         if ($this->directeurs->removeElement($directeur)) {
  158.             // set the owning side to null (unless already changed)
  159.             if ($directeur->getUser() === $this) {
  160.                 $directeur->setUser(null);
  161.             }
  162.         }
  164.         return $this;
  165.     }
  167.     /**
  168.      * @return Collection<int, ResponsableStructure>
  169.      */
  170.     public function getResponsableStructures(): Collection
  171.     {
  172.         return $this->responsableStructures;
  173.     }
  175.     public function addResponsableStructure(ResponsableStructure $responsableStructure): self
  176.     {
  177.         if (!$this->responsableStructures->contains($responsableStructure)) {
  178.             $this->responsableStructures->add($responsableStructure);
  179.             $responsableStructure->setUser($this);
  180.         }
  182.         return $this;
  183.     }
  185.     public function removeResponsableStructure(ResponsableStructure $responsableStructure): self
  186.     {
  187.         if ($this->responsableStructures->removeElement($responsableStructure)) {
  188.             // set the owning side to null (unless already changed)
  189.             if ($responsableStructure->getUser() === $this) {
  190.                 $responsableStructure->setUser(null);
  191.             }
  192.         }
  194.         return $this;
  195.     }
  197.     /**
  198.      * @return Collection<int, Chercheur>
  199.      */
  200.     public function getChercheurs(): Collection
  201.     {
  202.         return $this->chercheurs;
  203.     }
  205.     public function addChercheur(Chercheur $chercheur): self
  206.     {
  207.         if (!$this->chercheurs->contains($chercheur)) {
  208.             $this->chercheurs->add($chercheur);
  209.             $chercheur->setUser($this);
  210.         }
  212.         return $this;
  213.     }
  215.     public function removeChercheur(Chercheur $chercheur): self
  216.     {
  217.         if ($this->chercheurs->removeElement($chercheur)) {
  218.             // set the owning side to null (unless already changed)
  219.             if ($chercheur->getUser() === $this) {
  220.                 $chercheur->setUser(null);
  221.             }
  222.         }
  224.         return $this;
  225.     }
  227.     /**
  228.      * @return Collection<int, Projet>
  229.      */
  230.     public function getProjets(): Collection
  231.     {
  232.         return $this->projets;
  233.     }
  235.     public function addProjet(Projet $projet): self
  236.     {
  237.         if (!$this->projets->contains($projet)) {
  238.             $this->projets->add($projet);
  239.             $projet->setUser($this);
  240.         }
  242.         return $this;
  243.     }
  245.     public function removeProjet(Projet $projet): self
  246.     {
  247.         if ($this->projets->removeElement($projet)) {
  248.             // set the owning side to null (unless already changed)
  249.             if ($projet->getUser() === $this) {
  250.                 $projet->setUser(null);
  251.             }
  252.         }
  254.         return $this;
  255.     }
  257.     public function __toString(): string
  258.     {
  259.         return $this->email;
  260.     }
  262.     /**
  263.      * @return Collection<int, Tag>
  264.      */
  265.     public function getTags(): Collection
  266.     {
  267.         return $this->tags;
  268.     }
  270.     public function addTag(Tag $tag): self
  271.     {
  272.         if (!$this->tags->contains($tag)) {
  273.             $this->tags->add($tag);
  274.             $tag->setUser($this);
  275.         }
  277.         return $this;
  278.     }
  280.     public function removeTag(Tag $tag): self
  281.     {
  282.         if ($this->tags->removeElement($tag)) {
  283.             // set the owning side to null (unless already changed)
  284.             if ($tag->getUser() === $this) {
  285.                 $tag->setUser(null);
  286.             }
  287.         }
  289.         return $this;
  290.     }
  292.     /**
  293.      * @return Collection<int, Publication>
  294.      */
  295.     public function getPublications(): Collection
  296.     {
  297.         return $this->publications;
  298.     }
  300.     public function addPublication(Publication $publication): self
  301.     {
  302.         if (!$this->publications->contains($publication)) {
  303.             $this->publications->add($publication);
  304.             $publication->setUser($this);
  305.         }
  307.         return $this;
  308.     }
  310.     public function removePublication(Publication $publication): self
  311.     {
  312.         if ($this->publications->removeElement($publication)) {
  313.             // set the owning side to null (unless already changed)
  314.             if ($publication->getUser() === $this) {
  315.                 $publication->setUser(null);
  316.             }
  317.         }
  319.         return $this;
  320.     }
  322.     public function getUsername(): ?string
  323.     {
  324.         return $this->username;
  325.     }
  327.     public function setUsername(?string $username): self
  328.     {
  329.         $this->username = $username;
  331.         return $this;
  332.     }
  334.     public function getEtat(): ?int
  335.     {
  336.         return $this->etat;
  337.     }
  339.     public function setEtat(?int $etat): self
  340.     {
  341.         $this->etat = $etat;
  343.         return $this;
  344.     }
  345. }