Merge pull request #10 from codewithme-py/chore/ddd-isolation-refactoring

chore:Domain-Driven-Design

Author: codewithme-py

app/services/inventory/internal.py

@@ -0,0 +1,68 @@
+from uuid import UUID
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.exceptions import NotFoundError
+from app.services.inventory.models import Product, Reservation
+from app.services.orders.models import OrderStatus
+
+
+async def mark_reservation_as_completed(
+    session: AsyncSession, reservation_id: UUID
+) -> None:
+    res_result = await session.execute(
+        select(Reservation).with_for_update().where(Reservation.id == reservation_id)
+    )
+    reservation = res_result.scalar_one_or_none()
+    if not reservation:
+        raise NotFoundError
+    reservation.status = OrderStatus.COMPLETED
+
+
+async def mark_reservation_by_order_as_completed(
+    session: AsyncSession, order_id: UUID
+) -> None:
+    res_result = await session.execute(
+        select(Reservation).with_for_update().where(Reservation.order_id == order_id)
+    )
+    reservation = res_result.scalar_one_or_none()
+    if not reservation:
+        raise NotFoundError
+    reservation.status = OrderStatus.COMPLETED
+
+
+async def cancel_reservation_and_return_stock(
+    session: AsyncSession, reservation_id: UUID
+) -> None:
+    res_result = await session.execute(
+        select(Reservation).with_for_update().where(Reservation.id == reservation_id)
+    )
+    reservation = res_result.scalar_one_or_none()
+    if not reservation:
+        raise NotFoundError
+    prod_result = await session.execute(
+        select(Product).with_for_update().where(Product.id == reservation.product_id)
+    )
+    product = prod_result.scalar_one_or_none()
+    if product:
+        product.qty_available += reservation.qty_reserved
+    reservation.status = OrderStatus.CANCELLED
+
+
+async def cancel_reservation_by_order_and_return_stock(
+    session: AsyncSession, order_id: UUID
+) -> None:
+    res_result = await session.execute(
+        select(Reservation).with_for_update().where(Reservation.order_id == order_id)
+    )
+    reservation = res_result.scalar_one_or_none()
+    if not reservation:
+        raise NotFoundError
+    prod_result = await session.execute(
+        select(Product).with_for_update().where(Product.id == reservation.product_id)
+    )
+    product = prod_result.scalar_one_or_none()
+    if product:
+        product.qty_available += reservation.qty_reserved
+    reservation.status = OrderStatus.CANCELLED

app/services/inventory/tasks.py

@@ -5,7 +5,8 @@
 
 from app.main import logger
 from app.services.inventory.models import Product, Reservation
-from app.services.orders.models import Order, OrderStatus
+from app.services.orders.internal import cancel_order_by_system
+from app.services.orders.models import OrderStatus
 
 
 async def release_expired_reservations(ctx: dict) -> None:
@@ -38,13 +39,6 @@ async def release_expired_reservations(ctx: dict) -> None:
                 product.qty_available += reservation.qty_reserved
             reservation.status = OrderStatus.EXPIRED
             if reservation.order_id is not None:
-                order_result = await session.execute(
-                    select(Order)
-                    .with_for_update()
-                    .where(Order.id == reservation.order_id)
-                )
-                order = order_result.scalar_one_or_none()
-                if order:
-                    order.status = OrderStatus.CANCELLED
+                await cancel_order_by_system(session, reservation.order_id)
             await session.commit()
             logger.info(f'Released reservation {res_id}')

app/services/orders/internal.py

@@ -0,0 +1,17 @@
+from uuid import UUID
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.exceptions import NotFoundError
+from app.services.orders.models import Order, OrderStatus
+
+
+async def cancel_order_by_system(session: AsyncSession, order_id: UUID) -> None:
+    order_result = await session.execute(
+        select(Order).with_for_update().where(Order.id == order_id)
+    )
+    order = order_result.scalar_one_or_none()
+    if not order:
+        raise NotFoundError
+    order.status = OrderStatus.CANCELLED

app/services/orders/service.py

@@ -5,6 +5,10 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.exceptions import ConflictError, NotFoundError
+from app.services.inventory.internal import (
+    cancel_reservation_by_order_and_return_stock,
+    mark_reservation_by_order_as_completed,
+)
 from app.services.inventory.models import Product, Reservation
 from app.services.orders.models import Order, OrderItem, OrderStatus
 from app.services.orders.schemas import OrderCreate
@@ -89,11 +93,22 @@ async def confirm_order_payment(
     order_id: UUID,
     user_id: UUID,
 ) -> Order:
-    order, reservation = await _get_locked_order_and_reservation(
-        session, order_id, user_id
+    order_result = await session.execute(
+        select(Order)
+        .with_for_update()
+        .where(
+            Order.id == order_id,
+            Order.user_id == user_id,
+        )
     )
+    order = order_result.scalar_one_or_none()
+    if not order:
+        raise NotFoundError
+    if order.status != OrderStatus.PENDING:
+        raise ConflictError
+
     order.status = OrderStatus.PAID
-    reservation.status = OrderStatus.COMPLETED
+    await mark_reservation_by_order_as_completed(session, order_id)
     await session.commit()
     return order
 
@@ -103,16 +118,21 @@ async def cancel_order(
     order_id: UUID,
     user_id: UUID,
 ) -> Order:
-    order, reservation = await _get_locked_order_and_reservation(
-        session, order_id, user_id
-    )
-    product_rollback = await session.execute(
-        select(Product).with_for_update().where(Product.id == reservation.product_id)
+    order_result = await session.execute(
+        select(Order)
+        .with_for_update()
+        .where(
+            Order.id == order_id,
+            Order.user_id == user_id,
+        )
     )
-    product = product_rollback.scalar_one_or_none()
-    if product:
-        product.qty_available += reservation.qty_reserved
+    order = order_result.scalar_one_or_none()
+    if not order:
+        raise NotFoundError
+    if order.status != OrderStatus.PENDING:
+        raise ConflictError
+
     order.status = OrderStatus.CANCELLED
-    reservation.status = OrderStatus.CANCELLED
+    await cancel_reservation_by_order_and_return_stock(session, order_id)
     await session.commit()
     return order