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.      * Valeurs de segmentation multi-axes — source de vérité des affectations,
  376.      * synchronisée automatiquement par setSegmentation() / assignSegmentationValue()
  377.      *
  378.      * @ORM\OneToMany(targetEntity=UserSegmentation::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
  379.      * @Groups({"user:read:segmentations"})
  380.      */
  381.     private $userSegmentations;
  383.     /**
  384.      * @ORM\Column(type="string", length=255, nullable=true, options={"default": "FR"})
  385.      * @Groups({"user:read:country"})
  386.      */
  387.     private $country;
  389.     /**
  390.      * @ORM\Column(name="`function`", type="string", length=255, nullable=true)
  391.      * @Groups({"user:read:function", "user:read", "user:write", "company:read", "company:write", "export_csv", "manager_dashboard"})
  392.      */
  393.     private $function;
  395.     /**
  396.      * @ORM\Column(type="string", length=255, nullable=true)
  397.      * @Groups({"user:read:phone", "user:read", "user:write", "company:read", "company:write", "export_csv", "manager_dashboard"})
  398.      * @Assert\Length(min=8, max=20, minMessage="phone.min", maxMessage="phone.max")
  399.      */
  400.     private $phone;
  402.     /**
  403.      * @ORM\Column(type="string", length=255, nullable=true)
  404.      * @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"})
  405.      */
  406.     private $username;
  408.     /**
  409.      * @ORM\Column(type="integer", options={"default": "-1"})
  410.      * @Groups({"user:read:quotas", "user:read", "user:write", "user:read:export_csv"})
  411.      */
  412.     private $quotas = -1;
  414.     /**
  415.      * @ORM\Column(type="string", length=255, options={"default": "unset"})
  416.      * @Groups({"user:read:quotasType", "user:read", "user:write", "user:read:export_csv"})
  417.      */
  418.     private $quotasType = self::QUOTA_NONE;
  420.     /**
  421.      * @ORM\Column(type="datetime", nullable=true)
  422.      * @Gedmo\Timestampable(on="change", field="email")
  423.      */
  424.     private $emailUpdatedAt;
  426.     /**
  427.      * @ORM\Column(type="datetime", nullable=true)
  428.      */
  429.     private $emailValidatedAt;
  431.     /**
  432.      * @ORM\Column(type="string", length=255, nullable=true)
  433.      * @Groups({"user:read:status", "user:read", "company:read", "user:read:export_csv", "client:read"})
  434.      * @Assert\Choice(choices=self::STATUSES)
  435.      */
  436.     private $status = self::STATUS_ACTIVE;
  438.     /**
  439.      * @ORM\Column(type="string", length=255, nullable=true)
  440.      * @Groups({"user:read:deviceOs", "user:read", "user:write"})
  441.      */
  442.     private $deviceOs;
  444.     /**
  445.      * @ORM\Column(type="text", nullable=true)
  446.      * @Groups({"user:read:deviceToken", "user:read", "user:write"})
  447.      */
  448.     private $deviceToken;
  450.     /**
  451.      * @ORM\Column(type="string", length=255, nullable=true)
  452.      * @Groups({"user:read:deviceName", "user:read", "user:write"})
  453.      */
  454.     private $deviceName;
  456.     /**
  457.      * @ORM\Column(type="boolean", nullable=true, options={"default": 1})
  458.      * @Groups({"user:read:deviceActive", "user:read", "user:write"})
  459.      */
  460.     private $deviceActive = true;
  462.     /**
  463.      * @ORM\Column(type="datetime", nullable=true)
  464.      * @Gedmo\Timestampable(on="change", field={"deviceOs", "deviceToken", "deviceName", "deviceActive"})
  465.      * @Groups({"user:read:deviceUpdate", "user:read", "user:write"})
  466.      */
  467.     private $deviceUpdate;
  469.     /**
  470.      * @ORM\OneToMany(targetEntity=UserDevice::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  471.      */
  472.     private $devices;
  474.     /**
  475.      * @ORM\Column(type="boolean", options={"default": "0"})
  476.      * @Groups({"user:read:newsletter", "user:read", "company:read", "user:write", "client:read", "client:write"})
  477.      */
  478.     private $newsletter = false;
  480.     /**
  481.      * @ORM\Column(type="datetime", nullable=true)
  482.      * @Groups({"user:read:newsletterDate", "user:read", "company:read"})
  483.      * @Gedmo\Timestampable(on="change", field="newsletter", value=true)
  484.      */
  485.     private $newsletterDate;
  487.     /**
  488.      * @ORM\Column(type="boolean", options={"default": "1"})
  489.      * @Groups({"user:read:firstLogin", "user:read", "company:read", "user:write", "client:read", "client:write"})
  490.      */
  491.     private $firstLogin = true;
  493.     /**
  494.      * @ORM\Column(type="boolean", options={"default": "1"})
  495.      * @Groups({"user:read:homeSurvey", "user:read", "company:read", "user:write", "client:read", "client:write"})
  496.      */
  497.     private $homeSurvey = true;
  499.     /**
  500.      * @ORM\Column(type="boolean", nullable=true, options={"default": "1"})
  501.      * @Groups({"user:read:displayTeamplayTuto", "user:read", "user:write", "user:read:tuto_only", "client:read", "client:write"})
  502.      */
  503.     private $displayTeamplayTuto = true;
  505.     /**
  506.      * @ORM\OneToMany(targetEntity=Log::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  507.      */
  508.     private $logs;
  510.     /**
  511.      * Sent messages by the user to web admins
  512.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  513.      */
  514.     private $messages;
  516.     /**
  517.      * @ORM\OneToMany(targetEntity=VideoEvent::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  518.      */
  519.     private $videoEvents;
  521.     /**
  522.      * @ORM\OneToMany(targetEntity=UserResponse::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  523.      */
  524.     private $userResponses;
  526.     /**
  527.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  528.      * @Groups({"user:read:tvFavorites"})
  529.      * @ApiSubresource(maxDepth=1)
  530.      */
  531.     private $tvFavorites;
  533.     /**
  534.      * @ORM\OneToMany(targetEntity=LogEmail::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  535.      */
  536.     private $logEmails;
  538.     /**
  539.      * @ORM\OneToMany(targetEntity=Playlist::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  540.      */
  541.     private $playlists;
  543.     /**
  544.      * @ORM\ManyToMany(targetEntity=Objective::class, mappedBy="users")
  545.      * @Groups({"user:read", "user:write"})
  546.      */
  547.     private $objectives;
  549.     /**
  550.      * @ORM\OneToMany(targetEntity=TeamUser::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  551.      */
  552.     private $teamUsers;
  554.     /**
  555.      * @ORM\OneToMany(targetEntity=TeamplayLog::class, mappedBy="user", orphanRemoval=true, cascade={"refresh", "remove"})
  556.      */
  557.     private $teamplayLogs;
  559.     /**
  560.      * @ORM\OneToMany(targetEntity=PedometerLog::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  561.      */
  562.     private $pedometerLogs;
  564.     /**
  565.      * @ORM\OneToMany(targetEntity=UserNotification::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  566.      */
  567.     private $userNotifications;
  569.     /**
  570.      * @ORM\OneToMany(targetEntity=AwardLog::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  571.      */
  572.     private $awardLogs;
  574.     /**
  575.      * @ORM\OneToMany(targetEntity=UserVideoTimecode::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "refresh", "remove"})
  576.      */
  577.     private $userVideoTimecodes;
  579.     /**
  580.      * @ORM\OneToMany(targetEntity=Notation::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  581.      */
  582.     private $notations;
  584.     /**
  585.      * @ORM\OneToMany(targetEntity=VideoLastValidate::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  586.      */
  587.     private $videoLastValidates;
  589.     /**
  590.      * @ORM\OneToMany(targetEntity=VideoLastSeen::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  591.      */
  592.     private $videoLastSeens;
  594.     /**
  595.      * @ORM\OneToMany(targetEntity=MoodResponse::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  596.      */
  597.     private $moodResponses;
  599.     /**
  600.      * @ORM\OneToMany(targetEntity=ProgramEvent::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  601.      */
  602.     private $programEvents;
  604.     /**
  605.      * @ORM\OneToMany(targetEntity=DayEvent::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true)
  606.      */
  607.     private $dayEvents;
  609.     /**
  610.      * @ORM\OneToOne(targetEntity=TvUser::class, mappedBy="user", cascade={"persist", "refresh","remove"})
  611.      */
  612.     private $tvUser;
  614.     /**
  615.      * @ORM\Column(type="boolean", options={"default": "1"})
  616.      * @Groups({"user:read:live", "user:read", "user:write",  "user_favorite:read", "client:read"})
  617.      */
  618.     private $live = true;
  620.     /**
  621.      * @ORM\Column(type="boolean", options={"default": "1"})
  622.      * @Groups({"user:read:tv", "user:read", "user:write",  "user_favorite:read", "client:read"})
  623.      */
  624.     private $tv = true;
  626.     /**
  627.      *  
  628.      * @ORM\ManyToMany(targetEntity=Chat::class, inversedBy="users")
  629.      */
  630.     private $chats;
  632.     /**
  633.      * @var bool
  634.      */
  635.     public $isPopulated = false;
  637.     /**
  638.      * @ORM\OneToMany(targetEntity=Invoice::class, mappedBy="user", cascade={"persist", "refresh", "remove"}, orphanRemoval=true) 
  639.      */
  640.     private $invoices;
  642.     /**
  643.      * @ORM\OneToOne(targetEntity=NotificationPreference::class, mappedBy="user", cascade={"persist","remove"})
  644.      */
  645.     private $notificationPreference = null;
  647.     /**
  648.      * @ORM\OneToOne(targetEntity=StravaProfile::class, mappedBy="user", cascade={"persist", "remove"})
  649.      * @Groups({"user:read:stravaProfile", "user:read"})
  650.      */
  651.     private $stravaProfile;
  654.     public function __construct()
  655.     {
  656.         $this->roles[] = self::ROLE_USER;
  657.         $this->documents = new ArrayCollection();
  658.         $this->marketplaceReservations = new ArrayCollection();
  659.         $this->favorites = new ArrayCollection();
  660.         $this->devices = new ArrayCollection();
  661.         $this->logs = new ArrayCollection();
  662.         $this->messages = new ArrayCollection();
  663.         $this->videoEvents = new ArrayCollection();
  664.         $this->userResponses = new ArrayCollection();
  665.         $this->tvFavorites = new ArrayCollection();
  666.         $this->logEmails = new ArrayCollection();
  667.         $this->playlists = new ArrayCollection();
  668.         $this->objectives = new ArrayCollection();
  669.         $this->teamUsers = new ArrayCollection();
  670.         $this->teamplayLogs = new ArrayCollection();
  671.         $this->pedometerLogs = new ArrayCollection();
  672.         $this->userNotifications = new ArrayCollection();
  673.         $this->awardLogs = new ArrayCollection();
  674.         $this->userVideoTimecodes = new ArrayCollection();
  675.         $this->notations = new ArrayCollection();
  676.         $this->videoLastValidates = new ArrayCollection();
  677.         $this->videoLastSeens = new ArrayCollection();
  678.         $this->moodResponses = new ArrayCollection();
  679.         $this->programEvents = new ArrayCollection();
  680.         $this->dayEvents = new ArrayCollection();
  681.         $this->chats = new ArrayCollection();
  682.         $this->invoices = new ArrayCollection();
  683.         $this->userSegmentations = new ArrayCollection();
  684.     }
  686.     public function getId(): ?int
  687.     {
  688.         return $this->id;
  689.     }
  691.     public function getEmail(): ?string
  692.     {
  693.         return $this->email;
  694.     }
  696.     public function setEmail(string $email): self
  697.     {
  698.         $this->email = $email;
  700.         return $this;
  701.     }
  703.     /**
  704.      * A visual identifier that represents this user.
  705.      *
  706.      * @see UserInterface
  707.      */
  708.     public function getUserIdentifier(): string
  709.     {
  710.         return (string)$this->email;
  711.     }
  713.     public function getUsername(): ?string
  714.     {
  715.         return $this->username;
  716.     }
  718.     public function setUsername(?string $username): self
  719.     {
  720.         $this->username = $username;
  722.         return $this;
  723.     }
  725.     /**
  726.      * @see UserInterface
  727.      */
  728.     public function getRoles(): array
  729.     {
  730.         $roles = $this->roles;
  731.         // guarantee every user at least has ROLE_USER
  732.         $roles[] = self::ROLE_USER;
  734.         if ($this->isTv()) {
  735.             $roles[] = self::ROLE_TV;
  736.         }
  738.         if ($this->isLive()) {
  739.             $roles[] = self::ROLE_LIVE;
  740.         }
  742.         return array_unique($roles);
  743.     }
  745.     /**
  746.      * @param string $role
  747.      * @return bool
  748.      */
  749.     public function hasRole(string $role): bool
  750.     {
  751.         return in_array($role, $this->roles);
  752.     }
  754.     /**
  755.      * @see UserInterface
  756.      */
  757.     public function addRole(string $role): self
  758.     {
  759.         if (!in_array($role, $this->roles)) {
  760.             $this->roles[] = $role;
  761.         }
  762.         return $this;
  763.     }
  765.     /**
  766.      * @see UserInterface
  767.      */
  768.     public function removeRole(string $role): self
  769.     {
  770.         if (in_array($role, $this->roles)) {
  771.             foreach ($this->roles as $key => $item) {
  772.                 if ($item === $role) {
  773.                     unset($this->roles[$key]);
  774.                 }
  775.             }
  776.             $this->roles = array_values($this->roles);
  777.         }
  778.         return $this;
  779.     }
  781.     public function setRoles(array $roles): self
  782.     {
  783.         $this->roles = $roles;
  785.         return $this;
  786.     }
  788.     /**
  789.      * @see PasswordAuthenticatedUserInterface
  790.      */
  791.     public function getPassword(): ?string
  792.     {
  793.         return $this->password;
  794.     }
  796.     /**
  797.      * This setter also checks if the password has changed it will rehash it
  798.      * @param string|null $password New password
  799.      * @param bool $hash Forces rehash of password
  800.      * @return $this
  801.      */
  802.     public function setPassword(?string $password, bool $hash = false): self
  803.     {
  804.         if (!empty($password) && ($this->password !== $password || $hash)) {
  805.             $this->_hashPwd = true;
  806.         }
  807.         if (!empty($password)) {
  808.             $this->password = $password;
  809.         }
  810.         return $this;
  811.     }
  813.     /**
  814.      * If persisted this password will be encoded into the password field
  815.      * @param ?string $oldPassword
  816.      * @return User
  817.      */
  818.     public function setOldPassword(?string $oldPassword): User
  819.     {
  820.         $this->oldPassword = $oldPassword;
  821.         return $this;
  822.     }
  824.     /**
  825.      * @return string
  826.      */
  827.     public function getOldPassword(): ?string
  828.     {
  829.         return $this->oldPassword;
  830.     }
  832.     /**
  833.      * If persisted this password will be encoded into the password field
  834.      * @param string $password
  835.      * @return User
  836.      */
  837.     public function setPlainPassword(string $password): User
  838.     {
  839.         $this->plainPassword = $password;
  840.         return $this;
  841.     }
  843.     /**
  844.      * @return string
  845.      */
  846.     public function getPlainPassword(): ?string
  847.     {
  848.         return $this->plainPassword;
  849.     }
  851.     /**
  852.      * @return string|null
  853.      */
  854.     public function getPasswordConfirm(): ?string
  855.     {
  856.         return $this->passwordConfirm;
  857.     }
  859.     /**
  860.      * @param string|null $passwordConfirm
  861.      * @return User
  862.      */
  863.     public function setPasswordConfirm(?string $passwordConfirm): User
  864.     {
  865.         $this->passwordConfirm = $passwordConfirm;
  866.         return $this;
  867.     }
  869.     /**
  870.      * Returning a salt is only needed, if you are not using a modern
  871.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  872.      *
  873.      * @see UserInterface
  874.      */
  875.     public function getSalt(): ?string
  876.     {
  877.         return null;
  878.     }
  880.     /**
  881.      * @see UserInterface
  882.      */
  883.     public function eraseCredentials()
  884.     {
  885.         // If you store any temporary, sensitive data on the user, clear it here
  886.         $this->plainPassword = null;
  887.     }
  889.     public function getCreatedAt(): ?\DateTime
  890.     {
  891.         return $this->createdAt;
  892.     }
  894.     public function setCreatedAt(\DateTime $createdAt): self
  895.     {
  896.         $this->createdAt = $createdAt;
  898.         return $this;
  899.     }
  901.     public function getUpdatedAt(): ?\DateTime
  902.     {
  903.         return $this->updatedAt;
  904.     }
  906.     public function setUpdatedAt(\DateTime $updatedAt): self
  907.     {
  908.         $this->updatedAt = $updatedAt;
  910.         return $this;
  911.     }
  913.     public function getLastLogin(): ?\DateTimeInterface
  914.     {
  915.         return $this->lastLogin;
  916.     }
  918.     public function setLastLogin(?\DateTimeInterface $lastLogin): self
  919.     {
  920.         $this->lastLogin = $lastLogin;
  922.         return $this;
  923.     }
  925.     public function getName(): ?string
  926.     {
  927.         return $this->name;
  928.     }
  930.     public function setName(?string $name): self
  931.     {
  932.         $this->name = $name;
  934.         return $this;
  935.     }
  937.     public function getCategory(): ?string
  938.     {
  939.         return $this->category;
  940.     }
  942.     public function setCategory(string $category): self
  943.     {
  944.         $this->category = $category;
  946.         return $this;
  947.     }
  949.     public function getActive(): ?bool
  950.     {
  952.         return $this->active;
  953.     }
  955.     public function isActive(): ?bool
  956.     {
  957.         return $this->active;
  958.     }
  960.     public function setActive(bool $active): self
  961.     {
  962.         $this->active = $active;
  963.         if ($this->active) {
  964.             $this->status = self::STATUS_ACTIVE;
  965.         } else {
  966.             $this->status = self::STATUS_SUSPENDED;
  967.         }
  969.         return $this;
  970.     }
  972.     public function getBanStart(): ?\DateTimeInterface
  973.     {
  974.         return $this->banStart;
  975.     }
  977.     public function setBanStart(?\DateTimeInterface $banStart): self
  978.     {
  979.         $this->banStart = $banStart;
  981.         return $this;
  982.     }
  984.     public function getBanEnd(): ?\DateTimeInterface
  985.     {
  986.         return $this->banEnd;
  987.     }
  989.     public function setBanEnd(?\DateTimeInterface $banEnd): self
  990.     {
  991.         $this->banEnd = $banEnd;
  993.         return $this;
  994.     }
  996.     public function getResetToken(): ?string
  997.     {
  998.         return $this->resetToken;
  999.     }
  1001.     public function setResetToken(?string $resetToken): self
  1002.     {
  1003.         $this->resetToken = $resetToken;
  1005.         return $this;
  1006.     }
  1008.     public function getSpecialist(): ?Specialist
  1009.     {
  1010.         return $this->specialist;
  1011.     }
  1013.     public function setSpecialist(Specialist $specialist): self
  1014.     {
  1015.         // set the owning side of the relation if necessary
  1016.         if ($specialist->getUser() !== $this) {
  1017.             $specialist->setUser($this);
  1018.         }
  1020.         $this->specialist = $specialist;
  1022.         return $this;
  1023.     }
  1025.     public function getCompany(): ?Company
  1026.     {
  1027.         return $this->company;
  1028.     }
  1030.     public function setCompany(?Company $company): self
  1031.     {
  1032.         $this->company = $company;
  1034.         return $this;
  1035.     }
  1037.     public function getClient(): ?Client
  1038.     {
  1039.         return $this->client;
  1040.     }
  1042.     public function setClient(Client $client): self
  1043.     {
  1044.         // set the owning side of the relation if necessary
  1045.         if ($client->getUser() !== $this) {
  1046.             $client->setUser($this);
  1047.         }
  1049.         $this->client = $client;
  1051.         return $this;
  1052.     }
  1054.     /**
  1055.      * @return bool
  1056.      */
  1057.     public function isHashPwd(): bool
  1058.     {
  1059.         return $this->_hashPwd;
  1060.     }
  1062.     /**
  1063.      * @return string
  1064.      */
  1065.     public function __toString()
  1066.     {
  1067.         return $this->name;
  1068.     }
  1070.     /**
  1071.      * @ORM\PrePersist()
  1072.      */
  1073.     public function updateName()
  1074.     {
  1075.         if ($this->company instanceof Company) {
  1076.             $this->name = $this->company->getName();
  1077.         } elseif ($this->specialist instanceof Specialist) {
  1078.             $this->name = (string)$this->specialist;
  1079.         } elseif ($this->client instanceof Client) {
  1080.             $this->name = (string)$this->client;
  1081.         }
  1082.     }
  1084.     /**
  1085.      * @param string|null $token
  1086.      * @return User
  1087.      */
  1088.     public function setToken(?string $token): User
  1089.     {
  1090.         $this->token = $token;
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return string|null
  1096.      */
  1097.     public function getToken(): ?string
  1098.     {
  1099.         return $this->token;
  1100.     }
  1102.     public function setSamlAttributes(array $attributes)
  1103.     {
  1104.         $this->token = $attributes['sessionIndex'];
  1106.         $data = [];
  1107.         foreach ($attributes as $key => $value) {
  1108.             $data[ToolsService::toCamelCase($key)] = $value;
  1109.         }
  1111.         if (!empty($data['email'])) {
  1112.             if (is_array($data['email'])) $this->email = $data['email'][0];
  1113.             elseif (is_string($data['email'])) $this->email = $data['email'];
  1114.         }
  1116.         if (!empty($data['firstName'])) {
  1117.             if (is_array($data['firstName'])) $this->firstName = $data['firstName'][0];
  1118.             elseif (is_string($data['firstName'])) $this->firstName = $data['firstName'];
  1119.         }
  1121.         if (!empty($data['lastName'])) {
  1122.             if (is_array($data['lastName'])) $this->lastName = $data['lastName'][0];
  1123.             elseif (is_string($data['lastName'])) $this->lastName = $data['lastName'];
  1124.         }
  1126.         if (!empty($data['country'])) {
  1127.             if (is_array($data['country'])) $this->country = $data['country'][0];
  1128.             elseif (is_string($data['country'])) $this->country = $data['country'];
  1129.         }
  1130.     }
  1132.     /**
  1133.      * @return Collection<int, Document>
  1134.      */
  1135.     public function getDocuments(): Collection
  1136.     {
  1137.         return $this->documents;
  1138.     }
  1140.     public function addDocument(Document $document): self
  1141.     {
  1142.         if (!$this->documents->contains($document)) {
  1143.             $this->documents[] = $document;
  1144.             $document->setOwner($this);
  1145.         }
  1147.         return $this;
  1148.     }
  1150.     public function removeDocument(Document $document): self
  1151.     {
  1152.         if ($this->documents->removeElement($document)) {
  1153.             // set the owning side to null (unless already changed)
  1154.             if ($document->getOwner() === $this) {
  1155.                 $document->setOwner(null);
  1156.             }
  1157.         }
  1159.         return $this;
  1160.     }
  1162.     /**
  1163.      * @return Collection<int, MarketplaceReservation>
  1164.      */
  1165.     public function getMarketplaceReservations(): Collection
  1166.     {
  1167.         return $this->marketplaceReservations;
  1168.     }
  1170.     public function addMarketplaceReservation(MarketplaceReservation $marketplaceReservation): self
  1171.     {
  1172.         if (!$this->marketplaceReservations->contains($marketplaceReservation)) {
  1173.             $this->marketplaceReservations[] = $marketplaceReservation;
  1174.             $marketplaceReservation->setUser($this);
  1175.         }
  1177.         return $this;
  1178.     }
  1180.     public function removeMarketplaceReservation(MarketplaceReservation $marketplaceReservation): self
  1181.     {
  1182.         if ($this->marketplaceReservations->removeElement($marketplaceReservation)) {
  1183.             // set the owning side to null (unless already changed)
  1184.             if ($marketplaceReservation->getUser() === $this) {
  1185.                 $marketplaceReservation->setUser(null);
  1186.             }
  1187.         }
  1189.         return $this;
  1190.     }
  1192.     public function getFirstName(): ?string
  1193.     {
  1194.         return $this->firstName;
  1195.     }
  1197.     public function setFirstName(?string $firstName): self
  1198.     {
  1199.         $this->firstName = $firstName;
  1201.         $name = $this->firstName;
  1202.         if (!empty($this->lastName)) {
  1203.             $name .= " " . $this->lastName;
  1204.         }
  1205.         $this->setName($name);
  1207.         return $this;
  1208.     }
  1210.     public function getLastName(): ?string
  1211.     {
  1212.         return $this->lastName;
  1213.     }
  1215.     public function setLastName(?string $lastName): self
  1216.     {
  1217.         $this->lastName = $lastName;
  1219.         $name = $this->firstName;
  1220.         if (!empty($this->lastName)) {
  1221.             $name .= " " . $this->lastName;
  1222.         }
  1223.         $this->setName($name);
  1225.         return $this;
  1226.     }
  1228.     /**
  1229.      * @return Collection<int, UserFavorite>
  1230.      */
  1231.     public function getFavorites(): Collection
  1232.     {
  1233.         return $this->favorites;
  1234.     }
  1236.     public function addFavorite(UserFavorite $favorite): self
  1237.     {
  1238.         if (!$this->favorites->contains($favorite)) {
  1239.             $this->favorites[] = $favorite;
  1240.             $favorite->setUser($this);
  1241.         }
  1243.         return $this;
  1244.     }
  1246.     public function removeFavorite(UserFavorite $favorite): self
  1247.     {
  1248.         if ($this->favorites->removeElement($favorite)) {
  1249.             // set the owning side to null (unless already changed)
  1250.             if ($favorite->getUser() === $this) {
  1251.                 $favorite->setUser(null);
  1252.             }
  1253.         }
  1255.         return $this;
  1256.     }
  1258.     public function getSegmentation(): ?Segmentation
  1259.     {
  1260.         return $this->segmentation;
  1261.     }
  1263.     public function setSegmentation(?Segmentation $segmentation): self
  1264.     {
  1266.         $previous            = $this->segmentation;
  1267.         $this->segmentation  = $segmentation;
  1268.         if ($this->getClient()) {
  1269.             $this->getClient()->setSegmentation($segmentation);
  1270.         }
  1272.         // Invariant multi-axes : la valeur miroir doit toujours exister dans user_segmentation
  1273.         if ($segmentation instanceof Segmentation) {
  1274.             $this->syncSegmentationValue($segmentation);
  1275.         } elseif ($previous instanceof Segmentation) {
  1276.             $this->removeSegmentationValue($previous);
  1277.         }
  1279.         return $this;
  1280.     }
  1282.     /**
  1283.      * @return Collection<int, UserSegmentation>
  1284.      */
  1285.     public function getUserSegmentations(): Collection
  1286.     {
  1287.         return $this->userSegmentations;
  1288.     }
  1290.     /**
  1291.      * Affecte une valeur de segmentation multi-axes : remplace la valeur du même axe dans le pivot.
  1292.      * Si la valeur remplacée est celle portée par le miroir legacy (segmentation_id), le miroir suit.
  1293.      */
  1294.     public function assignSegmentationValue(Segmentation $segmentation): self
  1295.     {
  1297.         if ($this->segmentation instanceof Segmentation
  1298.             && !$this->isSameSegmentation($this->segmentation, $segmentation)
  1299.             && $this->isSameSegmentationAxis($this->segmentation, $segmentation)
  1300.         ) {
  1301.             return $this->setSegmentation($segmentation);
  1302.         }
  1304.         $this->syncSegmentationValue($segmentation);
  1306.         return $this;
  1307.     }
  1309.     /**
  1310.      * Retourne la valeur du pivot pour un axe donné (null = pseudo-axe racine, sans parent)
  1311.      */
  1312.     public function getSegmentationValueForAxis(?Segmentation $axis): ?Segmentation
  1313.     {
  1315.         foreach ($this->userSegmentations as $userSegmentation) {
  1316.             $parent = $userSegmentation->getSegmentation()->getParent();
  1317.             if ($axis === null && $parent === null) {
  1318.                 return $userSegmentation->getSegmentation();
  1319.             }
  1320.             if ($axis !== null && $parent !== null && $this->isSameSegmentation($parent, $axis)) {
  1321.                 return $userSegmentation->getSegmentation();
  1322.             }
  1323.         }
  1325.         return null;
  1326.     }
  1328.     /**
  1329.      * Ajoute la valeur dans le pivot en remplaçant celle du même axe (une valeur max par axe)
  1330.      */
  1331.     private function syncSegmentationValue(Segmentation $segmentation): void
  1332.     {
  1334.         $alreadyAssigned = false;
  1335.         foreach ($this->userSegmentations as $userSegmentation) {
  1336.             $current = $userSegmentation->getSegmentation();
  1337.             if ($this->isSameSegmentation($current, $segmentation)) {
  1338.                 $alreadyAssigned = true;
  1339.                 continue;
  1340.             }
  1341.             if ($this->isSameSegmentationAxis($current, $segmentation)) {
  1342.                 // orphanRemoval supprime la ligne du pivot au flush
  1343.                 $this->userSegmentations->removeElement($userSegmentation);
  1344.             }
  1345.         }
  1347.         if (!$alreadyAssigned) {
  1348.             $userSegmentation = (new UserSegmentation())
  1349.                 ->setUser($this)
  1350.                 ->setSegmentation($segmentation);
  1351.             $this->userSegmentations->add($userSegmentation);
  1352.         }
  1353.     }
  1355.     private function removeSegmentationValue(Segmentation $segmentation): void
  1356.     {
  1358.         foreach ($this->userSegmentations as $userSegmentation) {
  1359.             if ($this->isSameSegmentation($userSegmentation->getSegmentation(), $segmentation)) {
  1360.                 $this->userSegmentations->removeElement($userSegmentation);
  1361.             }
  1362.         }
  1363.     }
  1365.     /**
  1366.      * Comparaison par identité d'objet puis par id (les segmentations créées à la volée,
  1367.      * ex. SSO, n'ont pas encore d'id au moment du set)
  1368.      */
  1369.     private function isSameSegmentation(Segmentation $a, Segmentation $b): bool
  1370.     {
  1372.         return $a === $b || ($a->getId() !== null && $a->getId() === $b->getId());
  1373.     }
  1375.     /**
  1376.      * Deux valeurs appartiennent au même axe si elles partagent le même parent ;
  1377.      * l'absence de parent est traitée comme un pseudo-axe racine unique
  1378.      * (sémantique historique de la mono-segmentation)
  1379.      */
  1380.     private function isSameSegmentationAxis(Segmentation $a, Segmentation $b): bool
  1381.     {
  1383.         $parentA = $a->getParent();
  1384.         $parentB = $b->getParent();
  1386.         if ($parentA === null || $parentB === null) {
  1387.             return $parentA === null && $parentB === null;
  1388.         }
  1390.         return $this->isSameSegmentation($parentA, $parentB);
  1391.     }
  1393.     public function getCountry(): ?string
  1394.     {
  1395.         return $this->country;
  1396.     }
  1398.     public function setCountry(?string $country): self
  1399.     {
  1400.         $this->country = $country;
  1402.         return $this;
  1403.     }
  1405.     public function getFunction(): ?string
  1406.     {
  1407.         return $this->function;
  1408.     }
  1410.     public function setFunction(?string $function): self
  1411.     {
  1412.         $this->function = $function;
  1414.         return $this;
  1415.     }
  1417.     public function getPhone(): ?string
  1418.     {
  1419.         return $this->phone;
  1420.     }
  1422.     public function setPhone(?string $phone): self
  1423.     {
  1424.         $this->phone = $phone;
  1426.         return $this;
  1427.     }
  1429.     public function getQuotas(): ?int
  1430.     {
  1431.         return $this->quotas;
  1432.     }
  1434.     public function setQuotas(?int $quotas): self
  1435.     {
  1436.         $this->quotas = $quotas;
  1438.         return $this;
  1439.     }
  1441.     public function getQuotasType(): ?string
  1442.     {
  1443.         return $this->quotasType;
  1444.     }
  1446.     public function setQuotasType(?string $quotasType): self
  1447.     {
  1448.         $this->quotasType = $quotasType;
  1450.         return $this;
  1451.     }
  1453.     /**
  1454.      * Checks the quotas of a User
  1455.      * @return bool true if ok, false if not ok
  1456.      */
  1457.     public function checkQuotas(): bool
  1458.     {
  1459.         $result = true;
  1460.         if ($this->getQuotasType() != self::QUOTA_NONE) {
  1461.             $span = self::QUOTAS_VAlUES[$this->getQuotasType()];
  1462.             $limit = new \DateTime("-$span");
  1463.             $count = 0;
  1464.             foreach ($this->getVideoEvents() as $videoEvent) {
  1465.                 if ($limit->diff($videoEvent->getCreatedAt())->invert == 0) {
  1466.                     $count += $videoEvent->getValue();
  1467.                 }
  1468.             }
  1469.             if ($count > $this->getQuotas()) {
  1470.                 $result = false;
  1471.             }
  1472.         }
  1473.         return $result;
  1474.     }
  1476.     public function getEmailUpdatedAt(): ?\DateTimeInterface
  1477.     {
  1478.         return $this->emailUpdatedAt;
  1479.     }
  1481.     public function setEmailUpdatedAt(?\DateTimeInterface $emailUpdatedAt): self
  1482.     {
  1483.         $this->emailUpdatedAt = $emailUpdatedAt;
  1485.         return $this;
  1486.     }
  1488.     public function getEmailValidatedAt(): ?\DateTimeInterface
  1489.     {
  1490.         return $this->emailValidatedAt;
  1491.     }
  1493.     public function setEmailValidatedAt(?\DateTimeInterface $emailValidatedAt): self
  1494.     {
  1495.         $this->emailValidatedAt = $emailValidatedAt;
  1497.         return $this;
  1498.     }
  1500.     /**
  1501.      * Checks if the email is validated
  1502.      * @return bool
  1503.      */
  1504.     public function isEmailValidated(): bool
  1505.     {
  1506.         return ($this->emailValidatedAt !== null);
  1507.     }
  1509.     /**
  1510.      * Updates the Company according to the status of the order
  1511.      * @return User
  1512.      * @ORM\PrePersist
  1513.      */
  1514.     public function updateCompany(): self
  1515.     {
  1516.         if ($this->company instanceof Company) {
  1517.             $this->company->setClientsCount($this->company->getClientsCount() + 1);
  1518.         }
  1519.         return $this;
  1520.     }
  1522.     public function getStatus(): ?string
  1523.     {
  1524.         return $this->status;
  1525.     }
  1527.     public function setStatus(?string $status): self
  1528.     {
  1529.         $this->status = $status;
  1531.         return $this;
  1532.     }
  1534.     public function getDeviceOs(): ?string
  1535.     {
  1536.         return $this->deviceOs;
  1537.     }
  1539.     public function setDeviceOs(?string $deviceOs): self
  1540.     {
  1541.         $this->deviceOs = $deviceOs;
  1543.         return $this;
  1544.     }
  1546.     public function getDeviceToken(): ?string
  1547.     {
  1548.         return $this->deviceToken;
  1549.     }
  1551.     public function setDeviceToken(?string $deviceToken): self
  1552.     {
  1553.         $this->deviceToken = $deviceToken;
  1555.         return $this;
  1556.     }
  1558.     public function getDeviceName(): ?string
  1559.     {
  1560.         return $this->deviceName;
  1561.     }
  1563.     public function setDeviceName(?string $deviceName): self
  1564.     {
  1565.         $this->deviceName = $deviceName;
  1567.         return $this;
  1568.     }
  1570.     public function isDeviceActive(): ?bool
  1571.     {
  1572.         return $this->deviceActive;
  1573.     }
  1575.     public function setDeviceActive(?bool $deviceActive): self
  1576.     {
  1577.         $this->deviceActive = $deviceActive;
  1579.         return $this;
  1580.     }
  1582.     public function getDeviceUpdate(): ?\DateTimeInterface
  1583.     {
  1584.         return $this->deviceUpdate;
  1585.     }
  1587.     public function setDeviceUpdate(?\DateTimeInterface $deviceUpdate): self
  1588.     {
  1589.         $this->deviceUpdate = $deviceUpdate;
  1591.         return $this;
  1592.     }
  1594.     /**
  1595.      * @return Collection<int, UserDevice>
  1596.      */
  1597.     public function getDevices(): Collection
  1598.     {
  1599.         return $this->devices;
  1600.     }
  1602.     public function addDevice(UserDevice $device): self
  1603.     {
  1604.         if (!$this->devices->contains($device)) {
  1605.             $this->devices[] = $device;
  1606.             $device->setUser($this);
  1607.         }
  1609.         return $this;
  1610.     }
  1612.     public function removeDevice(UserDevice $device): self
  1613.     {
  1614.         if ($this->devices->removeElement($device)) {
  1615.             // set the owning side to null (unless already changed)
  1616.             if ($device->getUser() === $this) {
  1617.                 $device->setUser(null);
  1618.             }
  1619.         }
  1621.         return $this;
  1622.     }
  1624.     public function getNewsletter(): ?bool
  1625.     {
  1626.         return $this->newsletter;
  1627.     }
  1629.     public function setNewsletter(?bool $newsletter): self
  1630.     {
  1631.         $this->newsletter = $newsletter;
  1633.         return $this;
  1634.     }
  1636.     public function getNewsletterDate(): ?\DateTimeInterface
  1637.     {
  1638.         return $this->newsletterDate;
  1639.     }
  1641.     public function setNewsletterDate(?\DateTimeInterface $newsletterDate): self
  1642.     {
  1643.         $this->newsletterDate = $newsletterDate;
  1645.         return $this;
  1646.     }
  1648.     /**
  1649.      * @param bool $firstLogin
  1650.      * @return User
  1651.      */
  1652.     public function setFirstLogin(bool $firstLogin): User
  1653.     {
  1654.         $this->firstLogin = $firstLogin;
  1655.         return $this;
  1656.     }
  1658.     /**
  1659.      * @return bool
  1660.      */
  1661.     public function isFirstLogin(): bool
  1662.     {
  1663.         return $this->firstLogin;
  1664.     }
  1666.     /**
  1667.      * @param bool $homeSurvey
  1668.      * @return User
  1669.      */
  1670.     public function setHomeSurvey(bool $homeSurvey): User
  1671.     {
  1672.         $this->homeSurvey = $homeSurvey;
  1673.         return $this;
  1674.     }
  1676.     /**
  1677.      * @return bool
  1678.      */
  1679.     public function isHomeSurvey(): bool
  1680.     {
  1681.         return $this->homeSurvey;
  1682.     }
  1684.     public function getDisplayTeamplayTuto(): ?bool
  1685.     {
  1686.         return $this->displayTeamplayTuto;
  1687.     }
  1689.     public function setDisplayTeamplayTuto(?bool $displayTeamplayTuto): self
  1690.     {
  1691.         $this->displayTeamplayTuto = $displayTeamplayTuto;
  1693.         return $this;
  1694.     }
  1696.     /**
  1697.      * @return Collection|Log[]
  1698.      */
  1699.     public function getLogs(): Collection
  1700.     {
  1701.         return $this->logs;
  1702.     }
  1704.     public function addLog(Log $log): self
  1705.     {
  1706.         if (!$this->logs->contains($log)) {
  1707.             $this->logs[] = $log;
  1708.             $log->setUser($this);
  1709.         }
  1711.         return $this;
  1712.     }
  1714.     public function removeLog(Log $log): self
  1715.     {
  1716.         if ($this->logs->removeElement($log)) {
  1717.             // set the owning side to null (unless already changed)
  1718.             if ($log->getUser() === $this) {
  1719.                 $log->setUser(null);
  1720.             }
  1721.         }
  1723.         return $this;
  1724.     }
  1726.     /**
  1727.      * @return Collection|Message[]
  1728.      */
  1729.     public function getMessages(): Collection
  1730.     {
  1731.         return $this->messages;
  1732.     }
  1734.     public function addMessage(Message $message): self
  1735.     {
  1736.         if (!$this->messages->contains($message)) {
  1737.             $this->messages[] = $message;
  1738.             $message->setUser($this);
  1739.         }
  1741.         return $this;
  1742.     }
  1744.     public function removeMessage(Message $message): self
  1745.     {
  1746.         if ($this->messages->removeElement($message)) {
  1747.             // set the owning side to null (unless already changed)
  1748.             if ($message->getUser() === $this) {
  1749.                 $message->setUser(null);
  1750.             }
  1751.         }
  1753.         return $this;
  1754.     }
  1756.     /**
  1757.      * @return Collection|VideoEvent[]
  1758.      */
  1759.     public function getVideoEvents(): Collection
  1760.     {
  1761.         return $this->videoEvents;
  1762.     }
  1764.     public function addVideoEvent(VideoEvent $videoEvent): self
  1765.     {
  1766.         if (!$this->videoEvents->contains($videoEvent)) {
  1767.             $this->videoEvents[] = $videoEvent;
  1768.             $videoEvent->setUser($this);
  1769.         }
  1771.         return $this;
  1772.     }
  1774.     public function removeVideoEvent(VideoEvent $videoEvent): self
  1775.     {
  1776.         if ($this->videoEvents->removeElement($videoEvent)) {
  1777.             // set the owning side to null (unless already changed)
  1778.             if ($videoEvent->getUser() === $this) {
  1779.                 $videoEvent->setUser(null);
  1780.             }
  1781.         }
  1783.         return $this;
  1784.     }
  1786.     /**
  1787.      * @return Collection|UserResponse[]
  1788.      */
  1789.     public function getUserResponses(): Collection
  1790.     {
  1791.         return $this->userResponses;
  1792.     }
  1794.     public function addUserResponse(UserResponse $userResponse): self
  1795.     {
  1796.         if (!$this->userResponses->contains($userResponse)) {
  1797.             $this->userResponses[] = $userResponse;
  1798.             $userResponse->setUser($this);
  1799.         }
  1801.         return $this;
  1802.     }
  1804.     public function removeUserResponse(UserResponse $userResponse): self
  1805.     {
  1806.         if ($this->userResponses->removeElement($userResponse)) {
  1807.             // set the owning side to null (unless already changed)
  1808.             if ($userResponse->getUser() === $this) {
  1809.                 $userResponse->setUser(null);
  1810.             }
  1811.         }
  1813.         return $this;
  1814.     }
  1816.     /**
  1817.      * @return Collection|Favorite[]
  1818.      */
  1819.     public function getTvFavorites(): Collection
  1820.     {
  1821.         return $this->tvFavorites;
  1822.     }
  1824.     public function addTvFavorite(Favorite $tvFavorite): self
  1825.     {
  1826.         if (!$this->tvFavorites->contains($tvFavorite)) {
  1827.             $this->tvFavorites[] = $tvFavorite;
  1828.         }
  1830.         return $this;
  1831.     }
  1833.     public function removeTvFavorite(Favorite $tvFavorite): self
  1834.     {
  1835.         $this->tvFavorites->removeElement($tvFavorite);
  1837.         return $this;
  1838.     }
  1840.     /**
  1841.      * @return Collection|LogEmail[]
  1842.      */
  1843.     public function getLogEmails(): Collection
  1844.     {
  1845.         return $this->logEmails;
  1846.     }
  1848.     public function addLogEmail(LogEmail $logEmail): self
  1849.     {
  1850.         if (!$this->logEmails->contains($logEmail)) {
  1851.             $this->logEmails[] = $logEmail;
  1852.             $logEmail->setUser($this);
  1853.         }
  1855.         return $this;
  1856.     }
  1858.     public function removeLogEmail(LogEmail $logEmail): self
  1859.     {
  1860.         if ($this->logEmails->removeElement($logEmail)) {
  1861.             // set the owning side to null (unless already changed)
  1862.             if ($logEmail->getUser() === $this) {
  1863.                 $logEmail->setUser(null);
  1864.             }
  1865.         }
  1867.         return $this;
  1868.     }
  1870.     /**
  1871.      * @return Collection|Playlist[]
  1872.      */
  1873.     public function getPlaylists(): Collection
  1874.     {
  1875.         return $this->playlists;
  1876.     }
  1878.     public function addPlaylist(Playlist $playlist): self
  1879.     {
  1880.         if (!$this->playlists->contains($playlist)) {
  1881.             $this->playlists[] = $playlist;
  1882.             $playlist->setUser($this);
  1883.         }
  1885.         return $this;
  1886.     }
  1888.     public function removePlaylist(Playlist $playlist): self
  1889.     {
  1890.         if ($this->playlists->removeElement($playlist)) {
  1891.             // set the owning side to null (unless already changed)
  1892.             if ($playlist->getUser() === $this) {
  1893.                 $playlist->setUser(null);
  1894.             }
  1895.         }
  1897.         return $this;
  1898.     }
  1900.     /**
  1901.      * @Groups({"user:write"})
  1902.      */
  1903.     public function setAddPlaylist(Playlist $playlist): self
  1904.     {
  1905.         if (!$this->playlists->contains($playlist)) {
  1906.             $this->playlists[] = $playlist;
  1907.             $playlist->setUser($this);
  1908.         }
  1910.         return $this;
  1911.     }
  1913.     /**
  1914.      * @Groups({"user:write"})
  1915.      */
  1916.     public function setRemovePlaylist(Playlist $playlist): self
  1917.     {
  1918.         if ($this->playlists->removeElement($playlist)) {
  1919.             // set the owning side to null (unless already changed)
  1920.             if ($playlist->getUser() === $this) {
  1921.                 $playlist->setUser(null);
  1922.             }
  1923.         }
  1925.         return $this;
  1926.     }
  1928.     /**
  1929.      * @return Collection|Objective[]
  1930.      */
  1931.     public function getObjectives(): Collection
  1932.     {
  1933.         return $this->objectives;
  1934.     }
  1936.     /**
  1937.      * @return Collection|Objective[]
  1938.      */
  1939.     public function setObjectives(Collection $objectives): self
  1940.     {
  1941.         $this->objectives = $objectives;
  1943.         return $this;
  1944.     }
  1946.     public function addObjective(Objective $objective): self
  1947.     {
  1948.         if (!$this->objectives->contains($objective)) {
  1949.             $this->objectives[] = $objective;
  1950.             $objective->addUser($this);
  1951.         }
  1953.         return $this;
  1954.     }
  1956.     public function removeObjective(Objective $objective): self
  1957.     {
  1958.         if ($this->objectives->removeElement($objective)) {
  1959.             $objective->removeUser($this);
  1960.         }
  1962.         return $this;
  1963.     }
  1965.     /**
  1966.      * @return Collection|TeamUser[]
  1967.      */
  1968.     public function getTeamUsers(): Collection
  1969.     {
  1970.         return $this->teamUsers;
  1971.     }
  1973.     public function addTeamUser(TeamUser $teamUser): self
  1974.     {
  1975.         if (!$this->teamUsers->contains($teamUser)) {
  1976.             $this->teamUsers[] = $teamUser;
  1977.             $teamUser->setUser($this);
  1978.         }
  1980.         return $this;
  1981.     }
  1983.     public function removeTeamUser(TeamUser $teamUser): self
  1984.     {
  1985.         if ($this->teamUsers->removeElement($teamUser)) {
  1986.             // set the owning side to null (unless already changed)
  1987.             if ($teamUser->getUser() === $this) {
  1988.                 $teamUser->setUser(null);
  1989.             }
  1990.         }
  1992.         return $this;
  1993.     }
  1995.     /**
  1996.      * @return Collection|TeamplayLog[]
  1997.      */
  1998.     public function getTeamplayLogs(): Collection
  1999.     {
  2000.         return $this->teamplayLogs;
  2001.     }
  2003.     public function addTeamplayLog(TeamplayLog $teamplayLog): self
  2004.     {
  2005.         if (!$this->teamplayLogs->contains($teamplayLog)) {
  2006.             $this->teamplayLogs[] = $teamplayLog;
  2007.             $teamplayLog->setUser($this);
  2008.         }
  2010.         return $this;
  2011.     }
  2013.     public function removeTeamplayLog(TeamplayLog $teamplayLog): self
  2014.     {
  2015.         if ($this->teamplayLogs->removeElement($teamplayLog)) {
  2016.             // set the owning side to null (unless already changed)
  2017.             if ($teamplayLog->getUser() === $this) {
  2018.                 $teamplayLog->setUser(null);
  2019.             }
  2020.         }
  2022.         return $this;
  2023.     }
  2025.     /**
  2026.      * @return Collection|PedometerLog[]
  2027.      */
  2028.     public function getPedometerLogs(): Collection
  2029.     {
  2030.         return $this->pedometerLogs;
  2031.     }
  2033.     public function addPedometerLog(PedometerLog $pedometerLog): self
  2034.     {
  2035.         if (!$this->pedometerLogs->contains($pedometerLog)) {
  2036.             $this->pedometerLogs[] = $pedometerLog;
  2037.             $pedometerLog->setUser($this);
  2038.         }
  2040.         return $this;
  2041.     }
  2043.     public function removePedometerLog(PedometerLog $pedometerLog): self
  2044.     {
  2045.         if ($this->pedometerLogs->removeElement($pedometerLog)) {
  2046.             // set the owning side to null (unless already changed)
  2047.             if ($pedometerLog->getUser() === $this) {
  2048.                 $pedometerLog->setUser(null);
  2049.             }
  2050.         }
  2052.         return $this;
  2053.     }
  2055.     /**
  2056.      * @return Collection<int, UserNotification>
  2057.      */
  2058.     public function getUserNotifications(): Collection
  2059.     {
  2060.         return $this->userNotifications;
  2061.     }
  2063.     public function addUserNotification(UserNotification $userNotification): self
  2064.     {
  2065.         if (!$this->userNotifications->contains($userNotification)) {
  2066.             $this->userNotifications[] = $userNotification;
  2067.             $userNotification->setUser($this);
  2068.         }
  2070.         return $this;
  2071.     }
  2073.     public function removeUserNotification(UserNotification $userNotification): self
  2074.     {
  2075.         if ($this->userNotifications->removeElement($userNotification)) {
  2076.             // set the owning side to null (unless already changed)
  2077.             if ($userNotification->getUser() === $this) {
  2078.                 $userNotification->setUser(null);
  2079.             }
  2080.         }
  2082.         return $this;
  2083.     }
  2085.     /**
  2086.      * @return Collection|AwardLog[]
  2087.      */
  2088.     public function getAwardLogs(): Collection
  2089.     {
  2090.         return $this->awardLogs;
  2091.     }
  2093.     public function addAwardLog(AwardLog $awardLog): self
  2094.     {
  2095.         if (!$this->awardLogs->contains($awardLog)) {
  2096.             $this->awardLogs[] = $awardLog;
  2097.             $awardLog->setUser($this);
  2098.         }
  2100.         return $this;
  2101.     }
  2103.     public function removeAwardLog(AwardLog $awardLog): self
  2104.     {
  2105.         if ($this->awardLogs->removeElement($awardLog)) {
  2106.             // set the owning side to null (unless already changed)
  2107.             if ($awardLog->getUser() === $this) {
  2108.                 $awardLog->setUser(null);
  2109.             }
  2110.         }
  2112.         return $this;
  2113.     }
  2115.     /**
  2116.      * @return Collection|UserVideoTimecode[]
  2117.      */
  2118.     public function getUserVideoTimecodes(): Collection
  2119.     {
  2120.         return $this->userVideoTimecodes;
  2121.     }
  2123.     public function addUserVideoTimecode(UserVideoTimecode $userVideoTimecode): self
  2124.     {
  2125.         if (!$this->userVideoTimecodes->contains($userVideoTimecode)) {
  2126.             $this->userVideoTimecodes[] = $userVideoTimecode;
  2127.             $userVideoTimecode->setUser($this);
  2128.         }
  2130.         return $this;
  2131.     }
  2133.     public function removeUserVideoTimecode(UserVideoTimecode $userVideoTimecode): self
  2134.     {
  2135.         if ($this->userVideoTimecodes->removeElement($userVideoTimecode)) {
  2136.             // set the owning side to null (unless already changed)
  2137.             if ($userVideoTimecode->getUser() === $this) {
  2138.                 $userVideoTimecode->setUser(null);
  2139.             }
  2140.         }
  2142.         return $this;
  2143.     }
  2145.     /**
  2146.      * @return Collection|Notation[]
  2147.      */
  2148.     public function getNotations(): Collection
  2149.     {
  2150.         return $this->notations;
  2151.     }
  2153.     public function addNotation(Notation $notation): self
  2154.     {
  2155.         if (!$this->notations->contains($notation)) {
  2156.             $this->notations[] = $notation;
  2157.             $notation->setUser($this);
  2158.         }
  2160.         return $this;
  2161.     }
  2163.     public function removeNotation(Notation $notation): self
  2164.     {
  2165.         if ($this->notations->removeElement($notation)) {
  2166.             // set the owning side to null (unless already changed)
  2167.             if ($notation->getUser() === $this) {
  2168.                 $notation->setUser(null);
  2169.             }
  2170.         }
  2172.         return $this;
  2173.     }
  2175.     /**
  2176.      * @return Collection|VideoLastValidate[]
  2177.      */
  2178.     public function getVideoLastValidates(): Collection
  2179.     {
  2180.         return $this->videoLastValidates;
  2181.     }
  2183.     public function addVideoLastValidate(VideoLastValidate $videoLastValidate): self
  2184.     {
  2185.         if (!$this->videoLastValidates->contains($videoLastValidate)) {
  2186.             $this->videoLastValidates[] = $videoLastValidate;
  2187.             $videoLastValidate->setUser($this);
  2188.         }
  2190.         return $this;
  2191.     }
  2193.     public function removeVideoLastValidate(VideoLastValidate $videoLastValidate): self
  2194.     {
  2195.         if ($this->videoLastValidates->removeElement($videoLastValidate)) {
  2196.             // set the owning side to null (unless already changed)
  2197.             if ($videoLastValidate->getUser() === $this) {
  2198.                 $videoLastValidate->setUser(null);
  2199.             }
  2200.         }
  2202.         return $this;
  2203.     }
  2205.     /**
  2206.      * @return Collection|VideoLastSeen[]
  2207.      */
  2208.     public function getVideoLastSeens(): Collection
  2209.     {
  2210.         return $this->videoLastSeens;
  2211.     }
  2213.     public function addVideoLastSeen(VideoLastSeen $videoLastSeen): self
  2214.     {
  2215.         if (!$this->videoLastSeens->contains($videoLastSeen)) {
  2216.             $this->videoLastSeens[] = $videoLastSeen;
  2217.             $videoLastSeen->setUser($this);
  2218.         }
  2220.         return $this;
  2221.     }
  2223.     public function removeVideoLastSeen(VideoLastSeen $videoLastSeen): self
  2224.     {
  2225.         if ($this->videoLastSeens->removeElement($videoLastSeen)) {
  2226.             // set the owning side to null (unless already changed)
  2227.             if ($videoLastSeen->getUser() === $this) {
  2228.                 $videoLastSeen->setUser(null);
  2229.             }
  2230.         }
  2232.         return $this;
  2233.     }
  2235.     /**
  2236.      * @return Collection|MoodResponse[]
  2237.      */
  2238.     public function getMoodResponses(): Collection
  2239.     {
  2240.         return $this->moodResponses;
  2241.     }
  2243.     public function addMoodResponse(MoodResponse $moodResponse): self
  2244.     {
  2245.         if (!$this->moodResponses->contains($moodResponse)) {
  2246.             $this->moodResponses[] = $moodResponse;
  2247.             $moodResponse->setUser($this);
  2248.         }
  2250.         return $this;
  2251.     }
  2253.     public function removeMoodResponse(MoodResponse $moodResponse): self
  2254.     {
  2255.         if ($this->moodResponses->removeElement($moodResponse)) {
  2256.             // set the owning side to null (unless already changed)
  2257.             if ($moodResponse->getUser() === $this) {
  2258.                 $moodResponse->setUser(null);
  2259.             }
  2260.         }
  2262.         return $this;
  2263.     }
  2265.     /**
  2266.      * @return Collection|ProgramEvent[]
  2267.      */
  2268.     public function getProgramEvents(): Collection
  2269.     {
  2270.         return $this->programEvents;
  2271.     }
  2273.     public function addProgramEvent(ProgramEvent $programEvent): self
  2274.     {
  2275.         if (!$this->programEvents->contains($programEvent)) {
  2276.             $this->programEvents[] = $programEvent;
  2277.             $programEvent->setUser($this);
  2278.         }
  2280.         return $this;
  2281.     }
  2283.     public function removeProgramEvent(ProgramEvent $programEvent): self
  2284.     {
  2285.         if ($this->programEvents->removeElement($programEvent)) {
  2286.             // set the owning side to null (unless already changed)
  2287.             if ($programEvent->getUser() === $this) {
  2288.                 $programEvent->setUser(null);
  2289.             }
  2290.         }
  2292.         return $this;
  2293.     }
  2295.     /**
  2296.      * @return Collection|DayEvent[]
  2297.      */
  2298.     public function getDayEvents(): Collection
  2299.     {
  2300.         return $this->dayEvents;
  2301.     }
  2303.     public function addDayEvent(DayEvent $dayEvent): self
  2304.     {
  2305.         if (!$this->dayEvents->contains($dayEvent)) {
  2306.             $this->dayEvents[] = $dayEvent;
  2307.             $dayEvent->setUser($this);
  2308.         }
  2310.         return $this;
  2311.     }
  2313.     public function removeDayEvent(DayEvent $dayEvent): self
  2314.     {
  2315.         if ($this->dayEvents->removeElement($dayEvent)) {
  2316.             // set the owning side to null (unless already changed)
  2317.             if ($dayEvent->getUser() === $this) {
  2318.                 $dayEvent->setUser(null);
  2319.             }
  2320.         }
  2322.         return $this;
  2323.     }
  2325.     public function getTvUser(): ?TvUser
  2326.     {
  2327.         return $this->tvUser;
  2328.     }
  2330.     public function setTvUser(?TvUser $tvUser): self
  2331.     {
  2332.         $this->tvUser = $tvUser;
  2334.         return $this;
  2335.     }
  2337.     public function isLive(): ?bool
  2338.     {
  2339.         return $this->live;
  2340.     }
  2342.     public function setLive(bool $isLive): self
  2343.     {
  2344.         $this->live = $isLive;
  2346.         return $this;
  2347.     }
  2349.     public function isTv(): ?bool
  2350.     {
  2351.         return $this->tv;
  2352.     }
  2354.     public function setTv(bool $isTv): self
  2355.     {
  2356.         $this->tv = $isTv;
  2358.         return $this;
  2359.     }
  2361.     /**
  2362.      * @return Collection<int, Chat>
  2363.      */
  2364.     public function getChats(): Collection
  2365.     {
  2366.         return $this->chats;
  2367.     }
  2369.     public function addChat(Chat $chat): self
  2370.     {
  2371.         if (!$this->chats->contains($chat)) {
  2372.             $this->chats[] = $chat;
  2373.         }
  2375.         return $this;
  2376.     }
  2378.     public function removeChat(Chat $chat): self
  2379.     {
  2380.         $this->chats->removeElement($chat);
  2382.         return $this;
  2383.     }
  2385.     /**
  2386.      * @return Collection<int, Invoice>
  2387.      */
  2388.     public function getInvoices(): Collection
  2389.     {
  2390.         return $this->invoices;
  2391.     }
  2393.     public function addInvoice(Invoice $invoice): self
  2394.     {
  2395.         if (!$this->invoices->contains($invoice)) {
  2396.             $this->invoices->add($invoice);
  2397.             $invoice->setUser($this);
  2398.         }
  2400.         return $this;
  2401.     }
  2403.     public function removeInvoice(Invoice $invoice): self
  2404.     {
  2405.         if ($this->invoices->removeElement($invoice)) {
  2406.             // set the owning side to null (unless already changed)
  2407.             if ($invoice->getUser() === $this) {
  2408.                 $invoice->setUser(null);
  2409.             }
  2410.         }
  2412.         return $this;
  2413.     }
  2414.     public function getNotificationPreference(): ?NotificationPreference
  2415.     {
  2416.         return $this->notificationPreference;
  2417.     }
  2419.     public function setNotificationPreference(NotificationPreference $notificationPreference): static
  2420.     {
  2421.         // set the owning side of the relation if necessary
  2422.         if ($notificationPreference->getUser() !== $this) {
  2423.             $notificationPreference->setUser($this);
  2424.         }
  2426.         $this->notificationPreference = $notificationPreference;
  2428.         return $this;
  2429.     }
  2430.     public function getStravaProfile(): ?StravaProfile
  2431.     {
  2432.         return $this->stravaProfile;
  2433.     }
  2435.     public function setStravaProfile(?StravaProfile $stravaProfile): self
  2436.     {
  2437.         if ($stravaProfile !== null && $stravaProfile->getUser() !== $this) {
  2438.             $stravaProfile->setUser($this);
  2439.         }
  2440.         $this->stravaProfile = $stravaProfile;
  2441.         return $this;
  2442.     }
  2443. }