src/Entity/Room.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\RoomRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Table(name: '`escappart_room`')]
  11. #[ORM\Entity(repositoryClass: RoomRepository::class)]
  12. class Room
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\Column(length: 255)]
  20.     private ?string $name = null;
  22.     #[ORM\Column(length: 255, nullable: true)]
  23.     private ?string $color = null;
  25.     #[ORM\Column(length: 255, nullable: true)]
  26.     private ?string $bedsId = null;
  28.     #[ORM\ManyToOne(inversedBy: 'rooms', cascade: ['persist', 'remove'])]
  29.     #[ORM\JoinColumn(nullable: false)]
  30.     private ?Hotel $hotel = null;
  32.     #[ORM\OneToMany(mappedBy: 'room', targetEntity: Booking::class, orphanRemoval: true)]
  33.     private Collection $bookings;
  35.     #[ORM\OneToMany(mappedBy: 'room', targetEntity: SeasonalFinance::class)]
  36.     #[ORM\OrderBy(['season' => 'ASC'])]
  37.     private Collection $seasonalFinances;
  39.     #[ORM\OneToMany(mappedBy: 'room', targetEntity: Accounting::class, orphanRemoval: true)]
  40.     private Collection $accountings;
  42.     #[ORM\OneToMany(mappedBy: 'room', targetEntity: RoomUser::class, orphanRemoval: true)]
  43.     private Collection $roomUsers;
  45.     #[ORM\OneToMany(mappedBy: 'room', targetEntity: Fee::class)]
  46.     private Collection $fees;
  48.     public function __construct(Hotel $hotel)
  49.     {
  50.         $this->bookings = new ArrayCollection();
  51.         $this->seasonalFinances = new ArrayCollection();
  52.         $this->accountings = new ArrayCollection();
  53.         $this->roomUsers = new ArrayCollection();
  54.         $this->setHotel($hotel);
  55.         $this->fees = new ArrayCollection();
  56.     }
  57.     
  58.     public function __toString() {
  59.         return $this->name;
  60.     }
  62.     public function getId(): ?int
  63.     {
  64.         return $this->id;
  65.     }
  67.     public function getName(): ?string
  68.     {
  69.         return $this->name;
  70.     }
  72.     public function setName(string $name): self
  73.     {
  74.         $this->name = $name;
  76.         return $this;
  77.     }
  79.     public function getColor(): ?string
  80.     {
  81.         return $this->color;
  82.     }
  84.     public function setColor(?string $color): self
  85.     {
  86.         $this->color = $color;
  88.         return $this;
  89.     }
  91.     public function getBedsId(): ?string
  92.     {
  93.         return $this->bedsId;
  94.     }
  96.     public function setBedsId(?string $bedsId): self
  97.     {
  98.         $this->bedsId = $bedsId;
  100.         return $this;
  101.     }
  103.     public function getHotel(): ?Hotel
  104.     {
  105.         return $this->hotel;
  106.     }
  108.     public function setHotel(?Hotel $hotel): self
  109.     {
  110.         $this->hotel = $hotel;
  112.         return $this;
  113.     }
  115.     /**
  116.      * @return Collection<int, Booking>
  117.      */
  118.     public function getBookings(): Collection
  119.     {
  120.         return $this->bookings;
  121.     }
  123.     public function addBooking(Booking $booking): self
  124.     {
  125.         if (!$this->bookings->contains($booking)) {
  126.             $this->bookings->add($booking);
  127.             $booking->setRoom($this);
  128.         }
  130.         return $this;
  131.     }
  133.     public function removeBooking(Booking $booking): self
  134.     {
  135.         if ($this->bookings->removeElement($booking)) {
  136.             // set the owning side to null (unless already changed)
  137.             if ($booking->getRoom() === $this) {
  138.                 $booking->setRoom(null);
  139.             }
  140.         }
  142.         return $this;
  143.     }
  145.     /**
  146.      * @return Collection<int, Accounting>
  147.      */
  148.     public function getAccountings(): Collection
  149.     {
  150.         return $this->accountings;
  151.     }
  153.     public function addAccounting(Accounting $accounting): self
  154.     {
  155.         if (!$this->accountings->contains($accounting)) {
  156.             $this->accountings->add($accounting);
  157.             $accounting->setRoom($this);
  158.         }
  160.         return $this;
  161.     }
  163.     public function removeAccounting(Accounting $accounting): self
  164.     {
  165.         if ($this->accountings->removeElement($accounting)) {
  166.             // set the owning side to null (unless already changed)
  167.             if ($accounting->getRoom() === $this) {
  168.                 $accounting->setRoom(null);
  169.             }
  170.         }
  172.         return $this;
  173.     }
  175.     /**
  176.      * @return Collection<int, RoomUser>
  177.      */
  178.     public function getRoomUsers(): Collection
  179.     {
  180.         return $this->roomUsers;
  181.     }
  183.     public function addRoomUser(RoomUser $roomUser): self
  184.     {
  185.         if (!$this->roomUsers->contains($roomUser)) {
  186.             $this->roomUsers->add($roomUser);
  187.             $roomUser->setRoom($this);
  188.         }
  190.         return $this;
  191.     }
  193.     public function removeRoomUser(RoomUser $roomUser): self
  194.     {
  195.         if ($this->roomUsers->removeElement($roomUser)) {
  196.             // set the owning side to null (unless already changed)
  197.             if ($roomUser->getRoom() === $this) {
  198.                 $roomUser->setRoom(null);
  199.             }
  200.         }
  202.         return $this;
  203.     }
  205.     /**
  206.      * @return Collection<int, Fee>
  207.      */
  208.     public function getFees(): Collection
  209.     {
  210.         return $this->fees;
  211.     }
  213.     public function addFee(Fee $fee): self
  214.     {
  215.         if (!$this->fees->contains($fee)) {
  216.             $this->fees->add($fee);
  217.             $fee->setRoom($this);
  218.         }
  220.         return $this;
  221.     }
  223.     public function removeFee(Fee $fee): self
  224.     {
  225.         if ($this->fees->removeElement($fee)) {
  226.             // set the owning side to null (unless already changed)
  227.             if ($fee->getRoom() === $this) {
  228.                 $fee->setRoom(null);
  229.             }
  230.         }
  232.         return $this;
  233.     }
  235.     /**
  236.      * @return Collection<int, SeasonalFinance>
  237.      */
  238.     public function getSeasonalFinances(): Collection
  239.     {
  240.         return $this->seasonalFinances;
  241.     }
  243.     public function addSeasonalFinance(SeasonalFinance $seasonalFinance): self
  244.     {
  245.         if (!$this->seasonalFinances->contains($seasonalFinance)) {
  246.             $this->seasonalFinances->add($seasonalFinance);
  247.             $seasonalFinance->setRoom($this);
  248.         }
  250.         return $this;
  251.     }
  253.     public function removeSeasonalFinance(SeasonalFinance $seasonalFinance): self
  254.     {
  255.         if ($this->seasonalFinances->removeElement($seasonalFinance)) {
  256.             // set the owning side to null (unless already changed)
  257.             if ($seasonalFinance->getRoom() === $this) {
  258.                 $seasonalFinance->setRoom(null);
  259.             }
  260.         }
  262.         return $this;
  263.     }
  264. }