Добавлен POST /api/v1/delivery/suggest-address

app/adapters/address_suggestions/dadata/client.py

@@ -133,14 +133,27 @@ def _map_dadata_suggestion(payload: object) -> AddressSuggestion:
     if raw_data is not None and not isinstance(raw_data, dict):
         raise ValueError("Dadata suggestion data must be an object when provided.")
 
+    street = None
+    house = None
+    flat = None
     postal_code = None
     if isinstance(raw_data, dict):
-        raw_postal_code = raw_data.get("postal_code")
-        if raw_postal_code is not None:
-            postal_code = str(raw_postal_code).strip() or None
+        street = _coerce_optional_text(raw_data.get("street"))
+        house = _coerce_optional_text(raw_data.get("house"))
+        flat = _coerce_optional_text(raw_data.get("flat"))
+        postal_code = _coerce_optional_text(raw_data.get("postal_code"))
 
     return AddressSuggestion(
-        provider="dadata",
         address=raw_address.strip(),
+        street=street,
+        house=house,
+        flat=flat,
         postal_code=postal_code,
     )
+
+
+def _coerce_optional_text(value: object) -> str | None:
+    if value is None:
+        return None
+
+    return str(value).strip() or None

app/controllers/v1/delivery.py

@@ -2,18 +2,22 @@
 
 from fastapi import APIRouter, Depends, HTTPException, Request, status
 
+from app.adapters.address_suggestions.dadata import DadataAddressSuggestionProvider
 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 DeliveryCalculationRequest
-from app.schemas.response import DeliveryPrice
+from app.schemas.request import AddressSuggestRequest, DeliveryCalculationRequest
+from app.schemas.response import AddressSuggestion, DeliveryPrice
 from app.services.aggregator import (
+    AddressSuggestionsUnavailableError,
     AggregatorService,
     AggregatorServiceError,
+    InvalidAddressSuggestRequestError,
     InvalidDeliveryRequestError,
     InvalidOrderCreateRequestError,
+    UnsupportedAddressSuggestionCountryError,
 )
 
 router = APIRouter(prefix="/delivery", tags=["delivery"])
@@ -30,12 +34,20 @@ def _build_aggregator_service(settings: Settings) -> AggregatorService:
         http_client=http_client,
         adapter_config=settings.adapter,
     )
+    dadata_provider = DadataAddressSuggestionProvider.from_config(
+        http_client=http_client,
+        config=settings.address_suggestions.dadata,
+    )
     providers = (cdek_provider,)
     cache = PriceCache.from_repository_config(settings.repository)
     service = AggregatorService(
         providers=providers,
         cache=cache,
         order_adapter=cdek_provider,
+        address_suggestion_providers=(dadata_provider,),
+        address_suggestion_country_to_provider=(
+            settings.address_suggestions.country_to_provider
+        ),
         weight_round_scale=settings.business_logic.weight_round_scale,
         provider_price_multiplier=settings.business_logic.provider_price_multiplier,
     )
@@ -81,6 +93,42 @@ async def get_delivery_price(
         ) from exc
 
 
