Application\Model\Booking

Complexity

Total Complexity

32

Size/Duplication

Total Lines	212
Duplicated Lines	0 %

Test Coverage

Coverage

81.82%

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getStatus()	0	3	1
A	setEstimatedEndDate()	0	3	1
A	getEndDate()	0	3	1
A	setEndDate()	0	3	1
A	getBookable()	0	3	1
A	getStartDate()	0	3	1
A	invoiceInitial()	0	11	3
A	__construct()	0	1	1
A	terminate()	0	7	3
A	getParticipantCount()	0	3	1
A	getEndComment()	0	3	1
A	setOwner()	0	13	3
A	setStatus()	0	5	1
A	setParticipantCount()	0	3	1
A	setEndComment()	0	3	1
A	getEstimatedEndDate()	0	3	1
A	getPeriodicPrice()	0	10	2
A	setBookable()	0	13	3
A	setStartComment()	0	3	1
A	setDestination()	0	3	1
A	setStartDate()	0	3	1
A	getStartComment()	0	3	1
A	getDestination()	0	3	1

<?php

declare(strict_types=1);

namespace Application\Model;

use Application\Api\Input\Operator\RunningServicesOperatorType;
use Application\Enum\BookingStatus;
use Application\Repository\BookingRepository;
use Application\Service\Invoicer;
use Application\Traits\HasRemarks;
use Cake\Chronos\Chronos;
use Doctrine\ORM\Mapping as ORM;
use Ecodev\Felix\Model\Traits\HasInternalRemarks;
use GraphQL\Doctrine\Attribute as API;
use Money\Money;

/**
 * A booking linking a user and a bookable.
 */
#[API\Sorting(\Application\Api\Input\Sorting\Bookable::class)]
#[ORM\Entity(BookingRepository::class)]
#[ORM\AssociationOverrides([new ORM\AssociationOverride(name: 'owner', inversedBy: 'bookings')])]
#[ORM\Index(name: 'start_date', columns: ['start_date'])]
#[API\Filter(field: 'custom', operator: RunningServicesOperatorType::class, type: 'UserID')]
class Booking extends AbstractModel
{
    use HasInternalRemarks;
    use HasRemarks;

    #[ORM\Column(type: 'enum', length: 10, options: ['default' => BookingStatus::Application])]
    private BookingStatus $status = BookingStatus::Application;

    #[ORM\Column(type: 'integer', options: ['unsigned' => true, 'default' => 1])]
    private int $participantCount = 1;

    #[ORM\Column(type: 'string', length: 50, options: ['default' => ''])]
    private string $destination = '';

    #[ORM\Column(type: 'text', length: 65535, options: ['default' => ''])]
    private string $startComment = '';

    #[ORM\Column(type: 'text', length: 65535, options: ['default' => ''])]
    private string $endComment = '';

    #[ORM\Column(type: 'datetime')]
    private Chronos $startDate;

    #[ORM\Column(type: 'datetime', nullable: true)]
    private ?Chronos $endDate = null;

    #[ORM\Column(type: 'string', length: 50, options: ['default' => ''])]
    private string $estimatedEndDate = '';

    #[ORM\JoinColumn(onDelete: 'CASCADE')]
    #[ORM\ManyToOne(targetEntity: Bookable::class, inversedBy: 'bookings')]
    private ?Bookable $bookable = null;

    public function __construct() {}

    public function setOwner(?User $owner = null): void
    {
        if ($this->getOwner()) {
            $this->getOwner()->bookingRemoved($this);
        }

        parent::setOwner($owner);

        if ($this->getOwner()) {
            $this->getOwner()->bookingAdded($this);
        }

        $this->invoiceInitial();
    }

    /**
     * Total count of participant, at least 1.
     */
    public function getParticipantCount(): int
    {
        return $this->participantCount;
    }

    public function setParticipantCount(int $participantCount): void
    {
        $this->participantCount = $participantCount;
    }

    public function getDestination(): string
    {
        return $this->destination;
    }

    public function setDestination(string $destination): void
    {
        $this->destination = $destination;
    }

    public function getStartComment(): string
    {
        return $this->startComment;
    }

    public function setStartComment(string $startComment): void
    {
        $this->startComment = $startComment;
    }

    public function getEndComment(): string
    {
        return $this->endComment;
    }

    public function setEndComment(string $endComment): void
    {
        $this->endComment = $endComment;
    }

    public function getStartDate(): Chronos
    {
        return $this->startDate;
    }

    public function setStartDate(Chronos $startDate): void
    {
        $this->startDate = $startDate;
    }

    public function getEndDate(): ?Chronos
    {
        return $this->endDate;
    }

    public function setEndDate(?Chronos $endDate): void
    {
        $this->endDate = $endDate;
    }

    public function getEstimatedEndDate(): string
    {
        return $this->estimatedEndDate;
    }

    public function setEstimatedEndDate(string $estimatedEndDate): void
    {
        $this->estimatedEndDate = $estimatedEndDate;
    }

    /**
     * Get bookable, may be null for "my own material" case.
     */
    public function getBookable(): ?Bookable
    {
        return $this->bookable;
    }

    /**
     * Set bookable.
     */
    public function setBookable(?Bookable $bookable): void
    {
        if ($this->bookable) {
            $this->bookable->bookingRemoved($this);
        }

        $this->bookable = $bookable;

        if ($this->bookable) {
            $this->bookable->bookingAdded($this);
        }

        $this->invoiceInitial();
    }

    public function getStatus(): BookingStatus
    {
        return $this->status;
    }

    public function setStatus(BookingStatus $status): void
    {
        $previousStatus = $this->status;
        $this->status = $status;
        $this->invoiceInitial($previousStatus);
    }

    /**
     * Mark the booking as terminated with an optional comment,
     * but only if not already terminated.
     */
    public function terminate(?string $comment): void
    {
        // Booking can only be terminated once
        if (!$this->getEndDate()) {
            $this->setEndDate(new Chronos());
            if ($comment) {
                $this->setEndComment($comment);
            }
        }
    }

    /**
     * If the booking is complete, will make initial invoicing.
     */
    private function invoiceInitial(?BookingStatus $previousStatus = null): void
    {
        if (!$this->getOwner() || !$this->getBookable()) {
            return;
        }

        global $container;

        /** @var Invoicer $invoicer */
        $invoicer = $container->get(Invoicer::class);
        $invoicer->invoiceInitial($this->getOwner(), $this, $previousStatus);
    }

    /**
     * Returns the next invoiceable periodic price.
     *
     * In case it uses shared admin_assigned bookables, the price is divided by the number of usages
     */
    public function getPeriodicPrice(): Money
    {
        $bookable = $this->getBookable();
        $bookings = $bookable->getPeriodicPriceDividerBookings();

        if (!$bookings) {
            return $bookable->getPeriodicPrice();
        }

        return $bookable->getPeriodicPrice()->divide(count($bookings));
    }
}