feat: add payment module

Author: adiffpirate

Makefile

@@ -1,7 +1,8 @@
-.PHONY: help run stop test test-unit test-integration clean migrations
+.PHONY: help build run stop test test-unit test-integration clean migrations
 
 help:
 	@echo "Available commands:"
+	@echo "  build            - Build the docker images"
 	@echo "  run              - Run the application (development with auto-reload, debug mode)"
 	@echo "  stop             - Stop the application"
 	@echo "  test             - Run all tests"
@@ -10,8 +11,11 @@ help:
 	@echo "  clean            - Clean up Docker containers and volumes"
 	@echo "  migrations msg   - Generate alembic migration via Docker (e.g. make migrations msg='add cancelled status')"
 
+build:
+	docker compose build
+
 run:
-	docker compose up --build -d
+	docker compose up -d
 	@echo "Application running at http://localhost:8000"
 	@echo "Swagger UI is available at http://localhost:8000/docs"
 
@@ -25,8 +29,7 @@ test:
 
 test-unit:
 	@echo "Running unit tests..."
-	docker build -t python-fastapi-example-oms-app:latest .
-	docker run --rm --tty -e AUTH_JWT_SECRET_KEY=docker-unit-tests-key python-fastapi-example-oms-app:latest python -m pytest tests/unit/ -v
+	docker run --rm --tty -e AUTH_JWT_SECRET_KEY=docker-unit-tests-key python-fastapi-example-oms-app:dev python -m pytest tests/unit/ -v
 
 test-integration:
 	$(MAKE) clean

alembic/versions/6e6b7e4f8a18_add_invoices_table.py

@@ -0,0 +1,35 @@
+"""add invoices table
+
+Revision ID: 6e6b7e4f8a18
+Revises: 814107d68bb6
+Create Date: 2026-04-30 03:03:29.938373
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '6e6b7e4f8a18'
+down_revision: Union[str, Sequence[str], None] = '814107d68bb6'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.create_table(
+        'invoices',
+        sa.Column('id', sa.Integer(), primary_key=True, index=True),
+        sa.Column('order_id', sa.Integer(), sa.ForeignKey('orders.id'), nullable=False, index=True),
+        sa.Column('status', sa.Enum('PENDING', 'PAID', 'CANCELLED', name='invoicestatus'), nullable=False, default='PENDING'),
+        sa.Column('external_invoice_id', sa.String(), nullable=True, index=True),
+        sa.Column('created_at', sa.DateTime(), server_default=sa.func.now()),
+    )
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    op.drop_table('invoices')

alembic/versions/a1b2c3d4e5f6_add_unique_constraint_on_invoices_order_id.py

@@ -0,0 +1,28 @@
+"""add unique constraint on invoices.order_id
+
+Revision ID: a1b2c3d4e5f6
+Revises: 6e6b7e4f8a18
+Create Date: 2026-04-30 12:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'a1b2c3d4e5f6'
+down_revision: Union[str, Sequence[str], None] = '6e6b7e4f8a18'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.create_unique_constraint('uq_invoices_order_id', 'invoices', ['order_id'])
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    op.drop_constraint('uq_invoices_order_id', 'invoices', type_='unique')

alembic/versions/b2c3d4e5f6a7_add_user_id_to_orders.py

