src/Entity/User.php line 740

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Doctrine\Type\ClientType;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use JsonSerializable;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. /**
  15.  * @ORM\Entity(repositoryClass=UserRepository::class)
  16.  * @ORM\Table(name="`users`")
  17.  * @UniqueEntity(fields={"usermane"}, message="There is already an account with this usermane")
  18.  * @method string getUserIdentifier()
  19.  */
  20. class User implements UserInterface, JsonSerializable
  21. {
  22.     /**
  23.      * @ORM\Id
  24.      * @ORM\GeneratedValue
  25.      * @ORM\Column(type="integer")
  26.      */
  27.     private $id;
  29.     /**
  30.      * @ORM\Column(type="string", length=180)
  31.      */
  32.     private $usermane;
  34.     /**
  35.      * @ORM\Column(type="json")
  36.      */
  37.     private $roles = [];
  39.     /**
  40.      * @var string The hashed password
  41.      * @ORM\Column(type="string", nullable=true)
  42.      */
  43.     private $password;
  45.     /**
  46.      * @ORM\Column(type="string", length=255, nullable=true)
  47.      */
  48.     private $civility;
  50.     /**
  51.      * @ORM\Column(type="string", length=255, nullable=true)
  52.      */
  53.     private $firstName;
  55.     /**
  56.      * @ORM\Column(type="string", length=255, nullable=true)
  57.      */
  58.     private $LastName;
  60.     /**
  61.      * @ORM\Column(type="string", length=255, nullable=true)
  62.      */
  63.     private $email;
  65.     /**
  66.      * @ORM\Column(type="text", nullable=true)
  67.      */
  68.     private $description;
  70.     /**
  71.      * @ORM\Column(type="string", length=255, nullable=true)
  72.      */
  73.     private $phone;
  75.     /**
  76.      * @ORM\Column(type="string", length=255, nullable=true)
  77.      */
  78.     private $second_phone;
  80.     /**
  81.      * @ORM\Column(type="text", nullable=true)
  82.      */
  83.     private $adress;
  85.     /**
  86.      * @ORM\Column(type="text", nullable=true)
  87.      */
  88.     private $second_adress;
  90.     /**
  91.      * @ORM\Column(type="string", length=255, nullable=true)
  92.      */
  93.     private $country;
  95.     /**
  96.      * @ORM\Column(type="string", length=255, nullable=true)
  97.      */
  98.     private $region;
  100.     /**
  101.      * @ORM\Column(type="string", length=255, nullable=true)
  102.      */
  103.     private $city;
  105.     /**
  106.      * @ORM\Column(type="string", length=255, nullable=true)
  107.      */
  108.     private $tariff_category;
  110.     /**
  111.      * @ORM\Column(type="string", length=255, nullable=true)
  112.      */
  113.     private $zip;
  115.     /**
  116.      * @ORM\Column(type="string", length=255, nullable=true)
  117.      */
  118.     private $type;
  120.     /**
  121.      * @ORM\Column(type="boolean")
  122.      */
  123.     private $isVerified = false;
  125.     /**
  126.      * @ORM\OneToMany(targetEntity=Link::class, mappedBy="user",cascade={"persist"})
  127.      */
  128.     private $links;
  130.     /**
  131.      * @ORM\Column(type="datetime")
  132.      */
  133.     private $createdAt;
  135.     /**
  136.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="client")
  137.      */
  138.     private $documents;
  140.     /**
  141.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="user")
  142.      */
  143.     private $userDocuments;
  145.     /**
  146.      * @ORM\OneToMany(targetEntity=Address::class, mappedBy="user")
  147.      */
  148.     private $multiAddress;
  150.     /**
  151.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="user")
  152.      */
  153.     private $comments;
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="client")
  156.      */
  157.     private $notes;
  160.     /**
  161.      * @ORM\ManyToOne(targetEntity=Supplier::class, inversedBy="contacts")
  162.      */
  163.     private $supplier;
  165.     /**
  166.      * @ORM\ManyToOne(targetEntity=Promotion::class, inversedBy="clients")
  167.      */
  168.     private $promotion;
  170.     /**
  171.      * @ORM\OneToMany(targetEntity=Activity::class, mappedBy="currentUser")
  172.      * @ORM\OrderBy({"ceratedAt" = "DESC"})
  173.      */
  174.     private $activities;
  176.     /**
  177.      * @ORM\ManyToMany(targetEntity=Produit::class, mappedBy="users")
  178.      */
  179.     private $produits;
  180.     /**
  181.      * @ORM\ManyToOne(targetEntity=GroupUser::class, inversedBy="users")
  182.      */
  183.     private $groupUser;
  185.     /**
  186.      * @ORM\Column(type="client_type", length=255)
  187.      */
  188.     private $clientType='Nouveau client';
  190.     public function __construct()
  191.     {
  192.         $this->links = new ArrayCollection();
  193.         $this->documents = new ArrayCollection();
  194.         $this->userDocuments = new ArrayCollection();
  195.         $this->multiAddress = new ArrayCollection();
  196.         $this->comments = new ArrayCollection();
  197.         $this->notes = new ArrayCollection();
  198.         $this->activities = new ArrayCollection();
  199.         $this->produits = new ArrayCollection();
  200.         $this->zip="";
  201.     }
  203.     public function getId(): ?int
  204.     {
  205.         return $this->id;
  206.     }
  208.     public function getUsermane(): ?string
  209.     {
  210.         return $this->usermane;
  211.     }
  213.     public function setUsermane(string $usermane): self
  214.     {
  215.         $this->usermane = $usermane;
  217.         return $this;
  218.     }
  220.     /**
  221.      * A visual identifier that represents this user.
  222.      *
  223.      * @see UserInterface
  224.      */
  225.     public function getUsername(): string
  226.     {
  227.         return (string) $this->usermane;
  228.     }
  230.     /**
  231.      * @see UserInterface
  232.      */
  233.     public function getRoles(): array
  234.     {
  235.         $roles = $this->roles;
  236.         // guarantee every user at least has ROLE_USER
  237.         $roles[] = 'ROLE_USER';
  239.         return array_unique($roles);
  240.     }
  242.     public function setRoles(array $roles): self
  243.     {
  244.         $this->roles = $roles;
  246.         return $this;
  247.     }
  249.     /**
  250.      * @see UserInterface
  251.      */
  252.     public function getPassword(): string
  253.     {
  254.         return (string) $this->password;
  255.     }
  257.     public function setPassword(string $password): self
  258.     {
  259.         $this->password = $password;
  261.         return $this;
  262.     }
  264.     /**
  265.      * Returning a salt is only needed, if you are not using a modern
  266.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  267.      *
  268.      * @see UserInterface
  269.      */
  270.     public function getSalt(): ?string
  271.     {
  272.         return null;
  273.     }
  275.     /**
  276.      * @see UserInterface
  277.      */
  278.     public function eraseCredentials()
  279.     {
  280.         // If you store any temporary, sensitive data on the user, clear it here
  281.         // $this->plainPassword = null;
  282.     }
  284.     public function getCivility(): ?string
  285.     {
  286.         return $this->civility;
  287.     }
  289.     public function setCivility(string $civility): self
  290.     {
  291.         $this->civility = $civility;
  293.         return $this;
  294.     }
  296.     public function getFirstName(): ?string
  297.     {
  298.         return $this->firstName;
  299.     }
  301.     public function setFirstName(string $firstName): self
  302.     {
  303.         $this->firstName = $firstName;
  305.         return $this;
  306.     }
  308.     public function getLastName(): ?string
  309.     {
  310.         return $this->LastName;
  311.     }
  313.     public function setLastName(string $LastName): self
  314.     {
  315.         $this->LastName = $LastName;
  317.         return $this;
  318.     }
  319.     public function getFullName(): ?string
  320.     {
  321.         return $this->firstName .' '.$this->LastName;
  322.     }
  323.     public function getEmail(): ?string
  324.     {
  325.         return $this->email;
  326.     }
  328.     public function setEmail(string $email): self
  329.     {
  330.         $this->email = $email;
  332.         return $this;
  333.     }
  335.     public function getDescription(): ?string
  336.     {
  337.         return $this->description;
  338.     }
  340.     public function setDescription(string $description): self
  341.     {
  342.         $this->description = $description;
  344.         return $this;
  345.     }
  347.     public function getPhone(): ?string
  348.     {
  349.         return $this->phone;
  350.     }
  352.     public function setPhone(string $phone): self
  353.     {
  354.         $this->phone = $phone;
  356.         return $this;
  357.     }
  359.     public function getSecondPhone(): ?string
  360.     {
  361.         return $this->second_phone;
  362.     }
  364.     public function setSecondPhone(?string $second_phone): self
  365.     {
  366.         $this->second_phone = $second_phone;
  368.         return $this;
  369.     }
  371.     public function getAdress(): ?string
  372.     {
  373.         return $this->adress;
  374.     }
  376.     public function setAdress(string $adress): self
  377.     {
  378.         $this->adress = $adress;
  380.         return $this;
  381.     }
  383.     public function getSecondAdress(): ?string
  384.     {
  385.         return $this->second_adress;
  386.     }
  388.     public function setSecondAdress(?string $second_adress): self
  389.     {
  390.         $this->second_adress = $second_adress;
  392.         return $this;
  393.     }
  395.     public function getCountry(): ?string
  396.     {
  397.         return $this->country;
  398.     }
  400.     public function setCountry(string $country): self
  401.     {
  402.         $this->country = $country;
  404.         return $this;
  405.     }
  407.     public function getRegion(): ?string
  408.     {
  409.         return $this->region;
  410.     }
  412.     public function setRegion(string $region): self
  413.     {
  414.         $this->region = $region;
  416.         return $this;
  417.     }
  419.     public function getCity(): ?string
  420.     {
  421.         return $this->city;
  422.     }
  424.     public function setCity(string $city): self
  425.     {
  426.         $this->city = $city;
  428.         return $this;
  429.     }
  431.     public function getTariffCategory(): ?string
  432.     {
  433.         return $this->tariff_category;
  434.     }
  436.     public function setTariffCategory(?string $tariff_category): self
  437.     {
  438.         $this->tariff_category = $tariff_category;
  440.         return $this;
  441.     }
  443.     public function getZip(): ?string
  444.     {
  445.         return $this->zip;
  446.     }
  448.     public function setZip(string $zip): self
  449.     {
  450.         $this->zip = $zip;
  452.         return $this;
  453.     }
  455.     public function getType(): ?string
  456.     {
  457.         return $this->type;
  458.     }
  460.     public function setType(string $type): self
  461.     {
  462.         $this->type = $type;
  464.         return $this;
  465.     }
  467.     public function isVerified(): bool
  468.     {
  469.         return $this->isVerified;
  470.     }
  472.     public function setIsVerified(bool $isVerified): self
  473.     {
  474.         $this->isVerified = $isVerified;
  476.         return $this;
  477.     }
  479.     /**
  480.      * @return Collection|Link[]
  481.      */
  482.     public function getLinks(): Collection
  483.     {
  484.         return $this->links;
  485.     }
  487.     public function addLink(Link $link): self
  488.     {
  489.         if( !$this->links->contains($link)) {
  490.             $this->links[] = $link;
  491.             $link->setUser($this);
  492.         }
  494.         return $this;
  495.     }
  497.     public function removeLink(Link $link): self
  498.     {
  499.         if( $this->links->removeElement($link)) {
  500.             // set the owning side to null (unless already changed)
  501.             if( $link->getUser() === $this) {
  502.                 $link->setUser(null);
  503.             }
  504.         }
  506.         return $this;
  507.     }
  509.     public function getCreatedAt(): ?\DateTimeInterface
  510.     {
  511.         return $this->createdAt;
  512.     }
  514.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  515.     {
  516.         $this->createdAt = $createdAt;
  518.         return $this;
  519.     }
  521.     /**
  522.      * @return Collection|Document[]
  523.      */
  524.     public function getDocuments(): Collection
  525.     {
  526.         return $this->documents;
  527.     }
  529.     public function addDocument(Document $document): self
  530.     {
  531.         if( !$this->documents->contains($document)) {
  532.             $this->documents[] = $document;
  533.             $document->setClient($this);
  534.         }
  536.         return $this;
  537.     }
  539.     public function removeDocument(Document $document): self
  540.     {
  541.         if( $this->documents->removeElement($document)) {
  542.             // set the owning side to null (unless already changed)
  543.             if( $document->getClient() === $this) {
  544.                 $document->setClient(null);
  545.             }
  546.         }
  548.         return $this;
  549.     }
  551.     /**
  552.      * @return Collection|Document[]
  553.      */
  554.     public function getUserDocuments(): Collection
  555.     {
  556.         return $this->userDocuments;
  557.     }
  559.     public function addUserDocument(Document $userDocument): self
  560.     {
  561.         if( !$this->userDocuments->contains($userDocument)) {
  562.             $this->userDocuments[] = $userDocument;
  563.             $userDocument->setUser($this);
  564.         }
  566.         return $this;
  567.     }
  569.     public function removeUserDocument(Document $userDocument): self
  570.     {
  571.         if( $this->userDocuments->removeElement($userDocument)) {
  572.             // set the owning side to null (unless already changed)
  573.             if( $userDocument->getUser() === $this) {
  574.                 $userDocument->setUser(null);
  575.             }
  576.         }
  578.         return $this;
  579.     }
  581.     /**
  582.      * @return Collection|Address[]
  583.      */
  584.     public function getMultiAddress(): Collection
  585.     {
  586.         return $this->multiAddress;
  587.     }
  589.     public function addMultiAddress(Address $multiAddress): self
  590.     {
  591.         if( !$this->multiAddress->contains($multiAddress)) {
  592.             $this->multiAddress[] = $multiAddress;
  593.             $multiAddress->setUser($this);
  594.         }
  596.         return $this;
  597.     }
  599.     public function removeMultiAddress(Address $multiAddress): self
  600.     {
  601.         if( $this->multiAddress->removeElement($multiAddress)) {
  602.             // set the owning side to null (unless already changed)
  603.             if( $multiAddress->getUser() === $this) {
  604.                 $multiAddress->setUser(null);
  605.             }
  606.         }
  608.         return $this;
  609.     }
  611.     /**
  612.      * @return Collection|Comment[]
  613.      */
  614.     public function getComments(): Collection
  615.     {
  616.         return $this->comments;
  617.     }
  619.     public function addComment(Comment $comment): self
  620.     {
  621.         if( !$this->comments->contains($comment)) {
  622.             $this->comments[] = $comment;
  623.             $comment->setUser($this);
  624.         }
  626.         return $this;
  627.     }
  629.     public function removeComment(Comment $comment): self
  630.     {
  631.         if( $this->comments->removeElement($comment)) {
  632.             // set the owning side to null (unless already changed)
  633.             if( $comment->getUser() === $this) {
  634.                 $comment->setUser(null);
  635.             }
  636.         }
  638.         return $this;
  639.     }
  640.     /**
  641.      * @return Collection|Comment[]
  642.      */
  643.     public function getNotes(): Collection
  644.     {
  645.         return $this->notes;
  646.     }
  648.     public function addNote(Comment $note): self
  649.     {
  650.         if( !$this->notes->contains($note)) {
  651.             $this->notes[] = $note;
  652.             $note->setClient($this);
  653.         }
  655.         return $this;
  656.     }
  658.     public function removeNote(Comment $note): self
  659.     {
  660.         if( $this->notes->removeElement($note)) {
  661.             // set the owning side to null (unless already changed)
  662.             if( $note->getUser() === $this) {
  663.                 $note->setUser(null);
  664.             }
  665.         }
  667.         return $this;
  668.     }
  669.     public function getSupplier(): ?Supplier
  670.     {
  671.         return $this->supplier;
  672.     }
  674.     public function setSupplier(?Supplier $supplier): self
  675.     {
  676.         $this->supplier = $supplier;
  678.         return $this;
  679.     }
  681.     public function getPromotion(): ?Promotion
  682.     {
  683.         return $this->promotion;
  684.     }
  686.     public function setPromotion(?Promotion $promotion): self
  687.     {
  688.         $this->promotion = $promotion;
  690.         return $this;
  691.     }
  693.     /**
  694.      * @return Collection|Activity[]
  695.      */
  696.     public function getActivities(): Collection
  697.     {
  698.         return $this->activities;
  699.     }
  701.     public function addActivity(Activity $activity): self
  702.     {
  703.         if( !$this->activities->contains($activity)) {
  704.             $this->activities[] = $activity;
  705.             $activity->setCurrentUser($this);
  706.         }
  708.         return $this;
  709.     }
  711.     public function removeActivity(Activity $activity): self
  712.     {
  713.         if( $this->activities->removeElement($activity)) {
  714.             // set the owning side to null (unless already changed)
  715.             if( $activity->getCurrentUser() === $this) {
  716.                 $activity->setCurrentUser(null);
  717.             }
  718.         }
  720.         return $this;
  721.     }
  723.     public function getGroupUser(): ?GroupUser
  724.     {
  725.         return $this->groupUser;
  726.     }
  728.     public function setGroupUser(?GroupUser $groupUser): self
  729.     {
  730.         $this->groupUser = $groupUser;
  732.         return $this;
  733.     }
  735.     public function __call($name, $arguments)
  736.     {
  737.         // TODO: Implement @method string getUserIdentifier()
  738.     }
  740.     public function jsonSerialize()
  741.     {
  742.         return array(
  743.             'adress' => $this->getAdress(),
  744.             'second_adress' => $this->getSecondAdress(),
  745.             'firstName' => $this->getFirstName(),
  746.             'lastName' => $this->getLastName(),
  747.             'username' => $this->getUsermane(),
  748.             'email' => $this->getEmail(),
  749.             'password' => '',
  750.             'newPassword' => '',
  751.             'confirmPassword' => ''
  752.         );
  753.     }
  754.     /**
  755.      * @return Collection|Produit[]
  756.      */
  757.     public function getProduits(): Collection
  758.     {
  759.         return $this->produits;
  760.     }
  762.     public function addProduit(Produit $produit): self
  763.     {
  764.         if( !$this->produits->contains($produit)) {
  765.             $this->produits[] = $produit;
  766.             $produit->addUser($this);
  767.         }
  768.         return $this;
  769.     }
  771.     public function removeProduit(Produit $produit): self
  772.     {
  773.         if( $this->produits->contains($produit)) {
  774.             $this->produits->removeElement($produit);
  775.             $produit->removeUser($this);
  776.         }
  777.         return $this;
  778.     }
  780.     public function getClientType(): ?string
  781.     {
  782.         return $this->clientType;
  783.     }
  785.     public function setClientType(string $clientType): self
  786.     {
  787.         // Validate if the provided value is one of the valid ENUM values
  788.         if (!in_array($clientType, ClientType::getValidValues(), true)) {
  789.             throw new \InvalidArgumentException("Invalid client type: $clientType");
  790.         }
  792.         $this->clientType = $clientType;
  794.         return $this;
  795.     }
  796. }