Раис Юсупалиев
259 lines
9.6 KiB
Python
259 lines
9.6 KiB
Python
"""CDEK HTTP client and provider adapter."""
|
|
|
|
import asyncio
|
|
from collections.abc import Awaitable, Callable
|
|
from typing import Any
|
|
import logging
|
|
|
|
import httpx
|
|
|
|
from app.adapters.delivery_providers.base import DeliveryProvider, ProviderRequestError
|
|
from app.adapters.delivery_providers.cdek.auth import CDEKAuthClient
|
|
from app.adapters.delivery_providers.cdek.mapper import map_cdek_response
|
|
from app.adapters.delivery_providers.cdek.order_mapper import (
|
|
CDEKOrderMappingError,
|
|
map_cdek_existing_order_response,
|
|
map_cdek_order_request,
|
|
map_cdek_order_response,
|
|
)
|
|
from app.cities import cities_map
|
|
from app.config import AdapterConfig
|
|
from app.schemas.payment import InitPaymentRequest
|
|
from app.schemas.request import DeliveryCalculationRequest
|
|
from app.schemas.response import DeliveryPrice
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class CDEKClientError(RuntimeError):
|
|
"""Raised when CDEK tariff request fails."""
|
|
|
|
|
|
class CDEKRequestError(CDEKClientError, ProviderRequestError):
|
|
"""Raised when CDEK rejects request data as invalid."""
|
|
|
|
|
|
class CDEKClient:
|
|
def __init__(
|
|
self,
|
|
http_client: httpx.AsyncClient,
|
|
auth_client: CDEKAuthClient,
|
|
*,
|
|
base_url: str,
|
|
timeout_seconds: float = 10.0,
|
|
retry_attempts: int = 2,
|
|
retry_backoff_seconds: float = 0.2,
|
|
sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
|
|
) -> None:
|
|
self._http_client = http_client
|
|
self._auth_client = auth_client
|
|
normalized_base_url = base_url.rstrip("/")
|
|
self._tariff_url = f"{normalized_base_url}/calculator/tarifflist"
|
|
self._orders_url = f"{normalized_base_url}/orders"
|
|
self._timeout_seconds = timeout_seconds
|
|
self._retry_attempts = retry_attempts
|
|
self._retry_backoff_seconds = retry_backoff_seconds
|
|
self._sleep = sleep
|
|
|
|
async def get_raw_price(
|
|
self, request: DeliveryCalculationRequest
|
|
) -> dict[str, Any]:
|
|
payload = await self._build_payload(request)
|
|
for attempt in range(self._retry_attempts + 1):
|
|
try:
|
|
token = await self._auth_client.get_access_token()
|
|
response = await self._http_client.post(
|
|
self._tariff_url,
|
|
json=payload,
|
|
headers={"Authorization": f"Bearer {token}"},
|
|
timeout=self._timeout_seconds,
|
|
)
|
|
except (httpx.TimeoutException, httpx.TransportError) as exc:
|
|
if attempt < self._retry_attempts:
|
|
await self._sleep(self._retry_delay(attempt))
|
|
continue
|
|
raise CDEKClientError(
|
|
"CDEK tariff request failed after retry attempts."
|
|
) from exc
|
|
|
|
if self._should_retry(response.status_code):
|
|
if attempt < self._retry_attempts:
|
|
await self._sleep(self._retry_delay(attempt))
|
|
continue
|
|
raise CDEKClientError(
|
|
f"CDEK tariff request failed with status {response.status_code}."
|
|
)
|
|
|
|
try:
|
|
response.raise_for_status()
|
|
raw_payload = response.json()
|
|
except (httpx.HTTPError, TypeError, ValueError) as exc:
|
|
raise CDEKClientError("CDEK tariff request returned invalid payload.") from exc
|
|
|
|
if not isinstance(raw_payload, dict):
|
|
raise CDEKClientError("CDEK tariff payload must be a JSON object.")
|
|
return raw_payload
|
|
|
|
raise CDEKClientError("CDEK tariff request failed unexpectedly.")
|
|
|
|
async def register_order(self, request: InitPaymentRequest) -> str:
|
|
payload = map_cdek_order_request(request)
|
|
for attempt in range(self._retry_attempts + 1):
|
|
try:
|
|
token = await self._auth_client.get_access_token()
|
|
response = await self._http_client.post(
|
|
self._orders_url,
|
|
json=payload,
|
|
headers={"Authorization": f"Bearer {token}"},
|
|
timeout=self._timeout_seconds,
|
|
)
|
|
except (httpx.TimeoutException, httpx.TransportError) as exc:
|
|
if attempt < self._retry_attempts:
|
|
await self._sleep(self._retry_delay(attempt))
|
|
continue
|
|
raise CDEKClientError(
|
|
"CDEK order registration failed after retry attempts."
|
|
) from exc
|
|
|
|
if self._should_retry(response.status_code):
|
|
if attempt < self._retry_attempts:
|
|
await self._sleep(self._retry_delay(attempt))
|
|
continue
|
|
raise CDEKClientError(
|
|
"CDEK order registration failed with retriable status "
|
|
f"{response.status_code}."
|
|
)
|
|
|
|
if 400 <= response.status_code < 500:
|
|
existing_order_uuid = map_cdek_existing_order_response(
|
|
_response_json_or_none(response)
|
|
)
|
|
if existing_order_uuid is not None:
|
|
return existing_order_uuid
|
|
raise CDEKRequestError(
|
|
"CDEK order registration request was rejected with status "
|
|
f"{response.status_code}."
|
|
)
|
|
|
|
try:
|
|
response.raise_for_status()
|
|
raw_payload = response.json()
|
|
except (httpx.HTTPError, TypeError, ValueError) as exc:
|
|
raise CDEKClientError(
|
|
"CDEK order registration returned invalid payload."
|
|
) from exc
|
|
|
|
if not isinstance(raw_payload, dict):
|
|
raise CDEKClientError(
|
|
"CDEK order registration payload must be a JSON object."
|
|
)
|
|
|
|
try:
|
|
return map_cdek_order_response(raw_payload)
|
|
except CDEKOrderMappingError as exc:
|
|
raise CDEKClientError(
|
|
"CDEK order registration response payload is invalid."
|
|
) from exc
|
|
|
|
raise CDEKClientError("CDEK order registration failed unexpectedly.")
|
|
|
|
def _retry_delay(self, attempt: int) -> float:
|
|
return self._retry_backoff_seconds * (attempt + 1)
|
|
|
|
@staticmethod
|
|
def _should_retry(status_code: int) -> bool:
|
|
return status_code == 429 or status_code >= 500
|
|
|
|
async def _build_payload(
|
|
self, request: DeliveryCalculationRequest
|
|
) -> dict[str, Any]:
|
|
from_city_code = self._get_cdek_city_code(request.from_city)
|
|
to_city_code = self._get_cdek_city_code(request.to_city)
|
|
return {
|
|
"type": 2,
|
|
"from_location": {"code": from_city_code},
|
|
"to_location": {"code": to_city_code},
|
|
"packages": [
|
|
{
|
|
"weight": int(round(request.weight_kg * 1000)),
|
|
"length": int(round(request.length_cm)),
|
|
"width": int(round(request.width_cm)),
|
|
"height": int(round(request.height_cm)),
|
|
}
|
|
],
|
|
}
|
|
|
|
@staticmethod
|
|
def _get_cdek_city_code(city_id: int) -> int:
|
|
city_entry = cities_map.get(str(city_id))
|
|
if not isinstance(city_entry, dict):
|
|
raise CDEKRequestError(
|
|
f"CDEK city mapping is not configured for city id {city_id}."
|
|
)
|
|
|
|
cdek_data = city_entry.get("cdek")
|
|
if not isinstance(cdek_data, dict):
|
|
raise CDEKRequestError(
|
|
f"CDEK city mapping is not configured for city id {city_id}."
|
|
)
|
|
|
|
raw_city_code = cdek_data.get("code")
|
|
if raw_city_code is None or isinstance(raw_city_code, bool):
|
|
raise CDEKRequestError(
|
|
f"CDEK city code is invalid for city id {city_id}."
|
|
)
|
|
|
|
try:
|
|
return int(raw_city_code)
|
|
except (TypeError, ValueError) as exc:
|
|
raise CDEKRequestError(
|
|
f"CDEK city code is invalid for city id {city_id}."
|
|
) from exc
|
|
|
|
|
|
class CDEKProvider(DeliveryProvider):
|
|
name = "cdek"
|
|
|
|
def __init__(self, client: CDEKClient, *, cache_ttl_seconds: int = 900) -> None:
|
|
self._client = client
|
|
self.cache_ttl_seconds = cache_ttl_seconds
|
|
|
|
@classmethod
|
|
def from_adapter_config(
|
|
cls,
|
|
*,
|
|
http_client: httpx.AsyncClient,
|
|
adapter_config: AdapterConfig,
|
|
) -> "CDEKProvider":
|
|
auth_client = CDEKAuthClient(
|
|
http_client=http_client,
|
|
base_url=adapter_config.cdek_base_url,
|
|
client_id=adapter_config.cdek_client_id,
|
|
client_secret=adapter_config.cdek_client_secret,
|
|
timeout_seconds=adapter_config.cdek_timeout_seconds,
|
|
)
|
|
client = CDEKClient(
|
|
http_client=http_client,
|
|
auth_client=auth_client,
|
|
base_url=adapter_config.cdek_base_url,
|
|
timeout_seconds=adapter_config.cdek_timeout_seconds,
|
|
retry_attempts=adapter_config.cdek_retry_attempts,
|
|
retry_backoff_seconds=adapter_config.cdek_retry_backoff_seconds,
|
|
)
|
|
return cls(client=client, cache_ttl_seconds=adapter_config.cdek_cache_ttl_seconds)
|
|
|
|
async def get_prices(
|
|
self, request: DeliveryCalculationRequest
|
|
) -> list[DeliveryPrice]:
|
|
raw_payload = await self._client.get_raw_price(request)
|
|
return map_cdek_response(raw_payload)
|
|
|
|
async def register_order(self, request: InitPaymentRequest) -> str:
|
|
return await self._client.register_order(request)
|
|
|
|
|
|
def _response_json_or_none(response: httpx.Response) -> object | None:
|
|
try:
|
|
return response.json()
|
|
except (TypeError, ValueError):
|
|
return None
|