B2B Bayi Yönetim Sistemi — Aşama 2: Akıllı Stok ve Sepet Yönetimi (PNUM22951)

1. Aşama 2 Hata Kategorizasyonu Özeti
2. 10 Yeni Kritik Hata Detaylı Analizi
3. Production-Ready Frontend Kod (React — Sepet & Virtualization)
4. Production-Ready Backend Kod (FastAPI — Lock, Transaction, Webhook)
5. Mimari Diyagram — Sepet & Stuk Akışı
6. Sonraki Aşama: B2B e-Tahsilat ve Sanal Pos

İki bayi aynı anda son 10 adet ürünü sepete eklediğinde, ikisi de stoğun yeterli görebilir (read-then-write race). Hiçbir lock mekanizması olmadan SELECT-then-UPDATE yapılıyor.

Bayi sepeti doldururken arka planda fiyat güncellenirse, sepettle eski fiyatla sipariş onaylanabilir. Fiyat snapshot'ı alınmıyor.

Sepet endpoint'inde cart_id parametresi URL'de geliyor ve sunucu tarafında bu cart_id'nin hangi bayiye ait olduğu doğrulanmıyor. Bir bayi başka bir bayinin cart_id'sini deneyerek sepetteki ürünleri görebilir.

Bayi ürünü sepete ekleyip saatlerce orada bırakırsa, stok rezerve edilmiş kalır. Diğer bayiler o ürünü sipariş edemez.

Sepete ürün ekleme anında frontend optimistic update yapıyor (UI'da hemen gösteriyor) ama API hata verirse rollback yapmıyor. Bayi ürünün eklendiğini sanır ama gerçekte eklenmemiş olabilir.

Sepette 5 ürünün miktarı aynı anda güncellenirken, her biri için ayrı UPDATE sorgusu yapılıyor. 3. üründe hata olursa ilk 2 ürün güncellenmiş kalır — partial update.

Minimum order quantity kontrolü sadece React frontend'de yapılıyor. API'ye manuel istek atıldığında MOQ altında sipariş verilebilir.

Stuk Redis'te tutuluyor ama ERP (Logo/Netsis) ile periyodik senkronizasyon yapılmıyor. ERP'de stok güncellenmiş ama Redis'te eski değer kalmış.

500+ ürün içeren septe tüm ürünler DOM'a render ediliyor. Tarayıcı belleği şişer, scroll takılır.

ERP'den gelen sipariş onayı webhook'unda HMAC imza doğrulaması yok. Kötü niyetli biri sahte webhook göndererek sipariş durumunu değiştirebilir.

import React, { useState, useCallback } from 'react';
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { useVirtualizer } from '@tanstack/react-virtual'; // DÜZELTME 9: Virtualization

const API_BASE = import.meta.env.VITE_API_BASE_URL;
const CART_TTL_MINUTES = 30; // DÜZELTME 4: Sepet TTL

// DÜZELTME 9: Virtualized cart list — 500+ üründe bile akıcı
function VirtualizedCartList({ items, onUpdateQty, onRemove }) {
    const parentRef = React.useRef(null);

    const virtualizer = useVirtualizer({
        count: items.length,
        getScrollElement: () => parentRef.current,
        estimateSize: () => 60,
        overscan: 5,
    });

    return (
        

            

                {virtualizer.getVirtualItems().map(virtualItem => {
                    const item = items[virtualItem.index];
                    return (
                        

                            {item.name}
                            
                                {item.locked_price.toLocaleString('tr-TR')} TL
                            
                             onUpdateQty(item.product_id, parseInt(e.target.value))}
                                style={{ width: '60px', margin: '0 8px' }}
                            />
                             onRemove(item.product_id)}>Sil
                        
                    );
                })}
            
        
    );
}

