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

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

fastapi-backend/app/core/config.py

@@ -0,0 +1,24 @@
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    # Database configuration
+    DB_HOST: str = os.getenv("DB_HOST", "localhost")
+    DB_PORT: int = int(os.getenv("DB_PORT", 3306))
+    DB_USER: str = os.getenv("DB_USER", "root")
+    DB_PASSWORD: str = os.getenv("DB_PASSWORD", "password")
+    DB_NAME: str = os.getenv("DB_NAME", "niumall_dev")
+    
+    # JWT configuration
+    JWT_SECRET: str = os.getenv("JWT_SECRET", "niumall-jwt-secret")
+    JWT_ALGORITHM: str = os.getenv("JWT_ALGORITHM", "HS256")
+    JWT_EXPIRATION_MINUTES: int = int(os.getenv("JWT_EXPIRATION_MINUTES", 1440))
+    
+    # Server configuration
+    SERVER_HOST: str = os.getenv("SERVER_HOST", "0.0.0.0")
+    SERVER_PORT: int = int(os.getenv("SERVER_PORT", 8000))
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

fastapi-backend/app/core/security.py

@@ -0,0 +1,30 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from app.core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=settings.JWT_EXPIRATION_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.JWT_SECRET, algorithm=settings.JWT_ALGORITHM)
+    return encoded_jwt
+
+def decode_access_token(token: str):
+    try:
+        payload = jwt.decode(token, settings.JWT_SECRET, algorithms=[settings.JWT_ALGORITHM])
+        return payload
+    except JWTError:
+        return None

fastapi-backend/app/db/database.py

@@ -0,0 +1,24 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.core.config import settings
+
+# Create database URL
+SQLALCHEMY_DATABASE_URL = f"mysql+pymysql://{settings.DB_USER}:{settings.DB_PASSWORD}@{settings.DB_HOST}:{settings.DB_PORT}/{settings.DB_NAME}"
+
+# Create engine
+engine = create_engine(SQLALCHEMY_DATABASE_URL, echo=True, pool_pre_ping=True)
+
+# Create session
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Base class for models
+Base = declarative_base()
+
+# Dependency to get DB session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

fastapi-backend/app/main.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI, Request, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from app.api import auth, users, orders, payments
+from app.core.config import settings
+from app.db.database import engine, Base
+from app.middleware.error_handler import error_handler
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(
+    title="活牛采购智能数字化系统API",
+    description="活牛采购智能数字化系统后端API接口",
+    version="1.0.0",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify exact origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Add exception handlers
+app.add_exception_handler(StarletteHTTPException, error_handler)
+app.add_exception_handler(RequestValidationError, error_handler)
+app.add_exception_handler(Exception, error_handler)
+
+# Include routers
+app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
+app.include_router(users.router, prefix="/api/users", tags=["users"])
+app.include_router(orders.router, prefix="/api/orders", tags=["orders"])
+app.include_router(payments.router, prefix="/api/payments", tags=["payments"])
+
+@app.get("/")
+async def root():
+    return {"message": "活牛采购智能数字化系统后端服务", "version": "1.0.0"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}

fastapi-backend/app/middleware/auth.py

@@ -0,0 +1,39 @@
+from fastapi import HTTPException, status, Depends
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from app.db.database import get_db
+from app.models.user import User
+from app.core.security import decode_access_token
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/auth/login")
+
+def get_current_user(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
+
+def require_role(required_role: str):
+    def role_checker(current_user: User = Depends(get_current_user)):
+        if current_user.user_type != required_role:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Insufficient permissions",
+            )
+        return current_user
+    return role_checker

fastapi-backend/app/middleware/error_handler.py

@@ -0,0 +1,25 @@
+from fastapi import HTTPException, Request
+from fastapi.responses import JSONResponse
+from app.utils.response import ErrorResponse
+
+async def error_handler(request: Request, exc: Exception):
+    # Handle HTTP exceptions
+    if isinstance(exc, HTTPException):
+        return JSONResponse(
+            status_code=exc.status_code,
+            content=ErrorResponse(
+                code=exc.status_code,
+                message=exc.detail,
+                data=None
+            ).dict()
+        )
+    
+    # Handle general exceptions
+    return JSONResponse(
+        status_code=500,
+        content=ErrorResponse(
+            code=500,
+            message="Internal Server Error",
+            data=str(exc)
+        ).dict()
+    )

fastapi-backend/app/models/order.py

@@ -0,0 +1,33 @@
+from sqlalchemy import Column, Integer, String, Float, Enum, DateTime, Text, func, ForeignKey
+from app.db.database import Base
+from enum import Enum as PyEnum
+
+class OrderStatus(str, PyEnum):
+    PENDING = "pending"
+    CONFIRMED = "confirmed"
+    PROCESSING = "processing"
+    SHIPPED = "shipped"
+    DELIVERED = "delivered"
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+
+class Order(Base):
+    __tablename__ = "orders"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    order_no = Column(String(32), unique=True, index=True, nullable=False)
+    buyer_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    seller_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    variety_type = Column(String(50), nullable=False)
+    weight_range = Column(String(50), nullable=False)
+    weight_actual = Column(Float, nullable=True)
+    price_per_unit = Column(Float, nullable=False)
+    total_price = Column(Float, nullable=False)
+    advance_payment = Column(Float, nullable=False, default=0.0)
+    final_payment = Column(Float, nullable=False, default=0.0)
+    status = Column(Enum(OrderStatus), default=OrderStatus.PENDING, nullable=False)
+    delivery_address = Column(Text, nullable=True)
+    delivery_time = Column(DateTime, nullable=True)
+    remark = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now(), nullable=False)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now(), nullable=False)

