src/Entity/User.php line 15

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;
  13. #[ORM\Entity(repositoryClass: UserRepository::class)]
  14. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  15. class User implements UserInterface, PasswordAuthenticatedUserInterface
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 180, unique: true)]
  23.     private ?string $email = null;
  25.     #[ORM\Column]
  26.     private array $roles = [];
  28.     /**
  29.      * @var string The hashed password
  30.      */
  31.     #[ORM\Column]
  32.     private ?string $password = null;
  34.     #[ORM\Column(length: 50)]
  35.     private ?string $fullName = null;
  37.     #[ORM\Column]
  38.     private ?\DateTimeImmutable $createdAt = null;
  40.     
  42.     #[ORM\OneToMany(mappedBy: 'utilisateur', targetEntity: EntreeStock::class)]
  43.     private Collection $entreeStocks;
  45.     #[ORM\OneToMany(mappedBy: 'utilisateur', targetEntity: SortieStock::class)]
  46.     private Collection $sortieStocks;
  48.     #[ORM\OneToMany(mappedBy: 'utilisateur', targetEntity: Produit::class)]
  49.     private Collection $produits;
  52.     #[ORM\Column(length: 255)]
  53.     private ?string $telephone = null;
  55.     #[ORM\Column(length: 255)]
  56.     private ?string $adress = null;
  58.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ActionLog::class)]
  59.     private Collection $actionLogs;
  61.     #[ORM\OneToOne(mappedBy: 'user', cascade: ['persist', 'remove'])]
  62.     private ?Livreur $livreur = null;
  64.     #[ORM\ManyToOne(inversedBy: 'users')]
  65.     private ?Boutique $boutique = null;
  66.     public function __construct() {
  67.         $this->createdAt= new \DateTimeImmutable();
  68.         $this->entreeStocks = new ArrayCollection();
  69.         $this->sortieStocks = new ArrayCollection();
  70.         $this->produits = new ArrayCollection();
  71.         $this->actionLogs = new ArrayCollection();
  72.     }
  74.     public function getId(): ?int
  75.     {
  76.         return $this->id;
  77.     }
  79.     public function getEmail(): ?string
  80.     {
  81.         return $this->email;
  82.     }
  84.     public function setEmail(string $email): static
  85.     {
  86.         $this->email = $email;
  88.         return $this;
  89.     }
  91.     /**
  92.      * A visual identifier that represents this user.
  93.      *
  94.      * @see UserInterface
  95.      */
  96.     public function getUserIdentifier(): string
  97.     {
  98.         return (string) $this->email;
  99.     }
  101.     /**
  102.      * @see UserInterface
  103.      */
  104.     public function getRoles(): array
  105.     {
  106.        
  108.         return array_unique($this->roles);
  109.     }
  111.     public function setRoles(array $roles): static
  112.     {
  113.         $this->roles = $roles;
  115.         return $this;
  116.     }
  118.     /**
  119.      * @see PasswordAuthenticatedUserInterface
  120.      */
  121.     public function getPassword(): string
  122.     {
  123.         return $this->password;
  124.     }
  126.     public function setPassword(string $password): static
  127.     {
  128.         $this->password = $password;
  130.         return $this;
  131.     }
  133.     /**
  134.      * @see UserInterface
  135.      */
  136.     public function eraseCredentials(): void
  137.     {
  138.         // If you store any temporary, sensitive data on the user, clear it here
  139.         // $this->plainPassword = null;
  140.     }
  142.     public function getFullName(): ?string
  143.     {
  144.         return $this->fullName;
  145.     }
  147.     public function setFullName(string $fullName): static
  148.     {
  149.         $this->fullName = $fullName;
  151.         return $this;
  152.     }
  154.     public function getCreatedAt(): ?\DateTimeImmutable
  155.     {
  156.         return $this->createdAt;
  157.     }
  159.     public function setCreatedAt(\DateTimeImmutable $createdAt): static
  160.     {
  161.         $this->createdAt = $createdAt;
  163.         return $this;
  164.     }
  166.    
  167.  
  169.     /**
  170.      * @return Collection<int, EntreeStock>
  171.      */
  172.     public function getEntreeStocks(): Collection
  173.     {
  174.         return $this->entreeStocks;
  175.     }
  177.     public function addEntreeStock(EntreeStock $entreeStock): static
  178.     {
  179.         if (!$this->entreeStocks->contains($entreeStock)) {
  180.             $this->entreeStocks->add($entreeStock);
  181.             $entreeStock->setUtilisateur($this);
  182.         }
  184.         return $this;
  185.     }
  187.     public function removeEntreeStock(EntreeStock $entreeStock): static
  188.     {
  189.         if ($this->entreeStocks->removeElement($entreeStock)) {
  190.             // set the owning side to null (unless already changed)
  191.             if ($entreeStock->getUtilisateur() === $this) {
  192.                 $entreeStock->setUtilisateur(null);
  193.             }
  194.         }
  196.         return $this;
  197.     }
  199.     /**
  200.      * @return Collection<int, SortieStock>
  201.      */
  202.     public function getSortieStocks(): Collection
  203.     {
  204.         return $this->sortieStocks;
  205.     }
  207.     public function addSortieStock(SortieStock $sortieStock): static
  208.     {
  209.         if (!$this->sortieStocks->contains($sortieStock)) {
  210.             $this->sortieStocks->add($sortieStock);
  211.             $sortieStock->setUtilisateur($this);
  212.         }
  214.         return $this;
  215.     }
  217.     public function removeSortieStock(SortieStock $sortieStock): static
  218.     {
  219.         if ($this->sortieStocks->removeElement($sortieStock)) {
  220.             // set the owning side to null (unless already changed)
  221.             if ($sortieStock->getUtilisateur() === $this) {
  222.                 $sortieStock->setUtilisateur(null);
  223.             }
  224.         }
  226.         return $this;
  227.     }
  229.     /**
  230.      * @return Collection<int, Produit>
  231.      */
  232.     public function getProduits(): Collection
  233.     {
  234.         return $this->produits;
  235.     }
  237.     public function addProduit(Produit $produit): static
  238.     {
  239.         if (!$this->produits->contains($produit)) {
  240.             $this->produits->add($produit);
  241.             $produit->setUtilisateur($this);
  242.         }
  244.         return $this;
  245.     }
  247.     public function removeProduit(Produit $produit): static
  248.     {
  249.         if ($this->produits->removeElement($produit)) {
  250.             // set the owning side to null (unless already changed)
  251.             if ($produit->getUtilisateur() === $this) {
  252.                 $produit->setUtilisateur(null);
  253.             }
  254.         }
  256.         return $this;
  257.     }
  259.   
  260.     public function getTelephone(): ?string
  261.     {
  262.         return $this->telephone;
  263.     }
  265.     public function setTelephone(string $telephone): static
  266.     {
  267.         $this->telephone = $telephone;
  269.         return $this;
  270.     }
  272.     public function getAdress(): ?string
  273.     {
  274.         return $this->adress;
  275.     }
  277.     public function setAdress(string $adress): static
  278.     {
  279.         $this->adress = $adress;
  281.         return $this;
  282.     }
  284.     /**
  285.      * @return Collection<int, ActionLog>
  286.      */
  287.     public function getActionLogs(): Collection
  288.     {
  289.         return $this->actionLogs;
  290.     }
  292.     public function addActionLog(ActionLog $actionLog): static
  293.     {
  294.         if (!$this->actionLogs->contains($actionLog)) {
  295.             $this->actionLogs->add($actionLog);
  296.             $actionLog->setUser($this);
  297.         }
  299.         return $this;
  300.     }
  302.     public function removeActionLog(ActionLog $actionLog): static
  303.     {
  304.         if ($this->actionLogs->removeElement($actionLog)) {
  305.             // set the owning side to null (unless already changed)
  306.             if ($actionLog->getUser() === $this) {
  307.                 $actionLog->setUser(null);
  308.             }
  309.         }
  311.         return $this;
  312.     }
  314.     public function getLivreur(): ?Livreur
  315.     {
  316.         return $this->livreur;
  317.     }
  319.     public function setLivreur(Livreur $livreur): static
  320.     {
  321.         // set the owning side of the relation if necessary
  322.         if ($livreur->getUser() !== $this) {
  323.             $livreur->setUser($this);
  324.         }
  326.         $this->livreur = $livreur;
  328.         return $this;
  329.     }
  331.     public function getBoutique(): ?Boutique
  332.     {
  333.         return $this->boutique;
  334.     }
  336.     public function setBoutique(?Boutique $boutique): static
  337.     {
  338.         $this->boutique = $boutique;
  340.         return $this;
  341.     }
  342. }