src/Entity/User.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Serializer\Annotation\Groups; // Add this use statement
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[ORM\Table(name: '`user`')]
  16. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column]
  22.     #[Groups(["chat:channel:list", "chat_message"])] // Add group
  23.     private ?int $id = null;
  25.     #[ORM\Column(length: 180, unique: true)]
  26.     private ?string $email = null;
  28.     #[ORM\Column]
  29.     private array $roles = [];
  31.     /**
  32.      * @var string The hashed password
  33.      */
  34.     #[ORM\Column]
  35.     private ?string $password = null;
  37.     #[ORM\Column(length: 255)]
  38.     #[Groups(["chat:channel:list", "chat_message"])] // Add group
  39.     private ?string $firstName = null;
  41.     #[ORM\Column(length: 255)]
  42.     #[Groups(["chat:channel:list", "chat_message"])] // Add group
  43.     private ?string $lastName = null;
  45.     #[ORM\Column]
  46.     private ?\DateTimeImmutable $createdAt = null;
  48.     #[ORM\ManyToOne(inversedBy: 'users')]
  49.     private ?Company $company = null;
  51.     #[ORM\OneToOne(mappedBy: 'user', cascade: ['persist', 'remove'])]
  52.     #[Groups(["chat_message"])] // Add serialization group to expose profile
  53.     private ?UserProfile $profile = null;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserTeam::class, orphanRemoval: true)]
  56.     private Collection $userTeams;
  58.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Submission::class)]
  59.     private Collection $submissions;
  61.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ChatMessage::class)]
  62.     private Collection $chatMessages;
  64.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notification::class)]
  65.     private Collection $notifications;
  67.     public function __toString(): string
  68.     {
  69.         return $this->getFullName();
  70.     }
  72.     public function __construct()
  73.     {
  74.         $this->createdAt = new \DateTimeImmutable();
  75.         $this->userTeams = new ArrayCollection();
  76.         $this->submissions = new ArrayCollection();
  77.         $this->chatMessages = new ArrayCollection();
  78.         $this->notifications = new ArrayCollection();
  79.     }
  81.     public function getId(): ?int
  82.     {
  83.         return $this->id;
  84.     }
  86.     public function getEmail(): ?string
  87.     {
  88.         return $this->email;
  89.     }
  91.     public function setEmail(string $email): static
  92.     {
  93.         $this->email = $email;
  95.         return $this;
  96.     }
  98.     /**
  99.      * A visual identifier that represents this user.
  100.      *
  101.      * @see UserInterface
  102.      */
  103.     public function getUserIdentifier(): string
  104.     {
  105.         return (string) $this->email;
  106.     }
  108.     /**
  109.      * @see UserInterface
  110.      */
  111.     public function getRoles(): array
  112.     {
  113.         $roles = $this->roles;
  114.         // guarantee every user at least has ROLE_USER
  115.         $roles[] = 'ROLE_USER';
  117.         return array_unique($roles);
  118.     }
  120.     public function setRoles(array $roles): static
  121.     {
  122.         $this->roles = $roles;
  124.         return $this;
  125.     }
  127.     /**
  128.      * @see PasswordAuthenticatedUserInterface
  129.      */
  130.     public function getPassword(): string
  131.     {
  132.         return $this->password;
  133.     }
  135.     public function setPassword(string $password): static
  136.     {
  137.         $this->password = $password;
  139.         return $this;
  140.     }
  142.     /**
  143.      * @see UserInterface
  144.      */
  145.     public function eraseCredentials(): void
  146.     {
  147.         // If you store any temporary, sensitive data on the user, clear it here
  148.         // $this->plainPassword = null;
  149.     }
  151.     public function getFirstName(): ?string
  152.     {
  153.         return $this->firstName;
  154.     }
  156.     public function setFirstName(string $firstName): static
  157.     {
  158.         $this->firstName = $firstName;
  160.         return $this;
  161.     }
  163.     public function getLastName(): ?string
  164.     {
  165.         return $this->lastName;
  166.     }
  168.     public function setLastName(string $lastName): static
  169.     {
  170.         $this->lastName = $lastName;
  172.         return $this;
  173.     }
  175.     public function getCreatedAt(): ?\DateTimeImmutable
  176.     {
  177.         return $this->createdAt;
  178.     }
  180.     public function setCreatedAt(\DateTimeImmutable $createdAt): static
  181.     {
  182.         $this->createdAt = $createdAt;
  184.         return $this;
  185.     }
  187.     #[Groups(["chat:channel:list", "chat_message"])] // Add group to the getter for fullName
  188.     public function getFullName(): string
  189.     {
  190.         return $this->firstName . ' ' . $this->lastName;
  191.     }
  193.     public function getCompany(): ?Company
  194.     {
  195.         return $this->company;
  196.     }
  198.     public function setCompany(?Company $company): static
  199.     {
  200.         $this->company = $company;
  202.         return $this;
  203.     }
  205.     public function getProfile(): ?UserProfile
  206.     {
  207.         return $this->profile;
  208.     }
  210.     public function setProfile(UserProfile $profile): static
  211.     {
  212.         // set the owning side of the relation if necessary
  213.         if ($profile->getUser() !== $this) {
  214.             $profile->setUser($this);
  215.         }
  217.         $this->profile = $profile;
  219.         return $this;
  220.     }
  222.     /**
  223.      * @return Collection<int, UserTeam>
  224.      */
  225.     public function getUserTeams(): Collection
  226.     {
  227.         return $this->userTeams;
  228.     }
  230.     public function addUserTeam(UserTeam $userTeam): static
  231.     {
  232.         if (!$this->userTeams->contains($userTeam)) {
  233.             $this->userTeams->add($userTeam);
  234.             $userTeam->setUser($this);
  235.         }
  237.         return $this;
  238.     }
  240.     public function removeUserTeam(UserTeam $userTeam): static
  241.     {
  242.         if ($this->userTeams->removeElement($userTeam)) {
  243.             // set the owning side to null (unless already changed)
  244.             if ($userTeam->getUser() === $this) {
  245.                 $userTeam->setUser(null);
  246.             }
  247.         }
  249.         return $this;
  250.     }
  252.     /**
  253.      * @return Collection<int, Submission>
  254.      */
  255.     public function getSubmissions(): Collection
  256.     {
  257.         return $this->submissions;
  258.     }
  260.     public function addSubmission(Submission $submission): static
  261.     {
  262.         if (!$this->submissions->contains($submission)) {
  263.             $this->submissions->add($submission);
  264.             $submission->setUser($this);
  265.         }
  267.         return $this;
  268.     }
  270.     public function removeSubmission(Submission $submission): static
  271.     {
  272.         if ($this->submissions->removeElement($submission)) {
  273.             // set the owning side to null (unless already changed)
  274.             if ($submission->getUser() === $this) {
  275.                 $submission->setUser(null);
  276.             }
  277.         }
  279.         return $this;
  280.     }
  282.     /**
  283.      * @return Collection<int, ChatMessage>
  284.      */
  285.     public function getChatMessages(): Collection
  286.     {
  287.         return $this->chatMessages;
  288.     }
  290.     public function addChatMessage(ChatMessage $chatMessage): static
  291.     {
  292.         if (!$this->chatMessages->contains($chatMessage)) {
  293.             $this->chatMessages->add($chatMessage);
  294.             $chatMessage->setUser($this);
  295.         }
  297.         return $this;
  298.     }
  300.     public function removeChatMessage(ChatMessage $chatMessage): static
  301.     {
  302.         if ($this->chatMessages->removeElement($chatMessage)) {
  303.             // set the owning side to null (unless already changed)
  304.             if ($chatMessage->getUser() === $this) {
  305.                 $chatMessage->setUser(null);
  306.             }
  307.         }
  309.         return $this;
  310.     }
  312.     /**
  313.      * @return Collection<int, Notification>
  314.      */
  315.     public function getNotifications(): Collection
  316.     {
  317.         return $this->notifications;
  318.     }
  320.     public function addNotification(Notification $notification): static
  321.     {
  322.         if (!$this->notifications->contains($notification)) {
  323.             $this->notifications->add($notification);
  324.             $notification->setUser($this);
  325.         }
  327.         return $this;
  328.     }
  330.     public function removeNotification(Notification $notification): static
  331.     {
  332.         if ($this->notifications->removeElement($notification)) {
  333.             // set the owning side to null (unless already changed)
  334.             if ($notification->getUser() === $this) {
  335.                 $notification->setUser(null);
  336.             }
  337.         }
  339.         return $this;
  340.     }
  342.     /**
  343.      * Get all teams the user is a member of
  344.      *
  345.      * @return Collection<int, Team>
  346.      */
  347.     public function getTeams(): Collection
  348.     {
  349.         $teams = new ArrayCollection();
  350.         
  351.         foreach ($this->userTeams as $userTeam) {
  352.             $teams->add($userTeam->getTeam());
  353.         }
  354.         
  355.         return $teams;
  356.     }
  358.     /**
  359.      * Check if user is a member of a specific team
  360.      */
  361.     public function isMemberOfTeam(Team $team): bool
  362.     {
  363.         foreach ($this->userTeams as $userTeam) {
  364.             if ($userTeam->getTeam() === $team) {
  365.                 return true;
  366.             }
  367.         }
  368.         
  369.         return false;
  370.     }
  372.     /**
  373.      * Check if user is a leader of a specific team
  374.      */
  375.     public function isLeaderOfTeam(Team $team): bool
  376.     {
  377.         foreach ($this->userTeams as $userTeam) {
  378.             if ($userTeam->getTeam() === $team && $userTeam->getRole() === 'leader') {
  379.                 return true;
  380.             }
  381.         }
  382.         
  383.         return false;
  384.     }
  385.     
  386.     /**
  387.      * Get the user's primary team (first team found)
  388.      */
  389.     public function getUserTeam(): ?UserTeam
  390.     {
  391.         if ($this->userTeams->isEmpty()) {
  392.             return null;
  393.         }
  394.         
  395.         return $this->userTeams->first();
  396.     }
  397.     
  398.     /**
  399.      * Get the user's primary team entity
  400.      */
  401.     public function getTeam(): ?Team
  402.     {
  403.         $userTeam = $this->getUserTeam();
  404.         return $userTeam ? $userTeam->getTeam() : null;
  405.     }
  407.     /**
  408.      * Get total steps for a specific season
  409.      */
  410.     public function getTotalStepsForSeason(Season $season): int
  411.     {
  412.         $totalSteps = 0;
  414.         foreach ($this->submissions as $submission) {
  415.             // Only count approved submissions for this season
  416.             if ($submission->getSeason() === $season &&
  417.                 $submission->getStatus() === 'approved' &&
  418.                 $submission->getActivityData() !== null) {
  420.                 $activityData = $submission->getActivityData();
  421.                 if (isset($activityData['steps'])) {
  422.                     $totalSteps += (int) $activityData['steps'];
  423.                 }
  424.             }
  425.         }
  427.         return $totalSteps;
  428.     }
  430.     /**
  431.      * Get lifetime total steps across all seasons
  432.      */
  433.     public function getLifetimeTotalSteps(): int
  434.     {
  435.         $totalSteps = 0;
  437.         foreach ($this->submissions as $submission) {
  438.             // Only count approved submissions
  439.             if ($submission->getStatus() === 'approved' &&
  440.                 $submission->getActivityData() !== null) {
  442.                 $activityData = $submission->getActivityData();
  443.                 if (isset($activityData['steps'])) {
  444.                     $totalSteps += (int) $activityData['steps'];
  445.                 }
  446.             }
  447.         }
  449.         return $totalSteps;
  450.     }
  451. }