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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use libphonenumber\PhoneNumberUtil;
  11. use libphonenumber\NumberParseException;
  12. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  13. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  14. use Symfony\Component\Security\Core\User\UserInterface;
  16. #[ORM\Entity(repositoryClass: UserRepository::class)]
  17. #[UniqueEntity(fields: ['email'], message: 'Cette adresse mail est déjà associée à un compte.')]
  18. #[UniqueEntity(fields: ['companyName'], message: 'Ce nom de compagnie est déjà associé à un compte.')]
  19. class User implements UserInterface, PasswordAuthenticatedUserInterface
  20. {
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column]
  24.     private ?int $id = null;
  26.     #[ORM\Column(length: 180, unique: true)]
  27.     private ?string $email = null;
  29.     #[ORM\Column]
  30.     private array $roles = [];
  32.     /**
  33.      * @var string The hashed password
  34.      */
  35.     #[ORM\Column]
  36.     private ?string $password = null;
  38.     #[ORM\Column(length: 100)]
  39.     private ?string $firstName = null;
  41.     #[ORM\Column(length: 100)]
  42.     private ?string $lastName = null;
  44.     #[ORM\Column(type: 'boolean')]
  45.     private $isVerified = false;
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     private ?string $image = null;
  50.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Article::class)]
  51.     private Collection $articles;
  53.     #[ORM\Column(type: Types::TEXT)]
  54.     private ?string $customerKey = null;
  56.     #[ORM\Column(nullable: true)]
  57.     private ?float $credit = null;
  59.     #[ORM\Column(length: 100)]
  60.     private ?string $phoneNumber = null;
  62.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserPackage::class)]
  63.     private Collection $userPackages;
  65.     #[ORM\Column(nullable: true)]
  66.     private ?int $pbnId = null;
  68.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  69.     private ?string $customerSubjects = null;
  71.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Order::class, orphanRemoval: true)]
  72.     private Collection $orders;
  74.     #[ORM\Column(length: 100, nullable: true)]
  75.     private ?string $wordpressUsername = null;
  77.     #[ORM\Column(length: 150, nullable: true)]
  78.     private ?string $wordpressPassword = null;
  80.     #[ORM\Column(length: 100, nullable: true)]
  81.     private ?string $wordpressUrl = null;
  83.     #[ORM\Column(length: 60, nullable: true , options: ['default' => 'yoastseo'])]
  84.     private ?string $seoPlugin = null;
  86.     #[ORM\Column(options: ['default' => 0])]
  87.     private ?bool $autoPublish = null;
  89.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  90.     private ?\DateTimeInterface $creationDate = null;
  92.     #[ORM\Column(type: Types::SMALLINT, nullable: true, options: ['default' => 3])]
  93.     private ?int $numberOfTestArticle = null;
  95.     #[ORM\Column(length: 100, nullable: true, unique: true)]
  96.     private ?string $companyName = null;
  98.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  99.     private ?string $tempToken = null;
  101.     #[ORM\Column(options: ['default' => 0])]
  102.     private ?bool $memberOptionAutoPublish = null;
  104.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Sms::class, orphanRemoval: true)]
  105.     private Collection $sms;
  107.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ProposedArticle::class, orphanRemoval: true)]
  108.     private Collection $proposedArticles;
  110.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notification::class)]
  111.     private Collection $notifications;
  113.     public function __construct()
  114.     {
  115.         $this->articles = new ArrayCollection();
  116.         $this->packages = new ArrayCollection();
  117.         $this->userPackages = new ArrayCollection();
  118.         $this->orders = new ArrayCollection();
  119.         $this->sms = new ArrayCollection();
  120.         $this->proposedArticles = new ArrayCollection();
  121.         $this->notifications = new ArrayCollection();
  122.     }
  124.     public function getId(): ?int
  125.     {
  126.         return $this->id;
  127.     }
  129.     public function getEmail(): ?string
  130.     {
  131.         return $this->email;
  132.     }
  134.     public function setEmail(string $email): static
  135.     {
  136.         $this->email = $email;
  138.         return $this;
  139.     }
  141.     /**
  142.      * A visual identifier that represents this user.
  143.      *
  144.      * @see UserInterface
  145.      */
  146.     public function getUserIdentifier(): string
  147.     {
  148.         return (string) $this->email;
  149.     }
  151.     /**
  152.      * @see UserInterface
  153.      */
  154.     public function getRoles(): array
  155.     {
  156.         $roles = $this->roles;
  157.         // guarantee every user at least has ROLE_USER
  158.         $roles[] = 'ROLE_USER';
  160.         return array_unique($roles);
  161.     }
  163.     public function setRoles(array $roles): static
  164.     {
  165.         $this->roles = $roles;
  167.         return $this;
  168.     }
  170.     /**
  171.      * @see PasswordAuthenticatedUserInterface
  172.      */
  173.     public function getPassword(): string
  174.     {
  175.         return $this->password;
  176.     }
  178.     public function setPassword(string $password): static
  179.     {
  180.         $this->password = $password;
  182.         return $this;
  183.     }
  185.     /**
  186.      * @see UserInterface
  187.      */
  188.     public function eraseCredentials(): void
  189.     {
  190.         // If you store any temporary, sensitive data on the user, clear it here
  191.         // $this->plainPassword = null;
  192.     }
  194.     public function getFirstName(): ?string
  195.     {
  196.         return $this->firstName;
  197.     }
  199.     public function setFirstName(string $firstName): static
  200.     {
  201.         $this->firstName = $firstName;
  203.         return $this;
  204.     }
  206.     public function getLastName(): ?string
  207.     {
  208.         return $this->lastName;
  209.     }
  211.     public function setLastName(string $lastName): static
  212.     {
  213.         $this->lastName = $lastName;
  215.         return $this;
  216.     }
  218.     public function isVerified(): bool
  219.     {
  220.         return $this->isVerified;
  221.     }
  223.     public function setIsVerified(bool $isVerified): static
  224.     {
  225.         $this->isVerified = $isVerified;
  227.         return $this;
  228.     }
  230.     public function getImage(): ?string
  231.     {
  232.         return $this->image;
  233.     }
  235.     public function setImage(?string $image): static
  236.     {
  237.         $this->image = $image;
  239.         return $this;
  240.     }
  242.     /**
  243.      * @return Collection<int, Article>
  244.      */
  245.     public function getArticles(): Collection
  246.     {
  247.         return $this->articles;
  248.     }
  250.     public function addArticle(Article $article): static
  251.     {
  252.         if (!$this->articles->contains($article)) {
  253.             $this->articles->add($article);
  254.             $article->setUser($this);
  255.         }
  257.         return $this;
  258.     }
  260.     public function removeArticle(Article $article): static
  261.     {
  262.         if ($this->articles->removeElement($article)) {
  263.             // set the owning side to null (unless already changed)
  264.             if ($article->getUser() === $this) {
  265.                 $article->setUser(null);
  266.             }
  267.         }
  269.         return $this;
  270.     }
  272.     public function getCustomerKey(): ?string
  273.     {
  274.         return $this->customerKey;
  275.     }
  277.     public function setCustomerKey(string $customerKey): static
  278.     {
  279.         $this->customerKey = $customerKey;
  281.         return $this;
  282.     }
  284.     public function getCredit(): ?float
  285.     {
  286.         return $this->credit;
  287.     }
  289.     public function setCredit(?float $credit): static
  290.     {
  291.         $this->credit = $credit;
  293.         return $this;
  294.     }
  296.     public function getPhoneNumber(): ?string
  297.     {
  298.         return $this->phoneNumber;
  299.     }
  301.     public function setPhoneNumber(string $phoneNumber): self
  302.     {
  303.         /*
  304.         $phoneUtil = PhoneNumberUtil::getInstance();
  305.         
  306.         try {
  307.             $numberProto = $phoneUtil->parse($phoneNumber, "FR");
  308.             if ($phoneUtil->isValidNumber($numberProto)) {
  309.                 $this->phoneNumber = $phoneUtil->format($numberProto, \libphonenumber\PhoneNumberFormat::E164);
  310.             } else {
  311.                 $this->phoneNumber = "null";
  312.                 //throw new \InvalidArgumentException("Numéro de téléphone invalide.");
  313.             }
  314.         } catch (NumberParseException $e) {
  315.             $this->phoneNumber = "null";
  316.             //throw new \InvalidArgumentException("Erreur de parsing du numéro de téléphone: " . $e->getMessage());
  317.         }
  318.     
  319.         return $this;*/
  320.         $this->phoneNumber = $phoneNumber;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, UserPackage>
  327.      */
  328.     public function getUserPackages(): Collection
  329.     {
  330.         return $this->userPackages;
  331.     }
  333.     public function addUserPackage(UserPackage $userPackage): static
  334.     {
  335.         if (!$this->userPackages->contains($userPackage)) {
  336.             $this->userPackages->add($userPackage);
  337.             $userPackage->setUser($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeUserPackage(UserPackage $userPackage): static
  344.     {
  345.         if ($this->userPackages->removeElement($userPackage)) {
  346.             // set the owning side to null (unless already changed)
  347.             if ($userPackage->getUser() === $this) {
  348.                 $userPackage->setUser(null);
  349.             }
  350.         }
  352.         return $this;
  353.     }
  355.     public function getPbnId(): ?int
  356.     {
  357.         return $this->pbnId;
  358.     }
  360.     public function setPbnId(?int $pbnId): static
  361.     {
  362.         $this->pbnId = $pbnId;
  364.         return $this;
  365.     }
  367.     public function getCustomerSubjects(): ?string
  368.     {
  369.         return $this->customerSubjects;
  370.     }
  372.     public function setCustomerSubjects(?string $customerSubjects): static
  373.     {
  374.         $this->customerSubjects = $customerSubjects;
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return Collection<int, Order>
  381.      */
  382.     public function getOrders(): Collection
  383.     {
  384.         return $this->orders;
  385.     }
  387.     public function addOrder(Order $order): static
  388.     {
  389.         if (!$this->orders->contains($order)) {
  390.             $this->orders->add($order);
  391.             $order->setUser($this);
  392.         }
  394.         return $this;
  395.     }
  397.     public function removeOrder(Order $order): static
  398.     {
  399.         if ($this->orders->removeElement($order)) {
  400.             // set the owning side to null (unless already changed)
  401.             if ($order->getUser() === $this) {
  402.                 $order->setUser(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  409.     public function getWordpressUsername(): ?string
  410.     {
  411.         return $this->wordpressUsername;
  412.     }
  414.     public function setWordpressUsername(?string $wordpressUsername): static
  415.     {
  416.         $this->wordpressUsername = $wordpressUsername;
  418.         return $this;
  419.     }
  421.     public function getWordpressPassword(): ?string
  422.     {
  423.         return $this->wordpressPassword;
  424.     }
  426.     public function setWordpressPassword(?string $wordpressPassword): static
  427.     {
  428.         $this->wordpressPassword = $wordpressPassword;
  430.         return $this;
  431.     }
  433.     public function getWordpressUrl(): ?string
  434.     {
  435.         return $this->wordpressUrl;
  436.     }
  438.     public function setWordpressUrl(?string $wordpressUrl): static
  439.     {
  440.         $this->wordpressUrl = $wordpressUrl;
  442.         return $this;
  443.     }
  445.     public function getSeoPlugin(): ?string
  446.     {
  447.         return $this->seoPlugin;
  448.     }
  450.     public function setSeoPlugin(string $seoPlugin): static
  451.     {
  452.         $this->seoPlugin = $seoPlugin;
  454.         return $this;
  455.     }
  457.     public function isAutoPublish(): ?bool
  458.     {
  459.         return $this->autoPublish;
  460.     }
  462.     public function setAutoPublish(bool $autoPublish): static
  463.     {
  464.         $this->autoPublish = $autoPublish;
  466.         return $this;
  467.     }
  469.     public function getCreationDate(): ?\DateTimeInterface
  470.     {
  471.         return $this->creationDate;
  472.     }
  474.     public function setCreationDate(\DateTimeInterface $creationDate): static
  475.     {
  476.         $this->creationDate = $creationDate;
  478.         return $this;
  479.     }
  481.     public function getNumberOfTestArticle(): ?int
  482.     {
  483.         return $this->numberOfTestArticle;
  484.     }
  486.     public function setNumberOfTestArticle(?int $numberOfTestArticle): static
  487.     {
  488.         $this->numberOfTestArticle = $numberOfTestArticle;
  490.         return $this;
  491.     }
  493.     public function getCompanyName(): ?string
  494.     {
  495.         return $this->companyName;
  496.     }
  498.     public function setCompanyName(?string $companyName): static
  499.     {
  500.         $this->companyName = $companyName;
  502.         return $this;
  503.     }
  505.     public function getTempToken(): ?string
  506.     {
  507.         return $this->tempToken;
  508.     }
  510.     public function setTempToken(?string $tempToken): static
  511.     {
  512.         $this->tempToken = $tempToken;
  514.         return $this;
  515.     }
  517.     public function isMemberOptionAutoPublish(): ?bool
  518.     {
  519.         return $this->memberOptionAutoPublish;
  520.     }
  522.     public function setMemberOptionAutoPublish(bool $memberOptionAutoPublish): static
  523.     {
  524.         $this->memberOptionAutoPublish = $memberOptionAutoPublish;
  526.         return $this;
  527.     }
  529.     /**
  530.      * @return Collection<int, Sms>
  531.      */
  532.     public function getSms(): Collection
  533.     {
  534.         return $this->sms;
  535.     }
  537.     public function addSms(Sms $sms): static
  538.     {
  539.         if (!$this->sms->contains($sms)) {
  540.             $this->sms->add($sms);
  541.             $sms->setUser($this);
  542.         }
  544.         return $this;
  545.     }
  547.     public function removeSms(Sms $sms): static
  548.     {
  549.         if ($this->sms->removeElement($sms)) {
  550.             // set the owning side to null (unless already changed)
  551.             if ($sms->getUser() === $this) {
  552.                 $sms->setUser(null);
  553.             }
  554.         }
  556.         return $this;
  557.     }
  559.     /**
  560.      * @return Collection<int, ProposedArticle>
  561.      */
  562.     public function getProposedArticles(): Collection
  563.     {
  564.         return $this->proposedArticles;
  565.     }
  567.     public function addProposedArticle(ProposedArticle $proposedArticle): static
  568.     {
  569.         if (!$this->proposedArticles->contains($proposedArticle)) {
  570.             $this->proposedArticles->add($proposedArticle);
  571.             $proposedArticle->setUser($this);
  572.         }
  574.         return $this;
  575.     }
  577.     public function removeProposedArticle(ProposedArticle $proposedArticle): static
  578.     {
  579.         if ($this->proposedArticles->removeElement($proposedArticle)) {
  580.             // set the owning side to null (unless already changed)
  581.             if ($proposedArticle->getUser() === $this) {
  582.                 $proposedArticle->setUser(null);
  583.             }
  584.         }
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection<int, Notification>
  591.      */
  592.     public function getNotifications(): Collection
  593.     {
  594.         return $this->notifications;
  595.     }
  597.     public function addNotification(Notification $notification): static
  598.     {
  599.         if (!$this->notifications->contains($notification)) {
  600.             $this->notifications->add($notification);
  601.             $notification->setUser($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeNotification(Notification $notification): static
  608.     {
  609.         if ($this->notifications->removeElement($notification)) {
  610.             // set the owning side to null (unless already changed)
  611.             if ($notification->getUser() === $this) {
  612.                 $notification->setUser(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  618. }