@@ -0,0 +1,32 @@
+"""add user_id to orders
+
+Revision ID: b2c3d4e5f6a7
+Revises: a1b2c3d4e5f6
+Create Date: 2026-04-30 12:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'b2c3d4e5f6a7'
+down_revision: Union[str, Sequence[str], None] = 'a1b2c3d4e5f6'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.add_column('orders', sa.Column('user_id', sa.Integer(), nullable=False, server_default='1'))
+    op.create_foreign_key('fk_orders_user_id', 'orders', 'users', ['user_id'], ['id'])
+    op.create_index(op.f('ix_orders_user_id'), 'orders', ['user_id'], unique=False)
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    op.drop_index(op.f('ix_orders_user_id'), table_name='orders')
+    op.drop_constraint('fk_orders_user_id', 'orders', type_='foreignkey')
+    op.drop_column('orders', 'user_id')

app/api/router.py

@@ -1,8 +1,10 @@
 from fastapi import APIRouter
 from app.modules.orders.routes import router as orders_router
 from app.modules.users.routes import router as users_router
+from app.modules.payment.routes import router as payment_router
 
 api_router = APIRouter()
 
 api_router.include_router(orders_router, prefix="/orders", tags=["orders"])
 api_router.include_router(users_router, prefix="/users", tags=["users"])
+api_router.include_router(payment_router, prefix="/payment", tags=["payment"])

app/modules/orders/models.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, Enum
+from sqlalchemy import Column, Integer, String, ForeignKey, Enum
 from app.db.session import Base
 import enum
 
@@ -16,5 +16,6 @@ class Order(Base):
     __tablename__ = "orders"
 
     id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False, index=True)
     item = Column(String, nullable=False)
     status = Column(Enum(OrderStatus), default=OrderStatus.RECEIVED)

app/modules/orders/repository.py

@@ -6,8 +6,8 @@ class OrderRepository:
     def __init__(self, db: Session):
         self._db = db
 
-    def create_order(self, item: str):
-        order = models.Order(item=item)
+    def create_order(self, user_id: int, item: str):
+        order = models.Order(user_id=user_id, item=item)
         self._db.add(order)
         self._db.commit()
         self._db.refresh(order)
@@ -16,8 +16,18 @@ def create_order(self, item: str):
     def get_order(self, order_id: int):
         return self._db.query(models.Order).filter(models.Order.id == order_id).first()
 
-    def list_orders(self):
-        return self._db.query(models.Order).all()
+    def list_orders(self, user_id: int | None = None, status: str | None = None, search: str | None = None, page: int = 1, page_size: int = 20):
+        query = self._db.query(models.Order)
+        if user_id is not None:
+            query = query.filter(models.Order.user_id == user_id)
+        if status is not None:
+            query = query.filter(models.Order.status == status)
+        if search is not None:
+            query = query.filter(models.Order.item.ilike(f"%{search}%"))
+        total = query.count()
+        offset = (page - 1) * page_size
+        items = query.order_by(models.Order.id).offset(offset).limit(page_size).all()
+        return items, total
 
     def update_order(self, order_id: int, **kwargs):
         order = self._db.query(models.Order).filter(models.Order.id == order_id).first()

app/modules/orders/routes.py

@@ -5,6 +5,10 @@
 from . import service, schemas, repository
 from .service import InvalidOrderTransition
 from app.core.auth import get_current_user
+from app.modules.payment import service as payment_service
+from app.modules.payment import repository as payment_repo
+from app.modules.payment.service import PaymentError
+from app.modules.users import repository as user_repo
 
 router = APIRouter()
 
@@ -13,57 +17,136 @@ def get_orders_repository(db: Session = Depends(get_db)):
     return repository.OrderRepository(db)
 
 
+def get_payment_repository(db: Session = Depends(get_db)):
+    return payment_repo.InvoiceRepository(db)
+
+
+def get_user_repository(db: Session = Depends(get_db)):
+    return user_repo.UserRepository(db)
+
+
 @router.post("/", response_model=schemas.OrderRead)
 def create_order(
     payload: schemas.OrderCreate,
     repo: repository.OrderRepository = Depends(get_orders_repository),
-    _user: str = Depends(get_current_user),
+    user_repo: user_repo.UserRepository = Depends(get_user_repository),
+    username: str = Depends(get_current_user),
 ):
-    return service.create_order(repo, payload.item)
+    user = user_repo.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return service.create_order(repo, user.id, payload.item)
 
 
 @router.get("/{order_id}", response_model=schemas.OrderRead)
 def get_order(
     order_id: int,
     repo: repository.OrderRepository = Depends(get_orders_repository),
-    _user: str = Depends(get_current_user),
+    user_repo: user_repo.UserRepository = Depends(get_user_repository),
+    username: str = Depends(get_current_user),
 ):
-    try:
-        return service.get_order(repo, order_id)
-    except ValueError:
+    order = repo.get_order(order_id)
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    user = user_repo.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if order.user_id != user.id:
         raise HTTPException(status_code=404, detail="Order not found")
+    return order
 
 
-@router.get("/", response_model=list[schemas.OrderRead])
+@router.get("/", response_model=schemas.PaginatedOrders)
 def list_orders(
+    page: int = 1,
+    page_size: int = 20,
+    status: str | None = None,
+    search: str | None = None,
     repo: repository.OrderRepository = Depends(get_orders_repository),
-    _user: str = Depends(get_current_user),
+    user_repo: user_repo.UserRepository = Depends(get_user_repository),
+    username: str = Depends(get_current_user),
 ):
-    return service.list_orders(repo)
+    user = user_repo.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    items, total = service.list_orders(repo, user_id=user.id, status=status, search=search, page=page, page_size=page_size)
+    return {"items": items, "total": total, "page": page, "page_size": page_size}
 
 
 @router.put("/{order_id}", response_model=schemas.OrderRead)
 def update_order(
     order_id: int,
     payload: schemas.OrderUpdate,
     repo: repository.OrderRepository = Depends(get_orders_repository),
-    _user: str = Depends(get_current_user),
+    user_repo: user_repo.UserRepository = Depends(get_user_repository),
+    username: str = Depends(get_current_user),
 ):
+    order = repo.get_order(order_id)
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    user = user_repo.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if order.user_id != user.id:
+        raise HTTPException(status_code=404, detail="Order not found")
     try:
         updates = {k: v for k, v in payload.model_dump(exclude_unset=True).items()}
         return service.update_order(repo, order_id, **updates)
-    except ValueError:
-        raise HTTPException(status_code=404, detail="Order not found")
     except InvalidOrderTransition as e:
         raise HTTPException(status_code=400, detail=str(e))
 
 
+@router.post("/{order_id}/cancel", response_model=schemas.OrderRead)
+def cancel_order(
+    order_id: int,
+    repo: repository.OrderRepository = Depends(get_orders_repository),
+    user_repo: user_repo.UserRepository = Depends(get_user_repository),
+    payment_repo: payment_repo.InvoiceRepository = Depends(get_payment_repository),
+    username: str = Depends(get_current_user),
+):
+    order = repo.get_order(order_id)
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    user = user_repo.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if order.user_id != user.id:
+        raise HTTPException(status_code=404, detail="Order not found")
+    try:
+        order = service.cancel_order(repo, order_id)
+    except ValueError as e:
+        detail = str(e)
+        if "not found" in detail:
+            raise HTTPException(status_code=404, detail=detail)
+        if "already cancelled" in detail:
+            raise HTTPException(status_code=400, detail=detail)
+        if "Cannot cancel" in detail:
+            raise HTTPException(status_code=400, detail=detail)
+        raise HTTPException(status_code=400, detail=detail)
+
+    try:
+        payment_service.cancel_invoice_by_order_id(payment_repo, order_id)
+    except PaymentError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    return order
+
+
 @router.delete("/{order_id}", status_code=204)
 def delete_order(
     order_id: int,
     repo: repository.OrderRepository = Depends(get_orders_repository),
-    _user: str = Depends(get_current_user),
+    user_repo: user_repo.UserRepository = Depends(get_user_repository),
+    username: str = Depends(get_current_user),
 ):
+    order = repo.get_order(order_id)
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    user = user_repo.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if order.user_id != user.id:
+        raise HTTPException(status_code=404, detail="Order not found")
     try:
         service.delete_order(repo, order_id)
     except ValueError:

app/modules/orders/schemas.py

@@ -14,7 +14,15 @@ class OrderUpdate(BaseModel):
 
 class OrderRead(BaseModel):
     id: int
+    user_id: int
     item: str
     status: OrderStatus
 
     model_config = ConfigDict(from_attributes=True)
+
+
+class PaginatedOrders(BaseModel):
+    items: list[OrderRead]
+    total: int
+    page: int
+    page_size: int