src/Entity/Training/Schedule.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Training;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Entity\Schoolyear;
  7. use App\Repository\Training\ScheduleRepository;
  8. use App\Traits\Actions;
  9. use DateTime;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Doctrine\ORM\Mapping as ORM;
  14. #[ORM\Entity(repositoryClass: ScheduleRepository::class)]
  15. #[ORM\Table(name: 'hs_tc_training_schedule')]
  16. #[ApiResource]
  17. class Schedule
  18. {
  19.     use Actions;
  21.     #[ORM\ManyToOne(inversedBy: 'schedules')]
  22.     #[ORM\JoinColumn(nullable: false)]
  23.     private ?Groupe $groupe = null;
  25.     #[ORM\Column]
  26.     private ?string $semester = null;
  29.     #[ORM\Column(nullable: true)]
  30.     private ?\DateTimeImmutable $startAt = null;
  32.     #[ORM\Column(nullable: true)]
  33.     private ?\DateTimeImmutable $endAt = null;
  35.     #[ORM\OneToMany(mappedBy: 'schedule', targetEntity: Scheduleitem::class, orphanRemoval: true)]
  36.     #[ORM\OrderBy(["day" => "ASC", "startAt" => "ASC"])]
  37.     private Collection $scheduleitems;
  39.     #[ORM\OneToMany(mappedBy: 'schedule', targetEntity: Scheduleevent::class, orphanRemoval: true)]
  40.     #[ORM\OrderBy(["takesplaceOn" => "ASC", "startAt" => "ASC"])]
  41.     private Collection $scheduleevents;
  44.     #[ORM\Column(length: 255)]
  45.     private ?string $slug = null;
  48.     public function __construct()
  49.     {
  50.         // date_default_timezone_set('Africa/Casablanca');
  51.         $this->createAt=new \DateTime('now');
  52.         $this->published=true;
  53.         $this->scheduleitems = new ArrayCollection();
  54.         $this->slug=uniqid("schedule-");
  55.     }
  58.     public function getGroupe(): ?Groupe
  59.     {
  60.         return $this->groupe;
  61.     }
  63.     public function setGroupe(?Groupe $groupe): self
  64.     {
  65.         $this->groupe = $groupe;
  67.         return $this;
  68.     }
  70.     public function getSemester(): ?string
  71.     {
  72.         return $this->semester;
  73.     }
  75.     public function setSemester(?string $semester): void
  76.     {
  77.         $this->semester = $semester;
  78.     }
  83.     public function getStartAt(): ?\DateTimeImmutable
  84.     {
  85.         return $this->startAt;
  86.     }
  88.     public function setStartAt(?\DateTimeImmutable $startAt): self
  89.     {
  90.         $this->startAt = $startAt;
  92.         return $this;
  93.     }
  95.     public function getEndAt(): ?\DateTimeImmutable
  96.     {
  97.         return $this->endAt;
  98.     }
  100.     public function setEndAt(?\DateTimeImmutable $endAt): self
  101.     {
  102.         $this->endAt = $endAt;
  104.         return $this;
  105.     }
  107.     /**
  108.      * @return Collection<int, Scheduleitem>
  109.      */
  110.     public function getScheduleitems(): Collection
  111.     {
  112.         return $this->scheduleitems;
  113.     }
  115.     public function addScheduleitem(Scheduleitem $scheduleitem): self
  116.     {
  117.         if (!$this->scheduleitems->contains($scheduleitem)) {
  118.             $this->scheduleitems->add($scheduleitem);
  119.             $scheduleitem->setSchedule($this);
  120.         }
  122.         return $this;
  123.     }
  125.     public function removeScheduleitem(Scheduleitem $scheduleitem): self
  126.     {
  127.         if ($this->scheduleitems->removeElement($scheduleitem)) {
  128.             // set the owning side to null (unless already changed)
  129.             if ($scheduleitem->getSchedule() === $this) {
  130.                 $scheduleitem->setSchedule(null);
  131.             }
  132.         }
  134.         return $this;
  135.     }
  136.     /**
  137.      * @return Collection<int, Scheduleevent>
  138.      */
  139.     public function getScheduleevents(): Collection
  140.     {
  141.         return $this->scheduleevents;
  142.     }
  144.     public function addScheduleevent(Scheduleevent $scheduleevent): self
  145.     {
  146.         if (!$this->scheduleevents->contains($scheduleevent)) {
  147.             $this->scheduleevents->add($scheduleevent);
  148.             $scheduleevent->setSchedule($this);
  149.         }
  151.         return $this;
  152.     }
  154.     public function removeScheduleevent(Scheduleevent $scheduleevent): self
  155.     {
  156.         if ($this->scheduleevents->removeElement($scheduleevent)) {
  157.             // set the owning side to null (unless already changed)
  158.             if ($scheduleevent->getSchedule() === $this) {
  159.                 $scheduleevent->setSchedule(null);
  160.             }
  161.         }
  163.         return $this;
  164.     }
  165.     public function getSlug()
  166.     {
  167.         return $this->slug;
  168.     }
  170.     public function setSlug($slug)
  171.     {
  172.         $this->slug = $slug;
  173.     }
  175.     function getDayName($dayNumber) {
  176.         // Vérifie si le jour est entre 1 et 7
  177.         if ($dayNumber < 1 || $dayNumber > 7) {
  178.             return "Jour invalide";
  179.         }
  181.         // Utilise strftime() pour obtenir le nom du jour en français
  182.         setlocale(LC_TIME, 'fr_FR.utf8'); // Configuration de la localisation en français
  183.         return strftime('%A', strtotime("Sunday +{$dayNumber} days"));
  184.     }
  185.     public function isCurrent(): bool
  186.     {
  187.         $today = new \DateTime(); // Crée un objet DateTime représentant aujourd'hui
  189.         // Vérifie si la date d'aujourd'hui est entre startAt et endAt
  190.         return $today >= $this->startAt && $today <= $this->endAt;
  191.     }
  192.     public function __toString(){
  193.         return $this->getStartAt()->format('d/m/Y').' - '.$this->getEndAt()->format('d/m/Y');
  194.     }
  195.     public function getScheduleItemsDay(int $day)
  196.     {
  197.         $items=new ArrayCollection();
  198.         foreach ($this->scheduleitems as $item){
  199.             if($item->getDay()== $day) $items->add($item);
  200.         }
  201.         return $items;
  202.     }
  203.     public function getScheduleEventsDay(int $day)
  204.     {
  205.         $items=new ArrayCollection();
  206.         foreach ($this->scheduleevents as $item){
  207.             if($item->getDay()== $day) $items->add($item);
  208.         }
  209.         return $items;
  210.     }
  211.     public function getLevel(){
  212.         return match ($this->semester) {
  213.             'Semester 2', 'Semester 1' => '1ère année',
  214.             'Semester 3', 'Semester 4' => '2ème année',
  215.             'Semester 5', 'Semester 6' => '3ème année',
  216.             default => '',
  217.         };
  218.     }
  219.     public function getWeeks()
  220.     {
  221.         $startAt=$this->getStartAt();
  222.         $endAt=$this->getEndAt();
  223.         $weeks = [];
  224.         $currentStart = $startAt; // Pas besoin de clone car DateTimeImmutable est immuable
  226.         while ($currentStart <= $endAt) {
  227.             // Calculer la fin de la semaine (jusqu'à samedi ou endAt)
  228.             $currentEnd = $currentStart->modify('next saturday');
  230.             // Si la date de fin dépasse la vraie date de fin (endAt), on ajuste
  231.             if ($currentEnd > $endAt) {
  232.                 $currentEnd = $endAt;
  233.             }
  235.             // Ajouter la période dans le tableau des semaines
  236.             $weeks[] = [
  237.                 'startAt' => $currentStart,
  238.                 'endAt' => $currentEnd
  239.             ];
  241.             // Passer à la semaine suivante (lundi)
  242.             $currentStart = $currentEnd->modify('+2 day');
  243.         }
  245.         return $weeks;
  246.     }
  248.     public function getMonths(): array
  249.     {
  250.         $startAt=$this->getStartAt();
  251.         $endAt=$this->getEndAt();
  253.         $months = [];
  254.         $currentStart = $startAt;
  256.         while ($currentStart <= $endAt) {
  257.             // Déterminer le dernier jour du mois en cours
  258.             $currentEnd = $currentStart->modify('last day of this month');
  260.             // Si le dernier jour calculé dépasse la date de fin (endAt), on ajuste
  261.             if ($currentEnd > $endAt) {
  262.                 $currentEnd = $endAt;
  263.             }
  265.             // Ajouter la période dans le tableau des mois
  266.             $months[] = [
  267.                 'startAt' => $currentStart,
  268.                 'endAt' => $currentEnd
  269.             ];
  271.             // Passer au premier jour du mois suivant
  272.             $currentStart = $currentStart->modify('first day of next month');
  273.         }
  275.         return $months;
  276.     }
  277.     public function getSeances()
  278.     {
  279.         $allSeances = [];
  281.         // Parcourir chaque ScheduleItem
  282.         foreach ($this->getScheduleItems() as $scheduleItem) {
  283.             // Ajouter chaque séance de ScheduleItem à la collection $allSeances
  284.             foreach ($scheduleItem->getSeances() as $seance) {
  285.                 $allSeances[]=$seance;
  286.             }
  287.         }
  288.         usort($allSeances, function($a, $b) {
  289.             $dateA = DateTime::createFromFormat('d-m-Y H:i', $a->getTakesplaceOn()->format('d-m-Y').' '.$a->getStartAt());
  290.             $dateB = DateTime::createFromFormat('d-m-Y H:i', $b->getTakesplaceOn()->format('d-m-Y').' '.$b->getStartAt());
  291.             return $dateA <=> $dateB;
  292.         });
  294.         return $allSeances;
  295.     }
  296.     public function getSeancesCancelled()
  297.     {
  298.         $allSeances = [];
  299.         foreach ($this->getScheduleItems() as $scheduleItem) {
  300.             foreach ($scheduleItem->getSeancesCancelled() as $seance ) {
  301.                 $allSeances[] = ['scheduleitem'=>$scheduleItem, 'seanceDate'=>$seance];
  302.             }
  303.         }
  304.         usort($allSeances, function($a, $b) {
  305.             $dateA = DateTime::createFromFormat('d-m-Y H:i', $a['seanceDate'].' '.$a['scheduleitem']->getStartAt());
  306.             $dateB = DateTime::createFromFormat('d-m-Y H:i', $b['seanceDate'].' '.$b['scheduleitem']->getStartAt());
  307.             return $dateA <=> $dateB;
  308.         });
  309.         return $allSeances;
  310.     }
  311.     public function getSeancesNotCreate()
  312.     {
  313.         $allSeances = [];
  314.         foreach ($this->getScheduleItems() as $scheduleItem) {
  315.             foreach ($scheduleItem->getSeancesNotCreate() as $seance ) {
  316.                 $allSeances[] = ['scheduleitem'=>$scheduleItem, 'seanceDate'=>$seance];
  317.             }
  318.         }
  319.         usort($allSeances, function($a, $b) {
  320.             $dateA = DateTime::createFromFormat('d-m-Y H:i', $a['seanceDate'].' '.$a['scheduleitem']->getStartAt());
  321.             $dateB = DateTime::createFromFormat('d-m-Y H:i', $b['seanceDate'].' '.$b['scheduleitem']->getStartAt());
  322.             return $dateA <=> $dateB;
  323.         });
  324.         return $allSeances;
  325.     }
  326.     public function isWeekly(): bool
  327.     {
  328.         if ($this->startAt === null || $this->endAt === null) {
  329.             return false; // Si une des deux dates est absente, on considère que ce n'est pas une période valide.
  330.         }
  332.         // Calcul de la différence entre les deux dates
  333.         $interval = $this->startAt->diff($this->endAt);
  335.         // Vérifier si la différence est inférieure ou égale à 7 jours
  336.         return $interval->days <= 7;
  337.     }
  338. }