configure settings, add extra models, fix: models, create services, cruds, api endpoints

Author: RustamovAkrom

pyproject.toml

@@ -33,6 +33,7 @@ dependencies = [
     "python-multipart>=0.0.20",
     "ruff>=0.14.7",
     "sentry-sdk>=2.47.0",
+    "stripe>=14.0.1",
     "types-python-jose>=3.5.0.20250531",
     "uvicorn[standard]>=0.38.0",
 ]

src/api/routers.py

@@ -1,12 +1,27 @@
 from fastapi import APIRouter
 
-from api.v1 import admin, auth, brand, category, dashboard, social_auth, users  # noqa
+from api.v1 import (
+    admin,
+    auth,
+    brand,
+    cart,
+    category,
+    dashboard,
+    orders,
+    payments,
+    social_auth,
+    upload,
+    users,
+)
+from api.v1.products import images, products, variants
 from core.config import settings
 
 api_router = APIRouter(
     prefix=f"{settings.API_V1_PREFIX}",
 )
 
+
+api_router.include_router(upload.router, prefix="/Upload", tags=["Upload"])
 api_router.include_router(auth.router, prefix="/auth", tags=["Auth"])
 api_router.include_router(
     social_auth.router, prefix="/social_auth", tags=["Social Auth"]
@@ -16,5 +31,11 @@
 api_router.include_router(admin.router, prefix="/admin", tags=["Admin"])
 api_router.include_router(category.router, prefix="/categories", tags=["Categories"])
 api_router.include_router(brand.router, prefix="/brands", tags=["Brands"])
+api_router.include_router(cart.router, prefix="/carts", tags=["Carts"])
+api_router.include_router(products.router, prefix="/products", tags=["Products"])
+api_router.include_router(variants.router, prefix="/products", tags=["Variants"])
+api_router.include_router(images.router, prefix="/products", tags=["Images"])
+api_router.include_router(orders.router, prefix="/orders", tags=["Orders"])
+api_router.include_router(payments.router, prefix="/payments", tags=["Payments"])
 
 __all__ = ("api_router",)

src/api/v1/brand.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, status
 
 from db.crud.brand import BrandCRUD
 from db.dependencies.auth import ADMIN_ROLE, SELLER_ROLE, require_roles
@@ -7,6 +7,7 @@
     BrandOutScheme,
     BrandUpdateScheme,
 )
+from utils.shortcuts import get_or_404
 
 router = APIRouter(prefix="/brands", tags=["Brands"])
 
@@ -18,11 +19,7 @@ async def get_brands(brands_crud: BrandCRUD = Depends(BrandCRUD)):
 
 @router.get("/{slug}", response_model=BrandOutScheme)
 async def get_brand(slug: str, brands_crud: BrandCRUD = Depends(BrandCRUD)):
-    brand = await brands_crud.get_by_slug(slug)
-    if not brand:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Brand not found"
-        )
+    brand = await get_or_404(brands_crud.get_by_slug(slug), "Brand not found")
     return brand
 
 
@@ -46,11 +43,7 @@ async def create_brand(
 async def update_brand(
     slug: str, data: BrandUpdateScheme, brands_crud: BrandCRUD = Depends(BrandCRUD)
 ):
-    brand = await brands_crud.get_by_slug(slug)
-    if not brand:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Brand not found"
-        )
+    brand = await get_or_404(brands_crud.get_by_slug(slug), "Brand not found")
     return await brands_crud.update(brand, data)
 
 
@@ -60,9 +53,5 @@ async def update_brand(
     dependencies=[Depends(require_roles(ADMIN_ROLE, SELLER_ROLE))],
 )
 async def delete_brand(slug: str, brands_crud: BrandCRUD = Depends(BrandCRUD)):
-    brand = await brands_crud.get_by_slug(slug)
-    if not brand:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Brand not found"
-        )
+    brand = await get_or_404(brands_crud.get_by_slug(slug), "Brand not found")
     await brands_crud.delete(brand)

src/api/v1/cart.py

