fix ксе tariffs

app/adapters/delivery_providers/cse/client.py

@@ -236,9 +236,16 @@ class CSEClient:
 class CSEProvider(DeliveryProvider):
     name = CSE_PROVIDER_NAME
 
-    def __init__(self, client: CSEClient, *, cache_ttl_seconds: int = 900) -> None:
+    def __init__(
+        self,
+        client: CSEClient,
+        *,
+        cache_ttl_seconds: int = 900,
+        delivery_service_guids: tuple[str, ...] = (),
+    ) -> None:
         self._client = client
         self.cache_ttl_seconds = cache_ttl_seconds
+        self._delivery_service_guids = delivery_service_guids
         self._delivery_types: list[tuple[str, str]] | None = None
 
     @classmethod
@@ -262,7 +269,11 @@ class CSEProvider(DeliveryProvider):
             retry_attempts=config.retry_attempts,
             retry_backoff_seconds=config.retry_backoff_seconds,
         )
-        return cls(client=client, cache_ttl_seconds=config.cache_ttl_seconds)
+        return cls(
+            client=client,
+            cache_ttl_seconds=config.cache_ttl_seconds,
+            delivery_service_guids=tuple(config.delivery_service_guids),
+        )
 
     async def get_prices(
         self, request: DeliveryCalculationRequest
@@ -271,8 +282,9 @@ class CSEProvider(DeliveryProvider):
 
         results = await asyncio.gather(
             *(
-                self._prices_for_delivery_type(request, name, label)
+                self._prices_for_delivery_type(request, name, label, service_guid)
                 for name, label in delivery_types
+                for service_guid in self._service_guids_for_price_calculation()
             ),
             return_exceptions=True,
         )
@@ -294,18 +306,25 @@ class CSEProvider(DeliveryProvider):
         request: DeliveryCalculationRequest,
         delivery_type: str,
         delivery_type_label: str,
+        service_guid: str | None,
     ) -> list[DeliveryPrice]:
-        body = build_calc_body_for_calculation(request, delivery_type)
+        body = build_calc_body_for_calculation(request, delivery_type, service_guid)
         root = await self._client.calc(body)
         try:
             return map_cse_calc_response(
                 root,
                 delivery_type=delivery_type,
                 delivery_type_label=delivery_type_label,
+                service_guid=service_guid,
             )
         except CSEMappingError as exc:
             raise CSEClientError("CSE calc response payload is invalid.") from exc
 
+    def _service_guids_for_price_calculation(self) -> tuple[str, ...]:
+        if not self._delivery_service_guids:
+            raise CSERequestError("CSE delivery service GUIDs are not configured.")
+        return self._delivery_service_guids
+
     async def _resolve_delivery_types(self) -> list[tuple[str, str]]:
         if self._delivery_types is None:
             self._delivery_types = await self._client.get_delivery_types()
@@ -325,14 +344,16 @@ class CSEProvider(DeliveryProvider):
         request: InitPaymentRequest,
     ) -> DeliveryPrice | None:
         tariff_code = request.system_data.tariff.tariff_code
-        delivery_type, _ = split_tariff_code(tariff_code)
-        body = build_calc_body_for_payment(request, delivery_type)
-        root = await self._client.calc(body)
         try:
+            delivery_type, service_guid, _ = split_tariff_code(tariff_code)
+            body = build_calc_body_for_payment(request, delivery_type, service_guid)
+            root = await self._client.calc(body)
             return map_cse_calc_response_for_tariff_code(
                 root,
                 tariff_code=tariff_code,
             )
