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

1. Hata Kategorizasyonu Özeti
2. 10 Yeni Kritik Hata Detaylı Analizi
3. Production-Ready Frontend Kod (React — Sepet & Idempotency)
4. Production-Ready Backend Kod (FastAPI — Lock, Decimal, Transaction)
5. Kampanya Dönemi Stok Akışı Diyagramı
6. Sonuç ve Sonraki Aşama

Sepet toplam fiyatı ayrı bir state'te (totalPrice) tutuluyor ve useEffect ile senkronize ediliyor. Bu React'in 'derived state' antipattern'idir. State güncellemeleri batched olarak yapıldığında ara toplamlar bir karelik gecikmeyle gelir, bayi yanlış toplam görür.

updateQuantity fonksiyonunda sepet öğesi doğrudan mutasyona uğruyor: item.quantity = newQty. Bu React'in immutable state kuralını ihlal eder. Ayrıca önceki state güvenceye alınmıyor (functional update pattern eksik).

Sipariş Onayla butonuna çift tıklanırsa iki ayrı sipariş oluşur. Hiçbir debounce, loading state veya idempotency key mekanizması yok. Ağ yavaş olduğunda kullanıcı tekrar tıklar.

Miktar input'unda sayısal doğrulama yok. NaN, negatif değer, ondalık sayı girilebilir. parseInt(e.target.value) NaN dönebilir ve bu backend'e gider.

client_side_price parametresi frontend'den güvenilerek alınıyor! Bir bayi browser dev tools ile fiyatı 0.01 TL yapabilir. Backend hiçbir fiyat doğrulaması yapmıyor.

İskonto hesabında float veri tipi kullanılıyor: 5000.00 * (1 - 0.0853) = 4573.499999999999. Binlerce siparişte bu kuruş sapmaları birikerek muhasebe krizine dönüşür.

Frontend'den gelen fiyat ile backend hesaplanan fiyat uyuşmuyor ama işlem sadece print ile logluyor ve sessizce devam ediyor. Bu bir fail-safe mekanizması değil, fail-silent antipattern.

Stok kontrolü (if product['stock'] < item.quantity) ile stok düşme (product['stock'] -= item.quantity) arasında 0.1 saniye bekleme var. İki istek aynı anda kontrol yaparsa ikisi de stoku yeterli görür. Son stok 2 kez satılır.

db_inventory sözlüğü global bir Python değişkeni ve doğrudan mutasyona uğruyor: product['stock'] -= item.quantity. Çoklu worker'da her worker'ın kendi belleği farklı. Ayrıca hiçbir lock mekanizması yok.

Sepette 3 ürün var. 1. ürünün stoğu düşülür, 2. üründe stok yetersiz hatası çıkar. Ama 1. ürünün stok düşümü geri alınmaz. Transaction yok, rollback yok. Stok havada asılı kalır.

import React, { useState, useMemo, useCallback } from 'react';

// DÜZELTME 3: Idempotency key üretici
function generateIdempotencyKey() {
    return `${Date.now()}-${crypto.randomUUID()}`;
}

export default function B2BOrderCart({ initialItems }) {
    const [cartItems, setCartItems] = useState(initialItems);
    const [submitting, setSubmitting] = useState(false);
    const [error, setError] = useState(null);

    // DÜZELTME 1: Derived state antipattern cozumu — useMemo
    const totalPrice = useMemo(() => {
        return cartItems.reduce((sum, item) => sum + item.price * item.quantity, 0);
    }, [cartItems]);

    // DÜZELTME 2: Immutable update + functional update pattern
    const updateQuantity = useCallback((productId, newQty) => {
        // DÜZELTME 4: Kontrolsuuz girdi korumasi
        const parsedQty = Math.max(1, Math.floor(Number(newQty) || 1));

        setCartItems(prev =>
            prev.map(item =>
                item.id === productId
                    ? { ...item, quantity: parsedQty }
                    : item
            )
        );
    }, []);

    // DÜZELTME 3: Idempotency key + submitting state (double-click korumasi)
    const checkout = async () => {
        if (submitting) return; // Cift tiklama korumasi

        setSubmitting(true);
        setError(null);

        const idempotencyKey = generateIdempotencyKey();

        try {
            const response = await fetch('/api/v2/orders/confirm', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-Idempotency-Key': idempotencyKey  // DÜZELTME 3
                },
                credentials: 'include',
                body: JSON.stringify({
                    items: cartItems.map(item => ({
                        product_id: item.id,
                        quantity: item.quantity
                        // DÜZELTME 5: client_side_price GONDERILMIYOR!
                    }))
                })
            });

            if (!response.ok) {
                const err = await response.json();
                throw new Error(err.detail || 'Siparis basarisiz');
            }

            const result = await response.json();
            alert(`Siparis alindi! No: ${result.order_id}`);
        } catch (err) {
            setError(err.message);
        } finally {
            setSubmitting(false);
        }
    };

    return (
        

            {error && 
{error}
}
            {cartItems.map(item => (
                

                    {item.name} - {item.price.toLocaleString('tr-TR')} TL
                    {/* DÜZELTME 4: min=1, step=1 ile kontrol */}
                     updateQuantity(item.id, e.target.value)}
                    />
                
            ))}
            
