добавлено получение накладной в cse

app/adapters/delivery_providers/cse/client.py

@@ -21,12 +21,17 @@ from app.adapters.delivery_providers.cse.mapper import (
     map_cse_calc_response_for_tariff_code,
 )
 from app.adapters.delivery_providers.cse.order_mapper import (
+    CSEOrderInfo,
     CSEOrderRegistrationParams,
     CSEOrderRegistrationResult,
     build_calc_body_for_calculation,
     build_calc_body_for_payment,
+    build_tracking_body_for_order,
+    build_waybill_print_form_body,
+    map_cse_tracking_response,
     map_cse_save_order_request,
     map_cse_save_order_response,
+    map_cse_waybill_print_form_response,
     split_tariff_code,
 )
 from app.adapters.delivery_providers.cse.soap import (
@@ -113,6 +118,30 @@ class CSEClient:
         except CSEMappingError as exc:
             raise CSEClientError(str(exc)) from exc
 
+    async def get_order(self, order_number: str) -> CSEOrderInfo:
+        root = await self._post(
+            "Tracking",
+            build_tracking_body_for_order(order_number),
+            request_error_message="CSE Tracking request was rejected with status",
+        )
+        try:
+            return map_cse_tracking_response(root)
+        except CSEMappingError as exc:
+            raise CSEClientError(str(exc)) from exc
+
+    async def download_waybill_pdf(self, waybill_number: str) -> bytes:
+        root = await self._post(
+            "GetFormsForDocuments",
+            build_waybill_print_form_body(waybill_number),
+            request_error_message=(
+                "CSE GetFormsForDocuments request was rejected with status"
+            ),
+        )
+        try:
+            return map_cse_waybill_print_form_response(root)
+        except CSEMappingError as exc:
+            raise CSEClientError(str(exc)) from exc
+
     async def _post(
         self,
         operation: str,
@@ -152,7 +181,8 @@ class CSEClient:
                     status_code=response.status_code,
                 )
                 raise CSEClientError(
-                    f"CSE {operation} request failed with status {response.status_code}."
+                    f"CSE {operation} request failed with status "
+                    f"{response.status_code}."
                 )
 
             if 400 <= response.status_code < 500:
@@ -312,3 +342,9 @@ class CSEProvider(DeliveryProvider):
         self, request: InitPaymentRequest, order_uuid: str
     ) -> CSEOrderRegistrationResult:
         return await self._client.save_order(request, order_uuid)
+
+    async def get_order(self, order_number: str) -> CSEOrderInfo:
+        return await self._client.get_order(order_number)
+
+    async def download_waybill_pdf(self, waybill_number: str) -> bytes:
+        return await self._client.download_waybill_pdf(waybill_number)

app/adapters/delivery_providers/cse/order_mapper.py

@@ -1,5 +1,7 @@
-"""CSE Calc and SaveDocuments payload mappers."""
+"""CSE Calc, SaveDocuments and waybill payload mappers."""
 
