Раис Юсупалиев
849 lines
30 KiB
Python
849 lines
30 KiB
Python
"""Aggregator service orchestrating providers, cache and domain rules."""
|
|
|
|
import asyncio
|
|
import hashlib
|
|
import json
|
|
from collections.abc import Callable, Iterable, Mapping, Sequence
|
|
from contextlib import AbstractAsyncContextManager
|
|
from datetime import datetime, timezone
|
|
from decimal import Decimal
|
|
from typing import Protocol
|
|
from uuid import uuid4
|
|
|
|
import structlog
|
|
|
|
from app.adapters.address_suggestions.base import (
|
|
AddressSuggestionClientError,
|
|
AddressSuggestionProvider,
|
|
AddressSuggestionRequestError,
|
|
)
|
|
from app.adapters.delivery_providers.base import (
|
|
DeliveryProvider,
|
|
ProviderClientError,
|
|
ProviderRequestError,
|
|
)
|
|
from app.adapters.tbank.base import (
|
|
TBankPaymentAdapterError,
|
|
TBankPaymentNotificationTokenError,
|
|
TBankPaymentRequestError,
|
|
)
|
|
from app.domain.payment_notifications import (
|
|
TBankPaymentNotificationAction,
|
|
resolve_tbank_payment_notification_action,
|
|
should_apply_tbank_payment_status,
|
|
)
|
|
from app.domain.price import (
|
|
DEFAULT_PROVIDER_PRICE_MULTIPLIER,
|
|
DEFAULT_WEIGHT_ROUND_SCALE,
|
|
NormalizedDeliveryRequest,
|
|
calculate_expected_payment_amount_kopecks,
|
|
filter_and_sort_prices,
|
|
is_init_payment_price_valid,
|
|
normalize_delivery_request,
|
|
)
|
|
from app.repositories.order import OrderData
|
|
from app.schemas.payment import (
|
|
InitPaymentRequest,
|
|
InitPaymentResponse,
|
|
TBankPaymentNotification,
|
|
)
|
|
from app.cities import cities_map
|
|
from app.schemas.request import (
|
|
AddressSuggestRequest,
|
|
DeliveryCalculationRequest,
|
|
SuggestAddressRequest,
|
|
)
|
|
from app.schemas.response import AddressSuggestion, DeliveryPrice
|
|
|
|
logger = structlog.get_logger(__name__)
|
|
|
|
|
|
class AggregatorServiceError(RuntimeError):
|
|
"""Base exception for AggregatorService failures."""
|
|
|
|
|
|
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 InvalidInitPaymentRequestError(AggregatorServiceError):
|
|
"""Raised when provider rejects payment init payload as invalid."""
|
|
|
|
|
|
class InitPaymentUnavailableError(AggregatorServiceError):
|
|
"""Raised when payment initialization cannot be completed."""
|
|
|
|
|
|
class InvalidTBankPaymentNotificationError(AggregatorServiceError):
|
|
"""Raised when a TBank payment notification is invalid."""
|
|
|
|
|
|
class TBankPaymentNotificationProcessingError(AggregatorServiceError):
|
|
"""Raised when a TBank payment notification cannot be processed."""
|
|
|
|
|
|
class PriceCacheProtocol(Protocol):
|
|
async def get(self, key: str) -> object | None: ...
|
|
|
|
async def set(self, key: str, value: object, ttl: int | None = None) -> None: ...
|
|
|
|
|
|
class PaymentAdapterProtocol(Protocol):
|
|
async def create_payment_link(self, order_uuid: str, amount_kopecks: int) -> str: ...
|
|
|
|
def verify_payment_notification(
|
|
self,
|
|
notification: TBankPaymentNotification,
|
|
) -> None: ...
|
|
|
|
|
|
class PaymentPriceValidationAdapterProtocol(Protocol):
|
|
async def get_payment_price(
|
|
self,
|
|
request: InitPaymentRequest,
|
|
) -> DeliveryPrice | None: ...
|
|
|
|
|
|
class OrderRegistrationAdapterProtocol(Protocol):
|
|
async def register_order(
|
|
self, request: InitPaymentRequest, order_uuid: str
|
|
) -> object: ...
|
|
|
|
|
|
class OrderRepositoryProtocol(Protocol):
|
|
def session(self) -> AbstractAsyncContextManager[object]: ...
|
|
|
|
async def create_order(self, session: object, order_data: OrderData) -> object: ...
|
|
|
|
async def get_order_by_order_uuid(
|
|
self,
|
|
session: object,
|
|
order_uuid: str,
|
|
) -> object | None: ...
|
|
|
|
async def mark_payment_status(
|
|
self,
|
|
session: object,
|
|
order_uuid: str,
|
|
status: str,
|
|
payment_id: int,
|
|
) -> object | None: ...
|
|
|
|
async def mark_provider_order_registered(
|
|
self,
|
|
session: object,
|
|
order_uuid: str,
|
|
provider_order_id: str,
|
|
) -> object | None: ...
|
|
|
|
|
|
class EmailSenderProtocol(Protocol):
|
|
async def send_email(
|
|
self,
|
|
*,
|
|
to: str,
|
|
subject: str,
|
|
body: str,
|
|
) -> None: ...
|
|
|
|
|
|
class FilterAndSortPricesFn(Protocol):
|
|
def __call__(
|
|
self,
|
|
prices: Iterable[object],
|
|
*,
|
|
price_multiplier: Decimal = DEFAULT_PROVIDER_PRICE_MULTIPLIER,
|
|
parcel_type: object | None = None,
|
|
) -> list[object]: ...
|
|
|
|
|
|
class AggregatorService:
|
|
def __init__(
|
|
self,
|
|
providers: Sequence[DeliveryProvider],
|
|
cache: PriceCacheProtocol | None = None,
|
|
payment_adapter: PaymentAdapterProtocol | None = None,
|
|
payment_price_validation_adapters: (
|
|
Mapping[str, PaymentPriceValidationAdapterProtocol] | None
|
|
) = None,
|
|
order_repository: OrderRepositoryProtocol | None = None,
|
|
order_registration_adapters: (
|
|
Mapping[str, OrderRegistrationAdapterProtocol] | None
|
|
) = None,
|
|
email_sender: EmailSenderProtocol | 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,
|
|
filter_and_sort_prices_fn: FilterAndSortPricesFn = filter_and_sort_prices,
|
|
order_uuid_factory: Callable[[], str] = lambda: str(uuid4()),
|
|
) -> None:
|
|
self._providers = tuple(providers)
|
|
self._cache = cache
|
|
self._payment_adapter = payment_adapter
|
|
self._payment_price_validation_adapters = dict(
|
|
payment_price_validation_adapters or {}
|
|
)
|
|
self._order_repository = order_repository
|
|
self._order_registration_adapters = dict(order_registration_adapters or {})
|
|
self._email_sender = email_sender
|
|
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._order_uuid_factory = order_uuid_factory
|
|
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
|
|
) -> list[DeliveryPrice]:
|
|
normalized_request = normalize_delivery_request(
|
|
request, weight_round_scale=self._weight_round_scale
|
|
)
|
|
provider_request = self._to_provider_request(normalized_request)
|
|
|
|
provider_results = await asyncio.gather(
|
|
*(
|
|
self._get_provider_prices(
|
|
provider=provider,
|
|
request=provider_request,
|
|
cache_key=self._build_cache_key(
|
|
provider_name=provider.name,
|
|
request=normalized_request,
|
|
),
|
|
)
|
|
for provider in self._providers
|
|
),
|
|
return_exceptions=True,
|
|
)
|
|
|
|
successful_results = [
|
|
price
|
|
for provider_prices in provider_results
|
|
if isinstance(provider_prices, list)
|
|
for price in provider_prices
|
|
]
|
|
provider_errors = [
|
|
error
|
|
for error in provider_results
|
|
if isinstance(error, Exception)
|
|
]
|
|
if (
|
|
not successful_results
|
|
and provider_errors
|
|
and any(isinstance(error, ProviderRequestError) for error in provider_errors)
|
|
):
|
|
raise InvalidDeliveryRequestError(
|
|
"Delivery request is invalid for configured providers."
|
|
)
|
|
filtered_and_sorted = self._filter_and_sort_prices(
|
|
successful_results,
|
|
price_multiplier=self._provider_price_multiplier,
|
|
parcel_type=request.parcel_type,
|
|
)
|
|
return [self._coerce_delivery_price(price) for price in filtered_and_sorted]
|
|
|
|
async def suggest_addresses(
|
|
self, request: SuggestAddressRequest
|
|
) -> list[AddressSuggestion]:
|
|
provider_request = self._build_address_suggest_request(request)
|
|
provider = self._resolve_address_suggestion_provider(
|
|
provider_request.country_code
|
|
)
|
|
|
|
try:
|
|
suggestions = await provider.suggest(provider_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 init_payment(self, request: InitPaymentRequest) -> InitPaymentResponse:
|
|
if self._payment_adapter is None:
|
|
raise InitPaymentUnavailableError("Payment adapter is not configured.")
|
|
|
|
order_uuid = self._order_uuid_factory()
|
|
|
|
await self._validate_init_payment_price(request, order_uuid)
|
|
|
|
try:
|
|
payment_url = await self._payment_adapter.create_payment_link(
|
|
order_uuid=order_uuid,
|
|
amount_kopecks=request.system_data.tariff.price,
|
|
)
|
|
except TBankPaymentRequestError as exc:
|
|
logger.exception(
|
|
"payment_init_rejected",
|
|
order_uuid=order_uuid,
|
|
provider_status_code=exc.status_code,
|
|
provider_error_code=exc.error_code,
|
|
provider_error_message=exc.provider_message,
|
|
provider_error_details=exc.details,
|
|
)
|
|
raise InvalidInitPaymentRequestError(
|
|
"Payment init request is invalid for the configured provider."
|
|
) from exc
|
|
except TBankPaymentAdapterError as exc:
|
|
raise InitPaymentUnavailableError(
|
|
"Payment initialization is temporarily unavailable."
|
|
) from exc
|
|
except Exception as exc:
|
|
raise InitPaymentUnavailableError(
|
|
"Payment initialization is temporarily unavailable."
|
|
) from exc
|
|
|
|
await self._persist_order(
|
|
request=request, order_uuid=order_uuid, payment_url=payment_url
|
|
)
|
|
return InitPaymentResponse(payment_url=payment_url)
|
|
|
|
async def _validate_init_payment_price(
|
|
self,
|
|
request: InitPaymentRequest,
|
|
order_uuid: str,
|
|
) -> None:
|
|
provider = request.system_data.tariff.provider
|
|
validation_adapter = self._payment_price_validation_adapters.get(provider)
|
|
if validation_adapter is None:
|
|
logger.warning(
|
|
"init_payment_price_validation_provider_not_configured",
|
|
order_uuid=order_uuid,
|
|
provider=provider,
|
|
)
|
|
raise InvalidInitPaymentRequestError(
|
|
"Payment price validation is not configured for the tariff provider."
|
|
)
|
|
|
|
tariff_code = request.system_data.tariff.tariff_code
|
|
requested_price = request.system_data.tariff.price
|
|
try:
|
|
provider_price = await validation_adapter.get_payment_price(request)
|
|
except ProviderRequestError as exc:
|
|
logger.warning(
|
|
"init_payment_price_validation_request_rejected",
|
|
order_uuid=order_uuid,
|
|
tariff_code=tariff_code,
|
|
requested_price_kopecks=requested_price,
|
|
error=str(exc),
|
|
)
|
|
raise InvalidInitPaymentRequestError(
|
|
"Payment init request is invalid for provider price validation."
|
|
) from exc
|
|
except ProviderClientError as exc:
|
|
logger.warning(
|
|
"init_payment_price_validation_unavailable",
|
|
order_uuid=order_uuid,
|
|
tariff_code=tariff_code,
|
|
requested_price_kopecks=requested_price,
|
|
error=str(exc),
|
|
)
|
|
raise InitPaymentUnavailableError(
|
|
"Payment price validation is temporarily unavailable."
|
|
) from exc
|
|
except Exception as exc:
|
|
logger.exception(
|
|
"init_payment_price_validation_unexpected_error",
|
|
order_uuid=order_uuid,
|
|
tariff_code=tariff_code,
|
|
requested_price_kopecks=requested_price,
|
|
)
|
|
raise InitPaymentUnavailableError(
|
|
"Payment price validation is temporarily unavailable."
|
|
) from exc
|
|
|
|
if provider_price is None:
|
|
logger.warning(
|
|
"init_payment_price_validation_tariff_not_found",
|
|
order_uuid=order_uuid,
|
|
tariff_code=tariff_code,
|
|
requested_price_kopecks=requested_price,
|
|
)
|
|
raise InvalidInitPaymentRequestError(
|
|
"Provider did not return the requested tariff for payment validation."
|
|
)
|
|
|
|
expected_amount_kopecks = calculate_expected_payment_amount_kopecks(
|
|
provider_price,
|
|
price_multiplier=self._provider_price_multiplier,
|
|
)
|
|
if not is_init_payment_price_valid(
|
|
requested_price,
|
|
provider_price,
|
|
price_multiplier=self._provider_price_multiplier,
|
|
):
|
|
logger.warning(
|
|
"init_payment_price_mismatch",
|
|
order_uuid=order_uuid,
|
|
tariff_code=tariff_code,
|
|
requested_price_kopecks=requested_price,
|
|
expected_price_kopecks=expected_amount_kopecks,
|
|
provider_currency=getattr(provider_price, "currency", None),
|
|
provider_price=str(getattr(provider_price, "price", None)),
|
|
)
|
|
raise InvalidInitPaymentRequestError(
|
|
"Payment amount does not match provider validated delivery price."
|
|
)
|
|
|
|
async def handle_tbank_payment_notification(
|
|
self,
|
|
notification: TBankPaymentNotification,
|
|
) -> str:
|
|
if self._payment_adapter is None:
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Payment adapter is not configured."
|
|
)
|
|
|
|
try:
|
|
self._payment_adapter.verify_payment_notification(notification)
|
|
except TBankPaymentNotificationTokenError as exc:
|
|
logger.warning(
|
|
"tbank_notification_token_invalid",
|
|
order_id=notification.OrderId,
|
|
)
|
|
raise InvalidTBankPaymentNotificationError(
|
|
"TBank payment notification token is invalid."
|
|
) from exc
|
|
except TBankPaymentAdapterError as exc:
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"TBank payment notification verification failed."
|
|
) from exc
|
|
|
|
action = resolve_tbank_payment_notification_action(
|
|
status=notification.Status,
|
|
success=notification.Success,
|
|
error_code=notification.ErrorCode,
|
|
)
|
|
logger.info(
|
|
"tbank_notification_action_resolved",
|
|
order_id=notification.OrderId,
|
|
status=notification.Status,
|
|
action=action.name,
|
|
)
|
|
order = await self._load_order_and_mark_payment_status(notification)
|
|
|
|
if action is TBankPaymentNotificationAction.ACKNOWLEDGE_ONLY:
|
|
return "OK"
|
|
|
|
provider = self._resolve_order_provider(order)
|
|
if self._has_existing_registration(order, provider):
|
|
logger.info(
|
|
"tbank_notification_registration_skipped_duplicate",
|
|
order_id=notification.OrderId,
|
|
provider=provider,
|
|
)
|
|
return "OK"
|
|
|
|
registration_result = await self._register_provider_order(
|
|
order, order_uuid=notification.OrderId, provider=provider
|
|
)
|
|
await self._save_order_registration(
|
|
order_uuid=notification.OrderId,
|
|
provider=provider,
|
|
result=registration_result,
|
|
)
|
|
logger.info(
|
|
"tbank_notification_order_registered",
|
|
order_id=notification.OrderId,
|
|
provider=provider,
|
|
)
|
|
await self._send_payment_confirmation_email(
|
|
order, order_uuid=notification.OrderId
|
|
)
|
|
return "OK"
|
|
|
|
async def _send_payment_confirmation_email(
|
|
self,
|
|
order: object,
|
|
*,
|
|
order_uuid: str,
|
|
) -> None:
|
|
if self._email_sender is None or self._order_repository is None:
|
|
return
|
|
|
|
if getattr(order, "payment_email_sent_at", None) is not None:
|
|
return
|
|
|
|
account_email = getattr(order, "account_email", None)
|
|
if account_email is None:
|
|
return
|
|
|
|
try:
|
|
await self._email_sender.send_email(
|
|
to=account_email,
|
|
subject=f"Оплата по заказу {order_uuid} принята",
|
|
body=(
|
|
f"Здравствуйте!\n\n"
|
|
f"Оплата по заказу {order_uuid} успешно принята.\n"
|
|
f"Накладная будет отправлена на этот адрес в ближайшее время.\n\n"
|
|
f"Спасибо за заказ!"
|
|
),
|
|
)
|
|
async with self._order_repository.session() as session:
|
|
await self._order_repository.record_payment_email_sent(
|
|
session,
|
|
order_uuid=order_uuid,
|
|
sent_at=datetime.now(timezone.utc),
|
|
)
|
|
logger.info(
|
|
"payment_confirmation_email_sent",
|
|
order_uuid=order_uuid,
|
|
account_email=account_email,
|
|
)
|
|
except Exception:
|
|
logger.warning(
|
|
"payment_confirmation_email_failed",
|
|
order_uuid=order_uuid,
|
|
account_email=account_email,
|
|
exc_info=True,
|
|
)
|
|
|
|
async def _load_order_and_mark_payment_status(
|
|
self,
|
|
notification: TBankPaymentNotification,
|
|
) -> object:
|
|
if self._order_repository is None:
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order repository is not configured."
|
|
)
|
|
|
|
try:
|
|
async with self._order_repository.session() as session:
|
|
# FOR UPDATE: сериализуем конкурентные уведомления по одному заказу,
|
|
# чтобы внеочередной статус не затирал уже записанный (lost update).
|
|
order = await self._order_repository.get_order_by_order_uuid(
|
|
session,
|
|
notification.OrderId,
|
|
for_update=True,
|
|
)
|
|
if order is None:
|
|
logger.warning(
|
|
"tbank_payment_notification_order_not_found",
|
|
order_uuid=notification.OrderId,
|
|
)
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order was not found for TBank payment notification."
|
|
)
|
|
if should_apply_tbank_payment_status(
|
|
order.payment_status, notification.Status
|
|
):
|
|
await self._order_repository.mark_payment_status(
|
|
session,
|
|
notification.OrderId,
|
|
notification.Status,
|
|
notification.PaymentId,
|
|
)
|
|
else:
|
|
logger.info(
|
|
"tbank_payment_status_downgrade_skipped",
|
|
order_uuid=notification.OrderId,
|
|
current_status=order.payment_status,
|
|
incoming_status=notification.Status,
|
|
)
|
|
return order
|
|
except TBankPaymentNotificationProcessingError:
|
|
raise
|
|
except Exception as exc:
|
|
logger.exception(
|
|
"tbank_payment_notification_order_update_failed",
|
|
order_uuid=notification.OrderId,
|
|
payment_status=notification.Status,
|
|
tbank_payment_id=notification.PaymentId,
|
|
)
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"TBank payment notification order update failed."
|
|
) from exc
|
|
|
|
@staticmethod
|
|
def _resolve_order_provider(order: object) -> str:
|
|
provider = getattr(order, "provider", None)
|
|
if isinstance(provider, str) and provider:
|
|
return provider
|
|
request = AggregatorService._to_init_payment_request_from_order(order)
|
|
return request.system_data.tariff.provider
|
|
|
|
@staticmethod
|
|
def _has_existing_registration(order: object, provider: str) -> bool:
|
|
return bool(getattr(order, "provider_order_id", None))
|
|
|
|
@staticmethod
|
|
def _extract_registration_id(result: object) -> str:
|
|
for attr in ("order_uuid", "order_number"):
|
|
value = getattr(result, attr, None)
|
|
if isinstance(value, str) and value:
|
|
return value
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order registration result is missing an identifier."
|
|
)
|
|
|
|
async def _register_provider_order(
|
|
self, order: object, *, order_uuid: str, provider: str
|
|
) -> object:
|
|
registration_adapter = self._order_registration_adapters.get(provider)
|
|
if registration_adapter is None:
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order registration adapter is not configured for the provider."
|
|
)
|
|
|
|
try:
|
|
request = self._to_init_payment_request_from_order(order)
|
|
return await registration_adapter.register_order(request, order_uuid)
|
|
except Exception as exc:
|
|
logger.exception(
|
|
"provider_order_registration_failed",
|
|
provider=provider,
|
|
order_uuid=getattr(order, "order_uuid", None),
|
|
)
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Provider order registration failed."
|
|
) from exc
|
|
|
|
async def _save_order_registration(
|
|
self,
|
|
*,
|
|
order_uuid: str,
|
|
provider: str,
|
|
result: object,
|
|
) -> None:
|
|
if self._order_repository is None:
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order repository is not configured."
|
|
)
|
|
|
|
registration_id = self._extract_registration_id(result)
|
|
try:
|
|
async with self._order_repository.session() as session:
|
|
order = await self._order_repository.mark_provider_order_registered(
|
|
session,
|
|
order_uuid,
|
|
registration_id,
|
|
)
|
|
if order is None:
|
|
logger.warning(
|
|
"order_registration_order_not_found",
|
|
provider=provider,
|
|
order_uuid=order_uuid,
|
|
registration_id=registration_id,
|
|
)
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order was not found while saving registration identifier."
|
|
)
|
|
except TBankPaymentNotificationProcessingError:
|
|
raise
|
|
except Exception as exc:
|
|
logger.exception(
|
|
"order_registration_persistence_failed",
|
|
provider=provider,
|
|
order_uuid=order_uuid,
|
|
registration_id=registration_id,
|
|
)
|
|
raise TBankPaymentNotificationProcessingError(
|
|
"Order registration persistence failed."
|
|
) from exc
|
|
|
|
async def _persist_order(
|
|
self,
|
|
*,
|
|
request: InitPaymentRequest,
|
|
order_uuid: str,
|
|
payment_url: str,
|
|
) -> None:
|
|
if self._order_repository is None:
|
|
return
|
|
|
|
try:
|
|
async with self._order_repository.session() as session:
|
|
await self._order_repository.create_order(
|
|
session,
|
|
self._to_order_data(
|
|
request=request,
|
|
order_uuid=order_uuid,
|
|
payment_url=payment_url,
|
|
),
|
|
)
|
|
except Exception:
|
|
logger.exception(
|
|
"order_persistence_failed",
|
|
order_uuid=order_uuid,
|
|
)
|
|
|
|
@staticmethod
|
|
def _to_order_data(
|
|
*,
|
|
request: InitPaymentRequest,
|
|
order_uuid: str,
|
|
payment_url: str,
|
|
) -> OrderData:
|
|
return OrderData(
|
|
order_uuid=order_uuid,
|
|
payment_url=payment_url,
|
|
price=request.system_data.tariff.price,
|
|
tariff_code=request.system_data.tariff.tariff_code,
|
|
provider=request.system_data.tariff.provider,
|
|
account_email=request.account_email,
|
|
payload=request.model_dump(mode="json", by_alias=True),
|
|
)
|
|
|
|
@staticmethod
|
|
def _to_init_payment_request_from_order(order: object) -> InitPaymentRequest:
|
|
payload = getattr(order, "payload")
|
|
return InitPaymentRequest.model_validate(payload)
|
|
|
|
async def _get_provider_prices(
|
|
self,
|
|
*,
|
|
provider: DeliveryProvider,
|
|
request: DeliveryCalculationRequest,
|
|
cache_key: str,
|
|
) -> list[DeliveryPrice]:
|
|
cached_prices = await self._get_cached_prices(cache_key)
|
|
if cached_prices is not None:
|
|
return cached_prices
|
|
|
|
fresh_prices = await provider.get_prices(request)
|
|
await self._set_cached_prices(
|
|
cache_key,
|
|
fresh_prices,
|
|
ttl=getattr(provider, "cache_ttl_seconds", None),
|
|
)
|
|
return fresh_prices
|
|
|
|
async def _get_cached_prices(self, cache_key: str) -> list[DeliveryPrice] | None:
|
|
if self._cache is None:
|
|
return None
|
|
try:
|
|
payload = await self._cache.get(cache_key)
|
|
except Exception:
|
|
return None
|
|
if payload is None:
|
|
return None
|
|
try:
|
|
return self._coerce_delivery_prices(payload)
|
|
except Exception:
|
|
return None
|
|
|
|
async def _set_cached_prices(
|
|
self,
|
|
cache_key: str,
|
|
payload: list[DeliveryPrice],
|
|
*,
|
|
ttl: int | None,
|
|
) -> None:
|
|
if self._cache is None:
|
|
return
|
|
try:
|
|
await self._cache.set(cache_key, payload, ttl=ttl)
|
|
except Exception:
|
|
return
|
|
|
|
@staticmethod
|
|
def _to_provider_request(
|
|
request: NormalizedDeliveryRequest,
|
|
) -> DeliveryCalculationRequest:
|
|
return DeliveryCalculationRequest(
|
|
entity=request.entity,
|
|
from_city=request.from_city,
|
|
to_city=request.to_city,
|
|
weight_kg=request.weight_kg,
|
|
length_cm=request.length_cm,
|
|
width_cm=request.width_cm,
|
|
height_cm=request.height_cm,
|
|
)
|
|
|
|
@staticmethod
|
|
def _build_cache_key(provider_name: str, request: NormalizedDeliveryRequest) -> str:
|
|
cache_payload = {
|
|
"provider": provider_name,
|
|
"entity": request.entity,
|
|
"from_city": request.from_city,
|
|
"to_city": request.to_city,
|
|
"weight_kg": str(request.weight_kg),
|
|
"length_cm": str(request.length_cm),
|
|
"width_cm": str(request.width_cm),
|
|
"height_cm": str(request.height_cm),
|
|
}
|
|
serialized_payload = json.dumps(
|
|
cache_payload,
|
|
ensure_ascii=True,
|
|
sort_keys=True,
|
|
separators=(",", ":"),
|
|
)
|
|
cache_hash = hashlib.sha256(serialized_payload.encode("utf-8")).hexdigest()
|
|
return f"delivery-price:{provider_name}:{cache_hash}"
|
|
|
|
@staticmethod
|
|
def _coerce_delivery_price(value: object) -> DeliveryPrice:
|
|
return DeliveryPrice.model_validate(value, from_attributes=True)
|
|
|
|
@classmethod
|
|
def _coerce_delivery_prices(cls, value: object) -> list[DeliveryPrice]:
|
|
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)
|
|
|
|
@staticmethod
|
|
def _build_address_suggest_request(
|
|
request: SuggestAddressRequest,
|
|
) -> AddressSuggestRequest:
|
|
city_entry = cities_map.get(request.city)
|
|
if not isinstance(city_entry, dict):
|
|
raise InvalidAddressSuggestRequestError(
|
|
f"City is not configured for id {request.city}."
|
|
)
|
|
|
|
city_name = city_entry.get("city")
|
|
country_code = city_entry.get("country")
|
|
if not isinstance(city_name, str) or not isinstance(country_code, str):
|
|
raise InvalidAddressSuggestRequestError(
|
|
f"City mapping is invalid for id {request.city}."
|
|
)
|
|
|
|
return AddressSuggestRequest(
|
|
country_code=country_code,
|
|
city=city_name,
|
|
query=request.query,
|
|
limit=request.limit,
|
|
)
|
|
|
|
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
|