g2s-aggregator/app/controllers/v1/delivery.py

"""Delivery API controller skeleton."""

from fastapi import APIRouter, Depends, HTTPException, Request, status

from app.adapters.address_suggestions.dadata import DadataAddressSuggestionProvider
from app.adapters.address_suggestions.yandex_geosuggest import (
    YandexGeosuggestAddressSuggestionProvider,
)
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 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"])


_AGGREGATOR_SERVICE_STATE_KEY = "aggregator_service"


def _build_aggregator_service(settings: Settings) -> AggregatorService:
    http_client = build_controller_http_client(
        timeout_seconds=settings.adapter.cdek_timeout_seconds
    )
    cdek_provider = CDEKProvider.from_adapter_config(
        http_client=http_client,
        adapter_config=settings.adapter,
    )
    dadata_provider = DadataAddressSuggestionProvider.from_config(
        http_client=http_client,
        config=settings.address_suggestions.dadata,
    )
    yandex_geosuggest_provider = YandexGeosuggestAddressSuggestionProvider.from_config(
        http_client=http_client,
        config=settings.address_suggestions.yandex_geosuggest,
    )
    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, yandex_geosuggest_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,
    )
    return service


async def get_aggregator_service(request: Request) -> AggregatorService:
    cached_service = getattr(request.app.state, _AGGREGATOR_SERVICE_STATE_KEY, None)
    if cached_service is not None:
        return cached_service

    settings = request.app.state.settings
    service = _build_aggregator_service(settings)
    setattr(request.app.state, _AGGREGATOR_SERVICE_STATE_KEY, service)
    return service


@router.post(
    "/price",
    response_model=list[DeliveryPrice],
)
async def get_delivery_price(
    delivery_request: DeliveryCalculationRequest,
    service: AggregatorService = Depends(get_aggregator_service),
) -> list[DeliveryPrice]:
    try:
        return await service.get_all_prices(delivery_request)
    except InvalidDeliveryRequestError as exc:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={
                "code": "invalid_delivery_request",
                "message": "Delivery request contains unknown or unsupported location.",
            },
        ) from exc
    except AggregatorServiceError as exc:
        raise HTTPException(
            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
            detail={
                "code": "aggregator_service_error",
                "message": "Delivery price aggregation is temporarily unavailable.",
            },
        ) 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,
)
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