src/Entity/User.php line 18

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 Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. /**
  15.  * @ORM\Entity(repositoryClass=UserRepository::class)
  16.  * @UniqueEntity(fields={"email"}, message="There is already an account associated with this email address.")
  17.  */
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface
  19. {
  20.     /**
  21.      * @ORM\Id
  22.      * @ORM\GeneratedValue
  23.      * @ORM\Column(type="integer")
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\Column(type="string", length=180, unique=true)
  29.      */
  30.     private $email;
  32.     /**
  33.      * @ORM\Column(type="json")
  34.      */
  35.     private $roles = [];
  37.     /**
  38.      * @var string The hashed password
  39.      * @ORM\Column(type="string")
  40.      */
  41.     private $password;
  43.     /**
  44.      * @ORM\Column(type="boolean")
  45.      */
  46.     private $isVerified = false;
  48.     /**
  49.      * @ORM\Column(type="string", length=255, nullable=true)
  50.      */
  51.     private $firstname;
  53.     /**
  54.      * @ORM\Column(type="string", length=255, nullable=true)
  55.      */
  56.     private $lastname;
  58.     /**
  59.      * @ORM\Column(type="string", length=255, nullable=true)
  60.      */
  61.     private $phone;
  63.     /**
  64.      * @ORM\Column(type="string", length=255)
  65.      */
  66.     public $type = 'freelance';
  68.     /**
  69.      * @ORM\Column(type="string", length=255, nullable=true)
  70.      */
  71.     private $photo;
  73.     /**
  74.      * @ORM\OneToOne(targetEntity=Society::class, mappedBy="user", cascade={"persist", "remove"})
  75.      */
  76.     private $society;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=Profile::class, mappedBy="user", orphanRemoval=true)
  80.      */
  81.     private $profiles;
  83.     /**
  84.      * @ORM\Column(type="datetime", nullable=true)
  85.      */
  86.     private $deleteAt;
  88.     /**
  89.      * @ORM\Column(type="datetime", nullable=true)
  90.      */
  91.     private $lastConnection;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="writer")
  95.      */
  96.     private $messages;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity=Room::class, mappedBy="caller")
  100.      */
  101.     private $rooms;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=OfferFavorite::class, mappedBy="user", orphanRemoval=true)
  105.      */
  106.     private $offerFavorites;
  108.     /**
  109.      * @ORM\Column(type="datetime")
  110.      */
  111.     private $createdAt;
  113.     /**
  114.      * @ORM\OneToMany(targetEntity=AuthLog::class, mappedBy="user", orphanRemoval=true)
  115.      */
  116.     private $authLogs;
  118.     /**
  119.      * @ORM\OneToMany(targetEntity=OfferVisit::class, mappedBy="user", orphanRemoval=true)
  120.      */
  121.     private $offerVisits;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity=Report::class, mappedBy="user", orphanRemoval=true)
  125.      */
  126.     private $reports;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity=OfferAlert::class, mappedBy="user", orphanRemoval=true)
  130.      */
  131.     private $offerAlerts;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity=ProfileFavorite::class, mappedBy="user")
  135.      */
  136.     private $profileFavorites;
  138.     /**
  139.      * @ORM\Column(type="integer", nullable=true)
  140.      */
  141.     private $civility;
  143.     /**
  144.      * @ORM\Column(type="string", length=50, nullable=true)
  145.      */
  146.     private $jobSociety;
  148.     /**
  149.      * @ORM\ManyToOne(targetEntity=Society::class)
  150.      */
  151.     private $CompteSociety;
  153.     /**
  154.      * @ORM\Column(type="boolean", nullable=true)
  155.      */
  156.     private $compteTestIsNotActive;
  158.     /**
  159.      * @ORM\OneToOne(targetEntity=ForumUser::class, mappedBy="user", cascade={"persist", "remove"})
  160.      */
  161.     private $forumUser;
  163.     public function __construct()
  164.     {
  165.         $this->profiles = new ArrayCollection();
  166.         $this->messages = new ArrayCollection();
  167.         $this->rooms = new ArrayCollection();
  168.         $this->offerFavorites = new ArrayCollection();
  169.         $this->authLogs = new ArrayCollection();
  170.         $this->offerVisits = new ArrayCollection();
  171.         $this->reports = new ArrayCollection();
  172.         $this->offerAlerts = new ArrayCollection();
  173.         $this->profileFavorites = new ArrayCollection();
  174.     }
  176.     // ---------------------------------
  178.     public function getCivilityString(): string
  179.     {
  180.         if ($this->civility == 1){
  181.             return "Mr.";
  182.         }
  183.         if ($this->civility == 2){
  184.             return "Ms.";
  185.         }
  187.         return "";
  188.     }
  190.     public function isRole(string $role){
  191.         if (in_array($role, $this->roles)){
  192.             return true;
  193.         }
  194.         return false;
  195.     }
  198.     // ---------------------------------
  200.     public function getId(): ?int
  201.     {
  202.         return $this->id;
  203.     }
  205.     public function getEmail(): ?string
  206.     {
  207.         return $this->email;
  208.     }
  210.     public function setEmail(string $email): self
  211.     {
  212.         $this->email = $email;
  214.         return $this;
  215.     }
  217.     /**
  218.      * A visual identifier that represents this user.
  219.      *
  220.      * @see UserInterface
  221.      */
  222.     public function getUserIdentifier(): string
  223.     {
  224.         return (string)$this->email;
  225.     }
  227.     /**
  228.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  229.      */
  230.     public function getUsername(): string
  231.     {
  232.         return (string)$this->email;
  233.     }
  235.     /**
  236.      * @see UserInterface
  237.      */
  238.     public function getRoles(): array
  239.     {
  240.         $roles = $this->roles;
  241.         // guarantee every user at least has ROLE_USER
  242.         $roles[] = 'ROLE_USER';
  244.         return array_unique($roles);
  245.     }
  247.     public function setRoles(array $roles): self
  248.     {
  249.         $this->roles = $roles;
  251.         return $this;
  252.     }
  254.     /**
  255.      * @see PasswordAuthenticatedUserInterface
  256.      */
  257.     public function getPassword(): string
  258.     {
  259.         return $this->password;
  260.     }
  262.     public function setPassword(string $password): self
  263.     {
  264.         $this->password = $password;
  266.         return $this;
  267.     }
  269.     /**
  270.      * Returning a salt is only needed, if you are not using a modern
  271.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  272.      *
  273.      * @see UserInterface
  274.      */
  275.     public function getSalt(): ?string
  276.     {
  277.         return null;
  278.     }
  280.     /**
  281.      * @see UserInterface
  282.      */
  283.     public function eraseCredentials()
  284.     {
  285.         // If you store any temporary, sensitive data on the user, clear it here
  286.         // $this->plainPassword = null;
  287.     }
  289.     public function isVerified(): bool
  290.     {
  291.         return $this->isVerified;
  292.     }
  294.     public function hasProfile(): bool
  295.     {
  296.         return $this->getUniqueProfile()->getId() !== null;
  297.     }
  299.     public function setIsVerified(bool $isVerified): self
  300.     {
  301.         $this->isVerified = $isVerified;
  303.         return $this;
  304.     }
  306.     public function getType(): ?string
  307.     {
  308.         return $this->type;
  309.     }
  311.     public function setType(string $type): self
  312.     {
  313.         $this->type = $type;
  315.         return $this;
  316.     }
  318.     public function getPhoto(): ?string
  319.     {
  320.         if($this->getCompteSociety()){
  321.             $societe = $this->getCompteSociety();
  322.             return $societe->getUser()->getPhoto();
  323.         }
  325.         return $this->photo;
  326.     }
  328.     public function setPhoto(?string $photo): self
  329.     {
  330.         $this->photo = $photo;
  332.         return $this;
  333.     }
  335.     public function getFullName(): string
  336.     {
  337.         if ($this->type == 'freelance'){
  338.             $profile = $this->getUniqueProfile();
  340.             return $profile->getFullName();
  341.         }
  343.         return $this->firstname . ' ' . $this->lastname;
  344.     }
  346.     public function getSociety(): ?Society
  347.     {
  348.         if($this->getCompteSociety() && in_array("ROLE_RECRUTEUR", $this->roles)){
  349.             return $this->getCompteSociety();
  350.         }
  352.         return $this->society;
  353.     }
  355.     public function setSociety(Society $society): self
  356.     {
  357.         // set the owning side of the relation if necessary
  358.         if ($society->getUser() !== $this) {
  359.             $society->setUser($this);
  360.         }
  362.         $this->society = $society;
  364.         return $this;
  365.     }
  367.     public function isFreelance(): bool
  368.     {
  369.         return $this->type === 'freelance';
  370.     }
  372.     public function isSociety(): bool
  373.     {
  374.         if($this->getCompteSociety()){
  375.             return true;
  376.         }
  378.         return $this->type === 'society';
  379.     }
  381.     public function isAdmin(): bool
  382.     {
  383.         return $this->type == 'admin';
  384.     }
  386.     /**
  387.      * @return Collection|Profile[]
  388.      */
  389.     public function getProfiles(): Collection
  390.     {
  391.         return $this->profiles;
  392.     }
  394.     public function addProfile(Profile $profile): self
  395.     {
  396.         if (!$this->profiles->contains($profile)) {
  397.             $this->profiles[] = $profile;
  398.             $profile->setUser($this);
  399.         }
  401.         return $this;
  402.     }
  404.     public function removeProfile(Profile $profile): self
  405.     {
  406.         if ($this->profiles->removeElement($profile)) {
  407.             // set the owning side to null (unless already changed)
  408.             if ($profile->getUser() === $this) {
  409.                 $profile->setUser(null);
  410.             }
  411.         }
  413.         return $this;
  414.     }
  416.     public function getUniqueProfile(): Profile
  417.     {
  418.         return $this->getProfiles()->isEmpty()
  419.             ? (new Profile())
  420.                 ->setUser($this)
  421.                 ->setIsIntercontrat($this->isSociety())
  422.                 ->setName($this->isFreelance() ? $this->getLastname() : 'Intercontrat')
  423.                 ->setPhone($this->getPhone() ?? '')
  424.                 ->setFirstname($this->isFreelance() ? $this->getFirstname() : 'Intercontrat')
  425.             : $this->getProfiles()->first();
  426.     }
  428.     public function getDeleteAt(): ?\DateTimeInterface
  429.     {
  430.         return $this->deleteAt;
  431.     }
  433.     public function setDeleteAt(?\DateTimeInterface $deleteAt): self
  434.     {
  435.         $this->deleteAt = $deleteAt;
  437.         return $this;
  438.     }
  440.     public function getLastConnection(): ?\DateTimeInterface
  441.     {
  442.         return $this->lastConnection;
  443.     }
  445.     public function setLastConnection(?\DateTimeInterface $lastConnection): self
  446.     {
  447.         $this->lastConnection = $lastConnection;
  449.         return $this;
  450.     }
  452.     /**
  453.      * @return Collection|Message[]
  454.      */
  455.     public function getMessages(): Collection
  456.     {
  457.         return $this->messages;
  458.     }
  460.     public function addMessage(Message $message): self
  461.     {
  462.         if (!$this->messages->contains($message)) {
  463.             $this->messages[] = $message;
  464.             $message->setWriter($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeMessage(Message $message): self
  471.     {
  472.         if ($this->messages->removeElement($message)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($message->getWriter() === $this) {
  475.                 $message->setWriter(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection|Room[]
  484.      */
  485.     public function getRooms(): Collection
  486.     {
  487.         return $this->rooms;
  488.     }
  490.     public function addRoom(Room $room): self
  491.     {
  492.         if (!$this->rooms->contains($room)) {
  493.             $this->rooms[] = $room;
  494.             $room->setCaller($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeRoom(Room $room): self
  501.     {
  502.         if ($this->rooms->removeElement($room)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($room->getCaller() === $this) {
  505.                 $room->setCaller(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection|OfferFavorite[]
  514.      */
  515.     public function getOfferFavorites(): Collection
  516.     {
  517.         return $this->offerFavorites;
  518.     }
  520.     public function addOfferFavorite(OfferFavorite $offerFavorite): self
  521.     {
  522.         if (!$this->offerFavorites->contains($offerFavorite)) {
  523.             $this->offerFavorites[] = $offerFavorite;
  524.             $offerFavorite->setUser($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeOfferFavorite(OfferFavorite $offerFavorite): self
  531.     {
  532.         if ($this->offerFavorites->removeElement($offerFavorite)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($offerFavorite->getUser() === $this) {
  535.                 $offerFavorite->setUser(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     public function getCreatedAt(): ?\DateTimeInterface
  543.     {
  544.         return $this->createdAt;
  545.     }
  547.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  548.     {
  549.         $this->createdAt = $createdAt;
  551.         return $this;
  552.     }
  554.     /**
  555.      * @return Collection|AuthLog[]
  556.      */
  557.     public function getAuthLogs(): Collection
  558.     {
  559.         return $this->authLogs;
  560.     }
  562.     public function addAuthLog(AuthLog $authLog): self
  563.     {
  564.         if (!$this->authLogs->contains($authLog)) {
  565.             $this->authLogs[] = $authLog;
  566.             $authLog->setUser($this);
  567.         }
  569.         return $this;
  570.     }
  572.     public function removeAuthLog(AuthLog $authLog): self
  573.     {
  574.         if ($this->authLogs->removeElement($authLog)) {
  575.             // set the owning side to null (unless already changed)
  576.             if ($authLog->getUser() === $this) {
  577.                 $authLog->setUser(null);
  578.             }
  579.         }
  581.         return $this;
  582.     }
  584.     /**
  585.      * @return Collection|OfferVisit[]
  586.      */
  587.     public function getOfferVisits(): Collection
  588.     {
  589.         return $this->offerVisits;
  590.     }
  592.     public function addOfferVisit(OfferVisit $offerVisit): self
  593.     {
  594.         if (!$this->offerVisits->contains($offerVisit)) {
  595.             $this->offerVisits[] = $offerVisit;
  596.             $offerVisit->setUser($this);
  597.         }
  599.         return $this;
  600.     }
  602.     public function removeOfferVisit(OfferVisit $offerVisit): self
  603.     {
  604.         if ($this->offerVisits->removeElement($offerVisit)) {
  605.             // set the owning side to null (unless already changed)
  606.             if ($offerVisit->getUser() === $this) {
  607.                 $offerVisit->setUser(null);
  608.             }
  609.         }
  611.         return $this;
  612.     }
  614.     public function getPublicName(): ?string
  615.     {
  616.         return $this->isSociety()
  617.             ? $this->getSociety()->getName()
  618.             : $this->getUniqueProfile()->getPublicName();
  619.     }
  621.     /**
  622.      * @return Collection|Report[]
  623.      */
  624.     public function getReports(): Collection
  625.     {
  626.         return $this->reports;
  627.     }
  629.     public function addReport(Report $report): self
  630.     {
  631.         if (!$this->reports->contains($report)) {
  632.             $this->reports[] = $report;
  633.             $report->setUser($this);
  634.         }
  636.         return $this;
  637.     }
  639.     public function removeReport(Report $report): self
  640.     {
  641.         if ($this->reports->removeElement($report)) {
  642.             // set the owning side to null (unless already changed)
  643.             if ($report->getUser() === $this) {
  644.                 $report->setUser(null);
  645.             }
  646.         }
  648.         return $this;
  649.     }
  651.     /**
  652.      * @return Collection|OfferAlert[]
  653.      */
  654.     public function getOfferAlerts(): Collection
  655.     {
  656.         return $this->offerAlerts;
  657.     }
  659.     public function addOfferAlert(OfferAlert $offerAlert): self
  660.     {
  661.         if (!$this->offerAlerts->contains($offerAlert)) {
  662.             $this->offerAlerts[] = $offerAlert;
  663.             $offerAlert->setUser($this);
  664.         }
  666.         return $this;
  667.     }
  669.     public function removeOfferAlert(OfferAlert $offerAlert): self
  670.     {
  671.         if ($this->offerAlerts->removeElement($offerAlert)) {
  672.             // set the owning side to null (unless already changed)
  673.             if ($offerAlert->getUser() === $this) {
  674.                 $offerAlert->setUser(null);
  675.             }
  676.         }
  678.         return $this;
  679.     }
  681.     public function isOauth(): bool
  682.     {
  683.         return $this->password == 'nopass';
  684.     }
  686.     /**
  687.      * @return Collection<int, ProfileFavorite>
  688.      */
  689.     public function getProfileFavorites(): Collection
  690.     {
  691.         return $this->profileFavorites;
  692.     }
  694.     public function addProfileFavorite(ProfileFavorite $profileFavorite): self
  695.     {
  696.         if (!$this->profileFavorites->contains($profileFavorite)) {
  697.             $this->profileFavorites[] = $profileFavorite;
  698.             $profileFavorite->setUser($this);
  699.         }
  701.         return $this;
  702.     }
  704.     public function removeProfileFavorite(ProfileFavorite $profileFavorite): self
  705.     {
  706.         if ($this->profileFavorites->removeElement($profileFavorite)) {
  707.             // set the owning side to null (unless already changed)
  708.             if ($profileFavorite->getUser() === $this) {
  709.                 $profileFavorite->setUser(null);
  710.             }
  711.         }
  713.         return $this;
  714.     }
  716.     public function isIsVerified(): ?bool
  717.     {
  718.         return $this->isVerified;
  719.     }
  721.     public function getPhone(): ?string
  722.     {
  723.         return $this->phone;
  724.     }
  726.     public function setPhone(?string $phone): self
  727.     {
  728.         $this->phone = $phone;
  730.         return $this;
  731.     }
  733.     public function getCivility(): ?int
  734.     {
  735.         return $this->civility;
  736.     }
  738.     public function setCivility(?int $civility): self
  739.     {
  740.         $this->civility = $civility;
  742.         return $this;
  743.     }
  745.     public function getJobSociety(): ?string
  746.     {
  747.         return $this->jobSociety;
  748.     }
  750.     public function setJobSociety(?string $jobSociety): self
  751.     {
  752.         $this->jobSociety = $jobSociety;
  754.         return $this;
  755.     }
  757.     public function getCompteSociety(): ?Society
  758.     {
  759.         return $this->CompteSociety;
  760.     }
  762.     public function setCompteSociety(?Society $CompteSociety): self
  763.     {
  764.         $this->CompteSociety = $CompteSociety;
  766.         return $this;
  767.     }
  769.     public function isCompteTestIsNotActive(): ?bool
  770.     {
  771.         return $this->compteTestIsNotActive;
  772.     }
  774.     public function setCompteTestIsNotActive(?bool $compteTestIsNotActive): self
  775.     {
  776.         $this->compteTestIsNotActive = $compteTestIsNotActive;
  778.         return $this;
  779.     }
  781.     public function getFirstname(): ?string
  782.     {
  783.         return $this->firstname;
  784.     }
  786.     public function setFirstname(?string $firstname): self
  787.     {
  788.         $this->firstname = $firstname;
  790.         return $this;
  791.     }
  793.     public function getLastname(): ?string
  794.     {
  795.         return $this->lastname;
  796.     }
  798.     public function setLastname(?string $lastname): self
  799.     {
  800.         $this->lastname = $lastname;
  802.         return $this;
  803.     }
  805.     public function getForumUser(): ?ForumUser
  806.     {
  807.         return $this->forumUser;
  808.     }
  810.     public function setForumUser(?ForumUser $forumUser): self
  811.     {
  812.         // unset the owning side of the relation if necessary
  813.         if ($forumUser === null && $this->forumUser !== null) {
  814.             $this->forumUser->setUser(null);
  815.         }
  817.         // set the owning side of the relation if necessary
  818.         if ($forumUser !== null && $forumUser->getUser() !== $this) {
  819.             $forumUser->setUser($this);
  820.         }
  822.         $this->forumUser = $forumUser;
  824.         return $this;
  825.     }
  826. }