src/Entity/Utilisateur.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UtilisateurRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  13. /**
  14.  * @ORM\Entity(repositoryClass=UtilisateurRepository::class)
  15.  * @UniqueEntity(
  16.  *     fields={"email"},
  17.  *     message="Cet email est déjà utilisé."
  18.  * )
  19.  */
  20. class Utilisateur implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     /**
  23.      * @ORM\Id
  24.      * @ORM\GeneratedValue
  25.      * @ORM\Column(type="integer")
  26.      */
  27.     private $id;
  29.     /**
  30.      * @ORM\Column(type="string", length=180, unique=true)
  31.      */
  32.     private $email;
  34.     /**
  35.      * @ORM\Column(type="json")
  36.      */
  37.     private $roles = [];
  39.     /**
  40.      * @var string The hashed password
  41.      * @ORM\Column(type="string")
  42.      */
  43.     private $password;
  45.     /**
  46.      * @ORM\Column(type="boolean")
  47.      */
  48.     private $notification;
  50.     /**
  51.      * @ORM\Column(type="boolean")
  52.      */
  53.     private $hideAccount;
  55.     /**
  56.      * @ORM\Column(type="boolean")
  57.      */
  58.     private $hideEntreprise;
  60.     /**
  61.      * @ORM\Column(type="boolean")
  62.      */
  63.     private $allProgrammes;
  65.     /**
  66.      * @ORM\Column(type="string", length=7, nullable=true)
  67.      */
  68.     private $couleur;
  70.     /**
  71.      * @ORM\OneToMany(targetEntity=Historique::class, mappedBy="expediteur")
  72.      */
  73.     private $historiques;
  75.     /**
  76.      * @ORM\Column(type="string", length=255)
  77.      */
  78.     private $telephone;
  80.     /**
  81.      * @ORM\Column(type="string", length=255)
  82.      */
  83.     private $nom;
  85.     /**
  86.      * @ORM\Column(type="string", length=255)
  87.      */
  88.     private $prenom;
  90.     /**
  91.      * @ORM\OneToMany(targetEntity=Prospect::class, mappedBy="auteur")
  92.      */
  93.     private $prospects;
  95.     /**
  96.      * @ORM\ManyToOne(targetEntity=Entreprise::class, inversedBy="utilisateurs")
  97.      */
  98.     private $entreprise;
  100.     /**
  101.      * @ORM\OneToMany(targetEntity=Programme::class, mappedBy="prescripteur")
  102.      */
  103.     private $prescripteurProgrammes;
  105.     /**
  106.      * @ORM\Column(type="text", nullable=true)
  107.      */
  108.     private $prescripteurCoordonneesResponsable;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=InfosSuivi::class, mappedBy="utilisateur", cascade={"remove"})
  112.      */
  113.     private $infosSuivis;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=ActionTrace::class, mappedBy="user")
  117.      */
  118.     private $actionTraces;
  120.     /**
  121.      * @ORM\Column(type="boolean", options={"default":false})
  122.      */
  123.     private $peutModifier = false;
  125.     /**
  126.      * @ORM\Column(type="boolean", options={"default": false})
  127.      */
  128.     private $rapportQuotidien = false;
  130.     /**
  131.      * @ORM\Column(type="string", length=255, nullable=true)
  132.      */
  133.     private $smtpEmail;
  135.     /**
  136.      * @ORM\Column(type="string", length=255, nullable=true)
  137.      */
  138.     private $smtpPassword;
  140.     /**
  141.      * @ORM\Column(type="string", length=255, nullable=true)
  142.      */
  143.     private $smtpDisplayName;
  145.     public const ROLES = [];
  147.     public const SUPERADMIN_ROLES = [
  148.         'SUPER ADMIN' => 'ROLE_SUPERADMIN',
  149.         'ADMIN' => 'ROLE_ADMIN',
  150.         'Directeur/trice Commercial(e)' => 'ROLE_DIRECTEUR',
  151.         'Responsable Prescription' => 'ROLE_RESPONSABLE',
  152.         'Négociateur/Négociatrice ' => 'ROLE_COMMERCIAL',
  153.         'Partenaire/Prescripteur' => 'ROLE_PARTENAIRE',
  154.         'Opérateur/trice de Saisie' => 'ROLE_SAISIE',
  155.     ];
  157.     public const ADMIN_ROLES = [
  158.         'ADMIN' => 'ROLE_ADMIN',
  159.         'Directeur/trice Commercial(e)' => 'ROLE_DIRECTEUR',
  160.         'Responsable Prescription' => 'ROLE_RESPONSABLE',
  161.         'Négociateur/Négociatrice ' => 'ROLE_COMMERCIAL',
  162.         'Partenaire/Prescripteur' => 'ROLE_PARTENAIRE',
  163.         'Opérateur/trice de Saisie' => 'ROLE_SAISIE',
  164.     ];
  166.     public const DIRECTEUR_ROLES = [
  167.         'Négociateur/Négociatrice ' => 'ROLE_COMMERCIAL',
  168.         'Opérateur/trice de Saisie' => 'ROLE_SAISIE',
  169.     ];
  171.     public const RESPONSABLE_ROLES = [
  172.         'Partenaire/Prescripteur' => 'ROLE_PARTENAIRE',
  173.         'Opérateur/trice de Saisie' => 'ROLE_SAISIE',
  174.     ];
  176.     public function __construct()
  177.     {
  178.         $this->historiques = new ArrayCollection();
  179.         $this->prospects = new ArrayCollection();
  180.         if ($this->couleur === null) {
  181.             $this->couleur = '#F7F7F7';
  182.         }
  183.         $this->prescripteurProgrammes = new ArrayCollection();
  184.         $this->infosSuivis = new ArrayCollection();
  185.         $this->allProgrammes = false;
  186.         $this->actionTraces = new ArrayCollection();
  187.     }
  189.     public function __toString() {
  190.         return $this->getId() == null ? 'Nouvel utilisateur' : $this->getEmail();
  191.     }
  193.     public function getId(): ?int
  194.     {
  195.         return $this->id;
  196.     }
  198.     public function getEmail(): ?string
  199.     {
  200.         return $this->email;
  201.     }
  203.     public function setEmail(string $email): self
  204.     {
  205.         $this->email = $email;
  207.         return $this;
  208.     }
  210.     /**
  211.      * A visual identifier that represents this user.
  212.      *
  213.      * @see UserInterface
  214.      */
  215.     public function getUserIdentifier(): string
  216.     {
  217.         return (string) $this->email;
  218.     }
  220.     /**
  221.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  222.      */
  223.     public function getUsername(): string
  224.     {
  225.         return (string) $this->email;
  226.     }
  228.     public function getRole() {
  229.         if(!count($this->getRoles())) return null;
  230.         return $this->getRoles()[0];
  231.     }
  233.     public function setRole($role) {
  235.         return $this->setRoles([$role]);
  236.     }
  238.     /**
  239.      * @see UserInterface
  240.      */
  241.     public function getRoles(): array
  242.     {
  243.         $roles = $this->roles;
  244.         // guarantee every user at least has ROLE_USER
  245.         $roles[] = 'ROLE_USER';
  247.         return array_unique($roles);
  248.     }
  250.     public function setRoles(array $roles): self
  251.     {
  252.         $this->roles = $roles;
  254.         return $this;
  255.     }
  257.     /**
  258.      * @see PasswordAuthenticatedUserInterface
  259.      */
  260.     public function getPassword(): string
  261.     {
  262.         return $this->password;
  263.     }
  265.     public function setPassword(string $password): self
  266.     {
  267.         $this->password = $password;
  269.         return $this;
  270.     }
  272.     /**
  273.      * Returning a salt is only needed, if you are not using a modern
  274.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  275.      *
  276.      * @see UserInterface
  277.      */
  278.     public function getSalt(): ?string
  279.     {
  280.         return null;
  281.     }
  283.     /**
  284.      * @see UserInterface
  285.      */
  286.     public function eraseCredentials()
  287.     {
  288.         // If you store any temporary, sensitive data on the user, clear it here
  289.         // $this->plainPassword = null;
  290.     }
  292.     public function getNotification(): ?bool
  293.     {
  294.         return $this->notification;
  295.     }
  297.     public function setNotification(bool $notification): self
  298.     {
  299.         $this->notification = $notification;
  301.         return $this;
  302.     }
  304.     public function getSmtpEmail(): ?string
  305.     {
  306.         return $this->smtpEmail;
  307.     }
  309.     public function setSmtpEmail(?string $smtpEmail): self
  310.     {
  311.         $this->smtpEmail = $smtpEmail;
  313.         return $this;
  314.     }
  316.     public function getSmtpPassword(): ?string
  317.     {
  318.         return $this->smtpPassword;
  319.     }
  321.     public function setSmtpPassword(?string $smtpPassword): self
  322.     {
  323.         if ($smtpPassword === null || $smtpPassword === '') {
  324.             return $this;
  325.         }
  327.         $this->smtpPassword = $smtpPassword;
  329.         return $this;
  330.     }
  332.     public function getSmtpDisplayName(): ?string
  333.     {
  334.         return $this->smtpDisplayName;
  335.     }
  337.     public function setSmtpDisplayName(?string $smtpDisplayName): self
  338.     {
  339.         $this->smtpDisplayName = $smtpDisplayName;
  341.         return $this;
  342.     }
  344.     public function getHideAccount(): ?bool
  345.     {
  346.         return $this->hideAccount;
  347.     }
  349.     public function setHideAccount(bool $hideAccount): self
  350.     {
  351.         $this->hideAccount = $hideAccount;
  353.         return $this;
  354.     }
  356.     public function getHideEntreprise(): ?bool
  357.     {
  358.         return $this->hideEntreprise;
  359.     }
  361.     public function setHideEntreprise(bool $hideEntreprise): self
  362.     {
  363.         $this->hideEntreprise = $hideEntreprise;
  365.         return $this;
  366.     }
  368.     public function getallProgrammes(): ?bool
  369.     {
  370.         return $this->allProgrammes;
  371.     }
  373.     public function setallProgrammes(bool $allProgrammes): self
  374.     {
  375.         $this->allProgrammes = $allProgrammes;
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection|Historique[]
  382.      */
  383.     public function getHistoriques(): Collection
  384.     {
  385.         return $this->historiques;
  386.     }
  388.     public function addHistorique(Historique $historique): self
  389.     {
  390.         if (!$this->historiques->contains($historique)) {
  391.             $historique->setExpediteur($this);
  392.             $historique->setEntreprise($this->getEntreprise());
  393.             $this->historiques[] = $historique;
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeHistorique(Historique $historique): self
  400.     {
  401.         if ($this->historiques->removeElement($historique)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($historique->getExpediteur() === $this) {
  404.                 $historique->setExpediteur(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     public function isRapportQuotidien(): bool
  412.     {
  413.         return (bool) $this->rapportQuotidien;
  414.     }
  416.     public function setRapportQuotidien(bool $rapportQuotidien): self
  417.     {
  418.         $this->rapportQuotidien = $rapportQuotidien;
  420.         return $this;
  421.     }
  423.     public function getTelephone(): ?string
  424.     {
  425.         return $this->telephone;
  426.     }
  428.     public function setTelephone(string $telephone): self
  429.     {
  430.         $this->telephone = $telephone;
  432.         return $this;
  433.     }
  435.     public function getNom(): ?string
  436.     {
  437.         return $this->nom;
  438.     }
  440.     public function setNom(string $nom): self
  441.     {
  442.         $this->nom = $nom;
  444.         return $this;
  445.     }
  447.     public function getPrenom(): ?string
  448.     {
  449.         return $this->prenom;
  450.     }
  452.     public function setPrenom(string $prenom): self
  453.     {
  454.         $this->prenom = $prenom;
  456.         return $this;
  457.     }
  459.     public function getNomEtPrenom()
  460.     {
  461.         return $this->getPrenom() . ' ' . $this->getNom();
  462.     }
  464.     /**
  465.      * @return Collection<int, Prospect>
  466.      */
  467.     public function getProspects(): Collection
  468.     {
  469.         return $this->prospects;
  470.     }
  472.     public function addProspect(Prospect $prospect): self
  473.     {
  474.         if (!$this->prospects->contains($prospect)) {
  475.             $this->prospects[] = $prospect;
  476.             $prospect->setAuteur($this);
  477.         }
  479.         return $this;
  480.     }
  482.     public function removeProspect(Prospect $prospect): self
  483.     {
  484.         if ($this->prospects->removeElement($prospect)) {
  485.             // set the owning side to null (unless already changed)
  486.             if ($prospect->getAuteur() === $this) {
  487.                 $prospect->setAuteur(null);
  488.             }
  489.         }
  491.         return $this;
  492.     }
  494.     public function getEntreprise(): ?Entreprise
  495.     {
  496.         return $this->entreprise;
  497.     }
  499.     public function setEntreprise(?Entreprise $entreprise): self
  500.     {
  501.         $this->entreprise = $entreprise;
  503.         return $this;
  504.     }
  506.     public function isNotification(): ?bool
  507.     {
  508.         return $this->notification;
  509.     }
  511.     public function isHideAccount(): ?bool
  512.     {
  513.         return $this->hideAccount;
  514.     }
  516.     public function isHideEntreprise(): ?bool
  517.     {
  518.         return $this->hideEntreprise;
  519.     }
  521.     public function isallProgrammes(): ?bool
  522.     {
  523.         return $this->allProgrammes;
  524.     }
  526.     public function getCouleur(): ?string
  527.     {
  528.         return $this->couleur;
  529.     }
  531.     public function setCouleur(?string $couleur): self
  532.     {
  533.         $this->couleur = $couleur;
  535.         return $this;
  536.     }
  538.     public function getAvailableRoles(): array
  539.     {
  540.         $roles = self::ROLES;
  542.         if (in_array('ROLE_MASTER', $this->getRoles()) || in_array('ROLE_SUPERADMIN', $this->getRoles())) {
  543.             $roles = array_merge(self::SUPERADMIN_ROLES, $roles);
  544.         }
  546.         if (in_array('ROLE_ADMIN', $this->getRoles())) {
  547.             $roles = array_merge(self::ADMIN_ROLES, $roles);
  548.         }
  550.         if (in_array('ROLE_DIRECTEUR', $this->getRoles())) {
  551.             $roles = array_merge(self::DIRECTEUR_ROLES, $roles);
  552.         }
  554.         if (in_array('ROLE_RESPONSABLE', $this->getRoles())) {
  555.             $roles = array_merge(self::RESPONSABLE_ROLES, $roles);
  556.         }
  558.         return $roles;
  559.     }
  561.     /**
  562.      * @return Collection<int, Programme>
  563.      */
  564.     public function getPrescripteurProgrammes(): Collection
  565.     {
  566.         return $this->prescripteurProgrammes;
  567.     }
  569.     public function addPrescripteurProgramme(Programme $prescripteurProgramme): self
  570.     {
  571.         if (!$this->prescripteurProgrammes->contains($prescripteurProgramme)) {
  572.             $this->prescripteurProgrammes[] = $prescripteurProgramme;
  573.             $prescripteurProgramme->setPrescripteur($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removePrescripteurProgramme(Programme $prescripteurProgramme): self
  580.     {
  581.         if ($this->prescripteurProgrammes->removeElement($prescripteurProgramme)) {
  582.             // set the owning side to null (unless already changed)
  583.             if ($prescripteurProgramme->getPrescripteur() === $this) {
  584.                 $prescripteurProgramme->setPrescripteur(null);
  585.             }
  586.         }
  588.         return $this;
  589.     }
  591.     public function getPrescripteurCoordonneesResponsable(): ?string
  592.     {
  593.         return $this->prescripteurCoordonneesResponsable;
  594.     }
  596.     public function setPrescripteurCoordonneesResponsable(?string $prescripteurCoordonneesResponsable): self
  597.     {
  598.         $this->prescripteurCoordonneesResponsable = $prescripteurCoordonneesResponsable;
  600.         return $this;
  601.     }
  603.     /**
  604.      * @return Collection<int, InfosSuivi>
  605.      */
  606.     public function getInfosSuivis(): Collection
  607.     {
  608.         return $this->infosSuivis;
  609.     }
  611.     public function addInfosSuivi(InfosSuivi $infosSuivi): self
  612.     {
  613.         if (!$this->infosSuivis->contains($infosSuivi)) {
  614.             $this->infosSuivis[] = $infosSuivi;
  615.             $infosSuivi->setUtilisateur($this);
  616.         }
  618.         return $this;
  619.     }
  621.     public function removeInfosSuivi(InfosSuivi $infosSuivi): self
  622.     {
  623.         if ($this->infosSuivis->removeElement($infosSuivi)) {
  624.             // set the owning side to null (unless already changed)
  625.             if ($infosSuivi->getUtilisateur() === $this) {
  626.                 $infosSuivi->setUtilisateur(null);
  627.             }
  628.         }
  630.         return $this;
  631.     }
  633.     /**
  634.      * @return Collection<int, ActionTrace>
  635.      */
  636.     public function getActionTraces(): Collection
  637.     {
  638.         return $this->actionTraces;
  639.     }
  641.     public function addActionTrace(ActionTrace $actionTrace): self
  642.     {
  643.         if (!$this->actionTraces->contains($actionTrace)) {
  644.             $this->actionTraces[] = $actionTrace;
  645.             $actionTrace->setUser($this);
  646.         }
  648.         return $this;
  649.     }
  651.     public function removeActionTrace(ActionTrace $actionTrace): self
  652.     {
  653.         if ($this->actionTraces->removeElement($actionTrace)) {
  654.             // set the owning side to null (unless already changed)
  655.             if ($actionTrace->getUser() === $this) {
  656.                 $actionTrace->setUser(null);
  657.             }
  658.         }
  660.         return $this;
  661.     }
  663.     public function getPeutModifier(): ?bool
  664.     {
  665.         return $this->peutModifier;
  666.     }
  668.     public function setPeutModifier(bool $peutModifier): self
  669.     {
  670.         $this->peutModifier = $peutModifier;
  671.         return $this;
  672.     }
  674.     public function isPeutModifier(): ?bool
  675.     {
  676.         return $this->peutModifier;
  677.     }
  679.     /**
  680.      * Méthode pour vérifier si l'utilisateur peut modifier les lots et programmes
  681.      */
  682.     public function peutModifierContenu(): bool
  683.     {
  684.         if (in_array('ROLE_SUPERADMIN', $this->getRoles()) ||
  685.             in_array('ROLE_ADMIN', $this->getRoles()) ||
  686.             in_array('ROLE_DIRECTEUR', $this->getRoles()) ||
  687.             in_array('ROLE_SAISIE', $this->getRoles())) {
  688.             return true;
  689.         }
  691.         if (in_array('ROLE_COMMERCIAL', $this->getRoles()) ||
  692.             in_array('ROLE_PARTENAIRE', $this->getRoles())) {
  693.             return $this->getPeutModifier();
  694.         }
  696.         return false;
  697.     }
  698. }