src/Entity/User.php line 37

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\Post;
  7. use App\Controller\Api\ApiRegisterController;
  8. use App\Repository\UserRepository;
  9. use App\Service\GeoIP;
  10. use App\Trait\DateTrait;
  11. use App\Trait\DeletableTrait;
  12. use App\Trait\Notifiable;
  13. use DateTimeImmutable;
  14. use DateTimeInterface;
  15. use Doctrine\Common\Collections\ArrayCollection;
  16. use Doctrine\Common\Collections\Collection;
  17. use Doctrine\ORM\Mapping as ORM;
  18. use GeoIp2\Exception\AddressNotFoundException;
  19. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  20. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  21. use Symfony\Component\Security\Core\User\UserInterface;
  22. use Symfony\Component\Serializer\Annotation\Groups;
  23. use Symfony\Component\Validator\Constraints as Assert;
  25. #[ORM\Entity(repositoryClass: UserRepository::class)]
  26. #[ORM\Table(name: '`user`')]
  27. #[UniqueEntity(fields: ['email'], message: "Cet adresse email est déjà utilisée pour un autre compte")]
  28. #[UniqueEntity(fields: ['phone'], message: "Ce numéro est déjà utilisé pour un autre compte")]
  29. #[ApiResource(operations: [
  30.     new Post(
  31.         uriTemplate: '/register',
  32.         controller: ApiRegisterController::class,
  33.         denormalizationContext: ['groups' => ['user:register']],
  34.         write: false
  35.     )
  36. ])]
  37. class User implements UserInterface, PasswordAuthenticatedUserInterface
  38. {
  39.     use DateTrait;
  40.     use Notifiable;
  41.     use DeletableTrait;
  43.     #[ORM\Id]
  44.     #[ORM\GeneratedValue]
  45.     #[ORM\Column]
  46.     #[Groups(['article:view'])]
  47.     private ?int $id = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     #[Groups(['user:register', 'article:view'])]
  51.     private ?string $lastname = null;
  53.     #[ORM\Column(length: 255)]
  54.     #[Groups(['user:register', 'article:view'])]
  55.     private ?string $firstname = null;
  57.     #[ORM\Column(length: 180, unique: true)]
  58.     #[Groups(['user:register'])]
  59.     private ?string $email = null;
  61.     #[ORM\Column]
  62.     private array $roles = [];
  64.     /**
  65.      * @var string The hashed password
  66.      */
  67.     #[ORM\Column]
  68.     #[Groups(['user:register'])]
  69.     private ?string $password = null;
  71.     #[ORM\Column(length: 15, unique: true)]
  72.     #[Groups(['user:register'])]
  73.     private ?string $phone = null;
  75.     #[ORM\Column(options: ["default" => false])]
  76.     private ?bool $isPhoneVerified = false;
  78.     #[ORM\ManyToOne(cascade: ["persist"])]
  79.     #[ORM\JoinColumn(nullable: true)]
  80.     private ?Attachment $thumbnail = null;
  82.     #[ORM\Column(length: 3, nullable: true, options: ["default" => "CD"])]
  83.     private ?string $country;
  85.     #[ORM\Column(length: 255, nullable: true)]
  86.     private ?string $lastLoginIp = null;
  88.     #[ORM\Column(nullable: true)]
  89.     private ?DateTimeImmutable $lastLoginAt = null;
  91.     #[ORM\Column(nullable: true)]
  92.     private ?DateTimeInterface $bannedAt = null;
  94.     #[ORM\Column(nullable: true)]
  95.     private ?string $confirmationToken = null;
  97.     #[ORM\Column(type: 'boolean')]
  98.     private bool $isVerified = false;
  100.     #[ORM\Column(type: 'string', nullable: true, options: ["default" => null])]
  101.     private ?string $theme = null;
  103.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Article::class, orphanRemoval: true)]
  104.     private Collection $articles;
  106.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Service::class, orphanRemoval: true)]
  107.     private Collection $services;
  109.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Establishment::class, orphanRemoval: true)]
  110.     private Collection $establishments;
  112.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ConnectionLog::class, orphanRemoval: true)]
  113.     private Collection $connectionLogs;
  115.     #[ORM\Column(options: ['default' => true])]
  116.     private ?bool $isActive = true;
  118.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: OTP::class, orphanRemoval: true)]
  119.     private Collection $OTPs;
  121.     #[ORM\Column(length: 255, nullable: true)]
  122.     private ?string $city = null;
  124.     #[ORM\Column(length: 255, nullable: true)]
  125.     private ?string $latitude = null;
  127.     #[ORM\Column(length: 255, nullable: true)]
  128.     private ?string $longitude = null;
  130.     #[ORM\Column(length: 255, nullable: true)]
  131.     private ?string $timeZone = null;
  133.     #[ORM\Column(length: 255, nullable: true)]
  134.     private ?string $postal = null;
  136.     #[ORM\Column(length: 255, nullable: true)]
  137.     private ?string $ip = null;
  139.     #[ORM\Column(length: 255, nullable: true)]
  140.     private ?string $subdivisions = null;
  142.     #[ORM\Column(length: 255, nullable: true)]
  143.     private ?string $isp = null;
  145.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Cms::class)]
  146.     private Collection $cms;
  148.     #[ORM\OneToOne(inversedBy: 'user', cascade: ['persist', 'remove'])]
  149.     private ?UserDetail $detail = null;
  151.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Mutuality::class)]
  152.     private Collection $mutualities;
  154.     #[ORM\Column(length: 255, options: ['default' => "fr"])]
  155.     #[Assert\Locale(
  156.         canonicalize: true,
  157.     )]
  158.     private ?string $locale;
  160.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Planning::class)]
  161.     private Collection $createdPlannings;
  163.     #[ORM\ManyToMany(targetEntity: Planning::class, mappedBy: 'users')]
  164.     private Collection $plannings;
  166.     public function __construct($ip = null)
  167.     {
  168.         if (is_null($this->createdAt)) $this->createdAt = new DateTimeImmutable();
  169.         $this->updatedAt = new DateTimeImmutable();
  170.         $this->OTPs = new ArrayCollection();
  171.         $this->country = 'CD';
  172.         $this->locale = 'fr';
  174.         if ($ip) $this->initGeoIp($ip);
  176.         $this->articles = new ArrayCollection();
  177.         $this->services = new ArrayCollection();
  178.         $this->establishments = new ArrayCollection();
  179.         $this->connectionLogs = new ArrayCollection();
  180.         $this->cms = new ArrayCollection();
  181.         $this->mutualities = new ArrayCollection();
  182.     }
  184.     public function __serialize(): array
  185.     {
  186.         return [$this->id, $this->phone, $this->email, $this->password,];
  187.     }
  189.     public function __unserialize(array $data): void
  190.     {
  191.         if (count($data) === 4) [$this->id, $this->phone, $this->email, $this->password,] = $data;
  192.     }
  194.     public function __toString(): string
  195.     {
  196.         return "$this->firstname $this->lastname";
  197.     }
  199.     public function getId(): ?int
  200.     {
  201.         return $this->id;
  202.     }
  204.     public function getName()
  205.     {
  206.         return "$this->firstname $this->lastname";
  207.     }
  209.     public function getLastname(): ?string
  210.     {
  211.         return $this->lastname;
  212.     }
  214.     public function setLastname(?string $lastname): self
  215.     {
  216.         $this->lastname = $lastname;
  218.         return $this;
  219.     }
  221.     public function getFirstname(): ?string
  222.     {
  223.         return $this->firstname;
  224.     }
  226.     public function setFirstname(string $firstname): self
  227.     {
  228.         $this->firstname = $firstname;
  230.         return $this;
  231.     }
  233.     public function getEmail(): ?string
  234.     {
  235.         return $this->email;
  236.     }
  238.     public function setEmail(string $email): self
  239.     {
  240.         $this->email = $email;
  242.         return $this;
  243.     }
  245.     /**
  246.      * A visual identifier that represents this user.
  247.      *
  248.      * @see UserInterface
  249.      */
  250.     public function getUserIdentifier(): string
  251.     {
  252.         return (string)$this->email;
  253.     }
  255.     /**
  256.      * @see UserInterface
  257.      */
  258.     public function getRoles(): array
  259.     {
  260.         $roles = $this->roles;
  261.         // guarantee every user at least has ROLE_USER
  262.         $roles[] = 'ROLE_USER';
  264.         return array_unique($roles);
  265.     }
  267.     public function setRoles(array $roles): self
  268.     {
  269.         $this->roles = $roles;
  271.         return $this;
  272.     }
  274.     /**
  275.      * @see PasswordAuthenticatedUserInterface
  276.      */
  277.     public function getPassword(): string
  278.     {
  279.         return $this->password;
  280.     }
  282.     public function setPassword(string $password): self
  283.     {
  284.         $this->password = $password;
  286.         return $this;
  287.     }
  289.     /**
  290.      * @see UserInterface
  291.      */
  292.     public function eraseCredentials()
  293.     {
  294.         // If you store any temporary, sensitive data on the user, clear it here
  295.         // $this->plainPassword = null;
  296.     }
  298.     public function getPhone(): ?string
  299.     {
  300.         return $this->phone;
  301.     }
  304.     public function getThumbnail(): ?Attachment
  305.     {
  306.         return $this->thumbnail;
  307.     }
  309.     public function setThumbnail(?Attachment $thumbnail): self
  310.     {
  311.         $this->thumbnail = $thumbnail;
  313.         return $this;
  314.     }
  316.     public function setPhone(string $phone): static
  317.     {
  318.        $this->phone = GeoIP::phoneResolve($phone, $this->country);
  320.         return $this;
  321.     }
  323.     public function isIsActive(): ?bool
  324.     {
  325.         return $this->isActive;
  326.     }
  328.     public function setIsActive(bool $isActive): static
  329.     {
  330.         $this->isActive = $isActive;
  332.         return $this;
  333.     }
  335.     public function getCity(): ?string
  336.     {
  337.         return $this->city;
  338.     }
  340.     public function setCity(?string $city): self
  341.     {
  342.         $this->city = $city;
  344.         return $this;
  345.     }
  347.     public function getLatitude(): ?string
  348.     {
  349.         return $this->latitude;
  350.     }
  352.     public function setLatitude(?string $latitude): self
  353.     {
  354.         $this->latitude = $latitude;
  356.         return $this;
  357.     }
  359.     public function getLongitude(): ?string
  360.     {
  361.         return $this->longitude;
  362.     }
  364.     public function setLongitude(?string $longitude): self
  365.     {
  366.         $this->longitude = $longitude;
  368.         return $this;
  369.     }
  371.     public function getTimeZone(): ?string
  372.     {
  373.         return $this->timeZone;
  374.     }
  376.     public function setTimeZone(?string $timeZone): self
  377.     {
  378.         $this->timeZone = $timeZone;
  380.         return $this;
  381.     }
  383.     public function getPostal(): ?string
  384.     {
  385.         return $this->postal;
  386.     }
  388.     public function setPostal(?string $postal): self
  389.     {
  390.         $this->postal = $postal;
  392.         return $this;
  393.     }
  395.     public function getIp(): ?string
  396.     {
  397.         return $this->ip;
  398.     }
  400.     public function setIp(?string $ip): self
  401.     {
  402.         $this->ip = $ip;
  404.         return $this;
  405.     }
  407.     public function getSubdivisions(): ?string
  408.     {
  409.         return $this->subdivisions;
  410.     }
  412.     public function setSubdivisions(?string $subdivisions): self
  413.     {
  414.         $this->subdivisions = $subdivisions;
  416.         return $this;
  417.     }
  419.     public function getIsp(): ?string
  420.     {
  421.         return $this->isp;
  422.     }
  424.     public function setIsp(?string $isp): self
  425.     {
  426.         $this->isp = $isp;
  428.         return $this;
  429.     }
  431.     public function getLastLogin(): ?DateTimeImmutable
  432.     {
  433.         return $this->lastLogin;
  434.     }
  436.     public function setLastLogin(DateTimeImmutable $lastLogin): self
  437.     {
  438.         $this->lastLogin = $lastLogin;
  440.         return $this;
  441.     }
  443.     public function getCountry(): ?string
  444.     {
  445.         return $this->country ?: 'CD';
  446.     }
  448.     public function setCountry(?string $country): self
  449.     {
  450.         $this->country = $country;
  452.         return $this;
  453.     }
  455.     public function getLastLoginIp(): ?string
  456.     {
  457.         return $this->lastLoginIp;
  458.     }
  460.     public function setLastLoginIp(?string $lastLoginIp): User
  461.     {
  462.         $this->lastLoginIp = $lastLoginIp;
  464.         return $this;
  465.     }
  467.     public function getLastLoginAt(): ?DateTimeImmutable
  468.     {
  469.         return $this->lastLoginAt;
  470.     }
  472.     public function setLastLoginAt(DateTimeImmutable $lastLoginAt): self
  473.     {
  474.         $this->lastLoginAt = $lastLoginAt;
  476.         return $this;
  477.     }
  479.     public function isBanned(): bool
  480.     {
  481.         return null !== $this->bannedAt;
  482.     }
  484.     public function getBannedAt(): ?DateTimeInterface
  485.     {
  486.         return $this->bannedAt;
  487.     }
  489.     public function setBannedAt(?DateTimeInterface $bannedAt): User
  490.     {
  491.         $this->bannedAt = $bannedAt;
  493.         return $this;
  494.     }
  496.     public function getConfirmationToken(): ?string
  497.     {
  498.         return $this->confirmationToken;
  499.     }
  501.     public function setConfirmationToken(?string $confirmationToken): User
  502.     {
  503.         $this->confirmationToken = $confirmationToken;
  505.         return $this;
  506.     }
  508.     public function canLogin(): bool
  509.     {
  510.         return !$this->isBanned() && null === $this->getConfirmationToken();
  511.     }
  513.     public function isVerified(): bool
  514.     {
  515.         return $this->isVerified;
  516.     }
  518.     public function setIsVerified(bool $isVerified): self
  519.     {
  520.         $this->isVerified = $isVerified;
  522.         return $this;
  523.     }
  525.     public function getTheme(): ?string
  526.     {
  527.         return $this->theme;
  528.     }
  530.     public function setTheme(?string $theme): self
  531.     {
  532.         $this->theme = $theme;
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection<int, Article>
  539.      */
  540.     public function getArticles(): Collection
  541.     {
  542.         return $this->articles;
  543.     }
  545.     public function addArticle(Article $article): self
  546.     {
  547.         if (!$this->articles->contains($article)) {
  548.             $this->articles->add($article);
  549.             $article->setAuthor($this);
  550.         }
  552.         return $this;
  553.     }
  555.     public function removeArticle(Article $article): self
  556.     {
  557.         if ($this->articles->removeElement($article)) {
  558.             if ($article->getAuthor() === $this) {
  559.                 $article->setAuthor(null);
  560.             }
  561.         }
  563.         return $this;
  564.     }
  566.     /**
  567.      * @return Collection<int, Service>
  568.      */
  569.     public function getServices(): Collection
  570.     {
  571.         return $this->services;
  572.     }
  574.     public function addService(Service $service): self
  575.     {
  576.         if (!$this->services->contains($service)) {
  577.             $this->services->add($service);
  578.             $service->setAuthor($this);
  579.         }
  581.         return $this;
  582.     }
  584.     public function removeService(Service $service): self
  585.     {
  586.         if ($this->services->removeElement($service)) {
  587.             // set the owning side to null (unless already changed)
  588.             if ($service->getAuthor() === $this) {
  589.                 $service->setAuthor(null);
  590.             }
  591.         }
  593.         return $this;
  594.     }
  596.     /**
  597.      * @return Collection<int, Establishment>
  598.      */
  599.     public function getEstablishments(): Collection
  600.     {
  601.         return $this->establishments;
  602.     }
  604.     public function addEstablishment(Establishment $establishment): self
  605.     {
  606.         if (!$this->establishments->contains($establishment)) {
  607.             $this->establishments->add($establishment);
  608.             $establishment->setUser($this);
  609.         }
  611.         return $this;
  612.     }
  614.     public function removeEstablishment(Establishment $establishment): self
  615.     {
  616.         if ($this->establishments->removeElement($establishment)) {
  617.             // set the owning side to null (unless already changed)
  618.             if ($establishment->getUser() === $this) {
  619.                 $establishment->setUser(null);
  620.             }
  621.         }
  623.         return $this;
  624.     }
  626.     /**
  627.      * @return Collection<int, ConnectionLog>
  628.      */
  629.     public function getConnectionLogs(): Collection
  630.     {
  631.         return $this->connectionLogs;
  632.     }
  634.     public function addConnectionLog(ConnectionLog $connectionLog): self
  635.     {
  636.         if (!$this->connectionLogs->contains($connectionLog)) {
  637.             $this->connectionLogs->add($connectionLog);
  638.             $connectionLog->setUser($this);
  639.         }
  641.         return $this;
  642.     }
  644.     public function removeConnectionLog(ConnectionLog $connectionLog): self
  645.     {
  646.         if ($this->connectionLogs->removeElement($connectionLog)) {
  647.             // set the owning side to null (unless already changed)
  648.             if ($connectionLog->getUser() === $this) {
  649.                 $connectionLog->setUser(null);
  650.             }
  651.         }
  653.         return $this;
  654.     }
  656.     /**
  657.      * @return Collection<int, Cms>
  658.      */
  659.     public function getCms(): Collection
  660.     {
  661.         return $this->cms;
  662.     }
  664.     public function addCm(Cms $cm): self
  665.     {
  666.         if (!$this->cms->contains($cm)) {
  667.             $this->cms->add($cm);
  668.             $cm->setCreatedBy($this);
  669.         }
  671.         return $this;
  672.     }
  674.     public function removeCm(Cms $cm): self
  675.     {
  676.         if ($this->cms->removeElement($cm)) {
  677.             // set the owning side to null (unless already changed)
  678.             if ($cm->getCreatedBy() === $this) {
  679.                 $cm->setCreatedBy(null);
  680.             }
  681.         }
  683.         return $this;
  684.     }
  686.     /**
  687.      * @param string $ip
  688.      * @throws \Exception
  689.      */
  690.     public function initGeoIp(string $ip): void
  691.     {
  692.         try {
  693.             $isLocal = in_array($ip, ['127.0.0.1', '::1']);
  694.             $ip = $isLocal ? '41.78.192.90' : $ip;
  695.             $record = GeoIP::check($ip);
  697.             $this->setCountry($record->countryCode ?? null); // 'US'
  698.             $this->setIsp($record->isp ?? null);
  699.             $this->setSubdivisions($record->regionName ?? null);
  700.             $this->setCity($record->city ?? null); // 'Minneapolis'
  701.             $this->setPostal($record->zip ?? null); // '55455'
  702.             $this->setIp($record->query ?? null);
  703.             $this->setTimeZone($record->timezone ?? null);
  704.             $this->setLatitude($record->lat ?? null); // 44.9733
  705.             $this->setLongitude($record->lon ?? null);
  706.         } catch (AddressNotFoundException $ex) {
  707.             throw new \Exception("It wasn't possible to retrieve information about the providen IP");
  708.         }
  709.     }
  711.     public function isIsPhoneVerified(): ?bool
  712.     {
  713.         return $this->isPhoneVerified;
  714.     }
  716.     public function setIsPhoneVerified(bool $isPhoneVerified): static
  717.     {
  718.         $this->isPhoneVerified = $isPhoneVerified;
  720.         return $this;
  721.     }
  723.     public function getGender(): ?string
  724.     {
  725.         return $this->gender;
  726.     }
  728.     public function setGender(string $gender): static
  729.     {
  730.         $this->gender = $gender;
  732.         return $this;
  733.     }
  735.     public function getDetail(): ?UserDetail
  736.     {
  737.         return $this->detail;
  738.     }
  740.     public function setDetail(?UserDetail $detail): static
  741.     {
  742.         $this->detail = $detail;
  744.         return $this;
  745.     }
  747.     /**
  748.      * @return Collection<int, Mutuality>
  749.      */
  750.     public function getMutualities(): Collection
  751.     {
  752.         return $this->mutualities;
  753.     }
  755.     public function addMutuality(Mutuality $mutuality): static
  756.     {
  757.         if (!$this->mutualities->contains($mutuality)) {
  758.             $this->mutualities->add($mutuality);
  759.             $mutuality->setUser($this);
  760.         }
  762.         return $this;
  763.     }
  765.     public function removeMutuality(Mutuality $mutuality): static
  766.     {
  767.         if ($this->mutualities->removeElement($mutuality)) {
  768.             // set the owning side to null (unless already changed)
  769.             if ($mutuality->getUser() === $this) {
  770.                 $mutuality->setUser(null);
  771.             }
  772.         }
  774.         return $this;
  775.     }
  777.     public function getFullname(): string
  778.     {
  779.         return $this->firstname . ' ' . $this->lastname;
  780.     }
  782.     public function getLocale(): ?string
  783.     {
  784.         return $this->locale;
  785.     }
  787.     public function setLocale(string $locale): static
  788.     {
  789.         $this->locale = $locale;
  791.         return $this;
  792.     }
  793. }