src/Entity/Client.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ClientRepository;
  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 FOS\UserBundle\Model\User;
  11. use Symfony\Component\HttpFoundation\File\File;
  12. use Symfony\Component\HttpFoundation\File\UploadedFile;
  13. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  14. use Symfony\Component\Security\Core\User\UserInterface;
  15. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  16. #[ORM\Entity(repositoryClass: ClientRepository::class)]
  17. #[ORM\Table(name: "fos_user")]
  18. #[Vich\Uploadable]
  19. class Client extends User implements UserInterface,PasswordAuthenticatedUserInterface
  20. {
  21.     const ROLE_CLIENT = 'ROLE_CLIENT';
  24.     #[ORM\Id]
  25.     #[ORM\Column(type: "integer")]
  26.     #[ORM\GeneratedValue(strategy: "AUTO")]
  27.     protected $id;
  29.     #[ORM\Column(length: 255,nullable: true)]
  30.     private ?string $name = null;
  31.     #[ORM\Column(length: 255,nullable: true)]
  32.     private ?string $surname = null;
  34.     #[ORM\Column(length: 255, nullable: true)]
  35.     private ?string $city = null;
  37.     #[ORM\ManyToOne(inversedBy: 'clients')]
  38.     private ?Country $country = null;
  40.     #[ORM\Column(nullable: true)]
  41.     private ?bool $isDeleted = false;
  43.     #[ORM\Column(type: Types::DATETIME_MUTABLE,nullable: true)]
  44.     private ?\DateTimeInterface $dateCreated = null;
  46.     #[ORM\Column(type: Types::DATETIME_MUTABLE,nullable: true)]
  47.     private ?\DateTimeInterface $dateUpdated = null;
  49.     #[ORM\OneToOne(mappedBy: 'client', cascade: ['persist', 'remove'])]
  50.     private ?Rapper $rapper = null;
  52.     #[ORM\ManyToOne(inversedBy: 'voter')]
  53.     private ?Vote $myVotes = null;
  55.     #[ORM\Column]
  56.     private ?bool $isActive = false;
  58.     #[ORM\Column]
  59.     private ?\DateTime $activatedAt = null;
  61.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: ClientActivationToken::class,cascade: ['persist', 'remove'])]
  62.     private Collection $clientActivationTokens;
  64.     #[ORM\OneToOne(mappedBy: 'client', cascade: ['persist', 'remove'])]
  65.     private ?ClientSettings $clientSettings = null;
  67.     #[ORM\OneToOne(inversedBy: 'client', cascade: ['persist', 'remove'])]
  68.     private ?BeatAuthor $author = null;
  70.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: ClientMessage::class, orphanRemoval: true)]
  71.     private Collection $clientMessagesSent;
  73.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: ClientNotification::class, orphanRemoval: true)]
  74.     private Collection $clientNotifications;
  76.     #[ORM\ManyToMany(targetEntity: ClientMessage::class, mappedBy: 'recipients')]
  77.     private Collection $clientMessages;
  79.     #[ORM\ManyToMany(targetEntity: Rapper::class, mappedBy: 'followers')]
  80.     private Collection $rappersFollowed;
  82.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'referals')]
  83.     private ?self $referal = null;
  85.     #[ORM\OneToMany(mappedBy: 'referal', targetEntity: self::class)]
  86.     private Collection $referals;
  88.     #[ORM\ManyToMany(targetEntity: Beat::class, inversedBy: 'favoritedClients')]
  89.     private Collection $favoriteBeats;
  91.     #[ORM\ManyToMany(targetEntity: Battle::class, inversedBy: 'favoritedClients')]
  92.     private Collection $favoriteBattles;
  94.     #[ORM\Column(length: 255, nullable: true)]
  95.     private ?string $resetPasswordHash = null;
  97.     #[ORM\Column(nullable: true)]
  98.     private ?\DateTime $resetPasswordHashValidTo = null;
  100.     #[ORM\OneToOne(mappedBy: 'createdBy', cascade: ['persist', 'remove'])]
  101.     private ?Crew $crew = null;
  103.     #[Vich\UploadableField(mapping: 'client_image', fileNameProperty: 'imageName', size: 'imageSize')]
  104.     public ?File $imageFile = null;
  106.     #[ORM\Column(nullable: true)]
  107.     private ?string $imageName = null;
  109.     #[ORM\Column(nullable: true)]
  110.     private ?int $imageSize = null;
  112.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: AuthorizationToken::class,cascade: ['persist', 'remove'])]
  113.     private Collection $authorizationTokens;
  115.     #[ORM\ManyToMany(targetEntity: BeatAuthor::class, mappedBy: 'followers')]
  116.     private Collection $followedAuthors;
  118.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: BattleComment::class)]
  119.     private Collection $battleComments;
  121.     #[ORM\OneToMany(mappedBy: 'voter', targetEntity: Vote::class)]
  122.     private Collection $myBattleVotes;
  124.     #[ORM\OneToMany(mappedBy: 'likedBy', targetEntity: BattleCommentLike::class)]
  125.     private Collection $battleCommentLikes;
  128.     public function __construct()
  129.     {
  130.         parent::__construct();
  131.         $this->clientActivationTokens = new ArrayCollection();
  132.         $this->clientMessagesSent = new ArrayCollection();
  133.         $this->clientNotifications = new ArrayCollection();
  134.         $this->clientMessages = new ArrayCollection();
  135.         $this->rappersFollowed = new ArrayCollection();
  136.         $this->referals = new ArrayCollection();
  137.         $this->favoriteBeats = new ArrayCollection();
  138.         $this->favoriteBattles = new ArrayCollection();
  139.         $this->authorizationTokens = new ArrayCollection();
  140.         $this->followedAuthors = new ArrayCollection();
  141.         $this->battleComments = new ArrayCollection();
  142.         $this->myBattleVotes = new ArrayCollection();
  143.         $this->battleCommentLikes = new ArrayCollection();
  145.     }
  147.     public function getId(): ?int
  148.     {
  149.         return $this->id;
  150.     }
  152.     public function getEmail(): ?string
  153.     {
  154.         return $this->email;
  155.     }
  157.     public function getUserIdentifier(): string
  158.     {
  159.         return $this->email;
  160.     }
  164.     public function getRoles(): array
  165.     {
  166.         $roles = $this->roles;
  167.         $roles[] = self::ROLE_CLIENT; // Default role for all clients
  169.         return array_unique($roles);
  170.     }
  172.     public function setRoles(array $roles): self
  173.     {
  174.         $this->roles = $roles;
  175.         return $this;
  176.     }
  178.     public function eraseCredentials()
  179.     {
  180.         // If you store any temporary, sensitive data on the user, clear it here
  181.     }
  184.     /**
  185.      * @see PasswordAuthenticatedUserInterface
  186.      */
  187.     public function getPassword(): string
  188.     {
  189.         return $this->password;
  190.     }
  193.     public function getName(): ?string
  194.     {
  195.         return $this->name;
  196.     }
  198.     public function setName(string $name): self
  199.     {
  200.         $this->name = $name;
  201.         return $this;
  202.     }
  204.     public function getSurname(): ?string
  205.     {
  206.         return $this->surname;
  207.     }
  209.     public function setSurname(string $surname): self
  210.     {
  211.         $this->surname = $surname;
  213.         return $this;
  214.     }
  217.     public function getCity(): ?string
  218.     {
  219.         return $this->city;
  220.     }
  222.     public function setCity(?string $city): self
  223.     {
  224.         $this->city = $city;
  226.         return $this;
  227.     }
  229.     public function getCountry(): ?Country
  230.     {
  231.         return $this->country;
  232.     }
  234.     public function setCountry(?Country $country): self
  235.     {
  236.         $this->country = $country;
  238.         return $this;
  239.     }
  241.     public function isIsDeleted(): ?bool
  242.     {
  243.         return $this->isDeleted;
  244.     }
  246.     public function setIsDeleted(bool $isDeleted): self
  247.     {
  248.         $this->isDeleted = $isDeleted;
  250.         return $this;
  251.     }
  253.     public function getDateCreated(): ?\DateTimeInterface
  254.     {
  255.         return $this->dateCreated;
  256.     }
  258.     public function setDateCreated(\DateTimeInterface $dateCreated): self
  259.     {
  260.         $this->dateCreated = $dateCreated;
  262.         return $this;
  263.     }
  266.     public function getDateUpdated(): ?\DateTimeInterface
  267.     {
  268.         return $this->dateUpdated;
  269.     }
  271.     public function setDateUpdated(\DateTimeInterface $dateUpdated): self
  272.     {
  273.         $this->dateUpdated = $dateUpdated;
  275.         return $this;
  276.     }
  278.     public function getRapper(): ?Rapper
  279.     {
  280.         return $this->rapper;
  281.     }
  283.     public function setRapper(?Rapper $rapper): static
  284.     {
  285.         // unset the owning side of the relation if necessary
  286.         if ($rapper === null && $this->rapper !== null) {
  287.             $this->rapper->setClient(null);
  288.         }
  290.         // set the owning side of the relation if necessary
  291.         if ($rapper !== null && $rapper->getClient() !== $this) {
  292.             $rapper->setClient($this);
  293.         }
  295.         $this->rapper = $rapper;
  297.         return $this;
  298.     }
  301.     public function isIsActive(): ?bool
  302.     {
  303.         return $this->isActive;
  304.     }
  306.     public function setIsActive(bool $isActive): static
  307.     {
  308.         $this->isActive = $isActive;
  310.         return $this;
  311.     }
  313.     public function getActivatedAt(): ?\DateTime
  314.     {
  315.         return $this->activatedAt;
  316.     }
  318.     public function setActivatedAt(\DateTime $activatedAt): static
  319.     {
  320.         $this->activatedAt = $activatedAt;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, ClientActivationToken>
  327.      */
  328.     public function getClientActivationTokens(): Collection
  329.     {
  330.         return $this->clientActivationTokens;
  331.     }
  333.     public function addClientActivationToken(ClientActivationToken $clientActivationToken): static
  334.     {
  335.         if (!$this->clientActivationTokens->contains($clientActivationToken)) {
  336.             $this->clientActivationTokens->add($clientActivationToken);
  337.             $clientActivationToken->setClient($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeClientActivationToken(ClientActivationToken $clientActivationToken): static
  344.     {
  345.         if ($this->clientActivationTokens->removeElement($clientActivationToken)) {
  346.             // set the owning side to null (unless already changed)
  347.             if ($clientActivationToken->getClient() === $this) {
  348.                 $clientActivationToken->setClient(null);
  349.             }
  350.         }
  352.         return $this;
  353.     }
  355.     public function getClientSettings(): ?ClientSettings
  356.     {
  357.         return $this->clientSettings;
  358.     }
  360.     public function setClientSettings(ClientSettings $clientSettings): static
  361.     {
  362.         // set the owning side of the relation if necessary
  363.         if ($clientSettings->getClient() !== $this) {
  364.             $clientSettings->setClient($this);
  365.         }
  367.         $this->clientSettings = $clientSettings;
  369.         return $this;
  370.     }
  372.     public function getAuthor(): ?BeatAuthor
  373.     {
  374.         return $this->author;
  375.     }
  377.     public function setAuthor(?BeatAuthor $author): static
  378.     {
  379.         $this->author = $author;
  381.         return $this;
  382.     }
  387.     /**
  388.      * @return Collection<int, ClientMessage>
  389.      */
  390.     public function getClientMessagesSent(): Collection
  391.     {
  392.         return $this->clientMessagesSent;
  393.     }
  395.     public function addClientMessagesSent(ClientMessage $clientMessagesSent): static
  396.     {
  397.         if (!$this->clientMessagesSent->contains($clientMessagesSent)) {
  398.             $this->clientMessagesSent->add($clientMessagesSent);
  399.             $clientMessagesSent->setSender($this);
  400.         }
  402.         return $this;
  403.     }
  405.     public function removeClientMessagesSent(ClientMessage $clientMessagesSent): static
  406.     {
  407.         if ($this->clientMessagesSent->removeElement($clientMessagesSent)) {
  408.             // set the owning side to null (unless already changed)
  409.             if ($clientMessagesSent->getSender() === $this) {
  410.                 $clientMessagesSent->setSender(null);
  411.             }
  412.         }
  414.         return $this;
  415.     }
  417.     /**
  418.      * @return Collection<int, ClientNotification>
  419.      */
  420.     public function getClientNotifications(): Collection
  421.     {
  422.         return $this->clientNotifications;
  423.     }
  425.     public function addClientNotification(ClientNotification $clientNotification): static
  426.     {
  427.         if (!$this->clientNotifications->contains($clientNotification)) {
  428.             $this->clientNotifications->add($clientNotification);
  429.             $clientNotification->setClient($this);
  430.         }
  432.         return $this;
  433.     }
  435.     public function removeClientNotification(ClientNotification $clientNotification): static
  436.     {
  437.         if ($this->clientNotifications->removeElement($clientNotification)) {
  438.             // set the owning side to null (unless already changed)
  439.             if ($clientNotification->getClient() === $this) {
  440.                 $clientNotification->setClient(null);
  441.             }
  442.         }
  444.         return $this;
  445.     }
  447.     /**
  448.      * @return Collection<int, ClientMessage>
  449.      */
  450.     public function getClientMessages(): Collection
  451.     {
  452.         return $this->clientMessages;
  453.     }
  455.     public function addClientMessage(ClientMessage $clientMessage): static
  456.     {
  457.         if (!$this->clientMessages->contains($clientMessage)) {
  458.             $this->clientMessages->add($clientMessage);
  459.             $clientMessage->addRecipient($this);
  460.         }
  462.         return $this;
  463.     }
  465.     public function removeClientMessage(ClientMessage $clientMessage): static
  466.     {
  467.         if ($this->clientMessages->removeElement($clientMessage)) {
  468.             $clientMessage->removeRecipient($this);
  469.         }
  471.         return $this;
  472.     }
  474.     /**
  475.      * @return Collection<int, Rapper>
  476.      */
  477.     public function getRappersFollowed(): Collection
  478.     {
  479.         return $this->rappersFollowed;
  480.     }
  482.     public function addRappersFollowed(Rapper $rappersFollowed): static
  483.     {
  484.         if (!$this->rappersFollowed->contains($rappersFollowed)) {
  485.             $this->rappersFollowed->add($rappersFollowed);
  486.             $rappersFollowed->addFollower($this);
  487.         }
  489.         return $this;
  490.     }
  492.     public function removeRappersFollowed(Rapper $rappersFollowed): static
  493.     {
  494.         if ($this->rappersFollowed->removeElement($rappersFollowed)) {
  495.             $rappersFollowed->removeFollower($this);
  496.         }
  498.         return $this;
  499.     }
  501.     public function getReferal(): ?self
  502.     {
  503.         return $this->referal;
  504.     }
  506.     public function setReferal(?self $referal): static
  507.     {
  508.         $this->referal = $referal;
  510.         return $this;
  511.     }
  513.     /**
  514.      * @return Collection<int, self>
  515.      */
  516.     public function getReferals(): Collection
  517.     {
  518.         return $this->referals;
  519.     }
  521.     public function addReferal(self $referal): static
  522.     {
  523.         if (!$this->referals->contains($referal)) {
  524.             $this->referals->add($referal);
  525.             $referal->setReferal($this);
  526.         }
  528.         return $this;
  529.     }
  531.     public function removeReferal(self $referal): static
  532.     {
  533.         if ($this->referals->removeElement($referal)) {
  534.             // set the owning side to null (unless already changed)
  535.             if ($referal->getReferal() === $this) {
  536.                 $referal->setReferal(null);
  537.             }
  538.         }
  540.         return $this;
  541.     }
  543.     /**
  544.      * @return Collection<int, Beat>
  545.      */
  546.     public function getFavoriteBeats(): Collection
  547.     {
  548.         return $this->favoriteBeats;
  549.     }
  551.     public function addFavoriteBeat(Beat $favoriteBeat): static
  552.     {
  553.         if (!$this->favoriteBeats->contains($favoriteBeat)) {
  554.             $this->favoriteBeats->add($favoriteBeat);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeFavoriteBeat(Beat $favoriteBeat): static
  561.     {
  562.         $this->favoriteBeats->removeElement($favoriteBeat);
  564.         return $this;
  565.     }
  567.     /**
  568.      * @return Collection<int, Battle>
  569.      */
  570.     public function getFavoriteBattles(): Collection
  571.     {
  572.         return $this->favoriteBattles;
  573.     }
  575.     public function addFavoriteBattle(Battle $favoriteBattle): static
  576.     {
  577.         if (!$this->favoriteBattles->contains($favoriteBattle)) {
  578.             $this->favoriteBattles->add($favoriteBattle);
  579.         }
  581.         return $this;
  582.     }
  584.     public function removeFavoriteBattle(Battle $favoriteBattle): static
  585.     {
  586.         $this->favoriteBattles->removeElement($favoriteBattle);
  588.         return $this;
  589.     }
  591.     public function getResetPasswordHash(): ?string
  592.     {
  593.         return $this->resetPasswordHash;
  594.     }
  596.     public function setResetPasswordHash(?string $resetPasswordHash): static
  597.     {
  598.         $this->resetPasswordHash = $resetPasswordHash;
  600.         return $this;
  601.     }
  603.     public function getResetPasswordHashValidTo(): ?\DateTime
  604.     {
  605.         return $this->resetPasswordHashValidTo;
  606.     }
  608.     public function setResetPasswordHashValidTo(?\DateTime $resetPasswordHashValidTo): static
  609.     {
  610.         $this->resetPasswordHashValidTo = $resetPasswordHashValidTo;
  612.         return $this;
  613.     }
  615.     public function getCrew(): ?Crew
  616.     {
  617.         return $this->crew;
  618.     }
  620.     public function setCrew(?Crew $crew): static
  621.     {
  622.         // unset the owning side of the relation if necessary
  623.         if ($crew === null && $this->crew !== null) {
  624.             $this->crew->setCreatedBy(null);
  625.         }
  627.         // set the owning side of the relation if necessary
  628.         if ($crew !== null && $crew->getCreatedBy() !== $this) {
  629.             $crew->setCreatedBy($this);
  630.         }
  632.         $this->crew = $crew;
  634.         return $this;
  635.     }
  637.     public function setImageFile(?File $imageFile = null): void
  638.     {
  639.         $this->imageFile = $imageFile;
  641.         if ($this->imageFile instanceof UploadedFile) {
  642.             $this->dateUpdated = new \DateTime('now');
  643.         }
  644.     }
  646.     public function getImageFile(): ?File
  647.     {
  648.         return $this->imageFile;
  649.     }
  652.     public function setImageName(?string $imageName): void
  653.     {
  654.         $this->imageName = $imageName;
  655.     }
  657.     public function getImageName(): ?string
  658.     {
  659.         return $this->imageName;
  660.     }
  662.     public function setImageSize(?int $imageSize): void
  663.     {
  664.         $this->imageSize = $imageSize;
  665.     }
  667.     public function getAvatarSize(): ?int
  668.     {
  669.         return $this->imageSize;
  670.     }
  672.     /**
  673.      * @return Collection<int, AuthorizationToken>
  674.      */
  675.     public function getAuthorizationTokens(): Collection
  676.     {
  677.         return $this->authorizationTokens;
  678.     }
  680.     public function addAuthorizationToken(AuthorizationToken $authorizationToken): static
  681.     {
  682.         if (!$this->authorizationTokens->contains($authorizationToken)) {
  683.             $this->authorizationTokens->add($authorizationToken);
  684.             $authorizationToken->setClient($this);
  685.         }
  687.         return $this;
  688.     }
  690.     public function removeAuthorizationToken(AuthorizationToken $authorizationToken): static
  691.     {
  692.         if ($this->authorizationTokens->removeElement($authorizationToken)) {
  693.             // set the owning side to null (unless already changed)
  694.             if ($authorizationToken->getClient() === $this) {
  695.                 $authorizationToken->setClient(null);
  696.             }
  697.         }
  699.         return $this;
  700.     }
  702.     /**
  703.      * @return Collection<int, BeatAuthor>
  704.      */
  705.     public function getFollowedAuthors(): Collection
  706.     {
  707.         return $this->followedAuthors;
  708.     }
  710.     public function addFollowedAuthor(BeatAuthor $followedAuthor): static
  711.     {
  712.         if (!$this->followedAuthors->contains($followedAuthor)) {
  713.             $this->followedAuthors->add($followedAuthor);
  714.             $followedAuthor->addFollower($this);
  715.         }
  717.         return $this;
  718.     }
  720.     public function removeFollowedAuthor(BeatAuthor $followedAuthor): static
  721.     {
  722.         if ($this->followedAuthors->removeElement($followedAuthor)) {
  723.             $followedAuthor->removeFollower($this);
  724.         }
  726.         return $this;
  727.     }
  729.     /**
  730.      * @return Collection<int, BattleComment>
  731.      */
  732.     public function getBattleComments(): Collection
  733.     {
  734.         return $this->battleComments;
  735.     }
  737.     public function addBattleComment(BattleComment $battleComment): static
  738.     {
  739.         if (!$this->battleComments->contains($battleComment)) {
  740.             $this->battleComments->add($battleComment);
  741.             $battleComment->setSender($this);
  742.         }
  744.         return $this;
  745.     }
  747.     public function removeBattleComment(BattleComment $battleComment): static
  748.     {
  749.         if ($this->battleComments->removeElement($battleComment)) {
  750.             // set the owning side to null (unless already changed)
  751.             if ($battleComment->getSender() === $this) {
  752.                 $battleComment->setSender(null);
  753.             }
  754.         }
  756.         return $this;
  757.     }
  759.     /**
  760.      * @return Collection<int, Vote>
  761.      */
  762.     public function getMyBattleVotes(): Collection
  763.     {
  764.         return $this->myBattleVotes;
  765.     }
  767.     public function addMyBattleVote(Vote $myBattleVote): static
  768.     {
  769.         if (!$this->myBattleVotes->contains($myBattleVote)) {
  770.             $this->myBattleVotes->add($myBattleVote);
  771.             $myBattleVote->setVoter($this);
  772.         }
  774.         return $this;
  775.     }
  777.     public function removeMyBattleVote(Vote $myBattleVote): static
  778.     {
  779.         if ($this->myBattleVotes->removeElement($myBattleVote)) {
  780.             // set the owning side to null (unless already changed)
  781.             if ($myBattleVote->getVoter() === $this) {
  782.                 $myBattleVote->setVoter(null);
  783.             }
  784.         }
  786.         return $this;
  787.     }
  789.     /**
  790.      * @return Collection<int, BattleCommentLike>
  791.      */
  792.     public function getBattleCommentLikes(): Collection
  793.     {
  794.         return $this->battleCommentLikes;
  795.     }
  797.     public function addBattleCommentLike(BattleCommentLike $battleCommentLike): static
  798.     {
  799.         if (!$this->battleCommentLikes->contains($battleCommentLike)) {
  800.             $this->battleCommentLikes->add($battleCommentLike);
  801.             $battleCommentLike->setLikedBy($this);
  802.         }
  804.         return $this;
  805.     }
  807.     public function removeBattleCommentLike(BattleCommentLike $battleCommentLike): static
  808.     {
  809.         if ($this->battleCommentLikes->removeElement($battleCommentLike)) {
  810.             // set the owning side to null (unless already changed)
  811.             if ($battleCommentLike->getLikedBy() === $this) {
  812.                 $battleCommentLike->setLikedBy(null);
  813.             }
  814.         }
  816.         return $this;
  817.     }
  823. }