fastapi-backend/app/models/payment.py

@@ -0,0 +1,33 @@
+from sqlalchemy import Column, Integer, String, Float, Enum, DateTime, ForeignKey, func
+from app.db.database import Base
+from enum import Enum as PyEnum
+
+class PaymentType(str, PyEnum):
+    ADVANCE = "advance"
+    FINAL = "final"
+
+class PaymentMethod(str, PyEnum):
+    WECHAT = "wechat"
+    ALIPAY = "alipay"
+    BANK = "bank"
+
+class PaymentStatus(str, PyEnum):
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILED = "failed"
+    REFUNDED = "refunded"
+
+class Payment(Base):
+    __tablename__ = "payments"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    order_id = Column(Integer, ForeignKey("orders.id"), nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    payment_no = Column(String(32), unique=True, index=True, nullable=False)
+    amount = Column(Float, nullable=False)
+    payment_type = Column(Enum(PaymentType), nullable=False)
+    payment_method = Column(Enum(PaymentMethod), nullable=False)
+    status = Column(Enum(PaymentStatus), default=PaymentStatus.PENDING, nullable=False)
+    transaction_id = Column(String(128), nullable=True)
+    created_at = Column(DateTime, default=func.now(), nullable=False)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now(), nullable=False)

fastapi-backend/app/models/user.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column, Integer, String, Enum, DateTime, func
+from app.db.database import Base
+from passlib.context import CryptContext
+from enum import Enum as PyEnum
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+class UserType(str, PyEnum):
+    CLIENT = "client"
+    SUPPLIER = "supplier"
+    DRIVER = "driver"
+    STAFF = "staff"
+    ADMIN = "admin"
+
+class UserStatus(str, PyEnum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    LOCKED = "locked"
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    uuid = Column(String(36), unique=True, index=True, nullable=False)
+    username = Column(String(50), unique=True, index=True, nullable=False)
+    password_hash = Column(String(128), nullable=False)
+    user_type = Column(Enum(UserType), default=UserType.CLIENT, nullable=False)
+    status = Column(Enum(UserStatus), default=UserStatus.ACTIVE, nullable=False)
+    created_at = Column(DateTime, default=func.now(), nullable=False)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now(), nullable=False)
+    
+    def verify_password(self, plain_password):
+        return pwd_context.verify(plain_password, self.password_hash)
+    
+    def set_password(self, plain_password):
+        self.password_hash = pwd_context.hash(plain_password)

