250 lines
9.7 KiB
PHP
250 lines
9.7 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\BookingDto;
|
|
use App\Form\Model\ParticipantDto;
|
|
|
|
/**
|
|
* 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 BookingDto $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(BookingDto $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<int, Service> $services Array of Service objects to filter
|
|
* @param BookingDto $bookingDto The booking data with participant selections
|
|
* @param int $participantIndex The index of the participant currently filling the form
|
|
*
|
|
* @return array<int, Service> Filtered array containing only available services
|
|
*/
|
|
public function filterAvailableServices(array $services, BookingDto $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 (null), treat as unlimited
|
|
if (null === $service->available) {
|
|
return true;
|
|
}
|
|
|
|
// If availability is 0, service is sold out at the API level
|
|
if (0 === $service->available) {
|
|
return false;
|
|
}
|
|
|
|
// For services with positive availability, 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 BookingDto $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, BookingDto $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, treat as available (not unavailable)
|
|
if (null === $service) {
|
|
return false;
|
|
}
|
|
|
|
// If no availability tracking (null), service is unlimited and available
|
|
if (null === $service->available) {
|
|
return false;
|
|
}
|
|
|
|
// If availability is 0, service is sold out at the API level
|
|
if (0 === $service->available) {
|
|
return true;
|
|
}
|
|
|
|
// For services with positive availability, calculate remaining based on booking selections
|
|
$remainingAvailability = $this->calculateRemainingAvailability($bookingDto, $participantIndex);
|
|
|
|
return ($remainingAvailability[$serviceId] ?? $service->available) <= 0;
|
|
}
|
|
|
|
/**
|
|
* Calculate how many times each service has been selected by other participants.
|
|
*
|
|
* @param BookingDto $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(BookingDto $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
|
|
$participantUsage = $this->countParticipantServiceUsage($participant);
|
|
|
|
foreach ($participantUsage as $serviceId => $count) {
|
|
$serviceUsage[$serviceId] = ($serviceUsage[$serviceId] ?? 0) + $count;
|
|
}
|
|
}
|
|
|
|
return $serviceUsage;
|
|
}
|
|
|
|
/**
|
|
* Count service usage for a single participant and add to the usage array.
|
|
*
|
|
* @param ParticipantDto $participant The participant DTO object
|
|
*
|
|
* @return array<int, int> Usage counts keyed by service ID
|
|
*/
|
|
private function countParticipantServiceUsage(ParticipantDto $participant): array
|
|
{
|
|
$serviceUsage = [];
|
|
|
|
// Board service (single selection)
|
|
foreach ($participant->board as $service) {
|
|
if (null !== $service->id) {
|
|
$serviceUsage[$service->id] = ($serviceUsage[$service->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
// Ski pass service (single selection)
|
|
if (null !== $participant->skiPass && null !== $participant->skiPass->id) {
|
|
$serviceUsage[$participant->skiPass->id] = ($serviceUsage[$participant->skiPass->id] ?? 0) + 1;
|
|
}
|
|
|
|
// Parking service (single selection)
|
|
if (null !== $participant->parkingService && null !== $participant->parkingService->id) {
|
|
$serviceUsage[$participant->parkingService->id] = ($serviceUsage[$participant->parkingService->id] ?? 0) + 1;
|
|
}
|
|
|
|
// Transportation services (single selection each)
|
|
if (null !== $participant->transportationOutbound && null !== $participant->transportationOutbound->id) {
|
|
$serviceUsage[$participant->transportationOutbound->id] = ($serviceUsage[$participant->transportationOutbound->id] ?? 0) + 1;
|
|
}
|
|
|
|
if (null !== $participant->transportationInbound && null !== $participant->transportationInbound->id) {
|
|
$serviceUsage[$participant->transportationInbound->id] = ($serviceUsage[$participant->transportationInbound->id] ?? 0) + 1;
|
|
}
|
|
|
|
// Courses (multiple selection)
|
|
foreach ($participant->courses as $course) {
|
|
if (null !== $course->id) {
|
|
$serviceUsage[$course->id] = ($serviceUsage[$course->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
// Additional services (multiple selection)
|
|
foreach ($participant->additionalServices as $additionalService) {
|
|
if (null !== $additionalService->id) {
|
|
$serviceUsage[$additionalService->id] = ($serviceUsage[$additionalService->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
// Rentals (multiple selection)
|
|
foreach ($participant->rentals as $rental) {
|
|
if (null !== $rental->id) {
|
|
$serviceUsage[$rental->id] = ($serviceUsage[$rental->id] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
return $serviceUsage;
|
|
}
|
|
|
|
/**
|
|
* Get all services from the travel data for availability calculation.
|
|
*
|
|
* @param BookingDto $bookingDto The booking data containing travel information
|
|
*
|
|
* @return array<Service> Array of all available services
|
|
*/
|
|
private function getAllServicesFromTravel(BookingDto $bookingDto): array
|
|
{
|
|
$allServices = [];
|
|
|
|
// Get all 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,
|
|
Constants::TOKEN_PARKING,
|
|
];
|
|
|
|
foreach ($additionalServiceTokens as $token) {
|
|
$categoryServices = $bookingDto->travel->getAdditionalServicesBySubTypes($token);
|
|
$allServices = array_merge($allServices, $categoryServices);
|
|
}
|
|
|
|
return $allServices;
|
|
}
|
|
}
|