@@ -0,0 +1,67 @@
+# src/api/endpoints/cart.py
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from db.dependencies.auth import get_current_user  # твоя функция
+from db.dependencies.sessions import get_db_session
+from db.models.users import User
+from schemas.cart import (
+    AddToCartScheme,
+    CartResponse,
+    UpdateQuantityScheme,
+)
+from services.cart_service import CartService
+
+router = APIRouter(prefix="/carts", tags=["Carts"])
+
+
+def get_cart_service(session: AsyncSession = Depends(get_db_session)) -> CartService:
+    return CartService(session)
+
+
+@router.get("/", response_model=CartResponse)
+async def get_cart(
+    current_user: User = Depends(get_current_user),
+    cart_service: CartService = Depends(get_cart_service),
+):
+    cart = await cart_service.get_user_cart(current_user.id)
+    return cart
+
+
+@router.post("/add", response_model=CartResponse)
+async def add_to_cart(
+    data: AddToCartScheme,
+    current_user: User = Depends(get_current_user),
+    cart_service: CartService = Depends(get_cart_service),
+):
+    await cart_service.add_to_cart(current_user.id, data.variant_id, data.quantity)
+    return await cart_service.get_user_cart(current_user.id)
+
+
+@router.post("/update", response_model=CartResponse)
+async def update_quantity(
+    data: UpdateQuantityScheme,
+    current_user: User = Depends(get_current_user),
+    cart_service: CartService = Depends(get_cart_service),
+):
+    await cart_service.update_quantity(current_user.id, data.variant_id, data.quantity)
+    return await cart_service.get_user_cart(current_user.id)
+
+
+@router.delete("/{variant_id}")
+async def remove_item(
+    variant_id: int,
+    current_user: User = Depends(get_current_user),
+    cart_service: CartService = Depends(get_cart_service),
+):
+    await cart_service.remove_from_cart(current_user.id, variant_id)
+    return {"detail": "Item removed"}
+
+
+@router.delete("/", status_code=200)
+async def clear_cart(
+    current_user: User = Depends(get_current_user),
+    cart_service: CartService = Depends(get_cart_service),
+):
+    await cart_service.clear_cart(current_user.id)
+    return {"detail": "Cart cleared"}

src/api/v1/category.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, status
 
 from db.crud.category import CategoryCRUD
 from db.dependencies.auth import ADMIN_ROLE, SELLER_ROLE, require_roles
@@ -7,6 +7,7 @@
     CategoryOutScheme,
     CategoryUpdateScheme,
 )
+from utils.shortcuts import get_or_404
 
 router = APIRouter(prefix="/categories", tags=["Categories"])
 
@@ -20,9 +21,9 @@ async def get_categories(categoryies_crud: CategoryCRUD = Depends(CategoryCRUD))
 async def get_category(
     slug: str, categoryies_crud: CategoryCRUD = Depends(CategoryCRUD)
 ):
-    category = await categoryies_crud.get_by_slug(slug)
-    if not category:
-        raise HTTPException(status_code=404, detail="Category not found")
+    category = await get_or_404(
+        categoryies_crud.get_by_slug(slug), "Category not found"
+    )
     return category
 
 
@@ -48,10 +49,9 @@ async def update_category(
     data: CategoryUpdateScheme,
     categoryies_crud: CategoryCRUD = Depends(CategoryCRUD),
 ):
-    category = await categoryies_crud.get_by_slug(slug)
-    if not category:
-        raise HTTPException(status_code=404, detail="Category not found")
-
+    category = await get_or_404(
+        categoryies_crud.get_by_slug(slug), "Category not found"
+    )
     return await categoryies_crud.update(category, data)
 
 
