Убрали ПВЗ для КСЕ, и поправили формирование тарифа КСЕ

app/adapters/delivery_providers/cse/client.py

@@ -7,7 +7,10 @@ import httpx
 import structlog
 
 from app.adapters.delivery_providers.base import DeliveryProvider
-from app.adapters.delivery_providers.cse.constants import CSE_PROVIDER_NAME
+from app.adapters.delivery_providers.cse.constants import (
+    CSE_PROVIDER_NAME,
+    delivery_type_requires_pvz,
+)
 from app.adapters.delivery_providers.cse.errors import (
     CSEClientError,
     CSEMappingError,
@@ -24,10 +27,12 @@ from app.adapters.delivery_providers.cse.order_mapper import (
     build_calc_body_for_payment,
     map_cse_save_order_request,
     map_cse_save_order_response,
+    split_tariff_code,
 )
 from app.adapters.delivery_providers.cse.soap import (
     Element,
     build_envelope,
+    make_field,
     parse_response,
 )
 from app.config import AdapterConfig
@@ -71,6 +76,27 @@ class CSEClient:
             request_error_message="CSE calc request was rejected with status",
         )
 
+    async def get_delivery_types(self) -> list[tuple[str, str]]:
+        """Return available delivery schemes as (name, human label) pairs."""
+
+        body = {
+            "parameters": Element(
+                key="parameters",
+                items=[make_field("Reference", "DeliveryType")],
+            )
+        }
+        root = await self._post(
+            "GetReferenceData",
+            body,
+            request_error_message="CSE delivery types request was rejected with status",
+        )
+        result: list[tuple[str, str]] = []
+        for entry in root.items:
+            name = entry.value
+            if name:
+                result.append((name, entry.field_value("Information") or name))
+        return result
+
     async def save_order(
         self, request: InitPaymentRequest, order_uuid: str
     ) -> CSEOrderRegistrationResult:
@@ -183,6 +209,7 @@ class CSEProvider(DeliveryProvider):
     def __init__(self, client: CSEClient, *, cache_ttl_seconds: int = 900) -> None:
         self._client = client
         self.cache_ttl_seconds = cache_ttl_seconds
+        self._delivery_types: list[tuple[str, str]] | None = None
 
     @classmethod
     def from_adapter_config(
@@ -200,7 +227,6 @@ class CSEProvider(DeliveryProvider):
                 payer=adapter_config.cse_payer,
                 payment_method=adapter_config.cse_payment_method,
                 shipping_method=adapter_config.cse_shipping_method,
-                urgency=adapter_config.cse_urgency,
             ),
             timeout_seconds=adapter_config.cse_timeout_seconds,
             retry_attempts=adapter_config.cse_retry_attempts,
@@ -211,23 +237,71 @@ class CSEProvider(DeliveryProvider):
     async def get_prices(
         self, request: DeliveryCalculationRequest
     ) -> list[DeliveryPrice]:
-        body = build_calc_body_for_calculation(request)
+        delivery_types = await self._resolve_delivery_types()
+
+        results = await asyncio.gather(
+            *(
+                self._prices_for_delivery_type(request, name, label)
+                for name, label in delivery_types
+            ),
+            return_exceptions=True,
+        )
+
+        prices: list[DeliveryPrice] = []
+        errors: list[BaseException] = []
+        for result in results:
+            if isinstance(result, BaseException):
+                errors.append(result)
+            else:
+                prices.extend(result)
+
+        if not prices and errors:
+            raise errors[0]
+        return prices
+
+    async def _prices_for_delivery_type(
+        self,
+        request: DeliveryCalculationRequest,
+        delivery_type: str,
+        delivery_type_label: str,
+    ) -> list[DeliveryPrice]:
+        body = build_calc_body_for_calculation(request, delivery_type)
         root = await self._client.calc(body)
         try:
-            return map_cse_calc_response(root)
+            return map_cse_calc_response(
+                root,
+                delivery_type=delivery_type,
+                delivery_type_label=delivery_type_label,
+            )
         except CSEMappingError as exc:
             raise CSEClientError("CSE calc response payload is invalid.") from exc
 
+    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()
+        # Exclude schemes that require a pickup point (PVZ) at registration,
+        # since PVZ is not yet supported (only door-to-door is fulfillable).
+        usable = [
+            (name, label)
+            for name, label in self._delivery_types
+            if not delivery_type_requires_pvz(name, label)
+        ]
+        # Fall back to the contract-default scheme (empty delivery_type) so
+        # calculation still works if no usable schemes are returned.
+        return usable or [("", "")]
+
     async def get_payment_price(
         self,
         request: InitPaymentRequest,
     ) -> DeliveryPrice | None:
