src/Entity/Property.php line 361

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiFilter;
  7. use ApiPlatform\Core\Annotation\ApiResource;
  8. use App\Fiken\Api\FikenEnv;
  9. use DateTimeImmutable;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Doctrine\Common\Collections\Criteria;
  13. use Doctrine\Common\Collections\Expr\Expression;
  14. use Doctrine\Common\Collections\Selectable;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  17. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  18. use Symfony\Component\Serializer\Annotation\Groups;
  19. use Symfony\Component\Serializer\Annotation\SerializedName;
  21. /**
  22.  * @ApiResource(
  23.  *  attributes={"security"="is_granted('ROLE_USER')"},
  24.  *  itemOperations = {
  25.  *      "get" = {
  26.  *          "normalization_context" = {"groups" = {
  27.  *              "property:read", "property:item:get"
  28.  *          }}
  29.  *      },
  30.  *      "put" = {
  31.  *          "denormalization_context" = {"groups" = {
  32.  *              "property:item:put"
  33.  *          }}
  34.  *      }
  35.  *  },
  36.  *  collectionOperations = {
  37.  *      "get" = {
  38.  *          "normalization_context" = {"groups" = {
  39.  *              "property:read", "property:item:get"
  40.  *          }}
  41.  *      }
  42.  *  }
  43.  * )
  44.  * @ApiFilter(OrderFilter::class, properties={"section": "desc"})
  45.  * @ORM\Entity(repositoryClass="App\Repository\PropertyRepository")
  46.  */
  47. class Property
  48. {
  49.     /**
  50.      * @ORM\Id()
  51.      * @ORM\GeneratedValue()
  52.      * @ORM\Column(type="integer")
  53.      * @Groups({
  54.      *  "property:read", "property:item:get",
  55.      *  "booking:read", "booking:item:get"
  56.      * })
  57.      */
  58.     private $id;
  60.     /**
  61.      * @ORM\Column(type="string", length=255)
  62.      * @Groups({
  63.      *  "property:read", "property:item:get",
  64.      *  "booking:read", "booking:item:get"
  65.      * })
  66.      */
  67.     private $section;
  70.     /**
  71.      * @ORM\Column(type="json")
  72.      * @Groups({
  73.      *  "property:read", "property:item:get",
  74.      *  "booking:read", "booking:item:get"
  75.      * })
  76.      */
  77.     private $address = [];
  79.     /**
  80.      * @ORM\Column(type="text")
  81.      * @Groups({"property:read", "property:item:get"})
  82.      * @Groups({
  83.      *  "property:read", "property:item:get",
  84.      *  "booking:read", "booking:item:get"
  85.      * })
  86.      */
  87.     private $entryDescription;
  89.     /**
  90.      * @ORM\Column(type="time")
  91.      * @Groups({
  92.      *  "property:read", "property:item:get",
  93.      *  "booking:read", "booking:item:get"
  94.      * })
  95.      */
  96.     private $checkinTime;
  98.     /**
  99.      * @ORM\Column(type="time")
  100.      * @Groups({
  101.      *  "property:read", "property:item:get",
  102.      *  "booking:read", "booking:item:get"
  103.      * })
  104.      */
  105.     private $checkoutTime;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity="App\Entity\Booking", mappedBy="property", cascade={"persist"})
  109.      */
  110.     private $bookings;
  112.     /**
  113.      * @ORM\Column(type="json")
  114.      * @Groups({
  115.      *  "property:read", "property:item:get",
  116.      * })
  117.      */
  118.     private $cal = [];
  120.     /**
  121.      * @ORM\Column(type="json", nullable=true)
  122.      */
  123.     private $notes = [];
  125.     /**
  126.      * @ORM\Column(type="boolean")
  127.      */
  128.     private $disabled = false;
  130.     /**
  131.      * @ORM\ManyToOne(targetEntity=User::class)
  132.      */
  133.     private $responsible;
  135.     /**
  136.      * @ORM\Column(type="dateinterval", nullable=true)
  137.      */
  138.     private $cleaning_duration;
  140.     /**
  141.      * @ORM\Column(type="integer", nullable=true)
  142.      */
  143.     private $guests;
  145.     /**
  146.      * @ORM\Column(type="integer")
  147.      */
  148.     private $double_bedrooms;
  150.     /**
  151.      * @ORM\Column(type="integer")
  152.      */
  153.     private $single_rooms;
  155.     /**
  156.      * @ORM\Column(type="dateinterval")
  157.      */
  158.     private $driving_duration;
  160.     /**
  161.      * @ORM\Column(type="datetime_immutable")
  162.      */
  163.     private $created_at;
  165.     /**
  166.      * @ORM\OneToMany(targetEntity=Invoice::class, mappedBy="property", orphanRemoval=true)
  167.      */
  168.     private $invoices;
  170.     /**
  171.      * @ORM\Column(type="float")
  172.      */
  173.     private $base_fee_cleaning;
  175.     /**
  176.      * @ORM\Column(type="boolean")
  177.      */
  178.     private $vat_registered;
  180.     /**
  181.      * @ORM\Column(type="smallint")
  182.      */
  183.     private $host_share;
  185.     /**
  186.      * @ORM\ManyToOne(targetEntity=PropertyOwner::class, inversedBy="properties")
  187.      */
  188.     private $owner;
  190.     /**
  191.      * @ORM\Column(type="bigint", nullable=true)
  192.      */
  193.     private $projectId;
  195.     /**
  196.      * @ORM\Column(type="integer")
  197.      */
  198.     private $importAttempt;
  200.     /**
  201.      * @ORM\ManyToMany(targetEntity=MqttDoorLock::class, inversedBy="properties")
  202.      */
  203.     private $doorLocks;
  205.     /**
  206.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="propertyUser")
  207.      */
  208.     private $users;
  210.     /**
  211.      * @ORM\OneToMany(targetEntity=BookingProvider::class, mappedBy="property", cascade={"persist"})
  212.      */
  213.     private $bookingProviders;
  215.     /**
  216.      * @ORM\OneToOne(targetEntity=PropertyAddress::class, mappedBy="property", cascade={"persist", "remove"})
  217.      */
  218.     private $propertyAddress;
  220.     public function __construct() {
  221.         $this->bookings = new ArrayCollection();
  222.         $this->invoices = new ArrayCollection();
  223.         $this->doorLocks = new ArrayCollection();
  224.         $this->users = new ArrayCollection();
  225.         $this->bookingProviders = new ArrayCollection();
  226.     }
  228.     public function getId(): ?int {
  229.         return $this->id;
  230.     }
  232.     public function getAddress(): ?array {
  233.         return $this->address;
  234.     }
  236.     public function getStreetAddr(): ?string {
  237.         $addr = $this->getAddress() ? $this->getAddress()['address'] : "";
  238.         $addr = explode(',', $addr);
  239.         return trim($addr[0], ',');
  240.     }
  242.     public function getPostalCode(): ?string {
  243.         $addr = $this->getAddress() ? $this->getAddress()['address'] : "";
  244.         $addr = explode(',', $addr);
  246.         if (sizeof($addr) == 1)
  247.             return '9000';
  249.         return trim(explode(' ', trim($addr[1]))[0], ',');
  250.     }
  252.     public function getPostalCity(): ?string {
  253.         $addr = $this->getAddress() ? $this->getAddress()['address'] : "";
  254.         $addr = explode(',', $addr);
  256.         //dump($this, $addr);
  257.         if (sizeof($addr) == 1)
  258.             return 'Tromsø';
  260.         return trim(explode(" ", $addr[sizeof($addr)-1])[1]);
  261.     }
  263.     public function setAddress(array $address): self {
  264.         $this->address = $address;
  266.         return $this;
  267.     }
  269.     public function getEntryDescription(): ?string {
  270.         return $this->entryDescription;
  271.     }
  273.     public function setEntryDescription(string $entryDescription): self {
  274.         $this->entryDescription = $entryDescription;
  275.         return $this;
  276.     }
  277.     
  278.     private static function diffTimeOfDay(\DateTimeInterface $now): ?\DateInterval {
  279.         return static::setTimeToMidnight($now)?->diff($now);
  280.     }
  282.     private static function setTimeToDiff(?\DateTimeInterface $dateTime, ?\DateInterval $diff): ?\DateTimeImmutable {
  283.         return $diff && $dateTime ? static::setTimeToMidnight($dateTime)?->add($diff) : $diff;
  284.     }
  286.     private static function setTimeToMidnight(?\DateTimeInterface $dateTime): ?\DateTimeImmutable {
  287.         return $dateTime ? \DateTimeImmutable::createFromInterface($dateTime)->setTime(...Booking::START_OF_DAY) : null;
  288.     }
  290.     public function getCheckinTime(): ?\DateTimeInterface {
  291.         return $this->checkinTime;
  292.     }
  294.     public function getTodaysCheckinTime(?\DateTimeInterface $dateTime = null): ?\DateTimeImmutable {
  295.         return static::setTimeToDiff($dateTime ??= $this->checkinTime, static::diffTimeOfDay($this->checkinTime));
  296.     }
  298.     public function setCheckinTime(\DateTimeImmutable $checkinTime): self {
  299.         $this->checkinTime = $checkinTime;
  300.         return $this;
  301.     }
  303.     public function getCheckoutTime(): ?\DateTimeInterface {
  304.         return $this->checkoutTime;
  305.     }
  307.     public function getTodaysCheckoutTime(?\DateTimeInterface $dateTime = null): ?\DateTimeImmutable {
  308.         return static::setTimeToDiff($dateTime ??= $this->checkoutTime, static::diffTimeOfDay($this->checkoutTime));
  309.     }
  311.     public function setCheckoutTime(\DateTimeImmutable $checkoutTime): self {
  312.         $this->checkoutTime = $checkoutTime;
  313.         return $this;
  314.     }
  316.     /**
  317.      * @return Collection|Booking[]
  318.      */
  319.     public function getBookings(null|string|Expression ...$criterias): Collection {
  320.         return $this->selectBookings()->matching(self::getBookingsCriteria(...$criterias));
  321.     }
  323.     public function getBookingsCriteria(null|string|Expression ...$criterias): Criteria {
  324.         $criteria = Criteria::create();
  326.         $expressions = array_filter($criterias, fn(null|string|Expression $x): bool => $x instanceof Expression);
  327.         $dates = array_filter($criterias, fn(null|string|Expression $x): bool => is_string($x));
  329.         if (($dn = sizeof($dates)) > 2)
  330.             throw new \InvalidArgumentException(sprintf("To many string types for 'getBookings', max: 2, got: %d", $dn));
  332.         $types = ['checkin', 'checkout'];
  334.         $dates = sizeof($dates = array_map(fn($t): Expression => sizeof($res = array_map(
  335.             fn ($d, $id): Expression => Criteria::expr()->{($id % 2) ? 'lte' : 'gte'}($t, 
  336.                 (new \DateTimeImmutable($d))?->setTime(
  337.                     ...($id % 2 ? Booking::END_OF_DAY : Booking::START_OF_DAY)
  338.                 )),
  339.                 $dates, array_keys($dates)
  340.             )) > 1 ? Criteria::expr()->andX(...$res) : $res[0] ?? null,
  341.             array_splice($types, sizeof($types) - sizeof($dates), sizeof($dates)), 
  342.         )) > 1 ? Criteria::expr()->orX(...$dates) : $dates[0] ?? null;
  344.         $where = array_filter([$dates, ...$expressions], fn($a) => $a != null);
  346.         if ($where)
  347.             $criteria->andWhere(Criteria::expr()->andX(...$where));
  349.         return $criteria->orderBy(['checkin' => 'ASC']);
  350.     }
  352.     public function getConflictingBookings(string $fromFormat = null): Collection {
  353.         return $this->getBookings($fromFormat, 
  354.             Criteria::expr()->neq('blocking', 1),
  355.             Criteria::expr()->isNull('cancelledAt')
  356.         )->filter(
  357.             fn(Booking $b): bool => !$b->getConflictingBookings()->isEmpty()
  358.         );
  359.     }
  361.     public function getUncleanBookings(?string $dateFormat = null, Expression ...$criterias): Collection {
  362.         return $this->getBookings(
  363.             Criteria::expr()->neq('blocking', 1), Booking::cleanCriteria(false),
  364.             Criteria::expr()->lte('checkout', (new \DateTimeImmutable($dateFormat))->setTime(...Booking::END_OF_DAY)), ...$criterias
  365.         );
  366.     }
  368.     public function isClean(?string $dateFormat = null): bool {
  369.         return $this->getUncleanBookings($dateFormat)->isEmpty();
  370.     }
  372.     public function selectBookings(): Selectable {
  373.         return $this->bookings;
  374.     }
  376.     public function addBooking(Booking $booking): self {
  377.         if (!$this->bookings->contains($booking)) {
  378.             $this->bookings[] = $booking;
  379.             $booking->setProperty($this);
  380.         }
  381.         return $this;
  382.     }
  384.     public function removeBooking(Booking $booking): self {
  385.         if ($this->bookings->contains($booking)) {
  386.             $this->bookings->removeElement($booking);
  387.             // set the owning side to null (unless already changed)
  388.             if ($booking->getProperty() === $this) {
  389.                 $booking->setProperty(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  396.     public function getBookingProviderUrls(): ?array {
  397.         return $this->getBookingProviders()->map(fn(BookingProvider $bp): string => $bp->getCalendarUrl())->toArray();
  398.     }
  400.     public function getCal(): ?array {
  401.         return $this->getBookingProviderUrls();
  402.     }
  404.     public function setCal(array $cal): self {
  405.         $this->cal = $cal;
  407.         return $this;
  408.     }
  410.     public function getSection(): ?string {
  411.         return $this->section; // . ($this->disabled ? " (!! Contract ended, SKIP !!) " : "");
  412.     }
  414.     public function isDisabled(): bool {
  415.         return $this->disabled === true;
  416.     }
  418.     public function setSection(string $Section): self {
  419.         $this->section = $Section;
  421.         return $this;
  422.     }
  424.     /**
  425.      * @Groups({
  426.      *  "booking:read", "booking:item:get", "booking:item:put",
  427.      *  "property:read", "property:item:get"
  428.      * })
  429.      */
  430.     public function getNotes(): ?array {
  431.         return $this->notes;
  432.     }
  434.     /**
  435.      * @Groups({"booking:item:put"})
  436.      */
  437.     public function setNote(string $text): self {
  438.         $match =  [];
  439.         preg_match('/^((?:[^\/]*\/)*[\d]+):(.+)$/', $text, $match);
  441.         if (count($match) == 3) {
  442.             $this->notes[$match[1]] = $match[2];
  443.             try {
  444.                 $this->getBookings(
  445.                     Criteria::expr()->eq('id', intval(substr($match[1], strrpos($match[1], '/')+1)))
  446.                 )->first()?->setEmployeeNote($match[2]);
  447.             } catch(\Exception $e) {
  448.                 // It didn't work obviusly
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     /**
  456.      * @Groups({"booking:item:put"})
  457.      */
  458.     public function setNotes(array $array): self {
  460.         $this->notes = sizeof($array) == 0 ? null : $array;
  461.         return $this;
  462.     }
  464.     public function getResponsible(): ?User {
  465.         return $this->responsible;
  466.     }
  468.     public function getStartCleaningBy(): ?\DateTimeImmutable {
  469.         return (
  470.             fn(\DateTimeImmutable $d): \DateTimeImmutable => $d->sub($this->getCleaningDuration())
  471.         )($this->getTodaysCheckinTime());
  472.     }
  474.     public function getCleaningDuration(): ?\DateInterval {
  475.         return $this->cleaning_duration ?? (new \DateInterval('PT0H'));
  476.     }
  478.     public function setCleaningDuration(?\DateInterval $cleaning_duration): self {
  479.         $this->cleaning_duration = $cleaning_duration;
  481.         return $this;
  482.     }
  484.     /**
  485.      * @SerializedName("cleaningDuration")
  486.      * @Groups({
  487.      *  "property:read", "property:item:get",
  488.      *  "booking:read", "booking:item:get"
  489.      * })
  490.      */
  491.     public function getCleaningDurationMilliseconds(): ?int {
  492.         if (!$this->getCleaningDuration())
  493.             return null;
  495.         return self::durationToMilliseconds($this->getCleaningDuration());
  496.     }
  498.     public static function durationToMilliseconds(?\DateInterval $di): int {
  500.         if ($di == null)
  501.             return 0;
  503.         $ms = 1000;
  504.         return $di->d * (60 * 60 * 24 * $ms) +
  505.             $di->h * (60 * 60 * $ms) +
  506.             $di->i * (60 * $ms) +
  507.             $di->s * $ms;
  508.     }
  510.     /**
  511.      * @Groups({
  512.      *  "booking:read", "booking:item:get"
  513.      * })
  514.      * */
  515.     public function getNumBedrooms(): ?int {
  516.         return $this->getDoubleBedrooms() + $this->getSingleRooms();
  517.     }
  519.     /**
  520.      * @SerializedName("maxGuests")
  521.      * @Groups({"booking:read", "booking:item:get"})
  522.      */
  523.     public function getGuests(): int {
  524.         return $this->guests === null ? $this->getDoubleBedrooms() * 2 + $this->getSingleRooms() : $this->guests;
  525.     }
  527.     // public function setGuests(int $guests): self
  528.     // {
  529.     //     $this->guests = $guests;
  531.     //     return $this;
  532.     // }
  534.     public function getDoubleBedrooms(): int {
  535.         return $this->double_bedrooms;
  536.     }
  538.     public function setDoubleBedrooms(int $double_bedrooms): self {
  539.         $this->double_bedrooms = $double_bedrooms;
  541.         return $this;
  542.     }
  544.     public function getExtraBeds(): int {
  545.         return $this->getGuests() - ($this->getDoubleBedrooms() * 2 + $this->getSingleRooms());
  546.     }
  548.     public function getSingleRooms(): ?int {
  549.         return $this->single_rooms;
  550.     }
  552.     public function setSingleRooms(int $single_rooms): self {
  553.         $this->single_rooms = $single_rooms;
  555.         return $this;
  556.     }
  558.     /**
  559.      * @SerializedName("drivingDuration")
  560.      * @Groups({
  561.      *  "property:read", "property:item:get",
  562.      *  "booking:read", "booking:item:get"
  563.      * })
  564.      */
  565.     public function getDrivingDurationMilliseconds(): ?int {
  566.         return self::durationToMilliseconds($this->getDrivingDuration());
  567.     }
  569.     public function getDrivingDuration(): ?\DateInterval {
  570.         return $this->driving_duration;
  571.     }
  573.     public function setDrivingDuration(\DateInterval $driving_duration): self {
  574.         $this->driving_duration = $driving_duration;
  576.         return $this;
  577.     }
  579.     public function getCreatedAt(): ?\DateTimeImmutable {
  580.         return $this->created_at;
  581.     }
  583.     public function setCreatedAt(\DateTimeImmutable $created_at): self {
  584.         $this->created_at = $created_at;
  586.         return $this;
  587.     }
  590.     /**
  591.      * @Groups({
  592.      *  "property:read", "property:item:get"
  593.      * })
  594.      **/
  595.     public function hasInvoicableBookings(): bool {
  596.         return false;
  597.     }
  599.     /**
  600.      * @return Collection|Invoice[]
  601.      */
  602.     public function getInvoices(): Collection {
  603.         return $this->invoices;
  604.     }
  606.     public function addInvoice(Invoice $invoice): self {
  607.         if (!$this->invoices->contains($invoice)) {
  608.             $this->invoices[] = $invoice;
  609.             $invoice->setProperty($this);
  610.         }
  612.         return $this;
  613.     }
  615.     public function removeInvoice(Invoice $invoice): self {
  616.         if ($this->invoices->removeElement($invoice)) {
  617.             // set the owning side to null (unless already changed)
  618.             if ($invoice->getProperty() === $this) {
  619.                 $invoice->setProperty(null);
  620.             }
  621.         }
  623.         return $this;
  624.     }
  626.     /**
  627.      * @Groups({
  628.      *  "booking:read"
  629.      * })
  630.      **/
  631.     public function getBaseFeeCleaning(): ?float {
  632.         return $this->base_fee_cleaning;
  633.     }
  635.     public function setBaseFeeCleaning(float $base_fee_cleaning): self {
  636.         $this->base_fee_cleaning = $base_fee_cleaning;
  638.         return $this;
  639.     }
  641.     /**
  642.      * @Groups({
  643.      *  "booking:read"
  644.      * })
  645.      **/
  646.     public function getVatRegistered(): ?bool {
  647.         return $this->vat_registered;
  648.     }
  650.     public function setVatRegistered(bool $vat_registered): self {
  651.         $this->vat_registered = $vat_registered;
  653.         return $this;
  654.     }
  656.     /**
  657.      * @Groups({
  658.      *  "booking:read"
  659.      * })
  660.      */
  662.     public function getHostShare(): ?int {
  663.         return $this->host_share;
  664.     }
  666.     public function setHostShare(int $host_share): self {
  667.         $this->host_share = $host_share;
  669.         return $this;
  670.     }
  672.     public function getOwner(): ?PropertyOwner {
  673.         return $this->owner;
  674.     }
  676.     public function setOwner(?PropertyOwner $owner): self {
  677.         $this->owner = $owner;
  679.         return $this;
  680.     }
  682.     public function getProjectId(FikenEnv $fikenEnv = FikenEnv::DEBUG): ?int {
  683.         return $fikenEnv == FikenEnv::PROD ? $this->projectId : $this->getOwner()->getTestProjectId();
  684.     }
  686.     public function setProjectId(int $projectId): self {
  687.         $this->projectId = $projectId;
  689.         return $this;
  690.     }
  692.     /**
  693.      * @Groups({
  694.      *  "booking:read"
  695.      * })
  696.      */
  697.     public function isInvoiceReady(): ?bool {
  698.         return $this->owner != null && $this->projectId != null;
  699.     }
  701.     public function getImportAttempt(): ?int {
  702.         return $this->importAttempt;
  703.     }
  705.     public function setImportAttempt(int $importAttempt): self {
  706.         $this->importAttempt = $importAttempt;
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, MqttDoorLock>
  712.      * @SerializedName("doorLocks")
  713.      * @Groups({
  714.      *  "property:read", "property:item:get",
  715.      *  "booking:read", "booking:item:get"
  716.      * })
  717.      */
  718.     public function getDoorLocks(): Collection {
  719.         return $this->doorLocks;
  720.     }
  722.     public function addDoorLock(MqttDoorLock $doorLock): self {
  723.         if (!$this->doorLocks->contains($doorLock)) {
  724.             $this->doorLocks[] = $doorLock;
  725.         }
  727.         return $this;
  728.     }
  730.     public function removeDoorLock(MqttDoorLock $doorLock): self {
  731.         $this->doorLocks->removeElement($doorLock);
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return Collection<int, User>
  738.      */
  739.     public function getUsers(): Collection {
  740.         return $this->users;
  741.     }
  743.     public function addUser(User $user): self {
  744.         if (!$this->users->contains($user)) {
  745.             $this->users[] = $user;
  746.             $user->setPropertyUser($this);
  747.         }
  749.         return $this;
  750.     }
  752.     public function removeUser(User $user): self {
  753.         if ($this->users->removeElement($user)) {
  754.             // set the owning side to null (unless already changed)
  755.             if ($user->getPropertyUser() === $this) {
  756.                 $user->setPropertyUser(null);
  757.             }
  758.         }
  760.         return $this;
  761.     }
  763.     /**
  764.      * @return Collection<int, BookingProvider>
  765.      */
  766.     public function getBookingProviders(): Collection {
  767.         return $this->bookingProviders;
  768.     }
  770.     public function addBookingProvider(BookingProvider $bookingProvider): self {
  771.         if (!$this->bookingProviders->contains($bookingProvider)) {
  772.             $this->bookingProviders[] = $bookingProvider;
  773.             $bookingProvider->setProperty($this);
  774.         }
  776.         return $this;
  777.     }
  779.     public function removeBookingProvider(BookingProvider $bookingProvider): self {
  780.         if ($this->bookingProviders->removeElement($bookingProvider)) {
  781.             // set the owning side to null (unless already changed)
  782.             if ($bookingProvider->getProperty() === $this) {
  783.                 $bookingProvider->setProperty(null);
  784.             }
  785.         }
  787.         return $this;
  788.     }
  790.     public function getPropertyAddress(): ?PropertyAddress {
  791.         return $this->propertyAddress;
  792.     }
  794.     public function setPropertyAddress(PropertyAddress $propertyAddress): self {
  795.         $this->propertyAddress = $propertyAddress;
  796.         return $this;
  797.     }
  800. }