export default function ShoppingCart({ dealerId }) {
    const queryClient = useQueryClient();
    const [error, setError] = useState(null);

    // Sepeti yükle — DÜZELTME 3: dealerId'ye göre (IDOR koruması)
    const { data: cart, isLoading } = useQuery({
        queryKey: ['cart', dealerId],
        queryFn: async () => {
            const res = await fetch(`${API_BASE}/api/v1/cart`, {
                credentials: 'include' // JWT httpOnly cookie
            });
            if (!res.ok) throw new Error('Sepet yüklenemedi');
            return res.json();
        },
        staleTime: 60_000, // 1 dakika cache
    });

    // DÜZELTME 5: Optimistic update with rollback
    const updateQtyMutation = useMutation({
        mutationFn: async ({ productId, quantity }) => {
            const res = await fetch(`${API_BASE}/api/v1/cart/items`, {
                method: 'PATCH',
                credentials: 'include',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ product_id: productId, quantity })
            });
            if (!res.ok) {
                const err = await res.json();
                throw new Error(err.detail || 'Güncelleme başarısız');
            }
            return res.json();
        },
        onMutate: async ({ productId, quantity }) => {
            // Optimistic update — UI'da hemen göster
            await queryClient.cancelQueries({ queryKey: ['cart', dealerId] });
            const previousCart = queryClient.getQueryData(['cart', dealerId]);

            queryClient.setQueryData(['cart', dealerId], (old) => ({
                ...old,
                items: old.items.map(item =>
                    item.product_id === productId ? { ...item, quantity } : item
                )
            }));

            // Rollback için previous state'i döndür
            return { previousCart };
        },
        onError: (err, _vars, context) => {
            // Hata durumunda rollback
            if (context?.previousCart) {
                queryClient.setQueryData(['cart', dealerId], context.previousCart);
            }
            setError(err.message);
        },
        onSettled: () => {
            queryClient.invalidateQueries({ queryKey: ['cart', dealerId] });
        }
    });

    if (isLoading) return 
Yükleniyor...
;

    return (
        

            {error && 
{error}
}
            
Sepetim ({cart?.items?.length || 0} ürün)
            {/* DÜZELTME 9: Virtualized list */}
             updateQtyMutation.mutate({ productId, quantity: qty })}
            />
            

                Toplam: {cart?.total?.toLocaleString('tr-TR') || 0} TL
            
        
    );
}

import asyncio
import json
import logging
import hashlib
import hmac
from datetime import datetime, timedelta
from fastapi import FastAPI, HTTPException, Depends, status, Request, Header
from pydantic import BaseModel, validator
import redis.asyncio as aioredis
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, update

logger = logging.getLogger(__name__)
app = FastAPI()

redis_client = aioredis.from_url("redis://localhost:6379/0", decode_responses=True)

# DÜZELTME 3: JWT'den dealer_id çek (IDOR koruması)
async def get_current_dealer(token: str = Depends(oauth2_scheme)):
    payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
    dealer_id = payload.get("dealer_id")
    if not dealer_id:
        raise HTTPException(401, "Unauthorized")
    return dealer_id

