src/Entity/Season.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SeasonRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Serializer\Annotation\Groups; // Add this use statement
  12. #[ORM\Entity(repositoryClass: SeasonRepository::class)]
  13. class Season
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     #[Groups(["chat:channel:list", "chat_message"])] // Add group
  19.     private ?int $id = null;
  21.     #[ORM\Column(length: 255)]
  22.     #[Groups(["chat:channel:list", "chat_message"])] // Add group
  23.     private ?string $name = null;
  25.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  26.     private ?\DateTimeInterface $startDate = null;
  28.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  29.     private ?\DateTimeInterface $endDate = null;
  31.     #[ORM\Column]
  32.     private ?bool $isActive = null;
  34.     #[ORM\ManyToOne(inversedBy: 'seasons')]
  35.     #[ORM\JoinColumn(nullable: false)]
  36.     private ?Company $company = null;
  38.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: TeamSeason::class, orphanRemoval: true)]
  39.     private Collection $teamSeasons;
  41.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Submission::class)]
  42.     private Collection $submissions;
  44.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: ActivityConfiguration::class, orphanRemoval: true)]
  45.     private Collection $activityConfigurations;
  47.     #[ORM\Column(length: 50)]
  48.     private ?string $defaultValidationMethod = 'automatic';
  50.     #[ORM\Column(type: Types::JSON, nullable: true)]
  51.     private ?array $activityConfig = null;
  52.     
  53.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  54.     private ?string $summary = null;
  55.     
  56.     #[ORM\Column(length: 255, nullable: true)]
  57.     private ?string $imageFilename = null;
  58.     
  59.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  60.     private ?string $rewards = null;
  62.     #[ORM\OneToOne(mappedBy: 'season', cascade: ['persist', 'remove'])]
  63.     private ?SeasonGoogleChatConfig $googleChatConfig = null;
  65.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
  66.     private bool $useBalancedScoring = false;
  68.     public function __toString(): string
  69.     {
  70.         return $this->getName();
  71.     }
  73.     public function __construct()
  74.     {
  75.         $this->teamSeasons = new ArrayCollection();
  76.         $this->submissions = new ArrayCollection();
  77.         $this->activityConfigurations = new ArrayCollection();
  78.         $this->isActive = false;
  79.         $this->useBalancedScoring = false;
  80.     }
  82.     public function getId(): ?int
  83.     {
  84.         return $this->id;
  85.     }
  87.     public function getName(): ?string
  88.     {
  89.         return $this->name;
  90.     }
  92.     public function setName(string $name): static
  93.     {
  94.         $this->name = $name;
  96.         return $this;
  97.     }
  99.     public function getStartDate(): ?\DateTimeInterface
  100.     {
  101.         return $this->startDate;
  102.     }
  104.     public function setStartDate(\DateTimeInterface $startDate): static
  105.     {
  106.         $this->startDate = $startDate;
  108.         return $this;
  109.     }
  111.     public function getEndDate(): ?\DateTimeInterface
  112.     {
  113.         return $this->endDate;
  114.     }
  116.     public function setEndDate(\DateTimeInterface $endDate): static
  117.     {
  118.         $this->endDate = $endDate;
  120.         return $this;
  121.     }
  123.     public function isIsActive(): ?bool
  124.     {
  125.         return $this->isActive;
  126.     }
  128.     public function setIsActive(bool $isActive): static
  129.     {
  130.         $this->isActive = $isActive;
  132.         return $this;
  133.     }
  135.     public function getCompany(): ?Company
  136.     {
  137.         return $this->company;
  138.     }
  140.     public function setCompany(?Company $company): static
  141.     {
  142.         $this->company = $company;
  144.         return $this;
  145.     }
  147.     /**
  148.      * @return Collection<int, TeamSeason>
  149.      */
  150.     public function getTeamSeasons(): Collection
  151.     {
  152.         return $this->teamSeasons;
  153.     }
  155.     public function addTeamSeason(TeamSeason $teamSeason): static
  156.     {
  157.         if (!$this->teamSeasons->contains($teamSeason)) {
  158.             $this->teamSeasons->add($teamSeason);
  159.             $teamSeason->setSeason($this);
  160.         }
  162.         return $this;
  163.     }
  165.     public function removeTeamSeason(TeamSeason $teamSeason): static
  166.     {
  167.         if ($this->teamSeasons->removeElement($teamSeason)) {
  168.             // set the owning side to null (unless already changed)
  169.             if ($teamSeason->getSeason() === $this) {
  170.                 $teamSeason->setSeason(null);
  171.             }
  172.         }
  174.         return $this;
  175.     }
  177.     /**
  178.      * @return Collection<int, Submission>
  179.      */
  180.     public function getSubmissions(): Collection
  181.     {
  182.         return $this->submissions;
  183.     }
  185.     public function addSubmission(Submission $submission): static
  186.     {
  187.         if (!$this->submissions->contains($submission)) {
  188.             $this->submissions->add($submission);
  189.             $submission->setSeason($this);
  190.         }
  192.         return $this;
  193.     }
  195.     public function removeSubmission(Submission $submission): static
  196.     {
  197.         if ($this->submissions->removeElement($submission)) {
  198.             // set the owning side to null (unless already changed)
  199.             if ($submission->getSeason() === $this) {
  200.                 $submission->setSeason(null);
  201.             }
  202.         }
  204.         return $this;
  205.     }
  207.     /**
  208.      * Get all teams participating in this season
  209.      * 
  210.      * @return Collection<int, Team>
  211.      */
  212.     public function getTeams(): Collection
  213.     {
  214.         $teams = new ArrayCollection();
  215.         
  216.         foreach ($this->teamSeasons as $teamSeason) {
  217.             $teams->add($teamSeason->getTeam());
  218.         }
  219.         
  220.         return $teams;
  221.     }
  223.     /**
  224.      * Check if the season is currently active based on dates
  225.      */
  226.     public function isActive(): bool
  227.     {
  228.         $now = new \DateTime();
  229.         return $this->isActive && 
  230.                $this->startDate <= $now && 
  231.                $this->endDate >= $now;
  232.     }
  234.     /**
  235.      * @return Collection<int, ActivityConfiguration>
  236.      */
  237.     public function getActivityConfigurations(): Collection
  238.     {
  239.         return $this->activityConfigurations;
  240.     }
  242.     public function addActivityConfiguration(ActivityConfiguration $activityConfiguration): static
  243.     {
  244.         if (!$this->activityConfigurations->contains($activityConfiguration)) {
  245.             $this->activityConfigurations->add($activityConfiguration);
  246.             $activityConfiguration->setSeason($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeActivityConfiguration(ActivityConfiguration $activityConfiguration): static
  253.     {
  254.         if ($this->activityConfigurations->removeElement($activityConfiguration)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($activityConfiguration->getSeason() === $this) {
  257.                 $activityConfiguration->setSeason(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     public function getDefaultValidationMethod(): ?string
  265.     {
  266.         return $this->defaultValidationMethod;
  267.     }
  269.     public function setDefaultValidationMethod(string $defaultValidationMethod): static
  270.     {
  271.         $this->defaultValidationMethod = $defaultValidationMethod;
  273.         return $this;
  274.     }
  276.     public function getActivityConfig(): ?array
  277.     {
  278.         return $this->activityConfig;
  279.     }
  281.     public function setActivityConfig(?array $activityConfig): static
  282.     {
  283.         $this->activityConfig = $activityConfig;
  285.         return $this;
  286.     }
  287.     
  288.     public function getSummary(): ?string
  289.     {
  290.         return $this->summary;
  291.     }
  292.     
  293.     public function setSummary(?string $summary): static
  294.     {
  295.         $this->summary = $summary;
  296.         
  297.         return $this;
  298.     }
  299.     
  300.     public function getImageFilename(): ?string
  301.     {
  302.         return $this->imageFilename;
  303.     }
  304.     
  305.     public function setImageFilename(?string $imageFilename): static
  306.     {
  307.         $this->imageFilename = $imageFilename;
  308.         
  309.         return $this;
  310.     }
  311.     
  312.     public function getRewards(): ?string
  313.     {
  314.         return $this->rewards;
  315.     }
  316.     
  317.     public function setRewards(?string $rewards): static
  318.     {
  319.         $this->rewards = $rewards;
  320.         
  321.         return $this;
  322.     }
  324.     /**
  325.      * Get activity configuration for a specific activity
  326.      */
  327.     public function getActivityConfigurationForActivity(Activity $activity): ?ActivityConfiguration
  328.     {
  329.         foreach ($this->activityConfigurations as $activityConfiguration) {
  330.             if ($activityConfiguration->getActivity() === $activity) {
  331.                 return $activityConfiguration;
  332.             }
  333.         }
  334.         
  335.         return null;
  336.     }
  338.     /**
  339.      * Get all enabled activities for this season
  340.      *
  341.      * @return Collection<int, Activity>
  342.      */
  343.     public function getEnabledActivities(): Collection
  344.     {
  345.         $activities = new ArrayCollection();
  346.         
  347.         foreach ($this->activityConfigurations as $activityConfiguration) {
  348.             if ($activityConfiguration->isIsEnabled()) {
  349.                 $activities->add($activityConfiguration->getActivity());
  350.             }
  351.         }
  352.         
  353.         return $activities;
  354.     }
  356.     public function getGoogleChatConfig(): ?SeasonGoogleChatConfig
  357.     {
  358.         return $this->googleChatConfig;
  359.     }
  361.     public function setGoogleChatConfig(SeasonGoogleChatConfig $googleChatConfig): static
  362.     {
  363.         // set the owning side of the relation if necessary
  364.         if ($googleChatConfig->getSeason() !== $this) {
  365.             $googleChatConfig->setSeason($this);
  366.         }
  368.         $this->googleChatConfig = $googleChatConfig;
  370.         return $this;
  371.     }
  373.     public function getUseBalancedScoring(): bool
  374.     {
  375.         return $this->useBalancedScoring;
  376.     }
  378.     public function setUseBalancedScoring(bool $useBalancedScoring): static
  379.     {
  380.         $this->useBalancedScoring = $useBalancedScoring;
  382.         return $this;
  383.     }
  384. }