src/Entity/HotelRoomType.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\HotelRoomTypeRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Validator\Constraints as Assert;
  12. #[ORM\Entity(repositoryClass: HotelRoomTypeRepository::class)]
  13. class HotelRoomType extends ProductElement
  14. {
  16.     #[ORM\Column(type: Types::SMALLINT)]
  17.     #[Assert\NotNull]
  18.     #[Assert\Positive]
  19.     #[Assert\Range(min: 1, max: 8)]
  20.     private ?int $minOccupancy = null;
  22.     #[ORM\Column(type: Types::SMALLINT)]
  23.     #[Assert\NotNull]
  24.     #[Assert\Positive]
  25.     #[Assert\Range(min: 1, max: 8)]
  26.     private ?int $maxOccupancy = null;
  29.     #[ORM\Column(type: Types::SMALLINT)]
  30.     #[Assert\NotNull]
  31.     #[Assert\PositiveOrZero]
  32.     #[Assert\Range(min: 0, max: 8)]
  33.     private ?int $minOccupancyAdult = null;
  35.     #[ORM\Column(type: Types::SMALLINT)]
  36.     #[Assert\NotNull]
  37.     #[Assert\PositiveOrZero]
  38.     #[Assert\Range(min: 0, max: 8)]
  39.     private ?int $maxOccupancyAdult= null;
  41.     #[ORM\ManyToMany(targetEntity: Facility::class, inversedBy: 'hotelRoomTypes')]
  42.     private $facilities;
  44.     #[ORM\ManyToOne(targetEntity: RoomType::class)]
  45.     private ?RoomType $roomType=null;
  47.     #[ORM\ManyToOne(targetEntity: Hotel::class, inversedBy: 'hotelRoomTypes')]
  48.     private ?Hotel $hotel;
  51.     #[ORM\ManyToMany(targetEntity: RoomOccupancy::class, inversedBy: 'hotelRoomTypes')]
  52.     private Collection $occupancies;
  54. //    #[ORM\OneToMany(mappedBy: 'hotelRoomType', targetEntity: ProductElementStockOperation::class)]
  55. //    private Collection $hotelRoomTypeAllotments;
  57. //    #[ORM\OneToMany(mappedBy: 'hotelRoomType', targetEntity: HotelRoomTypeArrangement::class, orphanRemoval: true)]
  58. //    private Collection $hotelRoomTypeArrangements;
  61.     public function __construct()
  62.     {
  63.         parent::__construct();
  64.         $this->facilities = new ArrayCollection();
  65.         $this->occupancies = new ArrayCollection();
  66. //        $this->hotelRoomTypeAllotments = new ArrayCollection();
  67. //        $this->hotelRoomTypeArrangements = new ArrayCollection();
  68.     }
  71.     public function getMinOccupancy(): ?int
  72.     {
  73.         return $this->minOccupancy;
  74.     }
  76.     public function setMinOccupancy(?int $minOccupancy): self
  77.     {
  78.         $this->minOccupancy = $minOccupancy;
  80.         return $this;
  81.     }
  83.     public function getMaxOccupancy(): ?int
  84.     {
  85.         return $this->maxOccupancy;
  86.     }
  88.     public function setMaxOccupancy(?int $maxOccupancy): self
  89.     {
  90.         $this->maxOccupancy = $maxOccupancy;
  92.         return $this;
  93.     }
  95.     public function getMinOccupancyAdult(): ?int
  96.     {
  97.         return $this->minOccupancyAdult;
  98.     }
  100.     public function setMinOccupancyAdult(?int $minOccupancyAdult): self
  101.     {
  102.         $this->minOccupancyAdult = $minOccupancyAdult;
  104.         return $this;
  105.     }
  107.     /**
  108.      * @return Collection<int, Facility>
  109.      */
  110.     public function getFacilities(): Collection
  111.     {
  112.         return $this->facilities;
  113.     }
  115.     public function addFacility(Facility $facility): self
  116.     {
  117.         if (!$this->facilities->contains($facility)) {
  118.             $this->facilities[] = $facility;
  119.         }
  121.         return $this;
  122.     }
  124.     public function removeFacility(Facility $facility): self
  125.     {
  126.         $this->facilities->removeElement($facility);
  128.         return $this;
  129.     }
  132.     public function getRoomType(): ?RoomType
  133.     {
  134.         return $this->roomType;
  135.     }
  137.     public function setRoomType(?RoomType $roomType): self
  138.     {
  139.         $this->roomType = $roomType;
  141.         return $this;
  142.     }
  144.     public function getHotel(): ?Hotel
  145.     {
  146.         return $this->hotel;
  147.     }
  149.     public function setHotel(?Hotel $hotel): self
  150.     {
  151.         $this->hotel = $hotel;
  153.         return $this;
  154.     }
  157.     public function __toString(): string
  158.     {
  159.         return $this->getRoomType()->getName();
  160.     }
  163.     public function getMaxOccupancyAdult(): ?int
  164.     {
  165.         return $this->maxOccupancyAdult;
  166.     }
  168.     public function setMaxOccupancyAdult(?int $maxOccupancyAdult): self
  169.     {
  170.         $this->maxOccupancyAdult = $maxOccupancyAdult;
  172.         return $this;
  173.     }
  175.     /**
  176.      * @return Collection<int, RoomOccupancy>
  177.      */
  178.     public function getOccupancies(): Collection
  179.     {
  180.         return $this->occupancies;
  181.     }
  183.     public function addOccupancy(RoomOccupancy $occupancy): self
  184.     {
  185.         if (!$this->occupancies->contains($occupancy)) {
  186.             $this->occupancies->add($occupancy);
  187.         }
  189.         return $this;
  190.     }
  192.     public function removeOccupancy(RoomOccupancy $occupancy): self
  193.     {
  194.         $this->occupancies->removeElement($occupancy);
  196.         return $this;
  197.     }
  199.     public function removeOccupancies(): self
  200.     {
  201.         $this->occupancies = new ArrayCollection();
  203.         return $this;
  204.     }
  207.     #[Assert\IsTrue(message: 'CheckOccupancies')]
  208.     public function isOccupGood(): bool
  209.     {
  210.         return  $this->minOccupancy <= $this->maxOccupancy &&
  211.                 $this->minOccupancyAdult <= $this->maxOccupancyAdult &&
  212.                 $this->maxOccupancyAdult <= $this->maxOccupancy;
  213.     }
  215. //    /**
  216. //     * @return Collection<int, ProductElementStockOperation>
  217. //     */
  218. //    public function getHotelRoomTypeAllotments(): Collection
  219. //    {
  220. //        return $this->hotelRoomTypeAllotments;
  221. //    }
  222. //
  223. //    public function addHotelRoomTypeAllotment(ProductElementStockOperation $hotelRoomTypeAllotment): self
  224. //    {
  225. //        if (!$this->hotelRoomTypeAllotments->contains($hotelRoomTypeAllotment)) {
  226. //            $this->hotelRoomTypeAllotments->add($hotelRoomTypeAllotment);
  227. //            $hotelRoomTypeAllotment->setHotelRoomType($this);
  228. //        }
  229. //
  230. //        return $this;
  231. //    }
  232. //
  233. //    public function removeHotelRoomTypeAllotment(ProductElementStockOperation $hotelRoomTypeAllotment): self
  234. //    {
  235. //        if ($this->hotelRoomTypeAllotments->removeElement($hotelRoomTypeAllotment)) {
  236. //            // set the owning side to null (unless already changed)
  237. //            if ($hotelRoomTypeAllotment->getHotelRoomType() === $this) {
  238. //                $hotelRoomTypeAllotment->setHotelRoomType(null);
  239. //            }
  240. //        }
  241. //
  242. //        return $this;
  243. //    }
  244. //
  245. //    /**
  246. //     * @return Collection<int, HotelRoomTypeArrangement>
  247. //     */
  248. //    public function getHotelRoomTypeArrangements(): Collection
  249. //    {
  250. //        return $this->hotelRoomTypeArrangements;
  251. //    }
  252. //
  253. //    public function addHotelRoomTypeArrangement(HotelRoomTypeArrangement $hotelRoomTypeArrangement): self
  254. //    {
  255. //        if (!$this->hotelRoomTypeArrangements->contains($hotelRoomTypeArrangement)) {
  256. //            $this->hotelRoomTypeArrangements->add($hotelRoomTypeArrangement);
  257. //            $hotelRoomTypeArrangement->setHotelRoomType($this);
  258. //        }
  259. //
  260. //        return $this;
  261. //    }
  262. //
  263. //    public function removeHotelRoomTypeArrangement(HotelRoomTypeArrangement $hotelRoomTypeArrangement): self
  264. //    {
  265. //        if ($this->hotelRoomTypeArrangements->removeElement($hotelRoomTypeArrangement)) {
  266. //            // set the owning side to null (unless already changed)
  267. //            if ($hotelRoomTypeArrangement->getHotelRoomType() === $this) {
  268. //                $hotelRoomTypeArrangement->setHotelRoomType(null);
  269. //            }
  270. //        }
  271. //
  272. //        return $this;
  273. //    }
  275. }