+        except CSERequestError:
+            raise
         except CSEMappingError as exc:
             raise CSEClientError(
                 "CSE payment price validation response payload is invalid."

app/adapters/delivery_providers/cse/mapper.py

@@ -18,11 +18,14 @@ def map_cse_calc_response(
     *,
     delivery_type: str = "",
     delivery_type_label: str = "",
+    service_guid: str | None = None,
 ) -> list[DeliveryPrice]:
     """Map a parsed ``Calc`` ``return`` Element into unified delivery prices."""
 
     prices: list[DeliveryPrice] = []
     for tariff in _iter_tariffs(root):
+        if service_guid is not None and tariff.value != service_guid:
+            continue
         price = _map_tariff(tariff, delivery_type, delivery_type_label)
         if price is not None:
             prices.append(price)
@@ -35,11 +38,11 @@ def map_cse_calc_response_for_tariff_code(
     tariff_code: str,
     delivery_type_label: str = "",
 ) -> DeliveryPrice | None:
-    """Return the tariff matching ``tariff_code`` (``"<DeliveryType>|<Urgency>"``)."""
+    """Return tariff matching ``"<DeliveryType>|<ServiceGuid>|<Urgency>"``."""
 
-    delivery_type, _, urgency = tariff_code.partition("|")
+    delivery_type, tariff_guid, urgency = _split_tariff_code(tariff_code)
     for tariff in _iter_tariffs(root):
-        if _tariff_urgency(tariff) == urgency:
+        if _tariff_matches(tariff, tariff_guid, urgency):
             price = _map_tariff(tariff, delivery_type, delivery_type_label)
             if price is not None:
                 return price
@@ -52,6 +55,19 @@ def _tariff_urgency(tariff: Element) -> str | None:
     return tariff.field_value("Urgency") or tariff.value
 
 
+def _tariff_matches(tariff: Element, tariff_guid: str, urgency: str) -> bool:
+    if _tariff_urgency(tariff) != urgency:
+        return False
+    return tariff.value == tariff_guid
+
+
+def _split_tariff_code(tariff_code: str) -> tuple[str, str, str]:
+    parts = tariff_code.split("|")
+    if len(parts) != 3 or not parts[1] or not parts[2]:
+        raise CSEMappingError("CSE tariff_code has invalid format.")
+    return parts[0], parts[1], parts[2]
+
+
 def _iter_tariffs(root: Element):
     for destination in root.items:
         for tariff in destination.items:
@@ -70,9 +86,11 @@ def _map_tariff(
     urgency = _tariff_urgency(tariff)
     if not urgency:
         return None
-    # Unified tariff_code carries both the delivery scheme and the urgency so
-    # registration (SaveDocuments) can set DeliveryOfCargo and Urgency.
-    tariff_code = f"{delivery_type}|{urgency}"
+    if not tariff.value:
+        return None
+    # Unified tariff_code carries the delivery scheme, CSE service GUID and
+    # urgency so payment validation can recalculate the exact selected service.
+    tariff_code = f"{delivery_type}|{tariff.value}|{urgency}"
 
     raw_total = tariff.field_value("Total")
     if raw_total is None:

app/adapters/delivery_providers/cse/order_mapper.py

@@ -8,7 +8,7 @@ from app.adapters.delivery_providers.cse.constants import (
     resolve_cse_geography,
     resolve_type_of_cargo,
 )
-from app.adapters.delivery_providers.cse.errors import CSEMappingError
+from app.adapters.delivery_providers.cse.errors import CSEMappingError, CSERequestError
 from app.adapters.delivery_providers.cse.soap import Element, make_field
 from app.schemas.payment import Address, InitPaymentRequest
 from app.schemas.request import DeliveryCalculationRequest
@@ -44,6 +44,7 @@ class CSEOrderInfo:
 def build_calc_body_for_calculation(
     request: DeliveryCalculationRequest,
     delivery_type: str = "",
+    service_guid: str | None = None,
 ) -> dict[str, Element]:
     fields = [
         make_field("SenderGeography", resolve_cse_geography(request.from_city)),
@@ -53,12 +54,15 @@ def build_calc_body_for_calculation(
         make_field("Qty", "1", "int"),
     ]
     _append_delivery_type(fields, delivery_type)
+    if service_guid:
+        fields.append(make_field("Service", service_guid))
     return _calc_body(Element(key="Destination", fields=fields))
 
 
 def build_calc_body_for_payment(
     request: InitPaymentRequest,
     delivery_type: str = "",
+    service_guid: str | None = None,
 ) -> dict[str, Element]:
     system_data = request.system_data
     fields = [
@@ -75,6 +79,8 @@ def build_calc_body_for_payment(
         make_field("Qty", "1", "int"),
     ]
     _append_delivery_type(fields, delivery_type)
+    if service_guid:
+        fields.append(make_field("Service", service_guid))
     return _calc_body(Element(key="Destination", fields=fields))
 
 
@@ -83,14 +89,17 @@ def _append_delivery_type(fields: list[Element], delivery_type: str) -> None:
         fields.append(make_field("DeliveryType", delivery_type))
 
 
-def split_tariff_code(tariff_code: str) -> tuple[str, str]:
-    """Split the CSE ``tariff_code`` into (delivery_type, urgency).
+def split_tariff_code(tariff_code: str) -> tuple[str, str, str]:
+    """Split the CSE ``tariff_code`` into delivery type, service GUID, urgency.
 
-    The unified tariff_code encodes both dimensions as ``"<DeliveryType>|<Urgency>"``.
+    The expected format is ``"<DeliveryType>|<ServiceGuid>|<Urgency>"``.
+    ``DeliveryType`` may be empty when CSE contract defaults are used.
     """
 
-    delivery_type, _, urgency = tariff_code.partition("|")
-    return delivery_type, urgency
+    parts = tariff_code.split("|")
+    if len(parts) != 3 or not parts[1] or not parts[2]:
+        raise CSERequestError("CSE tariff_code has invalid format.")
+    return parts[0], parts[1], parts[2]
 
 
 def _calc_body(destination: Element) -> dict[str, Element]:
@@ -110,7 +119,7 @@ def map_cse_save_order_request(
 ) -> dict[str, Element]:
     system_data = request.system_data
     take_date = request.pickup_date.strftime(_DATETIME_FORMAT)
-    delivery_type, urgency = split_tariff_code(system_data.tariff.tariff_code)
+    delivery_type, _, urgency = split_tariff_code(system_data.tariff.tariff_code)
 
     fields = [
         make_field("TakeDate", take_date, "dateTime"),