src/Entity/User.php line 13

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;
  12. #[ORM\Entity(repositoryClass: UserRepository::class)]
  13. class User implements UserInterface, PasswordAuthenticatedUserInterface
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column(type: 'integer')]
  18.     private $id;
  20.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  21.     private $email;
  23.     #[ORM\Column(type: 'json')]
  24.     private $roles = [];
  26.     /**
  27.      * @var string The hashed password
  28.      */
  29.     #[ORM\Column(type: 'string')]
  30.     private $password;
  32.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  33.     private $nom;
  35.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  36.     private $prenom;
  38.     #[ORM\ManyToOne(targetEntity: Agence::class, inversedBy: 'users', cascade: ['persist'])]
  39.     private $agence;
  41.     #[ORM\OneToMany(targetEntity: Proposition::class, mappedBy: 'auteur', cascade: ['persist'])]
  42.     private $propositions;
  44.     #[ORM\OneToMany(targetEntity: Dossier::class, mappedBy: 'auteur', cascade: ['persist'])]
  45.     private $dossiersAuteur;
  47.     #[ORM\OneToMany(targetEntity: Dossier::class, mappedBy: 'relecteur', cascade: ['persist'])]
  48.     private $dossiersRelecteur;
  50.     #[ORM\OneToMany(targetEntity: Dossier::class, mappedBy: 'validateur', cascade: ['persist'])]
  51.     private $dossiersValidateur;
  53.     #[ORM\OneToMany(targetEntity: Courrier::class, mappedBy: 'auteur', cascade: ['persist'])]
  54.     private $courriers;
  56.     #[ORM\OneToMany(targetEntity: Affaire::class, mappedBy: 'responsable', cascade: ['persist'])]
  57.     private $affaires;
  59.     #[ORM\Column(type: 'datetime', nullable: true)]
  60.     private $createdAt;
  62.     #[ORM\Column(type: 'datetime', nullable: true)]
  63.     private $updatedAt;
  65.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  66.     private $telephone;
  68.     #[ORM\Column(type: 'boolean', nullable: true)]
  69.     private $actif = true;
  71.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  72.     private $trigramme;
  74.     public function __toString()
  75.     {
  76.         $trigramme=$this->getTrigramme();
  77.         if(!$trigramme){ $trigramme="non défini";}
  78.         return $trigramme;
  79.     }
  81.     public function __construct()
  82.     {
  83.         $this->setRoles(["ROLE_USER"]);
  84.         $this->propositions = new ArrayCollection();
  85.         $this->dossiersAuteur = new ArrayCollection();
  86.         $this->dossiersRelecteur = new ArrayCollection();
  87.         $this->dossiersValidateur = new ArrayCollection();
  88.         $this->courriers = new ArrayCollection();
  89.         $this->affaires = new ArrayCollection();
  90.     }
  92.     public function getId(): ?int
  93.     {
  94.         return $this->id;
  95.     }
  97.     public function getEmail(): ?string
  98.     {
  99.         return $this->email;
  100.     }
  102.     public function setEmail(string $email): self
  103.     {
  104.         $this->email = $email;
  106.         return $this;
  107.     }
  109.     /**
  110.      * A visual identifier that represents this user.
  111.      *
  112.      * @see UserInterface
  113.      */
  114.     public function getUserIdentifier(): string
  115.     {
  116.         return (string) $this->email;
  117.     }
  119.     /**
  120.      * A visual identifier that represents this user.
  121.      *
  122.      * @see UserInterface
  123.      */
  124.     public function getUsername(): string
  125.     {
  126.         return (string) $this->email;
  127.     }
  129.     /**
  130.      * @see UserInterface
  131.      */
  132.     public function getRoles(): array
  133.     {
  134.         $roles = $this->roles;
  135.         // guarantee every user at least has ROLE_USER
  136.         $roles[] = 'ROLE_USER';
  138.         return array_unique($roles);
  139.     }
  141.     public function setRoles(array $roles): self
  142.     {
  143.         $this->roles = $roles;
  145.         return $this;
  146.     }
  148.     /**
  149.      * @see UserInterface
  150.      */
  151.     public function getPassword(): string
  152.     {
  153.         return (string) $this->password;
  154.     }
  156.     public function setPassword(string $password): self
  157.     {
  158.         $this->password = $password;
  160.         return $this;
  161.     }
  163.     /**
  164.      * Returning a salt is only needed, if you are not using a modern
  165.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  166.      *
  167.      * @see UserInterface
  168.      */
  169.     public function getSalt(): ?string
  170.     {
  171.         return null;
  172.     }
  174.     /**
  175.      * @see UserInterface
  176.      */
  177.     public function eraseCredentials()
  178.     {
  179.         // If you store any temporary, sensitive data on the user, clear it here
  180.         // $this->plainPassword = null;
  181.     }
  183.     public function getNom(): ?string
  184.     {
  185.         return $this->nom;
  186.     }
  188.     public function setNom(?string $nom): self
  189.     {
  190.         $this->nom = $nom;
  192.         return $this;
  193.     }
  195.     public function getPrenom(): ?string
  196.     {
  197.         return $this->prenom;
  198.     }
  200.     public function setPrenom(?string $prenom): self
  201.     {
  202.         $this->prenom = $prenom;
  204.         return $this;
  205.     }
  207.     public function getAgence(): ?Agence
  208.     {
  209.         return $this->agence;
  210.     }
  212.     public function setAgence(?Agence $agence): self
  213.     {
  214.         $this->agence = $agence;
  216.         return $this;
  217.     }
  219.     /**
  220.      * @return Collection|Proposition[]
  221.      */
  222.     public function getPropositions(): Collection
  223.     {
  224.         return $this->propositions;
  225.     }
  227.     public function addProposition(Proposition $proposition): self
  228.     {
  229.         if (!$this->propositions->contains($proposition)) {
  230.             $this->propositions[] = $proposition;
  231.             $proposition->setAuteur($this);
  232.         }
  234.         return $this;
  235.     }
  237.     public function removeProposition(Proposition $proposition): self
  238.     {
  239.         if ($this->propositions->removeElement($proposition)) {
  240.             // set the owning side to null (unless already changed)
  241.             if ($proposition->getAuteur() === $this) {
  242.                 $proposition->setAuteur(null);
  243.             }
  244.         }
  246.         return $this;
  247.     }
  249.     /**
  250.      * @return Collection|Dossier[]
  251.      */
  252.     public function getDossiersAuteur(): Collection
  253.     {
  254.         return $this->dossiersAuteur;
  255.     }
  257.     public function addDossiersAuteur(Dossier $dossiersAuteur): self
  258.     {
  259.         if (!$this->dossiersAuteur->contains($dossiersAuteur)) {
  260.             $this->dossiersAuteur[] = $dossiersAuteur;
  261.             $dossiersAuteur->setAuteur($this);
  262.         }
  264.         return $this;
  265.     }
  267.     public function removeDossiersAuteur(Dossier $dossiersAuteur): self
  268.     {
  269.         if ($this->dossiersAuteur->removeElement($dossiersAuteur)) {
  270.             // set the owning side to null (unless already changed)
  271.             if ($dossiersAuteur->getAuteur() === $this) {
  272.                 $dossiersAuteur->setAuteur(null);
  273.             }
  274.         }
  276.         return $this;
  277.     }
  279.     /**
  280.      * @return Collection|Dossier[]
  281.      */
  282.     public function getDossiersRelecteur(): Collection
  283.     {
  284.         return $this->dossiersRelecteur;
  285.     }
  287.     public function addDossiersRelecteur(Dossier $dossiersRelecteur): self
  288.     {
  289.         if (!$this->dossiersRelecteur->contains($dossiersRelecteur)) {
  290.             $this->dossiersRelecteur[] = $dossiersRelecteur;
  291.             $dossiersRelecteur->setRelecteur($this);
  292.         }
  294.         return $this;
  295.     }
  297.     public function removeDossiersRelecteur(Dossier $dossiersRelecteur): self
  298.     {
  299.         if ($this->dossiersRelecteur->removeElement($dossiersRelecteur)) {
  300.             // set the owning side to null (unless already changed)
  301.             if ($dossiersRelecteur->getRelecteur() === $this) {
  302.                 $dossiersRelecteur->setRelecteur(null);
  303.             }
  304.         }
  306.         return $this;
  307.     }
  309.     /**
  310.      * @return Collection|Dossier[]
  311.      */
  312.     public function getDossiersValidateur(): Collection
  313.     {
  314.         return $this->dossiersValidateur;
  315.     }
  317.     public function addDossiersValidateur(Dossier $dossiersValidateur): self
  318.     {
  319.         if (!$this->dossiersValidateur->contains($dossiersValidateur)) {
  320.             $this->dossiersValidateur[] = $dossiersValidateur;
  321.             $dossiersValidateur->setValidateur($this);
  322.         }
  324.         return $this;
  325.     }
  327.     public function removeDossiersValidateur(Dossier $dossiersValidateur): self
  328.     {
  329.         if ($this->dossiersValidateur->removeElement($dossiersValidateur)) {
  330.             // set the owning side to null (unless already changed)
  331.             if ($dossiersValidateur->getValidateur() === $this) {
  332.                 $dossiersValidateur->setValidateur(null);
  333.             }
  334.         }
  336.         return $this;
  337.     }
  339.     /**
  340.      * @return Collection|Courrier[]
  341.      */
  342.     public function getCourriers(): Collection
  343.     {
  344.         return $this->courriers;
  345.     }
  347.     public function addCourrier(Courrier $courrier): self
  348.     {
  349.         if (!$this->courriers->contains($courrier)) {
  350.             $this->courriers[] = $courrier;
  351.             $courrier->setAuteur($this);
  352.         }
  354.         return $this;
  355.     }
  357.     public function removeCourrier(Courrier $courrier): self
  358.     {
  359.         if ($this->courriers->removeElement($courrier)) {
  360.             // set the owning side to null (unless already changed)
  361.             if ($courrier->getAuteur() === $this) {
  362.                 $courrier->setAuteur(null);
  363.             }
  364.         }
  366.         return $this;
  367.     }
  369.     /**
  370.      * @return Collection|Affaire[]
  371.      */
  372.     public function getAffaires(): Collection
  373.     {
  374.         return $this->affaires;
  375.     }
  377.     public function addAffaire(Affaire $affaire): self
  378.     {
  379.         if (!$this->affaires->contains($affaire)) {
  380.             $this->affaires[] = $affaire;
  381.             $affaire->setResponsable($this);
  382.         }
  384.         return $this;
  385.     }
  387.     public function removeAffaire(Affaire $affaire): self
  388.     {
  389.         if ($this->affaires->removeElement($affaire)) {
  390.             // set the owning side to null (unless already changed)
  391.             if ($affaire->getResponsable() === $this) {
  392.                 $affaire->setResponsable(null);
  393.             }
  394.         }
  396.         return $this;
  397.     }
  399.     public function getCreatedAt(): ?\DateTimeInterface
  400.     {
  401.         return $this->createdAt;
  402.     }
  404.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  405.     {
  406.         $this->createdAt = $createdAt;
  408.         return $this;
  409.     }
  411.     public function getUpdatedAt(): ?\DateTimeInterface
  412.     {
  413.         return $this->updatedAt;
  414.     }
  416.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  417.     {
  418.         $this->updatedAt = $updatedAt;
  420.         return $this;
  421.     }
  423.     private $plainPassword = null;
  425.     public function getPlainPassword(): ?string
  426.     {
  427.         return $this->plainPassword;
  428.     }
  430.     public function setPlainPassword(string $password): void
  431.     {
  432.         $this->plainPassword = $password;
  433.     }
  435.     public function getTelephone(): ?string
  436.     {
  437.         return $this->telephone;
  438.     }
  440.     public function setTelephone(?string $telephone): self
  441.     {
  442.         $this->telephone = $telephone;
  444.         return $this;
  445.     }
  447.     public function getActif(): ?bool
  448.     {
  449.         return $this->actif;
  450.     }
  452.     public function setActif(?bool $actif): self
  453.     {
  454.         $this->actif = $actif;
  456.         return $this;
  457.     }
  459.     public function getTrigramme(): ?string
  460.     {
  461.         return $this->trigramme;
  462.     }
  464.     public function setTrigramme(?string $trigramme): self
  465.     {
  466.         $this->trigramme = $trigramme;
  468.         return $this;
  469.     }
  471. }