wip: insurance booking

src/BusProNet/Constants.php

@@ -16,8 +16,14 @@ final class Constants
     public const TOKEN_BOARD = 'VPF';
     public const TOKEN_RENTALS = ['VER', 'VE2', 'VE3', 'VE4', 'VE5', 'VE6', 'VE7', 'VE8'];
     public const TOKEN_RENTAL_INSURANCE = 'LVS';
+    public const TOKEN_INSURANCES = ['RRV', 'PAK', 'OHN', 'PKG'];
     public const TOKEN_PARKING = 'PAR';
 
+    // Normalized service group keys for pricing display
+    public const GROUP_TRANSPORTATION = 'transportation';
+    public const GROUP_RENTALS = 'rentals';
+    public const GROUP_INSURANCE = 'insurance';
+
     public const STATUS_AVAILABLE = 'Frei';
     public const STATUS_BLOCKED = 'Buchungsstop';
     public const STATUS_ON_REQUEST = 'Anfrage';

src/BusProNet/Model/Insurance.php

@@ -91,4 +91,23 @@ class Insurance
      */
     #[Groups(['api:single', 'api:list'])]
     public array $containedInsuranceIds = [];
+
+    public function __toString(): string
+    {
+        return (string) $this->id;
+    }
+
+    /**
+     * Returns the subType, with virtual 'PKG' subType for insurance packages.
+     *
+     * @return string|null The subType (RRV, PAK, OHN, PKG) or null
+     */
+    public function getSubType(): ?string
+    {
+        if (true === $this->package) {
+            return 'PKG'; // Virtual subType for all insurance packages
+        }
+
+        return $this->subType;
+    }
 }

src/BusProNet/XmlLoader/InsuranceLoader.php

