src/Entity/User.php line 123

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiFilter;
  6. use ApiPlatform\Core\Annotation\ApiProperty;
  7. use ApiPlatform\Core\Annotation\ApiResource;
  8. use ApiPlatform\Core\Annotation\ApiSubresource;
  9. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\BooleanFilter;
  10. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\ExistsFilter;
  11. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  12. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  13. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\DateFilter;
  14. use ApiPlatform\Core\Serializer\Filter\GroupFilter;
  15. use ApiPlatform\Core\Serializer\Filter\PropertyFilter;
  16. use App\Annotation\SerializedNameGroups;
  17. use App\Repository\UserRepository;
  18. use App\Service\ToolsService;
  19. use Doctrine\Common\Collections\ArrayCollection;
  20. use Doctrine\Common\Collections\Collection;
  21. use Doctrine\ORM\Mapping as ORM;
  22. use Gedmo\Mapping\Annotation as Gedmo;
  23. use Hslavich\OneloginSamlBundle\Security\User\SamlUserInterface;
  24. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  25. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  26. use Symfony\Component\Security\Core\User\UserInterface;
  27. use Symfony\Component\Serializer\Annotation\Groups;
  28. use Symfony\Component\Security\Core\Validator\Constraints as SecurityAssert;
  29. use Symfony\Component\Validator\Constraints as Assert;
  30. use App\Entity\NotificationPreference;
  32. /**
  33.  * @ORM\Entity(repositoryClass=UserRepository::class)
  34.  * @ORM\Table(name="`user`")
  35.  * @ApiResource(
  36.  *     normalizationContext={"groups"={"user:read"}},
  37.  *     denormalizationContext={"groups"={"user:write"}},
  38.  *     subresourceOperations={
  39.  *          "users_favorites_get_subresource"={
  40.  *              "security"="is_granted('ROLE_ADMIN') or object == user"
  41.  *          }
  42.  *     },
  43.  *     itemOperations={
  44.  *         "get"={
  45.  *              "security"="is_granted('ROLE_USER')",
  46.  *              "security_message"="You are not allowed to access this ressource"
  47.  *          },
  48.  *         "patch"={
  49.  *              "security"="is_granted('ROLE_ADMIN') or is_granted('ROLE_COMPANY') or user == object"
  50.  *         },
  51.  *         "update_password"={
  52.  *              "method"="PATCH",
  53.  *              "input"="App\Dto\Security\PasswordUpdate",
  54.  *              "controller"="App\Controller\Api\UserController::updatePassword",
  55.  *              "path"="/users/{id}/update-pwd",
  56.  *              "security"="is_granted('ROLE_USER') and user.getId() === object.getId()",
  57.  *              "openapi_context"={
  58.  *                  "description" = "Updates pwd for the current user, it needs the current password, the new one and a confirmation of the new one",
  59.  *                  "summary" = "Updates pwd for the current user",
  60.  *              },
  61.  *         },
  62.  *     },
  63.  *     collectionOperations={
  64.  *          "get"={
  65.  *              "security"="is_granted('ROLE_USER')"
  66.  *          },
  67.  *          "tv_export"={
  68.  *              "security"="is_granted('ROLE_ADMIN')",
  69.  *              "method"="GET",
  70.  *              "controller"="App\Controller\Api\TvUserController::extractCsv",
  71.  *              "path"="/users/export",
  72.  *              "formats"={"csv"={"text/csv"}},
  73.  *              "pagination_enabled"=false,
  74.  *              "output"=Company::class,
  75.  *              "normalization_context"={"groups"={"user:read:export_csv"}}
  76.  *          },
  77.  *          "post"={
  78.  *              "security"="is_granted('ROLE_ADMIN')",
  79.  *              "normalization_context"={"groups"={"user:write:creation"}}
  80.  *          },
  81.  *          "api_users_import"={
  82.  *              "route_name"="api_users_import",
  83.  *              "description"="Import user",
  84.  *              "method"="post",
  85.  *              "openapi_context"={
  86.  *                  "description" = "This method imports a list of users from a csv",
  87.  *                  "summary" = "Imports several users",
  88.  *              },
  89.  *              "responses"={
  90.  *                  "200"={
  91.  *                      "description":"Users correctly created"
  92.  *                  }
  93.  *              },
  94.  *          }
  95.  *     }
  96.  * )
  97.  * @ApiFilter(OrderFilter::class, properties={"id", "username", "code", "active", "lastLogin", "status", "quotas"})
  98.  * @ApiFilter(SearchFilter::class, properties={"code": "partial", "status": "exact", "id": "partial", "username": "partial", "email": "partial"})
  99.  * @ApiFilter(BooleanFilter::class, properties={"active", "newsletter"})
  100.  * @ApiFilter(ExistsFilter::class, properties={"deviceToken"})
  101.  * @ApiFilter(DateFilter::class, properties={"lastLogin"})
  102.  * @ApiFilter(GroupFilter::class, 
  103.  *      arguments={
  104.  *          "parameterName": "groups", 
  105.  *          "overrideDefaultGroups": true, 
  106.  *          "whitelist": {"user:read:tuto_only", "user:read:form"}
  107.  *      }
  108.  * )
  109.  * @ApiFilter(PropertyFilter::class, 
  110.  *      arguments={
  111.  *          "parameterName"="fields", 
  112.  *          "overrideDefaultProperties"=true
  113.  *     }
  114.  * )
  115.  * @UniqueEntity(
  116.  *     fields={"email", "category"},
  117.  *     errorPath="email",
  118.  *     message="The email is already in use",
  119.  *     ignoreNull=false
  120.  * )
  121.  * @ORM\HasLifecycleCallbacks()
  122.  */
  123. class User implements UserInterface, PasswordAuthenticatedUserInterface, SamlUserInterface
  124. {
  125.     const QUOTA_DAY = 'daily';
  126.     const QUOTA_WEEK = 'weekly';
  127.     const QUOTA_MONTH = 'monthly';
  128.     const QUOTA_NONE = 'unset';
  129.     const STATUS_ACTIVE = 'active';
  130.     const STATUS_SUSPENDED = 'suspended';
  132.     const STATUSES = [
  133.         self::STATUS_ACTIVE,
  134.         self::STATUS_SUSPENDED,
  135.     ];
  137.     const QUOTAS = [
  138.         self::QUOTA_DAY,
  139.         self::QUOTA_WEEK,
  140.         self::QUOTA_MONTH,
  141.     ];
  143.     /**
  144.      * Associative array, keys are the quotas types (none excluded)
  145.      * values are the string to pass to a datetime object
  146.      */
  147.     const QUOTAS_VAlUES = [
  148.         self::QUOTA_DAY => '1 day',
  149.         self::QUOTA_WEEK => '1 week',
  150.         self::QUOTA_MONTH => '1 month',
  151.     ];
  153.     const GROUP_ADMIN = 'admin';
  154.     const GROUP_COMPANY = 'company';
  155.     const GROUP_CLIENT = 'client';
  156.     const GROUP_SPECIALIST = 'specialist';
  157.     const ROLE_USER = 'ROLE_USER';
  158.     const ROLE_CLIENT = 'ROLE_CLIENT';
  159.     const ROLE_COMPANY = 'ROLE_COMPANY';
  160.     const ROLE_EXTERNAL_COMPANY = 'ROLE_EXTERNAL_COMPANY';
  161.     const ROLE_ADMIN = 'ROLE_ADMIN';
  162.     const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
  163.     const ROLE_SPECIALIST = 'ROLE_SPECIALIST';
  165.     const ROLE_TV = 'ROLE_TV';
  166.     const ROLE_LIVE = 'ROLE_LIVE';
  168.     const GROUPS = [
  169.         self::GROUP_ADMIN,
  170.         self::GROUP_COMPANY,
  171.         self::GROUP_CLIENT,
  172.         self::GROUP_SPECIALIST,
  173.     ];
  175.     /**
  176.      * @ORM\Id
  177.      * @ORM\GeneratedValue
  178.      * @ORM\Column(type="integer")
  179.      * @Groups({
  180.      *      "user_favorite:read", "user:read:id", "user:read", "company:read", "user:read:export_csv", 
  181.      *      "team:read", "team_user:read", "user:read:form", "notification:read", "client:read",
  182.      *      "chat_message:read", "chat:read", "message:read"
  183.      * })
  184.      */
  185.     private $id;
  187.     /**
  188.      * @ORM\Column(type="string", length=180)
  189.      * @Assert\Email
  190.      * @Assert\NotBlank
  191.      * @Groups({
  192.      *      "user_favorite:read", "user:read:email", "user:read", "user:write:creation", "user:write", 
  193.      *      "team:read", "team_user:read", "user:read:form", "notification:read", "company:read", "company:write", 
  194.      *      "client:read", "client:write", "chat_message:read", "chat:read", "message:read"
  195.      * })
  196.      */
  197.     private $email;
  199.     /**
  200.      * @ORM\Column(type="json")
  201.      * @Groups({"user:read:roles", "user:read", "user_favorite:read", "client:read"})
  202.      */
  203.     private $roles = [];
  205.     /**
  206.      * @var string|null The hashed password
  207.      * @ORM\Column(type="string")
  208.      * @Assert\Length(min="8", max="255")
  209.      * @Assert\NotBlank
  210.      */
  211.     private $password = null;
  213.     /**
  214.      * @var string|null
  215.      * @Assert\NotBlank(
  216.      *      groups={"user:update:password"}
  217.      * )
  218.      * @SecurityAssert\UserPassword(
  219.      *      message="old_password.matching",
  220.      *      groups={"user:update:password"}
  221.      * )
  222.      */
  223.     private $oldPassword = null;
  225.     /**
  226.      * @var string|null
  227.      * @Groups({"user:write:creation", "user:write", "user:read:creation"})
  228.      * @Assert\Regex("/(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}/", 
  229.      *      message="password.pattern",
  230.      *      groups={"user:write:reset-password", "user:update:password"}
  231.      * )
  232.      * @Assert\NotBlank(
  233.      *      groups={"user:write:reset-password", "user:update:password"}
  234.      * )
  235.      * @Assert\Length(
  236.      *      min=6, 
  237.      *      max=4096,
  238.      *      minMessage="Your password should be at least {{ limit }} characters",
  239.      *      groups={"user:write:reset-password", "user:update:password"}
  240.      * )
  241.      * @SerializedNameGroups(name="Mot-de-passe", groups={"user:read:creation"})
  242.      */
  243.     private $plainPassword = null;
  245.     /**
  246.      * @var string|null
  247.      * @Groups({"user:write:creation", "user:write"})
  248.      * @Assert\IdenticalTo(propertyPath="plainPassword", 
  249.      *      message="password.matching",
  250.      *      groups={"user:write:reset-password", "user:update:password"}
  251.      * )
  252.      */
  253.     private $passwordConfirm = null;
  255.     /**
  256.      * @ORM\Column(type="datetime")
  257.      * @Gedmo\Timestampable(on="create")
  258.      * @Groups({"user:read:createdAt", "user:read"})
  259.      */
  260.     private $createdAt;
  262.     /**
  263.      * @ORM\Column(type="datetime", nullable=true)
  264.      * @Gedmo\Timestampable(on="update")
  265.      * @Groups({"user:read:updatedAt", "user:read"})
  266.      */
  267.     private $updatedAt;
  269.     /**
  270.      * @ORM\Column(type="datetime", nullable=true)
  271.      * @Groups({"user:read:lastLogin", "user:read", "user:write", "client:read"})
  272.      */
  273.     private $lastLogin;
  275.     /**
  276.      * @ORM\Column(type="string", length=255)
  277.      * @Assert\Length(max="255", min="0")
  278.      * @Groups({"user:read:name", "user:read", "user_favorite:read", "chat_message:read", "chat:read"})
  279.      * @var string
  280.      */
  281.     private $name = '';
  283.     /**
  284.      * @ORM\Column(type="string", length=50)
  285.      * @Assert\Choice(choices=self::GROUPS)
  286.      * @Groups({"user:read:category", "user:read", "user_favorite:read"})
  287.      */
  288.     private $category;
  290.     /**
  291.      * @ORM\Column(type="boolean", options={"default": "1"})
  292.      * @Groups({"user_favorite:read", "user:read:active", "user:read", "company:read", "user:read:export_csv", "notification:read", "chat_message:read", "chat:read", "client:read"})
  293.      */
  294.     private $active = true;
  296.     /**
  297.      * @ORM\Column(type="datetime", nullable=true)
  298.      */
  299.     private $banStart;
  301.     /**
  302.      * @ORM\Column(type="datetime", nullable=true)
  303.      */
  304.     private $banEnd;
  306.     /**
  307.      * @ORM\Column(type="string", length=255, nullable=true, unique=true)
  308.      */
  309.     private $resetToken;
  311.     /**
  312.      * @ORM\OneToOne(targetEntity=Specialist::class, mappedBy="user", cascade={"persist", "remove"})
  313.      */
  314.     private $specialist;
  316.     /**
  317.      * @ORM\OneToOne(targetEntity=Company::class, mappedBy="user", cascade={"persist", "remove"})
  318.      * @ApiProperty(security="is_granted('ROLE_ADMIN') or is_granted('ROLE_COMPANY')")
  319.      * @Groups({"user:read:company", "user:read", "message:read"})
  320.      */
  321.     private $company;
  323.     /**
  324.      * @ORM\OneToOne(targetEntity=Client::class, mappedBy="user", cascade={"persist", "remove"})
  325.      * @Groups({"user:read:client", "user:read", "team_user:read", "chat_message:read", "chat:read", "message:read"})
  326.      */
  327.     private $client;
  329.     /**
  330.      * @var bool
  331.      */
  332.     private $_hashPwd = false;
  334.     /**
  335.      * @var null|string
  336.      */
  337.     private $token = null;
  339.     /**
  340.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="owner")
  341.      */
  342.     private $documents;
  344.     /**
  345.      * @ORM\OneToMany(targetEntity=MarketplaceReservation::class, mappedBy="user", cascade={"persist", "refresh", "remove"})
  346.      */
  347.     private $marketplaceReservations;
  349.     /**
  350.      * @ORM\Column(type="string", length=255, nullable=true)
  351.      * @Groups({"user:read:firstName", "user:read", "user_favorite:read", "company:read", "company:write", "team_user:read", "chat_message:read", "chat:read"})
  352.      */
  353.     private $firstName;
  355.     /**
  356.      * @ORM\Column(type="string", length=255, nullable=true)
  357.      * @Groups({"user:read:lastName", "user:read", "user_favorite:read", "company:read", "company:write", "team_user:read", "chat_message:read", "chat:read"})
  358.      */
  359.     private $lastName;
  361.     /**
  362.      * @ORM\OneToMany(targetEntity=UserFavorite::class, mappedBy="user", cascade={"persist", "refresh", "remove"})
  363.      * @Groups({"user:read:favorites"})
  364.      * @ApiSubresource(maxDepth=1)
  365.      */
  366.     private $favorites;
  368.     /**
  369.      * @ORM\ManyToOne(targetEntity=Segmentation::class, inversedBy="users", cascade={"persist"})
  370.      * @Groups({"user:read:segmentation", "user:read", "user:write", "chat_message:read", "chat:read"})
  371.      */
  372.     private $segmentation;
  374.     /**
  375.      * @ORM\Column(type="string", length=255, nullable=true, options={"default": "FR"})
  376.      * @Groups({"user:read:country"})
  377.      */
  378.     private $country;
  380.     /**
  381.      * @ORM\Column(name="`function`", type="string", length=255, nullable=true)
  382.      * @Groups({"user:read:function", "user:read", "user:write", "company:read", "company:write", "export_csv", "manager_dashboard"})
  383.      */
  384.     private $function;
  386.     /**
  387.      * @ORM\Column(type="string", length=255, nullable=true)
  388.      * @Groups({"user:read:phone", "user:read", "user:write", "company:read", "company:write", "export_csv", "manager_dashboard"})
  389.      * @Assert\Length(min=8, max=20, minMessage="phone.min", maxMessage="phone.max")
  390.      */
  391.     private $phone;
  393.     /**
  394.      * @ORM\Column(type="string", length=255, nullable=true)
  395.      * @Groups({"user:read:username", "user:read", "user:write:creation", "user:write", "team:read", "team_user:read", "user:read:form", "notification:read", "chat_message:read", "chat:read"})
  396.      */
  397.     private $username;
  399.     /**
  400.      * @ORM\Column(type="integer", options={"default": "-1"})
  401.      * @Groups({"user:read:quotas", "user:read", "user:write", "user:read:export_csv"})
  402.      */
  403.     private $quotas = -1;
  405.     /**
  406.      * @ORM\Column(type="string", length=255, options={"default": "unset"})
  407.      * @Groups({"user:read:quotasType", "user:read", "user:write", "user:read:export_csv"})
  408.      */
  409.     private $quotasType = self::QUOTA_NONE;
  411.     /**
  412.      * @ORM\Column(type="datetime", nullable=true)
  413.      * @Gedmo\Timestampable(on="change", field="email")
  414.      */
  415.     private $emailUpdatedAt;
  417.     /**
  418.      * @ORM\Column(type="datetime", nullable=true)
  419.      */
  420.     private $emailValidatedAt;
  422.     /**
  423.      * @ORM\Column(type="string", length=255, nullable=true)
  424.      * @Groups({"user:read:status", "user:read", "company:read", "user:read:export_csv", "client:read"})
  425.      * @Assert\Choice(choices=self::STATUSES)
  426.      */
  427.     private $status = self::STATUS_ACTIVE;
  429.     /**
  430.      * @ORM\Column(type="string", length=255, nullable=true)
  431.      * @Groups({"user:read:deviceOs", "user:read", "user:write"})
  432.      */
  433.     private $deviceOs;
  435.     /**
  436.      * @ORM\Column(type="text", nullable=true)
  437.      * @Groups({"user:read:deviceToken", "user:read", "user:write"})
  438.      */
  439.     private $deviceToken;
  441.     /**
  442.      * @ORM\Column(type="string", length=255, nullable=true)
  443.      * @Groups({"user:read:deviceName", "user:read", "user:write"})
  444.      */
  445.     private $deviceName;
  447.     /**
  448.      * @ORM\Column(type="boolean", nullable=true, options={"default": 1})
  449.      * @Groups({"user:read:deviceActive", "user:read", "user:write"})
  450.      */
  451.     private $deviceActive = true;
  453.     /**
  454.      * @ORM\Column(type="datetime", nullable=true)
  455.      * @Gedmo\Timestampable(on="change", field={"deviceOs", "deviceToken", "deviceName", "deviceActive"})
  456.      * @Groups({"user:read:deviceUpdate", "user:read", "user:write"})
  457.      */
  458.     private $deviceUpdate;
  460.     /**
  461.      * @ORM\OneToMany(targetEntity=UserDevice::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  462.      */
  463.     private $devices;
  465.     /**
  466.      * @ORM\Column(type="boolean", options={"default": "0"})
  467.      * @Groups({"user:read:newsletter", "user:read", "company:read", "user:write", "client:read", "client:write"})
  468.      */
  469.     private $newsletter = false;
  471.     /**
  472.      * @ORM\Column(type="datetime", nullable=true)
  473.      * @Groups({"user:read:newsletterDate", "user:read", "company:read"})
  474.      * @Gedmo\Timestampable(on="change", field="newsletter", value=true)
  475.      */
  476.     private $newsletterDate;
  478.     /**
  479.      * @ORM\Column(type="boolean", options={"default": "1"})
  480.      * @Groups({"user:read:firstLogin", "user:read", "company:read", "user:write", "client:read", "client:write"})
  481.      */
  482.     private $firstLogin = true;
  484.     /**
  485.      * @ORM\Column(type="boolean", options={"default": "1"})
  486.      * @Groups({"user:read:homeSurvey", "user:read", "company:read", "user:write", "client:read", "client:write"})
  487.      */
  488.     private $homeSurvey = true;
  490.     /**
  491.      * @ORM\Column(type="boolean", nullable=true, options={"default": "1"})
  492.      * @Groups({"user:read:displayTeamplayTuto", "user:read", "user:write", "user:read:tuto_only", "client:read", "client:write"})
  493.      */
  494.     private $displayTeamplayTuto = true;
  496.     /**
  497.      * @ORM\OneToMany(targetEntity=Log::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  498.      */
  499.     private $logs;
  501.     /**
  502.      * Sent messages by the user to web admins
  503.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  504.      */
  505.     private $messages;
  507.     /**
  508.      * @ORM\OneToMany(targetEntity=VideoEvent::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  509.      */
  510.     private $videoEvents;
  512.     /**
  513.      * @ORM\OneToMany(targetEntity=UserResponse::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  514.      */
  515.     private $userResponses;
  517.     /**
  518.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  519.      * @Groups({"user:read:tvFavorites"})
  520.      * @ApiSubresource(maxDepth=1)
  521.      */
  522.     private $tvFavorites;
  524.     /**
  525.      * @ORM\OneToMany(targetEntity=LogEmail::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  526.      */
  527.     private $logEmails;
  529.     /**
  530.      * @ORM\OneToMany(targetEntity=Playlist::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  531.      */
  532.     private $playlists;
  534.     /**
  535.      * @ORM\ManyToMany(targetEntity=Objective::class, mappedBy="users")
  536.      * @Groups({"user:read", "user:write"})
  537.      */
  538.     private $objectives;
  540.     /**
  541.      * @ORM\OneToMany(targetEntity=TeamUser::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  542.      */
  543.     private $teamUsers;
  545.     /**
  546.      * @ORM\OneToMany(targetEntity=TeamplayLog::class, mappedBy="user", orphanRemoval=true, cascade={"refresh", "remove"})
  547.      */
  548.     private $teamplayLogs;
  550.     /**
  551.      * @ORM\OneToMany(targetEntity=PedometerLog::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  552.      */
  553.     private $pedometerLogs;
  555.     /**
  556.      * @ORM\OneToMany(targetEntity=UserNotification::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  557.      */
  558.     private $userNotifications;
  560.     /**
  561.      * @ORM\OneToMany(targetEntity=AwardLog::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  562.      */
  563.     private $awardLogs;
  565.     /**
  566.      * @ORM\OneToMany(targetEntity=UserVideoTimecode::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  567.      */
  568.     private $userVideoTimecodes;
  570.     /**
  571.      * @ORM\OneToMany(targetEntity=Notation::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  572.      */
  573.     private $notations;
  575.     /**
  576.      * @ORM\OneToMany(targetEntity=VideoLastValidate::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  577.      */
  578.     private $videoLastValidates;
  580.     /**
  581.      * @ORM\OneToMany(targetEntity=VideoLastSeen::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  582.      */
  583.     private $videoLastSeens;
  585.     /**
  586.      * @ORM\OneToMany(targetEntity=MoodResponse::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  587.      */
  588.     private $moodResponses;
  590.     /**
  591.      * @ORM\OneToMany(targetEntity=ProgramEvent::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  592.      */
  593.     private $programEvents;
  595.     /**
  596.      * @ORM\OneToMany(targetEntity=DayEvent::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  597.      */
  598.     private $dayEvents;
  600.     /**
  601.      * @ORM\OneToOne(targetEntity=TvUser::class, mappedBy="user", cascade={"persist", "refresh","remove"})
  602.      */
  603.     private $tvUser;
  605.     /**
  606.      * @ORM\Column(type="boolean", options={"default": "1"})
  607.      * @Groups({"user:read:live", "user:read", "user:write",  "user_favorite:read", "client:read"})
  608.      */
  609.     private $live = true;
  611.     /**
  612.      * @ORM\Column(type="boolean", options={"default": "1"})
  613.      * @Groups({"user:read:tv", "user:read", "user:write",  "user_favorite:read", "client:read"})
  614.      */
  615.     private $tv = true;
  617.     /**
  618.      *  
  619.      * @ORM\ManyToMany(targetEntity=Chat::class, inversedBy="users")
  620.      */
  621.     private $chats;
  623.     /**
  624.      * @var bool
  625.      */
  626.     public $isPopulated = false;
  628.     /**
  629.      * @ORM\OneToMany(targetEntity=Invoice::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true) 
  630.      */
  631.     private $invoices;
  633.     /**
  634.      * @ORM\OneToOne(targetEntity=NotificationPreference::class, mappedBy="user", cascade={"persist","remove"})
  635.      */
  636.     private $notificationPreference = null;
  639.     public function __construct()
  640.     {
  641.         $this->roles[] = self::ROLE_USER;
  642.         $this->documents = new ArrayCollection();
  643.         $this->marketplaceReservations = new ArrayCollection();
  644.         $this->favorites = new ArrayCollection();
  645.         $this->devices = new ArrayCollection();
  646.         $this->logs = new ArrayCollection();
  647.         $this->messages = new ArrayCollection();
  648.         $this->videoEvents = new ArrayCollection();
  649.         $this->userResponses = new ArrayCollection();
  650.         $this->tvFavorites = new ArrayCollection();
  651.         $this->logEmails = new ArrayCollection();
  652.         $this->playlists = new ArrayCollection();
  653.         $this->objectives = new ArrayCollection();
  654.         $this->teamUsers = new ArrayCollection();
  655.         $this->teamplayLogs = new ArrayCollection();
  656.         $this->pedometerLogs = new ArrayCollection();
  657.         $this->userNotifications = new ArrayCollection();
  658.         $this->awardLogs = new ArrayCollection();
  659.         $this->userVideoTimecodes = new ArrayCollection();
  660.         $this->notations = new ArrayCollection();
  661.         $this->videoLastValidates = new ArrayCollection();
  662.         $this->videoLastSeens = new ArrayCollection();
  663.         $this->moodResponses = new ArrayCollection();
  664.         $this->programEvents = new ArrayCollection();
  665.         $this->dayEvents = new ArrayCollection();
  666.         $this->chats = new ArrayCollection();
  667.         $this->invoices = new ArrayCollection();
  668.     }
  670.     public function getId(): ?int
  671.     {
  672.         return $this->id;
  673.     }
  675.     public function getEmail(): ?string
  676.     {
  677.         return $this->email;
  678.     }
  680.     public function setEmail(string $email): self
  681.     {
  682.         $this->email = $email;
  684.         return $this;
  685.     }
  687.     /**
  688.      * A visual identifier that represents this user.
  689.      *
  690.      * @see UserInterface
  691.      */
  692.     public function getUserIdentifier(): string
  693.     {
  694.         return (string)$this->email;
  695.     }
  697.     public function getUsername(): ?string
  698.     {
  699.         return $this->username;
  700.     }
  702.     public function setUsername(?string $username): self
  703.     {
  704.         $this->username = $username;
  706.         return $this;
  707.     }
  709.     /**
  710.      * @see UserInterface
  711.      */
  712.     public function getRoles(): array
  713.     {
  714.         $roles = $this->roles;
  715.         // guarantee every user at least has ROLE_USER
  716.         $roles[] = self::ROLE_USER;
  718.         if ($this->isTv()) {
  719.             $roles[] = self::ROLE_TV;
  720.         }
  722.         if ($this->isLive()) {
  723.             $roles[] = self::ROLE_LIVE;
  724.         }
  726.         return array_unique($roles);
  727.     }
  729.     /**
  730.      * @param string $role
  731.      * @return bool
  732.      */
  733.     public function hasRole(string $role): bool
  734.     {
  735.         return in_array($role, $this->roles);
  736.     }
  738.     /**
  739.      * @see UserInterface
  740.      */
  741.     public function addRole(string $role): self
  742.     {
  743.         if (!in_array($role, $this->roles)) {
  744.             $this->roles[] = $role;
  745.         }
  746.         return $this;
  747.     }
  749.     /**
  750.      * @see UserInterface
  751.      */
  752.     public function removeRole(string $role): self
  753.     {
  754.         if (in_array($role, $this->roles)) {
  755.             foreach ($this->roles as $key => $item) {
  756.                 if ($item === $role) {
  757.                     unset($this->roles[$key]);
  758.                 }
  759.             }
  760.             $this->roles = array_values($this->roles);
  761.         }
  762.         return $this;
  763.     }
  765.     public function setRoles(array $roles): self
  766.     {
  767.         $this->roles = $roles;
  769.         return $this;
  770.     }
  772.     /**
  773.      * @see PasswordAuthenticatedUserInterface
  774.      */
  775.     public function getPassword(): ?string
  776.     {
  777.         return $this->password;
  778.     }
  780.     /**
  781.      * This setter also checks if the password has changed it will rehash it
  782.      * @param string|null $password New password
  783.      * @param bool $hash Forces rehash of password
  784.      * @return $this
  785.      */
  786.     public function setPassword(?string $password, bool $hash = false): self
  787.     {
  788.         if (!empty($password) && ($this->password !== $password || $hash)) {
  789.             $this->_hashPwd = true;
  790.         }
  791.         if (!empty($password)) {
  792.             $this->password = $password;
  793.         }
  794.         return $this;
  795.     }
  797.     /**
  798.      * If persisted this password will be encoded into the password field
  799.      * @param ?string $oldPassword
  800.      * @return User
  801.      */
  802.     public function setOldPassword(?string $oldPassword): User
  803.     {
  804.         $this->oldPassword = $oldPassword;
  805.         return $this;
  806.     }
  808.     /**
  809.      * @return string
  810.      */
  811.     public function getOldPassword(): ?string
  812.     {
  813.         return $this->oldPassword;
  814.     }
  816.     /**
  817.      * If persisted this password will be encoded into the password field
  818.      * @param string $password
  819.      * @return User
  820.      */
  821.     public function setPlainPassword(string $password): User
  822.     {
  823.         $this->plainPassword = $password;
  824.         return $this;
  825.     }
  827.     /**
  828.      * @return string
  829.      */
  830.     public function getPlainPassword(): ?string
  831.     {
  832.         return $this->plainPassword;
  833.     }
  835.     /**
  836.      * @return string|null
  837.      */
  838.     public function getPasswordConfirm(): ?string
  839.     {
  840.         return $this->passwordConfirm;
  841.     }
  843.     /**
  844.      * @param string|null $passwordConfirm
  845.      * @return User
  846.      */
  847.     public function setPasswordConfirm(?string $passwordConfirm): User
  848.     {
  849.         $this->passwordConfirm = $passwordConfirm;
  850.         return $this;
  851.     }
  853.     /**
  854.      * Returning a salt is only needed, if you are not using a modern
  855.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  856.      *
  857.      * @see UserInterface
  858.      */
  859.     public function getSalt(): ?string
  860.     {
  861.         return null;
  862.     }
  864.     /**
  865.      * @see UserInterface
  866.      */
  867.     public function eraseCredentials()
  868.     {
  869.         // If you store any temporary, sensitive data on the user, clear it here
  870.         $this->plainPassword = null;
  871.     }
  873.     public function getCreatedAt(): ?\DateTime
  874.     {
  875.         return $this->createdAt;
  876.     }
  878.     public function setCreatedAt(\DateTime $createdAt): self
  879.     {
  880.         $this->createdAt = $createdAt;
  882.         return $this;
  883.     }
  885.     public function getUpdatedAt(): ?\DateTime
  886.     {
  887.         return $this->updatedAt;
  888.     }
  890.     public function setUpdatedAt(\DateTime $updatedAt): self
  891.     {
  892.         $this->updatedAt = $updatedAt;
  894.         return $this;
  895.     }
  897.     public function getLastLogin(): ?\DateTimeInterface
  898.     {
  899.         return $this->lastLogin;
  900.     }
  902.     public function setLastLogin(?\DateTimeInterface $lastLogin): self
  903.     {
  904.         $this->lastLogin = $lastLogin;
  906.         return $this;
  907.     }
  909.     public function getName(): ?string
  910.     {
  911.         return $this->name;
  912.     }
  914.     public function setName(?string $name): self
  915.     {
  916.         $this->name = $name;
  918.         return $this;
  919.     }
  921.     public function getCategory(): ?string
  922.     {
  923.         return $this->category;
  924.     }
  926.     public function setCategory(string $category): self
  927.     {
  928.         $this->category = $category;
  930.         return $this;
  931.     }
  933.     public function getActive(): ?bool
  934.     {
  936.         return $this->active;
  937.     }
  939.     public function isActive(): ?bool
  940.     {
  941.         return $this->active;
  942.     }
  944.     public function setActive(bool $active): self
  945.     {
  946.         $this->active = $active;
  947.         if ($this->active) {
  948.             $this->status = self::STATUS_ACTIVE;
  949.         } else {
  950.             $this->status = self::STATUS_SUSPENDED;
  951.         }
  953.         return $this;
  954.     }
  956.     public function getBanStart(): ?\DateTimeInterface
  957.     {
  958.         return $this->banStart;
  959.     }
  961.     public function setBanStart(?\DateTimeInterface $banStart): self
  962.     {
  963.         $this->banStart = $banStart;
  965.         return $this;
  966.     }
  968.     public function getBanEnd(): ?\DateTimeInterface
  969.     {
  970.         return $this->banEnd;
  971.     }
  973.     public function setBanEnd(?\DateTimeInterface $banEnd): self
  974.     {
  975.         $this->banEnd = $banEnd;
  977.         return $this;
  978.     }
  980.     public function getResetToken(): ?string
  981.     {
  982.         return $this->resetToken;
  983.     }
  985.     public function setResetToken(?string $resetToken): self
  986.     {
  987.         $this->resetToken = $resetToken;
  989.         return $this;
  990.     }
  992.     public function getSpecialist(): ?Specialist
  993.     {
  994.         return $this->specialist;
  995.     }
  997.     public function setSpecialist(Specialist $specialist): self
  998.     {
  999.         // set the owning side of the relation if necessary
  1000.         if ($specialist->getUser() !== $this) {
  1001.             $specialist->setUser($this);
  1002.         }
  1004.         $this->specialist = $specialist;
  1006.         return $this;
  1007.     }
  1009.     public function getCompany(): ?Company
  1010.     {
  1011.         return $this->company;
  1012.     }
  1014.     public function setCompany(?Company $company): self
  1015.     {
  1016.         $this->company = $company;
  1018.         return $this;
  1019.     }
  1021.     public function getClient(): ?Client
  1022.     {
  1023.         return $this->client;
  1024.     }
  1026.     public function setClient(Client $client): self
  1027.     {
  1028.         // set the owning side of the relation if necessary
  1029.         if ($client->getUser() !== $this) {
  1030.             $client->setUser($this);
  1031.         }
  1033.         $this->client = $client;
  1035.         return $this;
  1036.     }
  1038.     /**
  1039.      * @return bool
  1040.      */
  1041.     public function isHashPwd(): bool
  1042.     {
  1043.         return $this->_hashPwd;
  1044.     }
  1046.     /**
  1047.      * @return string
  1048.      */
  1049.     public function __toString()
  1050.     {
  1051.         return $this->name;
  1052.     }
  1054.     /**
  1055.      * @ORM\PrePersist()
  1056.      */
  1057.     public function updateName()
  1058.     {
  1059.         if ($this->company instanceof Company) {
  1060.             $this->name = $this->company->getName();
  1061.         } elseif ($this->specialist instanceof Specialist) {
  1062.             $this->name = (string)$this->specialist;
  1063.         } elseif ($this->client instanceof Client) {
  1064.             $this->name = (string)$this->client;
  1065.         }
  1066.     }
  1068.     /**
  1069.      * @param string|null $token
  1070.      * @return User
  1071.      */
  1072.     public function setToken(?string $token): User
  1073.     {
  1074.         $this->token = $token;
  1075.         return $this;
  1076.     }
  1078.     /**
  1079.      * @return string|null
  1080.      */
  1081.     public function getToken(): ?string
  1082.     {
  1083.         return $this->token;
  1084.     }
  1086.     public function setSamlAttributes(array $attributes)
  1087.     {
  1088.         $this->token = $attributes['sessionIndex'];
  1090.         $data = [];
  1091.         foreach ($attributes as $key => $value) {
  1092.             $data[ToolsService::toCamelCase($key)] = $value;
  1093.         }
  1095.         if (!empty($data['email'])) {
  1096.             if (is_array($data['email'])) $this->email = $data['email'][0];
  1097.             elseif (is_string($data['email'])) $this->email = $data['email'];
  1098.         }
  1100.         if (!empty($data['firstName'])) {
  1101.             if (is_array($data['firstName'])) $this->firstName = $data['firstName'][0];
  1102.             elseif (is_string($data['firstName'])) $this->firstName = $data['firstName'];
  1103.         }
  1105.         if (!empty($data['lastName'])) {
  1106.             if (is_array($data['lastName'])) $this->lastName = $data['lastName'][0];
  1107.             elseif (is_string($data['lastName'])) $this->lastName = $data['lastName'];
  1108.         }
  1110.         if (!empty($data['country'])) {
  1111.             if (is_array($data['country'])) $this->country = $data['country'][0];
  1112.             elseif (is_string($data['country'])) $this->country = $data['country'];
  1113.         }
  1114.     }
  1116.     /**
  1117.      * @return Collection<int, Document>
  1118.      */
  1119.     public function getDocuments(): Collection
  1120.     {
  1121.         return $this->documents;
  1122.     }
  1124.     public function addDocument(Document $document): self
  1125.     {
  1126.         if (!$this->documents->contains($document)) {
  1127.             $this->documents[] = $document;
  1128.             $document->setOwner($this);
  1129.         }
  1131.         return $this;
  1132.     }
  1134.     public function removeDocument(Document $document): self
  1135.     {
  1136.         if ($this->documents->removeElement($document)) {
  1137.             // set the owning side to null (unless already changed)
  1138.             if ($document->getOwner() === $this) {
  1139.                 $document->setOwner(null);
  1140.             }
  1141.         }
  1143.         return $this;
  1144.     }
  1146.     /**
  1147.      * @return Collection<int, MarketplaceReservation>
  1148.      */
  1149.     public function getMarketplaceReservations(): Collection
  1150.     {
  1151.         return $this->marketplaceReservations;
  1152.     }
  1154.     public function addMarketplaceReservation(MarketplaceReservation $marketplaceReservation): self
  1155.     {
  1156.         if (!$this->marketplaceReservations->contains($marketplaceReservation)) {
  1157.             $this->marketplaceReservations[] = $marketplaceReservation;
  1158.             $marketplaceReservation->setUser($this);
  1159.         }
  1161.         return $this;
  1162.     }
  1164.     public function removeMarketplaceReservation(MarketplaceReservation $marketplaceReservation): self
  1165.     {
  1166.         if ($this->marketplaceReservations->removeElement($marketplaceReservation)) {
  1167.             // set the owning side to null (unless already changed)
  1168.             if ($marketplaceReservation->getUser() === $this) {
  1169.                 $marketplaceReservation->setUser(null);
  1170.             }
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     public function getFirstName(): ?string
  1177.     {
  1178.         return $this->firstName;
  1179.     }
  1181.     public function setFirstName(?string $firstName): self
  1182.     {
  1183.         $this->firstName = $firstName;
  1185.         $name = $this->firstName;
  1186.         if (!empty($this->lastName)) {
  1187.             $name .= " " . $this->lastName;
  1188.         }
  1189.         $this->setName($name);
  1191.         return $this;
  1192.     }
  1194.     public function getLastName(): ?string
  1195.     {
  1196.         return $this->lastName;
  1197.     }
  1199.     public function setLastName(?string $lastName): self
  1200.     {
  1201.         $this->lastName = $lastName;
  1203.         $name = $this->firstName;
  1204.         if (!empty($this->lastName)) {
  1205.             $name .= " " . $this->lastName;
  1206.         }
  1207.         $this->setName($name);
  1209.         return $this;
  1210.     }
  1212.     /**
  1213.      * @return Collection<int, UserFavorite>
  1214.      */
  1215.     public function getFavorites(): Collection
  1216.     {
  1217.         return $this->favorites;
  1218.     }
  1220.     public function addFavorite(UserFavorite $favorite): self
  1221.     {
  1222.         if (!$this->favorites->contains($favorite)) {
  1223.             $this->favorites[] = $favorite;
  1224.             $favorite->setUser($this);
  1225.         }
  1227.         return $this;
  1228.     }
  1230.     public function removeFavorite(UserFavorite $favorite): self
  1231.     {
  1232.         if ($this->favorites->removeElement($favorite)) {
  1233.             // set the owning side to null (unless already changed)
  1234.             if ($favorite->getUser() === $this) {
  1235.                 $favorite->setUser(null);
  1236.             }
  1237.         }
  1239.         return $this;
  1240.     }
  1242.     public function getSegmentation(): ?Segmentation
  1243.     {
  1244.         return $this->segmentation;
  1245.     }
  1247.     public function setSegmentation(?Segmentation $segmentation): self
  1248.     {
  1249.         $this->segmentation = $segmentation;
  1250.         if ($this->getClient()) {
  1251.             $this->getClient()->setSegmentation($segmentation);
  1252.         }
  1254.         return $this;
  1255.     }
  1257.     public function getCountry(): ?string
  1258.     {
  1259.         return $this->country;
  1260.     }
  1262.     public function setCountry(?string $country): self
  1263.     {
  1264.         $this->country = $country;
  1266.         return $this;
  1267.     }
  1269.     public function getFunction(): ?string
  1270.     {
  1271.         return $this->function;
  1272.     }
  1274.     public function setFunction(?string $function): self
  1275.     {
  1276.         $this->function = $function;
  1278.         return $this;
  1279.     }
  1281.     public function getPhone(): ?string
  1282.     {
  1283.         return $this->phone;
  1284.     }
  1286.     public function setPhone(?string $phone): self
  1287.     {
  1288.         $this->phone = $phone;
  1290.         return $this;
  1291.     }
  1293.     public function getQuotas(): ?int
  1294.     {
  1295.         return $this->quotas;
  1296.     }
  1298.     public function setQuotas(?int $quotas): self
  1299.     {
  1300.         $this->quotas = $quotas;
  1302.         return $this;
  1303.     }
  1305.     public function getQuotasType(): ?string
  1306.     {
  1307.         return $this->quotasType;
  1308.     }
  1310.     public function setQuotasType(?string $quotasType): self
  1311.     {
  1312.         $this->quotasType = $quotasType;
  1314.         return $this;
  1315.     }
  1317.     /**
  1318.      * Checks the quotas of a User
  1319.      * @return bool true if ok, false if not ok
  1320.      */
  1321.     public function checkQuotas(): bool
  1322.     {
  1323.         $result = true;
  1324.         if ($this->getQuotasType() != self::QUOTA_NONE) {
  1325.             $span = self::QUOTAS_VAlUES[$this->getQuotasType()];
  1326.             $limit = new \DateTime("-$span");
  1327.             $count = 0;
  1328.             foreach ($this->getVideoEvents() as $videoEvent) {
  1329.                 if ($limit->diff($videoEvent->getCreatedAt())->invert == 0) {
  1330.                     $count += $videoEvent->getValue();
  1331.                 }
  1332.             }
  1333.             if ($count > $this->getQuotas()) {
  1334.                 $result = false;
  1335.             }
  1336.         }
  1337.         return $result;
  1338.     }
  1340.     public function getEmailUpdatedAt(): ?\DateTimeInterface
  1341.     {
  1342.         return $this->emailUpdatedAt;
  1343.     }
  1345.     public function setEmailUpdatedAt(?\DateTimeInterface $emailUpdatedAt): self
  1346.     {
  1347.         $this->emailUpdatedAt = $emailUpdatedAt;
  1349.         return $this;
  1350.     }
  1352.     public function getEmailValidatedAt(): ?\DateTimeInterface
  1353.     {
  1354.         return $this->emailValidatedAt;
  1355.     }
  1357.     public function setEmailValidatedAt(?\DateTimeInterface $emailValidatedAt): self
  1358.     {
  1359.         $this->emailValidatedAt = $emailValidatedAt;
  1361.         return $this;
  1362.     }
  1364.     /**
  1365.      * Checks if the email is validated
  1366.      * @return bool
  1367.      */
  1368.     public function isEmailValidated(): bool
  1369.     {
  1370.         return ($this->emailValidatedAt !== null);
  1371.     }
  1373.     /**
  1374.      * Updates the Company according to the status of the order
  1375.      * @return User
  1376.      * @ORM\PrePersist
  1377.      */
  1378.     public function updateCompany(): self
  1379.     {
  1380.         if ($this->company instanceof Company) {
  1381.             $this->company->setClientsCount($this->company->getClientsCount() + 1);
  1382.         }
  1383.         return $this;
  1384.     }
  1386.     public function getStatus(): ?string
  1387.     {
  1388.         return $this->status;
  1389.     }
  1391.     public function setStatus(?string $status): self
  1392.     {
  1393.         $this->status = $status;
  1395.         return $this;
  1396.     }
  1398.     public function getDeviceOs(): ?string
  1399.     {
  1400.         return $this->deviceOs;
  1401.     }
  1403.     public function setDeviceOs(?string $deviceOs): self
  1404.     {
  1405.         $this->deviceOs = $deviceOs;
  1407.         return $this;
  1408.     }
  1410.     public function getDeviceToken(): ?string
  1411.     {
  1412.         return $this->deviceToken;
  1413.     }
  1415.     public function setDeviceToken(?string $deviceToken): self
  1416.     {
  1417.         $this->deviceToken = $deviceToken;
  1419.         return $this;
  1420.     }
  1422.     public function getDeviceName(): ?string
  1423.     {
  1424.         return $this->deviceName;
  1425.     }
  1427.     public function setDeviceName(?string $deviceName): self
  1428.     {
  1429.         $this->deviceName = $deviceName;
  1431.         return $this;
  1432.     }
  1434.     public function isDeviceActive(): ?bool
  1435.     {
  1436.         return $this->deviceActive;
  1437.     }
  1439.     public function setDeviceActive(?bool $deviceActive): self
  1440.     {
  1441.         $this->deviceActive = $deviceActive;
  1443.         return $this;
  1444.     }
  1446.     public function getDeviceUpdate(): ?\DateTimeInterface
  1447.     {
  1448.         return $this->deviceUpdate;
  1449.     }
  1451.     public function setDeviceUpdate(?\DateTimeInterface $deviceUpdate): self
  1452.     {
  1453.         $this->deviceUpdate = $deviceUpdate;
  1455.         return $this;
  1456.     }
  1458.     /**
  1459.      * @return Collection<int, UserDevice>
  1460.      */
  1461.     public function getDevices(): Collection
  1462.     {
  1463.         return $this->devices;
  1464.     }
  1466.     public function addDevice(UserDevice $device): self
  1467.     {
  1468.         if (!$this->devices->contains($device)) {
  1469.             $this->devices[] = $device;
  1470.             $device->setUser($this);
  1471.         }
  1473.         return $this;
  1474.     }
  1476.     public function removeDevice(UserDevice $device): self
  1477.     {
  1478.         if ($this->devices->removeElement($device)) {
  1479.             // set the owning side to null (unless already changed)
  1480.             if ($device->getUser() === $this) {
  1481.                 $device->setUser(null);
  1482.             }
  1483.         }
  1485.         return $this;
  1486.     }
  1488.     public function getNewsletter(): ?bool
  1489.     {
  1490.         return $this->newsletter;
  1491.     }
  1493.     public function setNewsletter(?bool $newsletter): self
  1494.     {
  1495.         $this->newsletter = $newsletter;
  1497.         return $this;
  1498.     }
  1500.     public function getNewsletterDate(): ?\DateTimeInterface
  1501.     {
  1502.         return $this->newsletterDate;
  1503.     }
  1505.     public function setNewsletterDate(?\DateTimeInterface $newsletterDate): self
  1506.     {
  1507.         $this->newsletterDate = $newsletterDate;
  1509.         return $this;
  1510.     }
  1512.     /**
  1513.      * @param bool $firstLogin
  1514.      * @return User
  1515.      */
  1516.     public function setFirstLogin(bool $firstLogin): User
  1517.     {
  1518.         $this->firstLogin = $firstLogin;
  1519.         return $this;
  1520.     }
  1522.     /**
  1523.      * @return bool
  1524.      */
  1525.     public function isFirstLogin(): bool
  1526.     {
  1527.         return $this->firstLogin;
  1528.     }
  1530.     /**
  1531.      * @param bool $homeSurvey
  1532.      * @return User
  1533.      */
  1534.     public function setHomeSurvey(bool $homeSurvey): User
  1535.     {
  1536.         $this->homeSurvey = $homeSurvey;
  1537.         return $this;
  1538.     }
  1540.     /**
  1541.      * @return bool
  1542.      */
  1543.     public function isHomeSurvey(): bool
  1544.     {
  1545.         return $this->homeSurvey;
  1546.     }
  1548.     public function getDisplayTeamplayTuto(): ?bool
  1549.     {
  1550.         return $this->displayTeamplayTuto;
  1551.     }
  1553.     public function setDisplayTeamplayTuto(?bool $displayTeamplayTuto): self
  1554.     {
  1555.         $this->displayTeamplayTuto = $displayTeamplayTuto;
  1557.         return $this;
  1558.     }
  1560.     /**
  1561.      * @return Collection|Log[]
  1562.      */
  1563.     public function getLogs(): Collection
  1564.     {
  1565.         return $this->logs;
  1566.     }
  1568.     public function addLog(Log $log): self
  1569.     {
  1570.         if (!$this->logs->contains($log)) {
  1571.             $this->logs[] = $log;
  1572.             $log->setUser($this);
  1573.         }
  1575.         return $this;
  1576.     }
  1578.     public function removeLog(Log $log): self
  1579.     {
  1580.         if ($this->logs->removeElement($log)) {
  1581.             // set the owning side to null (unless already changed)
  1582.             if ($log->getUser() === $this) {
  1583.                 $log->setUser(null);
  1584.             }
  1585.         }
  1587.         return $this;
  1588.     }
  1590.     /**
  1591.      * @return Collection|Message[]
  1592.      */
  1593.     public function getMessages(): Collection
  1594.     {
  1595.         return $this->messages;
  1596.     }
  1598.     public function addMessage(Message $message): self
  1599.     {
  1600.         if (!$this->messages->contains($message)) {
  1601.             $this->messages[] = $message;
  1602.             $message->setUser($this);
  1603.         }
  1605.         return $this;
  1606.     }
  1608.     public function removeMessage(Message $message): self
  1609.     {
  1610.         if ($this->messages->removeElement($message)) {
  1611.             // set the owning side to null (unless already changed)
  1612.             if ($message->getUser() === $this) {
  1613.                 $message->setUser(null);
  1614.             }
  1615.         }
  1617.         return $this;
  1618.     }
  1620.     /**
  1621.      * @return Collection|VideoEvent[]
  1622.      */
  1623.     public function getVideoEvents(): Collection
  1624.     {
  1625.         return $this->videoEvents;
  1626.     }
  1628.     public function addVideoEvent(VideoEvent $videoEvent): self
  1629.     {
  1630.         if (!$this->videoEvents->contains($videoEvent)) {
  1631.             $this->videoEvents[] = $videoEvent;
  1632.             $videoEvent->setUser($this);
  1633.         }
  1635.         return $this;
  1636.     }
  1638.     public function removeVideoEvent(VideoEvent $videoEvent): self
  1639.     {
  1640.         if ($this->videoEvents->removeElement($videoEvent)) {
  1641.             // set the owning side to null (unless already changed)
  1642.             if ($videoEvent->getUser() === $this) {
  1643.                 $videoEvent->setUser(null);
  1644.             }
  1645.         }
  1647.         return $this;
  1648.     }
  1650.     /**
  1651.      * @return Collection|UserResponse[]
  1652.      */
  1653.     public function getUserResponses(): Collection
  1654.     {
  1655.         return $this->userResponses;
  1656.     }
  1658.     public function addUserResponse(UserResponse $userResponse): self
  1659.     {
  1660.         if (!$this->userResponses->contains($userResponse)) {
  1661.             $this->userResponses[] = $userResponse;
  1662.             $userResponse->setUser($this);
  1663.         }
  1665.         return $this;
  1666.     }
  1668.     public function removeUserResponse(UserResponse $userResponse): self
  1669.     {
  1670.         if ($this->userResponses->removeElement($userResponse)) {
  1671.             // set the owning side to null (unless already changed)
  1672.             if ($userResponse->getUser() === $this) {
  1673.                 $userResponse->setUser(null);
  1674.             }
  1675.         }
  1677.         return $this;
  1678.     }
  1680.     /**
  1681.      * @return Collection|Favorite[]
  1682.      */
  1683.     public function getTvFavorites(): Collection
  1684.     {
  1685.         return $this->tvFavorites;
  1686.     }
  1688.     public function addTvFavorite(Favorite $tvFavorite): self
  1689.     {
  1690.         if (!$this->tvFavorites->contains($tvFavorite)) {
  1691.             $this->tvFavorites[] = $tvFavorite;
  1692.         }
  1694.         return $this;
  1695.     }
  1697.     public function removeTvFavorite(Favorite $tvFavorite): self
  1698.     {
  1699.         $this->tvFavorites->removeElement($tvFavorite);
  1701.         return $this;
  1702.     }
  1704.     /**
  1705.      * @return Collection|LogEmail[]
  1706.      */
  1707.     public function getLogEmails(): Collection
  1708.     {
  1709.         return $this->logEmails;
  1710.     }
  1712.     public function addLogEmail(LogEmail $logEmail): self
  1713.     {
  1714.         if (!$this->logEmails->contains($logEmail)) {
  1715.             $this->logEmails[] = $logEmail;
  1716.             $logEmail->setUser($this);
  1717.         }
  1719.         return $this;
  1720.     }
  1722.     public function removeLogEmail(LogEmail $logEmail): self
  1723.     {
  1724.         if ($this->logEmails->removeElement($logEmail)) {
  1725.             // set the owning side to null (unless already changed)
  1726.             if ($logEmail->getUser() === $this) {
  1727.                 $logEmail->setUser(null);
  1728.             }
  1729.         }
  1731.         return $this;
  1732.     }
  1734.     /**
  1735.      * @return Collection|Playlist[]
  1736.      */
  1737.     public function getPlaylists(): Collection
  1738.     {
  1739.         return $this->playlists;
  1740.     }
  1742.     public function addPlaylist(Playlist $playlist): self
  1743.     {
  1744.         if (!$this->playlists->contains($playlist)) {
  1745.             $this->playlists[] = $playlist;
  1746.             $playlist->setUser($this);
  1747.         }
  1749.         return $this;
  1750.     }
  1752.     public function removePlaylist(Playlist $playlist): self
  1753.     {
  1754.         if ($this->playlists->removeElement($playlist)) {
  1755.             // set the owning side to null (unless already changed)
  1756.             if ($playlist->getUser() === $this) {
  1757.                 $playlist->setUser(null);
  1758.             }
  1759.         }
  1761.         return $this;
  1762.     }
  1764.     /**
  1765.      * @Groups({"user:write"})
  1766.      */
  1767.     public function setAddPlaylist(Playlist $playlist): self
  1768.     {
  1769.         if (!$this->playlists->contains($playlist)) {
  1770.             $this->playlists[] = $playlist;
  1771.             $playlist->setUser($this);
  1772.         }
  1774.         return $this;
  1775.     }
  1777.     /**
  1778.      * @Groups({"user:write"})
  1779.      */
  1780.     public function setRemovePlaylist(Playlist $playlist): self
  1781.     {
  1782.         if ($this->playlists->removeElement($playlist)) {
  1783.             // set the owning side to null (unless already changed)
  1784.             if ($playlist->getUser() === $this) {
  1785.                 $playlist->setUser(null);
  1786.             }
  1787.         }
  1789.         return $this;
  1790.     }
  1792.     /**
  1793.      * @return Collection|Objective[]
  1794.      */
  1795.     public function getObjectives(): Collection
  1796.     {
  1797.         return $this->objectives;
  1798.     }
  1800.     /**
  1801.      * @return Collection|Objective[]
  1802.      */
  1803.     public function setObjectives(Collection $objectives): self
  1804.     {
  1805.         $this->objectives = $objectives;
  1807.         return $this;
  1808.     }
  1810.     public function addObjective(Objective $objective): self
  1811.     {
  1812.         if (!$this->objectives->contains($objective)) {
  1813.             $this->objectives[] = $objective;
  1814.             $objective->addUser($this);
  1815.         }
  1817.         return $this;
  1818.     }
  1820.     public function removeObjective(Objective $objective): self
  1821.     {
  1822.         if ($this->objectives->removeElement($objective)) {
  1823.             $objective->removeUser($this);
  1824.         }
  1826.         return $this;
  1827.     }
  1829.     /**
  1830.      * @return Collection|TeamUser[]
  1831.      */
  1832.     public function getTeamUsers(): Collection
  1833.     {
  1834.         return $this->teamUsers;
  1835.     }
  1837.     public function addTeamUser(TeamUser $teamUser): self
  1838.     {
  1839.         if (!$this->teamUsers->contains($teamUser)) {
  1840.             $this->teamUsers[] = $teamUser;
  1841.             $teamUser->setUser($this);
  1842.         }
  1844.         return $this;
  1845.     }
  1847.     public function removeTeamUser(TeamUser $teamUser): self
  1848.     {
  1849.         if ($this->teamUsers->removeElement($teamUser)) {
  1850.             // set the owning side to null (unless already changed)
  1851.             if ($teamUser->getUser() === $this) {
  1852.                 $teamUser->setUser(null);
  1853.             }
  1854.         }
  1856.         return $this;
  1857.     }
  1859.     /**
  1860.      * @return Collection|TeamplayLog[]
  1861.      */
  1862.     public function getTeamplayLogs(): Collection
  1863.     {
  1864.         return $this->teamplayLogs;
  1865.     }
  1867.     public function addTeamplayLog(TeamplayLog $teamplayLog): self
  1868.     {
  1869.         if (!$this->teamplayLogs->contains($teamplayLog)) {
  1870.             $this->teamplayLogs[] = $teamplayLog;
  1871.             $teamplayLog->setUser($this);
  1872.         }
  1874.         return $this;
  1875.     }
  1877.     public function removeTeamplayLog(TeamplayLog $teamplayLog): self
  1878.     {
  1879.         if ($this->teamplayLogs->removeElement($teamplayLog)) {
  1880.             // set the owning side to null (unless already changed)
  1881.             if ($teamplayLog->getUser() === $this) {
  1882.                 $teamplayLog->setUser(null);
  1883.             }
  1884.         }
  1886.         return $this;
  1887.     }
  1889.     /**
  1890.      * @return Collection|PedometerLog[]
  1891.      */
  1892.     public function getPedometerLogs(): Collection
  1893.     {
  1894.         return $this->pedometerLogs;
  1895.     }
  1897.     public function addPedometerLog(PedometerLog $pedometerLog): self
  1898.     {
  1899.         if (!$this->pedometerLogs->contains($pedometerLog)) {
  1900.             $this->pedometerLogs[] = $pedometerLog;
  1901.             $pedometerLog->setUser($this);
  1902.         }
  1904.         return $this;
  1905.     }
  1907.     public function removePedometerLog(PedometerLog $pedometerLog): self
  1908.     {
  1909.         if ($this->pedometerLogs->removeElement($pedometerLog)) {
  1910.             // set the owning side to null (unless already changed)
  1911.             if ($pedometerLog->getUser() === $this) {
  1912.                 $pedometerLog->setUser(null);
  1913.             }
  1914.         }
  1916.         return $this;
  1917.     }
  1919.     /**
  1920.      * @return Collection<int, UserNotification>
  1921.      */
  1922.     public function getUserNotifications(): Collection
  1923.     {
  1924.         return $this->userNotifications;
  1925.     }
  1927.     public function addUserNotification(UserNotification $userNotification): self
  1928.     {
  1929.         if (!$this->userNotifications->contains($userNotification)) {
  1930.             $this->userNotifications[] = $userNotification;
  1931.             $userNotification->setUser($this);
  1932.         }
  1934.         return $this;
  1935.     }
  1937.     public function removeUserNotification(UserNotification $userNotification): self
  1938.     {
  1939.         if ($this->userNotifications->removeElement($userNotification)) {
  1940.             // set the owning side to null (unless already changed)
  1941.             if ($userNotification->getUser() === $this) {
  1942.                 $userNotification->setUser(null);
  1943.             }
  1944.         }
  1946.         return $this;
  1947.     }
  1949.     /**
  1950.      * @return Collection|AwardLog[]
  1951.      */
  1952.     public function getAwardLogs(): Collection
  1953.     {
  1954.         return $this->awardLogs;
  1955.     }
  1957.     public function addAwardLog(AwardLog $awardLog): self
  1958.     {
  1959.         if (!$this->awardLogs->contains($awardLog)) {
  1960.             $this->awardLogs[] = $awardLog;
  1961.             $awardLog->setUser($this);
  1962.         }
  1964.         return $this;
  1965.     }
  1967.     public function removeAwardLog(AwardLog $awardLog): self
  1968.     {
  1969.         if ($this->awardLogs->removeElement($awardLog)) {
  1970.             // set the owning side to null (unless already changed)
  1971.             if ($awardLog->getUser() === $this) {
  1972.                 $awardLog->setUser(null);
  1973.             }
  1974.         }
  1976.         return $this;
  1977.     }
  1979.     /**
  1980.      * @return Collection|UserVideoTimecode[]
  1981.      */
  1982.     public function getUserVideoTimecodes(): Collection
  1983.     {
  1984.         return $this->userVideoTimecodes;
  1985.     }
  1987.     public function addUserVideoTimecode(UserVideoTimecode $userVideoTimecode): self
  1988.     {
  1989.         if (!$this->userVideoTimecodes->contains($userVideoTimecode)) {
  1990.             $this->userVideoTimecodes[] = $userVideoTimecode;
  1991.             $userVideoTimecode->setUser($this);
  1992.         }
  1994.         return $this;
  1995.     }
  1997.     public function removeUserVideoTimecode(UserVideoTimecode $userVideoTimecode): self
  1998.     {
  1999.         if ($this->userVideoTimecodes->removeElement($userVideoTimecode)) {
  2000.             // set the owning side to null (unless already changed)
  2001.             if ($userVideoTimecode->getUser() === $this) {
  2002.                 $userVideoTimecode->setUser(null);
  2003.             }
  2004.         }
  2006.         return $this;
  2007.     }
  2009.     /**
  2010.      * @return Collection|Notation[]
  2011.      */
  2012.     public function getNotations(): Collection
  2013.     {
  2014.         return $this->notations;
  2015.     }
  2017.     public function addNotation(Notation $notation): self
  2018.     {
  2019.         if (!$this->notations->contains($notation)) {
  2020.             $this->notations[] = $notation;
  2021.             $notation->setUser($this);
  2022.         }
  2024.         return $this;
  2025.     }
  2027.     public function removeNotation(Notation $notation): self
  2028.     {
  2029.         if ($this->notations->removeElement($notation)) {
  2030.             // set the owning side to null (unless already changed)
  2031.             if ($notation->getUser() === $this) {
  2032.                 $notation->setUser(null);
  2033.             }
  2034.         }
  2036.         return $this;
  2037.     }
  2039.     /**
  2040.      * @return Collection|VideoLastValidate[]
  2041.      */
  2042.     public function getVideoLastValidates(): Collection
  2043.     {
  2044.         return $this->videoLastValidates;
  2045.     }
  2047.     public function addVideoLastValidate(VideoLastValidate $videoLastValidate): self
  2048.     {
  2049.         if (!$this->videoLastValidates->contains($videoLastValidate)) {
  2050.             $this->videoLastValidates[] = $videoLastValidate;
  2051.             $videoLastValidate->setUser($this);
  2052.         }
  2054.         return $this;
  2055.     }
  2057.     public function removeVideoLastValidate(VideoLastValidate $videoLastValidate): self
  2058.     {
  2059.         if ($this->videoLastValidates->removeElement($videoLastValidate)) {
  2060.             // set the owning side to null (unless already changed)
  2061.             if ($videoLastValidate->getUser() === $this) {
  2062.                 $videoLastValidate->setUser(null);
  2063.             }
  2064.         }
  2066.         return $this;
  2067.     }
  2069.     /**
  2070.      * @return Collection|VideoLastSeen[]
  2071.      */
  2072.     public function getVideoLastSeens(): Collection
  2073.     {
  2074.         return $this->videoLastSeens;
  2075.     }
  2077.     public function addVideoLastSeen(VideoLastSeen $videoLastSeen): self
  2078.     {
  2079.         if (!$this->videoLastSeens->contains($videoLastSeen)) {
  2080.             $this->videoLastSeens[] = $videoLastSeen;
  2081.             $videoLastSeen->setUser($this);
  2082.         }
  2084.         return $this;
  2085.     }
  2087.     public function removeVideoLastSeen(VideoLastSeen $videoLastSeen): self
  2088.     {
  2089.         if ($this->videoLastSeens->removeElement($videoLastSeen)) {
  2090.             // set the owning side to null (unless already changed)
  2091.             if ($videoLastSeen->getUser() === $this) {
  2092.                 $videoLastSeen->setUser(null);
  2093.             }
  2094.         }
  2096.         return $this;
  2097.     }
  2099.     /**
  2100.      * @return Collection|MoodResponse[]
  2101.      */
  2102.     public function getMoodResponses(): Collection
  2103.     {
  2104.         return $this->moodResponses;
  2105.     }
  2107.     public function addMoodResponse(MoodResponse $moodResponse): self
  2108.     {
  2109.         if (!$this->moodResponses->contains($moodResponse)) {
  2110.             $this->moodResponses[] = $moodResponse;
  2111.             $moodResponse->setUser($this);
  2112.         }
  2114.         return $this;
  2115.     }
  2117.     public function removeMoodResponse(MoodResponse $moodResponse): self
  2118.     {
  2119.         if ($this->moodResponses->removeElement($moodResponse)) {
  2120.             // set the owning side to null (unless already changed)
  2121.             if ($moodResponse->getUser() === $this) {
  2122.                 $moodResponse->setUser(null);
  2123.             }
  2124.         }
  2126.         return $this;
  2127.     }
  2129.     /**
  2130.      * @return Collection|ProgramEvent[]
  2131.      */
  2132.     public function getProgramEvents(): Collection
  2133.     {
  2134.         return $this->programEvents;
  2135.     }
  2137.     public function addProgramEvent(ProgramEvent $programEvent): self
  2138.     {
  2139.         if (!$this->programEvents->contains($programEvent)) {
  2140.             $this->programEvents[] = $programEvent;
  2141.             $programEvent->setUser($this);
  2142.         }
  2144.         return $this;
  2145.     }
  2147.     public function removeProgramEvent(ProgramEvent $programEvent): self
  2148.     {
  2149.         if ($this->programEvents->removeElement($programEvent)) {
  2150.             // set the owning side to null (unless already changed)
  2151.             if ($programEvent->getUser() === $this) {
  2152.                 $programEvent->setUser(null);
  2153.             }
  2154.         }
  2156.         return $this;
  2157.     }
  2159.     /**
  2160.      * @return Collection|DayEvent[]
  2161.      */
  2162.     public function getDayEvents(): Collection
  2163.     {
  2164.         return $this->dayEvents;
  2165.     }
  2167.     public function addDayEvent(DayEvent $dayEvent): self
  2168.     {
  2169.         if (!$this->dayEvents->contains($dayEvent)) {
  2170.             $this->dayEvents[] = $dayEvent;
  2171.             $dayEvent->setUser($this);
  2172.         }
  2174.         return $this;
  2175.     }
  2177.     public function removeDayEvent(DayEvent $dayEvent): self
  2178.     {
  2179.         if ($this->dayEvents->removeElement($dayEvent)) {
  2180.             // set the owning side to null (unless already changed)
  2181.             if ($dayEvent->getUser() === $this) {
  2182.                 $dayEvent->setUser(null);
  2183.             }
  2184.         }
  2186.         return $this;
  2187.     }
  2189.     public function getTvUser(): ?TvUser
  2190.     {
  2191.         return $this->tvUser;
  2192.     }
  2194.     public function setTvUser(?TvUser $tvUser): self
  2195.     {
  2196.         $this->tvUser = $tvUser;
  2198.         return $this;
  2199.     }
  2201.     public function isLive(): ?bool
  2202.     {
  2203.         return $this->live;
  2204.     }
  2206.     public function setLive(bool $isLive): self
  2207.     {
  2208.         $this->live = $isLive;
  2210.         return $this;
  2211.     }
  2213.     public function isTv(): ?bool
  2214.     {
  2215.         return $this->tv;
  2216.     }
  2218.     public function setTv(bool $isTv): self
  2219.     {
  2220.         $this->tv = $isTv;
  2222.         return $this;
  2223.     }
  2225.     /**
  2226.      * @return Collection<int, Chat>
  2227.      */
  2228.     public function getChats(): Collection
  2229.     {
  2230.         return $this->chats;
  2231.     }
  2233.     public function addChat(Chat $chat): self
  2234.     {
  2235.         if (!$this->chats->contains($chat)) {
  2236.             $this->chats[] = $chat;
  2237.         }
  2239.         return $this;
  2240.     }
  2242.     public function removeChat(Chat $chat): self
  2243.     {
  2244.         $this->chats->removeElement($chat);
  2246.         return $this;
  2247.     }
  2249.     /**
  2250.      * @return Collection<int, Invoice>
  2251.      */
  2252.     public function getInvoices(): Collection
  2253.     {
  2254.         return $this->invoices;
  2255.     }
  2257.     public function addInvoice(Invoice $invoice): self
  2258.     {
  2259.         if (!$this->invoices->contains($invoice)) {
  2260.             $this->invoices->add($invoice);
  2261.             $invoice->setUser($this);
  2262.         }
  2264.         return $this;
  2265.     }
  2267.     public function removeInvoice(Invoice $invoice): self
  2268.     {
  2269.         if ($this->invoices->removeElement($invoice)) {
  2270.             // set the owning side to null (unless already changed)
  2271.             if ($invoice->getUser() === $this) {
  2272.                 $invoice->setUser(null);
  2273.             }
  2274.         }
  2276.         return $this;
  2277.     }
  2278.     public function getNotificationPreference(): ?NotificationPreference
  2279.     {
  2280.         return $this->notificationPreference;
  2281.     }
  2283.     public function setNotificationPreference(NotificationPreference $notificationPreference): static
  2284.     {
  2285.         // set the owning side of the relation if necessary
  2286.         if ($notificationPreference->getUser() !== $this) {
  2287.             $notificationPreference->setUser($this);
  2288.         }
  2290.         $this->notificationPreference = $notificationPreference;
  2292.         return $this;
  2293.     }
  2294. }