@@ -63,8 +63,7 @@ async def update_category(
 async def delete_category(
     slug: str, categoryies_crud: CategoryCRUD = Depends(CategoryCRUD)
 ):
-    category = await categoryies_crud.get_by_slug(slug)
-    if not category:
-        raise HTTPException(status_code=404, detail="Category not found")
-
+    category = await get_or_404(
+        categoryies_crud.get_by_slug(slug), "Category not found"
+    )
     await categoryies_crud.delete(category)

src/api/v1/orders.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from db.dependencies.sessions import get_db_session
+from schemas.order import CheckoutRequestScheme, OrderOutScheme
+from services.order_service import OrderService
+from utils.shortcuts import get_or_404
+
+router = APIRouter(prefix="/orders", tags=["Orders"])
+
+
+async def get_order_service(
+    session: AsyncSession = Depends(get_db_session),
+) -> OrderService:
+    return OrderService(session)
+
+
+@router.post(
+    "/checkout", response_model=OrderOutScheme, status_code=status.HTTP_201_CREATED
+)
+async def checkout(
+    payload: CheckoutRequestScheme, service: OrderService = Depends(get_order_service)
+):
+    order = await service.checkout(
+        user_id=payload.user_id,
+        address_id=payload.address_id,
+        delivery_id=payload.delivery_id,
+        items=payload.items,
+        promo_code=payload.promo_code,
+        currency=payload.currency,
+    )
+    return order
+
+
+@router.post("/{order_id}/pay", status_code=status.HTTP_200_OK)
+async def pay_success(
+    order_id: int, service: OrderService = Depends(get_order_service)
+):
+    order = await service.on_payment_success(order_id)
+    return {"detail": "Payment confirmed", "order_id": order.id}
+
+
+@router.post("/{order_id}/cancel", status_code=status.HTTP_200_OK)
+async def cancel(order_id: int, service: OrderService = Depends(get_order_service)):
+    order = await service.cancel_order(order_id)
+    return {"detail": "Order cancelled", "order_id": order.id}
+
+
+@router.get("/{order_id}", response_model=OrderOutScheme)
+async def get_order(order_id: int, service: OrderService = Depends(get_order_service)):
+    order = await service.crud.get_order(order_id)
+    order = await get_or_404(order, "Order not found")
+    return order

src/api/v1/payments.py

@@ -0,0 +1,53 @@
+# src/api/v1/payments.py
+import stripe
+from fastapi import APIRouter, Depends, Header, HTTPException, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.config import settings
+from db.dependencies.sessions import get_db_session
+from services.payment_service import PaymentService
+
+router = APIRouter(prefix="/payments", tags=["Payments"])
+
+
+async def get_payment_service(session: AsyncSession = Depends(get_db_session)):
+    return PaymentService(session)
+
+
+# 1) create payment intent for order (returns client_secret)
+@router.post("/{order_id}/create")
+async def create_payment(
+    order_id: int, service: PaymentService = Depends(get_payment_service)
+):
+    return await service.create_payment_intent_for_order(order_id)
+
+
+# 2) webhook endpoint — Stripe will POST events here
+# IMPORTANT: do NOT use regular body parsing for verification — read raw body bytes
+@router.post("/webhook", status_code=200)
+async def stripe_webhook(
+    request: Request,
+    stripe_signature: str | None = Header(None),
+    service: PaymentService = Depends(get_payment_service),
+):
+    payload = await request.body()
+    sig_header = stripe_signature or request.headers.get(
+        "stripe-signature"
+    )  # header name lowercase may occur
+    if sig_header is None:
+        raise HTTPException(status_code=400, detail="Missing stripe signature")
+
+    try:
+        event = stripe.Webhook.construct_event(
+            payload=payload,
+            sig_header=sig_header,
+            secret=settings.STRIPE_WEBHOOK_SECRET,
+        )
+    except stripe.error.SignatureVerificationError:
+        raise HTTPException(status_code=400, detail="Invalid signature")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Webhook error: {e}")
+
+    # event is verified — handle it
+    result = await service.handle_webhook_event(event)
+    return result

src/api/v1/products/__init__.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import List
+
+from fastapi import APIRouter, Depends, UploadFile, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from db.dependencies.auth import ADMIN_ROLE, SELLER_ROLE, require_roles
+from db.dependencies.sessions import get_db_session
+from schemas.product import (
+    ProductImageOutScheme,
+)
+from services.product_service import ProductImageService
+
+router = APIRouter(prefix="/products", tags=["Product Images"])
+
+
+async def get_product_images_service(
+    session: AsyncSession = Depends(get_db_session),
+) -> ProductImageService:
+    return ProductImageService(session)
+
+
+# Product Image endpoints
+@router.get("/{product_id}/images", response_model=List[ProductImageOutScheme])
+async def list_images(
+    product_id: int,
+    product_service: ProductImageService = Depends(get_product_images_service),
+):
+    return await product_service.list_images(product_id)
+
+
+@router.post(
+    "/{product_id}/images",
+    response_model=ProductImageOutScheme,
+    #  dependencies=[Depends(require_roles(ADMIN_ROLE, SELLER_ROLE))]
+)
+async def upload_image(
+    product_id: int,
+    file: UploadFile,
+    product_service: ProductImageService = Depends(get_product_images_service),
+):
+    return await product_service.add_image(product_id, file)
+
+
+@router.delete(
+    "/images/{image_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    dependencies=[Depends(require_roles(ADMIN_ROLE, SELLER_ROLE))],
+)
+async def delete_image(
+    image_id: int,
+    product_service: ProductImageService = Depends(get_product_images_service),
+):
+    await product_service.delete_image(image_id)