Добавлено сохранение заказов в postgres

app/repositories/order/__init__.py

@@ -0,0 +1,5 @@
+"""Order repository exports."""
+
+from app.repositories.order.repository import OrderData, OrderRepository
+
+__all__ = ("OrderData", "OrderRepository")

app/repositories/order/models.py

@@ -0,0 +1,63 @@
+"""SQLAlchemy models for order persistence."""
+
+from datetime import datetime
+from typing import Any
+from uuid import UUID, uuid4
+
+from sqlalchemy import DateTime, Integer, String, UniqueConstraint, Uuid, func
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from sqlalchemy.types import JSON
+
+
+def _json_payload_type() -> JSON:
+    return JSON().with_variant(JSONB, "postgresql")
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Order(Base):
+    __tablename__ = "orders"
+    __table_args__ = (
+        UniqueConstraint("order_uuid", name="uq_orders_order_uuid"),
+    )
+
+    id: Mapped[UUID] = mapped_column(
+        Uuid(as_uuid=True),
+        primary_key=True,
+        default=uuid4,
+    )
+    order_uuid: Mapped[str] = mapped_column(String(128), nullable=False)
+    payment_url: Mapped[str] = mapped_column(String(2048), nullable=False)
+    price: Mapped[int] = mapped_column(Integer, nullable=False)
+    delivery_type: Mapped[int] = mapped_column(Integer, nullable=False)
+    tariff_code: Mapped[int] = mapped_column(Integer, nullable=False)
+    sender: Mapped[dict[str, Any]] = mapped_column(_json_payload_type(), nullable=False)
+    recipient: Mapped[dict[str, Any]] = mapped_column(
+        _json_payload_type(),
+        nullable=False,
+    )
+    from_location: Mapped[dict[str, Any]] = mapped_column(
+        _json_payload_type(),
+        nullable=False,
+    )
+    to_location: Mapped[dict[str, Any]] = mapped_column(
+        _json_payload_type(),
+        nullable=False,
+    )
+    packages: Mapped[list[dict[str, Any]]] = mapped_column(
+        _json_payload_type(),
+        nullable=False,
+    )
+    services: Mapped[list[dict[str, Any]] | None] = mapped_column(
+        _json_payload_type(),
+        nullable=True,
+    )
+    comment: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )

app/repositories/order/repository.py

@@ -0,0 +1,53 @@
+"""PostgreSQL order repository."""
+
+from contextlib import AbstractAsyncContextManager
+from dataclasses import dataclass
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from app.repositories.order.models import Order
+
+
+@dataclass(frozen=True)
+class OrderData:
+    order_uuid: str
+    payment_url: str
+    price: int
+    delivery_type: int
+    tariff_code: int
+    sender: dict[str, Any]
+    recipient: dict[str, Any]
+    from_location: dict[str, Any]
+    to_location: dict[str, Any]
+    packages: list[dict[str, Any]]
+    services: list[dict[str, Any]] | None
+    comment: str | None
+
+
+class OrderRepository:
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._session_factory = session_factory
+
+    def session(self) -> AbstractAsyncContextManager[AsyncSession]:
+        return self._session_factory.begin()
+
+    async def create_order(self, session: AsyncSession, order_data: OrderData) -> Order:
+        order = Order(
+            order_uuid=order_data.order_uuid,
+            payment_url=order_data.payment_url,
+            price=order_data.price,
+            delivery_type=order_data.delivery_type,
+            tariff_code=order_data.tariff_code,
+            sender=order_data.sender,
+            recipient=order_data.recipient,
+            from_location=order_data.from_location,
+            to_location=order_data.to_location,
+            packages=order_data.packages,
+            services=order_data.services,
+            comment=order_data.comment,
+        )
+        session.add(order)
+        await session.flush()
+        await session.refresh(order)
+        return order