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\Column(type: Types::JSON, nullable: true)]
  136.     private ?array $reportWidgets = null;
  138.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Reservation::class)]
  139.     private Collection $reservations;
  141.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserEntreprise::class)]
  142.     private Collection $userEntreprises;
  144.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Entreprise::class)]
  145.     private Collection $entreprises;
  148.     public function __construct()
  149.     {
  150.         $this->locations = new ArrayCollection();
  151.         $this->users = new ArrayCollection();
  152.         $this->countries = new ArrayCollection();
  153.         $this->logs = new ArrayCollection();
  154.         $this->templates = new ArrayCollection();
  155.         $this->incidents = new ArrayCollection();
  156.         $this->incidentUpdates = new ArrayCollection();
  157.         $this->services = new ArrayCollection();
  158.         $this->announcements = new ArrayCollection();
  159.         $this->reservations = new ArrayCollection();
  160.         $this->userEntreprises = new ArrayCollection();
  161.         $this->entreprises = new ArrayCollection();
  162.     }
  164.     public function getId(): ?int
  165.     {
  166.         return $this->id;
  167.     }
  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 (string) $this->username;
  189.     }
  191.     /**
  192.      * @see UserInterface
  193.      */
  194.     public function getRoles(): array
  195.     {
  196.         $rs = [];
  198.         $rs[] = 'ROLE_ADMIN';
  200.         if ($this->role != null) {
  201.             foreach ($this->role->getPrivilege() as $role)
  202.             {
  203.                 $rs[] = 'ROLE_'.$role->getlibelle();
  204.             }
  205.         }
  207.         return $rs;
  208.     }
  210.     /**
  211.      * @see PasswordAuthenticatedUserInterface
  212.      */
  213.     public function getPassword(): string
  214.     {
  215.         return $this->password;
  216.     }
  218.     public function setPassword(string $password): self
  219.     {
  220.         $this->password = $password;
  222.         return $this;
  223.     }
  225.     /**
  226.      * @see UserInterface
  227.      */
  228.     public function eraseCredentials()
  229.     {
  230.         // If you store any temporary, sensitive data on the user, clear it here
  231.         // $this->plainPassword = null;
  232.     }
  234.     public function getRole(): ?Role
  235.     {
  236.         return $this->role;
  237.     }
  239.     public function setRole(?Role $role): self
  240.     {
  241.         $this->role = $role;
  243.         return $this;
  244.     }
  246.     public function getName(): ?string
  247.     {
  248.         return $this->name;
  249.     }
  251.     public function setName(?string $name): self
  252.     {
  253.         $this->name = $name;
  255.         return $this;
  256.     }
  258.     public function getLastname(): ?string
  259.     {
  260.         return $this->lastname;
  261.     }
  263.     public function setLastname(?string $lastname): self
  264.     {
  265.         $this->lastname = $lastname;
  267.         return $this;
  268.     }
  270.     public function getCode(): ?string
  271.     {
  272.         return $this->code;
  273.     }
  275.     public function setCode(?string $code): self
  276.     {
  277.         $this->code = $code;
  279.         return $this;
  280.     }
  282.     public function isStatus(): ?bool
  283.     {
  284.         return $this->status;
  285.     }
  287.     public function setStatus(?bool $status): self
  288.     {
  289.         $this->status = $status;
  291.         return $this;
  292.     }
  294.     public function isReset(): ?bool
  295.     {
  296.         return $this->reset;
  297.     }
  299.     public function setReset(?bool $reset): self
  300.     {
  301.         $this->reset = $reset;
  303.         return $this;
  304.     }
  306.     public function __toString(): string
  307.     {
  308.         return $this->name . ' ' . $this->lastname;
  309.     }
  311.     public function getSexe(): ?string
  312.     {
  313.         return $this->sexe;
  314.     }
  316.     public function setSexe(?string $sexe): static
  317.     {
  318.         $this->sexe = $sexe;
  320.         return $this;
  321.     }
  323.     public function getPhone(): ?string
  324.     {
  325.         return $this->phone;
  326.     }
  328.     public function setPhone(?string $phone): static
  329.     {
  330.         $this->phone = $phone;
  332.         return $this;
  333.     }
  335.     public function getPicture(): ?string
  336.     {
  337.         return $this->picture;
  338.     }
  340.     public function setPicture(?string $picture): static
  341.     {
  342.         $this->picture = $picture;
  344.         return $this;
  345.     }
  347.     /**
  348.      * @return Collection<int, Location>
  349.      */
  350.     public function getLocations(): Collection
  351.     {
  352.         return $this->locations;
  353.     }
  355.     public function addLocation(Location $location): static
  356.     {
  357.         if (!$this->locations->contains($location)) {
  358.             $this->locations->add($location);
  359.             $location->setCreatedBy($this);
  360.         }
  362.         return $this;
  363.     }
  365.     public function removeLocation(Location $location): static
  366.     {
  367.         if ($this->locations->removeElement($location)) {
  368.             // set the owning side to null (unless already changed)
  369.             if ($location->getCreatedBy() === $this) {
  370.                 $location->setCreatedBy(null);
  371.             }
  372.         }
  374.         return $this;
  375.     }
  377.     public function getEntreprise(): ?Entreprise
  378.     {
  379.         return $this->entreprise;
  380.     }
  382.     public function setEntreprise(?Entreprise $entreprise): static
  383.     {
  384.         $this->entreprise = $entreprise;
  386.         return $this;
  387.     }
  389.     public function getCreatedBy(): ?self
  390.     {
  391.         return $this->createdBy;
  392.     }
  394.     public function setCreatedBy(?self $createdBy): static
  395.     {
  396.         $this->createdBy = $createdBy;
  398.         return $this;
  399.     }
  401.     /**
  402.      * @return Collection<int, self>
  403.      */
  404.     public function getUsers(): Collection
  405.     {
  406.         return $this->users;
  407.     }
  409.     public function addUser(self $user): static
  410.     {
  411.         if (!$this->users->contains($user)) {
  412.             $this->users->add($user);
  413.             $user->setCreatedBy($this);
  414.         }
  416.         return $this;
  417.     }
  419.     public function removeUser(self $user): static
  420.     {
  421.         if ($this->users->removeElement($user)) {
  422.             // set the owning side to null (unless already changed)
  423.             if ($user->getCreatedBy() === $this) {
  424.                 $user->setCreatedBy(null);
  425.             }
  426.         }
  428.         return $this;
  429.     }
  431.     public function isNotif(): ?bool
  432.     {
  433.         return $this->notif;
  434.     }
  436.     public function setNotif(?bool $notif): static
  437.     {
  438.         $this->notif = $notif;
  440.         return $this;
  441.     }
  443.     public function getEmail(): ?string
  444.     {
  445.         return $this->email;
  446.     }
  448.     public function setEmail(?string $email): static
  449.     {
  450.         $this->email = $email;
  452.         return $this;
  453.     }
  455.     public function getProfil(): ?string
  456.     {
  457.         return $this->profil;
  458.     }
  460.     public function setProfil(?string $profil): static
  461.     {
  462.         $this->profil = $profil;
  464.         return $this;
  465.     }
  467.     /**
  468.      * @return Collection<int, Country>
  469.      */
  470.     public function getCountries(): Collection
  471.     {
  472.         return $this->countries;
  473.     }
  475.     public function addCountry(Country $country): static
  476.     {
  477.         if (!$this->countries->contains($country)) {
  478.             $this->countries->add($country);
  479.             $country->setCreatedBy($this);
  480.         }
  482.         return $this;
  483.     }
  485.     public function removeCountry(Country $country): static
  486.     {
  487.         if ($this->countries->removeElement($country)) {
  488.             // set the owning side to null (unless already changed)
  489.             if ($country->getCreatedBy() === $this) {
  490.                 $country->setCreatedBy(null);
  491.             }
  492.         }
  494.         return $this;
  495.     }
  497.     /**
  498.      * @return Collection<int, Log>
  499.      */
  500.     public function getLogs(): Collection
  501.     {
  502.         return $this->logs;
  503.     }
  505.     public function addLog(Log $log): static
  506.     {
  507.         if (!$this->logs->contains($log)) {
  508.             $this->logs->add($log);
  509.             $log->setCreatedBy($this);
  510.         }
  512.         return $this;
  513.     }
  515.     public function removeLog(Log $log): static
  516.     {
  517.         if ($this->logs->removeElement($log)) {
  518.             // set the owning side to null (unless already changed)
  519.             if ($log->getCreatedBy() === $this) {
  520.                 $log->setCreatedBy(null);
  521.             }
  522.         }
  524.         return $this;
  525.     }
  527.     /**
  528.      * @return Collection<int, Template>
  529.      */
  530.     public function getTemplates(): Collection
  531.     {
  532.         return $this->templates;
  533.     }
  535.     public function addTemplate(Template $template): static
  536.     {
  537.         if (!$this->templates->contains($template)) {
  538.             $this->templates->add($template);
  539.             $template->setCreatedBy($this);
  540.         }
  542.         return $this;
  543.     }
  545.     public function removeTemplate(Template $template): static
  546.     {
  547.         if ($this->templates->removeElement($template)) {
  548.             // set the owning side to null (unless already changed)
  549.             if ($template->getCreatedBy() === $this) {
  550.                 $template->setCreatedBy(null);
  551.             }
  552.         }
  554.         return $this;
  555.     }
  557.     public function getLevel(): ?int
  558.     {
  559.         return $this->level;
  560.     }
  562.     public function setLevel(?int $level): static
  563.     {
  564.         $this->level = $level;
  566.         return $this;
  567.     }
  569.     /**
  570.      * @return Collection<int, Incident>
  571.      */
  572.     public function getIncidents(): Collection
  573.     {
  574.         return $this->incidents;
  575.     }
  577.     public function addIncident(Incident $incident): static
  578.     {
  579.         if (!$this->incidents->contains($incident)) {
  580.             $this->incidents->add($incident);
  581.             $incident->setCreatedBy($this);
  582.         }
  584.         return $this;
  585.     }
  587.     public function removeIncident(Incident $incident): static
  588.     {
  589.         if ($this->incidents->removeElement($incident)) {
  590.             // set the owning side to null (unless already changed)
  591.             if ($incident->getCreatedBy() === $this) {
  592.                 $incident->setCreatedBy(null);
  593.             }
  594.         }
  596.         return $this;
  597.     }
  599.     /**
  600.      * @return Collection<int, IncidentUpdate>
  601.      */
  602.     public function getIncidentUpdates(): Collection
  603.     {
  604.         return $this->incidentUpdates;
  605.     }
  607.     public function addIncidentUpdate(IncidentUpdate $incidentUpdate): static
  608.     {
  609.         if (!$this->incidentUpdates->contains($incidentUpdate)) {
  610.             $this->incidentUpdates->add($incidentUpdate);
  611.             $incidentUpdate->setCreatedBy($this);
  612.         }
  614.         return $this;
  615.     }
  617.     public function removeIncidentUpdate(IncidentUpdate $incidentUpdate): static
  618.     {
  619.         if ($this->incidentUpdates->removeElement($incidentUpdate)) {
  620.             // set the owning side to null (unless already changed)
  621.             if ($incidentUpdate->getCreatedBy() === $this) {
  622.                 $incidentUpdate->setCreatedBy(null);
  623.             }
  624.         }
  626.         return $this;
  627.     }
  629.     /**
  630.      * @return Collection<int, Service>
  631.      */
  632.     public function getServices(): Collection
  633.     {
  634.         return $this->services;
  635.     }
  637.     public function addService(Service $service): static
  638.     {
  639.         if (!$this->services->contains($service)) {
  640.             $this->services->add($service);
  641.             $service->setCreatedBy($this);
  642.         }
  644.         return $this;
  645.     }
  647.     public function removeService(Service $service): static
  648.     {
  649.         if ($this->services->removeElement($service)) {
  650.             // set the owning side to null (unless already changed)
  651.             if ($service->getCreatedBy() === $this) {
  652.                 $service->setCreatedBy(null);
  653.             }
  654.         }
  656.         return $this;
  657.     }
  659.     public function getAdress(): ?string
  660.     {
  661.         return $this->adress;
  662.     }
  664.     public function setAdress(?string $adress): static
  665.     {
  666.         $this->adress = $adress;
  668.         return $this;
  669.     }
  671.     public function getCity(): ?string
  672.     {
  673.         return $this->city;
  674.     }
  676.     public function setCity(?string $city): static
  677.     {
  678.         $this->city = $city;
  680.         return $this;
  681.     }
  683.     public function getProvince(): ?string
  684.     {
  685.         return $this->province;
  686.     }
  688.     public function setProvince(?string $province): static
  689.     {
  690.         $this->province = $province;
  692.         return $this;
  693.     }
  695.     public function getCountry(): ?Country
  696.     {
  697.         return $this->country;
  698.     }
  700.     public function setCountry(?Country $country): static
  701.     {
  702.         $this->country = $country;
  704.         return $this;
  705.     }
  707.     /**
  708.      * @return Collection<int, Announcement>
  709.      */
  710.     public function getAnnouncements(): Collection
  711.     {
  712.         return $this->announcements;
  713.     }
  715.     public function addAnnouncement(Announcement $announcement): static
  716.     {
  717.         if (!$this->announcements->contains($announcement)) {
  718.             $this->announcements->add($announcement);
  719.             $announcement->addUser($this);
  720.         }
  722.         return $this;
  723.     }
  725.     public function removeAnnouncement(Announcement $announcement): static
  726.     {
  727.         if ($this->announcements->removeElement($announcement)) {
  728.             $announcement->removeUser($this);
  729.         }
  731.         return $this;
  732.     }
  734.     public function getMode(): ?string
  735.     {
  736.         return $this->mode;
  737.     }
  739.     public function setMode(?string $mode): static
  740.     {
  741.         $this->mode = $mode;
  743.         return $this;
  744.     }
  746.     public function getLastAction(): ?\DateTimeInterface
  747.     {
  748.         return $this->lastAction;
  749.     }
  751.     public function setLastAction(?\DateTimeInterface $lastAction): static
  752.     {
  753.         $this->lastAction = $lastAction;
  755.         return $this;
  756.     }
  758.     public function getReportWidgets(): ?array
  759.     {
  760.         return $this->reportWidgets;
  761.     }
  763.     public function setReportWidgets(?array $reportWidgets): static
  764.     {
  765.         $this->reportWidgets = $reportWidgets;
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection<int, Reservation>
  772.      */
  773.     public function getReservations(): Collection
  774.     {
  775.         return $this->reservations;
  776.     }
  778.     public function addReservation(Reservation $reservation): static
  779.     {
  780.         if (!$this->reservations->contains($reservation)) {
  781.             $this->reservations->add($reservation);
  782.             $reservation->setCreatedBy($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeReservation(Reservation $reservation): static
  789.     {
  790.         if ($this->reservations->removeElement($reservation)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($reservation->getCreatedBy() === $this) {
  793.                 $reservation->setCreatedBy(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection<int, UserEntreprise>
  802.      */
  803.     public function getUserEntreprises(): Collection
  804.     {
  805.         return $this->userEntreprises;
  806.     }
  808.     public function addUserEntreprise(UserEntreprise $userEntreprise): static
  809.     {
  810.         if (!$this->userEntreprises->contains($userEntreprise)) {
  811.             $this->userEntreprises->add($userEntreprise);
  812.             $userEntreprise->setUser($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeUserEntreprise(UserEntreprise $userEntreprise): static
  819.     {
  820.         if ($this->userEntreprises->removeElement($userEntreprise)) {
  821.             // set the owning side to null (unless already changed)
  822.             if ($userEntreprise->getUser() === $this) {
  823.                 $userEntreprise->setUser(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     /**
  831.      * @return Collection<int, Entreprise>
  832.      */
  833.     public function getEntreprises(): Collection
  834.     {
  835.         return $this->entreprises;
  836.     }
  838.     public function addEntreprise(Entreprise $entreprise): static
  839.     {
  840.         if (!$this->entreprises->contains($entreprise)) {
  841.             $this->entreprises->add($entreprise);
  842.             $entreprise->setOwner($this);
  843.         }
  845.         return $this;
  846.     }
  848.     public function removeEntreprise(Entreprise $entreprise): static
  849.     {
  850.         if ($this->entreprises->removeElement($entreprise)) {
  851.             // set the owning side to null (unless already changed)
  852.             if ($entreprise->getOwner() === $this) {
  853.                 $entreprise->setOwner(null);
  854.             }
  855.         }
  857.         return $this;
  858.     }
  859. }