src/Entity/User.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Component\Security\Core\User\UserInterface;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. #[ORM\Entity(repositoryClass: \App\Repository\UserRepository::class)]
  12. class User implements UserInterface, PasswordAuthenticatedUserInterface, \Stringable
  13. {
  14.   #[ORM\Id]
  15.   #[ORM\GeneratedValue]
  16.   #[ORM\Column(type: 'integer')]
  17.   private ?int $id = 0;
  19.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  20.   private ?string $email= null;
  22.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  23.   private ?string $first_name= null;
  25.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  26.   private ?string $last_name= null;
  28.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  29.   private ?string $phone_number= null;
  31.   #[ORM\Column(type: 'datetime', nullable: true)]
  32.   private mixed $created_at;
  34.   #[ORM\Column(type: 'datetime', nullable: true)]
  35.   private mixed $updated_at;
  37.   #[ORM\Column(type: 'integer', nullable: true)]
  38.   private int $term_version;
  40.   #[ORM\Column(type: 'integer', nullable: true)]
  41.   private mixed $font_size;
  43.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  44.   private ?string $font_family= null;
  46.   #[ORM\Column(type: 'integer', nullable: true)]
  47.   private mixed $dark_mode = null;
  49.   #[ORM\OneToMany(targetEntity: \App\Entity\Post::class, mappedBy: 'created_by')]
  50.   private mixed $created_posts;
  52.   #[ORM\OneToMany(targetEntity: \App\Entity\Post::class, mappedBy: 'updated_by')]
  53.   private mixed $updated_posts;
  55.   #[ORM\Column(name: 'password', type: 'string', length: 255, nullable: true)]
  56.   private ?string $password = null;
  58.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  59.   private ?string $role= null;
  61.   #[ORM\ManyToOne(targetEntity: \App\Entity\TargetPublic::class, inversedBy: 'users')]
  62.   #[ORM\JoinColumn(onDelete: 'SET NULL')]
  63.   private mixed $public;
  65.   #[ORM\OneToMany(targetEntity: \App\Entity\Post::class, mappedBy: 'edit_user', cascade: ['remove'])]
  66.   private mixed $posts;
  68.   #[ORM\OneToMany(targetEntity: \App\Entity\PostLog::class, mappedBy: 'user', cascade: ['remove'])]
  69.   private mixed $postLogs;
  71.   #[ORM\OneToMany(targetEntity: \App\Entity\AuthToken::class, mappedBy: 'user', cascade: ['remove'])]
  72.   private mixed $tokens;
  74.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  75.   private ?string $token_reset= null;
  77.   #[ORM\Column(type: 'boolean')]
  78.   private ?bool $active = true;
  80.   #[ORM\Column(type: 'string', length: 255, nullable: true)]
  81.   private ?string $token_activation= null;
  83.   #[ORM\ManyToMany(targetEntity: \App\Entity\Post::class, inversedBy: 'users')]
  84.   private mixed $favoris;
  86.   #[ORM\ManyToMany(targetEntity: \App\Entity\Topic::class, inversedBy: 'users')]
  87.   private mixed $thematiques;
  89.   #[ORM\ManyToMany(targetEntity: \App\Entity\Territory::class, inversedBy: 'users')]
  90.   private mixed $territoires;
  92.   #[ORM\Column(type: 'boolean', nullable: true)]
  93.   private ?bool $private_posts_only;
  95.   #[ORM\OneToMany(targetEntity: Incident::class, mappedBy: 'user')]
  96.   private mixed $incidents;
  98.   public function __construct()
  99.   {
  100.     $this->created_posts = new ArrayCollection();
  101.     $this->updated_posts = new ArrayCollection();
  102.     $this->posts = new ArrayCollection();
  103.     $this->postLogs = new ArrayCollection();
  104.     $this->tokens = new ArrayCollection();
  105.     $this->favoris = new ArrayCollection();
  106.     $this->thematiques = new ArrayCollection();
  107.     $this->territoires = new ArrayCollection();
  108.     $this->incidents = new ArrayCollection();
  109.   }
  111.   public function getPassword(): ?string
  112.   {
  113.     return $this->password;
  114.   }
  116.   public function setPassword(string $password): self
  117.   {
  118.     $this->password = $password;
  120.     return $this;
  121.   }
  123.   public function getRoles(): array
  124.   {
  125.     if ($this->role == 'admin') {
  126.       return ['ROLE_ADMIN'];
  127.     } else if ($this->role == 'superadmin') {
  128.       return ['ROLE_SUPERADMIN'];
  129.     } else if ($this->role == 'lenordadmin') {
  130.       return ['ROLE_LENORDADMIN'];
  131.     } else if ($this->role == 'redacteur') {
  132.       return ['ROLE_REDACTEUR'];
  133.     } else if ($this->role == 'lecteur') {
  134.       return ["ROLE_LECTEUR"];
  135.     } else if ($this->role == 'agent') {
  136.       return ["ROLE_AGENT"];
  137.     } else if ($this->role == 'public') {
  138.       return ["ROLE_PUBLIC"];
  139.     } else if ($this->role == 'presse') {
  140.       return ["ROLE_PRESSE"];
  141.     } else if ($this->role == 'vip') {
  142.       return ["ROLE_VIP"];
  143.     } else if ($this->role == 'ged') {
  144.       return ["ROLE_GED"];
  145.     }
  146.     return ['ROLE_USER'];
  147.   }
  149.   public function getSalt(): ?string
  150.   {
  151.     return null;
  152.   }
  154.   public function eraseCredentials(): void
  155.   {
  156.   }
  158.   public function equals(UserInterface $user): bool
  159.   {
  160.     return $user->getEmail() == $this->getEmail();
  161.   }
  163.   public function getUsername(): ?string
  164.   {
  165.     return $this->email;
  166.   }
  167.   /**
  168.    * The public representation of the user (e.g. a username, an email address, etc.)
  169.    *
  170.    * @see UserInterface
  171.    */
  172.   public function getUserIdentifier(): string
  173.   {
  174.     return (string) $this->email;
  175.   }
  177.   public function getId(): ?int
  178.   {
  179.     return $this->id;
  180.   }
  182.   public function getEmail(): ?string
  183.   {
  184.     return $this->email;
  185.   }
  187.   public function setEmail(?string $email): self
  188.   {
  189.     $this->email = $email;
  191.     return $this;
  192.   }
  194.   public function getFontSize(): ?int
  195.   {
  196.     return $this->font_size;
  197.   }
  199.   public function setFontSize(?int $font_size): self
  200.   {
  201.     $this->font_size = $font_size;
  202.     return $this;
  203.   }
  205.   public function getFontFamily(): ?string
  206.   {
  207.     return $this->font_family;
  208.   }
  210.   public function setFontFamily(?string $font_family): self
  211.   {
  212.     $this->font_family = $font_family;
  213.     return $this;
  214.   }
  216.   public function getDarkMode(): ?int
  217.   {
  218.     return $this->dark_mode;
  219.   }
  221.   public function setDarkMode(?int $dark_mode): self
  222.   {
  223.     $this->dark_mode = $dark_mode;
  224.     return $this;
  225.   }
  227.   public function getFirstName(): ?string
  228.   {
  229.     return $this->first_name;
  230.   }
  232.   public function setFirstName(?string $first_name): self
  233.   {
  234.     $this->first_name = $first_name;
  236.     return $this;
  237.   }
  239.   public function getLastName(): ?string
  240.   {
  241.     return $this->last_name;
  242.   }
  244.   public function setLastName(?string $last_name): self
  245.   {
  246.     $this->last_name = $last_name;
  248.     return $this;
  249.   }
  251.   public function getPhoneNumber(): ?string
  252.   {
  253.     return $this->phone_number;
  254.   }
  256.   public function setPhoneNumber(?string $phone_number): self
  257.   {
  258.     $this->phone_number = $phone_number;
  260.     return $this;
  261.   }
  263.   public function getCreatedAt(): ?\DateTimeInterface
  264.   {
  265.     return $this->created_at;
  266.   }
  268.   public function setCreatedAt(?\DateTimeInterface $created_at): self
  269.   {
  270.     $this->created_at = $created_at;
  272.     return $this;
  273.   }
  275.   public function getUpdatedAt(): ?\DateTimeInterface
  276.   {
  277.     return $this->updated_at;
  278.   }
  280.   public function setUpdatedAt(?\DateTimeInterface $updated_at): self
  281.   {
  282.     $this->updated_at = $updated_at;
  284.     return $this;
  285.   }
  287.   public function getTermVersion(): ?int
  288.   {
  289.     return $this->term_version;
  290.   }
  292.   public function setTermVersion(?int $term_version): self
  293.   {
  294.     $this->term_version = $term_version;
  296.     return $this;
  297.   }
  299.   /**
  300.    * @return Collection|Post[]
  301.    */
  302.   public function getCreatedPosts(): Collection
  303.   {
  304.     return $this->created_posts;
  305.   }
  307.   public function addCreatedPost(Post $createdPost): self
  308.   {
  309.     if (!$this->created_posts->contains($createdPost)) {
  310.       $this->created_posts[] = $createdPost;
  311.       $createdPost->setCreatedBy($this);
  312.     }
  314.     return $this;
  315.   }
  317.   public function removeCreatedPost(Post $createdPost): self
  318.   {
  319.     if ($this->created_posts->contains($createdPost)) {
  320.       $this->created_posts->removeElement($createdPost);
  321.       // set the owning side to null (unless already changed)
  322.       if ($createdPost->getCreatedBy() === $this) {
  323.         $createdPost->setCreatedBy(null);
  324.       }
  325.     }
  327.     return $this;
  328.   }
  330.   /**
  331.    * @return Collection|Post[]
  332.    */
  333.   public function getUpdatedPosts(): Collection
  334.   {
  335.     return $this->updated_posts;
  336.   }
  338.   public function addUpdatedPost(Post $updatedPost): self
  339.   {
  340.     if (!$this->updated_posts->contains($updatedPost)) {
  341.       $this->updated_posts[] = $updatedPost;
  342.       $updatedPost->setUpdatedBy($this);
  343.     }
  345.     return $this;
  346.   }
  348.   public function removeUpdatedPost(Post $updatedPost): self
  349.   {
  350.     if ($this->updated_posts->contains($updatedPost)) {
  351.       $this->updated_posts->removeElement($updatedPost);
  352.       // set the owning side to null (unless already changed)
  353.       if ($updatedPost->getUpdatedBy() === $this) {
  354.         $updatedPost->setUpdatedBy(null);
  355.       }
  356.     }
  358.     return $this;
  359.   }
  361.   public function getRole(): ?string
  362.   {
  363.     return $this->role;
  364.   }
  366.   public function setRole(?string $role): self
  367.   {
  368.     $this->role = $role;
  370.     return $this;
  371.   }
  373.   public function __toString(): string
  374.   {
  375.     return $this->first_name . ' ' . $this->last_name;
  376.   }
  378.   public function getPublic(): ?TargetPublic
  379.   {
  380.     return $this->public;
  381.   }
  383.   public function setPublic(?TargetPublic $public): self
  384.   {
  385.     $this->public = $public;
  387.     return $this;
  388.   }
  390.   /**
  391.    * @return Collection|Post[]
  392.    */
  393.   public function getPosts(): Collection
  394.   {
  395.     return $this->posts;
  396.   }
  398.   public function addPost(Post $post): self
  399.   {
  400.     if (!$this->posts->contains($post)) {
  401.       $this->posts[] = $post;
  402.       $post->setEditUser($this);
  403.     }
  405.     return $this;
  406.   }
  408.   public function removePost(Post $post): self
  409.   {
  410.     if ($this->posts->contains($post)) {
  411.       $this->posts->removeElement($post);
  412.       // set the owning side to null (unless already changed)
  413.       if ($post->getEditUser() === $this) {
  414.         $post->setEditUser(null);
  415.       }
  416.     }
  418.     return $this;
  419.   }
  421.   /**
  422.    * @return Collection|PostLog[]
  423.    */
  424.   public function getPostLogs(): Collection
  425.   {
  426.     return $this->postLogs;
  427.   }
  429.   public function addPostLog(PostLog $postLog): self
  430.   {
  431.     if (!$this->postLogs->contains($postLog)) {
  432.       $this->postLogs[] = $postLog;
  433.       $postLog->setUser($this);
  434.     }
  436.     return $this;
  437.   }
  439.   public function removePostLog(PostLog $postLog): self
  440.   {
  441.     if ($this->postLogs->contains($postLog)) {
  442.       $this->postLogs->removeElement($postLog);
  443.       // set the owning side to null (unless already changed)
  444.       if ($postLog->getUser() === $this) {
  445.         $postLog->setUser(null);
  446.       }
  447.     }
  449.     return $this;
  450.   }
  452.   public function getTokenReset(): ?string
  453.   {
  454.     return $this->token_reset;
  455.   }
  457.   public function setTokenReset(?string $token_reset): self
  458.   {
  459.     $this->token_reset = $token_reset;
  461.     return $this;
  462.   }
  464.   public function getActive(): ?bool
  465.   {
  466.     return $this->active;
  467.   }
  469.   public function setActive(bool $active): self
  470.   {
  471.     $this->active = $active;
  473.     return $this;
  474.   }
  476.   public function getPrivatePostsOnly(): ?bool
  477.   {
  478.     return $this->private_posts_only;
  479.   }
  481.   public function setPrivatePostsOnly(bool $private_posts_only): self
  482.   {
  483.     $this->private_posts_only = $private_posts_only;
  485.     return $this;
  486.   }
  488.   public function getTokenActivation(): ?string
  489.   {
  490.     return $this->token_activation;
  491.   }
  493.   public function setTokenActivation(?string $token_activation): self
  494.   {
  495.     $this->token_activation = $token_activation;
  497.     return $this;
  498.   }
  500.   /**
  501.    * @return Collection|Post[]
  502.    */
  503.   public function getFavoris(): Collection
  504.   {
  505.     return $this->favoris;
  506.   }
  508.   public function addFavori(Post $favori): self
  509.   {
  510.     if (!$this->favoris->contains($favori)) {
  511.       $this->favoris[] = $favori;
  512.     }
  514.     return $this;
  515.   }
  517.   public function removeFavori(Post $favori): self
  518.   {
  519.     if ($this->favoris->contains($favori)) {
  520.       $this->favoris->removeElement($favori);
  521.     }
  523.     return $this;
  524.   }
  526.   /**
  527.    * @return Collection|Topic[]
  528.    */
  529.   public function getThematiques(): Collection
  530.   {
  531.     return $this->thematiques;
  532.   }
  534.   public function addThematique(Topic $thematique): self
  535.   {
  536.     if (!$this->thematiques->contains($thematique)) {
  537.       $this->thematiques[] = $thematique;
  538.     }
  540.     return $this;
  541.   }
  543.   public function removeThematique(Topic $thematique): self
  544.   {
  545.     if ($this->thematiques->contains($thematique)) {
  546.       $this->thematiques->removeElement($thematique);
  547.     }
  549.     return $this;
  550.   }
  552.   /**
  553.    * @return Collection|Territory[]
  554.    */
  555.   public function getTerritoires(): Collection
  556.   {
  557.     return $this->territoires;
  558.   }
  560.   public function addTerritoire(Territory $territoire): self
  561.   {
  562.     if (!$this->territoires->contains($territoire)) {
  563.       $this->territoires[] = $territoire;
  564.     }
  566.     return $this;
  567.   }
  569.   public function removeTerritoire(Territory $territoire): self
  570.   {
  571.     if ($this->territoires->contains($territoire)) {
  572.       $this->territoires->removeElement($territoire);
  573.     }
  575.     return $this;
  576.   }
  577.   /**
  578.    * @return Collection|PostLog[]
  579.    */
  580.   public function getTokens(): Collection
  581.   {
  582.     return $this->tokens;
  583.   }
  585.   public function addToken(AuthToken $postLog): self
  586.   {
  587.     if (!$this->tokens->contains($postLog)) {
  588.       $this->tokens[] = $postLog;
  589.       $postLog->setUser($this);
  590.     }
  592.     return $this;
  593.   }
  595.   public function removeToken(AuthToken $postLog): self
  596.   {
  597.     if ($this->tokens->contains($postLog)) {
  598.       $this->tokens->removeElement($postLog);
  599.       // set the owning side to null (unless already changed)
  600.       if ($postLog->getUser() === $this) {
  601.         $postLog->setUser(null);
  602.       }
  603.     }
  605.     return $this;
  606.   }
  608.   /**
  609.    * @return Collection|Incident[]
  610.    */
  611.   public function getIncidents(): Collection
  612.   {
  613.     return $this->incidents;
  614.   }
  616.   public function addIncident(Incident $incident): self
  617.   {
  618.     if (!$this->incidents->contains($incident)) {
  619.       $this->incidents[] = $incident;
  620.       $incident->setUser($this);
  621.     }
  623.     return $this;
  624.   }
  626.   public function removeIncident(Incident $incident): self
  627.   {
  628.     if ($this->incidents->removeElement($incident)) {
  629.       // set the owning side to null (unless already changed)
  630.       if ($incident->getUser() === $this) {
  631.         $incident->setUser(null);
  632.       }
  633.     }
  635.     return $this;
  636.   }
  637. }