+import base64
+import binascii
 from dataclasses import dataclass
 
 from app.adapters.delivery_providers.cse.constants import (
@@ -32,6 +34,13 @@ class CSEOrderRegistrationResult:
     order_number: str
 
 
+@dataclass(frozen=True)
+class CSEOrderInfo:
+    order_number: str
+    status_code: str | None
+    waybill_number: str | None
+
+
 def build_calc_body_for_calculation(
     request: DeliveryCalculationRequest,
     delivery_type: str = "",
@@ -176,6 +185,73 @@ def map_cse_save_order_response(root: Element) -> CSEOrderRegistrationResult:
     raise CSEMappingError("CSE SaveDocuments response is missing document Number.")
 
 
+def build_tracking_body_for_order(order_number: str) -> dict[str, Element]:
+    return {
+        "documents": Element(
+            key="Documents",
+            items=[Element(key=order_number)],
+        ),
+        "parameters": Element(
+            key="parameters",
+            items=[
+                make_field("DocumentType", "Order"),
+                make_field("OnlySelectedType", True, "boolean"),
+            ],
+        ),
+    }
+
+
+def map_cse_tracking_response(root: Element) -> CSEOrderInfo:
+    for document in root.items:
+        order_number = document.property_value("Number") or document.key
+        if not order_number:
+            continue
+        return CSEOrderInfo(
+            order_number=order_number,
+            status_code=_latest_tracking_status(document),
+            waybill_number=_extract_waybill_number(document),
+        )
+    raise CSEMappingError("CSE Tracking response is missing document data.")
+
+
+def build_waybill_print_form_body(waybill_number: str) -> dict[str, Element]:
+    return {
+        "documents": Element(
+            key="Documents",
+            items=[Element(key=waybill_number)],
+        ),
+        "parameters": Element(
+            key="parameters",
+            items=[
+                make_field("DocumentType", "waybill"),
+                make_field("Type", "print"),
+                make_field(
+                    "Name",
+                    "Универсальная печатная "
+                    "форма документа НАКЛАДНАЯ",
+                ),
+                make_field("Format", "pdf"),
+                make_field("OnlySelectedType", True, "boolean"),
+            ],
+        ),
+    }
+
+
+def map_cse_waybill_print_form_response(root: Element) -> bytes:
+    for document in root.items:
+        bdata = document.bdata
+        if not bdata:
+            continue
+        try:
+            normalized_bdata = "".join(bdata.split())
+            return base64.b64decode(normalized_bdata, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise CSEMappingError(
+                "CSE GetFormsForDocuments response contains invalid BData."
+            ) from exc
+    raise CSEMappingError("CSE GetFormsForDocuments response is missing BData.")
+
+
 def _parcel_type(request: DeliveryCalculationRequest) -> str | None:
     return request.parcel_type.value if request.parcel_type is not None else None
 
@@ -190,3 +266,30 @@ def _compose_address(address: Address) -> str:
 
 def _format_decimal(value: float) -> str:
     return format(value, "g")
+
+
+def _latest_tracking_status(document: Element) -> str | None:
+    dated: list[tuple[str, str]] = []
+    for state in document.items:
+        if not state.key:
+            continue
+        date_time = state.property_value("DateTime") or ""
+        dated.append((date_time, state.key))
+    if not dated:
+        return None
+    dated.sort(key=lambda item: item[0])
+    return dated[-1][1]
+
+
+def _extract_waybill_number(document: Element) -> str | None:
+    for table in document.tables:
+        if table.key != "Waybills":
+            continue
+        for waybill in table.items:
+            document_type = waybill.property_value("DocumentType")
+            if document_type is not None and document_type.lower() != "waybill":
+                continue
+            number = waybill.property_value("Number") or waybill.key
+            if number:
+                return number
+    return None

app/adapters/delivery_providers/cse/soap.py

@@ -18,6 +18,7 @@ SOAP_NS = "http://www.w3.org/2003/05/soap-envelope"
 # Child tags of an Element that hold nested Element lists.
 _LIST_TAGS = ("Fields", "List", "Tables", "Properties")
 _SCALAR_TAGS = ("Key", "Value", "ValueType")
+_BINARY_TAG = "BData"
 
 
 @dataclass
@@ -27,6 +28,7 @@ class Element:
     key: str | None = None
     value: str | None = None
     value_type: str | None = None
+    bdata: str | None = None
     fields: list["Element"] = field(default_factory=list)
     items: list["Element"] = field(default_factory=list)  # <List>
     tables: list["Element"] = field(default_factory=list)
@@ -159,6 +161,8 @@ def _parse_element(node: ET.Element) -> Element:
             element.tables.append(_parse_element(child))
         elif local == "Properties":
             element.properties.append(_parse_element(child))
+        elif local == _BINARY_TAG:
+            element.bdata = (child.text or "").strip()
     return element
 
 

app/repositories/order/repository.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any
 
-from sqlalchemy import select
+from sqlalchemy import and_, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
 from app.domain.cdek_polling import TERMINAL_ORDER_STATUSES
@@ -95,17 +95,23 @@ class OrderRepository:
         *,
         limit: int,
     ) -> Sequence[Order]:
+        cdek_pending = and_(
+            Order.provider == "cdek",
+            Order.provider_order_id.is_not(None),
+            Order.provider_waybill_url.is_(None),
+            (
+                Order.provider_order_status.is_(None)
+                | Order.provider_order_status.not_in(TERMINAL_ORDER_STATUSES)
+            ),
+        )
+        cse_pending = and_(
+            Order.provider == "cse",
+            Order.provider_order_id.is_not(None),
+            Order.provider_waybill_id.is_(None),
+        )
         statement = (
             select(Order)
-            .where(
-                Order.provider == "cdek",
-                Order.provider_order_id.is_not(None),
-                Order.provider_waybill_url.is_(None),
-                (
-                    Order.provider_order_status.is_(None)
-                    | Order.provider_order_status.not_in(TERMINAL_ORDER_STATUSES)
-                ),
-            )
+            .where(or_(cdek_pending, cse_pending))
             .order_by(Order.provider_polled_at.asc().nulls_first())
             .limit(limit)
             .with_for_update(skip_locked=True)
@@ -173,11 +179,18 @@ class OrderRepository:
         *,
         limit: int,
     ) -> Sequence[Order]:
+        cdek_ready = and_(
+            Order.provider == "cdek",
+            Order.provider_waybill_url.is_not(None),
+        )
+        cse_ready = and_(
+            Order.provider == "cse",
+            Order.provider_waybill_id.is_not(None),
+        )
         statement = (
             select(Order)
             .where(
-                Order.provider == "cdek",
-                Order.provider_waybill_url.is_not(None),
+                or_(cdek_ready, cse_ready),
                 Order.waybill_email_sent_at.is_(None),
             )
             .order_by(Order.created_at.asc())

app/services/waybill_email_sender.py

@@ -1,7 +1,7 @@
-"""Background service that e-mails CDEK waybill PDFs to customers."""
+"""Background service that e-mails provider waybill PDFs to customers."""
 
 import asyncio
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -15,15 +15,18 @@ logger = structlog.get_logger(__name__)
 _EMAIL_SUBJECT_TEMPLATE = "Накладная по заказу {order_uuid}"
 _EMAIL_BODY_TEMPLATE = (
     "Здравствуйте!\n\n"
-    "По вашему заказу {order_uuid} сформирована транспортная накладная CDEK.\n"
+    "По вашему заказу {order_uuid} сформирована "
+    "транспортная накладная.\n"
     "PDF-файл накладной приложен к этому письму.\n"
+)
+_EMAIL_BODY_URL_LINE_TEMPLATE = (
     "Также накладная доступна по ссылке: {waybill_url}\n"
 )
 _ATTACHMENT_FILENAME_TEMPLATE = "waybill_{order_uuid}.pdf"
 
 
 class WaybillPDFDownloaderProtocol(Protocol):
-    async def download_waybill_pdf(self, url: str) -> bytes: ...
+    async def download_waybill_pdf(self, order: "OrderRecord") -> bytes: ...
 
 
 class EmailSenderProtocol(Protocol):
@@ -40,7 +43,9 @@ class EmailSenderProtocol(Protocol):
 
 class OrderRecord(Protocol):
     order_uuid: str
+    provider: str
     account_email: str
+    provider_waybill_id: str | None
     provider_waybill_url: str | None
 
 
@@ -72,13 +77,13 @@ class WaybillEmailSenderService:
         self,
         *,
         order_repository: WaybillEmailSenderRepositoryProtocol,
-        waybill_downloader: WaybillPDFDownloaderProtocol,
+        waybill_downloaders: Mapping[str, WaybillPDFDownloaderProtocol],
         email_sender: EmailSenderProtocol,
         batch_size: int,
         datetime_now: Callable[[], datetime] = lambda: datetime.now(timezone.utc),
     ) -> None:
         self._repository = order_repository
-        self._waybill_downloader = waybill_downloader
+        self._waybill_downloaders = dict(waybill_downloaders)
         self._email_sender = email_sender
         self._batch_size = batch_size
         self._datetime_now = datetime_now
@@ -99,6 +104,7 @@ class WaybillEmailSenderService:
                     logger.exception(
                         "waybill_email_order_failed",
                         order_uuid=order.order_uuid,
+                        provider=order.provider,
                         account_email=order.account_email,
                     )
             return SendBatchSummary(
@@ -133,16 +139,17 @@ class WaybillEmailSenderService:
                 continue
 
     async def _handle_order(self, session: object, order: OrderRecord) -> None:
-        waybill_url = order.provider_waybill_url
-        if waybill_url is None:
+        if order.provider_waybill_url is None and order.provider_waybill_id is None:
             return
 
-        pdf_bytes = await self._waybill_downloader.download_waybill_pdf(waybill_url)
+        downloader = self._resolve_downloader(order.provider)
+        pdf_bytes = await downloader.download_waybill_pdf(order)
         subject = _EMAIL_SUBJECT_TEMPLATE.format(order_uuid=order.order_uuid)
-        body = _EMAIL_BODY_TEMPLATE.format(
-            order_uuid=order.order_uuid,
-            waybill_url=waybill_url,
-        )
+        body = _EMAIL_BODY_TEMPLATE.format(order_uuid=order.order_uuid)
+        if order.provider_waybill_url is not None:
+            body += _EMAIL_BODY_URL_LINE_TEMPLATE.format(
+                waybill_url=order.provider_waybill_url,
+            )
         filename = _ATTACHMENT_FILENAME_TEMPLATE.format(order_uuid=order.order_uuid)
 
         await self._email_sender.send_email(
@@ -162,6 +169,13 @@ class WaybillEmailSenderService:
         logger.info(
             "waybill_email_sent",
             order_uuid=order.order_uuid,
+            provider=order.provider,
             account_email=order.account_email,
             sent_at=sent_at,
         )
+
+    def _resolve_downloader(self, provider: str) -> WaybillPDFDownloaderProtocol:
+        downloader = self._waybill_downloaders.get(provider)
+        if downloader is None:
+            raise RuntimeError(f"Waybill downloader is not configured for {provider}.")
+        return downloader

app/services/waybill_poller.py

@@ -1,7 +1,7 @@
-"""Background service that polls CDEK for waybill updates."""
+"""Background service that polls providers for waybill updates."""
 
 import asyncio
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -9,24 +9,20 @@ from typing import Protocol
 
 import structlog
 
-from app.adapters.delivery_providers.cdek.order_mapper import (
-    CDEKOrderInfo,
-    CDEKWaybillInfo,
-)
-
 logger = structlog.get_logger(__name__)
 
 
-class CDEKOrderInfoAdapterProtocol(Protocol):
-    async def get_order(self, cdek_order_uuid: str) -> CDEKOrderInfo: ...
+class OrderInfoAdapterProtocol(Protocol):
+    async def get_order(self, provider_order_id: str) -> object: ...
 
 
-class CDEKWaybillInfoAdapterProtocol(Protocol):
-    async def get_waybill(self, cdek_waybill_uuid: str) -> CDEKWaybillInfo: ...
+class WaybillInfoAdapterProtocol(Protocol):
+    async def get_waybill(self, provider_waybill_id: str) -> object: ...
 
 
 class OrderRecord(Protocol):
     order_uuid: str
+    provider: str
     provider_order_id: str | None
     provider_waybill_id: str | None
 
@@ -70,14 +66,14 @@ class WaybillPollerService:
         self,
         *,
         order_repository: WaybillPollerRepositoryProtocol,
-        order_info_adapter: CDEKOrderInfoAdapterProtocol,
-        waybill_info_adapter: CDEKWaybillInfoAdapterProtocol,
+        order_info_adapters: Mapping[str, OrderInfoAdapterProtocol],
+        waybill_info_adapters: Mapping[str, WaybillInfoAdapterProtocol],
         batch_size: int,
         datetime_now: Callable[[], datetime] = lambda: datetime.now(timezone.utc),
     ) -> None:
         self._repository = order_repository
-        self._order_info_adapter = order_info_adapter
-        self._waybill_info_adapter = waybill_info_adapter
+        self._order_info_adapters = dict(order_info_adapters)
+        self._waybill_info_adapters = dict(waybill_info_adapters)
         self._batch_size = batch_size
         self._datetime_now = datetime_now
 
@@ -97,6 +93,7 @@ class WaybillPollerService:
                     logger.exception(
                         "waybill_poll_order_failed",
                         order_uuid=order.order_uuid,
+                        provider=order.provider,
                         provider_order_id=order.provider_order_id,
                         provider_waybill_id=order.provider_waybill_id,
                     )
@@ -137,35 +134,74 @@ class WaybillPollerService:
             provider_order_id = order.provider_order_id
             if provider_order_id is None:
                 return
-            info = await self._order_info_adapter.get_order(provider_order_id)
+            adapter = self._resolve_order_info_adapter(order.provider)
+            info = await adapter.get_order(provider_order_id)
+            status_code = _extract_status_code(info)
+            waybill_id = _extract_waybill_id(info)
             await self._repository.record_order_poll(
                 session,
                 order_uuid=order.order_uuid,
-                order_status=info.status_code,
-                waybill_uuid=info.waybill_uuid,
+                order_status=status_code,
+                waybill_uuid=waybill_id,
                 polled_at=polled_at,
             )
             logger.info(
                 "waybill_poll_order_result",
                 order_uuid=order.order_uuid,
+                provider=order.provider,
                 provider_order_id=provider_order_id,
-                provider_order_status=info.status_code,
-                provider_waybill_id=info.waybill_uuid,
+                provider_order_status=status_code,
+                provider_waybill_id=waybill_id,
             )
             return
 
-        waybill = await self._waybill_info_adapter.get_waybill(
-            order.provider_waybill_id
-        )
+        adapter = self._resolve_waybill_info_adapter(order.provider)
+        waybill = await adapter.get_waybill(order.provider_waybill_id)
+        waybill_url = _extract_waybill_url(waybill)
         await self._repository.record_waybill_poll(
             session,
             order_uuid=order.order_uuid,
-            waybill_url=waybill.url,
+            waybill_url=waybill_url,
             polled_at=polled_at,
         )
         logger.info(
             "waybill_poll_waybill_result",
             order_uuid=order.order_uuid,
+            provider=order.provider,
             provider_waybill_id=order.provider_waybill_id,
-            provider_waybill_url=waybill.url,
+            provider_waybill_url=waybill_url,
         )
+
+    def _resolve_order_info_adapter(self, provider: str) -> OrderInfoAdapterProtocol:
+        adapter = self._order_info_adapters.get(provider)
+        if adapter is None:
+            raise RuntimeError(f"Order info adapter is not configured for {provider}.")
+        return adapter
+
+    def _resolve_waybill_info_adapter(
+        self, provider: str
+    ) -> WaybillInfoAdapterProtocol:
+        adapter = self._waybill_info_adapters.get(provider)
+        if adapter is None:
+            raise RuntimeError(
+                f"Waybill info adapter is not configured for {provider}."
+            )
+        return adapter
+
+
+def _extract_status_code(info: object) -> str | None:
+    value = getattr(info, "status_code", None)
+    return value if isinstance(value, str) and value else None
+
+
+def _extract_waybill_id(info: object) -> str | None:
+    for attr in ("waybill_id", "waybill_uuid", "waybill_number"):
+        value = getattr(info, attr, None)
+        if isinstance(value, str) and value:
+            return value
+    return None
+
+
+def _extract_waybill_url(info: object) -> str | None:
+    value = getattr(info, "url", None)
+    return value if isinstance(value, str) and value else None

app/workers/waybill_email_sender.py

@@ -1,13 +1,21 @@
-"""Background worker that e-mails CDEK waybill PDFs."""
+"""Background worker that e-mails provider waybill PDFs."""
 
 import asyncio
 import signal
+from dataclasses import dataclass
 
 import httpx
 import structlog
 
+from app.adapters.delivery_providers.registry import (
+    resolve_delivery_provider_timeout_seconds,
+)
 from app.adapters.delivery_providers.cdek.auth import CDEKAuthClient
 from app.adapters.delivery_providers.cdek.client import CDEKClient
+from app.adapters.delivery_providers.cse.client import CSEClient
+from app.adapters.delivery_providers.cse.order_mapper import (
+    CSEOrderRegistrationParams,
+)
 from app.adapters.email import SMTPEmailSender
 from app.adapters.postgres.engine import (
     create_postgres_engine,
@@ -21,24 +29,71 @@ from app.services.waybill_email_sender import WaybillEmailSenderService
 logger = structlog.get_logger(__name__)
 
 
+@dataclass(frozen=True)
+class CDEKWaybillPDFDownloader:
+    client: CDEKClient
+
+    async def download_waybill_pdf(self, order: object) -> bytes:
+        url = getattr(order, "provider_waybill_url", None)
+        if not isinstance(url, str) or not url:
+            raise RuntimeError("CDEK waybill URL is missing.")
+        return await self.client.download_waybill_pdf(url)
+
+
+@dataclass(frozen=True)
+class CSEWaybillPDFDownloader:
+    client: CSEClient
+
+    async def download_waybill_pdf(self, order: object) -> bytes:
+        waybill_number = getattr(order, "provider_waybill_id", None)
+        if not isinstance(waybill_number, str) or not waybill_number:
+            raise RuntimeError("CSE waybill number is missing.")
+        return await self.client.download_waybill_pdf(waybill_number)
+
+
 async def _run(settings: Settings, stop_event: asyncio.Event) -> None:
+    http_client = httpx.AsyncClient(
+        timeout=resolve_delivery_provider_timeout_seconds(settings.delivery_providers)
+    )
+    waybill_downloaders: dict[str, object] = {}
+
     cdek_config = settings.delivery_providers.cdek
-    http_client = httpx.AsyncClient(timeout=cdek_config.timeout_seconds)
-    auth_client = CDEKAuthClient(
-        http_client=http_client,
-        base_url=cdek_config.base_url,
-        client_id=cdek_config.client_id,
-        client_secret=cdek_config.client_secret,
-        timeout_seconds=cdek_config.timeout_seconds,
-    )
-    cdek_client = CDEKClient(
-        http_client=http_client,
-        auth_client=auth_client,
-        base_url=cdek_config.base_url,
-        timeout_seconds=cdek_config.timeout_seconds,
-        retry_attempts=cdek_config.retry_attempts,
-        retry_backoff_seconds=cdek_config.retry_backoff_seconds,
-    )
+    if cdek_config.enabled:
+        auth_client = CDEKAuthClient(
+            http_client=http_client,
+            base_url=cdek_config.base_url,
+            client_id=cdek_config.client_id,
+            client_secret=cdek_config.client_secret,
+            timeout_seconds=cdek_config.timeout_seconds,
+        )
+        cdek_client = CDEKClient(
+            http_client=http_client,
+            auth_client=auth_client,
+            base_url=cdek_config.base_url,
+            timeout_seconds=cdek_config.timeout_seconds,
+            retry_attempts=cdek_config.retry_attempts,
+            retry_backoff_seconds=cdek_config.retry_backoff_seconds,
+        )
+        waybill_downloaders["cdek"] = CDEKWaybillPDFDownloader(cdek_client)
+
+    cse_config = settings.delivery_providers.cse
+    if cse_config.enabled:
+        cse_client = CSEClient(
+            http_client=http_client,
+            base_url=cse_config.base_url,
+            login=cse_config.login,
+            password=cse_config.password,
+            registration_params=CSEOrderRegistrationParams(
+                payer=cse_config.payer,
+                payment_method=cse_config.payment_method,
+                shipping_method=cse_config.shipping_method,
+            ),
+            timeout_seconds=cse_config.timeout_seconds,
+            retry_attempts=cse_config.retry_attempts,
+            retry_backoff_seconds=cse_config.retry_backoff_seconds,
+        )
+        waybill_downloaders["cse"] = CSEWaybillPDFDownloader(cse_client)
+
     email_sender = SMTPEmailSender(
         smtp_host=settings.email.smtp_host,
         smtp_port=settings.email.smtp_port,
@@ -53,7 +108,7 @@ async def _run(settings: Settings, stop_event: asyncio.Event) -> None:
     repository = OrderRepository(session_factory=session_factory)
     service = WaybillEmailSenderService(
         order_repository=repository,
-        waybill_downloader=cdek_client,
+        waybill_downloaders=waybill_downloaders,
         email_sender=email_sender,
         batch_size=settings.waybill_email_sender.batch_size,
     )

app/workers/waybill_poller.py

@@ -1,4 +1,4 @@
-"""Background worker that polls CDEK for waybill updates."""
+"""Background worker that polls delivery providers for waybill updates."""
 
 import asyncio
 import signal
@@ -6,8 +6,15 @@ import signal
 import httpx
 import structlog
 
+from app.adapters.delivery_providers.registry import (
+    resolve_delivery_provider_timeout_seconds,
+)
 from app.adapters.delivery_providers.cdek.auth import CDEKAuthClient
 from app.adapters.delivery_providers.cdek.client import CDEKClient
+from app.adapters.delivery_providers.cse.client import CSEClient
+from app.adapters.delivery_providers.cse.order_mapper import (
+    CSEOrderRegistrationParams,
+)
 from app.adapters.postgres.engine import (
     create_postgres_engine,
     create_postgres_session_factory,
@@ -21,30 +28,57 @@ logger = structlog.get_logger(__name__)
 
 
 async def _run(settings: Settings, stop_event: asyncio.Event) -> None:
+    http_client = httpx.AsyncClient(
+        timeout=resolve_delivery_provider_timeout_seconds(settings.delivery_providers)
+    )
+    order_info_adapters: dict[str, object] = {}
+    waybill_info_adapters: dict[str, object] = {}
+
     cdek_config = settings.delivery_providers.cdek
-    http_client = httpx.AsyncClient(timeout=cdek_config.timeout_seconds)
-    auth_client = CDEKAuthClient(
-        http_client=http_client,
-        base_url=cdek_config.base_url,
-        client_id=cdek_config.client_id,
-        client_secret=cdek_config.client_secret,
-        timeout_seconds=cdek_config.timeout_seconds,
-    )
-    cdek_client = CDEKClient(
-        http_client=http_client,
-        auth_client=auth_client,
-        base_url=cdek_config.base_url,
-        timeout_seconds=cdek_config.timeout_seconds,
-        retry_attempts=cdek_config.retry_attempts,
-        retry_backoff_seconds=cdek_config.retry_backoff_seconds,
-    )
+    if cdek_config.enabled:
+        auth_client = CDEKAuthClient(
+            http_client=http_client,
+            base_url=cdek_config.base_url,
+            client_id=cdek_config.client_id,
+            client_secret=cdek_config.client_secret,
+            timeout_seconds=cdek_config.timeout_seconds,
+        )
+        cdek_client = CDEKClient(
+            http_client=http_client,
+            auth_client=auth_client,
+            base_url=cdek_config.base_url,
+            timeout_seconds=cdek_config.timeout_seconds,
+            retry_attempts=cdek_config.retry_attempts,
+            retry_backoff_seconds=cdek_config.retry_backoff_seconds,
+        )
+        order_info_adapters["cdek"] = cdek_client
+        waybill_info_adapters["cdek"] = cdek_client
+
+    cse_config = settings.delivery_providers.cse
+    if cse_config.enabled:
+        cse_client = CSEClient(
+            http_client=http_client,
+            base_url=cse_config.base_url,
+            login=cse_config.login,
+            password=cse_config.password,
+            registration_params=CSEOrderRegistrationParams(
+                payer=cse_config.payer,
+                payment_method=cse_config.payment_method,
+                shipping_method=cse_config.shipping_method,
+            ),
+            timeout_seconds=cse_config.timeout_seconds,
+            retry_attempts=cse_config.retry_attempts,
+            retry_backoff_seconds=cse_config.retry_backoff_seconds,
+        )
+        order_info_adapters["cse"] = cse_client
+
     engine = create_postgres_engine(settings.postgres)
     session_factory = create_postgres_session_factory(engine)
     repository = OrderRepository(session_factory=session_factory)
     service = WaybillPollerService(
         order_repository=repository,
-        order_info_adapter=cdek_client,
-        waybill_info_adapter=cdek_client,
+        order_info_adapters=order_info_adapters,
+        waybill_info_adapters=waybill_info_adapters,
         batch_size=settings.waybill_poller.batch_size,
     )
     logger.info(