378 lines
15 KiB
PHP
378 lines
15 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Service;
|
|
|
|
use App\BusProNet\Model\Insurance;
|
|
use App\BusProNet\Traits\SortByPriceTrait;
|
|
use App\Form\Model\BookingDto;
|
|
use App\Form\Model\ParticipantDto;
|
|
use App\Model\InsuranceEligibilityCriteria;
|
|
use Carbon\Carbon;
|
|
|
|
/**
|
|
* Service for matching insurances to participants based on eligibility criteria.
|
|
*
|
|
* Evaluates insurance constraints including age limits, travel dates, booking windows,
|
|
* travel price ranges, and duration limits to determine which insurances are available
|
|
* for specific participants and booking scenarios.
|
|
*/
|
|
class InsuranceMatchingService
|
|
{
|
|
use SortByPriceTrait;
|
|
|
|
public function __construct(
|
|
private readonly BookingPriceCalculatorService $priceCalculatorService,
|
|
) {
|
|
}
|
|
|
|
/**
|
|
* Filters insurances based on participant and booking criteria.
|
|
*
|
|
* @param array<Insurance> $insurances Available insurances to filter
|
|
* @param ParticipantDto $participant The participant to match insurances for
|
|
* @param BookingDto $booking The booking context for additional criteria
|
|
*
|
|
* @return array<Insurance> Filtered array of eligible insurances
|
|
*/
|
|
public function getEligibleInsurances(array $insurances, ParticipantDto $participant, BookingDto $booking): array
|
|
{
|
|
$criteria = $this->createEligibilityCriteria($participant, $booking);
|
|
|
|
if (null === $criteria) {
|
|
return []; // Cannot match insurances without travel dates
|
|
}
|
|
|
|
$eligibleInsurances = array_filter(
|
|
$insurances,
|
|
fn (Insurance $insurance) => $this->isInsuranceEligible($insurance, $criteria)
|
|
);
|
|
|
|
return $this->sortByPrice($eligibleInsurances);
|
|
}
|
|
|
|
/**
|
|
* Auto-reassigns an insurance to the same type with appropriate price tier.
|
|
*
|
|
* This method is used when a participant's individual price changes and their
|
|
* current insurance is no longer eligible. It finds the same insurance type
|
|
* (subType + familyInsurance) with the correct price tier.
|
|
*
|
|
* @param array<Insurance> $availableInsurances All available insurances
|
|
* @param Insurance $currentInsurance The currently selected insurance
|
|
* @param ParticipantDto $participant The participant to reassign for
|
|
* @param BookingDto $booking The booking context
|
|
*
|
|
* @return Insurance|null The reassigned insurance or null if no suitable match found
|
|
*/
|
|
public function reassignInsuranceForPriceChange(array $availableInsurances, Insurance $currentInsurance, ParticipantDto $participant, BookingDto $booking): ?Insurance
|
|
{
|
|
// Group insurances of the same type
|
|
$sameTypeInsurances = $this->filterInsurancesByType($availableInsurances, $currentInsurance);
|
|
|
|
// Get eligible insurances for this participant
|
|
$eligibleInsurances = $this->getEligibleInsurances($sameTypeInsurances, $participant, $booking);
|
|
|
|
// Return the first eligible insurance (they should all be equivalent for the same type)
|
|
return !empty($eligibleInsurances) ? array_values($eligibleInsurances)[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Batch-assigns insurances of the same type to all participants based on individual pricing.
|
|
*
|
|
* FUTURE FEATURE: This method will be used when implementing the "applicant assigns
|
|
* insurance to all participants" feature. The applicant's selection will be propagated
|
|
* to all participants with automatic price tier adjustment based on individual prices.
|
|
*
|
|
* This method takes the applicant's insurance selection and assigns the same insurance type
|
|
* (subType + familyInsurance) to all participants, but selects the appropriate price tier
|
|
* based on each participant's individual travel price.
|
|
*
|
|
* @param array<Insurance> $availableInsurances All available insurances
|
|
* @param Insurance $selectedInsurance The insurance selected by the applicant
|
|
* @param BookingDto $booking The booking with all participants
|
|
*
|
|
* @return array<int, Insurance|null> Array indexed by participant index with assigned insurances
|
|
*
|
|
* @internal Reserved for future feature implementation
|
|
*/
|
|
public function batchAssignInsuranceToParticipants(array $availableInsurances, Insurance $selectedInsurance, BookingDto $booking): array
|
|
{
|
|
$assignments = [];
|
|
|
|
// Group insurances of the same type
|
|
$sameTypeInsurances = $this->filterInsurancesByType($availableInsurances, $selectedInsurance);
|
|
|
|
// Assign appropriate insurance to each participant
|
|
foreach ($booking->getParticipants() as $index => $participant) {
|
|
$eligibleInsurances = $this->getEligibleInsurances($sameTypeInsurances, $participant, $booking);
|
|
$assignments[$index] = !empty($eligibleInsurances) ? array_values($eligibleInsurances)[0] : null;
|
|
}
|
|
|
|
return $assignments;
|
|
}
|
|
|
|
/**
|
|
* Creates eligibility criteria from participant and booking data.
|
|
*
|
|
* This method performs early validation before creating the criteria object
|
|
* to avoid unnecessary object instantiation when criteria cannot be satisfied.
|
|
*/
|
|
private function createEligibilityCriteria(ParticipantDto $participant, BookingDto $booking): ?InsuranceEligibilityCriteria
|
|
{
|
|
// Early return if travel dates are missing - cannot evaluate any criteria
|
|
$travelStartDate = $booking->travel->dateFrom;
|
|
$travelEndDate = $booking->travel->dateTo;
|
|
|
|
if (null === $travelStartDate || null === $travelEndDate) {
|
|
return null; // Cannot create criteria without travel dates
|
|
}
|
|
|
|
return new InsuranceEligibilityCriteria(
|
|
participant: $participant,
|
|
travelStartDate: $travelStartDate,
|
|
travelEndDate: $travelEndDate,
|
|
bookingDate: Carbon::now()->toDateTimeImmutable(),
|
|
travelPrice: $this->calculateTravelPrice($booking, $participant->index),
|
|
travelDurationDays: $this->calculateTravelDurationDays($travelStartDate, $travelEndDate),
|
|
booking: $booking,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Checks if a specific insurance is eligible for given criteria.
|
|
*/
|
|
private function isInsuranceEligible(Insurance $insurance, InsuranceEligibilityCriteria $criteria): bool
|
|
{
|
|
// Family insurance constraints
|
|
if (false === $this->checkFamilyInsuranceConstraints($insurance, $criteria->booking)) {
|
|
return false;
|
|
}
|
|
|
|
// Age constraints
|
|
if (false === $this->checkAgeConstraints($insurance, $criteria->participant, $criteria->travelStartDate)) {
|
|
return false;
|
|
}
|
|
|
|
// Travel date constraints
|
|
if (false === $this->checkTravelDateConstraints($insurance, $criteria->travelStartDate, $criteria->travelEndDate)) {
|
|
return false;
|
|
}
|
|
|
|
// Booking date constraints
|
|
if (false === $this->checkBookingDateConstraints($insurance, $criteria->bookingDate)) {
|
|
return false;
|
|
}
|
|
|
|
// Travel price constraints
|
|
if (false === $this->checkTravelPriceConstraints($insurance, $criteria->travelPrice)) {
|
|
return false;
|
|
}
|
|
|
|
// Travel duration constraints
|
|
if (false === $this->checkTravelDurationConstraints($insurance, $criteria->travelDurationDays)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if family insurance constraints are met.
|
|
*
|
|
* Family insurances should only be available for family bookings,
|
|
* and individual insurances should only be available for non-family bookings.
|
|
*/
|
|
private function checkFamilyInsuranceConstraints(Insurance $insurance, BookingDto $booking): bool
|
|
{
|
|
// Family booking detection only available in create mode
|
|
if (BookingDto::MODE_EDIT === $booking->getMode()) {
|
|
return true; // Skip family constraints for edit mode
|
|
}
|
|
|
|
$isFamilyBooking = $booking->isFamilyBooking();
|
|
|
|
// If it's a family insurance, it should only be available for family bookings
|
|
if (true === $insurance->familyInsurance && false === $isFamilyBooking) {
|
|
return false;
|
|
}
|
|
|
|
// If it's not a family insurance, it should only be available for non-family bookings
|
|
if (false === $insurance->familyInsurance && true === $isFamilyBooking) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if participant age meets insurance age constraints.
|
|
*/
|
|
private function checkAgeConstraints(Insurance $insurance, ParticipantDto $participant, \DateTimeImmutable $travelStartDate): bool
|
|
{
|
|
$participantAge = $participant->getAge($travelStartDate);
|
|
|
|
// If no birth date is provided, skip age constraints (field will be hidden via field state conditions)
|
|
if (null === $participantAge) {
|
|
return true;
|
|
}
|
|
|
|
// Check minimum age
|
|
if (null !== $insurance->ageFrom && $participantAge < $insurance->ageFrom) {
|
|
return false;
|
|
}
|
|
|
|
// Check maximum age
|
|
if (null !== $insurance->ageTo && $participantAge > $insurance->ageTo) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if travel dates fall within insurance validity period.
|
|
*/
|
|
private function checkTravelDateConstraints(Insurance $insurance, \DateTimeImmutable $travelStartDate, \DateTimeImmutable $travelEndDate): bool
|
|
{
|
|
// Check travel start date
|
|
if (null !== $insurance->travelDateFrom && $travelStartDate < $insurance->travelDateFrom) {
|
|
return false;
|
|
}
|
|
|
|
if (null !== $insurance->travelDateTo && $travelStartDate > $insurance->travelDateTo) {
|
|
return false;
|
|
}
|
|
|
|
// Check travel end date
|
|
if (null !== $insurance->travelDateTo && $travelEndDate > $insurance->travelDateTo) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if booking date falls within insurance booking window.
|
|
*/
|
|
private function checkBookingDateConstraints(Insurance $insurance, \DateTimeImmutable $bookingDate): bool
|
|
{
|
|
// Check booking window start
|
|
if (null !== $insurance->bookingDateFrom && $bookingDate < $insurance->bookingDateFrom) {
|
|
return false;
|
|
}
|
|
|
|
// Check booking window end
|
|
if (null !== $insurance->bookingDateTo && $bookingDate > $insurance->bookingDateTo) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if travel price falls within insurance price range.
|
|
*/
|
|
private function checkTravelPriceConstraints(Insurance $insurance, float $travelPrice): bool
|
|
{
|
|
// Check minimum price
|
|
if (null !== $insurance->travelPriceFrom && $travelPrice < $insurance->travelPriceFrom) {
|
|
return false;
|
|
}
|
|
|
|
// Check maximum price
|
|
if (null !== $insurance->travelPriceTo && $travelPrice > $insurance->travelPriceTo) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if travel duration falls within insurance duration limits.
|
|
*/
|
|
private function checkTravelDurationConstraints(Insurance $insurance, int $travelDurationDays): bool
|
|
{
|
|
// Check minimum duration
|
|
if (null !== $insurance->travelDurationFrom && $travelDurationDays < $insurance->travelDurationFrom) {
|
|
return false;
|
|
}
|
|
|
|
// Check maximum duration
|
|
if (null !== $insurance->travelDurationTo && $travelDurationDays > $insurance->travelDurationTo) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Calculates the total travel price for a participant, excluding insurance prices.
|
|
*
|
|
* This method calculates the travel price used for insurance eligibility filtering.
|
|
* It excludes insurance prices to prevent circular dependency where insurance selection
|
|
* affects travel price which then affects insurance eligibility.
|
|
*
|
|
* @param BookingDto $booking The booking to calculate price for
|
|
* @param int $participantIndex The participant index to calculate for
|
|
*
|
|
* @return float The total travel price for the participant excluding insurance
|
|
*/
|
|
private function calculateTravelPrice(BookingDto $booking, int $participantIndex): float
|
|
{
|
|
// Use the price calculator to get the participant's individual price excluding insurance
|
|
return $this->priceCalculatorService->calculateIndividualParticipantPriceExcludingInsurance($booking, $participantIndex);
|
|
}
|
|
|
|
/**
|
|
* Calculates travel duration in days.
|
|
*
|
|
* @param \DateTimeImmutable $startDate Travel start date
|
|
* @param \DateTimeImmutable $endDate Travel end date
|
|
*
|
|
* @return int Duration in days
|
|
*/
|
|
private function calculateTravelDurationDays(\DateTimeImmutable $startDate, \DateTimeImmutable $endDate): int
|
|
{
|
|
return $startDate->diff($endDate)->days;
|
|
}
|
|
|
|
/**
|
|
* Filters insurances by type based on label (for packages) or subType (for individual insurances).
|
|
*
|
|
* This method groups insurances of the same type together for reassignment or batch assignment.
|
|
* Insurance type matching strategy:
|
|
* - **Packages**: Match by label + familyInsurance (packages with same label are different price tiers)
|
|
* - **Individual insurances**: Match by subType + familyInsurance
|
|
*
|
|
* Example: "Reise-Rücktritt + Selbstbehaltübernahme" at €10, €14, €26 are the same type,
|
|
* but different from "Reiseschutz Platin Auto/Bahn/Bus (Europa) + Selbstbehaltübernahme".
|
|
*
|
|
* @param array<Insurance> $insurances All available insurances to filter
|
|
* @param Insurance $referenceInsurance The insurance to match against
|
|
*
|
|
* @return array<Insurance> Filtered insurances of the same type
|
|
*/
|
|
private function filterInsurancesByType(array $insurances, Insurance $referenceInsurance): array
|
|
{
|
|
// For packages, match by label (packages with same label are different price tiers of same type)
|
|
if (true === $referenceInsurance->package) {
|
|
return array_filter(
|
|
$insurances,
|
|
fn (Insurance $insurance) => true === $insurance->package
|
|
&& $insurance->label === $referenceInsurance->label
|
|
&& $insurance->familyInsurance === $referenceInsurance->familyInsurance
|
|
);
|
|
}
|
|
|
|
// For individual insurances, match by subType
|
|
return array_filter(
|
|
$insurances,
|
|
fn (Insurance $insurance) => false === $insurance->package
|
|
&& $insurance->subType === $referenceInsurance->subType
|
|
&& $insurance->familyInsurance === $referenceInsurance->familyInsurance
|
|
);
|
|
}
|
|
}
|