fastapi-backend/app/schemas/order.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from enum import Enum
+
+class OrderStatus(str, Enum):
+    PENDING = "pending"
+    CONFIRMED = "confirmed"
+    PROCESSING = "processing"
+    SHIPPED = "shipped"
+    DELIVERED = "delivered"
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+
+class OrderBase(BaseModel):
+    buyer_id: int
+    seller_id: int
+    variety_type: str
+    weight_range: str
+    weight_actual: Optional[float] = None
+    price_per_unit: float
+    total_price: float
+    advance_payment: float = 0.0
+    final_payment: float = 0.0
+    status: OrderStatus = OrderStatus.PENDING
+    delivery_address: Optional[str] = None
+    delivery_time: Optional[datetime] = None
+    remark: Optional[str] = None
+
+class OrderCreate(OrderBase):
+    pass
+
+class OrderUpdate(BaseModel):
+    buyer_id: Optional[int] = None
+    seller_id: Optional[int] = None
+    variety_type: Optional[str] = None
+    weight_range: Optional[str] = None
+    weight_actual: Optional[float] = None
+    price_per_unit: Optional[float] = None
+    total_price: Optional[float] = None
+    advance_payment: Optional[float] = None
+    final_payment: Optional[float] = None
+    status: Optional[OrderStatus] = None
+    delivery_address: Optional[str] = None
+    delivery_time: Optional[datetime] = None
+    remark: Optional[str] = None
+
+class OrderInDBBase(OrderBase):
+    id: int
+    order_no: str
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        orm_mode = True
+
+class Order(OrderInDBBase):
+    pass

fastapi-backend/app/schemas/payment.py

@@ -0,0 +1,52 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from enum import Enum
+
+class PaymentType(str, Enum):
+    ADVANCE = "advance"
+    FINAL = "final"
+
+class PaymentMethod(str, Enum):
+    WECHAT = "wechat"
+    ALIPAY = "alipay"
+    BANK = "bank"
+
+class PaymentStatus(str, Enum):
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILED = "failed"
+    REFUNDED = "refunded"
+
+class PaymentBase(BaseModel):
+    order_id: int
+    user_id: int
+    amount: float
+    payment_type: PaymentType
+    payment_method: PaymentMethod
+    status: PaymentStatus = PaymentStatus.PENDING
+    transaction_id: Optional[str] = None
+
+class PaymentCreate(PaymentBase):
+    pass
+
+class PaymentUpdate(BaseModel):
+    order_id: Optional[int] = None
+    user_id: Optional[int] = None
+    amount: Optional[float] = None
+    payment_type: Optional[PaymentType] = None
+    payment_method: Optional[PaymentMethod] = None
+    status: Optional[PaymentStatus] = None
+    transaction_id: Optional[str] = None
+
+class PaymentInDBBase(PaymentBase):
+    id: int
+    payment_no: str
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        orm_mode = True
+
+class Payment(PaymentInDBBase):
+    pass

fastapi-backend/app/schemas/user.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from enum import Enum
+
+class UserType(str, Enum):
+    CLIENT = "client"
+    SUPPLIER = "supplier"
+    DRIVER = "driver"
+    STAFF = "staff"
+    ADMIN = "admin"
+
+class UserStatus(str, Enum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    LOCKED = "locked"
+
+class UserBase(BaseModel):
+    username: str
+    user_type: UserType = UserType.CLIENT
+    status: UserStatus = UserStatus.ACTIVE
+
+class UserCreate(UserBase):
+    password: str
+
+class UserUpdate(BaseModel):
+    username: Optional[str] = None
+    user_type: Optional[UserType] = None
+    status: Optional[UserStatus] = None
+
+class UserInDBBase(UserBase):
+    id: int
+    uuid: str
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        orm_mode = True
+
+class User(UserInDBBase):
+    pass
+
+class UserInDB(UserInDBBase):
+    password_hash: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    uuid: Optional[str] = None

fastapi-backend/app/utils/response.py

@@ -0,0 +1,26 @@
+from typing import Any, Optional, Generic, TypeVar
+from pydantic import BaseModel
+from datetime import datetime
+
+T = TypeVar('T')
+
+class SuccessResponse(BaseModel, Generic[T]):
+    code: int = 200
+    message: str = "Success"
+    data: Optional[T] = None
+    timestamp: datetime = datetime.now()
+
+class ErrorResponse(BaseModel):
+    code: int = 500
+    message: str = "Internal Server Error"
+    data: Optional[Any] = None
+    timestamp: datetime = datetime.now()
+
+class PaginatedResponse(BaseModel, Generic[T]):
+    code: int = 200
+    message: str = "Success"
+    data: Optional[T] = None
+    timestamp: datetime = datetime.now()
+    total: int
+    page: int
+    limit: int