src/Entity/User.php line 19

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\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  15. /**
  16.  * @UniqueEntity(fields={"username"}, message="There is already an account with this username")
  17.  */
  18. #[ORM\Entity(repositoryClass: UserRepository::class)]
  19. class User implements UserInterface, PasswordAuthenticatedUserInterface
  20. {
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column(type: 'integer')]
  24.     private $id;
  26.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  27.     private $username;
  29.     #[ORM\Column(type: 'json')]
  30.     private $roles = [];
  32.     #[ORM\Column(type: 'string')]
  33.     private $password;
  35.     #[ORM\Column(type: 'string', length: 255)]
  36.     private $name;
  38.     #[ORM\Column(type: 'string', length: 255)]
  39.     private $prenom;
  41.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  42.     private $email;
  44.     #[ORM\Column(type: 'string', length: 255)]
  45.     private $mobile;
  47.     #[ORM\ManyToOne(targetEntity: Roles::class, inversedBy: 'users')]
  48.     #[ORM\JoinColumn(nullable: true)]
  49.     private $role;
  51.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Departement::class)]
  52.     private Collection $departements;
  54.     #[ORM\ManyToOne(inversedBy: 'users')]
  55.     private ?Departement $Departement = null;
  57.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'users')]
  58.     private ?self $Creepar = null;
  60.     #[ORM\OneToMany(mappedBy: 'Creepar', targetEntity: self::class)]
  61.     private Collection $users;
  63.     #[ORM\Column(nullable: true)]
  64.     private ?bool $Status = null;
  66.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Commande::class)]
  67.     private Collection $commandes;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $Service = null;
  72.     #[ORM\OneToMany(mappedBy: 'creePar', targetEntity: ReglementAchat::class)]
  73.     private Collection $reglementAchats;
  75.     #[ORM\OneToMany(mappedBy: 'creePar', targetEntity: ReglementCommande::class)]
  76.     private Collection $reglementCommandes;
  78.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: ReglementTransit::class)]
  79.     private Collection $reglementTransits;
  81.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Achat::class)]
  82.     private Collection $achats;
  84.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: DepenseCommande::class)]
  85.     private Collection $depenseCommandes;
  87.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Produit::class)]
  88.     private Collection $produits;
  90.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Client::class)]
  91.     private Collection $clients;
  95.     public function __construct()
  96.     {
  97.         $this->departements = new ArrayCollection();
  98.         $this->users = new ArrayCollection();
  99.         $this->commandes = new ArrayCollection();
  100.         $this->reglementAchats = new ArrayCollection();
  101.         $this->reglementCommandes = new ArrayCollection();
  102.         $this->reglementTransits = new ArrayCollection();
  103.         $this->achats = new ArrayCollection();
  104.         $this->depenseCommandes = new ArrayCollection();
  105.         $this->produits = new ArrayCollection();
  106.         $this->clients = new ArrayCollection();
  107.     }
  111.     public function getId(): ?int
  112.     {
  113.         return $this->id;
  114.     }
  116.     /**
  117.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  118.      */
  119.     public function getUsername(): string
  120.     {
  121.         return (string)$this->username;
  122.     }
  124.     public function setUsername(string $username): self
  125.     {
  126.         $this->username = $username;
  128.         return $this;
  129.     }
  131.     /**
  132.      * A visual identifier that represents this user.
  133.      *
  134.      * @see UserInterface
  135.      */
  136.     public function getUserIdentifier(): string
  137.     {
  138.         return (string)$this->username;
  139.     }
  141.     /**
  142.      * @see UserInterface
  143.      */
  144.     public function getRoles(): array
  145.     {
  146.         $roles = $this->roles;
  147.         // guarantee every user at least has ROLE_USER
  148.         $roles[] = 'ROLE_USER';
  150.         return array_unique($roles);
  151.     }
  153.     public function setRoles(array $roles): self
  154.     {
  155.         $this->roles = $roles;
  157.         return $this;
  158.     }
  160.     /**
  161.      * @see PasswordAuthenticatedUserInterface
  162.      */
  163.     public function getPassword(): string
  164.     {
  165.         return $this->password;
  166.     }
  168.     public function setPassword(string $password): self
  169.     {
  170.         $this->password = $password;
  172.         return $this;
  173.     }
  175.     /**
  176.      * Returning a salt is only needed, if you are not using a modern
  177.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  178.      *
  179.      * @see UserInterface
  180.      */
  181.     public function getSalt(): ?string
  182.     {
  183.         return null;
  184.     }
  186.     /**
  187.      * @see UserInterface
  188.      */
  189.     public function eraseCredentials()
  190.     {
  191.         // If you store any temporary, sensitive data on the user, clear it here
  192.         // $this->plainPassword = null;
  193.     }
  195.     public function getName(): ?string
  196.     {
  197.         return $this->name;
  198.     }
  200.     public function setName(string $name): self
  201.     {
  202.         $this->name = $name;
  204.         return $this;
  205.     }
  207.     public function getPrenom(): ?string
  208.     {
  209.         return $this->prenom;
  210.     }
  212.     public function setPrenom(string $prenom): self
  213.     {
  214.         $this->prenom = $prenom;
  216.         return $this;
  217.     }
  219.     public function getEmail(): ?string
  220.     {
  221.         return $this->email;
  222.     }
  224.     public function setEmail(string $email): self
  225.     {
  226.         $this->email = $email;
  228.         return $this;
  229.     }
  231.     public function getMobile(): ?string
  232.     {
  233.         return $this->mobile;
  234.     }
  236.     public function setMobile(string $mobile): self
  237.     {
  238.         $this->mobile = $mobile;
  240.         return $this;
  241.     }
  243.     public function getRole(): ?Roles
  244.     {
  245.         return $this->role;
  246.     }
  248.     public function setRole(?Roles $role): self
  249.     {
  250.         $this->role = $role;
  252.         return $this;
  253.     }
  255.     /**
  256.      * @return Collection<int, Departement>
  257.      */
  258.     public function getDepartements(): Collection
  259.     {
  260.         return $this->departements;
  261.     }
  263.     public function addDepartement(Departement $departement): self
  264.     {
  265.         if (!$this->departements->contains($departement)) {
  266.             $this->departements->add($departement);
  267.             $departement->setUser($this);
  268.         }
  270.         return $this;
  271.     }
  273.     public function removeDepartement(Departement $departement): self
  274.     {
  275.         if ($this->departements->removeElement($departement)) {
  276.             // set the owning side to null (unless already changed)
  277.             if ($departement->getUser() === $this) {
  278.                 $departement->setUser(null);
  279.             }
  280.         }
  282.         return $this;
  283.     }
  285.     public function getDepartement(): ?Departement
  286.     {
  287.         return $this->Departement;
  288.     }
  290.     public function setDepartement(?Departement $Departement): self
  291.     {
  292.         $this->Departement = $Departement;
  294.         return $this;
  295.     }
  297.     public function getCreepar(): ?self
  298.     {
  299.         return $this->Creepar;
  300.     }
  302.     public function setCreepar(?self $Creepar): self
  303.     {
  304.         $this->Creepar = $Creepar;
  306.         return $this;
  307.     }
  309.     /**
  310.      * @return Collection<int, self>
  311.      */
  312.     public function getUsers(): Collection
  313.     {
  314.         return $this->users;
  315.     }
  317.     public function addUser(self $user): self
  318.     {
  319.         if (!$this->users->contains($user)) {
  320.             $this->users->add($user);
  321.             $user->setCreepar($this);
  322.         }
  324.         return $this;
  325.     }
  327.     public function removeUser(self $user): self
  328.     {
  329.         if ($this->users->removeElement($user)) {
  330.             // set the owning side to null (unless already changed)
  331.             if ($user->getCreepar() === $this) {
  332.                 $user->setCreepar(null);
  333.             }
  334.         }
  336.         return $this;
  337.     }
  339.     public function isStatus(): ?bool
  340.     {
  341.         return $this->Status;
  342.     }
  344.     public function setStatus(?bool $Status): self
  345.     {
  346.         $this->Status = $Status;
  348.         return $this;
  349.     }
  351.     /**
  352.      * @return Collection<int, Commande>
  353.      */
  354.     public function getCommandes(): Collection
  355.     {
  356.         return $this->commandes;
  357.     }
  359.     public function addCommande(Commande $commande): self
  360.     {
  361.         if (!$this->commandes->contains($commande)) {
  362.             $this->commandes->add($commande);
  363.             $commande->setUser($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeCommande(Commande $commande): self
  370.     {
  371.         if ($this->commandes->removeElement($commande)) {
  372.             // set the owning side to null (unless already changed)
  373.             if ($commande->getUser() === $this) {
  374.                 $commande->setUser(null);
  375.             }
  376.         }
  378.         return $this;
  379.     }
  381.     public function getService(): ?string
  382.     {
  383.         return $this->Service;
  384.     }
  386.     public function setService(?string $Service): self
  387.     {
  388.         $this->Service = $Service;
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return Collection<int, ReglementAchat>
  395.      */
  396.     public function getReglementAchats(): Collection
  397.     {
  398.         return $this->reglementAchats;
  399.     }
  401.     public function addReglementAchat(ReglementAchat $reglementAchat): self
  402.     {
  403.         if (!$this->reglementAchats->contains($reglementAchat)) {
  404.             $this->reglementAchats->add($reglementAchat);
  405.             $reglementAchat->setCreePar($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeReglementAchat(ReglementAchat $reglementAchat): self
  412.     {
  413.         if ($this->reglementAchats->removeElement($reglementAchat)) {
  414.             // set the owning side to null (unless already changed)
  415.             if ($reglementAchat->getCreePar() === $this) {
  416.                 $reglementAchat->setCreePar(null);
  417.             }
  418.         }
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, ReglementCommande>
  425.      */
  426.     public function getReglementCommandes(): Collection
  427.     {
  428.         return $this->reglementCommandes;
  429.     }
  431.     public function addReglementCommande(ReglementCommande $reglementCommande): self
  432.     {
  433.         if (!$this->reglementCommandes->contains($reglementCommande)) {
  434.             $this->reglementCommandes->add($reglementCommande);
  435.             $reglementCommande->setCreePar($this);
  436.         }
  438.         return $this;
  439.     }
  441.     public function removeReglementCommande(ReglementCommande $reglementCommande): self
  442.     {
  443.         if ($this->reglementCommandes->removeElement($reglementCommande)) {
  444.             // set the owning side to null (unless already changed)
  445.             if ($reglementCommande->getCreePar() === $this) {
  446.                 $reglementCommande->setCreePar(null);
  447.             }
  448.         }
  450.         return $this;
  451.     }
  453.     /**
  454.      * @return Collection<int, ReglementTransit>
  455.      */
  456.     public function getReglementTransits(): Collection
  457.     {
  458.         return $this->reglementTransits;
  459.     }
  461.     public function addReglementTransit(ReglementTransit $reglementTransit): self
  462.     {
  463.         if (!$this->reglementTransits->contains($reglementTransit)) {
  464.             $this->reglementTransits->add($reglementTransit);
  465.             $reglementTransit->setUser($this);
  466.         }
  468.         return $this;
  469.     }
  471.     public function removeReglementTransit(ReglementTransit $reglementTransit): self
  472.     {
  473.         if ($this->reglementTransits->removeElement($reglementTransit)) {
  474.             // set the owning side to null (unless already changed)
  475.             if ($reglementTransit->getUser() === $this) {
  476.                 $reglementTransit->setUser(null);
  477.             }
  478.         }
  480.         return $this;
  481.     }
  483.     public function getPermissionsList(): array
  484. {
  485.     $permissions = [];
  487.     if ($this->getRole()) {
  488.         foreach ($this->getRole()->getRolePermissions() as $perm) {
  489.             $permissions[] = $perm->getPermission(); // Assure-toi que le nom correspond à ton entité
  490.         }
  491.     }
  493.     return $permissions;
  494. }
  496.     public function getModulePermissions(): array
  497. {
  498.     $modulePermissions = [];
  500.     if ($this->getRole()) {
  501.         foreach ($this->getRole()->getRolePermissions() as $perm) {
  502.             $module = $perm->getModule() ? strtoupper($perm->getModule()) : 'GENERAL';
  503.             $permission = strtoupper($perm->getPermission());
  504.             
  505.             if (!isset($modulePermissions[$module])) {
  506.                 $modulePermissions[$module] = [];
  507.             }
  508.             
  509.             if (!in_array($permission, $modulePermissions[$module], true)) {
  510.                 $modulePermissions[$module][] = $permission;
  511.             }
  512.         }
  513.     }
  515.     return $modulePermissions;
  516. }
  518.     /**
  519.      * @return Collection<int, Achat>
  520.      */
  521.     public function getAchats(): Collection
  522.     {
  523.         return $this->achats;
  524.     }
  526.     public function addAchat(Achat $achat): self
  527.     {
  528.         if (!$this->achats->contains($achat)) {
  529.             $this->achats->add($achat);
  530.             $achat->setUser($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function removeAchat(Achat $achat): self
  537.     {
  538.         if ($this->achats->removeElement($achat)) {
  539.             // set the owning side to null (unless already changed)
  540.             if ($achat->getUser() === $this) {
  541.                 $achat->setUser(null);
  542.             }
  543.         }
  545.         return $this;
  546.     }
  548.     /**
  549.      * @return Collection<int, DepenseCommande>
  550.      */
  551.     public function getDepenseCommandes(): Collection
  552.     {
  553.         return $this->depenseCommandes;
  554.     }
  556.     public function addDepenseCommande(DepenseCommande $depenseCommande): self
  557.     {
  558.         if (!$this->depenseCommandes->contains($depenseCommande)) {
  559.             $this->depenseCommandes->add($depenseCommande);
  560.             $depenseCommande->setUser($this);
  561.         }
  563.         return $this;
  564.     }
  566.     public function removeDepenseCommande(DepenseCommande $depenseCommande): self
  567.     {
  568.         if ($this->depenseCommandes->removeElement($depenseCommande)) {
  569.             // set the owning side to null (unless already changed)
  570.             if ($depenseCommande->getUser() === $this) {
  571.                 $depenseCommande->setUser(null);
  572.             }
  573.         }
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return Collection<int, Produit>
  580.      */
  581.     public function getProduits(): Collection
  582.     {
  583.         return $this->produits;
  584.     }
  586.     public function addProduit(Produit $produit): self
  587.     {
  588.         if (!$this->produits->contains($produit)) {
  589.             $this->produits->add($produit);
  590.             $produit->setUser($this);
  591.         }
  593.         return $this;
  594.     }
  596.     public function removeProduit(Produit $produit): self
  597.     {
  598.         if ($this->produits->removeElement($produit)) {
  599.             // set the owning side to null (unless already changed)
  600.             if ($produit->getUser() === $this) {
  601.                 $produit->setUser(null);
  602.             }
  603.         }
  605.         return $this;
  606.     }
  608.     /**
  609.      * @return Collection<int, Client>
  610.      */
  611.     public function getClients(): Collection
  612.     {
  613.         return $this->clients;
  614.     }
  616.     public function addClient(Client $client): self
  617.     {
  618.         if (!$this->clients->contains($client)) {
  619.             $this->clients->add($client);
  620.             $client->setUser($this);
  621.         }
  623.         return $this;
  624.     }
  626.     public function removeClient(Client $client): self
  627.     {
  628.         if ($this->clients->removeElement($client)) {
  629.             // set the owning side to null (unless already changed)
  630.             if ($client->getUser() === $this) {
  631.                 $client->setUser(null);
  632.             }
  633.         }
  635.         return $this;
  636.     }
  638. }