src/Entity/TvUser.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Annotation\SerializedNameGroups;
  6. use App\Repository\TvUserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Doctrine\ORM\Mapping\Index;
  11. use Doctrine\ORM\Mapping\Table;
  12. use Gedmo\Mapping\Annotation as Gedmo;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Component\Serializer\Annotation\Groups;
  17. use Symfony\Component\Validator\Constraints as Assert;
  19. /**
  20.  * @ORM\Entity(repositoryClass=TvUserRepository::class)
  21.  * @ORM\HasLifecycleCallbacks
  22.  * @Table(indexes={@Index(name="search_idx", columns={"id", "code"})})
  23.  * @UniqueEntity("username", message="user.username_unique")
  24.  */
  25. class TvUser implements UserInterface, PasswordAuthenticatedUserInterface
  26. {
  27.     const QUOTA_DAY = 'daily';
  28.     const QUOTA_WEEK = 'weekly';
  29.     const QUOTA_MONTH = 'monthly';
  30.     const QUOTA_NONE = 'unset';
  31.     const STATUS_ACTIVE = 'active';
  32.     const STATUS_SUSPENDED = 'suspended';
  34.     const STATUSES = [
  35.         self::STATUS_ACTIVE,
  36.         self::STATUS_SUSPENDED,
  37.     ];
  39.     const QUOTAS = [
  40.         self::QUOTA_DAY,
  41.         self::QUOTA_WEEK,
  42.         self::QUOTA_MONTH,
  43.     ];
  45.     /**
  46.      * Associative array, keys are the quotas types (none excluded)
  47.      * values are the string to pass to a datetime object
  48.      */
  49.     const QUOTAS_VAlUES = [
  50.         self::QUOTA_DAY => '1 day',
  51.         self::QUOTA_WEEK => '1 week',
  52.         self::QUOTA_MONTH => '1 month',
  53.     ];
  55.     const ROLE_USER = 'ROLE_USER';
  56.     const ROLE_ADMIN = 'ROLE_ADMIN';
  57.     const ROLE_GOD = 'ROLE_GOD';
  58.     const ROLE_MANAGER = 'ROLE_MANAGER';
  59.     const ROLE_COMPANY_MANAGER = 'ROLE_COMPANY_MANAGER';
  61.     const ROLES = [
  62.         self::ROLE_ADMIN,
  63.         self::ROLE_GOD,
  64.         self::ROLE_USER,
  65.         self::ROLE_MANAGER,
  66.         self::ROLE_COMPANY_MANAGER,
  67.     ];
  69.     /**
  70.      * @ORM\Id
  71.      * @ORM\GeneratedValue
  72.      * @ORM\Column(type="integer")
  73.      * @Groups({"tv_user_read", "tv_company_read", "export_tv_user_csv", "team_read", "team_user_read", "tv_user:read:form", "notification_read"})
  74.      */
  75.     private $id;
  77.     /**
  78.      * @ORM\Column(type="string", length=255, nullable=false, unique=true)
  79.      * @Groups({"tv_user_read", "tv_company_read", "tv_user_creation", "export_tv_user_csv", "message_read", "tv_user_read_creation"})
  80.      * @SerializedNameGroups(name="Identifiant", groups={"tv_user_read_creation"})
  81.      */
  82.     private $code;
  84.     /**
  85.      * @ORM\Column(type="string", length=180, unique=true)
  86.      * @Groups({"tv_user_read", "tv_user_creation", "tv_user_write", "team_read", "team_user_read", "tv_user:read:form", "notification_read"})
  87.      */
  88.     private $username;
  90.     /**
  91.      * @ORM\Column(type="json")
  92.      */
  93.     private $roles = [];
  95.     /**
  96.      * @var string The hashed password
  97.      * @ORM\Column(type="string")
  98.      */
  99.     private $password;
  101.     /**
  102.      * @ORM\Column(type="string", length=255, nullable=true)
  103.      * @Groups({"tv_user_read", "tv_user_write", "team_read", "team_user_read"})
  104.      * @Assert\Email(message="user.email")
  105.      */
  106.     private $email;
  108.     /**
  109.      * @ORM\Column(type="integer")
  110.      * @Groups({"tv_user_read", "tv_user_write", "export_tv_user_csv"})
  111.      */
  112.     private $quotas = 0;
  114.     /**
  115.      * @ORM\Column(type="string", length=255)
  116.      * @Groups({"tv_user_read", "tv_user_write", "export_tv_user_csv"})
  117.      */
  118.     private $quotasType = self::QUOTA_NONE;
  120.     /**
  121.      * @ORM\Column(type="boolean", options={"default": 1})
  122.      * @Groups({"tv_user_read", "tv_company_read", "export_tv_user_csv", "notification_read"})
  123.      */
  124.     private $active = true;
  126.     /**
  127.      * @ORM\Column(type="datetime")
  128.      * @Gedmo\Timestampable(on="create")
  129.      * @Groups({"tv_user_read"})
  130.      */
  131.     private $createdAt;
  133.     /**
  134.      * @ORM\Column(type="datetime")
  135.      * @Groups({"tv_user_read"})
  136.      * @Gedmo\Timestampable(on="update")
  137.      */
  138.     private $updatedAt;
  140.     /**
  141.      * @ORM\Column(type="string", length=255, nullable=true)
  142.      */
  143.     private $recoveryToken;
  145.     /**
  146.      * Property rendered public to use in security precept
  147.      * @var TvCompany
  148.      * @ORM\ManyToOne(targetEntity=TvCompany::class, inversedBy="tvUsers")
  149.      * @Groups({"tv_user_read", "tv_user_creation", "message_read", "tv_user_read_creation", "team_user_read"})
  150.      * @SerializedNameGroups(name="Entreprise", groups={"tv_user_read_creation"})
  151.      */
  152.     public $tvCompany;
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=Log::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  156.      */
  157.     private $logs;
  159.     /**
  160.      * Sent messages by the tvUser to web admins
  161.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  162.      */
  163.     private $messages;
  165.     /**
  166.      * @ORM\Column(type="datetime", nullable=true)
  167.      * @Groups({"tv_user_read", "tv_company_read"})
  168.      */
  169.     private $lastLogin;
  171.     /**
  172.      * @var string|null
  173.      * @Groups({"tv_user_creation", "tv_user_write", "tv_user_read_creation"})
  174.      * @Assert\Regex("/(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}/", message="user.password")
  175.      * @SerializedNameGroups(name="Mot-de-passe", groups={"tv_user_read_creation"})
  176.      */
  177.     private $plainPassword = null;
  179.     /**
  180.      * @var string|null
  181.      * @Groups({"tv_user_creation", "tv_user_write"})
  182.      * @Assert\IdenticalTo(propertyPath="plainPassword", message="user.repeat_password")
  183.      */
  184.     private $passwordConfirm = null;
  186.     /**
  187.      * @var bool
  188.      */
  189.     public $isPopulated = false;
  191.     /**
  192.      * @ORM\OneToMany(targetEntity=VideoEvent::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  193.      */
  194.     private $videoEvents;
  196.     /**
  197.      * @ORM\Column(type="boolean", options={"default": 0})
  198.      * @Groups({"tv_user_read", "tv_company_read", "tv_user_write"})
  199.      */
  200.     private $newsletter = false;
  202.     /**
  203.      * @ORM\Column(type="boolean", options={"default": 1})
  204.      * @Groups({"tv_user_read", "tv_company_read", "tv_user_write"})
  205.      */
  206.     private $firstLogin = true;
  208.     /**
  209.      * @ORM\Column(type="boolean", options={"default": 1})
  210.      * @Groups({"tv_user_read", "tv_company_read", "tv_user_write"})
  211.      */
  212.     private $homeSurvey = true;
  214.     /**
  215.      * @ORM\Column(type="datetime", nullable=true)
  216.      * @Groups({"tv_user_read", "tv_company_read"})
  217.      * @Gedmo\Timestampable(on="change", field="newsletter", value=true)
  218.      */
  219.     private $newsletterDate;
  221.     /**
  222.      * @ORM\OneToMany(targetEntity=UserResponse::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  223.      */
  224.     private $userResponses;
  226.     /**
  227.      * @ORM\Column(type="datetime", nullable=true)
  228.      * @Gedmo\Timestampable(on="change", field="email")
  229.      */
  230.     private $emailUpdatedAt;
  232.     /**
  233.      * @ORM\Column(type="datetime", nullable=true)
  234.      */
  235.     private $emailValidatedAt;
  237.     /**
  238.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  239.      */
  240.     private $favorites;
  242.     /**
  243.      * @ORM\Column(type="string", length=255)
  244.      * @Groups({"tv_user_read", "tv_company_read", "export_tv_user_csv"})
  245.      * @Assert\Choice(choices=self::STATUSES)
  246.      */
  247.     private $status;
  249.     /**
  250.      * @ORM\ManyToOne(targetEntity=Department::class, inversedBy="tvUsers")
  251.      * @Groups({"tv_user_read", "tv_user_write"})
  252.      */
  253.     private $department;
  255.     /**
  256.      * @ORM\OneToMany(targetEntity=LogEmail::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  257.      */
  258.     private $logEmails;
  260.     /**
  261.      * @ORM\OneToMany(targetEntity=Channel::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  262.      */
  263.     private $channels;
  265.     /**
  266.      * @ORM\ManyToMany(targetEntity=Objective::class, mappedBy="tvUsers")
  267.      */
  268.     private $objectives;
  270.     /**
  271.      * @ORM\ManyToOne(targetEntity=Association::class, inversedBy="tvUsers")
  272.      * @Groups({"tv_user_read", "tv_user_write", "tv_company_read"})
  273.      */
  274.     private $association;
  276.     /**
  277.      * @ORM\OneToMany(targetEntity=TeamUser::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  278.      */
  279.     private $teamUsers;
  281.     /**
  282.      * @ORM\Column(type="boolean", nullable=true, options={"default": "1"})
  283.      * @Groups({"tv_user_read", "tv_user_write", "tuto_only"})
  284.      */
  285.     private $displayTeamplayTuto = true;
  287.     /**
  288.      * @ORM\OneToMany(targetEntity=TeamplayLog::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  289.      */
  290.     private $teamplayLogs;
  292.     /**
  293.      * @ORM\OneToMany(targetEntity=PedometerLog::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  294.      */
  295.     private $pedometerLogs;
  297.     /**
  298.      * @ORM\Column(type="string", length=255, nullable=true)
  299.      * @Groups({"tv_user_read", "tv_user_write"})
  300.      */
  301.     private $deviceOs;
  303.     /**
  304.      * @ORM\Column(type="text", nullable=true)
  305.      * @Groups({"tv_user_read", "tv_user_write"})
  306.      */
  307.     private $deviceToken;
  309.     /**
  310.      * @ORM\Column(type="string", length=255, nullable=true)
  311.      * @Groups({"tv_user_read", "tv_user_write"})
  312.      */
  313.     private $deviceName;
  315.     /**
  316.      * @ORM\Column(type="boolean", nullable=true, options={"default": 1})
  317.      * @Groups({"tv_user_read", "tv_user_write"})
  318.      */
  319.     private $deviceActive = true;
  321.     /**
  322.      * @ORM\Column(type="datetime", nullable=true)
  323.      * @Gedmo\Timestampable(on="change", field={"deviceOs", "deviceToken", "deviceName", "deviceActive"})
  324.      * @Groups({"tv_user_read", "tv_user_write"})
  325.      */
  326.     private $deviceUpdate;
  328.     /**
  329.      * @ORM\OneToMany(targetEntity=UserNotification::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  330.      */
  331.     private $userNotifications;
  333.     /**
  334.      * @ORM\OneToMany(targetEntity=UserDevice::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  335.      */
  336.     private $devices;
  338.     /**
  339.      * @ORM\OneToMany(targetEntity=AwardLog::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  340.      */
  341.     private $awardLogs;
  343.     /**
  344.      * @ORM\OneToMany(targetEntity=UserVideoTimecode::class, mappedBy="tvUser", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  345.      */
  346.     private $userVideoTimecodes;
  348.     /**
  349.      * @ORM\OneToMany(targetEntity=Notation::class, mappedBy="tvUser", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  350.      */
  351.     private $notations;
  353.     /**
  354.      * @ORM\OneToMany(targetEntity=VideoLastValidate::class, mappedBy="tvUser", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  355.      */
  356.     private $videoLastValidates;
  358.     /**
  359.      * @ORM\OneToMany(targetEntity=VideoLastSeen::class, mappedBy="tvUser", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  360.      */
  361.     private $videoLastSeens;
  363.     /**
  364.      * @ORM\OneToMany(targetEntity=MoodResponse::class, mappedBy="tvUser", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  365.      */
  366.     private $moodResponses;
  368.     /**
  369.      * @ORM\OneToMany(targetEntity=ProgramEvent::class, mappedBy="tvUser", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  370.      */
  371.     private $programEvents;
  373.     /**
  374.      * @ORM\OneToMany(targetEntity=DayEvent::class, mappedBy="tvUser", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  375.      */
  376.     private $dayEvents;
  378.     /**
  379.      * @ORM\OneToOne(targetEntity=User::class, inversedBy="tvUser")
  380.      */
  381.     private $user;
  383.     public function __construct()
  384.     {
  385.         $this->logs = new ArrayCollection();
  386.         $this->messages = new ArrayCollection();
  387.         $this->videoEvents = new ArrayCollection();
  388.         $this->roles = [self::ROLE_USER];
  389.         $this->userResponses = new ArrayCollection();
  390.         $this->favorites = new ArrayCollection();
  391.         $this->logEmails = new ArrayCollection();
  392.         $this->channels = new ArrayCollection();
  393.         $this->objectives = new ArrayCollection();
  394.         $this->teamUsers = new ArrayCollection();
  395.         $this->teams = new ArrayCollection();
  396.         $this->teamplayLogs = new ArrayCollection();
  397.         $this->pedometerLogs = new ArrayCollection();
  398.         $this->userNotifications = new ArrayCollection();
  399.         $this->devices = new ArrayCollection();
  400.         $this->awardLogs = new ArrayCollection();
  401.         $this->userVideoTimecodes = new ArrayCollection();
  402.         $this->notations = new ArrayCollection();
  403.         $this->videoLastValidates = new ArrayCollection();
  404.         $this->videoLastSeens = new ArrayCollection();
  405.         $this->moodResponses = new ArrayCollection();
  406.         $this->programEvents = new ArrayCollection();
  407.         $this->dayEvents = new ArrayCollection();
  408.     }
  410.     public function __toString(): string
  411.     {
  412.         return "#{$this->getId()} - {$this->getUsername()}";
  413.     }
  415.     public function getId(): ?int
  416.     {
  417.         return $this->id;
  418.     }
  420.     /**
  421.      * A visual identifier that represents this user.
  422.      *
  423.      * @see UserInterface
  424.      */
  425.     public function getUserIdentifier(): string
  426.     {
  427.         return (string)$this->getUsername();
  428.     }
  430.     /**
  431.      * A visual identifier that represents this tvUser.
  432.      *
  433.      * @see UserInterface
  434.      */
  435.     public function getUsername(): string
  436.     {
  437.         return (string)$this->username;
  438.     }
  440.     public function setUsername(string $username): self
  441.     {
  442.         $this->username = $username;
  444.         return $this;
  445.     }
  447.     /**
  448.      * @see UserInterface
  449.      */
  450.     public function getRoles(): array
  451.     {
  452.         $roles = $this->roles;
  453.         // guarantee every tvUser at least has ROLE_USER
  454.         $roles[] = 'ROLE_USER';
  456.         return array_unique($roles);
  457.     }
  459.     public function setRoles(array $roles): self
  460.     {
  461.         $this->roles = $roles;
  463.         return $this;
  464.     }
  466.     /**
  467.      * @see UserInterface
  468.      */
  469.     public function getPassword(): string
  470.     {
  471.         return (string)$this->password;
  472.     }
  474.     public function setPassword(string $password): self
  475.     {
  476.         $this->password = $password;
  478.         return $this;
  479.     }
  481.     /**
  482.      * @see UserInterface
  483.      */
  484.     public function getSalt()
  485.     {
  486.         // not needed when using the "bcrypt" algorithm in security.yaml
  487.     }
  489.     /**
  490.      * @see UserInterface
  491.      */
  492.     public function eraseCredentials()
  493.     {
  494.         // If you store any temporary, sensitive data on the tvUser, clear it here
  495.         $this->plainPassword = null;
  496.     }
  498.     public function getEmail(): ?string
  499.     {
  500.         return $this->email;
  501.     }
  503.     public function setEmail(?string $email): self
  504.     {
  505.         $this->email = $email;
  507.         return $this;
  508.     }
  510.     public function getQuotas(): ?int
  511.     {
  512.         return $this->quotas;
  513.     }
  515.     public function setQuotas(int $quotas): self
  516.     {
  517.         $this->quotas = $quotas;
  519.         return $this;
  520.     }
  522.     public function getQuotasType(): ?string
  523.     {
  524.         return $this->quotasType;
  525.     }
  527.     public function setQuotasType(string $quotasType): self
  528.     {
  529.         $this->quotasType = $quotasType;
  531.         return $this;
  532.     }
  534.     public function getActive(): ?bool
  535.     {
  536.         return $this->active;
  537.     }
  539.     public function setActive(bool $active): self
  540.     {
  541.         $this->active = $active;
  542.         if ($this->active){
  543.             $this->status = self::STATUS_ACTIVE;
  544.         }else{
  545.             $this->status = self::STATUS_SUSPENDED;
  546.         }
  547.         return $this;
  548.     }
  550.     public function getCreatedAt(): ?\DateTimeInterface
  551.     {
  552.         return $this->createdAt;
  553.     }
  555.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  556.     {
  557.         $this->createdAt = $createdAt;
  559.         return $this;
  560.     }
  562.     public function getUpdatedAt(): ?\DateTimeInterface
  563.     {
  564.         return $this->updatedAt;
  565.     }
  567.     public function setUpdatedAt(\DateTimeInterface $updatedAt): self
  568.     {
  569.         $this->updatedAt = $updatedAt;
  571.         return $this;
  572.     }
  574.     public function getRecoveryToken(): ?string
  575.     {
  576.         return $this->recoveryToken;
  577.     }
  579.     public function setRecoveryToken(?string $recoveryToken): self
  580.     {
  581.         $this->recoveryToken = $recoveryToken;
  583.         return $this;
  584.     }
  586.     public function getTvCompany(): ?TvCompany
  587.     {
  588.         return $this->tvCompany;
  589.     }
  591.     public function setTvCompany(?TvCompany $tvCompany): self
  592.     {
  593.         $this->tvCompany = $tvCompany;
  595.         return $this;
  596.     }
  598.     /**
  599.      * @ORM\PrePersist
  600.      * @ORM\PreUpdate
  601.      */
  602.     public function updatedTimestamps(): void
  603.     {
  604.         $this->setUpdatedAt(new \DateTime('now'));
  605.         if ($this->getCreatedAt() === null) {
  606.             $this->setCreatedAt(new \DateTime('now'));
  607.         }
  608.     }
  610.     /**
  611.      * @return Collection|Log[]
  612.      */
  613.     public function getLogs(): Collection
  614.     {
  615.         return $this->logs;
  616.     }
  618.     public function addLog(Log $log): self
  619.     {
  620.         if (!$this->logs->contains($log)) {
  621.             $this->logs[] = $log;
  622.             $log->setTvUser($this);
  623.         }
  625.         return $this;
  626.     }
  628.     public function removeLog(Log $log): self
  629.     {
  630.         if ($this->logs->removeElement($log)) {
  631.             // set the owning side to null (unless already changed)
  632.             if ($log->getTvUser() === $this) {
  633.                 $log->setTvUser(null);
  634.             }
  635.         }
  637.         return $this;
  638.     }
  640.     /**
  641.      * @return Collection|Message[]
  642.      */
  643.     public function getMessages(): Collection
  644.     {
  645.         return $this->messages;
  646.     }
  648.     public function addMessage(Message $message): self
  649.     {
  650.         if (!$this->messages->contains($message)) {
  651.             $this->messages[] = $message;
  652.             $message->setTvUser($this);
  653.         }
  655.         return $this;
  656.     }
  658.     public function removeMessage(Message $message): self
  659.     {
  660.         if ($this->messages->removeElement($message)) {
  661.             // set the owning side to null (unless already changed)
  662.             if ($message->getTvUser() === $this) {
  663.                 $message->setTvUser(null);
  664.             }
  665.         }
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return \DateTime|null
  672.      */
  673.     public function getLastLogin(): ?\DateTime
  674.     {
  675.         return $this->lastLogin;
  676.     }
  678.     /**
  679.      * @param string|null $code
  680.      * @return TvUser
  681.      */
  682.     public function setCode(?string $code): TvUser
  683.     {
  684.         $this->code = $code;
  685.         return $this;
  686.     }
  688.     /**
  689.      * @return string|null
  690.      */
  691.     public function getCode(): ?string
  692.     {
  693.         return $this->code;
  694.     }
  696.     /**
  697.      * @param string $role
  698.      * @return bool
  699.      */
  700.     public function hasRole(string $role)
  701.     {
  702.         return in_array($role, $this->roles);
  703.     }
  705.     /**
  706.      * Updates the tvCompany according to the status of the order
  707.      * @return TvUser
  708.      * @ORM\PrePersist
  709.      */
  710.     public function updateTvCompany(): self
  711.     {
  712.         if ($this->tvCompany instanceof TvCompany) {
  713.             $this->tvCompany->setTvUsersCount($this->tvCompany->getTvUsersCount() + 1);
  714.         }
  715.         return $this;
  716.     }
  718.     public function setLastLogin(?\DateTimeInterface $lastLogin): self
  719.     {
  720.         $this->lastLogin = $lastLogin;
  722.         return $this;
  723.     }
  725.     /**
  726.      * If persisted this password will be encoded into the password field
  727.      * @param string $password
  728.      * @return $this
  729.      */
  730.     public function setPlainPassword(string $password): TvUser
  731.     {
  732.         $this->plainPassword = $password;
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return string
  738.      */
  739.     public function getPlainPassword(): ?string
  740.     {
  741.         return $this->plainPassword;
  742.     }
  744.     /**
  745.      * @return Collection|VideoEvent[]
  746.      */
  747.     public function getVideoEvents(): Collection
  748.     {
  749.         return $this->videoEvents;
  750.     }
  752.     public function addVideoEvent(VideoEvent $videoEvent): self
  753.     {
  754.         if (!$this->videoEvents->contains($videoEvent)) {
  755.             $this->videoEvents[] = $videoEvent;
  756.             $videoEvent->setTvUser($this);
  757.         }
  759.         return $this;
  760.     }
  762.     public function removeVideoEvent(VideoEvent $videoEvent): self
  763.     {
  764.         if ($this->videoEvents->removeElement($videoEvent)) {
  765.             // set the owning side to null (unless already changed)
  766.             if ($videoEvent->getTvUser() === $this) {
  767.                 $videoEvent->setTvUser(null);
  768.             }
  769.         }
  771.         return $this;
  772.     }
  774.     /**
  775.      * Checks the quotas of a tvUser
  776.      * @return bool true if ok, false if not ok
  777.      */
  778.     public function checkQuotas(): bool
  779.     {
  780.         $result = true;
  781.         if ($this->getQuotasType() != self::QUOTA_NONE){
  782.             $span = self::QUOTAS_VAlUES[$this->getQuotasType()];
  783.             $limit = new \DateTime("-$span");
  784.             $count = 0;
  785.             foreach ($this->getVideoEvents() as $videoEvent) {
  786.                 if ($limit->diff($videoEvent->getCreatedAt())->invert == 0){
  787.                     $count += $videoEvent->getValue();
  788.                 }
  789.             }
  790.             if ($count > $this->getQuotas()){
  791.                 $result = false;
  792.             }
  793.         }
  794.         return $result;
  795.     }
  797.     public function getNewsletter(): ?bool
  798.     {
  799.         return $this->newsletter;
  800.     }
  802.     public function setNewsletter(bool $newsletter): self
  803.     {
  804.         $this->newsletter = $newsletter;
  806.         return $this;
  807.     }
  809.     public function getNewsletterDate(): ?\DateTimeInterface
  810.     {
  811.         return $this->newsletterDate;
  812.     }
  814.     public function setNewsletterDate(?\DateTimeInterface $newsletterDate): self
  815.     {
  816.         $this->newsletterDate = $newsletterDate;
  818.         return $this;
  819.     }
  821.     /**
  822.      * @return Collection|UserResponse[]
  823.      */
  824.     public function getUserResponses(): Collection
  825.     {
  826.         return $this->userResponses;
  827.     }
  829.     public function addUserResponse(UserResponse $userResponse): self
  830.     {
  831.         if (!$this->userResponses->contains($userResponse)) {
  832.             $this->userResponses[] = $userResponse;
  833.             $userResponse->setTvUser($this);
  834.         }
  836.         return $this;
  837.     }
  839.     public function removeUserResponse(UserResponse $userResponse): self
  840.     {
  841.         if ($this->userResponses->removeElement($userResponse)) {
  842.             // set the owning side to null (unless already changed)
  843.             if ($userResponse->getTvUser() === $this) {
  844.                 $userResponse->setTvUser(null);
  845.             }
  846.         }
  848.         return $this;
  849.     }
  851.     public function getEmailUpdatedAt(): ?\DateTimeInterface
  852.     {
  853.         return $this->emailUpdatedAt;
  854.     }
  856.     public function setEmailUpdatedAt(?\DateTimeInterface $emailUpdatedAt): self
  857.     {
  858.         $this->emailUpdatedAt = $emailUpdatedAt;
  860.         return $this;
  861.     }
  863.     public function getEmailValidatedAt(): ?\DateTimeInterface
  864.     {
  865.         return $this->emailValidatedAt;
  866.     }
  868.     public function setEmailValidatedAt(?\DateTimeInterface $emailValidatedAt): self
  869.     {
  870.         $this->emailValidatedAt = $emailValidatedAt;
  872.         return $this;
  873.     }
  875.     /**
  876.      * Checks if the email is validated
  877.      * @return bool
  878.      */
  879.     public function isEmailValidated(): bool
  880.     {
  881.         return ($this->emailValidatedAt !== null);
  882.     }
  884.     /**
  885.      * @param bool $firstLogin
  886.      * @return TvUser
  887.      */
  888.     public function setFirstLogin(bool $firstLogin): TvUser
  889.     {
  890.         $this->firstLogin = $firstLogin;
  891.         return $this;
  892.     }
  894.     /**
  895.      * @return bool
  896.      */
  897.     public function isFirstLogin(): bool
  898.     {
  899.         return $this->firstLogin;
  900.     }
  902.     /**
  903.      * @param bool $homeSurvey
  904.      * @return TvUser
  905.      */
  906.     public function setHomeSurvey(bool $homeSurvey): TvUser
  907.     {
  908.         $this->homeSurvey = $homeSurvey;
  909.         return $this;
  910.     }
  912.     /**
  913.      * @return bool
  914.      */
  915.     public function isHomeSurvey(): bool
  916.     {
  917.         return $this->homeSurvey;
  918.     }
  920.     /**
  921.      * @return Collection|Favorite[]
  922.      */
  923.     public function getFavorites(): Collection
  924.     {
  925.         return $this->favorites;
  926.     }
  928.     public function addFavorite(Favorite $favorite): self
  929.     {
  930.         if (!$this->favorites->contains($favorite)) {
  931.             $this->favorites[] = $favorite;
  932.         }
  934.         return $this;
  935.     }
  937.     public function removeFavorite(Favorite $favorite): self
  938.     {
  939.         $this->favorites->removeElement($favorite);
  941.         return $this;
  942.     }
  944.     public function getStatus(): ?string
  945.     {
  946.         return $this->status;
  947.     }
  949.     public function setStatus(string $status): self
  950.     {
  951.         $this->status = $status;
  953.         return $this;
  954.     }
  956.     /**
  957.      * @return string|null
  958.      */
  959.     public function getPasswordConfirm(): ?string
  960.     {
  961.         return $this->passwordConfirm;
  962.     }
  964.     /**
  965.      * @param string|null $passwordConfirm
  966.      * @return TvUser
  967.      */
  968.     public function setPasswordConfirm(?string $passwordConfirm): TvUser
  969.     {
  970.         $this->passwordConfirm = $passwordConfirm;
  971.         return $this;
  972.     }
  974.     public function getDepartment(): ?Department
  975.     {
  976.         return $this->department;
  977.     }
  979.     public function setDepartment(?Department $department): self
  980.     {
  981.         $this->department = $department;
  983.         return $this;
  984.     }
  986.     /**
  987.      * @return Collection|LogEmail[]
  988.      */
  989.     public function getLogEmails(): Collection
  990.     {
  991.         return $this->logEmails;
  992.     }
  994.     public function addLogEmail(LogEmail $logEmail): self
  995.     {
  996.         if (!$this->logEmails->contains($logEmail)) {
  997.             $this->logEmails[] = $logEmail;
  998.             $logEmail->setTvUser($this);
  999.         }
  1001.         return $this;
  1002.     }
  1004.     public function removeLogEmail(LogEmail $logEmail): self
  1005.     {
  1006.         if ($this->logEmails->removeElement($logEmail)) {
  1007.             // set the owning side to null (unless already changed)
  1008.             if ($logEmail->getTvUser() === $this) {
  1009.                 $logEmail->setTvUser(null);
  1010.             }
  1011.         }
  1013.         return $this;
  1014.     }
  1016.     /**
  1017.      * @return Collection|Channel[]
  1018.      */
  1019.     public function getChannels(): Collection
  1020.     {
  1021.         return $this->channels;
  1022.     }
  1024.     public function addChannel(Channel $channel): self
  1025.     {
  1026.         if (!$this->channels->contains($channel)) {
  1027.             $this->channels[] = $channel;
  1028.             $channel->setTvUser($this);
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     public function removeChannel(Channel $channel): self
  1035.     {
  1036.         if ($this->channels->removeElement($channel)) {
  1037.             // set the owning side to null (unless already changed)
  1038.             if ($channel->getTvUser() === $this) {
  1039.                 $channel->setTvUser(null);
  1040.             }
  1041.         }
  1043.         return $this;
  1044.     }
  1045.     
  1046.     /**
  1047.      * @return Collection|Objective[]
  1048.      */
  1049.     public function getObjectives(): Collection
  1050.     {
  1051.         return $this->objectives;
  1052.     }
  1054.     /**
  1055.      * @return Collection|Objective[]
  1056.      * @Groups({"tv_user_write"})
  1057.      */
  1058.     public function setObjectives(Collection $objectives): self
  1059.     {
  1060.         $this->objectives = $objectives;
  1062.         return $this;
  1063.     }
  1065.     public function addObjective(Objective $objective): self
  1066.     {
  1067.         if (!$this->objectives->contains($objective)) {
  1068.             $this->objectives[] = $objective;
  1069.             $objective->addTvUser($this);
  1070.         }
  1072.         return $this;
  1073.     }
  1074.     
  1075.     public function removeObjective(Objective $objective): self
  1076.     {
  1077.         if ($this->objectives->removeElement($objective)) {
  1078.             $objective->removeTvUser($this);
  1079.         }
  1081.         return $this;
  1082.     }
  1084.     public function getAssociation(): ?Association
  1085.     {
  1086.         return $this->association;
  1087.     }
  1089.     public function setAssociation(?Association $association): self
  1090.     {
  1091.         $this->association = $association;
  1093.         return $this;
  1094.     }
  1096.     /**
  1097.      * @return Collection|TeamUser[]
  1098.      */
  1099.     public function getTeamUsers(): Collection
  1100.     {
  1101.         return $this->teamUsers;
  1102.     }
  1104.     public function addTeamUser(TeamUser $teamUser): self
  1105.     {
  1106.         if (!$this->teamUsers->contains($teamUser)) {
  1107.             $this->teamUsers[] = $teamUser;
  1108.             $teamUser->setTvUser($this);
  1109.         }
  1111.         return $this;
  1112.     }
  1114.     public function removeTeamUser(TeamUser $teamUser): self
  1115.     {
  1116.         if ($this->teamUsers->removeElement($teamUser)) {
  1117.             // set the owning side to null (unless already changed)
  1118.             if ($teamUser->getTvUser() === $this) {
  1119.                 $teamUser->setTvUser(null);
  1120.             }
  1121.         }
  1123.         return $this;
  1124.     }
  1126.     /**
  1127.      * Récupére un tableau de Team
  1128.      * @return Collection|Team[]|null
  1129.      */
  1130.     public function getTeams(): ?Collection
  1131.     {
  1132.         $teams = null;
  1134.         if(!$this->teamUsers->isEmpty()) {
  1135.             $teams = new ArrayCollection([]);
  1136.             foreach ($this->teamUsers->toArray() as $teamUser) {
  1137.                 if($teamUser->getTeam() instanceof Team) {
  1138.                     $teams->add($teamUser->getTeam());
  1139.                 }
  1140.             }
  1141.         }
  1143.         return $teams;
  1144.     }
  1146.     public function getDisplayTeamplayTuto(): ?bool
  1147.     {
  1148.         return $this->displayTeamplayTuto;
  1149.     }
  1151.     public function setDisplayTeamplayTuto(?bool $displayTeamplayTuto): self
  1152.     {
  1153.         $this->displayTeamplayTuto = $displayTeamplayTuto;
  1155.         return $this;
  1156.     }
  1158.     /**
  1159.      * @return Collection|TeamplayLog[]
  1160.      */
  1161.     public function getTeamplayLogs(): Collection
  1162.     {
  1163.         return $this->teamplayLogs;
  1164.     }
  1166.     public function addTeamplayLog(TeamplayLog $teamplayLog): self
  1167.     {
  1168.         if (!$this->teamplayLogs->contains($teamplayLog)) {
  1169.             $this->teamplayLogs[] = $teamplayLog;
  1170.             $teamplayLog->setTvUser($this);
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     public function removeTeamplayLog(TeamplayLog $teamplayLog): self
  1177.     {
  1178.         if ($this->teamplayLogs->removeElement($teamplayLog)) {
  1179.             // set the owning side to null (unless already changed)
  1180.             if ($teamplayLog->getTvUser() === $this) {
  1181.                 $teamplayLog->setTvUser(null);
  1182.             }
  1183.         }
  1185.         return $this;
  1186.     }
  1188.     /**
  1189.      * @return Collection|PedometerLog[]
  1190.      */
  1191.     public function getPedometerLogs(): Collection
  1192.     {
  1193.         return $this->pedometerLogs;
  1194.     }
  1196.     public function addPedometerLog(PedometerLog $pedometerLog): self
  1197.     {
  1198.         if (!$this->pedometerLogs->contains($pedometerLog)) {
  1199.             $this->pedometerLogs[] = $pedometerLog;
  1200.             $pedometerLog->setTvUser($this);
  1201.         }
  1203.         return $this;
  1204.     }
  1206.     public function removePedometerLog(PedometerLog $pedometerLog): self
  1207.     {
  1208.         if ($this->pedometerLogs->removeElement($pedometerLog)) {
  1209.             // set the owning side to null (unless already changed)
  1210.             if ($pedometerLog->getTvUser() === $this) {
  1211.                 $pedometerLog->setTvUser(null);
  1212.             }
  1213.         }
  1215.         return $this;
  1216.     }
  1218.     public function getDeviceOs(): ?string
  1219.     {
  1220.         return $this->deviceOs;
  1221.     }
  1223.     public function setDeviceOs(?string $deviceOs): self
  1224.     {
  1225.         $this->deviceOs = $deviceOs;
  1227.         return $this;
  1228.     }
  1230.     public function getDeviceToken(): ?string
  1231.     {
  1232.         return $this->deviceToken;
  1233.     }
  1235.     public function setDeviceToken(?string $deviceToken): self
  1236.     {
  1237.         $this->deviceToken = $deviceToken;
  1239.         return $this;
  1240.     }
  1242.     public function getDeviceName(): ?string
  1243.     {
  1244.         return $this->deviceName;
  1245.     }
  1247.     public function setDeviceName(?string $deviceName): self
  1248.     {
  1249.         $this->deviceName = $deviceName;
  1251.         return $this;
  1252.     }
  1254.     public function isDeviceActive(): ?bool
  1255.     {
  1256.         return $this->deviceActive;
  1257.     }
  1259.     public function setDeviceActive(?bool $deviceActive): self
  1260.     {
  1261.         $this->deviceActive = $deviceActive;
  1263.         return $this;
  1264.     }
  1266.     public function getDeviceUpdate(): ?\DateTimeInterface
  1267.     {
  1268.         return $this->deviceUpdate;
  1269.     }
  1271.     public function setDeviceUpdate(?\DateTimeInterface $deviceUpdate): self
  1272.     {
  1273.         $this->deviceUpdate = $deviceUpdate;
  1275.         return $this;
  1276.     }
  1278.     /**
  1279.      * @return Collection<int, UserNotification>
  1280.      */
  1281.     public function getUserNotifications(): Collection
  1282.     {
  1283.         return $this->userNotifications;
  1284.     }
  1286.     public function addUserNotification(UserNotification $userNotification): self
  1287.     {
  1288.         if (!$this->userNotifications->contains($userNotification)) {
  1289.             $this->userNotifications[] = $userNotification;
  1290.             $userNotification->setTvUser($this);
  1291.         }
  1293.         return $this;
  1294.     }
  1296.     public function removeUserNotification(UserNotification $userNotification): self
  1297.     {
  1298.         if ($this->userNotifications->removeElement($userNotification)) {
  1299.             // set the owning side to null (unless already changed)
  1300.             if ($userNotification->getTvUser() === $this) {
  1301.                 $userNotification->setTvUser(null);
  1302.             }
  1303.         }
  1305.         return $this;
  1306.     }
  1308.     /**
  1309.      * @return Collection<int, UserDevice>
  1310.      */
  1311.     public function getDevices(): Collection
  1312.     {
  1313.         return $this->devices;
  1314.     }
  1316.     public function addDevice(UserDevice $device): self
  1317.     {
  1318.         if (!$this->devices->contains($device)) {
  1319.             $this->devices[] = $device;
  1320.             $device->setTvUser($this);
  1321.         }
  1323.         return $this;
  1324.     }
  1326.     public function removeDevice(UserDevice $device): self
  1327.     {
  1328.         if ($this->devices->removeElement($device)) {
  1329.             // set the owning side to null (unless already changed)
  1330.             if ($device->getTvUser() === $this) {
  1331.                 $device->setTvUser(null);
  1332.             }
  1333.         }
  1335.         return $this;
  1336.     }
  1338.     /**
  1339.      * @return Collection|AwardLog[]
  1340.      */
  1341.     public function getAwardLogs(): Collection
  1342.     {
  1343.         return $this->awardLogs;
  1344.     }
  1346.     public function addAwardLog(AwardLog $awardLog): self
  1347.     {
  1348.         if (!$this->awardLogs->contains($awardLog)) {
  1349.             $this->awardLogs[] = $awardLog;
  1350.             $awardLog->setTvUser($this);
  1351.         }
  1353.         return $this;
  1354.     }
  1356.     public function removeAwardLog(AwardLog $awardLog): self
  1357.     {
  1358.         if ($this->awardLogs->removeElement($awardLog)) {
  1359.             // set the owning side to null (unless already changed)
  1360.             if ($awardLog->getTvUser() === $this) {
  1361.                 $awardLog->setTvUser(null);
  1362.             }
  1363.         }
  1365.         return $this;
  1366.     }
  1368.     /**
  1369.      * @return Collection|UserVideoTimecode[]
  1370.      */
  1371.     public function getUserVideoTimecodes(): Collection
  1372.     {
  1373.         return $this->userVideoTimecodes;
  1374.     }
  1376.     public function addUserVideoTimecode(UserVideoTimecode $userVideoTimecode): self
  1377.     {
  1378.         if (!$this->userVideoTimecodes->contains($userVideoTimecode)) {
  1379.             $this->userVideoTimecodes[] = $userVideoTimecode;
  1380.             $userVideoTimecode->setTvUser($this);
  1381.         }
  1383.         return $this;
  1384.     }
  1386.     public function removeUserVideoTimecode(UserVideoTimecode $userVideoTimecode): self
  1387.     {
  1388.         if ($this->userVideoTimecodes->removeElement($userVideoTimecode)) {
  1389.             // set the owning side to null (unless already changed)
  1390.             if ($userVideoTimecode->getTvUser() === $this) {
  1391.                 $userVideoTimecode->setTvUser(null);
  1392.             }
  1393.         }
  1395.         return $this;
  1396.     }
  1398.     /**
  1399.      * @return Collection|Notation[]
  1400.      */
  1401.     public function getNotations(): Collection
  1402.     {
  1403.         return $this->notations;
  1404.     }
  1406.     public function addNotation(Notation $notation): self
  1407.     {
  1408.         if (!$this->notations->contains($notation)) {
  1409.             $this->notations[] = $notation;
  1410.             $notation->setTvUser($this);
  1411.         }
  1413.         return $this;
  1414.     }
  1416.     public function removeNotation(Notation $notation): self
  1417.     {
  1418.         if ($this->notations->removeElement($notation)) {
  1419.             // set the owning side to null (unless already changed)
  1420.             if ($notation->getTvUser() === $this) {
  1421.                 $notation->setTvUser(null);
  1422.             }
  1423.         }
  1425.         return $this;
  1426.     }
  1427.     
  1428.     /**
  1429.      * @return Collection|VideoLastValidate[]
  1430.      */
  1431.     public function getVideoLastValidates(): Collection
  1432.     {
  1433.         return $this->videoLastValidates;
  1434.     }
  1436.     public function addVideoLastValidate(VideoLastValidate $videoLastValidate): self
  1437.     {
  1438.         if (!$this->videoLastValidates->contains($videoLastValidate)) {
  1439.             $this->videoLastValidates[] = $videoLastValidate;
  1440.             $videoLastValidate->setTvUser($this);
  1441.         }
  1443.         return $this;
  1444.     }
  1446.     public function removeVideoLastValidate(VideoLastValidate $videoLastValidate): self
  1447.     {
  1448.         if ($this->videoLastValidates->removeElement($videoLastValidate)) {
  1449.             // set the owning side to null (unless already changed)
  1450.             if ($videoLastValidate->getTvUser() === $this) {
  1451.                 $videoLastValidate->setTvUser(null);
  1452.             }
  1453.         }
  1455.         return $this;
  1456.     }
  1458.     /**
  1459.      * @return Collection|VideoLastSeen[]
  1460.      */
  1461.     public function getVideoLastSeens(): Collection
  1462.     {
  1463.         return $this->videoLastSeens;
  1464.     }
  1466.     public function addVideoLastSeen(VideoLastSeen $videoLastSeen): self
  1467.     {
  1468.         if (!$this->videoLastSeens->contains($videoLastSeen)) {
  1469.             $this->videoLastSeens[] = $videoLastSeen;
  1470.             $videoLastSeen->setTvUser($this);
  1471.         }
  1473.         return $this;
  1474.     }
  1476.     public function removeVideoLastSeen(VideoLastSeen $videoLastSeen): self
  1477.     {
  1478.         if ($this->videoLastSeens->removeElement($videoLastSeen)) {
  1479.             // set the owning side to null (unless already changed)
  1480.             if ($videoLastSeen->getTvUser() === $this) {
  1481.                 $videoLastSeen->setTvUser(null);
  1482.             }
  1483.         }
  1485.         return $this;
  1486.     }
  1488.     /**
  1489.      * @return Collection|MoodResponse[]
  1490.      */
  1491.     public function getMoodResponses(): Collection
  1492.     {
  1493.         return $this->moodResponses;
  1494.     }
  1496.     public function addMoodResponse(MoodResponse $moodResponse): self
  1497.     {
  1498.         if (!$this->moodResponses->contains($moodResponse)) {
  1499.             $this->moodResponses[] = $moodResponse;
  1500.             $moodResponse->setTvUser($this);
  1501.         }
  1503.         return $this;
  1504.     }
  1506.     public function removeMoodResponse(MoodResponse $moodResponse): self
  1507.     {
  1508.         if ($this->moodResponses->removeElement($moodResponse)) {
  1509.             // set the owning side to null (unless already changed)
  1510.             if ($moodResponse->getTvUser() === $this) {
  1511.                 $moodResponse->setTvUser(null);
  1512.             }
  1513.         }
  1515.         return $this;
  1516.     }
  1518.     /**
  1519.      * @return Collection|ProgramEvent[]
  1520.      */
  1521.     public function getProgramEvents(): Collection
  1522.     {
  1523.         return $this->programEvents;
  1524.     }
  1526.     public function addProgramEvent(ProgramEvent $programEvent): self
  1527.     {
  1528.         if (!$this->programEvents->contains($programEvent)) {
  1529.             $this->programEvents[] = $programEvent;
  1530.             $programEvent->setTvUser($this);
  1531.         }
  1533.         return $this;
  1534.     }
  1536.     public function removeProgramEvent(ProgramEvent $programEvent): self
  1537.     {
  1538.         if ($this->programEvents->removeElement($programEvent)) {
  1539.             // set the owning side to null (unless already changed)
  1540.             if ($programEvent->getTvUser() === $this) {
  1541.                 $programEvent->setTvUser(null);
  1542.             }
  1543.         }
  1545.         return $this;
  1546.     }
  1548.     /**
  1549.      * @return Collection|DayEvent[]
  1550.      */
  1551.     public function getDayEvents(): Collection
  1552.     {
  1553.         return $this->dayEvents;
  1554.     }
  1556.     public function addDayEvent(DayEvent $dayEvent): self
  1557.     {
  1558.         if (!$this->dayEvents->contains($dayEvent)) {
  1559.             $this->dayEvents[] = $dayEvent;
  1560.             $dayEvent->setTvUser($this);
  1561.         }
  1563.         return $this;
  1564.     }
  1566.     public function removeDayEvent(DayEvent $dayEvent): self
  1567.     {
  1568.         if ($this->dayEvents->removeElement($dayEvent)) {
  1569.             // set the owning side to null (unless already changed)
  1570.             if ($dayEvent->getTvUser() === $this) {
  1571.                 $dayEvent->setTvUser(null);
  1572.             }
  1573.         }
  1575.         return $this;
  1576.     }
  1578.     public function getUser(): ?User
  1579.     {
  1580.         return $this->user;
  1581.     }
  1583.     public function setUser(?User $user): self
  1584.     {
  1585.         $this->user = $user;
  1587.         return $this;
  1588.     }
  1589. }