222 lines
9.1 KiB
PHP
222 lines
9.1 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Service;
|
|
|
|
use App\BusProNet\Constants;
|
|
use App\BusProNet\Model\Service;
|
|
use App\BusProNet\Utility\DirectionMapper;
|
|
use App\Form\Model\BookingCreateDto;
|
|
|
|
/**
|
|
* Calculates dynamic service availability based on current booking selections.
|
|
*
|
|
* This service tracks how many participants have selected each service within
|
|
* the current booking session and calculates remaining availability for
|
|
* display to other participants. This prevents overbooking within a single
|
|
* booking workflow.
|
|
*/
|
|
class ServiceAvailabilityCalculator
|
|
{
|
|
/**
|
|
* Calculate remaining availability for all services based on current participant selections.
|
|
*
|
|
* @param BookingCreateDto $bookingDto The booking data with participant selections
|
|
* @param int $currentParticipantIndex The index of the participant currently filling the form
|
|
*
|
|
* @return array<int, int> Array mapping service IDs to remaining availability counts
|
|
*/
|
|
public function calculateRemainingAvailability(BookingCreateDto $bookingDto, int $currentParticipantIndex): array
|
|
{
|
|
$serviceUsage = $this->calculateServiceUsage($bookingDto, $currentParticipantIndex);
|
|
$remainingAvailability = [];
|
|
|
|
// Get all services from the travel data
|
|
$allServices = $this->getAllServicesFromTravel($bookingDto);
|
|
|
|
foreach ($allServices as $service) {
|
|
$originalAvailability = $service->available ?? null;
|
|
$usedCount = $serviceUsage[$service->id] ?? 0;
|
|
|
|
// Only track services that have availability limits set
|
|
if (null !== $originalAvailability && $originalAvailability > 0) {
|
|
$remaining = max(0, $originalAvailability - $usedCount);
|
|
$remainingAvailability[$service->id] = $remaining;
|
|
}
|
|
}
|
|
|
|
return $remainingAvailability;
|
|
}
|
|
|
|
/**
|
|
* Filter services array to only include those with remaining availability.
|
|
*
|
|
* @param array $services Array of Service objects to filter
|
|
* @param BookingCreateDto $bookingDto The booking data with participant selections
|
|
* @param int $participantIndex The index of the participant currently filling the form
|
|
*
|
|
* @return array Filtered array containing only available services
|
|
*/
|
|
public function filterAvailableServices(array $services, BookingCreateDto $bookingDto, int $participantIndex): array
|
|
{
|
|
$remainingAvailability = $this->calculateRemainingAvailability($bookingDto, $participantIndex);
|
|
|
|
return array_filter($services, function (Service $service) use ($remainingAvailability) {
|
|
// If service has no availability limit set, treat as unlimited
|
|
if (null === $service->available || $service->available <= 0) {
|
|
return true;
|
|
}
|
|
|
|
// For services with availability limits, check remaining availability
|
|
return ($remainingAvailability[$service->id] ?? $service->available) > 0;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if a specific service is unavailable (sold out) for the current participant.
|
|
*
|
|
* @param int $serviceId The ID of the service to check
|
|
* @param BookingCreateDto $bookingDto The booking data with participant selections
|
|
* @param int $participantIndex The index of the participant currently filling the form
|
|
*
|
|
* @return bool True if the service is unavailable (has availability limit and remaining is 0)
|
|
*/
|
|
public function isServiceUnavailable(int $serviceId, BookingCreateDto $bookingDto, int $participantIndex): bool
|
|
{
|
|
$allServices = $this->getAllServicesFromTravel($bookingDto);
|
|
$service = null;
|
|
|
|
foreach ($allServices as $serviceObj) {
|
|
if ($serviceObj->id === $serviceId) {
|
|
$service = $serviceObj;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If service not found or has no availability limit, it's not unavailable
|
|
if (null === $service || null === $service->available || $service->available <= 0) {
|
|
return false;
|
|
}
|
|
|
|
$remainingAvailability = $this->calculateRemainingAvailability($bookingDto, $participantIndex);
|
|
|
|
return ($remainingAvailability[$serviceId] ?? $service->available) <= 0;
|
|
}
|
|
|
|
/**
|
|
* Calculate how many times each service has been selected by other participants.
|
|
*
|
|
* @param BookingCreateDto $bookingDto The booking data with participant selections
|
|
* @param int $currentParticipantIndex The index of the participant currently filling the form
|
|
*
|
|
* @return array<int, int> Array mapping service IDs to usage counts
|
|
*/
|
|
private function calculateServiceUsage(BookingCreateDto $bookingDto, int $currentParticipantIndex): array
|
|
{
|
|
$serviceUsage = [];
|
|
|
|
foreach ($bookingDto->participants as $index => $participant) {
|
|
// Skip the current participant to avoid counting their potential selections
|
|
if ($index === $currentParticipantIndex) {
|
|
continue;
|
|
}
|
|
|
|
// Count service selections for this participant
|
|
$this->countParticipantServiceUsage($participant, $serviceUsage);
|
|
}
|
|
|
|
return $serviceUsage;
|
|
}
|
|
|
|
/**
|
|
* Count service usage for a single participant and add to the usage array.
|
|
*
|
|
* @param mixed $participant The participant DTO object
|
|
* @param array $serviceUsage Reference to the service usage array to update
|
|
*/
|
|
private function countParticipantServiceUsage($participant, array &$serviceUsage): void
|
|
{
|
|
// Board service (single selection)
|
|
if (isset($participant->board) && $participant->board instanceof Service) {
|
|
$serviceUsage[$participant->board->id] = ($serviceUsage[$participant->board->id] ?? 0) + 1;
|
|
}
|
|
|
|
// Ski pass service (single selection)
|
|
if (isset($participant->skiPass) && $participant->skiPass instanceof Service) {
|
|
$serviceUsage[$participant->skiPass->id] = ($serviceUsage[$participant->skiPass->id] ?? 0) + 1;
|
|
}
|
|
|
|
// Transportation services (single selection each)
|
|
if (isset($participant->transportationOutbound) && $participant->transportationOutbound instanceof Service) {
|
|
$serviceUsage[$participant->transportationOutbound->id] = ($serviceUsage[$participant->transportationOutbound->id] ?? 0) + 1;
|
|
}
|
|
|
|
if (isset($participant->transportationInbound) && $participant->transportationInbound instanceof Service) {
|
|
$serviceUsage[$participant->transportationInbound->id] = ($serviceUsage[$participant->transportationInbound->id] ?? 0) + 1;
|
|
}
|
|
|
|
// Courses (multiple selection)
|
|
if (isset($participant->courses) && is_array($participant->courses)) {
|
|
foreach ($participant->courses as $course) {
|
|
if ($course instanceof Service) {
|
|
$serviceUsage[$course->id] = ($serviceUsage[$course->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Additional services (multiple selection)
|
|
if (isset($participant->additionalServices) && is_array($participant->additionalServices)) {
|
|
foreach ($participant->additionalServices as $additionalService) {
|
|
if ($additionalService instanceof Service) {
|
|
$serviceUsage[$additionalService->id] = ($serviceUsage[$additionalService->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Rentals (multiple selection)
|
|
if (isset($participant->rentals) && is_array($participant->rentals)) {
|
|
foreach ($participant->rentals as $rental) {
|
|
if ($rental instanceof Service) {
|
|
$serviceUsage[$rental->id] = ($serviceUsage[$rental->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all services from the travel data for availability calculation.
|
|
*
|
|
* @param BookingCreateDto $bookingDto The booking data containing travel information
|
|
*
|
|
* @return array<Service> Array of all available services
|
|
*/
|
|
private function getAllServicesFromTravel(BookingCreateDto $bookingDto): array
|
|
{
|
|
$allServices = [];
|
|
|
|
// Get transportation services
|
|
$transportationServices = array_merge(
|
|
$bookingDto->travel->getTransportationServicesByDirection(DirectionMapper::OUTBOUND_TRAVEL) ?? [],
|
|
$bookingDto->travel->getTransportationServicesByDirection(DirectionMapper::INBOUND_TRAVEL) ?? []
|
|
);
|
|
$allServices = array_merge($allServices, $transportationServices);
|
|
|
|
// Get additional services by category using proper constants
|
|
$additionalServiceTokens = [
|
|
Constants::TOKEN_COURSES,
|
|
Constants::TOKEN_ADDITIONAL,
|
|
Constants::TOKEN_RENTALS,
|
|
Constants::TOKEN_SKI_PASS,
|
|
Constants::TOKEN_BOARD,
|
|
];
|
|
|
|
foreach ($additionalServiceTokens as $token) {
|
|
$categoryServices = $bookingDto->travel->getAdditionalServicesBySubTypes($token) ?? [];
|
|
$allServices = array_merge($allServices, $categoryServices);
|
|
}
|
|
|
|
return $allServices;
|
|
}
|
|
}
|