src/Entity/User.php line 20

  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\HttpFoundation\File\File;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. #[ORM\Entity(repositoryClass: UserRepository::class)]
  16. #[ORM\Table(name: '`user`')]
  17. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  18. #[Vich\Uploadable]
  20. class User implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     #[ORM\Id]
  23.     #[ORM\GeneratedValue]
  24.     #[ORM\Column]
  25.     private ?int $id = null;
  27.     #[ORM\Column(length: 180, unique: true)]
  28.     private ?string $email = null;
  30.     #[ORM\Column]
  31.     private array $roles = [];
  33.     /**
  34.      * @var string The hashed password
  35.      */
  36.     #[ORM\Column]
  37.     private ?string $password = null;
  39.     #[ORM\Column(type: 'boolean')]
  40.     private $isVerified = false;
  42.     #[ORM\Column(length: 255)]
  43.     private ?string $name = null;
  45.     #[ORM\Column(length: 255)]
  46.     private ?string $firstname = null;
  48.     #[ORM\Column(length: 255)]
  49.     private ?string $phone = null;
  51.     #[ORM\Column(length: 255, nullable: true)]
  52.     private ?string $image = null;
  54.     #[Vich\UploadableField(mapping: 'users_images', fileNameProperty: 'image')]
  55.     private ?File $imageFile = null;
  57.     #[ORM\ManyToOne(targetEntity: self::class, cascade: ['remove'], inversedBy: 'users')]
  58.     #[ORM\JoinColumn(name: 'administrator_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
  59.     private ?self $administrator = null;
  61.     #[ORM\OneToMany(mappedBy: 'administrator', targetEntity: self::class)]
  62.     private Collection $users;
  64.     #[ORM\ManyToMany(targetEntity: Program::class, mappedBy: 'collaborators')]
  65.     private Collection $programs;
  67.     #[ORM\OneToMany(mappedBy: 'adminUser', targetEntity: Client::class)]
  68.     private Collection $clients;
  70.     #[ORM\OneToMany(mappedBy: 'adminUser', targetEntity: Company::class)]
  71.     private Collection $companies;
  73.     #[ORM\OneToMany(mappedBy: 'adminUser', targetEntity: Groupe::class)]
  74.     private Collection $groupes;
  76.     #[ORM\OneToOne(mappedBy: 'userClient', targetEntity: Client::class)]
  77.     private ?Client $client = null;
  79.     #[ORM\Column]
  80.     private ?bool $isDisable = null;
  83.     public function __construct()
  84.     {
  85.         $this->users = new ArrayCollection();
  86.         $this->programs = new ArrayCollection();
  87.         $this->clients = new ArrayCollection();
  88.         $this->companies = new ArrayCollection();
  89.         $this->groupes = new ArrayCollection();
  90.         $this->isDisable = false;
  91.     }
  94.     /**
  95.      * @return string|null
  96.      */
  97.     public function getName(): ?string
  98.     {
  99.         return $this->name;
  100.     }
  102.     /**
  103.      * @param string|null $name
  104.      */
  105.     public function setName(?string $name): void
  106.     {
  107.         $this->name = $name;
  108.     }
  110.     /**
  111.      * @return string|null
  112.      */
  113.     public function getFirstname(): ?string
  114.     {
  115.         return $this->firstname;
  116.     }
  118.     /**
  119.      * @param string|null $firstname
  120.      */
  121.     public function setFirstname(?string $firstname): void
  122.     {
  123.         $this->firstname = $firstname;
  124.     }
  126.     /**
  127.      * @return string|null
  128.      */
  129.     public function getPhone(): ?string
  130.     {
  131.         return $this->phone;
  132.     }
  134.     /**
  135.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  136.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  137.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  138.      * must be able to accept an instance of 'CandidateFile' as the bundle will inject one here
  139.      * during Doctrine hydration.
  140.      *
  141.      * @param CandidateFile|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  142.      */
  143.     public function setImageFile(?File $imageFile = null): void
  144.     {
  145.         $this->imageFile = $imageFile;
  147.         if (null !== $imageFile) {
  148.             // It is required that at least one field changes if you are using doctrine
  149.             // otherwise the event listeners won't be called and the file is lost
  150.             $this->updatedAt = new \DateTimeImmutable();
  151.         }
  152.     }
  154.     public function getImageFile(): ?File
  155.     {
  156.         return $this->imageFile;
  157.     }
  159.     /**
  160.      * @param string|null $phone
  161.      */
  162.     public function setPhone(?string $phone): void
  163.     {
  164.         $this->phone = $phone;
  165.     }
  167.     /**
  168.      * @return string|null
  169.      */
  170.     public function getImage(): ?string
  171.     {
  172.         return $this->image;
  173.     }
  175.     /**
  176.      * @param string|null $image
  177.      */
  178.     public function setImage(?string $image): void
  179.     {
  180.         $this->image = $image;
  181.     }
  183.     public function getId(): ?int
  184.     {
  185.         return $this->id;
  186.     }
  188.     public function getEmail(): ?string
  189.     {
  190.         return $this->email;
  191.     }
  193.     public function setEmail(string $email): self
  194.     {
  195.         $this->email = $email;
  197.         return $this;
  198.     }
  200.     /**
  201.      * A visual identifier that represents this user.
  202.      *
  203.      * @see UserInterface
  204.      */
  205.     public function getUserIdentifier(): string
  206.     {
  207.         return (string) $this->email;
  208.     }
  210.     /**
  211.      * @see UserInterface
  212.      */
  213.     public function getRoles(): array
  214.     {
  215.         $roles = $this->roles;
  216.         // guarantee every user at least has ROLE_USER
  217.         $roles[] = 'ROLE_USER';
  219.         return array_unique($roles);
  220.     }
  222.     public function setRoles(array $roles): self
  223.     {
  224.         $this->roles = $roles;
  226.         return $this;
  227.     }
  229.     /**
  230.      * @see PasswordAuthenticatedUserInterface
  231.      */
  232.     public function getPassword(): string
  233.     {
  234.         return $this->password;
  235.     }
  237.     public function setPassword(string $password): self
  238.     {
  239.         $this->password = $password;
  241.         return $this;
  242.     }
  244.     /**
  245.      * @see UserInterface
  246.      */
  247.     public function eraseCredentials()
  248.     {
  249.         // If you store any temporary, sensitive data on the user, clear it here
  250.         // $this->plainPassword = null;
  251.     }
  253.     public function isVerified(): bool
  254.     {
  255.         return $this->isVerified;
  256.     }
  258.     public function setIsVerified(bool $isVerified): self
  259.     {
  260.         $this->isVerified = $isVerified;
  262.         return $this;
  263.     }
  265.     public function getAdministrator(): ?self
  266.     {
  267.         return $this->administrator;
  268.     }
  270.     public function setAdministrator(?self $administrator): self
  271.     {
  272.         $this->administrator = $administrator;
  274.         return $this;
  275.     }
  277.     /**
  278.      * @return Collection<int, self>
  279.      */
  280.     public function getUsers(): Collection
  281.     {
  282.         return $this->users;
  283.     }
  285.     public function addUser(self $user): self
  286.     {
  287.         if (!$this->users->contains($user)) {
  288.             $this->users->add($user);
  289.             $user->setAdministrator($this);
  290.         }
  292.         return $this;
  293.     }
  295.     public function removeUser(self $user): self
  296.     {
  297.         if ($this->users->removeElement($user)) {
  298.             // set the owning side to null (unless already changed)
  299.             if ($user->getAdministrator() === $this) {
  300.                 $user->setAdministrator(null);
  301.             }
  302.         }
  304.         return $this;
  305.     }
  307.     /**
  308.      * @return Collection<int, Program>
  309.      */
  310.     public function getPrograms(): Collection
  311.     {
  312.         return $this->programs;
  313.     }
  315.     public function addProgram(Program $program): self
  316.     {
  317.         if (!$this->programs->contains($program)) {
  318.             $this->programs->add($program);
  319.             $program->addCollaborator($this);
  320.         }
  322.         return $this;
  323.     }
  325.     public function removeProgram(Program $program): self
  326.     {
  327.         if ($this->programs->removeElement($program)) {
  328.             $program->removeCollaborator($this);
  329.         }
  331.         return $this;
  332.     }
  334.     /**
  335.      * @return Collection<int, Client>
  336.      */
  337.     public function getClients(): Collection
  338.     {
  339.         return $this->clients;
  340.     }
  342.     public function addClient(Client $client): self
  343.     {
  344.         if (!$this->clients->contains($client)) {
  345.             $this->clients->add($client);
  346.             $client->setAdminUser($this);
  347.         }
  349.         return $this;
  350.     }
  352.     public function removeClient(Client $client): self
  353.     {
  354.         if ($this->clients->removeElement($client)) {
  355.             // set the owning side to null (unless already changed)
  356.             if ($client->getAdminUser() === $this) {
  357.                 $client->setAdminUser(null);
  358.             }
  359.         }
  361.         return $this;
  362.     }
  364.     /**
  365.      * @return Collection<int, Company>
  366.      */
  367.     public function getCompanies(): Collection
  368.     {
  369.         return $this->companies;
  370.     }
  372.     public function addCompany(Company $company): self
  373.     {
  374.         if (!$this->companies->contains($company)) {
  375.             $this->companies->add($company);
  376.             $company->setAdminUser($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function removeCompany(Company $company): self
  383.     {
  384.         if ($this->companies->removeElement($company)) {
  385.             // set the owning side to null (unless already changed)
  386.             if ($company->getAdminUser() === $this) {
  387.                 $company->setAdminUser(null);
  388.             }
  389.         }
  391.         return $this;
  392.     }
  394.     /**
  395.      * @return Collection<int, Groupe>
  396.      */
  397.     public function getGroupes(): Collection
  398.     {
  399.         return $this->groupes;
  400.     }
  402.     public function addGroupe(Groupe $groupe): self
  403.     {
  404.         if (!$this->groupes->contains($groupe)) {
  405.             $this->groupes->add($groupe);
  406.             $groupe->setAdminUser($this);
  407.         }
  409.         return $this;
  410.     }
  412.     public function removeGroupe(Groupe $groupe): self
  413.     {
  414.         if ($this->groupes->removeElement($groupe)) {
  415.             // set the owning side to null (unless already changed)
  416.             if ($groupe->getAdminUser() === $this) {
  417.                 $groupe->setAdminUser(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     /**
  425.      * @return Client|null
  426.      */
  427.     public function getClient(): ?Client
  428.     {
  429.         return $this->client;
  430.     }
  432.     /**
  433.      * @param Client|null $client
  434.      */
  435.     public function setClient(?Client $client): void
  436.     {
  437.         $this->client = $client;
  438.     }
  440.     public function isIsDisable(): ?bool
  441.     {
  442.         return $this->isDisable;
  443.     }
  445.     public function setIsDisable(bool $isDisable): self
  446.     {
  447.         $this->isDisable = $isDisable;
  449.         return $this;
  450.     }
  453. }