+@router.post(
+    "/suggest-address",
+    response_model=list[AddressSuggestion],
+)
+async def suggest_addresses(
+    address_request: AddressSuggestRequest,
+    service: AggregatorService = Depends(get_aggregator_service),
+) -> list[AddressSuggestion]:
+    try:
+        return await service.suggest_addresses(address_request)
+    except UnsupportedAddressSuggestionCountryError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": "unsupported_address_suggestion_country",
+                "message": "Address suggestions are not configured for the requested country.",
+            },
+        ) from exc
+    except InvalidAddressSuggestRequestError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": "invalid_address_suggest_request",
+                "message": "Address suggestion request contains invalid or unsupported provider data.",
+            },
+        ) from exc
+    except AddressSuggestionsUnavailableError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail={
+                "code": "address_suggestions_unavailable",
+                "message": "Address suggestions are temporarily unavailable.",
+            },
+        ) from exc
+
+
 @router.post(
     "/order",
     response_model=OrderCreateResponse,

app/schemas/response.py

@@ -15,6 +15,8 @@ class DeliveryPrice(BaseModel):
 
 
 class AddressSuggestion(BaseModel):
-    provider: str = Field(min_length=1)
     address: str = Field(min_length=1)
-    postal_code: str | None = None
+    street: str | None = Field(default=None, min_length=1)
+    house: str | None = Field(default=None, min_length=1)
+    flat: str | None = Field(default=None, min_length=1)
+    postal_code: str | None = Field(default=None, min_length=1)

app/services/aggregator.py

@@ -3,10 +3,15 @@
 import asyncio
 import hashlib
 import json
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from decimal import Decimal
 from typing import Protocol
 
+from app.adapters.address_suggestions.base import (
+    AddressSuggestionClientError,
+    AddressSuggestionProvider,
+    AddressSuggestionRequestError,
+)
 from app.adapters.delivery_providers.base import DeliveryProvider, ProviderRequestError
 from app.domain.price import (
     DEFAULT_PROVIDER_PRICE_MULTIPLIER,
@@ -16,8 +21,8 @@ from app.domain.price import (
     normalize_delivery_request,
 )
 from app.schemas.order import OrderCreateRequest, OrderCreateResponse
-from app.schemas.request import DeliveryCalculationRequest
-from app.schemas.response import DeliveryPrice
+from app.schemas.request import AddressSuggestRequest, DeliveryCalculationRequest
+from app.schemas.response import AddressSuggestion, DeliveryPrice
 
 
 class AggregatorServiceError(RuntimeError):
@@ -28,6 +33,18 @@ class InvalidDeliveryRequestError(AggregatorServiceError):
     """Raised when provider rejects delivery request as invalid."""
 
 
+class UnsupportedAddressSuggestionCountryError(AggregatorServiceError):
+    """Raised when address suggestions are not configured for a country."""
+
+
+class InvalidAddressSuggestRequestError(AggregatorServiceError):
+    """Raised when provider rejects address suggestion payload."""
+
+
+class AddressSuggestionsUnavailableError(AggregatorServiceError):
+    """Raised when address suggestions cannot be completed."""
+
+
 class InvalidOrderCreateRequestError(AggregatorServiceError):
     """Raised when provider rejects order creation payload as invalid."""
 
@@ -64,6 +81,8 @@ class AggregatorService:
         providers: Sequence[DeliveryProvider],
         cache: PriceCacheProtocol | None = None,
         order_adapter: OrderRegistrationAdapterProtocol | None = None,
+        address_suggestion_providers: Sequence[AddressSuggestionProvider] = (),
+        address_suggestion_country_to_provider: Mapping[str, str] | None = None,
         *,
         weight_round_scale: int = DEFAULT_WEIGHT_ROUND_SCALE,
         provider_price_multiplier: Decimal = DEFAULT_PROVIDER_PRICE_MULTIPLIER,
@@ -75,6 +94,12 @@ class AggregatorService:
         self._weight_round_scale = weight_round_scale
         self._provider_price_multiplier = provider_price_multiplier
         self._filter_and_sort_prices = filter_and_sort_prices_fn
+        self._address_suggestion_providers: dict[str, AddressSuggestionProvider] = {
+            provider.name: provider for provider in address_suggestion_providers
+        }
+        self._address_suggestion_country_to_provider = (
+            address_suggestion_country_to_provider or {}
+        )
 
     async def get_all_prices(
         self, request: DeliveryCalculationRequest
@@ -125,6 +150,24 @@ class AggregatorService:
         )
         return [self._coerce_delivery_price(price) for price in filtered_and_sorted]
 
+    async def suggest_addresses(
+        self, request: AddressSuggestRequest
+    ) -> list[AddressSuggestion]:
+        provider = self._resolve_address_suggestion_provider(request.country_code)
+
+        try:
+            suggestions = await provider.suggest(request)
+        except AddressSuggestionRequestError as exc:
+            raise InvalidAddressSuggestRequestError(
+                "Address suggestion request is invalid for the configured provider."
+            ) from exc
+        except AddressSuggestionClientError as exc:
+            raise AddressSuggestionsUnavailableError(
+                "Address suggestions are temporarily unavailable."
+            ) from exc
+
+        return [self._coerce_address_suggestion(item) for item in suggestions]
+
     async def create_order(self, request: OrderCreateRequest) -> OrderCreateResponse:
         if self._order_adapter is None:
             raise OrderCreationUnavailableError(
@@ -238,3 +281,23 @@ class AggregatorService:
         if not isinstance(value, list):
             raise TypeError("Cached delivery prices must be a list.")
         return [cls._coerce_delivery_price(item) for item in value]
+
+    @staticmethod
+    def _coerce_address_suggestion(value: object) -> AddressSuggestion:
+        return AddressSuggestion.model_validate(value, from_attributes=True)
+
+    def _resolve_address_suggestion_provider(
+        self, country_code: str
+    ) -> AddressSuggestionProvider:
+        provider_id = self._address_suggestion_country_to_provider.get(country_code)
+        if provider_id is None:
+            raise UnsupportedAddressSuggestionCountryError(
+                "Address suggestions are not configured for the requested country."
+            )
+
+        provider = self._address_suggestion_providers.get(provider_id)
+        if provider is None:
+            raise UnsupportedAddressSuggestionCountryError(
+                "Address suggestions are not configured for the requested country."
+            )
+        return provider