src/Entity/User.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use DateTimeInterface;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  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 Symfony\Component\Validator\Constraints as Assert;
  15. /**
  16.  * @ORM\Entity(repositoryClass=UserRepository::class)
  17.  * @UniqueEntity("username")
  18.  * @UniqueEntity("email", ignoreNull=true)
  19.  */
  20. class User implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     /**
  23.      * @ORM\Id
  24.      * @ORM\GeneratedValue
  25.      * @ORM\Column(type="integer")
  26.      */
  27.     private ?int $id = null;
  29.     /**
  30.      * @ORM\Column(type="string", length=180, unique=true)
  31.      */
  32.     private ?string $username = null;
  34.     /**
  35.      * @ORM\Column(type="json")
  36.      * @Assert\NotNull()
  37.      */
  38.     private array $roles = [];
  40.     /**
  41.      * @var string|null The hashed password
  42.      * @ORM\Column(type="string")
  43.      */
  44.     private ?string $password;
  46.     /**
  47.      * @Assert\NotNull(groups={"create"})
  48.      * @Assert\Length(min=8, max=4096)
  49.      */
  50.     private ?string $rawPassword = null;
  52.     /**
  53.      * @ORM\Column(type="string", length=255, nullable=true)
  54.      * @Assert\NotNull(groups={"porteur", "drci", "girci", "other"})
  55.      * @Assert\Blank(groups={"expert"})
  56.      */
  57.     private ?string $email;
  59.     /**
  60.      * @ORM\Column(type="string", length=10, nullable=true)
  61.      */
  62.     private ?string $title;
  64.     /**
  65.      * @ORM\Column(type="string", length=10, nullable=true)
  66.      * @Assert\NotNull(groups={"porteur"})
  67.      */
  68.     private ?string $civility;
  70.     /**
  71.      * @ORM\Column(type="string", length=255, nullable=true)
  72.      * @Assert\NotNull(groups={"porteur"})
  73.      */
  74.     private ?string $name;
  76.     /**
  77.      * @ORM\Column(type="string", length=255, nullable=true)
  78.      * @Assert\NotNull(groups={"porteur"})
  79.      */
  80.     private ?string $firstname;
  82.     /**
  83.      * @ORM\Column(type="string", length=25, nullable=true)
  84.      * @Assert\NotNull(groups={"porteur"})
  85.      */
  86.     private ?string $phone;
  88.     /**
  89.      * @ORM\ManyToOne(targetEntity=Drci::class)
  90.      * @Assert\NotNull(groups={"porteur", "drci"})
  91.      */
  92.     private ?Drci $drci;
  94.     /**
  95.      * @ORM\ManyToOne(targetEntity=Girci::class)
  96.      * @Assert\NotNull(groups={"girci"})
  97.      */
  98.     private ?Girci $girci;
  100.     /**
  101.      * @ORM\Column(type="string", length=255, nullable=true)
  102.      * @Assert\NotNull(groups={"porteur"})
  103.      */
  104.     private ?string $service;
  106.     /**
  107.      * @ORM\Column(type="string", length=255, nullable=true)
  108.      * @Assert\NotNull(groups={"porteur"})
  109.      */
  110.     private ?string $street;
  112.     /**
  113.      * @ORM\Column(type="string", length=10, nullable=true)
  114.      * @Assert\NotNull(groups={"porteur"})
  115.      */
  116.     private ?string $postalCode;
  118.     /**
  119.      * @ORM\Column(type="string", length=255, nullable=true)
  120.      * @Assert\NotNull(groups={"porteur"})
  121.      */
  122.     private ?string $city;
  124.     /**
  125.      * @ORM\OneToMany(targetEntity=Project::class, mappedBy="author")
  126.      */
  127.     private $projects;
  129.     /**
  130.      * @ORM\Column(type="datetime", nullable=true)
  131.      */
  132.     private $lastLoginDate;
  134.     /**
  135.      * @ORM\Column(type="datetime")
  136.      */
  137.     private $creationDate;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity=UserProject::class, mappedBy="user")
  141.      */
  142.     private $userProjects;
  144.     /**
  145.      * @ORM\Column(type="boolean")
  146.      */
  147.     private $enabled;
  149.     /**
  150.      * @ORM\Column(type="boolean")
  151.      */
  152.     private $isVerified = false;
  154.     public function __construct()
  155.     {
  156.         $this->projects = new ArrayCollection();
  157.         $this->userProjects = new ArrayCollection();
  158.         $this->enabled = false;
  159.     }
  161.     public function getId(): ?int
  162.     {
  163.         return $this->id;
  164.     }
  166.     /**
  167.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  168.      */
  169.     public function getUsername(): ?string
  170.     {
  171.         return $this->username;
  172.     }
  174.     public function setUsername(string $username): self
  175.     {
  176.         $this->username = $username;
  178.         return $this;
  179.     }
  181.     /**
  182.      * A visual identifier that represents this user.
  183.      *
  184.      * @see UserInterface
  185.      */
  186.     public function getUserIdentifier(): string
  187.     {
  188.         return $this->username;
  189.     }
  191.     /**
  192.      * @see UserInterface
  193.      */
  194.     public function getRoles(): array
  195.     {
  196.         $roles = $this->roles;
  197.         // guarantee every user at least has ROLE_USER
  198.         $roles[] = 'ROLE_USER';
  200.         return array_unique($roles);
  201.     }
  203.     public function setRoles(array $roles): self
  204.     {
  205.         $this->roles = $roles;
  207.         return $this;
  208.     }
  210.     public function addRole($role): self
  211.     {
  212.         $role = strtoupper($role);
  213.         if ($role === 'ROLE_USER') {
  214.             return $this;
  215.         }
  216.         if (!in_array($role, $this->roles, true)) {
  217.             $this->roles[] = $role;
  218.         }
  219.         return $this;
  220.     }
  222.     public function removeRole($role): self
  223.     {
  224.         if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  225.             unset($this->roles[$key]);
  226.             $this->roles = array_values($this->roles);
  227.         }
  228.         return $this;
  229.     }
  231.     public function hasRole(string $role)
  232.     {
  233.         if (in_array($role, $this->roles, true)) {
  234.             return true;
  235.         }
  236.         return false;
  237.     }
  239.     /**
  240.      * @see PasswordAuthenticatedUserInterface
  241.      */
  242.     public function getPassword(): string
  243.     {
  244.         return $this->password;
  245.     }
  247.     public function setPassword(string $password): self
  248.     {
  249.         $this->password = $password;
  251.         return $this;
  252.     }
  254.     public function getRawPassword(): ?string
  255.     {
  256.         return $this->rawPassword;
  257.     }
  259.     public function setRawPassword(string $rawPassword): self
  260.     {
  261.         $this->rawPassword = $rawPassword;
  262.         $this->password = null;
  264.         return $this;
  265.     }
  267.     /**
  268.      * Returning a salt is only needed, if you are not using a modern
  269.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  270.      *
  271.      * @see UserInterface
  272.      */
  273.     public function getSalt(): ?string
  274.     {
  275.         return null;
  276.     }
  278.     /**
  279.      * @see UserInterface
  280.      */
  281.     public function eraseCredentials()
  282.     {
  283.         // If you store any temporary, sensitive data on the user, clear it here
  284.          $this->rawPassword = null;
  285.     }
  287.     public function getEmail(): ?string
  288.     {
  289.         return $this->email;
  290.     }
  292.     public function setEmail(?string $email): self
  293.     {
  294.         $this->email = $email;
  296.         return $this;
  297.     }
  299.     public function getTitle(): ?string
  300.     {
  301.         return $this->title;
  302.     }
  304.     public function setTitle(?string $title): self
  305.     {
  306.         $this->title = $title;
  308.         return $this;
  309.     }
  311.     public function getCivility(): ?string
  312.     {
  313.         return $this->civility;
  314.     }
  316.     public function setCivility(?string $civility): self
  317.     {
  318.         $this->civility = $civility;
  320.         return $this;
  321.     }
  323.     public function getName(): ?string
  324.     {
  325.         return $this->name;
  326.     }
  328.     public function setName(?string $name): self
  329.     {
  330.         $this->name = $name;
  332.         return $this;
  333.     }
  335.     public function getFirstname(): ?string
  336.     {
  337.         return $this->firstname;
  338.     }
  340.     public function setFirstname(?string $firstname): self
  341.     {
  342.         $this->firstname = $firstname;
  344.         return $this;
  345.     }
  347.     public function getPhone(): ?string
  348.     {
  349.         return $this->phone;
  350.     }
  352.     public function setPhone(?string $phone): self
  353.     {
  354.         $this->phone = $phone;
  356.         return $this;
  357.     }
  359.     public function getDrci(): ?Drci
  360.     {
  361.         return $this->drci;
  362.     }
  364.     public function setDrci(?Drci $drci): self
  365.     {
  366.         $this->drci = $drci;
  368.         return $this;
  369.     }
  371.     public function getGirci(): ?Girci
  372.     {
  373.         return $this->girci;
  374.     }
  376.     public function setGirci(?Girci $girci): self
  377.     {
  378.         $this->girci = $girci;
  380.         return $this;
  381.     }
  383.     public function getService(): ?string
  384.     {
  385.         return $this->service;
  386.     }
  388.     public function setService(?string $service): self
  389.     {
  390.         $this->service = $service;
  392.         return $this;
  393.     }
  395.     public function getStreet(): ?string
  396.     {
  397.         return $this->street;
  398.     }
  400.     public function setStreet(?string $street): self
  401.     {
  402.         $this->street = $street;
  404.         return $this;
  405.     }
  407.     public function getPostalCode(): ?string
  408.     {
  409.         return $this->postalCode;
  410.     }
  412.     public function setPostalCode(?string $postalCode): self
  413.     {
  414.         $this->postalCode = $postalCode;
  416.         return $this;
  417.     }
  419.     public function getCity(): ?string
  420.     {
  421.         return $this->city;
  422.     }
  424.     public function setCity(?string $city): self
  425.     {
  426.         $this->city = $city;
  428.         return $this;
  429.     }
  431.     /**
  432.      * @return Collection|Project[]
  433.      */
  434.     public function getProjects(): Collection
  435.     {
  436.         return $this->projects;
  437.     }
  439.     public function addProject(Project $project): self
  440.     {
  441.         if (!$this->projects->contains($project)) {
  442.             $this->projects[] = $project;
  443.             $project->setAuthor($this);
  444.         }
  446.         return $this;
  447.     }
  449.     public function removeProject(Project $project): self
  450.     {
  451.         if ($this->projects->removeElement($project)) {
  452.             // set the owning side to null (unless already changed)
  453.             if ($project->getAuthor() === $this) {
  454.                 $project->setAuthor(null);
  455.             }
  456.         }
  458.         return $this;
  459.     }
  461.     public function getLastLoginDate(): ?DateTimeInterface
  462.     {
  463.         return $this->lastLoginDate;
  464.     }
  466.     public function setLastLoginDate(?DateTimeInterface $lastLoginDate): self
  467.     {
  468.         $this->lastLoginDate = $lastLoginDate;
  470.         return $this;
  471.     }
  473.     public function getCreationDate(): ?DateTimeInterface
  474.     {
  475.         return $this->creationDate;
  476.     }
  478.     public function setCreationDate(DateTimeInterface $creationDate): self
  479.     {
  480.         $this->creationDate = $creationDate;
  482.         return $this;
  483.     }
  485.     /**
  486.      * @return Collection|UserProject[]
  487.      */
  488.     public function getUserProjects(): Collection
  489.     {
  490.         return $this->userProjects;
  491.     }
  493.     public function addUserProject(UserProject $userProject) {
  494.         if (!$this->userProjects->contains($userProject)) {
  495.             $this->userProjects[] = $userProject;
  496.             $userProject->setUser($this);
  497.         }
  499.         return $this;
  500.     }
  502.     public function removeUserProject(UserProject $userproject): self
  503.     {
  504.         if ($this->userProjects->removeElement($userproject)) {
  505.             // set the owning side to null (unless already changed)
  506.             if ($userproject->getUser() === $this) {
  507.                 $userproject->setUser(null);
  508.             }
  509.         }
  511.         return $this;
  512.     }
  514.     public function isEnabled(): ?bool
  515.     {
  516.         return $this->enabled;
  517.     }
  519.     public function setEnabled(bool $enabled): self
  520.     {
  521.         $this->enabled = $enabled;
  523.         return $this;
  524.     }
  526.     public function isVerified(): bool
  527.     {
  528.         return $this->isVerified;
  529.     }
  531.     public function setIsVerified(bool $isVerified): self
  532.     {
  533.         $this->isVerified = $isVerified;
  535.         return $this;
  536.     }
  538. }