src/Entity/Season.php line 22

  1. <?php
  3. namespace App\Entity;
  5. use DateTime;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Symfony\Component\Uid\Ulid;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use App\Repository\SeasonRepository;
  11. use ApiPlatform\Core\Annotation\ApiResource;
  12. use Symfony\Bridge\Doctrine\IdGenerator\UlidGenerator;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  14. use Gedmo\Mapping\Annotation as Gedmo;
  16. #[ORM\Entity(repositoryClass: SeasonRepository::class)]
  17. #[Gedmo\SoftDeleteable(fieldName: 'deletedAt', timeAware: false, hardDelete: true)]
  18. #[ORM\HasLifecycleCallbacks]
  19. #[ApiResource(
  20.     attributes: ["security" => "is_granted('IS_AUTHENTICATED_FULLY')"],
  21. )]
  22. class Season
  23. {
  24.     use Timestamps;
  26.     #[ORM\Id]
  27.     #[ORM\Column(type: 'ulid', unique: true)]
  28.     #[ORM\GeneratedValue(strategy: "CUSTOM")]
  29.     #[ORM\CustomIdGenerator(class: UlidGenerator::class)]
  30.     #[Groups('read:season:basic')]
  31.     private ?Ulid $id = null;
  33.     #[ORM\Column(type: 'string', length: 255)]
  34.     #[Groups('read:season:basic')]
  35.     private $name;
  37.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  38.     #[Groups('read:season:basic')]
  39.     private $description;
  41.     #[ORM\Column(type: 'datetime')]
  42.     #[Groups('read:season:basic')]
  43.     private $start_date;
  45.     #[ORM\Column(type: 'datetime')]
  46.     #[Groups('read:season:basic')]
  47.     private $end_date;
  49.     #[ORM\ManyToOne(targetEntity: Company::class, inversedBy: 'seasons')]
  50.     #[ORM\JoinColumn(nullable: false)]
  51.     private $owner;
  53.     #[ORM\Column(type: 'boolean')]
  54.     private $is_active = false;
  56.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Subscription::class, orphanRemoval: true)]
  57.     private $subscriptions;
  59.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Classroom::class, orphanRemoval: true)]
  60.     private $classrooms;
  62.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Task::class, orphanRemoval: true)]
  63.     private $tasks;
  65.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Evenement::class, orphanRemoval: true)]
  66.     private $evenements;
  68.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Payment::class, orphanRemoval: true)]
  69.     private $payments;
  71.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Expense::class, orphanRemoval: true)]
  72.     private $expenses;
  74.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: AbsenceEmployee::class, orphanRemoval: true)]
  75.     private $absenceEmployees;
  77.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Child::class, orphanRemoval: true)]
  78.     private $children;
  80.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: FamilyMember::class, orphanRemoval: true)]
  81.     private $familyMembers;
  83.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Employee::class, orphanRemoval: true)]
  84.     private $employees;
  86.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Pointing::class, orphanRemoval: true)]
  87.     private $pointings;
  89.     function __construct()
  90.     {
  91.         $this->start_date = new DateTime();
  92.         $this->end_date = new DateTime();
  93.         $this->subscriptions = new ArrayCollection();
  94.         $this->classrooms = new ArrayCollection();
  95.         $this->tasks = new ArrayCollection();
  96.         $this->evenements = new ArrayCollection();
  97.         $this->payments = new ArrayCollection();
  98.         $this->expenses = new ArrayCollection();
  99.         $this->absenceChildren = new ArrayCollection();
  100.         $this->absenceEmployees = new ArrayCollection();
  101.         $this->children = new ArrayCollection();
  102.         $this->familyMembers = new ArrayCollection();
  103.         $this->employees = new ArrayCollection();
  104.         $this->pointings = new ArrayCollection();
  105.     }
  107.     public function __toString()
  108.     {
  109.         return $this->name;
  110.     }
  112.     public function getId(): ?Ulid
  113.     {
  114.         return $this->id;
  115.     }
  117.     public function getName(): ?string
  118.     {
  119.         return $this->name;
  120.     }
  122.     public function setName(string $name): self
  123.     {
  124.         $this->name = $name;
  126.         return $this;
  127.     }
  129.     public function getDescription(): ?string
  130.     {
  131.         return $this->description;
  132.     }
  134.     public function setDescription(?string $description): self
  135.     {
  136.         $this->description = $description;
  138.         return $this;
  139.     }
  141.     public function getStartDate(): ?\DateTimeInterface
  142.     {
  143.         return $this->start_date;
  144.     }
  146.     public function setStartDate(\DateTimeInterface $start_date): self
  147.     {
  148.         $this->start_date = $start_date;
  150.         return $this;
  151.     }
  153.     public function getEndDate(): ?\DateTimeInterface
  154.     {
  155.         return $this->end_date;
  156.     }
  158.     public function setEndDate(\DateTimeInterface $end_date): self
  159.     {
  160.         $this->end_date = $end_date;
  162.         return $this;
  163.     }
  165.     public function getOwner(): ?Company
  166.     {
  167.         return $this->owner;
  168.     }
  170.     public function setOwner(?Company $owner): self
  171.     {
  172.         $this->owner = $owner;
  174.         return $this;
  175.     }
  177.     public function isIsActive(): ?bool
  178.     {
  179.         return $this->is_active;
  180.     }
  182.     public function setIsActive(bool $is_active): self
  183.     {
  184.         $this->is_active = $is_active;
  186.         return $this;
  187.     }
  189.     /**
  190.      * @return Collection<int, Subscription>
  191.      */
  192.     public function getSubscriptions(): Collection
  193.     {
  194.         return $this->subscriptions;
  195.     }
  197.     public function addSubscription(Subscription $subscription): self
  198.     {
  199.         if (!$this->subscriptions->contains($subscription)) {
  200.             $this->subscriptions[] = $subscription;
  201.             $subscription->setSeason($this);
  202.         }
  204.         return $this;
  205.     }
  207.     public function removeSubscription(Subscription $subscription): self
  208.     {
  209.         if ($this->subscriptions->removeElement($subscription)) {
  210.             // set the owning side to null (unless already changed)
  211.             if ($subscription->getSeason() === $this) {
  212.                 $subscription->setSeason(null);
  213.             }
  214.         }
  216.         return $this;
  217.     }
  219.     /**
  220.      * @return Collection<int, Classroom>
  221.      */
  222.     public function getClassrooms(): Collection
  223.     {
  224.         return $this->classrooms;
  225.     }
  227.     public function addClassroom(Classroom $classroom): self
  228.     {
  229.         if (!$this->classrooms->contains($classroom)) {
  230.             $this->classrooms[] = $classroom;
  231.             $classroom->setSeason($this);
  232.         }
  234.         return $this;
  235.     }
  237.     public function removeClassroom(Classroom $classroom): self
  238.     {
  239.         if ($this->classrooms->removeElement($classroom)) {
  240.             // set the owning side to null (unless already changed)
  241.             if ($classroom->getSeason() === $this) {
  242.                 $classroom->setSeason(null);
  243.             }
  244.         }
  246.         return $this;
  247.     }
  249.     /**
  250.      * @return Collection<int, Task>
  251.      */
  252.     public function getTasks(): Collection
  253.     {
  254.         return $this->tasks;
  255.     }
  257.     public function addTask(Task $task): self
  258.     {
  259.         if (!$this->tasks->contains($task)) {
  260.             $this->tasks[] = $task;
  261.             $task->setSeason($this);
  262.         }
  264.         return $this;
  265.     }
  267.     public function removeTask(Task $task): self
  268.     {
  269.         if ($this->tasks->removeElement($task)) {
  270.             // set the owning side to null (unless already changed)
  271.             if ($task->getSeason() === $this) {
  272.                 $task->setSeason(null);
  273.             }
  274.         }
  276.         return $this;
  277.     }
  279.     /**
  280.      * @return Collection<int, Evenement>
  281.      */
  282.     public function getEvenements(): Collection
  283.     {
  284.         return $this->evenements;
  285.     }
  287.     public function addEvenement(Evenement $evenement): self
  288.     {
  289.         if (!$this->evenements->contains($evenement)) {
  290.             $this->evenements[] = $evenement;
  291.             $evenement->setSeason($this);
  292.         }
  294.         return $this;
  295.     }
  297.     public function removeEvenement(Evenement $evenement): self
  298.     {
  299.         if ($this->evenements->removeElement($evenement)) {
  300.             // set the owning side to null (unless already changed)
  301.             if ($evenement->getSeason() === $this) {
  302.                 $evenement->setSeason(null);
  303.             }
  304.         }
  306.         return $this;
  307.     }
  309.     /**
  310.      * @return Collection<int, Payment>
  311.      */
  312.     public function getPayments(): Collection
  313.     {
  314.         return $this->payments;
  315.     }
  317.     public function addPayment(Payment $payment): self
  318.     {
  319.         if (!$this->payments->contains($payment)) {
  320.             $this->payments[] = $payment;
  321.             $payment->setSeason($this);
  322.         }
  324.         return $this;
  325.     }
  327.     public function removePayment(Payment $payment): self
  328.     {
  329.         if ($this->payments->removeElement($payment)) {
  330.             // set the owning side to null (unless already changed)
  331.             if ($payment->getSeason() === $this) {
  332.                 $payment->setSeason(null);
  333.             }
  334.         }
  336.         return $this;
  337.     }
  339.     /**
  340.      * @return Collection<int, Expense>
  341.      */
  342.     public function getExpenses(): Collection
  343.     {
  344.         return $this->expenses;
  345.     }
  347.     public function addExpense(Expense $expense): self
  348.     {
  349.         if (!$this->expenses->contains($expense)) {
  350.             $this->expenses[] = $expense;
  351.             $expense->setSeason($this);
  352.         }
  354.         return $this;
  355.     }
  357.     public function removeExpense(Expense $expense): self
  358.     {
  359.         if ($this->expenses->removeElement($expense)) {
  360.             // set the owning side to null (unless already changed)
  361.             if ($expense->getSeason() === $this) {
  362.                 $expense->setSeason(null);
  363.             }
  364.         }
  366.         return $this;
  367.     }
  369.     /**
  370.      * @return Collection<int, AbsenceEmployee>
  371.      */
  372.     public function getAbsenceEmployees(): Collection
  373.     {
  374.         return $this->absenceEmployees;
  375.     }
  377.     public function addAbsenceEmployee(AbsenceEmployee $absenceEmployee): self
  378.     {
  379.         if (!$this->absenceEmployees->contains($absenceEmployee)) {
  380.             $this->absenceEmployees[] = $absenceEmployee;
  381.             $absenceEmployee->setSeason($this);
  382.         }
  384.         return $this;
  385.     }
  387.     public function removeAbsenceEmployee(AbsenceEmployee $absenceEmployee): self
  388.     {
  389.         if ($this->absenceEmployees->removeElement($absenceEmployee)) {
  390.             // set the owning side to null (unless already changed)
  391.             if ($absenceEmployee->getSeason() === $this) {
  392.                 $absenceEmployee->setSeason(null);
  393.             }
  394.         }
  396.         return $this;
  397.     }
  399.     /**
  400.      * @return Collection<int, Child>
  401.      */
  402.     public function getChildren(): Collection
  403.     {
  404.         return $this->children;
  405.     }
  407.     public function addChild(Child $child): self
  408.     {
  409.         if (!$this->children->contains($child)) {
  410.             $this->children[] = $child;
  411.             $child->setSeason($this);
  412.         }
  414.         return $this;
  415.     }
  417.     public function removeChild(Child $child): self
  418.     {
  419.         if ($this->children->removeElement($child)) {
  420.             // set the owning side to null (unless already changed)
  421.             if ($child->getSeason() === $this) {
  422.                 $child->setSeason(null);
  423.             }
  424.         }
  426.         return $this;
  427.     }
  429.     /**
  430.      * @return Collection<int, FamilyMember>
  431.      */
  432.     public function getFamilyMembers(): Collection
  433.     {
  434.         return $this->familyMembers;
  435.     }
  437.     public function addFamilyMember(FamilyMember $familyMember): self
  438.     {
  439.         if (!$this->familyMembers->contains($familyMember)) {
  440.             $this->familyMembers[] = $familyMember;
  441.             $familyMember->setSeason($this);
  442.         }
  444.         return $this;
  445.     }
  447.     public function removeFamilyMember(FamilyMember $familyMember): self
  448.     {
  449.         if ($this->familyMembers->removeElement($familyMember)) {
  450.             // set the owning side to null (unless already changed)
  451.             if ($familyMember->getSeason() === $this) {
  452.                 $familyMember->setSeason(null);
  453.             }
  454.         }
  456.         return $this;
  457.     }
  459.     /**
  460.      * @return Collection<int, Employee>
  461.      */
  462.     public function getEmployees(): Collection
  463.     {
  464.         return $this->employees;
  465.     }
  467.     public function addEmployee(Employee $employee): self
  468.     {
  469.         if (!$this->employees->contains($employee)) {
  470.             $this->employees[] = $employee;
  471.             $employee->setSeason($this);
  472.         }
  474.         return $this;
  475.     }
  477.     public function removeEmployee(Employee $employee): self
  478.     {
  479.         if ($this->employees->removeElement($employee)) {
  480.             // set the owning side to null (unless already changed)
  481.             if ($employee->getSeason() === $this) {
  482.                 $employee->setSeason(null);
  483.             }
  484.         }
  486.         return $this;
  487.     }
  489.     /**
  490.      * @return Collection<int, Pointing>
  491.      */
  492.     public function getPointings(): Collection
  493.     {
  494.         return $this->pointings;
  495.     }
  497.     public function addPointing(Pointing $pointing): self
  498.     {
  499.         if (!$this->pointings->contains($pointing)) {
  500.             $this->pointings[] = $pointing;
  501.             $pointing->setSeason($this);
  502.         }
  504.         return $this;
  505.     }
  507.     public function removePointing(Pointing $pointing): self
  508.     {
  509.         if ($this->pointings->removeElement($pointing)) {
  510.             // set the owning side to null (unless already changed)
  511.             if ($pointing->getSeason() === $this) {
  512.                 $pointing->setSeason(null);
  513.             }
  514.         }
  516.         return $this;
  517.     }
  518. }