017 add creating order router

app/controllers/v1/delivery.py

@@ -6,12 +6,14 @@ from app.adapters.delivery_providers.cdek import CDEKProvider
 from app.config import Settings
 from app.controllers.http_client import build_controller_http_client
 from app.repositories.cache.redis_cache import PriceCache
+from app.schemas.order import OrderCreateRequest, OrderCreateResponse
 from app.schemas.request import DeliveryRequest
 from app.schemas.response import DeliveryPrice
 from app.services.aggregator import (
     AggregatorService,
     AggregatorServiceError,
     InvalidDeliveryRequestError,
+    InvalidOrderCreateRequestError,
 )
 
 router = APIRouter(prefix="/delivery", tags=["delivery"])
@@ -24,16 +26,16 @@ def _build_aggregator_service(settings: Settings) -> AggregatorService:
     http_client = build_controller_http_client(
         timeout_seconds=settings.adapter.cdek_timeout_seconds
     )
-    providers = (
-        CDEKProvider.from_adapter_config(
-            http_client=http_client,
-            adapter_config=settings.adapter,
-        ),
+    cdek_provider = CDEKProvider.from_adapter_config(
+        http_client=http_client,
+        adapter_config=settings.adapter,
     )
+    providers = (cdek_provider,)
     cache = PriceCache.from_repository_config(settings.repository)
     service = AggregatorService(
         providers=providers,
         cache=cache,
+        order_adapter=cdek_provider,
         weight_round_scale=settings.business_logic.weight_round_scale,
         provider_price_multiplier=settings.business_logic.provider_price_multiplier,
     )
@@ -77,3 +79,31 @@ async def get_delivery_price(
                 "message": "Delivery price aggregation is temporarily unavailable.",
             },
         ) from exc
+
+
+@router.post(
+    "/order",
+    response_model=OrderCreateResponse,
+)
+async def create_delivery_order(
+    order_request: OrderCreateRequest,
+    service: AggregatorService = Depends(get_aggregator_service),
+) -> OrderCreateResponse:
+    try:
+        return await service.create_order(order_request)
+    except InvalidOrderCreateRequestError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": "invalid_order_create_request",
+                "message": "Order request contains invalid or unsupported CDEK data.",
+            },
+        ) from exc
+    except AggregatorServiceError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail={
+                "code": "order_creation_unavailable",
+                "message": "CDEK order creation is temporarily unavailable.",
+            },
+        ) from exc

app/services/aggregator.py

@@ -15,6 +15,7 @@ from app.domain.price import (
     filter_and_sort_prices,
     normalize_delivery_request,
 )
+from app.schemas.order import OrderCreateRequest, OrderCreateResponse
 from app.schemas.request import DeliveryRequest
 from app.schemas.response import DeliveryPrice
 
@@ -27,6 +28,14 @@ class InvalidDeliveryRequestError(AggregatorServiceError):
     """Raised when provider rejects delivery request as invalid."""
 
 
+class InvalidOrderCreateRequestError(AggregatorServiceError):
+    """Raised when provider rejects order creation payload as invalid."""
+
+
+class OrderCreationUnavailableError(AggregatorServiceError):
+    """Raised when order creation cannot be completed."""
+
+
 class PriceCacheProtocol(Protocol):
     async def get(self, key: str) -> object | None: ...
 
@@ -42,11 +51,18 @@ class FilterAndSortPricesFn(Protocol):
     ) -> list[object]: ...
 
 
+class OrderRegistrationAdapterProtocol(Protocol):
+    async def register_order(
+        self, request: OrderCreateRequest
+    ) -> OrderCreateResponse: ...
+
+
 class AggregatorService:
     def __init__(
         self,
         providers: Sequence[DeliveryProvider],
         cache: PriceCacheProtocol | None = None,
+        order_adapter: OrderRegistrationAdapterProtocol | None = None,
         *,
         weight_round_scale: int = DEFAULT_WEIGHT_ROUND_SCALE,
         provider_price_multiplier: Decimal = DEFAULT_PROVIDER_PRICE_MULTIPLIER,
@@ -54,6 +70,7 @@ class AggregatorService:
     ) -> None:
         self._providers = tuple(providers)
         self._cache = cache
+        self._order_adapter = order_adapter
         self._weight_round_scale = weight_round_scale
         self._provider_price_multiplier = provider_price_multiplier
         self._filter_and_sort_prices = filter_and_sort_prices_fn
@@ -103,6 +120,28 @@ class AggregatorService:
         )
         return [self._coerce_delivery_price(price) for price in filtered_and_sorted]
 
+    async def create_order(self, request: OrderCreateRequest) -> OrderCreateResponse:
+        if self._order_adapter is None:
+            raise OrderCreationUnavailableError(
+                "Order registration adapter is not configured."
+            )
+
+        try:
+            created_order = await self._order_adapter.register_order(request)
+        except ProviderRequestError as exc:
+            raise InvalidOrderCreateRequestError(
+                "Order request is invalid for the configured provider."
+            ) from exc
+        except Exception as exc:
+            raise OrderCreationUnavailableError(
+                "Order creation is temporarily unavailable."
+            ) from exc
+
+        return OrderCreateResponse.model_validate(
+            created_order,
+            from_attributes=True,
+        )
+
     async def _get_provider_price(
         self,
         *,