src/Entity/HtItem.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\MDS\VenuesBundle\Entity\ReservationLoungeDetails;
  6. use App\MDS\VenuesBundle\Entity\ReservationService;
  7. use App\Repository\HtItemRepository;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\Validator\Constraints as Assert;
  12. use Symfony\Component\Validator\Context\ExecutionContextInterface;
  14. /**
  15.  * @ORM\Entity(repositoryClass=HtItemRepository::class)
  16.  * @ORM\HasLifecycleCallbacks()
  17.  */
  18. class HtItem
  19. {
  20.     /**
  21.      * @ORM\Id
  22.      * @ORM\GeneratedValue
  23.      * @ORM\Column(type="integer")
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\OneToOne(targetEntity=ReservationService::class, inversedBy="htItem", cascade={"persist", "remove"})
  29.      */
  30.     private $reservationService;
  32.     /**
  33.      * @ORM\ManyToOne(targetEntity=ReservationLoungeDetails::class)
  34.      */
  35.     private $loungeGp;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $loungeOther;
  42.     /**
  43.      * @ORM\Column(type="datetime")
  44.      */
  45.     private $dateStart;
  47.     /**
  48.      * @ORM\Column(type="time")
  49.      */
  50.     private $hourEnd;
  52.     /**
  53.      * @ORM\Column(type="integer")
  54.      */
  55.     private $gratitudes;
  57.     /**
  58.      * @ORM\ManyToOne(targetEntity=User::class)
  59.      * @ORM\JoinColumn(nullable=false)
  60.      */
  61.     private $createdId;
  63.     /**
  64.      * @ORM\ManyToOne(targetEntity=User::class)
  65.      * @ORM\JoinColumn(nullable=false)
  66.      */
  67.     private $updatedId;
  69.     /**
  70.      * @ORM\Column(type="datetime_immutable")
  71.      */
  72.     private $createdAt;
  74.     /**
  75.      * @ORM\Column(type="datetime_immutable")
  76.      */
  77.     private $updatedAt;
  79.     /**
  80.      * @ORM\ManyToOne(targetEntity=HtFile::class, inversedBy="htItems")
  81.      * @ORM\JoinColumn(nullable=false)
  82.      */
  83.     private $htFile;
  85.     /**
  86.      * @ORM\Column(type="integer", nullable=true)
  87.      */
  88.     private $pax;
  90.     /**
  91.      * @ORM\OneToMany(targetEntity=HtMenu::class, mappedBy="htItem", cascade={"persist", "remove"})
  92.      */
  93.     private $htMenus;
  95.     /**
  96.      * @ORM\Column(type="text", nullable=true)
  97.      */
  98.     private $observation;
  100.     /**
  101.      * @ORM\OneToMany(targetEntity=HtExtra::class, mappedBy="htItem", cascade={"persist", "remove"})
  102.      */
  103.     private $htExtras;
  105.     /**
  106.      * @ORM\Column(type="string", length=55, nullable=true)
  107.      */
  108.     private $type;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=HtNote::class, mappedBy="htItem", orphanRemoval=true)
  112.      */
  113.     private $htNotes;
  115.     public function __construct()
  116.     {
  117.         $this->htExtras = new ArrayCollection();
  118.         $this->htNotes = new ArrayCollection();
  119.         $this->htMenus = new ArrayCollection();
  120.     }
  122.     public function getId(): ?int
  123.     {
  124.         return $this->id;
  125.     }
  127.     public function getReservationService(): ?ReservationService
  128.     {
  129.         return $this->reservationService;
  130.     }
  132.     public function setReservationService(?ReservationService $reservationService): self
  133.     {
  134.         $this->reservationService = $reservationService;
  136.         return $this;
  137.     }
  139.     public function getLoungeGp(): ?ReservationLoungeDetails
  140.     {
  141.         return $this->loungeGp;
  142.     }
  144.     public function setLoungeGp(?ReservationLoungeDetails $loungeGp): self
  145.     {
  146.         $this->loungeGp = $loungeGp;
  148.         return $this;
  149.     }
  151.     public function getLoungeOther(): ?string
  152.     {
  153.         return $this->loungeOther;
  154.     }
  156.     public function setLoungeOther(?string $loungeOther): self
  157.     {
  158.         $this->loungeOther = $loungeOther;
  160.         return $this;
  161.     }
  163.     public function getDateStart(): ?\DateTimeInterface
  164.     {
  165.         return $this->dateStart;
  166.     }
  168.     public function setDateStart(\DateTimeInterface $dateStart): self
  169.     {
  170.         $this->dateStart = $dateStart;
  172.         return $this;
  173.     }
  175.     public function getHourEnd(): ?\DateTimeInterface
  176.     {
  177.         return $this->hourEnd;
  178.     }
  180.     public function setHourEnd(\DateTimeInterface $hourEnd): self
  181.     {
  182.         $this->hourEnd = $hourEnd;
  184.         return $this;
  185.     }
  187.     public function getGratitudes(): ?int
  188.     {
  189.         return $this->gratitudes;
  190.     }
  192.     public function setGratitudes(int $gratitudes): self
  193.     {
  194.         $this->gratitudes = $gratitudes;
  196.         return $this;
  197.     }
  199.     public function getCreatedId(): ?User
  200.     {
  201.         return $this->createdId;
  202.     }
  204.     public function setCreatedId(?User $createdId): self
  205.     {
  206.         $this->createdId = $createdId;
  208.         return $this;
  209.     }
  211.     public function getUpdatedId(): ?User
  212.     {
  213.         return $this->updatedId;
  214.     }
  216.     public function setUpdatedId(?User $updatedId): self
  217.     {
  218.         $this->updatedId = $updatedId;
  220.         return $this;
  221.     }
  223.     public function getCreatedAt(): ?\DateTimeImmutable
  224.     {
  225.         return $this->createdAt;
  226.     }
  228.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  229.     {
  230.         $this->createdAt = $createdAt;
  232.         return $this;
  233.     }
  235.     public function getUpdatedAt(): ?\DateTimeImmutable
  236.     {
  237.         return $this->updatedAt;
  238.     }
  240.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  241.     {
  242.         $this->updatedAt = $updatedAt;
  244.         return $this;
  245.     }
  247.     /**
  248.      * @ORM\PrePersist
  249.      */
  250.     public function setCreatedAtValue()
  251.     {
  252.         $this->createdAt = new \DateTimeImmutable();
  253.         if ($this->dateStart === null) { $this->dateStart = new \DateTime(); }
  254.         if ($this->hourEnd === null) { $this->hourEnd = new \DateTime(); }
  255.         $this->gratitudes = 0;
  256.     }
  258.     /**
  259.      * @ORM\PrePersist
  260.      * @ORM\PreUpdate
  261.      */
  262.     public function setUpdatedAtValue()
  263.     {
  264.         $this->updatedAt = new \DateTimeImmutable();
  265.     }
  267.     public function getHtFile(): ?HtFile
  268.     {
  269.         return $this->htFile;
  270.     }
  272.     public function setHtFile(?HtFile $htFile): self
  273.     {
  274.         $this->htFile = $htFile;
  276.         return $this;
  277.     }
  279.     public function getPax(): ?int
  280.     {
  281.         return $this->pax;
  282.     }
  284.     public function setPax(?int $pax): self
  285.     {
  286.         $this->pax = $pax;
  288.         return $this;
  289.     }
  291.     /**
  292.      * @return Collection|HtMenu[]
  293.      */
  294.     public function getHtMenus(): Collection
  295.     {
  296.         return $this->htMenus;
  297.     }
  299.     public function addHtMenu(HtMenu $htMenu): self
  300.     {
  301.         if (!$this->htMenus->contains($htMenu)) {
  302.             $this->htMenus[] = $htMenu;
  303.             $htMenu->setHtItem($this);
  304.         }
  306.         return $this;
  307.     }
  309.     public function removeHtMenu(HtMenu $htMenu): self
  310.     {
  311.         if ($this->htMenus->removeElement($htMenu)) {
  312.             // set the owning side to null (unless already changed)
  313.             if ($htMenu->getHtItem() === $this) {
  314.                 $htMenu->setHtItem(null);
  315.             }
  316.         }
  318.         return $this;
  319.     }
  321.     public function getObservation(): ?string
  322.     {
  323.         return $this->observation;
  324.     }
  326.     public function setObservation(?string $observation): self
  327.     {
  328.         $this->observation = $observation;
  330.         return $this;
  331.     }
  333.     /**
  334.      * @return Collection<int, HtExtra>
  335.      */
  336.     public function getHtExtras(): Collection
  337.     {
  338.         return $this->htExtras;
  339.     }
  341.     public function addHtExtra(HtExtra $htExtra): self
  342.     {
  343.         if (!$this->htExtras->contains($htExtra)) {
  344.             $this->htExtras[] = $htExtra;
  345.             $htExtra->setHtItem($this);
  346.         }
  348.         return $this;
  349.     }
  351.     public function removeHtExtra(HtExtra $htExtra): self
  352.     {
  353.         if ($this->htExtras->removeElement($htExtra)) {
  354.             // set the owning side to null (unless already changed)
  355.             if ($htExtra->getHtItem() === $this) {
  356.                 $htExtra->setHtItem(null);
  357.             }
  358.         }
  360.         return $this;
  361.     }
  363.     public function getType(): ?string
  364.     {
  365.         return $this->type;
  366.     }
  368.     public function setType(?string $type): self
  369.     {
  370.         $this->type = $type;
  372.         return $this;
  373.     }
  375.     /**
  376.      * @return Collection<int, HtNote>
  377.      */
  378.     public function getHtNotes(): Collection
  379.     {
  380.         return $this->htNotes;
  381.     }
  383.     public function addHtNote(HtNote $htNote): self
  384.     {
  385.         if (!$this->htNotes->contains($htNote)) {
  386.             $this->htNotes[] = $htNote;
  387.             $htNote->setHtItem($this);
  388.         }
  390.         return $this;
  391.     }
  393.     public function removeHtNote(HtNote $htNote): self
  394.     {
  395.         if ($this->htNotes->removeElement($htNote)) {
  396.             // set the owning side to null (unless already changed)
  397.             if ($htNote->getHtItem() === $this) {
  398.                 $htNote->setHtItem(null);
  399.             }
  400.         }
  402.         return $this;
  403.     }
  405.     /**
  406.      * Para la función clone de php nativa
  407.      */
  408.     public function __clone()
  409.     {
  410.         // Resetear el ID
  411.         $this->id = null;
  413.         // Clonar y resetear relaciones si es necesario
  414.         if ($this->reservationService) {
  415.             $this->reservationService = clone $this->reservationService;
  416.         }
  418.         if ($this->htMenus) {
  419.             $clonedMenus = [];
  420.             foreach ($this->htMenus as $menu) {
  421.                 $clonedMenu = clone $menu;
  422.                 $clonedMenu->setHtItem($this);
  423.                 $clonedMenus[] = $clonedMenu;
  424.             }
  425.             $this->htMenus = $clonedMenus;
  426.         }
  428.         // Clonar colecciones de HtExtras
  429.         $this->htExtras = new ArrayCollection();
  430.         foreach ($this->htExtras as $extra) {
  431.             $clonedExtra = clone $extra;
  432.             $clonedExtra->setHtItem($this);
  433.             $this->htExtras->add($clonedExtra);
  434.         }
  436.         // Clonar colecciones de HtNotes
  437.         $this->htNotes = new ArrayCollection();
  438.         foreach ($this->htNotes as $note) {
  439.             $clonedNote = clone $note;
  440.             $clonedNote->setHtItem($this);
  441.             $this->htNotes->add($clonedNote);
  442.         }
  444.         // No es necesario clonar las relaciones ManyToOne o OneToOne que no se deben duplicar en profundidad
  445.         // pero se debe reasignar la relación inversa en caso de que se dupliquen.
  446.     }
  448.     /**
  449.      * @Assert\Callback
  450.      */
  451.     public function validateDateRange(ExecutionContextInterface $context, $payload): void
  452.     {
  453.         if ($this->htFile === null || $this->dateStart === null) {
  454.             return;
  455.         }
  457.         $fileStart = $this->htFile->getDateStart();
  458.         $fileEnd = $this->htFile->getDateEnd();
  460.         if ($fileStart && $this->dateStart < $fileStart) {
  461.             $context->buildViolation('La fecha no puede ser anterior a la fecha de inicio del expediente (%date%).')
  462.                 ->setParameter('%date%', $fileStart->format('d/m/Y H:i'))
  463.                 ->atPath('dateStart')
  464.                 ->addViolation();
  465.         }
  467.         if ($fileEnd && $this->dateStart > $fileEnd) {
  468.             $context->buildViolation('La fecha no puede ser posterior a la fecha de fin del expediente (%date%).')
  469.                 ->setParameter('%date%', $fileEnd->format('d/m/Y H:i'))
  470.                 ->atPath('dateStart')
  471.                 ->addViolation();
  472.         }
  473.     }
  475.     public function __toString(): string
  476.     {
  477.         return (string) ($this->id ?? 'nuevo');
  478.     }
  480. }