class CartItemRequest(BaseModel):
    product_id: int
    quantity: int

    # DÜZELTME 7: Backend MOQ validasyonu
    @validator('quantity')
    def validate_quantity(cls, v, values):
        if v < 1:
            raise ValueError('Miktar 1'den az olamaz')
        return v

class CartItemUpdateRequest(BaseModel):
    product_id: int
    quantity: int

# DÜZELTME 1: Distributed lock ile stok rezervasyonu (race condition çözümü)
async def acquire_stock_lock(redis, product_id: int, dealer_id: int, ttl: int = 30):
    # Redis Redlock pattern - atomic stok rezervasyonu.
    lock_key = f"stock_lock:product:{product_id}:dealer:{dealer_id}"
    lock_value = f"{dealer_id}:{datetime.utcnow().isoformat()}"

    # SET NX (only if not exists) + TTL
    acquired = await redis.set(lock_key, lock_value, nx=True, ex=ttl)
    if not acquired:
        raise HTTPException(
            status_code=409,
            detail="Bu ürün şu anda işleniyor, lütfen tekrar deneyin"
        )
    return lock_key, lock_value

async def release_stock_lock(redis, lock_key: str, lock_value: str):
    # Locku güvenli sekilde release et (sadece sahibi release edebilir).
    current = await redis.get(lock_key)
    if current == lock_value:
        await redis.delete(lock_key)

@app.post("/api/v1/cart/items")
async def add_to_cart(
    req: CartItemRequest,
    dealer_id: int = Depends(get_current_dealer),
    db: AsyncSession = Depends(get_db)
):
    # DÜZELTME 1: Stok lock'u al
    lock_key, lock_value = await acquire_stock_lock(
        redis_client, req.product_id, dealer_id
    )

    try:
        # Redis'ten mevcut stok kontrolü
        stock_key = f"stock:product:{req.product_id}"
        current_stock = int(await redis_client.get(stock_key) or 0)

        if current_stock < req.quantity:
            raise HTTPException(
                status_code=409,
                detail=f"Yetersiz stok. Mevcut: {current_stock}, İstenen: {req.quantity}"
            )

        # DÜZELTME 2: Fiyat snapshot'ı al (price lock)
        price_key = f"price:product:{req.product_id}"
        current_price = float(await redis_client.get(price_key) or 0)

        # Sepet anahtarı — DÜZELTME 3: dealer_id'ye göre
        cart_key = f"cart:dealer:{dealer_id}"

        # DÜZELTME 4: Sepet TTL yenile (30 dakika)
        await redis_client.expire(cart_key, 1800)

        # Sepete ekle — locked_price ile
        cart_item = {
            "product_id": req.product_id,
            "quantity": req.quantity,
            "locked_price": current_price,  # DÜZELTME 2: Fiyat snapshot
            "price_locked_at": datetime.utcnow().isoformat(),
            "name": await redis_client.hget(f"product:{req.product_id}", "name")
        }

        # Redis hash olarak sepete ekle
        await redis_client.hset(cart_key, str(req.product_id), json.dumps(cart_item))

        # Stok rezervasyonu (atomic decrement)
        await redis_client.decrby(stock_key, req.quantity)

        logger.info(
            "Cart item added",
            extra={"dealer_id": dealer_id, "product_id": req.product_id, "qty": req.quantity}
        )

        return {"status": "added", "cart_item": cart_item}

    finally:
        # DÜZELTME 1: Lock'u release et
        await release_stock_lock(redis_client, lock_key, lock_value)

@app.patch("/api/v1/cart/items")
async def update_cart_item(
    req: CartItemUpdateRequest,
    dealer_id: int = Depends(get_current_dealer),
    db: AsyncSession = Depends(get_db)
):
    cart_key = f"cart:dealer:{dealer_id}"

    # Mevcut sepet öğesini al
    existing = await redis_client.hget(cart_key, str(req.product_id))
    if not existing:
        raise HTTPException(404, "Ürün sepette bulunamadı")

    item = json.loads(existing)
    old_quantity = item["quantity"]
    diff = req.quantity - old_quantity

    # DÜZELTME 1: Stok lock
    lock_key, lock_value = await acquire_stock_lock(
        redis_client, req.product_id, dealer_id
    )

    try:
        if diff > 0:
            # Miktar arttı — ek stok rezervasyonu gerekli
            stock_key = f"stock:product:{req.product_id}"
            current_stock = int(await redis_client.get(stock_key) or 0)
            if current_stock < diff:
                raise HTTPException(409, f"Yetersiz stok. Ekstra gerekli: {diff}")
            await redis_client.decrby(stock_key, diff)
        elif diff < 0:
            # Miktar azaldı — stoğu geri ver
            stock_key = f"stock:product:{req.product_id}"
            await redis_client.incrby(stock_key, abs(diff))

        # Sepeti güncelle
        item["quantity"] = req.quantity
        await redis_client.hset(cart_key, str(req.product_id), json.dumps(item))
        await redis_client.expire(cart_key, 1800)  # DÜZELTME 4: TTL yenile

        return {"status": "updated", "item": item}

    finally:
        await release_stock_lock(redis_client, lock_key, lock_value)

# DÜZELTME 6: Toplu sepet güncelleme — tek transaction
@app.post("/api/v1/cart/checkout")
async def checkout_cart(
    dealer_id: int = Depends(get_current_dealer),
    db: AsyncSession = Depends(get_db)
):
    cart_key = f"cart:dealer:{dealer_id}"
    cart_items = await redis_client.hgetall(cart_key)

    if not cart_items:
        raise HTTPException(400, "Sepet boş")

    # DÜZELTME 6: Tüm sipariş tek transaction'da
    async with db.begin():
        try:
            order = await create_order(db, dealer_id, cart_items)

            # Stok kalıcı düş (DB'de)
            for product_id_str, item_json in cart_items.items():
                item = json.loads(item_json)

                # DÜZELTME 2: Fiyat snapshot kontrolü
                current_price = await get_current_product_price(db, int(product_id_str))
                if abs(current_price - item["locked_price"]) > 0.01:
                    logger.warning(
                        f"Price mismatch for product {product_id_str}: "
                        f"locked={item['locked_price']}, current={current_price}"
                    )
                    # Fiyat değişmiş — bayiye sor
                    raise HTTPException(
                        409,
                        f"Ürün {item['name']} fiyatı değişmiş. "
                        f"Sepet: {item['locked_price']} TL, Güncel: {current_price} TL. "
                        f"Sepeti güncelleyin."
                    )

                # DB'de stok güncelle (SELECT FOR UPDATE — pessimistic lock)
                product = await db.execute(
                    select(Product)
                    .where(Product.id == int(product_id_str))
                    .with_for_update()  # DÜZELTME 1: DB-level lock
                )
                product_obj = product.scalar_one_or_none()
                if not product_obj or product_obj.stock < item["quantity"]:
                    raise HTTPException(409, f"Yetersiz stok: {item['name']}")

                product_obj.stock -= item["quantity"]

            # Sipariş öğelerini oluştur
            for product_id_str, item_json in cart_items.items():
                item = json.loads(item_json)
                order_item = OrderItem(
                    order_id=order.id,
                    product_id=int(product_id_str),
                    quantity=item["quantity"],
                    unit_price=item["locked_price"],  # DÜZELTME 2: Locked price
                    total_price=item["locked_price"] * item["quantity"]
                )
                db.add(order_item)

            # Sepeti temizle
            await redis_client.delete(cart_key)

            await db.flush()
            logger.info(f"Order created: {order.id} for dealer {dealer_id}")
            return {"order_id": order.id, "status": "confirmed"}

        except Exception as e:
            # DÜZELTME 6: Transaction rollback (otomatik — async with db.begin())
            logger.error(f"Checkout failed for dealer {dealer_id}: {e}")
            raise

# DÜZELTME 10: Webhook imza doğrulaması
@app.post("/api/v1/webhooks/erp-order-status")
async def erp_webhook(
    request: Request,
    x_erp_signature: str = Header(None),
    x_erp_timestamp: str = Header(None)
):
    body = await request.body()

    # HMAC-SHA256 imza doğrulaması
    expected_sig = hmac.new(
        ERP_WEBHOOK_SECRET.encode(),
        body,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected_sig, x_erp_signature or ""):
        logger.error("Invalid webhook signature")
        raise HTTPException(401, "Invalid signature")

    # Timestamp kontrolü (5 dakika pencere — replay attack koruması)
    if abs(datetime.utcnow().timestamp() - float(x_erp_timestamp or 0)) > 300:
        raise HTTPException(401, "Expired webhook")

    data = json.loads(body)
    logger.info(f"ERP webhook received: {data.get('order_id')}")

    # Sipariş durumunu güncelle
    await update_order_from_erp(data)

    return {"status": "processed"}