-        body = build_calc_body_for_payment(request)
+        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:
             return map_cse_calc_response_for_tariff_code(
                 root,
-                tariff_code=request.system_data.tariff.tariff_code,
+                tariff_code=tariff_code,
             )
         except CSEMappingError as exc:
             raise CSEClientError(

app/adapters/delivery_providers/cse/constants.py

@@ -12,6 +12,16 @@ from app.cities import cities_map
 # Provider name surfaced in unified DeliveryPrice/SystemDataTariff.
 CSE_PROVIDER_NAME = "cse"
 
+# Keywords in a DeliveryType name/label that imply a pickup point (PVZ) is
+# required at registration (SenderPVZ/RecipientPVZ). PVZ is not yet supported,
+# so such schemes are excluded from price calculation.
+_PVZ_SCHEME_KEYWORDS = ("склад", "самовывоз", "почтов", "пвз")
+
+
+def delivery_type_requires_pvz(name: str, label: str) -> bool:
+    haystack = f"{name} {label}".lower()
+    return any(keyword in haystack for keyword in _PVZ_SCHEME_KEYWORDS)
+
 # CSE returns currency short names (e.g. "RUR"); normalize to ISO-4217.
 _CURRENCY_NAME_TO_CODE = {
     "RUR": "RUB",

app/adapters/delivery_providers/cse/mapper.py

@@ -13,12 +13,17 @@ from app.schemas.response import DeliveryPrice
 _TARIFF_KEY = "Tariff"
 
 
-def map_cse_calc_response(root: Element) -> list[DeliveryPrice]:
+def map_cse_calc_response(
+    root: Element,
+    *,
+    delivery_type: str = "",
+    delivery_type_label: str = "",
+) -> list[DeliveryPrice]:
     """Map a parsed ``Calc`` ``return`` Element into unified delivery prices."""
 
     prices: list[DeliveryPrice] = []
     for tariff in _iter_tariffs(root):
-        price = _map_tariff(tariff)
+        price = _map_tariff(tariff, delivery_type, delivery_type_label)
         if price is not None:
             prices.append(price)
     return prices
@@ -28,15 +33,23 @@ def map_cse_calc_response_for_tariff_code(
     root: Element,
     *,
     tariff_code: str,
+    delivery_type_label: str = "",
 ) -> DeliveryPrice | None:
-    """Return the tariff matching the given GUID, or ``None`` when absent."""
+    """Return the tariff matching ``tariff_code`` (``"<DeliveryType>|<Urgency>"``)."""
 
+    delivery_type, _, urgency = tariff_code.partition("|")
     for tariff in _iter_tariffs(root):
-        if tariff.value == tariff_code:
-            return _map_tariff(tariff)
+        if _tariff_urgency(tariff) == urgency:
+            return _map_tariff(tariff, delivery_type, delivery_type_label)
     return None
 
 
+def _tariff_urgency(tariff: Element) -> str | None:
+    """Urgency GUID of a Calc tariff (fallback: the tariff record GUID)."""
+
+    return tariff.field_value("Urgency") or tariff.value
+
+
 def _iter_tariffs(root: Element):
     for destination in root.items:
         for tariff in destination.items:
@@ -44,10 +57,17 @@ def _iter_tariffs(root: Element):
                 yield tariff
 
 
-def _map_tariff(tariff: Element) -> DeliveryPrice | None:
-    tariff_code = tariff.value
-    if not tariff_code:
+def _map_tariff(
+    tariff: Element,
+    delivery_type: str,
+    delivery_type_label: str,
+) -> DeliveryPrice | None:
+    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}"
 
     raw_total = tariff.field_value("Total")
     if raw_total is None:
@@ -60,9 +80,12 @@ def _map_tariff(tariff: Element) -> DeliveryPrice | None:
     if not price.is_finite() or price <= 0:
         return None
 
-    service_name = tariff.field_value("Service") or tariff.field_value("UrgencyName")
-    if not service_name:
-        service_name = tariff_code
+    base_name = tariff.field_value("Service") or tariff.field_value("UrgencyName")
+    if not base_name:
+        base_name = urgency
+    service_name = (
+        f"{base_name} — {delivery_type_label}" if delivery_type_label else base_name
+    )
 
     currency = normalize_currency(tariff.field_value("CurrencyName"))
 

app/adapters/delivery_providers/cse/order_mapper.py

@@ -16,12 +16,15 @@ _DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
 
 @dataclass(frozen=True)
 class CSEOrderRegistrationParams:
-    """Contract-specific required parameters for SaveDocuments."""
+    """Contract-specific required parameters for SaveDocuments.
+
+    ``Urgency`` is not here: it comes from the tariff the client selected
+    (``system_data.tariff.tariff_code`` holds the urgency GUID).
+    """
 
     payer: str
     payment_method: str
     shipping_method: str
-    urgency: str
 
 
 @dataclass(frozen=True)
@@ -31,39 +34,54 @@ class CSEOrderRegistrationResult:
 
 def build_calc_body_for_calculation(
     request: DeliveryCalculationRequest,
+    delivery_type: str = "",
 ) -> dict[str, Element]:
-    destination = Element(
-        key="Destination",
-        fields=[
-            make_field("SenderGeography", resolve_cse_geography(request.from_city)),
-            make_field("RecipientGeography", resolve_cse_geography(request.to_city)),
-            make_field("TypeOfCargo", resolve_type_of_cargo(_parcel_type(request))),
-            make_field("Weight", _format_decimal(request.weight_kg), "float"),
-            make_field("Qty", "1", "int"),
-        ],
-    )
-    return _calc_body(destination)
+    fields = [
+        make_field("SenderGeography", resolve_cse_geography(request.from_city)),
+        make_field("RecipientGeography", resolve_cse_geography(request.to_city)),
+        make_field("TypeOfCargo", resolve_type_of_cargo(_parcel_type(request))),
+        make_field("Weight", _format_decimal(request.weight_kg), "float"),
+        make_field("Qty", "1", "int"),
+    ]
+    _append_delivery_type(fields, delivery_type)
+    return _calc_body(Element(key="Destination", fields=fields))
 
 
-def build_calc_body_for_payment(request: InitPaymentRequest) -> dict[str, Element]:
+def build_calc_body_for_payment(
+    request: InitPaymentRequest,
+    delivery_type: str = "",
+) -> dict[str, Element]:
     system_data = request.system_data
-    destination = Element(
-        key="Destination",
-        fields=[
-            make_field(
-                "SenderGeography",
-                resolve_cse_geography(request.sender_address.city_id),
-            ),
-            make_field(
-                "RecipientGeography",
-                resolve_cse_geography(request.receiver_address.city_id),
-            ),
-            make_field("TypeOfCargo", resolve_type_of_cargo(system_data.parcel_type)),
-            make_field("Weight", system_data.weight, "float"),
-            make_field("Qty", "1", "int"),
-        ],
-    )
-    return _calc_body(destination)
+    fields = [
+        make_field(
+            "SenderGeography",
+            resolve_cse_geography(request.sender_address.city_id),
+        ),
+        make_field(
+            "RecipientGeography",
+            resolve_cse_geography(request.receiver_address.city_id),
+        ),
+        make_field("TypeOfCargo", resolve_type_of_cargo(system_data.parcel_type)),
+        make_field("Weight", system_data.weight, "float"),
+        make_field("Qty", "1", "int"),
+    ]
+    _append_delivery_type(fields, delivery_type)
+    return _calc_body(Element(key="Destination", fields=fields))
+
+
+def _append_delivery_type(fields: list[Element], delivery_type: str) -> None:
+    if delivery_type:
+        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).
+
+    The unified tariff_code encodes both dimensions as ``"<DeliveryType>|<Urgency>"``.
+    """
+
+    delivery_type, _, urgency = tariff_code.partition("|")
+    return delivery_type, urgency
 
 
 def _calc_body(destination: Element) -> dict[str, Element]:
@@ -83,6 +101,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)
 
     fields = [
         make_field("TakeDate", take_date, "dateTime"),
@@ -101,7 +120,7 @@ def map_cse_save_order_request(
         ),
         make_field("RecipientAddress", _compose_address(request.receiver_address)),
         make_field("RecipientPhone", request.receiver_contact.phone),
-        make_field("Urgency", params.urgency),
+        make_field("Urgency", urgency),
         make_field("Payer", params.payer, "float"),
         make_field("PaymentMethod", params.payment_method, "float"),
         make_field("ShippingMethod", params.shipping_method),
@@ -109,6 +128,8 @@ def map_cse_save_order_request(
         make_field("Weight", system_data.weight, "float"),
         make_field("CargoPackageQty", "1", "float"),
     ]
+    if delivery_type:
+        fields.append(make_field("DeliveryOfCargo", delivery_type))
 
     if request.delivery_date is not None:
         fields.append(

app/config.py

@@ -54,10 +54,10 @@ class AdapterConfig(BaseModel):
     cse_timeout_seconds: float = Field(default=10.0, gt=0)
     cse_cache_ttl_seconds: int = Field(default=900, gt=0)
     # Contract-specific required parameters for SaveDocuments (order registration).
+    # Urgency is not here: it comes from the tariff selected by the client.
     cse_payer: str = ""
     cse_payment_method: str = ""
     cse_shipping_method: str = ""
-    cse_urgency: str = ""
 
 
 class TBankPaymentAuthConfig(BaseModel):