src/Entity/User.php line 29

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\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  11. use Symfony\Component\Validator\Constraints as Assert;
  12. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  13. use Symfony\Component\HttpFoundation\File\File;
  15. /**
  16.  * @ORM\Entity(repositoryClass=UserRepository::class)
  17.  * @UniqueEntity(
  18.  *     fields={"username"},
  19.  *     errorPath="username",
  20.  *     message="This username is already used"
  21.  * )
  22.  *  @UniqueEntity(
  23.  *     fields={"email"},
  24.  *     errorPath="email",
  25.  *     message="This email is already used"
  26.  * )
  27.  * @ORM\Table(name="`user`")
  28.  */
  29. class User implements UserInterface, PasswordAuthenticatedUserInterface
  30. {
  31.     /**
  32.      * @ORM\Id
  33.      * @ORM\GeneratedValue
  34.      * @ORM\Column(type="integer")
  35.      */
  36.     private $id;
  38.     /**
  39.      * @ORM\Column(type="string", length=50, unique=true)
  40.      * @Assert\NotBlank()
  41.      * @Assert\Email(
  42.      *     message = "The email '{{ value }}' is not valid."
  43.      * )
  44.      */    
  45.     private $email;
  47.     /**
  48.      * @ORM\Column(type="json")
  49.      */
  50.     private $roles = [];
  52.     /**
  53.      * @var string The hashed password
  54.      * @ORM\Column(type="string")
  55.      * @Assert\NotBlank(groups={"password"})
  56.      * @Assert\Length(
  57.      *      min = 4,
  58.      *      max = 15,
  59.      *      minMessage = "Your password must be at least {{ limit }} characters",
  60.      *      maxMessage = "Your password must be at most {{ limit }} characters",
  61.      *      groups={"password"}
  62.      * )
  63.      */
  64.     private $password;
  66.     /**
  67.      * @ORM\Column(type="string", length=20)
  68.      * @Assert\NotBlank()
  69.      * @Assert\Regex(
  70.      *     pattern = "/^(?=.{3,15}$)(?![_.-])(?!.*[_.-]{2})[a-zA-Z0-9_-]+([^._-])$/",
  71.      *     message = "Your username is invalid"
  72.      * )
  73.      * @Assert\Length(
  74.      *      min = 3,
  75.      *      max = 15,
  76.      *      minMessage = "Your username must be at least {{ limit }} characters",
  77.      *      maxMessage = "Your username must be at most {{ limit }} characters"
  78.      * )
  79.      */
  80.     private $username;
  82.     /**
  83.      * @ORM\Column(type="datetime_immutable")
  84.      */
  85.     private $created_at;
  87.     public function __construct()
  88.     {
  89.         $this->last_login = new \DateTime();
  90.         $this->created_at = new \DateTimeImmutable();
  91.         $this->photos = new ArrayCollection();
  92.         $this->photoLikes = new ArrayCollection();
  93.         $this->influencerFollowers = new ArrayCollection();
  94.         $this->comments = new ArrayCollection();
  95.         $this->videos = new ArrayCollection();
  96.         $this->profil_comments = new ArrayCollection();
  97.         $this->notifications = new ArrayCollection();
  98.         $this->setPicture(false);
  99.         $this->setNewsletter(true);
  100.         $this->setMailNotification(true);
  101.         $this->setImage(null);
  102.         $this->setRoles(['ROLE_USER']);        
  103.     }
  106.     /**
  107.      * @ORM\Column(type="datetime")
  108.      */
  109.     private $last_login;
  111.     /**
  112.      * @ORM\OneToMany(targetEntity=Photo::class, mappedBy="user", orphanRemoval=true)
  113.      */
  114.     private $photos;
  116.     /**
  117.      * @Assert\NotBlank()
  118.      */
  119.     private $agree_terms;
  121.     /**
  122.      * @ORM\OneToMany(targetEntity=PhotoLike::class, mappedBy="user", orphanRemoval=true)
  123.      */
  124.     private $photoLikes;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=InfluencerFollower::class, mappedBy="user", orphanRemoval=true)
  128.      */
  129.     private $influencerFollowers;
  131.     /**
  132.      * @ORM\Column(type="string", length=255, nullable=true)
  133.      */
  134.     private $ip;
  136.     /**
  137.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="user", orphanRemoval=true)
  138.      */
  139.     private $comments;
  141.     /**
  142.      * @ORM\Column(type="string", length=255, nullable=true)
  143.      */
  144.     private $country;
  146.     /**
  147.      * @Assert\Length(
  148.      *      min = 3,
  149.      *      max = 250,
  150.      *      minMessage = "Your bio must be at least {{ limit }} characters long",
  151.      *      maxMessage = "Your bio cannot be longer than {{ limit }} characters"
  152.      * )    
  153.      * @ORM\Column(type="string", length=255, nullable=true)
  154.      */
  155.     private $bio;
  157.     /**
  158.      * @Assert\Image(
  159.      *     minWidth = 70,
  160.      *     minHeight = 70,
  161.      *     minWidthMessage = "Your photo is too small",
  162.      *     minHeightMessage = "Your photo is too small",
  163.      *     maxSize = "5M",
  164.      *     maxSizeMessage = "The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}"
  165.      * )     
  166.      * @Assert\Valid()
  167.      */
  168.     private $image;
  170.     /**
  171.      * @ORM\Column(type="boolean", nullable=true)
  172.      */
  173.     private $picture;
  175.     /**
  176.      * @ORM\OneToMany(targetEntity=Video::class, mappedBy="user", orphanRemoval=true)
  177.      */
  178.     private $videos;
  180.     /**
  181.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="to_user")
  182.      */
  183.     private $profil_comments;
  185.     /**
  186.      * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="user", orphanRemoval=true)
  187.      */
  188.     private $notifications;
  190.     /**
  191.      * @ORM\Column(type="boolean", nullable=true)
  192.      */
  193.     private $newsletter;
  195.     /**
  196.      * @ORM\Column(type="boolean", nullable=true)
  197.      */
  198.     private $mail_notification;
  200.     /**
  201.      * @ORM\Column(type="smallint", options={"default": 0})
  202.      */
  203.     private $trust_level = 0;
  205.     /**
  206.      * @ORM\Column(type="integer", options={"default": 0})
  207.      */
  208.     private $upload_count = 0;
  210.     /**
  211.      * @ORM\Column(type="integer", options={"default": 0})
  212.      */
  213.     private $approved_count = 0;
  215.     /**
  216.      * @ORM\Column(type="integer", options={"default": 0})
  217.      */
  218.     private $rejected_count = 0;
  220.     /**
  221.      * @ORM\Column(type="date", nullable=true)
  222.      */
  223.     private $last_upload_date;
  225.     /**
  226.      * @ORM\Column(type="integer", options={"default": 0})
  227.      */
  228.     private $daily_upload_count = 0;
  230.     /**
  231.      * @ORM\Column(type="boolean", options={"default": false})
  232.      */
  233.     private $banned = false;
  235.     public function getId(): ?int
  236.     {
  237.         return $this->id;
  238.     }
  240.     public function getEmail(): ?string
  241.     {
  242.         return $this->email;
  243.     }
  245.     public function setEmail(string $email): self
  246.     {
  247.         $this->email = $email;
  249.         return $this;
  250.     }
  252.     /**
  253.      * A visual identifier that represents this user.
  254.      *
  255.      * @see UserInterface
  256.      */
  257.     public function getUserIdentifier(): string
  258.     {
  259.         return (string) $this->email;
  260.     }
  262.     /**
  263.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  264.      */
  265.     public function getUsername(): string
  266.     {
  267.         return (string) $this->username;
  268.     }
  270.     /**
  271.      * @see UserInterface
  272.      */
  273.     public function getRoles(): array
  274.     {
  275.         $roles = $this->roles;
  276.         // guarantee every user at least has ROLE_USER
  277.         $roles[] = 'ROLE_USER';
  279.         return array_unique($roles);
  280.     }
  282.     public function setRoles(array $roles): self
  283.     {
  284.         $this->roles = $roles;
  286.         return $this;
  287.     }
  289.     /**
  290.      * @see PasswordAuthenticatedUserInterface
  291.      */
  292.     public function getPassword(): string
  293.     {
  294.         return $this->password;
  295.     }
  297.     public function setPassword(string $password): self
  298.     {
  299.         $this->password = $password;
  301.         return $this;
  302.     }
  304.     /**
  305.      * Returning a salt is only needed, if you are not using a modern
  306.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  307.      *
  308.      * @see UserInterface
  309.      */
  310.     public function getSalt(): ?string
  311.     {
  312.         return null;
  313.     }
  315.     /**
  316.      * @see UserInterface
  317.      */
  318.     public function eraseCredentials()
  319.     {
  320.         // If you store any temporary, sensitive data on the user, clear it here
  321.         // $this->plainPassword = null;
  322.     }
  324.     public function setUsername(string $username): self
  325.     {
  326.         $this->username = $username;
  328.         return $this;
  329.     }
  331.     public function getCreatedAt(): ?\DateTimeImmutable
  332.     {
  333.         return $this->created_at;
  334.     }
  336.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  337.     {
  338.         $this->created_at = $created_at;
  340.         return $this;
  341.     }
  343.     public function getLastLogin(): ?\DateTime
  344.     {
  345.         return $this->last_login;
  346.     }
  348.     public function setLastLogin(\DateTime $last_login): self
  349.     {
  350.         $this->last_login = $last_login;
  352.         return $this;
  353.     }
  355.     /**
  356.      * @return Collection<int, Photo>
  357.      */
  358.     public function getPhotos(): Collection
  359.     {
  360.         return $this->photos;
  361.     }
  363.     public function addPhoto(Photo $photo): self
  364.     {
  365.         if (!$this->photos->contains($photo)) {
  366.             $this->photos[] = $photo;
  367.             $photo->setUser($this);
  368.         }
  370.         return $this;
  371.     }
  373.     public function removePhoto(Photo $photo): self
  374.     {
  375.         if ($this->photos->removeElement($photo)) {
  376.             // set the owning side to null (unless already changed)
  377.             if ($photo->getUser() === $this) {
  378.                 $photo->setUser(null);
  379.             }
  380.         }
  382.         return $this;
  383.     }
  386.     public function setAgreeTerms(bool $agree_terms): self
  387.     {
  388.         $this->agree_terms = $agree_terms;
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return Collection<int, PhotoLike>
  395.      */
  396.     public function getPhotoLikes(): Collection
  397.     {
  398.         return $this->photoLikes;
  399.     }
  401.     public function addPhotoLike(PhotoLike $photoLike): self
  402.     {
  403.         if (!$this->photoLikes->contains($photoLike)) {
  404.             $this->photoLikes[] = $photoLike;
  405.             $photoLike->setUser($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removePhotoLike(PhotoLike $photoLike): self
  412.     {
  413.         if ($this->photoLikes->removeElement($photoLike)) {
  414.             // set the owning side to null (unless already changed)
  415.             if ($photoLike->getUser() === $this) {
  416.                 $photoLike->setUser(null);
  417.             }
  418.         }
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, InfluencerFollower>
  425.      */
  426.     public function getInfluencerFollowers(): Collection
  427.     {
  428.         return $this->influencerFollowers;
  429.     }
  431.     public function addInfluencerFollower(InfluencerFollower $influencerFollower): self
  432.     {
  433.         if (!$this->influencerFollowers->contains($influencerFollower)) {
  434.             $this->influencerFollowers[] = $influencerFollower;
  435.             $influencerFollower->setUser($this);
  436.         }
  438.         return $this;
  439.     }
  441.     public function removeInfluencerFollower(InfluencerFollower $influencerFollower): self
  442.     {
  443.         if ($this->influencerFollowers->removeElement($influencerFollower)) {
  444.             // set the owning side to null (unless already changed)
  445.             if ($influencerFollower->getUser() === $this) {
  446.                 $influencerFollower->setUser(null);
  447.             }
  448.         }
  450.         return $this;
  451.     }
  453.     public function getIp(): ?string
  454.     {
  455.         return $this->ip;
  456.     }
  458.     public function setIp(?string $ip): self
  459.     {
  460.         $this->ip = $ip;
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, Comment>
  467.      */
  468.     public function getComments(): Collection
  469.     {
  470.         return $this->comments;
  471.     }
  473.     public function addComment(Comment $comment): self
  474.     {
  475.         if (!$this->comments->contains($comment)) {
  476.             $this->comments[] = $comment;
  477.             $comment->setUser($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeComment(Comment $comment): self
  484.     {
  485.         if ($this->comments->removeElement($comment)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($comment->getUser() === $this) {
  488.                 $comment->setUser(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  495.     public function getCountry(): ?string
  496.     {
  497.         return $this->country;
  498.     }
  500.     public function setCountry(?string $country): self
  501.     {
  502.         $this->country = $country;
  504.         return $this;
  505.     }
  507.     public function getBio(): ?string
  508.     {
  509.         return $this->bio;
  510.     }
  512.     public function setBio(?string $bio): self
  513.     {
  514.         $this->bio = $bio;
  516.         return $this;
  517.     }
  519.     public function getPicture(): ?bool
  520.     {
  521.         return $this->picture;
  522.     }
  524.     public function setPicture(?bool $picture): self
  525.     {
  526.         $this->picture = $picture;
  528.         return $this;
  529.     }
  531.     public function getImage(): ?string
  532.     {
  533.         return $this->image;
  534.     }
  536.     public function setImage(File $file = null)
  537.     {
  538.         $this->image = $file;
  540.         return $this;
  541.     }
  543.     /**
  544.      * @return Collection<int, Video>
  545.      */
  546.     public function getVideos(): Collection
  547.     {
  548.         return $this->videos;
  549.     }
  551.     public function addVideo(Video $video): self
  552.     {
  553.         if (!$this->videos->contains($video)) {
  554.             $this->videos[] = $video;
  555.             $video->setUser($this);
  556.         }
  558.         return $this;
  559.     }
  561.     public function removeVideo(Video $video): self
  562.     {
  563.         if ($this->videos->removeElement($video)) {
  564.             // set the owning side to null (unless already changed)
  565.             if ($video->getUser() === $this) {
  566.                 $video->setUser(null);
  567.             }
  568.         }
  570.         return $this;
  571.     }
  573.     /**
  574.      * @return Collection<int, Comment>
  575.      */
  576.     public function getProfilComments(): Collection
  577.     {
  578.         return $this->profil_comments;
  579.     }
  581.     public function addProfilComment(Comment $profilComment): self
  582.     {
  583.         if (!$this->profil_comments->contains($profilComment)) {
  584.             $this->profil_comments[] = $profilComment;
  585.             $profilComment->setToUser($this);
  586.         }
  588.         return $this;
  589.     }
  591.     public function removeProfilComment(Comment $profilComment): self
  592.     {
  593.         if ($this->profil_comments->removeElement($profilComment)) {
  594.             // set the owning side to null (unless already changed)
  595.             if ($profilComment->getToUser() === $this) {
  596.                 $profilComment->setToUser(null);
  597.             }
  598.         }
  600.         return $this;
  601.     }
  603.     /**
  604.      * @return Collection<int, Notification>
  605.      */
  606.     public function getNotifications(): Collection
  607.     {
  608.         return $this->notifications;
  609.     }
  611.     public function addNotification(Notification $notification): self
  612.     {
  613.         if (!$this->notifications->contains($notification)) {
  614.             $this->notifications[] = $notification;
  615.             $notification->setUser($this);
  616.         }
  618.         return $this;
  619.     }
  621.     public function removeNotification(Notification $notification): self
  622.     {
  623.         if ($this->notifications->removeElement($notification)) {
  624.             // set the owning side to null (unless already changed)
  625.             if ($notification->getUser() === $this) {
  626.                 $notification->setUser(null);
  627.             }
  628.         }
  630.         return $this;
  631.     }
  633.     public function getNewsletter(): ?bool
  634.     {
  635.         return $this->newsletter;
  636.     }
  638.     public function setNewsletter(?bool $newsletter): self
  639.     {
  640.         $this->newsletter = $newsletter;
  642.         return $this;
  643.     }
  645.     public function getMailNotification(): ?bool
  646.     {
  647.         return $this->mail_notification;
  648.     }
  650.     public function setMailNotification(bool $mail_notification): self
  651.     {
  652.         $this->mail_notification = $mail_notification;
  654.         return $this;
  655.     }
  657.     public function getTrustLevel(): int
  658.     {
  659.         return $this->trust_level ?? 0;
  660.     }
  662.     public function setTrustLevel(int $trust_level): self
  663.     {
  664.         $this->trust_level = $trust_level;
  665.         return $this;
  666.     }
  668.     public function getUploadCount(): int
  669.     {
  670.         return $this->upload_count ?? 0;
  671.     }
  673.     public function setUploadCount(int $upload_count): self
  674.     {
  675.         $this->upload_count = $upload_count;
  676.         return $this;
  677.     }
  679.     public function getApprovedCount(): int
  680.     {
  681.         return $this->approved_count ?? 0;
  682.     }
  684.     public function setApprovedCount(int $approved_count): self
  685.     {
  686.         $this->approved_count = $approved_count;
  687.         return $this;
  688.     }
  690.     public function getRejectedCount(): int
  691.     {
  692.         return $this->rejected_count ?? 0;
  693.     }
  695.     public function setRejectedCount(int $rejected_count): self
  696.     {
  697.         $this->rejected_count = $rejected_count;
  698.         return $this;
  699.     }
  701.     public function getLastUploadDate(): ?\DateTimeInterface
  702.     {
  703.         return $this->last_upload_date;
  704.     }
  706.     public function setLastUploadDate(?\DateTimeInterface $last_upload_date): self
  707.     {
  708.         $this->last_upload_date = $last_upload_date;
  709.         return $this;
  710.     }
  712.     public function getDailyUploadCount(): int
  713.     {
  714.         return $this->daily_upload_count ?? 0;
  715.     }
  717.     public function setDailyUploadCount(int $daily_upload_count): self
  718.     {
  719.         $this->daily_upload_count = $daily_upload_count;
  720.         return $this;
  721.     }
  723.     public function getDailyUploadLimit(): int
  724.     {
  725.         switch ($this->getTrustLevel()) {
  726.             case 2: return 50;
  727.             case 1: return 20;
  728.             default: return 5;
  729.         }
  730.     }
  732.     public function canAutoPublish(): bool
  733.     {
  734.         return $this->getTrustLevel() >= 1;
  735.     }
  737.     public function isBanned(): bool
  738.     {
  739.         return (bool) $this->banned;
  740.     }
  742.     public function setBanned(bool $banned): self
  743.     {
  744.         $this->banned = $banned;
  745.         return $this;
  746.     }
  748. }