重构后端服务架构并优化前端错误处理

fastapi-backend/app/api/auth.py

@@ -0,0 +1,80 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm, OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from app.db.database import get_db
+from app.models.user import User
+from app.schemas.user import UserCreate, Token, User
+from app.core.security import verify_password, create_access_token, decode_access_token
+from datetime import timedelta
+from app.core.config import settings
+import uuid
+
+router = APIRouter()
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/auth/login")
+
+@router.post("/login", response_model=Token)
+def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+    # Find user by username
+    user = db.query(User).filter(User.username == form_data.username).first()
+    if not user or not verify_password(form_data.password, user.password_hash):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Create access token
+    access_token_expires = timedelta(minutes=settings.JWT_EXPIRATION_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.uuid}, expires_delta=access_token_expires
+    )
+    
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.post("/register", response_model=User)
+def register(user: UserCreate, db: Session = Depends(get_db)):
+    # Check if user already exists
+    db_user = db.query(User).filter(User.username == user.username).first()
+    if db_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Username already registered",
+        )
+    
+    # Create new user
+    new_user = User(
+        uuid=str(uuid.uuid4()),
+        username=user.username,
+        user_type=user.user_type,
+        status=user.status
+    )
+    new_user.set_password(user.password)
+    
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    
+    return new_user
+
+@router.get("/me", response_model=User)
+def read_users_me(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    payload = decode_access_token(token)
+    if payload is None:
+        raise credentials_exception
+    
+    uuid: str = payload.get("sub")
+    if uuid is None:
+        raise credentials_exception
+    
+    user = db.query(User).filter(User.uuid == uuid).first()
+    if user is None:
+        raise credentials_exception
+    
+    return user

fastapi-backend/app/api/orders.py

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from app.db.database import get_db
+from app.models.order import Order
+from app.schemas.order import Order, OrderCreate, OrderUpdate
+import uuid
+
+router = APIRouter()
+
+@router.get("/", response_model=List[Order])
+def read_orders(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    orders = db.query(Order).offset(skip).limit(limit).all()
+    return orders
+
+@router.get("/{order_id}", response_model=Order)
+def read_order(order_id: int, db: Session = Depends(get_db)):
+    db_order = db.query(Order).filter(Order.id == order_id).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+    return db_order
+
+@router.post("/", response_model=Order)
+def create_order(order: OrderCreate, db: Session = Depends(get_db)):
+    # Generate unique order number
+    order_no = f"ORD{uuid.uuid4().hex[:16].upper()}"
+    
+    db_order = Order(
+        order_no=order_no,
+        buyer_id=order.buyer_id,
+        seller_id=order.seller_id,
+        variety_type=order.variety_type,
+        weight_range=order.weight_range,
+        weight_actual=order.weight_actual,
+        price_per_unit=order.price_per_unit,
+        total_price=order.total_price,
+        advance_payment=order.advance_payment,
+        final_payment=order.final_payment,
+        status=order.status,
+        delivery_address=order.delivery_address,
+        delivery_time=order.delivery_time,
+        remark=order.remark
+    )
+    
+    db.add(db_order)
+    db.commit()
+    db.refresh(db_order)
+    return db_order
+
+@router.put("/{order_id}", response_model=Order)
+def update_order(order_id: int, order: OrderUpdate, db: Session = Depends(get_db)):
+    db_order = db.query(Order).filter(Order.id == order_id).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+    
+    # Update order fields
+    for field, value in order.dict(exclude_unset=True).items():
+        setattr(db_order, field, value)
+    
+    db.commit()
+    db.refresh(db_order)
+    return db_order
+
+@router.delete("/{order_id}", response_model=Order)
+def delete_order(order_id: int, db: Session = Depends(get_db)):
+    db_order = db.query(Order).filter(Order.id == order_id).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+    
+    db.delete(db_order)
+    db.commit()
+    return db_order

fastapi-backend/app/api/payments.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from app.db.database import get_db
+from app.models.payment import Payment
+from app.schemas.payment import Payment, PaymentCreate, PaymentUpdate
+import uuid
+
+router = APIRouter()
+
+@router.get("/", response_model=List[Payment])
+def read_payments(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    payments = db.query(Payment).offset(skip).limit(limit).all()
+    return payments
+
+@router.get("/{payment_id}", response_model=Payment)
+def read_payment(payment_id: int, db: Session = Depends(get_db)):
+    db_payment = db.query(Payment).filter(Payment.id == payment_id).first()
+    if db_payment is None:
+        raise HTTPException(status_code=404, detail="Payment not found")
+    return db_payment
+
+@router.post("/", response_model=Payment)
+def create_payment(payment: PaymentCreate, db: Session = Depends(get_db)):
+    # Generate unique payment number
+    payment_no = f"PMT{uuid.uuid4().hex[:16].upper()}"
+    
+    db_payment = Payment(
+        payment_no=payment_no,
+        order_id=payment.order_id,
+        user_id=payment.user_id,
+        amount=payment.amount,
+        payment_type=payment.payment_type,
+        payment_method=payment.payment_method,
+        status=payment.status,
+        transaction_id=payment.transaction_id
+    )
+    
+    db.add(db_payment)
+    db.commit()
+    db.refresh(db_payment)
+    return db_payment
+
+@router.put("/{payment_id}", response_model=Payment)
+def update_payment(payment_id: int, payment: PaymentUpdate, db: Session = Depends(get_db)):
+    db_payment = db.query(Payment).filter(Payment.id == payment_id).first()
+    if db_payment is None:
+        raise HTTPException(status_code=404, detail="Payment not found")
+    
+    # Update payment fields
+    for field, value in payment.dict(exclude_unset=True).items():
+        setattr(db_payment, field, value)
+    
+    db.commit()
+    db.refresh(db_payment)
+    return db_payment
+
+@router.delete("/{payment_id}", response_model=Payment)
+def delete_payment(payment_id: int, db: Session = Depends(get_db)):
+    db_payment = db.query(Payment).filter(Payment.id == payment_id).first()
+    if db_payment is None:
+        raise HTTPException(status_code=404, detail="Payment not found")
+    
+    db.delete(db_payment)
+    db.commit()
+    return db_payment

fastapi-backend/app/api/users.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from app.db.database import get_db
+from app.models.user import User
+from app.schemas.user import User, UserCreate, UserUpdate
+from app.api.auth import oauth2_scheme
+
+router = APIRouter()
+
+@router.get("/", response_model=List[User])
+def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    users = db.query(User).offset(skip).limit(limit).all()
+    return users
+
+@router.get("/{user_id}", response_model=User)
+def read_user(user_id: int, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return db_user
+
+@router.put("/{user_id}", response_model=User)
+def update_user(user_id: int, user: UserUpdate, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    # Update user fields
+    if user.username is not None:
+        db_user.username = user.username
+    if user.user_type is not None:
+        db_user.user_type = user.user_type
+    if user.status is not None:
+        db_user.status = user.status
+    
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.delete("/{user_id}", response_model=User)
+def delete_user(user_id: int, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    db.delete(db_user)
+    db.commit()
+    return db_user