src/Entity/Reservation.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\CustomExtra;
  6. use App\Entity\History\Reservation\ReservationHistory;
  7. use App\Entity\Payment\AbstractPayment;
  8. use App\Entity\Payment\CarteCadeauPayment;
  9. use App\Entity\Payment\EmptyPayment;
  10. use App\Repository\ReservationRepository;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\ORM\Mapping as ORM;
  15. /**
  16.  * @ORM\Entity(repositoryClass=ReservationRepository::class)
  17.  */
  18. class Reservation extends AbstractReservation
  19. {
  20.     /**
  21.      * @ORM\Column(type="string", length=255)
  22.      */
  23.     private $bains;
  25.     /**
  26.      * @ORM\Column(type="boolean")
  27.      */
  28.     private $confirmed;
  30.     /**
  31.      * @ORM\Column(type="string", length=255)
  32.      */
  33.     private $token;
  35.     /**
  36.      * @ORM\Column(type="boolean", nullable=true)
  37.      */
  38.     private $deleted;
  40.     /**
  41.      * @ORM\Column(type="string", length=255, nullable=true)
  42.      */
  43.     private $comment;
  45.     /**
  46.      * @ORM\OneToMany(targetEntity=ExtraReservation::class, mappedBy="reservation", orphanRemoval=true, cascade={"persist", "remove"})
  47.      */
  48.     protected $extraReservations;
  50.     /**
  51.      * @ORM\OneToMany(targetEntity=CustomExtra::class, mappedBy="reservation", orphanRemoval=true, cascade={"persist", "remove"})
  52.      */
  53.     private $customExtras;
  55.     /**
  56.      * @ORM\OneToMany(targetEntity=Participant::class, mappedBy="reservation", orphanRemoval=true, cascade={"persist", "remove"})
  57.      */
  58.     protected $participants;
  60.     /**
  61.      * @ORM\OneToMany(targetEntity=Token::class, mappedBy="reservation", cascade={"persist", "remove"})
  62.      */
  63.     private $tokens;
  65.     /**
  66.      * @ORM\Column(type="float", nullable=true)
  67.      */
  68.     private $resteAPayer;
  70.     /**
  71.      * @ORM\OneToMany(targetEntity=AbstractPayment::class, mappedBy="reservation", cascade={"remove"})
  72.      */
  73.     private $abstractPayments;
  75.     /**
  76.      * @ORM\ManyToOne(targetEntity=Contact::class, inversedBy="reservations", cascade={"persist"})
  77.      */
  78.     private $contact;
  80.     /**
  81.      * @ORM\OneToMany(targetEntity=ReservationHistory::class, mappedBy="reservation", cascade={"remove"})
  82.      */
  83.     private $reservationHistories;
  85.     /**
  86.      * @ORM\Column(type="boolean", nullable=true)
  87.      */
  88.     private $isSatisfied;
  90.     /**
  91.      * @ORM\Column(type="boolean", nullable=true)
  92.      */
  93.     private $isClientMissing;
  95.     /**
  96.      * @ORM\Column(type="string", length=255, nullable=true)
  97.      */
  98.     private $clientMissingReason;
  100.     /**
  101.      * @ORM\Column(type="string", length=255, nullable=true)
  102.      */
  103.     private $cancelReason;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity=Code::class, mappedBy="createdFromReservation", cascade={"remove"})
  107.      */
  108.     private $createdCodes;
  111.     /**
  112.      * Constructor
  113.      */
  114.     public function __construct()
  115.     {
  116.         parent::__construct();
  117.         $this->deleted = false;
  118.         $this->confirmed = false;
  119.         $this->bains = '[]'; // Initialize with empty JSON array
  120.         $this->participants = new ArrayCollection();
  121.         $this->extraReservations = new ArrayCollection();
  122.         $this->customExtras = new ArrayCollection();
  123.         $this->tokens = new ArrayCollection();
  124.         $this->abstractPayments = new ArrayCollection();
  125.         $this->reservationHistories = new ArrayCollection();
  126.         $this->createdCodes = new ArrayCollection();
  127.     }
  129.     public function __clone()
  130.     {
  131.         $participants = new ArrayCollection();
  132.         foreach($this->getParticipants() as $participant) {
  133.             $newParticipant = clone $participant;
  134.             $participants->add($newParticipant);
  135.             $this->removeParticipant($participant);
  136.         }
  138.         $this->participants = $participants;
  140.         $extraReservations = new ArrayCollection();
  141.         foreach($this->getExtraReservations() as $extraReservation) {
  142.             $newExtraReservation = clone $extraReservation;
  143.             $extraReservations->add($newExtraReservation);
  144.             $this->removeExtraReservation($extraReservation);
  145.         }
  147.         $this->extraReservations = $extraReservations;
  149.         $customExtras = new ArrayCollection();
  150.         foreach($this->getCustomExtras() as $customExtra) {
  151.             $newCustomExtra = clone $customExtra;
  152.             $newCustomExtra->setReservation($this);
  153.             $customExtras->add($newCustomExtra);
  154.         }
  155.         $this->customExtras = $customExtras;
  156.     }
  158.     public function getBains(): ?string
  159.     {
  160.         return $this->bains;
  161.     }
  163.     public function setBains(string $bains): self
  164.     {
  165.         $this->bains = $bains;
  167.         return $this;
  168.     }
  170.     public function getConfirmed(): ?bool
  171.     {
  172.         return $this->confirmed;
  173.     }
  175.     public function setConfirmed(bool $confirmed): self
  176.     {
  177.         $this->confirmed = $confirmed;
  179.         return $this;
  180.     }
  182.     public function getToken(): ?string
  183.     {
  184.         return $this->token;
  185.     }
  187.     public function setToken(string $token): self
  188.     {
  189.         $this->token = $token;
  191.         return $this;
  192.     }
  194.     public function getDeleted(): ?bool
  195.     {
  196.         return $this->deleted;
  197.     }
  199.     public function setDeleted(?bool $deleted): self
  200.     {
  201.         $this->deleted = $deleted;
  203.         return $this;
  204.     }
  206.     public function getComment(): ?string
  207.     {
  208.         return $this->comment;
  209.     }
  211.     public function setComment(?string $comment): self
  212.     {
  213.         $this->comment = $comment;
  215.         return $this;
  216.     }
  218.     /**
  219.      * @return Collection<int, ExtraReservation>
  220.      */
  221.     public function getExtraReservations(): Collection
  222.     {
  223.         return $this->extraReservations;
  224.     }
  226.     /**
  227.      * @return Collection<int, ExtraReservation>
  228.      */
  229.     public function getActiveExtraReservations(): Collection
  230.     {
  231.         return $this->extraReservations->filter(function(ExtraReservation $extraReservation) {
  232.             return !$extraReservation->isEmpty();
  233.         });
  234.     }
  236.     public function addExtraReservation(ExtraReservation $extraReservation): self
  237.     {
  238.         if (!$this->extraReservations->contains($extraReservation)) {
  239.             $this->extraReservations[] = $extraReservation;
  240.             $extraReservation->setReservation($this);
  241.         }
  243.         return $this;
  244.     }
  246.     public function removeExtraReservation(ExtraReservation $extraReservation): self
  247.     {
  248.         if ($this->extraReservations->removeElement($extraReservation)) {
  249.             // set the owning side to null (unless already changed)
  250.             if ($extraReservation->getReservation() === $this) {
  251.                 $extraReservation->setReservation(null);
  252.             }
  253.         }
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return Collection<int, CustomExtra>
  260.      */
  261.     public function getCustomExtras(): Collection
  262.     {
  263.         return $this->customExtras;
  264.     }
  266.     public function addCustomExtra(CustomExtra $customExtra): self
  267.     {
  268.         if (!$this->customExtras->contains($customExtra)) {
  269.             $this->customExtras[] = $customExtra;
  270.             $customExtra->setReservation($this);
  271.         }
  273.         return $this;
  274.     }
  276.     public function removeCustomExtra(CustomExtra $customExtra): self
  277.     {
  278.         if ($this->customExtras->removeElement($customExtra)) {
  279.             if ($customExtra->getReservation() === $this) {
  280.                 $customExtra->setReservation(null);
  281.             }
  282.         }
  284.         return $this;
  285.     }
  287.     /**
  288.      * @return Collection<int, Participant>
  289.      */
  290.     public function getParticipants(): Collection
  291.     {
  292.         return $this->participants;
  293.     }
  295.     public function addParticipant(Participant $participant): self
  296.     {
  297.         if (!$this->participants->contains($participant)) {
  298.             $this->participants[] = $participant;
  299.             $participant->setReservation($this);
  300.         }
  302.         return $this;
  303.     }
  305.     public function removeParticipant(Participant $participant): self
  306.     {
  307.         if ($this->participants->removeElement($participant)) {
  308.             // set the owning side to null (unless already changed)
  309.             if ($participant->getReservation() === $this) {
  310.                 $participant->setReservation(null);
  311.             }
  312.         }
  314.         return $this;
  315.     }
  317.     /**
  318.      * @return Collection<int, Token>
  319.      */
  320.     public function getTokens(): Collection
  321.     {
  322.         return $this->tokens;
  323.     }
  325.     public function addToken(Token $token): self
  326.     {
  327.         if (!$this->tokens->contains($token)) {
  328.             $this->tokens[] = $token;
  329.             $token->setReservation($this);
  330.         }
  332.         return $this;
  333.     }
  335.     public function removeToken(Token $token): self
  336.     {
  337.         if ($this->tokens->removeElement($token)) {
  338.             // set the owning side to null (unless already changed)
  339.             if ($token->getReservation() === $this) {
  340.                 $token->setReservation(null);
  341.             }
  342.         }
  344.         return $this;
  345.     }
  347.     public function getResteAPayer(): ?float
  348.     {
  349.         return $this->resteAPayer ?? 0;
  350.     }
  352.     public function setResteAPayer(?float $resteAPayer): self
  353.     {
  354.         $this->resteAPayer = $resteAPayer;
  356.         return $this;
  357.     }
  359.     /**
  360.      * @return Collection<int, AbstractPayment>
  361.      */
  362.     public function getAbstractPayments(): Collection
  363.     {
  364.         return $this->abstractPayments;
  365.     }
  367.     public function isPaidWithCarteCadeau(): bool
  368.     {
  369.         foreach ($this->abstractPayments as $payment) {
  370.             if ($payment instanceof CarteCadeauPayment) {
  371.                 return true;
  372.             }
  373.         }
  375.         return false;
  376.     }
  378.     public function getUsedCarteCadeaux(): Collection
  379.     {
  380.         $carteCadeaux = new ArrayCollection();
  382.         foreach ($this->abstractPayments as $payment) {
  383.             if ($payment instanceof CarteCadeauPayment) {
  384.                 $carteCadeaux->add($payment->getCartecadeau());
  385.             }
  386.         }
  388.         return $carteCadeaux;
  389.     }
  391.     public function addAbstractPayment(AbstractPayment $abstractPayment): self
  392.     {
  393.         if (!$this->abstractPayments->contains($abstractPayment)) {
  394.             $this->abstractPayments[] = $abstractPayment;
  395.             $abstractPayment->setReservation($this);
  396.         }
  398.         return $this;
  399.     }
  401.     public function removeAbstractPayment(AbstractPayment $abstractPayment): self
  402.     {
  403.         if ($this->abstractPayments->removeElement($abstractPayment)) {
  404.             // set the owning side to null (unless already changed)
  405.             if ($abstractPayment->getReservation() === $this) {
  406.                 $abstractPayment->setReservation(null);
  407.             }
  408.         }
  410.         return $this;
  411.     }
  413.     public function getContact(): ?Contact
  414.     {
  415.         return $this->contact;
  416.     }
  418.     public function setContact(?Contact $contact): self
  419.     {
  420.         $this->contact = $contact;
  422.         return $this;
  423.     }
  425.     public function getAllHistories(): array
  426.     {
  427.         $histories = new ArrayCollection();
  428.         foreach($this->getReservationHistories() as $history) {
  429.             $histories->add($history);
  430.         }
  432.         foreach($this->getAbstractPayments() as $payment) {
  433.             if (!$payment instanceof EmptyPayment) {
  434.                 $histories->add($payment);
  435.             }
  436. //            foreach($payment->getPaymentHistories() as $history) {
  437. //                $histories->add($history->getPayment());
  438. //            }
  439.         }
  441.         // sort by createdAt
  442.         $histories = $histories->toArray();
  443.         usort($histories, function($a, $b) {
  444.             return $b->getCreatedAt() <=> $a->getCreatedAt();
  445.         });
  447.         return $histories;
  448.     }
  450.     /**
  451.      * Get only payment histories from all histories
  452.      * @return array Payment histories sorted by creation date (newest first)
  453.      */
  454.     public function getPaymentHistories(): array
  455.     {
  456.         $paymentHistories = new ArrayCollection();
  457.         
  458.         foreach($this->getAbstractPayments() as $payment) {
  459.             if (!$payment instanceof EmptyPayment) {
  460.                 $paymentHistories->add($payment);
  461.             }
  462.         }
  464.         // sort by createdAt
  465.         $histories = $paymentHistories->toArray();
  466.         usort($histories, function($a, $b) {
  467.             return $b->getCreatedAt() <=> $a->getCreatedAt();
  468.         });
  470.         return $histories;
  471.     }
  473.     /**
  474.      * @return Collection<int, ReservationHistory>
  475.      */
  476.     public function getReservationHistories(): Collection
  477.     {
  478.         return $this->reservationHistories;
  479.     }
  481.     public function addReservationHistory(ReservationHistory $reservationHistory): self
  482.     {
  483.         if (!$this->reservationHistories->contains($reservationHistory)) {
  484.             $this->reservationHistories[] = $reservationHistory;
  485.             $reservationHistory->setReservation($this);
  486.         }
  488.         return $this;
  489.     }
  491.     public function removeReservationHistory(ReservationHistory $reservationHistory): self
  492.     {
  493.         $this->reservationHistories->removeElement($reservationHistory);
  495.         return $this;
  496.     }
  498.     public function getTotalPeople(): int
  499.     {
  500.         return ( $this->getSolo() ?? 0 )
  501.             + ( ($this->getDuo() ?? 0) * 2);
  502.     }
  504.     public function getTotalBaths(): int
  505.     {
  506.         return ( $this->getSolo() ?? 0 )
  507.             + ( $this->getDuo() ?? 0) ;
  508.     }
  510.     public function getArrivalDate(): ?\DateTimeInterface
  511.     {
  512.         return $this->getDate()->modify('-15 minutes');
  513.     }
  515.     public function getDepartureDate(): ?\DateTimeInterface
  516.     {
  517.         return $this->getOffer() == "60" ?
  518.             $this->getDate()->modify('+80 minutes') :
  519.             $this->getDate()->modify('+110 minutes')
  520.             ;
  521.     }
  523.     public function getIsSatisfied(): ?bool
  524.     {
  525.         return $this->isSatisfied;
  526.     }
  528.     public function setIsSatisfied(?bool $isSatisfied): self
  529.     {
  530.         $this->isSatisfied = $isSatisfied;
  532.         return $this;
  533.     }
  535.     public function getIsClientMissing(): ?bool
  536.     {
  537.         return $this->isClientMissing;
  538.     }
  540.     public function setIsClientMissing(?bool $isClientMissing): self
  541.     {
  542.         $this->isClientMissing = $isClientMissing;
  544.         return $this;
  545.     }
  547.     public function getDateFormated(): string
  548.     {
  549.         // French day and month names
  550.         $days = [
  551.             'Sunday' => 'Dimanche',
  552.             'Monday' => 'Lundi',
  553.             'Tuesday' => 'Mardi',
  554.             'Wednesday' => 'Mercredi',
  555.             'Thursday' => 'Jeudi',
  556.             'Friday' => 'Vendredi',
  557.             'Saturday' => 'Samedi'
  558.         ];
  560.         $months = [
  561.             'January' => 'janvier',
  562.             'February' => 'février',
  563.             'March' => 'mars',
  564.             'April' => 'avril',
  565.             'May' => 'mai',
  566.             'June' => 'juin',
  567.             'July' => 'juillet',
  568.             'August' => 'août',
  569.             'September' => 'septembre',
  570.             'October' => 'octobre',
  571.             'November' => 'novembre',
  572.             'December' => 'décembre'
  573.         ];
  575.         $date = $this->getDate();
  577.         // Format components
  578.         $dayName = $days[$date->format('l')]; // Full day name
  579.         $day = $date->format('d'); // Day of the month
  580.         $monthName = $months[$date->format('F')]; // Full month name
  581.         $year = $date->format('Y'); // Year
  582.         $time = $date->format('H\h') . str_pad($date->format('i'), 2, '0', STR_PAD_LEFT);
  584.         // Combine the formatted string
  585.         $formattedDate = "$dayName $day $monthName $year à $time";
  587.         return $formattedDate;
  588.     }
  590.     public function getIsPast() {
  591.         return $this->getEndDate() < new \DateTime();
  592.     }
  594.     public function getEndDate(): \DateTimeInterface
  595.     {
  596.         $offerDuration = $this->getOffer() == "60" ? 60 : 90; // Durée en minutes
  597.         return (clone $this->getDate())->modify("+$offerDuration minutes");
  598.     }
  600.     public function getClientMissingReason(): ?string
  601.     {
  602.         return $this->clientMissingReason;
  603.     }
  605.     public function setClientMissingReason(?string $clientMissingReason): self
  606.     {
  607.         $this->clientMissingReason = $clientMissingReason;
  609.         return $this;
  610.     }
  612.     public function getCancelReason(): ?string
  613.     {
  614.         return $this->cancelReason;
  615.     }
  617.     public function setCancelReason(?string $cancelReason): self
  618.     {
  619.         $this->cancelReason = $cancelReason;
  621.         return $this;
  622.     }
  624.     /**
  625.      * @return Collection<int, Code>
  626.      */
  627.     public function getCreatedCodes(): Collection
  628.     {
  629.         return $this->createdCodes;
  630.     }
  632.     public function addCreatedCode(Code $createdCode): self
  633.     {
  634.         if (!$this->createdCodes->contains($createdCode)) {
  635.             $this->createdCodes[] = $createdCode;
  636.             $createdCode->setCreatedFromReservation($this);
  637.         }
  639.         return $this;
  640.     }
  642.     public function removeCreatedCode(Code $createdCode): self
  643.     {
  644.         if ($this->createdCodes->removeElement($createdCode)) {
  645.             // set the owning side to null (unless already changed)
  646.             if ($createdCode->getCreatedFromReservation() === $this) {
  647.                 $createdCode->setCreatedFromReservation(null);
  648.             }
  649.         }
  651.         return $this;
  652.     }
  654.     /**
  655.      * Count the number of times a client (non-admin) has edited this reservation
  656.      * @return int The number of client edits
  657.      */
  658.     public function getClientEditCount(): int
  659.     {
  660.         $count = 0;
  661.         foreach($this->getReservationHistories() as $history) {
  662.             if ($history instanceof \App\Entity\History\Reservation\UpdateReservationHistory
  663.                 && $history->getModifier() !== "admin@taakabeerspa.com") {
  664.                 $count++;
  665.             }
  666.         }
  667.         return $count;
  668.     }
  669.     
  670.     /**
  671.      * Check if a client can edit this reservation (limit to 3 edits)
  672.      * @return bool Whether the client can edit the reservation
  673.      */
  674.     public function canClientEdit(): bool
  675.     {
  676.         return $this->getClientEditCount() < 3;
  677.     }
  679.     /**
  680.      * Get the current status of the reservation based on business rules
  681.      * @return string The status constant from ReservationStatus
  682.      */
  683.     public function getStatus(): string
  684.     {
  685.         if ($this->getDeleted()) {
  686.             return ReservationStatus::ANNULE;
  687.         }
  688.         
  689.         if ($this->getConfirmed() && $this->getIsClientMissing()) {
  690.             return ReservationStatus::ABSENT;
  691.         }
  692.         
  693.         if ($this->getConfirmed()) {
  694.             return ReservationStatus::CONFIRME;
  695.         }
  696.         
  697.         return ReservationStatus::NON_CONFIRME;
  698.     }
  700.     /**
  701.      * Get the human-readable label for the current status
  702.      * @return string The French label for the status
  703.      */
  704.     public function getStatusLabel(): string
  705.     {
  706.         return ReservationStatus::getLabel($this->getStatus());
  707.     }
  709.     /**
  710.      * Get the CSS class for the current status
  711.      * @return string The CSS class name for styling
  712.      */
  713.     public function getStatusCssClass(): string
  714.     {
  715.         return ReservationStatus::getCssStatusClass($this->getStatus());
  716.     }
  718.     /**
  719.      * String representation of the reservation for debugging purposes
  720.      * @return string
  721.      */
  722.     public function __toString(): string
  723.     {
  724.         return sprintf(
  725.             'Reservation(id: %s, token: %s, date: %s, confirmed: %s)',
  726.             $this->getId() ?? 'new',
  727.             $this->getToken() ?? 'none',
  728.             $this->getDate() ? $this->getDate()->format('Y-m-d H:i:s') : 'none',
  729.             $this->getConfirmed() ? 'true' : 'false'
  730.         );
  731.     }
  732. }