src/Entity/User.php line 28

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use App\Service\ToolsService;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Hslavich\OneloginSamlBundle\Security\User\SamlUserInterface;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Validator\Constraints as Assert;
  15. use Symfony\Component\Serializer\Annotation\Groups;
  17. /**
  18.  * @ORM\Entity(repositoryClass=UserRepository::class)
  19.  * @ORM\Table(name="`user`")
  20.  * @UniqueEntity(
  21.  *     fields={"email", "category"},
  22.  *     errorPath="email",
  23.  *     message="The email is already in use",
  24.  *     ignoreNull=false
  25.  * )
  26.  * @ORM\HasLifecycleCallbacks()
  27.  */
  28. class User implements UserInterface, PasswordAuthenticatedUserInterface, SamlUserInterface
  29. {
  30.     const GROUP_ADMIN = 'admin';
  31.     const GROUP_COMPANY = 'company';
  32.     const GROUP_CLIENT = 'client';
  33.     const GROUP_SPECIALIST = 'specialist';
  34.     const ROLE_USER = 'ROLE_USER';
  35.     const ROLE_CLIENT = 'ROLE_CLIENT';
  36.     const ROLE_COMPANY = 'ROLE_COMPANY';
  37.     const ROLE_EXTERNAL_COMPANY = 'ROLE_EXTERNAL_COMPANY';
  38.     const ROLE_ADMIN = 'ROLE_ADMIN';
  39.     const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
  40.     const ROLE_SPECIALIST = 'ROLE_SPECIALIST';
  42.     const GROUPS = [
  43.         self::GROUP_ADMIN,
  44.         self::GROUP_COMPANY,
  45.         self::GROUP_CLIENT,
  46.         self::GROUP_SPECIALIST,
  47.     ];
  49.     /**
  50.      * @ORM\Id
  51.      * @ORM\GeneratedValue
  52.      * @ORM\Column(type="integer")
  53.      * @Groups("user_favorite:read")
  54.      */
  55.     protected $id;
  57.     /**
  58.      * @ORM\Column(type="string", length=180)
  59.      * @Assert\Email
  60.      * @Assert\NotBlank
  61.      * @Groups("user_favorite:read")
  62.      */
  63.     protected $email;
  65.     /**
  66.      * @ORM\Column(type="json")
  67.      * @Groups("user_favorite:read")
  68.      */
  69.     protected $roles = [];
  71.     /**
  72.      * @var string|null The hashed password
  73.      * @ORM\Column(type="string")
  74.      * @Assert\Length(min="8", max="255")
  75.      * @Assert\NotBlank
  76.      */
  77.     protected $password = null;
  79.     /**
  80.      * @ORM\Column(type="datetime")
  81.      */
  82.     protected $createdAt;
  84.     /**
  85.      * @ORM\Column(type="datetime", nullable=true)
  86.      */
  87.     protected $lastLogin;
  89.     /**
  90.      * @ORM\Column(type="string", length=255)
  91.      * @Assert\NotBlank()
  92.      * @Assert\Length(max="255", min="0")
  93.      * @Groups("user_favorite:read")
  94.      * @var string
  95.      */
  96.     protected $name = '';
  98.     /**
  99.      * @ORM\Column(type="string", length=50)
  100.      * @Assert\Choice(choices=self::GROUPS)
  101.      * @Groups("user_favorite:read")
  102.      */
  103.     protected $category;
  105.     /**
  106.      * @ORM\Column(type="boolean")
  107.      * @Groups("user_favorite:read")
  108.      */
  109.     protected $active = true;
  111.     /**
  112.      * @ORM\Column(type="datetime", nullable=true)
  113.      */
  114.     protected $banStart;
  116.     /**
  117.      * @ORM\Column(type="datetime", nullable=true)
  118.      */
  119.     protected $banEnd;
  121.     /**
  122.      * @ORM\Column(type="string", length=255, nullable=true, unique=true)
  123.      */
  124.     protected $resetToken;
  126.     /**
  127.      * @ORM\OneToOne(targetEntity=Specialist::class, mappedBy="user", cascade={"persist", "remove"})
  128.      */
  129.     protected $specialist;
  131.     /**
  132.      * @ORM\OneToOne(targetEntity=Company::class, mappedBy="user", cascade={"persist", "remove"})
  133.      */
  134.     protected $company;
  136.     /**
  137.      * @ORM\OneToOne(targetEntity=Client::class, mappedBy="user", cascade={"persist", "remove"})
  138.      */
  139.     protected $client;
  141.     /**
  142.      * @var bool
  143.      */
  144.     protected $_hashPwd = false;
  146.     /**
  147.      * @var null|string
  148.      */
  149.     private $token = null;
  151.     /**
  152.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="owner")
  153.      */
  154.     private $documents;
  156.     /**
  157.      * @ORM\OneToMany(targetEntity=MarketplaceReservation::class, mappedBy="user")
  158.      */
  159.     private $marketplaceReservations;
  161.     /**
  162.      * @ORM\Column(type="string", length=255, nullable=true)
  163.      * @Groups("user_favorite:read")
  164.      */
  165.     private $firstName;
  167.     /**
  168.      * @ORM\Column(type="string", length=255, nullable=true)
  169.      * @Groups("user_favorite:read")
  170.      */
  171.     private $lastName;
  173.     /**
  174.      * @ORM\OneToMany(targetEntity=UserFavorite::class, mappedBy="user", cascade={"persist", "remove"})
  175.      */
  176.     private $favorites;
  178.     /**
  179.      * @ORM\ManyToOne(targetEntity=Segmentation::class, inversedBy="users", cascade={"persist"})
  180.      */
  181.     private $segmentation;
  183.     /**
  184.      * @ORM\Column(type="string", length=255, nullable=true, options={"default": "FR"})
  185.      */
  186.     private $country;
  188.     public function __construct()
  189.     {
  190.         $this->createdAt = new \DateTime();
  191.         $this->roles[] = 'ROLE_USER';
  192.         $this->documents = new ArrayCollection();
  193.         $this->marketplaceReservations = new ArrayCollection();
  194.         $this->favorites = new ArrayCollection();
  195.     }
  197.     public function getId(): ?int
  198.     {
  199.         return $this->id;
  200.     }
  202.     public function getEmail(): ?string
  203.     {
  204.         return $this->email;
  205.     }
  207.     public function setEmail(string $email): self
  208.     {
  209.         $this->email = $email;
  211.         return $this;
  212.     }
  214.     /**
  215.      * A visual identifier that represents this user.
  216.      *
  217.      * @see UserInterface
  218.      */
  219.     public function getUserIdentifier(): string
  220.     {
  221.         return (string)$this->email;
  222.     }
  224.     /**
  225.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  226.      */
  227.     public function getUsername(): string
  228.     {
  229.         return (string)$this->email;
  230.     }
  232.     /**
  233.      * @see UserInterface
  234.      */
  235.     public function getRoles(): array
  236.     {
  237.         $roles = $this->roles;
  238.         // guarantee every user at least has ROLE_USER
  239.         $roles[] = 'ROLE_USER';
  241.         return array_unique($roles);
  242.     }
  244.     /**
  245.      * @param string $role
  246.      * @return bool
  247.      */
  248.     public function hasRole(string $role): bool
  249.     {
  250.         return in_array($role, $this->roles);
  251.     }
  253.     /**
  254.      * @see UserInterface
  255.      */
  256.     public function addRole(string $role): self
  257.     {
  258.         if (!in_array($role, $this->roles)) {
  259.             $this->roles[] = $role;
  260.         }
  261.         return $this;
  262.     }
  264.     /**
  265.      * @see UserInterface
  266.      */
  267.     public function removeRole(string $role): self
  268.     {
  269.         if (in_array($role, $this->roles)) {
  270.             foreach ($this->roles as $key => $item) {
  271.                 if ($item === $role) {
  272.                     unset($this->roles[$key]);
  273.                 }
  274.             }
  275.             $this->roles = array_values($this->roles);
  276.         }
  277.         return $this;
  278.     }
  280.     public function setRoles(array $roles): self
  281.     {
  282.         $this->roles = $roles;
  284.         return $this;
  285.     }
  287.     /**
  288.      * @see PasswordAuthenticatedUserInterface
  289.      */
  290.     public function getPassword(): ?string
  291.     {
  292.         return $this->password;
  293.     }
  295.     /**
  296.      * This setter also checks if the password has changed it will rehash it
  297.      * @param string|null $password New password
  298.      * @param bool $hash Forces rehash of password
  299.      * @return $this
  300.      */
  301.     public function setPassword(?string $password, bool $hash = false): self
  302.     {
  303.         if (!empty($password) && ($this->password !== $password || $hash)) {
  304.             $this->_hashPwd = true;
  305.         }
  306.         if (!empty($password)){
  307.             $this->password = $password;
  308.         }
  309.         return $this;
  310.     }
  312.     /**
  313.      * Returning a salt is only needed, if you are not using a modern
  314.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  315.      *
  316.      * @see UserInterface
  317.      */
  318.     public function getSalt(): ?string
  319.     {
  320.         return null;
  321.     }
  323.     /**
  324.      * @see UserInterface
  325.      */
  326.     public function eraseCredentials()
  327.     {
  328.         // If you store any temporary, sensitive data on the user, clear it here
  329.         // $this->plainPassword = null;
  330.     }
  332.     public function getCreatedAt(): ?\DateTime
  333.     {
  334.         return $this->createdAt;
  335.     }
  337.     public function setCreatedAt(\DateTime $createdAt): self
  338.     {
  339.         $this->createdAt = $createdAt;
  341.         return $this;
  342.     }
  344.     public function getLastLogin(): ?\DateTimeInterface
  345.     {
  346.         return $this->lastLogin;
  347.     }
  349.     public function setLastLogin(?\DateTimeInterface $lastLogin): self
  350.     {
  351.         $this->lastLogin = $lastLogin;
  353.         return $this;
  354.     }
  356.     public function getName(): ?string
  357.     {
  358.         return $this->name;
  359.     }
  361.     public function setName(?string $name): self
  362.     {
  363.         $this->name = $name;
  365.         return $this;
  366.     }
  368.     public function getCategory(): ?string
  369.     {
  370.         return $this->category;
  371.     }
  373.     public function setCategory(string $category): self
  374.     {
  375.         $this->category = $category;
  377.         return $this;
  378.     }
  380.     public function getActive(): ?bool
  381.     {
  382.         return $this->active;
  383.     }
  385.     public function setActive(bool $active): self
  386.     {
  387.         $this->active = $active;
  389.         return $this;
  390.     }
  392.     public function getBanStart(): ?\DateTimeInterface
  393.     {
  394.         return $this->banStart;
  395.     }
  397.     public function setBanStart(?\DateTimeInterface $banStart): self
  398.     {
  399.         $this->banStart = $banStart;
  401.         return $this;
  402.     }
  404.     public function getBanEnd(): ?\DateTimeInterface
  405.     {
  406.         return $this->banEnd;
  407.     }
  409.     public function setBanEnd(?\DateTimeInterface $banEnd): self
  410.     {
  411.         $this->banEnd = $banEnd;
  413.         return $this;
  414.     }
  416.     public function getResetToken(): ?string
  417.     {
  418.         return $this->resetToken;
  419.     }
  421.     public function setResetToken(?string $resetToken): self
  422.     {
  423.         $this->resetToken = $resetToken;
  425.         return $this;
  426.     }
  428.     public function getSpecialist(): ?Specialist
  429.     {
  430.         return $this->specialist;
  431.     }
  433.     public function setSpecialist(Specialist $specialist): self
  434.     {
  435.         // set the owning side of the relation if necessary
  436.         if ($specialist->getUser() !== $this) {
  437.             $specialist->setUser($this);
  438.         }
  440.         $this->specialist = $specialist;
  442.         return $this;
  443.     }
  445.     public function getCompany(): ?Company
  446.     {
  447.         return $this->company;
  448.     }
  450.     public function setCompany(Company $company): self
  451.     {
  452.         $this->company = $company;
  454.         return $this;
  455.     }
  457.     public function getClient(): ?Client
  458.     {
  459.         return $this->client;
  460.     }
  462.     public function setClient(Client $client): self
  463.     {
  464.         // set the owning side of the relation if necessary
  465.         if ($client->getUser() !== $this) {
  466.             $client->setUser($this);
  467.         }
  469.         $this->client = $client;
  471.         return $this;
  472.     }
  474.     /**
  475.      * @return bool
  476.      */
  477.     public function isHashPwd(): bool
  478.     {
  479.         return $this->_hashPwd;
  480.     }
  482.     /**
  483.      * @return string
  484.      */
  485.     public function __toString()
  486.     {
  487.         return $this->name;
  488.     }
  490.     /**
  491.      * @ORM\PrePersist()
  492.      */
  493.     public function updateName()
  494.     {
  495.         if ($this->company instanceof Company) {
  496.             $this->name = $this->company->getName();
  497.         } elseif ($this->specialist instanceof Specialist) {
  498.             $this->name = (string)$this->specialist;
  499.         } elseif ($this->client instanceof Client) {
  500.             $this->name = (string)$this->client;
  501.         }
  502.     }
  504.     /**
  505.      * @param string|null $token
  506.      * @return User
  507.      */
  508.     public function setToken(?string $token): User
  509.     {
  510.         $this->token = $token;
  511.         return $this;
  512.     }
  514.     /**
  515.      * @return string|null
  516.      */
  517.     public function getToken(): ?string
  518.     {
  519.         return $this->token;
  520.     }
  522.     public function setSamlAttributes(array $attributes)
  523.     {
  524.         $this->token = $attributes['sessionIndex'];
  526.         $data = [];
  527.         foreach ($attributes as $key => $value) {
  528.             $data[ToolsService::toCamelCase($key)] = $value;
  529.         }
  531.         if (!empty($data['email'])) {
  532.             if(is_array($data['email'])) $this->email = $data['email'][0];
  533.             elseif (is_string($data['email'])) $this->email = $data['email'];
  534.         }
  536.         if (!empty($data['firstName'])) {
  537.             if(is_array($data['firstName'])) $this->firstName = $data['firstName'][0];
  538.             elseif (is_string($data['firstName'])) $this->firstName = $data['firstName'];
  539.         }
  541.         if (!empty($data['lastName'])) {
  542.             if(is_array($data['lastName'])) $this->lastName = $data['lastName'][0];
  543.             elseif (is_string($data['lastName'])) $this->lastName = $data['lastName'];
  544.         }
  546.         if (!empty($data['country'])) {
  547.             if(is_array($data['country'])) $this->country = $data['country'][0];
  548.             elseif (is_string($data['country'])) $this->country = $data['country'];
  549.         }
  550.     }
  552.     /**
  553.      * @return Collection<int, Document>
  554.      */
  555.     public function getDocuments(): Collection
  556.     {
  557.         return $this->documents;
  558.     }
  560.     public function addDocument(Document $document): self
  561.     {
  562.         if (!$this->documents->contains($document)) {
  563.             $this->documents[] = $document;
  564.             $document->setOwner($this);
  565.         }
  567.         return $this;
  568.     }
  570.     public function removeDocument(Document $document): self
  571.     {
  572.         if ($this->documents->removeElement($document)) {
  573.             // set the owning side to null (unless already changed)
  574.             if ($document->getOwner() === $this) {
  575.                 $document->setOwner(null);
  576.             }
  577.         }
  579.         return $this;
  580.     }
  582.     /**
  583.      * @return Collection<int, MarketplaceReservation>
  584.      */
  585.     public function getMarketplaceReservations(): Collection
  586.     {
  587.         return $this->marketplaceReservations;
  588.     }
  590.     public function addMarketplaceReservation(MarketplaceReservation $marketplaceReservation): self
  591.     {
  592.         if (!$this->marketplaceReservations->contains($marketplaceReservation)) {
  593.             $this->marketplaceReservations[] = $marketplaceReservation;
  594.             $marketplaceReservation->setUser($this);
  595.         }
  597.         return $this;
  598.     }
  600.     public function removeMarketplaceReservation(MarketplaceReservation $marketplaceReservation): self
  601.     {
  602.         if ($this->marketplaceReservations->removeElement($marketplaceReservation)) {
  603.             // set the owning side to null (unless already changed)
  604.             if ($marketplaceReservation->getUser() === $this) {
  605.                 $marketplaceReservation->setUser(null);
  606.             }
  607.         }
  609.         return $this;
  610.     }
  612.     public function getFirstName(): ?string
  613.     {
  614.         return $this->firstName;
  615.     }
  617.     public function setFirstName(?string $firstName): self
  618.     {
  619.         $this->firstName = $firstName;
  621.         return $this;
  622.     }
  624.     public function getLastName(): ?string
  625.     {
  626.         return $this->lastName;
  627.     }
  629.     public function setLastName(?string $lastName): self
  630.     {
  631.         $this->lastName = $lastName;
  633.         return $this;
  634.     }
  636.     /**
  637.      * @return Collection<int, UserFavorite>
  638.      */
  639.     public function getFavorites(): Collection
  640.     {
  641.         return $this->favorites;
  642.     }
  644.     public function addFavorite(UserFavorite $favorite): self
  645.     {
  646.         if (!$this->favorites->contains($favorite)) {
  647.             $this->favorites[] = $favorite;
  648.             $favorite->setUser($this);
  649.         }
  651.         return $this;
  652.     }
  654.     public function removeFavorite(UserFavorite $favorite): self
  655.     {
  656.         if ($this->favorites->removeElement($favorite)) {
  657.             // set the owning side to null (unless already changed)
  658.             if ($favorite->getUser() === $this) {
  659.                 $favorite->setUser(null);
  660.             }
  661.         }
  663.         return $this;
  664.     }
  666.     public function getSegmentation(): ?Segmentation
  667.     {
  668.         return $this->segmentation;
  669.     }
  671.     public function setSegmentation(?Segmentation $segmentation): self
  672.     {
  673.         $this->segmentation = $segmentation;
  675.         return $this;
  676.     }
  678.     public function getCountry(): ?string
  679.     {
  680.         return $this->country;
  681.     }
  683.     public function setCountry(?string $country): self
  684.     {
  685.         $this->country = $country;
  687.         return $this;
  688.     }
  689. }