src/Entity/User.php line 18

Open in your IDE?
  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\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Gedmo\Mapping\Annotation as Gedmo;
  15. #[ORM\Entity(repositoryClass: UserRepository::class)]
  16. #[ORM\Table(name: '`user`')]
  17. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface
  19. {
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column(type: 'integer')]
  23.     private $id;
  25.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  26.     private $email;
  28.     #[ORM\Column(type: 'json')]
  29.     private $roles = [];
  31.     #[ORM\Column(type: 'string', nullable: true)]
  32.     private $password;
  34.     #[ORM\Column(type: 'string', length: 255)]
  35.     private $nom;
  37.     #[ORM\Column(type: 'string', length: 255)]
  38.     private $prenom;
  40.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  41.     private $telephone;
  43.     #[ORM\Column(type: 'date', nullable: true)]
  44.     private $arrivee;
  46.     #[ORM\Column(type: 'date', nullable: true)]
  47.     private $depart;
  49.     #[ORM\Column(type: 'boolean', nullable: true)]
  50.     private $enabled=true;
  52.     #[ORM\ManyToOne(targetEntity: Ptf::class, inversedBy: 'users')]
  53.     private $ptf;
  55.     #[ORM\ManyToOne(targetEntity: Poste::class, inversedBy: 'users')]
  56.     private $poste;
  58.     #[Gedmo\Timestampable(on: 'create')]
  59.     #[ORM\Column(type: 'datetime')]
  60.     private $created_at;
  62.     #[Gedmo\Timestampable(on: 'update')]
  63.     #[ORM\Column(type: 'datetime')]
  64.     private $updated_at;
  66.     #[ORM\Column(type: 'integer')]
  67.     private $created_by;
  69.     #[ORM\Column(type: 'integer')]
  70.     private $updated_by;
  72.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  73.     private ?string $file = 'avatars/null.png';
  75.     #[ORM\Column]
  76.     private ?bool $changepwd = true;
  78.     #[ORM\Column]
  79.     private ?bool $resetpwd = true;
  81.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Commentaire::class)]
  82.     private Collection $commentaires;
  84.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Groupe::class)]
  85.     private Collection $groupes;
  87.     public function __construct()
  88.     {
  89.         $this->commentaires = new ArrayCollection();
  90.         $this->groupes = new ArrayCollection();
  91.     }
  93.     public function __toString()
  94.     {
  95.         return $this->getPrenom()." ".$this->getNom();
  96.     }
  98.     public function getId(): ?int
  99.     {
  100.         return $this->id;
  101.     }
  103.     public function getEmail(): ?string
  104.     {
  105.         return $this->email;
  106.     }
  108.     public function setEmail(string $email): self
  109.     {
  110.         $this->email = $email;
  112.         return $this;
  113.     }
  115.     /**
  116.      * A visual identifier that represents this user.
  117.      *
  118.      * @see UserInterface
  119.      */
  120.     public function getUserIdentifier(): string
  121.     {
  122.         return (string) $this->email;
  123.     }
  125.     /**
  126.      * @see UserInterface
  127.      */
  128.     public function getRoles(): array
  129.     {
  130.         $roles = $this->roles;
  131.         // guarantee every user at least has ROLE_USER
  132.         $roles[] = 'ROLE_USER';
  134.         return array_unique($roles);
  135.     }
  137.     public function setRoles(array $roles): self
  138.     {
  139.         $this->roles = $roles;
  141.         return $this;
  142.     }
  144.     public function hasRole($role)
  145.     {
  146.         return in_array($role, $this->getRoles(), true);
  147.     }
  149.     public function addRole($role)
  150.     {
  151.         if (!in_array($role, $this->roles, true)) {
  152.             $this->roles[] = $role;
  153.         }
  155.         return $this;
  156.     }
  158.     public function removeRole($role)
  159.     {
  160.         if (false !== $key = array_search($role, $this->roles, true)) {
  161.             unset($this->roles[$key]);
  162.             $this->roles = array_values($this->roles);
  163.         }
  165.         return $this;
  166.     }
  168.     public function removeAllRole(): self
  169.     {
  170.         foreach ($this->roles as $role) {
  171.             $this->removeRole($role);
  172.         }
  173.         return $this;
  174.     }
  176.     /**
  177.      * @see PasswordAuthenticatedUserInterface
  178.      */
  179.     public function getPassword(): string
  180.     {
  181.         return $this->password;
  182.     }
  184.     public function setPassword(string $password): self
  185.     {
  186.         $this->password = $password;
  188.         return $this;
  189.     }
  191.     /**
  192.      * @see UserInterface
  193.      */
  194.     public function eraseCredentials()
  195.     {
  196.         // If you store any temporary, sensitive data on the user, clear it here
  197.         // $this->plainPassword = null;
  198.     }
  200.     public function getNom(): ?string
  201.     {
  202.         return $this->nom;
  203.     }
  205.     public function setNom(string $nom): self
  206.     {
  207.         $this->nom = $nom;
  209.         return $this;
  210.     }
  212.     public function getPrenom(): ?string
  213.     {
  214.         return $this->prenom;
  215.     }
  217.     public function setPrenom(string $prenom): self
  218.     {
  219.         $this->prenom = $prenom;
  221.         return $this;
  222.     }
  224.     public function getTelephone(): ?string
  225.     {
  226.         return $this->telephone;
  227.     }
  229.     public function setTelephone(?string $telephone): self
  230.     {
  231.         $this->telephone = $telephone;
  233.         return $this;
  234.     }
  236.     public function getArrivee(): ?\DateTimeInterface
  237.     {
  238.         return $this->arrivee;
  239.     }
  241.     public function setArrivee(?\DateTimeInterface $arrivee): self
  242.     {
  243.         $this->arrivee = $arrivee;
  245.         return $this;
  246.     }
  248.     public function getDepart(): ?\DateTimeInterface
  249.     {
  250.         return $this->depart;
  251.     }
  253.     public function setDepart(?\DateTimeInterface $depart): self
  254.     {
  255.         $this->depart = $depart;
  257.         return $this;
  258.     }
  260.     public function isEnabled(): ?bool
  261.     {
  262.         return $this->enabled;
  263.     }
  265.     public function setEnabled(?bool $enabled): self
  266.     {
  267.         $this->enabled = $enabled;
  269.         return $this;
  270.     }
  272.     public function getPtf(): ?Ptf
  273.     {
  274.         return $this->ptf;
  275.     }
  277.     public function setPtf(?Ptf $ptf): self
  278.     {
  279.         $this->ptf = $ptf;
  281.         return $this;
  282.     }
  284.     public function getPoste(): ?Poste
  285.     {
  286.         return $this->poste;
  287.     }
  289.     public function setPoste(?Poste $poste): self
  290.     {
  291.         $this->poste = $poste;
  293.         return $this;
  294.     }
  296.     public function getCreatedAt(): ?\DateTimeInterface
  297.     {
  298.         return $this->created_at;
  299.     }
  301.     public function setCreatedAt(\DateTimeInterface $created_at): self
  302.     {
  303.         $this->created_at = $created_at;
  305.         return $this;
  306.     }
  308.     public function getUpdatedAt(): ?\DateTimeInterface
  309.     {
  310.         return $this->updated_at;
  311.     }
  313.     public function setUpdatedAt(\DateTimeInterface $updated_at): self
  314.     {
  315.         $this->updated_at = $updated_at;
  317.         return $this;
  318.     }
  320.     public function getCreatedBy(): ?int
  321.     {
  322.         return $this->created_by;
  323.     }
  325.     public function setCreatedBy(int $created_by): self
  326.     {
  327.         $this->created_by = $created_by;
  329.         return $this;
  330.     }
  332.     public function getUpdatedBy(): ?int
  333.     {
  334.         return $this->updated_by;
  335.     }
  337.     public function setUpdatedBy(int $updated_by): self
  338.     {
  339.         $this->updated_by = $updated_by;
  341.         return $this;
  342.     }
  344.     public function getFile(): ?string
  345.     {
  346.         return $this->file;
  347.     }
  349.     public function setFile(?string $file): self
  350.     {
  351.         $this->file = $file;
  353.         return $this;
  354.     }
  356.     public function isChangepwd(): ?bool
  357.     {
  358.         return $this->changepwd;
  359.     }
  361.     public function setChangepwd(bool $changepwd): self
  362.     {
  363.         $this->changepwd = $changepwd;
  365.         return $this;
  366.     }
  368.     public function isResetpwd(): ?bool
  369.     {
  370.         return $this->resetpwd;
  371.     }
  373.     public function setResetpwd(bool $resetpwd): self
  374.     {
  375.         $this->resetpwd = $resetpwd;
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection<int, Commentaire>
  382.      */
  383.     public function getCommentaires(): Collection
  384.     {
  385.         return $this->commentaires;
  386.     }
  388.     public function addCommentaire(Commentaire $commentaire): self
  389.     {
  390.         if (!$this->commentaires->contains($commentaire)) {
  391.             $this->commentaires->add($commentaire);
  392.             $commentaire->setUser($this);
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeCommentaire(Commentaire $commentaire): self
  399.     {
  400.         if ($this->commentaires->removeElement($commentaire)) {
  401.             // set the owning side to null (unless already changed)
  402.             if ($commentaire->getUser() === $this) {
  403.                 $commentaire->setUser(null);
  404.             }
  405.         }
  407.         return $this;
  408.     }
  410.     /**
  411.      * @return Collection<int, Groupe>
  412.      */
  413.     public function getGroupes(): Collection
  414.     {
  415.         return $this->groupes;
  416.     }
  418.     public function addGroupe(Groupe $groupe): self
  419.     {
  420.         if (!$this->groupes->contains($groupe)) {
  421.             $this->groupes->add($groupe);
  422.             $groupe->setUser($this);
  423.         }
  425.         return $this;
  426.     }
  428.     public function removeGroupe(Groupe $groupe): self
  429.     {
  430.         if ($this->groupes->removeElement($groupe)) {
  431.             // set the owning side to null (unless already changed)
  432.             if ($groupe->getUser() === $this) {
  433.                 $groupe->setUser(null);
  434.             }
  435.         }
  437.         return $this;
  438.     }
  439. }