src/Entity/User.php line 21

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\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  11. use Symfony\Component\Serializer\Annotation\MaxDepth;
  12. use Symfony\Component\Serializer\Annotation\Ignore;
  14. use App\Traits\Timestampable;
  15. use App\Traits\Blameable;
  17. /**
  18.  * @ORM\Table(name="user")
  19.  * @ORM\Entity(repositoryClass=UserRepository::class)
  20.  */
  21. class User implements UserInterface, PasswordAuthenticatedUserInterface
  22. {
  23.     use Timestampable;
  24.     use Blameable;
  26.     /**
  27.      * @ORM\Id
  28.      * @ORM\GeneratedValue
  29.      * @ORM\Column(type="integer")
  30.      */
  31.     private $id;
  33.     /**
  34.      * @ORM\Column(type="integer")
  35.      */
  36.     private $statut;
  38.     /**
  39.      * @ORM\Column(type="string", length=180, unique=true)
  40.      */
  41.     private $email;
  43.     /**
  44.      * @ORM\Column(type="string", length=255)
  45.      */
  46.     private $prenom;
  48.     /**
  49.      * @ORM\Column(type="string", length=255)
  50.      */
  51.     private $nom;
  53.     /**
  54.      * @ORM\Column(type="string", length=255)
  55.      */
  56.     private $trigramme;
  58.     /**     
  59.      * @Ignore()
  60.      * @ORM\Column(type="text")
  61.      * @MaxDepth(1)
  62.      */
  63.     private $roles;
  65.     /**
  66.      * @var string The hashed password
  67.      * @Ignore()
  68.      * @ORM\Column(type="string")
  69.      * @MaxDepth(1)
  70.      */
  71.     private $password;
  73.     /**
  74.      * @Ignore()
  75.      * @ORM\Column(type="string", unique=true, nullable=true)
  76.      * @MaxDepth(1)
  77.      */
  78.     private $apiToken;
  80.     /**
  81.      * @ORM\Column(type="boolean", nullable=true)
  82.      */
  83.     private $externe;
  85.     // /**
  86.     //  * @Ignore()
  87.     //  * @ORM\OneToMany(targetEntity=FormSectionDroit::class, mappedBy="user")
  88.     //  * @MaxDepth(1)
  89.     //  */
  90.     // private $sectionDroits;
  92.     /**
  93.      * @Ignore()
  94.      * @ORM\OneToMany(targetEntity=FormSectionVisa::class, mappedBy="user")
  95.      */
  96.     private $sectionVisas;
  98.     /**
  99.      * @Ignore()
  100.      * @ORM\OneToMany(targetEntity=Favori::class, mappedBy="user")
  101.      * @ORM\OrderBy({"position" = "ASC"})
  102.      */
  103.     private $favoris;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity=Onglet::class, mappedBy="user", orphanRemoval=true)
  107.      * @Ignore()
  108.      */
  109.     private $onglets;
  111.     /**
  112.      * @Ignore()
  113.      * @ORM\OneToMany(targetEntity=MenuInvisible::class, mappedBy="user", orphanRemoval=true)
  114.      */
  115.     private $menuInvisibles;
  117.     /**
  118.      * @ORM\Column(type="integer", nullable=true)
  119.      * @Ignore()
  120.      */
  121.     private $tabsAtLogin;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity=OngletLogin::class, mappedBy="user")
  125.      * @Ignore()
  126.      */
  127.     private $ongletsAtLogin;
  129.     /**
  130.      * @ORM\Column(type="string", length=555, nullable=true)
  131.      * @Ignore()
  132.      */
  133.     private $avatar;
  135.     /**
  136.      * @Ignore()
  137.      * @ORM\OneToMany(targetEntity="App\Entity\Log", mappedBy="user_crea")
  138.      * @MaxDepth(1)
  139.      */
  140.     private $logs;
  142.     /**
  143.      * @Ignore()
  144.      * @ORM\OneToMany(targetEntity=WebsocketMessage::class, mappedBy="user", orphanRemoval=true)
  145.      * @MaxDepth(1)
  146.      */
  147.     private $websocketMessages;
  149.     /**
  150.      * @ORM\Column(type="string", length=255, options={"default" : "fr"})
  151.      */
  152.     private $langage = 'fr';
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=UtilisateurMine::class, mappedBy="user", orphanRemoval=true)
  156.      */
  157.     private $utilisateurMines;
  159.     /**
  160.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="responsableListUsers")
  161.      */
  162.     private $responsable;
  164.     /**
  165.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="responsable")
  166.      */
  167.     private $responsableListUsers;
  169.     /**
  170.      * @ORM\Column(type="string", length=5000, nullable=true)
  171.      */
  172.     private $notes;
  175.     /**
  176.      * @ORM\OneToMany(targetEntity=DroitInvisible::class, mappedBy="user")
  177.      */
  178.     private $droitInvisibles;
  180.     /**
  181.      * @ORM\Column(type="string", length=255, nullable=true)
  182.      * @Ignore()
  183.      * @MaxDepth(1)
  184.      */
  185.     private $tokenRefresh;
  187.     /**
  188.      * @ORM\Column(type="datetime", nullable=true)
  189.      */
  190.     private $dateRefresh;
  192.     public function __construct()
  193.     {
  194.         
  195.         $this->sectionVisas     = new ArrayCollection();
  196.         $this->favoris          = new ArrayCollection();
  197.         $this->onglets          = new ArrayCollection();
  198.         $this->menuInvisibles   = new ArrayCollection();
  199.         $this->ongletsAtLogin   = new ArrayCollection();
  200.         $this->logs             = new ArrayCollection();
  201.         $this->websocketMessages = new ArrayCollection();
  202.         $this->utilisateurMines = new ArrayCollection();
  203.         $this->responsableListUsers = new ArrayCollection();
  204.         $this->droitInvisibles = new ArrayCollection();
  205.     }
  208.     public function getId(): ?int
  209.     {
  210.         return $this->id;
  211.     }
  213.     public function getStatut(): ?int
  214.     {
  215.         return $this->statut;
  216.     }
  218.     public function setStatut(string $statut): self
  219.     {
  220.         $this->statut = $statut;
  222.         return $this;
  223.     }
  225.     public function getUsername(): ?string
  226.     {
  227.         return $this->email;
  228.     }
  230.     public function getEmail(): ?string
  231.     {
  232.         return $this->email;
  233.     }
  235.     public function setEmail(string $email): self
  236.     {
  237.         $this->email = $email;
  239.         return $this;
  240.     }
  242.     public function getNom(): ?string
  243.     {
  244.         return $this->nom;
  245.     }
  247.     public function setNom(string $nom): self
  248.     {
  249.         $this->nom = $nom;
  251.         return $this;
  252.     }
  254.     public function getPrenom(): ?string
  255.     {
  256.         return $this->prenom;
  257.     }
  259.     public function setPrenom(string $prenom): self
  260.     {
  261.         $this->prenom = $prenom;
  263.         return $this;
  264.     }
  266.     public function getTrigramme(): ?string
  267.     {
  268.         return $this->trigramme;
  269.     }
  271.     public function setTrigramme(string $trigramme): self
  272.     {
  273.         $this->trigramme = $trigramme;
  275.         return $this;
  276.     }
  278.     public function getApiToken(): ?string
  279.     {
  280.         return $this->apiToken;
  281.     }
  283.     public function setApiToken(string $apiToken): self
  284.     {
  285.         $this->apiToken = $apiToken;
  287.         return $this;
  288.     }
  290.     /**
  291.      * A visual identifier that represents this user.
  292.      *
  293.      * @see UserInterface
  294.      */
  295.     public function getUserIdentifier(): string
  296.     {
  297.         return (string) $this->email;
  298.     }
  300.     /**
  301.      * @see UserInterface
  302.      */
  303.     public function getRoles(): array
  304.     {
  305.         $tabRoles = json_decode($this->roles, true);
  306.         $roles = !is_null($tabRoles) ? $tabRoles : [];
  307.         // guarantee every user at least has ROLE_USER
  308.         $roles[] = 'ROLE_USER';
  310.         return array_unique($roles);
  311.     }
  313.     public function setRoles(array $roles): self
  314.     {
  315.         $this->roles = json_encode($roles);
  317.         return $this;
  318.     }
  320.     /**
  321.      * @see PasswordAuthenticatedUserInterface
  322.      */
  323.     public function getPassword(): string
  324.     {
  325.         return $this->password;
  326.     }
  328.     public function setPassword(string $password): self
  329.     {
  330.         $this->password = $password;
  332.         return $this;
  333.     }
  335.     public function setExterne(bool $externe): self
  336.     {
  337.         $this->externe = $externe;
  339.         return $this;
  340.     }
  342.     public function getExterne()
  343.     {
  344.         return $this->externe;
  345.     }
  347.     /**
  348.      * Returning a salt is only needed, if you are not using a modern
  349.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  350.      *
  351.      * @see UserInterface
  352.      */
  353.     public function getSalt(): ?string
  354.     {
  355.         return null;
  356.     }
  358.     /**
  359.      * @see UserInterface
  360.      */
  361.     public function eraseCredentials()
  362.     {
  363.         // If you store any temporary, sensitive data on the user, clear it here
  364.         // $this->plainPassword = null;
  365.     }
  367.     /**
  368.      * @return Collection|FormSectionVisa[]
  369.      */
  370.     public function getSectionVisas(): Collection
  371.     {
  372.         return $this->sectionVisas;
  373.     }
  375.     public function addSectionVisa(FormSectionVisa $sectionVisa): self
  376.     {
  377.         if (!$this->sectionVisas->contains($sectionVisa)) {
  378.             $this->sectionVisas[] = $sectionVisa;
  379.             $sectionVisa->setUser($this);
  380.         }
  382.         return $this;
  383.     }
  385.     public function removeSectionVisa(FormSectionVisa $sectionVisa): self
  386.     {
  387.         if ($this->sectionVisas->removeElement($sectionVisa)) {
  388.             // set the owning side to null (unless already changed)
  389.             if ($sectionVisa->getUser() === $this) {
  390.                 $sectionVisa->setUser(null);
  391.             }
  392.         }
  394.         return $this;
  395.     }
  397.     /**
  398.      * @return Collection|Favori[]
  399.      */
  400.     public function getFavoris(): Collection
  401.     {
  402.         return $this->favoris;
  403.     }
  405.     public function addFavori(Favori $favori): self
  406.     {
  407.         if (!$this->favoris->contains($favori)) {
  408.             $this->favoris[] = $favori;
  409.             $favori->setUser($this);
  410.         }
  412.         return $this;
  413.     }
  415.     public function removeFavori(Favori $favori): self
  416.     {
  417.         if ($this->favoris->removeElement($favori)) {
  418.             // set the owning side to null (unless already changed)
  419.             if ($favori->getUser() === $this) {
  420.                 $favori->setUser(null);
  421.             }
  422.         }
  424.         return $this;
  425.     }
  427.     /**
  428.      * @return Collection|Onglet[]
  429.      */
  430.     public function getOnglets(): Collection
  431.     {
  432.         return $this->onglets;
  433.     }
  435.     public function addOnglet(Onglet $onglet): self
  436.     {
  437.         if (!$this->onglets->contains($onglet)) {
  438.             $this->onglets[] = $onglet;
  439.             $onglet->setUser($this);
  440.         }
  442.         return $this;
  443.     }
  445.     public function removeOnglet(Onglet $onglet): self
  446.     {
  447.         if ($this->onglets->removeElement($onglet)) {
  448.             // set the owning side to null (unless already changed)
  449.             if ($onglet->getUser() === $this) {
  450.                 $onglet->setUser(null);
  451.             }
  452.         }
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection|MenuInvisible[]
  459.      */
  460.     public function getMenuInvisibles(): Collection
  461.     {
  462.         return $this->menuInvisibles;
  463.     }
  465.     public function addMenuInvisible(MenuInvisible $menuInvisible): self
  466.     {
  467.         if (!$this->menuInvisibles->contains($menuInvisible)) {
  468.             $this->menuInvisibles[] = $menuInvisible;
  469.             $menuInvisible->setUser($this);
  470.         }
  472.         return $this;
  473.     }
  475.     public function removeMenuInvisible(MenuInvisible $menuInvisible): self
  476.     {
  477.         if ($this->menuInvisibles->removeElement($menuInvisible)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($menuInvisible->getUser() === $this) {
  480.                 $menuInvisible->setUser(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     public function getTabsAtLogin(): ?int
  488.     {
  489.         return $this->tabsAtLogin;
  490.     }
  492.     public function setTabsAtLogin(?int $tabsAtLogin): self
  493.     {
  494.         $this->tabsAtLogin = $tabsAtLogin;
  496.         return $this;
  497.     }
  499.     /**
  500.      * @return Collection|OngletLogin[]
  501.      */
  502.     public function getOngletsAtLogin(): Collection
  503.     {
  504.         return $this->ongletsAtLogin;
  505.     }
  507.     public function addOngletsAtLogin(OngletLogin $ongletsAtLogin): self
  508.     {
  509.         if (!$this->ongletsAtLogin->contains($ongletsAtLogin)) {
  510.             $this->ongletsAtLogin[] = $ongletsAtLogin;
  511.             $ongletsAtLogin->setUser($this);
  512.         }
  514.         return $this;
  515.     }
  517.     public function removeOngletsAtLogin(OngletLogin $ongletsAtLogin): self
  518.     {
  519.         if ($this->ongletsAtLogin->removeElement($ongletsAtLogin)) {
  520.             // set the owning side to null (unless already changed)
  521.             if ($ongletsAtLogin->getUser() === $this) {
  522.                 $ongletsAtLogin->setUser(null);
  523.             }
  524.         }
  526.         return $this;
  527.     }
  529.     /**
  530.     * @return string
  531.     */
  532.     public function getAvatar(): ?string
  533.     {
  534.         return $this->avatar;
  535.     }
  537.     /**
  538.     * @param string $avatar Chemin de l'avatar
  539.     * @return User
  540.     */
  541.     public function setAvatar(?string $avatar): self
  542.     {
  543.         $this->avatar = $avatar;
  545.         return $this;
  546.     }
  548.     /**
  549.      * @return Collection|Log[]
  550.      */
  551.     public function getLogs(): Collection
  552.     {
  553.         return $this->logs;
  554.     }
  556.     public function addLog(Log $log): self
  557.     {
  558.         if (!$this->logs->contains($log)) {
  559.             $this->logs[] = $log;
  560.             $log->setUserCrea($this);
  561.         }
  563.         return $this;
  564.     }
  566.     public function removeLog(Log $log): self
  567.     {
  568.         if ($this->logs->contains($log)) {
  569.             $this->logs->removeElement($log);
  570.             // set the owning side to null (unless already changed)
  571.             if ($log->getUserCrea() === $this) {
  572.                 $log->setUserCrea(null);
  573.             }
  574.         }
  576.         return $this;
  577.     }
  579.     /**
  580.      * @return Collection|WebsocketMessage[]
  581.      */
  582.     public function getWebsocketMessages(): Collection
  583.     {
  584.         return $this->websocketMessages;
  585.     }
  587.     public function addWebsocketMessage(WebsocketMessage $websocketMessage): self
  588.     {
  589.         if (!$this->websocketMessages->contains($websocketMessage)) {
  590.             $this->websocketMessages[] = $websocketMessage;
  591.             $websocketMessage->setUser($this);
  592.         }
  594.         return $this;
  595.     }
  597.     public function removeWebsocketMessage(WebsocketMessage $websocketMessage): self
  598.     {
  599.         if ($this->websocketMessages->removeElement($websocketMessage)) {
  600.             // set the owning side to null (unless already changed)
  601.             if ($websocketMessage->getUser() === $this) {
  602.                 $websocketMessage->setUser(null);
  603.             }
  604.         }
  606.         return $this;
  607.     }
  609.     public function getLangage(): ?string
  610.     {
  611.         return $this->langage;
  612.     }
  614.     public function setLangage(string $langage): self
  615.     {
  616.         $this->langage = $langage;
  618.         return $this;
  619.     }
  621.     /**
  622.      * @return Collection|UtilisateurMine[]
  623.      */
  624.     public function getUtilisateurMines(): Collection
  625.     {
  626.         return $this->utilisateurMines;
  627.     }
  629.     public function setUtilisateurMines($utilisateurMines)
  630.     {
  631.         $this->utilisateurMines = $utilisateurMines;
  633.         return $this;
  634.     }
  636.     public function addUtilisateurMine(UtilisateurMine $utilisateurMine): self
  637.     {
  638.         if (!$this->utilisateurMines->contains($utilisateurMine)) {
  639.             $this->utilisateurMines[] = $utilisateurMine;
  640.             $utilisateurMine->setUser($this);
  641.         }
  643.         return $this;
  644.     }
  646.     public function removeUtilisateurMine(UtilisateurMine $utilisateurMine): self
  647.     {
  648.         if ($this->utilisateurMines->removeElement($utilisateurMine)) {
  649.             // set the owning side to null (unless already changed)
  650.             if ($utilisateurMine->getUser() === $this) {
  651.                 $utilisateurMine->setUser(null);
  652.             }
  653.         }
  655.         return $this;
  656.     }
  658.     public function getResponsable(): ?self
  659.     {
  660.         return $this->responsable;
  661.     }
  663.     public function setResponsable(?self $responsable): self
  664.     {
  665.         $this->responsable = $responsable;
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return Collection|self[]
  672.      */
  673.     public function getResponsableListUsers(): Collection
  674.     {
  675.         return $this->responsableListUsers;
  676.     }
  678.     public function addResponsableListUser(self $responsableListUser): self
  679.     {
  680.         if (!$this->responsableListUsers->contains($responsableListUser)) {
  681.             $this->responsableListUsers[] = $responsableListUser;
  682.             $responsableListUser->setResponsable($this);
  683.         }
  685.         return $this;
  686.     }
  688.     public function removeResponsableListUser(self $responsableListUser): self
  689.     {
  690.         if ($this->responsableListUsers->removeElement($responsableListUser)) {
  691.             // set the owning side to null (unless already changed)
  692.             if ($responsableListUser->getResponsable() === $this) {
  693.                 $responsableListUser->setResponsable(null);
  694.             }
  695.         }
  697.         return $this;
  698.     }
  700.     public function getNotes(): ?string
  701.     {
  702.         return $this->notes;
  703.     }
  705.     public function setNotes(?string $notes): self
  706.     {
  707.         $this->notes = $notes;
  709.         return $this;
  710.     }
  712.     /**
  713.      * @return Collection<int, DroitInvisible>
  714.      */
  715.     public function getDroitInvisibles(): Collection
  716.     {
  717.         return $this->droitInvisibles;
  718.     }
  720.     public function addDroitInvisible(DroitInvisible $droitInvisible): self
  721.     {
  722.         if (!$this->droitInvisibles->contains($droitInvisible)) {
  723.             $this->droitInvisibles[] = $droitInvisible;
  724.             $droitInvisible->setUser($this);
  725.         }
  727.         return $this;
  728.     }
  730.     public function removeDroitInvisible(DroitInvisible $droitInvisible): self
  731.     {
  732.         if ($this->droitInvisibles->removeElement($droitInvisible)) {
  733.             // set the owning side to null (unless already changed)
  734.             if ($droitInvisible->getUser() === $this) {
  735.                 $droitInvisible->setUser(null);
  736.             }
  737.         }
  739.         return $this;
  740.     }
  743.     /**
  744.      * Get token refresh
  745.      *
  746.      * @return  string
  747.      */ 
  748.     public function getTokenRefresh()
  749.     {
  750.         return $this->tokenRefresh;
  751.     }
  753.     /**
  754.      * Set token refresh
  755.      *
  756.      * @param  string  $tokenRefresh  token refresh
  757.      *
  758.      * @return  self
  759.      */ 
  760.     public function setTokenRefresh(string $tokenRefresh)
  761.     {
  762.         $this->tokenRefresh = $tokenRefresh;
  764.         return $this;
  765.     }
  767.     /**
  768.      * Get the value of dateRefresh
  769.      */ 
  770.     public function getDateRefresh()
  771.     {
  772.         return $this->dateRefresh;
  773.     }
  775.     /**
  776.      * Set the value of dateRefresh
  777.      *
  778.      * @return  self
  779.      */ 
  780.     public function setDateRefresh($dateRefresh)
  781.     {
  782.         $this->dateRefresh = $dateRefresh;
  784.         return $this;
  785.     }
  786. }