Toplam: {totalPrice.toLocaleString('tr-TR')} TL
            
                {submitting ? 'Isleniyor...' : 'Siparisi Onayla'}
            
        
    );
}

import asyncio
import uuid
from decimal import Decimal, ROUND_HALF_UP  # DÜZELTME 6: Decimal
from fastapi import FastAPI, HTTPException, Header, Depends
from pydantic import BaseModel, validator
from typing import List
import redis.asyncio as aioredis
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, text

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

# DÜZELTME 5: client_side_price KALDIRILDI
class CartItem(BaseModel):
    product_id: int
    quantity: int

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

# DÜZELTME 8: Redis distributed lock
async def acquire_lock(product_id: int, ttl: int = 10):
    lock_key = f"stock_lock:{product_id}"
    lock_id = str(uuid.uuid4())
    acquired = await redis_client.set(lock_key, lock_id, nx=True, ex=ttl)
    if not acquired:
        raise HTTPException(409, "Urun isleniyor, tekrar deneyin")
    return lock_key, lock_id

async def release_lock(lock_key: str, lock_id: str):
    current = await redis_client.get(lock_key)
    if current == lock_id:
        await redis_client.delete(lock_key)

@app.post("/api/v2/orders/confirm")
async def confirm_order(
    items: List[CartItem],
    x_idempotency_key: str = Header(...),  # DÜZELTME 3: Idempotency key
    db: AsyncSession = Depends(get_db)
):
    # DÜZELTME 3: Idempotency key kontrolu
    idem_key = f"idem:{x_idempotency_key}"
    existing = await redis_client.get(idem_key)
    if existing:
        return {"status": "duplicate", "order_id": existing}

    # DÜZELTME 10: Tum siparis TEK transaction
    locks = []
    try:
        async with db.begin():
            for item in items:
                # DÜZELTME 8: Lock al
                lk, lid = await acquire_lock(item.product_id)
                locks.append((lk, lid))

                # DÜZELTME 9: Atomik stok dusumu (SELECT FOR UPDATE + atomic decrement)
                result = await db.execute(
                    text("UPDATE products SET stock = stock - :qty WHERE id = :pid AND stock >= :qty RETURNING id, name, stock, base_price"),
                    {"qty": item.quantity, "pid": item.product_id}
                )
                row = result.fetchone()
                if not row:
                    raise HTTPException(
                        409,
                        f"Stok yetersiz: Urun ID {item.product_id}"
                    )

                # DÜZELTME 6: Decimal ile fiyat hesabi
                base_price = Decimal(str(row.base_price))
                discount_ratio = Decimal("0.0853")
                calculated_price = (base_price * (Decimal("1") - discount_ratio)
                    .quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

                # DÜZELTME 7: Fiyat tutarlilik kontrolu
                logger.info(
                    f"Price calculated for product {item.product_id}: "
                    f"base={base_price}, final={calculated_price}"
                )

                # Siparis ogresini olustur
                order_item = OrderItem(
                    product_id=item.product_id,
                    quantity=item.quantity,
                    unit_price=calculated_price,
                    total_price=calculated_price * item.quantity
                )
                db.add(order_item)

            # Siparisi olustur
            order = Order(status="confirmed")
            db.add(order)
            await db.flush()

            # DÜZELTME 3: Idempotency key kaydet (24 saat)
            await redis_client.setex(idem_key, 86400, str(order.id))

            return {"status": "confirmed", "order_id": order.id}

    except HTTPException:
        raise  # Stok yetersiz hatasi — transaction rollback olur
    except Exception as e:
        logger.error(f"Order failed: {e}")
        raise HTTPException(500, "Siparis olusturulamadi")
    finally:
        # DÜZELTME 8+10: Tum locklari release et
        for lk, lid in locks:
            await release_lock(lk, lid)