src/Entity/HtItem.php line 16

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\MDS\GreenPatioBundle\Entity\ReservationLoungeDetails;
  4. use App\MDS\GreenPatioBundle\Entity\ReservationService;
  5. use App\Repository\HtItemRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. /**
  10.  * @ORM\Entity(repositoryClass=HtItemRepository::class)
  11.  * @ORM\HasLifecycleCallbacks()
  12.  */
  13. class HtItem
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  21.     /**
  22.      * @ORM\OneToOne(targetEntity=ReservationService::class, inversedBy="htItem", cascade={"persist", "remove"})
  23.      */
  24.     private $reservationService;
  25.     /**
  26.      * @ORM\ManyToOne(targetEntity=ReservationLoungeDetails::class, inversedBy="htItems")
  27.      */
  28.     private $loungeGp;
  29.     /**
  30.      * @ORM\Column(type="string", length=255, nullable=true)
  31.      */
  32.     private $loungeOther;
  33.     /**
  34.      * @ORM\Column(type="datetime")
  35.      */
  36.     private $dateStart;
  37.     /**
  38.      * @ORM\Column(type="time")
  39.      */
  40.     private $hourEnd;
  41.     /**
  42.      * @ORM\Column(type="integer")
  43.      */
  44.     private $gratitudes;
  45.     /**
  46.      * @ORM\ManyToOne(targetEntity=User::class)
  47.      * @ORM\JoinColumn(nullable=false)
  48.      */
  49.     private $createdId;
  50.     /**
  51.      * @ORM\ManyToOne(targetEntity=User::class)
  52.      * @ORM\JoinColumn(nullable=false)
  53.      */
  54.     private $updatedId;
  55.     /**
  56.      * @ORM\Column(type="datetime_immutable")
  57.      */
  58.     private $createdAt;
  59.     /**
  60.      * @ORM\Column(type="datetime_immutable")
  61.      */
  62.     private $updatedAt;
  63.     /**
  64.      * @ORM\ManyToOne(targetEntity=HtFile::class, inversedBy="htItems")
  65.      * @ORM\JoinColumn(nullable=false)
  66.      */
  67.     private $htFile;
  68.     /**
  69.      * @ORM\Column(type="integer", nullable=true)
  70.      */
  71.     private $pax;
  72.     /**
  73.      * @ORM\OneToMany(targetEntity=HtMenu::class, mappedBy="htItem", cascade={"persist", "remove"})
  74.      */
  75.     private $htMenus;
  76.     /**
  77.      * @ORM\Column(type="text", nullable=true)
  78.      */
  79.     private $observation;
  80.     /**
  81.      * @ORM\OneToMany(targetEntity=HtExtra::class, mappedBy="htItem", cascade={"persist", "remove"})
  82.      */
  83.     private $htExtras;
  84.     /**
  85.      * @ORM\Column(type="string", length=55, nullable=true)
  86.      */
  87.     private $type;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity=HtNote::class, mappedBy="htItem", orphanRemoval=true)
  90.      */
  91.     private $htNotes;
  92.     public function __construct()
  93.     {
  94.         $this->htExtras = new ArrayCollection();
  95.         $this->htNotes = new ArrayCollection();
  96.         $this->htMenu = new ArrayCollection();
  97.     }
  98.     public function getId(): ?int
  99.     {
  100.         return $this->id;
  101.     }
  102.     public function getReservationService(): ?ReservationService
  103.     {
  104.         return $this->reservationService;
  105.     }
  106.     public function setReservationService(?ReservationService $reservationService): self
  107.     {
  108.         $this->reservationService $reservationService;
  109.         return $this;
  110.     }
  111.     public function getLoungeGp(): ?ReservationLoungeDetails
  112.     {
  113.         return $this->loungeGp;
  114.     }
  115.     public function setLoungeGp(?ReservationLoungeDetails $loungeGp): self
  116.     {
  117.         $this->loungeGp $loungeGp;
  118.         return $this;
  119.     }
  120.     public function getLoungeOther(): ?string
  121.     {
  122.         return $this->loungeOther;
  123.     }
  124.     public function setLoungeOther(?string $loungeOther): self
  125.     {
  126.         $this->loungeOther $loungeOther;
  127.         return $this;
  128.     }
  129.     public function getDateStart(): ?\DateTimeInterface
  130.     {
  131.         return $this->dateStart;
  132.     }
  133.     public function setDateStart(\DateTimeInterface $dateStart): self
  134.     {
  135.         $this->dateStart $dateStart;
  136.         return $this;
  137.     }
  138.     public function getHourEnd(): ?\DateTimeInterface
  139.     {
  140.         return $this->hourEnd;
  141.     }
  142.     public function setHourEnd(\DateTimeInterface $hourEnd): self
  143.     {
  144.         $this->hourEnd $hourEnd;
  145.         return $this;
  146.     }
  147.     public function getGratitudes(): ?int
  148.     {
  149.         return $this->gratitudes;
  150.     }
  151.     public function setGratitudes(int $gratitudes): self
  152.     {
  153.         $this->gratitudes $gratitudes;
  154.         return $this;
  155.     }
  156.     public function getCreatedId(): ?User
  157.     {
  158.         return $this->createdId;
  159.     }
  160.     public function setCreatedId(?User $createdId): self
  161.     {
  162.         $this->createdId $createdId;
  163.         return $this;
  164.     }
  165.     public function getUpdatedId(): ?User
  166.     {
  167.         return $this->updatedId;
  168.     }
  169.     public function setUpdatedId(?User $updatedId): self
  170.     {
  171.         $this->updatedId $updatedId;
  172.         return $this;
  173.     }
  174.     public function getCreatedAt(): ?\DateTimeImmutable
  175.     {
  176.         return $this->createdAt;
  177.     }
  178.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  179.     {
  180.         $this->createdAt $createdAt;
  181.         return $this;
  182.     }
  183.     public function getUpdatedAt(): ?\DateTimeImmutable
  184.     {
  185.         return $this->updatedAt;
  186.     }
  187.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  188.     {
  189.         $this->updatedAt $updatedAt;
  190.         return $this;
  191.     }
  192.     /**
  193.      * @ORM\PrePersist
  194.      */
  195.     public function setCreatedAtValue()
  196.     {
  197.         $this->createdAt = new \DateTimeImmutable();
  198.         if ($this->dateStart === null) { $this->dateStart = new \DateTime(); }
  199.         if ($this->hourEnd === null) { $this->hourEnd = new \DateTime(); }
  200.         $this->gratitudes 0;
  201.     }
  202.     /**
  203.      * @ORM\PrePersist
  204.      * @ORM\PreUpdate
  205.      */
  206.     public function setUpdatedAtValue()
  207.     {
  208.         $this->updatedAt = new \DateTimeImmutable();
  209.     }
  210.     public function getHtFile(): ?HtFile
  211.     {
  212.         return $this->htFile;
  213.     }
  214.     public function setHtFile(?HtFile $htFile): self
  215.     {
  216.         $this->htFile $htFile;
  217.         return $this;
  218.     }
  219.     public function getPax(): ?int
  220.     {
  221.         return $this->pax;
  222.     }
  223.     public function setPax(?int $pax): self
  224.     {
  225.         $this->pax $pax;
  226.         return $this;
  227.     }
  228.     /**
  229.      * @return Collection|HtMenu[]
  230.      */
  231.     public function getHtMenus(): Collection
  232.     {
  233.         return $this->htMenus;
  234.     }
  235.     public function addHtMenu(HtMenu $htMenu): self
  236.     {
  237.         if (!$this->htMenus->contains($htMenu)) {
  238.             $this->htMenus[] = $htMenu;
  239.             $htMenu->setHtItem($this);
  240.         }
  241.         return $this;
  242.     }
  243.     public function removeHtMenu(HtMenu $htMenu): self
  244.     {
  245.         if ($this->htMenus->removeElement($htMenu)) {
  246.             // set the owning side to null (unless already changed)
  247.             if ($htMenu->getHtItem() === $this) {
  248.                 $htMenu->setHtItem(null);
  249.             }
  250.         }
  251.         return $this;
  252.     }
  253.     public function getObservation(): ?string
  254.     {
  255.         return $this->observation;
  256.     }
  257.     public function setObservation(?string $observation): self
  258.     {
  259.         $this->observation $observation;
  260.         return $this;
  261.     }
  262.     /**
  263.      * @return Collection<int, HtExtra>
  264.      */
  265.     public function getHtExtras(): Collection
  266.     {
  267.         return $this->htExtras;
  268.     }
  269.     public function addHtExtra(HtExtra $htExtra): self
  270.     {
  271.         if (!$this->htExtras->contains($htExtra)) {
  272.             $this->htExtras[] = $htExtra;
  273.             $htExtra->setHtItem($this);
  274.         }
  275.         return $this;
  276.     }
  277.     public function removeHtExtra(HtExtra $htExtra): self
  278.     {
  279.         if ($this->htExtras->removeElement($htExtra)) {
  280.             // set the owning side to null (unless already changed)
  281.             if ($htExtra->getHtItem() === $this) {
  282.                 $htExtra->setHtItem(null);
  283.             }
  284.         }
  285.         return $this;
  286.     }
  287.     public function getType(): ?string
  288.     {
  289.         return $this->type;
  290.     }
  291.     public function setType(?string $type): self
  292.     {
  293.         $this->type $type;
  294.         return $this;
  295.     }
  296.     /**
  297.      * @return Collection<int, HtNote>
  298.      */
  299.     public function getHtNotes(): Collection
  300.     {
  301.         return $this->htNotes;
  302.     }
  303.     public function addHtNote(HtNote $htNote): self
  304.     {
  305.         if (!$this->htNotes->contains($htNote)) {
  306.             $this->htNotes[] = $htNote;
  307.             $htNote->setHtItem($this);
  308.         }
  309.         return $this;
  310.     }
  311.     public function removeHtNote(HtNote $htNote): self
  312.     {
  313.         if ($this->htNotes->removeElement($htNote)) {
  314.             // set the owning side to null (unless already changed)
  315.             if ($htNote->getHtItem() === $this) {
  316.                 $htNote->setHtItem(null);
  317.             }
  318.         }
  319.         return $this;
  320.     }
  321.     /**
  322.      * Para la función clone de php nativa
  323.      */
  324.     public function __clone()
  325.     {
  326.         // Resetear el ID
  327.         $this->id null;
  328.         // Clonar y resetear relaciones si es necesario
  329.         if ($this->reservationService) {
  330.             $this->reservationService = clone $this->reservationService;
  331.         }
  332.         if ($this->htMenus) {
  333.             $clonedMenus = [];
  334.             foreach ($this->htMenus as $menu) {
  335.                 $clonedMenu = clone $menu;
  336.                 $clonedMenu->setHtItem($this);
  337.                 $clonedMenus[] = $clonedMenu;
  338.             }
  339.             $this->htMenus $clonedMenus;
  340.         }
  341.         // Clonar colecciones de HtExtras
  342.         $this->htExtras = new ArrayCollection();
  343.         foreach ($this->htExtras as $extra) {
  344.             $clonedExtra = clone $extra;
  345.             $clonedExtra->setHtItem($this);
  346.             $this->htExtras->add($clonedExtra);
  347.         }
  348.         // Clonar colecciones de HtNotes
  349.         $this->htNotes = new ArrayCollection();
  350.         foreach ($this->htNotes as $note) {
  351.             $clonedNote = clone $note;
  352.             $clonedNote->setHtItem($this);
  353.             $this->htNotes->add($clonedNote);
  354.         }
  355.         // No es necesario clonar las relaciones ManyToOne o OneToOne que no se deben duplicar en profundidad
  356.         // pero se debe reasignar la relación inversa en caso de que se dupliquen.
  357.     }
  358. }