@@ -15,8 +15,8 @@ use Symfony\Contracts\Cache\ItemInterface;
 class InsuranceLoader extends AbstractLoader
 {
     public function __construct(
-        protected readonly CacheInterface $cache,
-        protected readonly FilesystemOperator $xmlExport,
+        CacheInterface $cache,
+        FilesystemOperator $xmlExport,
         private readonly InsuranceParser $insuranceParser,
     ) {
         parent::__construct($cache, $xmlExport);

src/BusProNet/XmlParser/InsuranceParser.php

@@ -19,6 +19,7 @@ class InsuranceParser extends AbstractParser
      * Parses insurance XML nodes into Insurance objects.
      *
      * @param Crawler $xmlContent The XML crawler containing insurance data
+     *
      * @return array<string|int, Insurance> Array of Insurance objects indexed by id
      */
     public function parse(Crawler $xmlContent): array
@@ -28,25 +29,29 @@ class InsuranceParser extends AbstractParser
         // First pass: collect referenced insurance IDs from packages
         $referencedIds = $this->collectReferencedInsuranceIds($xmlContent);
 
-        // Parse individual insurances with conditional filtering
+        // Second pass: Parse individual insurances with conditional filtering
+        $individualInsurances = [];
         $xmlContent->filterXPath('//versicherungen/versicherung')
-            ->each(function (Crawler $node) use (&$insurances, $referencedIds) {
+            ->each(function (Crawler $node) use (&$individualInsurances, &$insurances, $referencedIds) {
                 $id = (int) $node->attr('idbuspro'); // Individual insurances have int IDs
-                $isZusatz = $this->getBoolAttributeValue($node->attr('zusatzversicherung'));
+                $isAdditional = $this->getBoolAttributeValue($node->attr('zusatzversicherung'));
 
-                // Include if: not zusatzversicherung OR referenced by package
-                if (!$isZusatz || in_array($id, $referencedIds, true)) {
-                    $insurance = $this->parseInsuranceNode($node, false);
-                    if (null !== $insurance && null !== $insurance->id) {
+                // Parse all individual insurances for reference lookup
+                $insurance = $this->parseInsuranceNode($node, false);
+                if (null !== $insurance && null !== $insurance->id) {
+                    $individualInsurances[$insurance->id] = $insurance;
+
+                    // Include if: not additional insurance OR referenced by package
+                    if (!$isAdditional || in_array($id, $referencedIds, true)) {
                         $insurances[$insurance->id] = $insurance;
                     }
                 }
             });
 
-        // Parse packages (no filtering needed)
+        // Third pass: Parse packages with family detection based on contained insurances
         $xmlContent->filterXPath('//versicherungspakete/versicherungspaket')
-            ->each(function (Crawler $node) use (&$insurances) {
-                $insurance = $this->parseInsuranceNode($node, true);
+            ->each(function (Crawler $node) use (&$insurances, $individualInsurances) {
+                $insurance = $this->parseInsuranceNode($node, true, $individualInsurances);
                 if (null !== $insurance && null !== $insurance->id) {
                     // Parse contained insurance IDs
                     $insurance->containedInsuranceIds = $this->parseContainedInsuranceIds($node);
@@ -57,14 +62,37 @@ class InsuranceParser extends AbstractParser
         return $insurances;
     }
 
+    /**
+     * Determines if a package contains any family insurances.
+     *
+     * @param Crawler               $packageNode          The package XML node
+     * @param array<int, Insurance> $individualInsurances Parsed individual insurances for reference
+     *
+     * @return bool True if any contained insurance is a family insurance
+     */
+    private function isPackageFamilyInsurance(Crawler $packageNode, array $individualInsurances): bool
+    {
+        // Check if any contained insurance is a family insurance
+        $containedInsuranceIds = $this->parseContainedInsuranceIds($packageNode);
+        foreach ($containedInsuranceIds as $containedId) {
+            if (isset($individualInsurances[$containedId]) && true === $individualInsurances[$containedId]->familyInsurance) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Parses a single insurance or package node.
      *
-     * @param Crawler $node The XML node to parse
-     * @param bool $isPackage Whether this is a package node
+     * @param Crawler               $node                 The XML node to parse
+     * @param bool                  $isPackage            Whether this is a package node
+     * @param array<int, Insurance> $individualInsurances Individual insurances for package family detection
+     *
      * @return Insurance|null The parsed insurance object
      */
-    private function parseInsuranceNode(Crawler $node, bool $isPackage): ?Insurance
+    private function parseInsuranceNode(Crawler $node, bool $isPackage, array $individualInsurances = []): ?Insurance
     {
         $insurance = new Insurance();
         $insurance->package = $isPackage;
@@ -79,6 +107,11 @@ class InsuranceParser extends AbstractParser
             $this->stringToFloat($node->attr('preis')) : null;
         $insurance->familyInsurance = $this->stringToBool($node->attr('familienversicherung'));
 
+        // For packages, check if any contained insurances are family insurances
+        if ($isPackage && !$insurance->familyInsurance && !empty($individualInsurances)) {
+            $insurance->familyInsurance = $this->isPackageFamilyInsurance($node, $individualInsurances);
+        }
+
         // Date constraints
         $insurance->travelDateFrom = $node->attr('reisedatumvon') ?
             $this->stringToDate($node->attr('reisedatumvon')) : null;
@@ -115,6 +148,7 @@ class InsuranceParser extends AbstractParser
      * Collects all insurance IDs referenced by packages.
      *
      * @param Crawler $xmlContent The XML content to scan
+     *
      * @return array<int> Array of referenced insurance IDs
      */
     private function collectReferencedInsuranceIds(Crawler $xmlContent): array
@@ -135,6 +169,7 @@ class InsuranceParser extends AbstractParser
      * Parses contained insurance IDs from a package node.
      *
      * @param Crawler $node The package XML node
+     *
      * @return array<int> Array of contained insurance IDs (always int, as they reference individual insurances)
      */
     private function parseContainedInsuranceIds(Crawler $node): array
@@ -152,4 +187,4 @@ class InsuranceParser extends AbstractParser
     {
         return !empty($value) && $this->stringToBool($value);
     }
-}
+}