src/Entity/User.php line 23

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use App\Traits\TimeStampTrait;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  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\Validator\Constraints as Assert;
  16. #[ORM\Table(name: 'User')]
  17. #[ORM\Entity(repositoryClass: UserRepository::class)]
  18. #[ORM\HasLifecycleCallbacks]
  19. #[UniqueEntity(
  20.     fields: ['username'],
  21.     message: 'Ce nom utilisateur est déjà pris.',
  22. )]
  23. class User implements UserInterface, PasswordAuthenticatedUserInterface
  24. {
  25.     use TimeStampTrait;
  27.     #[ORM\Id]
  28.     #[ORM\GeneratedValue]
  29.     #[ORM\Column]
  30.     private ?int $id = null;
  32.     #[ORM\Column(length: 180, unique: true)]
  33.     private ?string $username = null;
  35.     /**
  36.      * @var string The hashed password
  37.      */
  38.     #[ORM\Column]
  39.     private ?string $password = null;
  41.     #[ORM\ManyToOne(inversedBy: 'users')]
  42.     private ?Role $role = null;
  44.     #[ORM\Column(length: 50, nullable: true)]
  45.     private ?string $name = null;
  47.     #[ORM\Column(length: 50, nullable: true)]
  48.     private ?string $lastname = null;
  50.     #[ORM\Column(length: 100, nullable: true)]
  51.     private ?string $code = null;
  53.     #[ORM\Column(nullable: true)]
  54.     private ?bool $status = null;
  56.     #[ORM\Column(nullable: true)]
  57.     private ?bool $reset = null;
  59.     #[ORM\Column(length: 25, nullable: true)]
  60.     private ?string $sexe = null;
  62.     #[ORM\Column(length: 25, nullable: true)]
  63.     private ?string $phone = null;
  65.     #[ORM\Column(length: 150, nullable: true)]
  66.     private ?string $picture = null;
  68.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Location::class)]
  69.     private Collection $locations;
  71.     #[ORM\ManyToOne(inversedBy: 'users')]
  72.     private ?Entreprise $entreprise = null;
  74.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'users')]
  75.     private ?self $createdBy = null;
  77.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: self::class)]
  78.     private Collection $users;
  80.     #[ORM\Column(nullable: true)]
  81.     private ?bool $notif = null;
  83.     /**
  84.      * @Assert\NotBlank()
  85.      * @Assert\Email()
  86.      */
  87.     #[ORM\Column(length: 100, nullable: true)]
  88.     private ?string $email = null;
  90.     #[ORM\Column(length: 50, nullable: true)]
  91.     private ?string $profil = null;
  93.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Country::class)]
  94.     private Collection $countries;
  96.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Log::class)]
  97.     private Collection $logs;
  99.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Template::class)]
  100.     private Collection $templates;
  102.     #[ORM\Column(nullable: true)]
  103.     private ?int $level = null;
  105.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Incident::class)]
  106.     private Collection $incidents;
  108.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: IncidentUpdate::class)]
  109.     private Collection $incidentUpdates;
  111.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Service::class)]
  112.     private Collection $services;
  114.     #[ORM\Column(length: 100, nullable: true)]
  115.     private ?string $adress = null;
  117.     #[ORM\Column(length: 50, nullable: true)]
  118.     private ?string $city = null;
  120.     #[ORM\Column(length: 50, nullable: true)]
  121.     private ?string $province = null;
  123.     #[ORM\ManyToOne(inversedBy: 'users')]
  124.     private ?Country $country = null;
  126.     #[ORM\ManyToMany(targetEntity: Announcement::class, mappedBy: 'user')]
  127.     private Collection $announcements;
  129.     #[ORM\Column(length: 25, nullable: true)]
  130.     private ?string $mode = null;
  132.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  133.     private ?\DateTimeInterface $lastAction = null;
  135.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Reservation::class)]
  136.     private Collection $reservations;
  138.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserEntreprise::class)]
  139.     private Collection $userEntreprises;
  141.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Entreprise::class)]
  142.     private Collection $entreprises;
  145.     public function __construct()
  146.     {
  147.         $this->locations = new ArrayCollection();
  148.         $this->users = new ArrayCollection();
  149.         $this->countries = new ArrayCollection();
  150.         $this->logs = new ArrayCollection();
  151.         $this->templates = new ArrayCollection();
  152.         $this->incidents = new ArrayCollection();
  153.         $this->incidentUpdates = new ArrayCollection();
  154.         $this->services = new ArrayCollection();
  155.         $this->announcements = new ArrayCollection();
  156.         $this->reservations = new ArrayCollection();
  157.         $this->userEntreprises = new ArrayCollection();
  158.         $this->entreprises = new ArrayCollection();
  159.     }
  161.     public function getId(): ?int
  162.     {
  163.         return $this->id;
  164.     }
  166.     public function getUsername(): ?string
  167.     {
  168.         return $this->username;
  169.     }
  171.     public function setUsername(string $username): self
  172.     {
  173.         $this->username = $username;
  175.         return $this;
  176.     }
  178.     /**
  179.      * A visual identifier that represents this user.
  180.      *
  181.      * @see UserInterface
  182.      */
  183.     public function getUserIdentifier(): string
  184.     {
  185.         return (string) $this->username;
  186.     }
  188.     /**
  189.      * @see UserInterface
  190.      */
  191.     public function getRoles(): array
  192.     {
  193.         $rs = [];
  195.         $rs[] = 'ROLE_ADMIN';
  197.         if ($this->role != null) {
  198.             foreach ($this->role->getPrivilege() as $role)
  199.             {
  200.                 $rs[] = 'ROLE_'.$role->getlibelle();
  201.             }
  202.         }
  204.         return $rs;
  205.     }
  207.     /**
  208.      * @see PasswordAuthenticatedUserInterface
  209.      */
  210.     public function getPassword(): string
  211.     {
  212.         return $this->password;
  213.     }
  215.     public function setPassword(string $password): self
  216.     {
  217.         $this->password = $password;
  219.         return $this;
  220.     }
  222.     /**
  223.      * @see UserInterface
  224.      */
  225.     public function eraseCredentials()
  226.     {
  227.         // If you store any temporary, sensitive data on the user, clear it here
  228.         // $this->plainPassword = null;
  229.     }
  231.     public function getRole(): ?Role
  232.     {
  233.         return $this->role;
  234.     }
  236.     public function setRole(?Role $role): self
  237.     {
  238.         $this->role = $role;
  240.         return $this;
  241.     }
  243.     public function getName(): ?string
  244.     {
  245.         return $this->name;
  246.     }
  248.     public function setName(?string $name): self
  249.     {
  250.         $this->name = $name;
  252.         return $this;
  253.     }
  255.     public function getLastname(): ?string
  256.     {
  257.         return $this->lastname;
  258.     }
  260.     public function setLastname(?string $lastname): self
  261.     {
  262.         $this->lastname = $lastname;
  264.         return $this;
  265.     }
  267.     public function getCode(): ?string
  268.     {
  269.         return $this->code;
  270.     }
  272.     public function setCode(?string $code): self
  273.     {
  274.         $this->code = $code;
  276.         return $this;
  277.     }
  279.     public function isStatus(): ?bool
  280.     {
  281.         return $this->status;
  282.     }
  284.     public function setStatus(?bool $status): self
  285.     {
  286.         $this->status = $status;
  288.         return $this;
  289.     }
  291.     public function isReset(): ?bool
  292.     {
  293.         return $this->reset;
  294.     }
  296.     public function setReset(?bool $reset): self
  297.     {
  298.         $this->reset = $reset;
  300.         return $this;
  301.     }
  303.     public function __toString(): string
  304.     {
  305.         return $this->name . ' ' . $this->lastname;
  306.     }
  308.     public function getSexe(): ?string
  309.     {
  310.         return $this->sexe;
  311.     }
  313.     public function setSexe(?string $sexe): static
  314.     {
  315.         $this->sexe = $sexe;
  317.         return $this;
  318.     }
  320.     public function getPhone(): ?string
  321.     {
  322.         return $this->phone;
  323.     }
  325.     public function setPhone(?string $phone): static
  326.     {
  327.         $this->phone = $phone;
  329.         return $this;
  330.     }
  332.     public function getPicture(): ?string
  333.     {
  334.         return $this->picture;
  335.     }
  337.     public function setPicture(?string $picture): static
  338.     {
  339.         $this->picture = $picture;
  341.         return $this;
  342.     }
  344.     /**
  345.      * @return Collection<int, Location>
  346.      */
  347.     public function getLocations(): Collection
  348.     {
  349.         return $this->locations;
  350.     }
  352.     public function addLocation(Location $location): static
  353.     {
  354.         if (!$this->locations->contains($location)) {
  355.             $this->locations->add($location);
  356.             $location->setCreatedBy($this);
  357.         }
  359.         return $this;
  360.     }
  362.     public function removeLocation(Location $location): static
  363.     {
  364.         if ($this->locations->removeElement($location)) {
  365.             // set the owning side to null (unless already changed)
  366.             if ($location->getCreatedBy() === $this) {
  367.                 $location->setCreatedBy(null);
  368.             }
  369.         }
  371.         return $this;
  372.     }
  374.     public function getEntreprise(): ?Entreprise
  375.     {
  376.         return $this->entreprise;
  377.     }
  379.     public function setEntreprise(?Entreprise $entreprise): static
  380.     {
  381.         $this->entreprise = $entreprise;
  383.         return $this;
  384.     }
  386.     public function getCreatedBy(): ?self
  387.     {
  388.         return $this->createdBy;
  389.     }
  391.     public function setCreatedBy(?self $createdBy): static
  392.     {
  393.         $this->createdBy = $createdBy;
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection<int, self>
  400.      */
  401.     public function getUsers(): Collection
  402.     {
  403.         return $this->users;
  404.     }
  406.     public function addUser(self $user): static
  407.     {
  408.         if (!$this->users->contains($user)) {
  409.             $this->users->add($user);
  410.             $user->setCreatedBy($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeUser(self $user): static
  417.     {
  418.         if ($this->users->removeElement($user)) {
  419.             // set the owning side to null (unless already changed)
  420.             if ($user->getCreatedBy() === $this) {
  421.                 $user->setCreatedBy(null);
  422.             }
  423.         }
  425.         return $this;
  426.     }
  428.     public function isNotif(): ?bool
  429.     {
  430.         return $this->notif;
  431.     }
  433.     public function setNotif(?bool $notif): static
  434.     {
  435.         $this->notif = $notif;
  437.         return $this;
  438.     }
  440.     public function getEmail(): ?string
  441.     {
  442.         return $this->email;
  443.     }
  445.     public function setEmail(?string $email): static
  446.     {
  447.         $this->email = $email;
  449.         return $this;
  450.     }
  452.     public function getProfil(): ?string
  453.     {
  454.         return $this->profil;
  455.     }
  457.     public function setProfil(?string $profil): static
  458.     {
  459.         $this->profil = $profil;
  461.         return $this;
  462.     }
  464.     /**
  465.      * @return Collection<int, Country>
  466.      */
  467.     public function getCountries(): Collection
  468.     {
  469.         return $this->countries;
  470.     }
  472.     public function addCountry(Country $country): static
  473.     {
  474.         if (!$this->countries->contains($country)) {
  475.             $this->countries->add($country);
  476.             $country->setCreatedBy($this);
  477.         }
  479.         return $this;
  480.     }
  482.     public function removeCountry(Country $country): static
  483.     {
  484.         if ($this->countries->removeElement($country)) {
  485.             // set the owning side to null (unless already changed)
  486.             if ($country->getCreatedBy() === $this) {
  487.                 $country->setCreatedBy(null);
  488.             }
  489.         }
  491.         return $this;
  492.     }
  494.     /**
  495.      * @return Collection<int, Log>
  496.      */
  497.     public function getLogs(): Collection
  498.     {
  499.         return $this->logs;
  500.     }
  502.     public function addLog(Log $log): static
  503.     {
  504.         if (!$this->logs->contains($log)) {
  505.             $this->logs->add($log);
  506.             $log->setCreatedBy($this);
  507.         }
  509.         return $this;
  510.     }
  512.     public function removeLog(Log $log): static
  513.     {
  514.         if ($this->logs->removeElement($log)) {
  515.             // set the owning side to null (unless already changed)
  516.             if ($log->getCreatedBy() === $this) {
  517.                 $log->setCreatedBy(null);
  518.             }
  519.         }
  521.         return $this;
  522.     }
  524.     /**
  525.      * @return Collection<int, Template>
  526.      */
  527.     public function getTemplates(): Collection
  528.     {
  529.         return $this->templates;
  530.     }
  532.     public function addTemplate(Template $template): static
  533.     {
  534.         if (!$this->templates->contains($template)) {
  535.             $this->templates->add($template);
  536.             $template->setCreatedBy($this);
  537.         }
  539.         return $this;
  540.     }
  542.     public function removeTemplate(Template $template): static
  543.     {
  544.         if ($this->templates->removeElement($template)) {
  545.             // set the owning side to null (unless already changed)
  546.             if ($template->getCreatedBy() === $this) {
  547.                 $template->setCreatedBy(null);
  548.             }
  549.         }
  551.         return $this;
  552.     }
  554.     public function getLevel(): ?int
  555.     {
  556.         return $this->level;
  557.     }
  559.     public function setLevel(?int $level): static
  560.     {
  561.         $this->level = $level;
  563.         return $this;
  564.     }
  566.     /**
  567.      * @return Collection<int, Incident>
  568.      */
  569.     public function getIncidents(): Collection
  570.     {
  571.         return $this->incidents;
  572.     }
  574.     public function addIncident(Incident $incident): static
  575.     {
  576.         if (!$this->incidents->contains($incident)) {
  577.             $this->incidents->add($incident);
  578.             $incident->setCreatedBy($this);
  579.         }
  581.         return $this;
  582.     }
  584.     public function removeIncident(Incident $incident): static
  585.     {
  586.         if ($this->incidents->removeElement($incident)) {
  587.             // set the owning side to null (unless already changed)
  588.             if ($incident->getCreatedBy() === $this) {
  589.                 $incident->setCreatedBy(null);
  590.             }
  591.         }
  593.         return $this;
  594.     }
  596.     /**
  597.      * @return Collection<int, IncidentUpdate>
  598.      */
  599.     public function getIncidentUpdates(): Collection
  600.     {
  601.         return $this->incidentUpdates;
  602.     }
  604.     public function addIncidentUpdate(IncidentUpdate $incidentUpdate): static
  605.     {
  606.         if (!$this->incidentUpdates->contains($incidentUpdate)) {
  607.             $this->incidentUpdates->add($incidentUpdate);
  608.             $incidentUpdate->setCreatedBy($this);
  609.         }
  611.         return $this;
  612.     }
  614.     public function removeIncidentUpdate(IncidentUpdate $incidentUpdate): static
  615.     {
  616.         if ($this->incidentUpdates->removeElement($incidentUpdate)) {
  617.             // set the owning side to null (unless already changed)
  618.             if ($incidentUpdate->getCreatedBy() === $this) {
  619.                 $incidentUpdate->setCreatedBy(null);
  620.             }
  621.         }
  623.         return $this;
  624.     }
  626.     /**
  627.      * @return Collection<int, Service>
  628.      */
  629.     public function getServices(): Collection
  630.     {
  631.         return $this->services;
  632.     }
  634.     public function addService(Service $service): static
  635.     {
  636.         if (!$this->services->contains($service)) {
  637.             $this->services->add($service);
  638.             $service->setCreatedBy($this);
  639.         }
  641.         return $this;
  642.     }
  644.     public function removeService(Service $service): static
  645.     {
  646.         if ($this->services->removeElement($service)) {
  647.             // set the owning side to null (unless already changed)
  648.             if ($service->getCreatedBy() === $this) {
  649.                 $service->setCreatedBy(null);
  650.             }
  651.         }
  653.         return $this;
  654.     }
  656.     public function getAdress(): ?string
  657.     {
  658.         return $this->adress;
  659.     }
  661.     public function setAdress(?string $adress): static
  662.     {
  663.         $this->adress = $adress;
  665.         return $this;
  666.     }
  668.     public function getCity(): ?string
  669.     {
  670.         return $this->city;
  671.     }
  673.     public function setCity(?string $city): static
  674.     {
  675.         $this->city = $city;
  677.         return $this;
  678.     }
  680.     public function getProvince(): ?string
  681.     {
  682.         return $this->province;
  683.     }
  685.     public function setProvince(?string $province): static
  686.     {
  687.         $this->province = $province;
  689.         return $this;
  690.     }
  692.     public function getCountry(): ?Country
  693.     {
  694.         return $this->country;
  695.     }
  697.     public function setCountry(?Country $country): static
  698.     {
  699.         $this->country = $country;
  701.         return $this;
  702.     }
  704.     /**
  705.      * @return Collection<int, Announcement>
  706.      */
  707.     public function getAnnouncements(): Collection
  708.     {
  709.         return $this->announcements;
  710.     }
  712.     public function addAnnouncement(Announcement $announcement): static
  713.     {
  714.         if (!$this->announcements->contains($announcement)) {
  715.             $this->announcements->add($announcement);
  716.             $announcement->addUser($this);
  717.         }
  719.         return $this;
  720.     }
  722.     public function removeAnnouncement(Announcement $announcement): static
  723.     {
  724.         if ($this->announcements->removeElement($announcement)) {
  725.             $announcement->removeUser($this);
  726.         }
  728.         return $this;
  729.     }
  731.     public function getMode(): ?string
  732.     {
  733.         return $this->mode;
  734.     }
  736.     public function setMode(?string $mode): static
  737.     {
  738.         $this->mode = $mode;
  740.         return $this;
  741.     }
  743.     public function getLastAction(): ?\DateTimeInterface
  744.     {
  745.         return $this->lastAction;
  746.     }
  748.     public function setLastAction(?\DateTimeInterface $lastAction): static
  749.     {
  750.         $this->lastAction = $lastAction;
  752.         return $this;
  753.     }
  755.     /**
  756.      * @return Collection<int, Reservation>
  757.      */
  758.     public function getReservations(): Collection
  759.     {
  760.         return $this->reservations;
  761.     }
  763.     public function addReservation(Reservation $reservation): static
  764.     {
  765.         if (!$this->reservations->contains($reservation)) {
  766.             $this->reservations->add($reservation);
  767.             $reservation->setCreatedBy($this);
  768.         }
  770.         return $this;
  771.     }
  773.     public function removeReservation(Reservation $reservation): static
  774.     {
  775.         if ($this->reservations->removeElement($reservation)) {
  776.             // set the owning side to null (unless already changed)
  777.             if ($reservation->getCreatedBy() === $this) {
  778.                 $reservation->setCreatedBy(null);
  779.             }
  780.         }
  782.         return $this;
  783.     }
  785.     /**
  786.      * @return Collection<int, UserEntreprise>
  787.      */
  788.     public function getUserEntreprises(): Collection
  789.     {
  790.         return $this->userEntreprises;
  791.     }
  793.     public function addUserEntreprise(UserEntreprise $userEntreprise): static
  794.     {
  795.         if (!$this->userEntreprises->contains($userEntreprise)) {
  796.             $this->userEntreprises->add($userEntreprise);
  797.             $userEntreprise->setUser($this);
  798.         }
  800.         return $this;
  801.     }
  803.     public function removeUserEntreprise(UserEntreprise $userEntreprise): static
  804.     {
  805.         if ($this->userEntreprises->removeElement($userEntreprise)) {
  806.             // set the owning side to null (unless already changed)
  807.             if ($userEntreprise->getUser() === $this) {
  808.                 $userEntreprise->setUser(null);
  809.             }
  810.         }
  812.         return $this;
  813.     }
  815.     /**
  816.      * @return Collection<int, Entreprise>
  817.      */
  818.     public function getEntreprises(): Collection
  819.     {
  820.         return $this->entreprises;
  821.     }
  823.     public function addEntreprise(Entreprise $entreprise): static
  824.     {
  825.         if (!$this->entreprises->contains($entreprise)) {
  826.             $this->entreprises->add($entreprise);
  827.             $entreprise->setOwner($this);
  828.         }
  830.         return $this;
  831.     }
  833.     public function removeEntreprise(Entreprise $entreprise): static
  834.     {
  835.         if ($this->entreprises->removeElement($entreprise)) {
  836.             // set the owning side to null (unless already changed)
  837.             if ($entreprise->getOwner() === $this) {
  838.                 $entreprise->setOwner(null);
  839.             }
  840.         }
  842.         return $this;
  843.     }
  844. }