Django comprehensive practical project - complete guide to e-commerce platform development | Daoman PythonAI#

# services/user/user_service/apps/user_auth/models.py
from django.db import models
from django.contrib.auth.models import AbstractUser
import uuid

class User(AbstractUser):
    """扩展的用户模型"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    phone = models.CharField(max_length=20, blank=True, unique=True)
    avatar = models.URLField(blank=True)
    email_verified = models.BooleanField(default=False)
    phone_verified = models.BooleanField(default=False)
    is_premium = models.BooleanField(default=False, verbose_name="是否高级会员")
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'users'

# services/user/user_service/apps/user_auth/views.py
from rest_framework.views import APIView
from rest_framework.permissions import AllowAny
from rest_framework_simplejwt.tokens import RefreshToken
from .serializers import UserRegistrationSerializer
from .utils import send_verification_email

class UserRegistrationView(APIView):
    """用户注册"""
    permission_classes = [AllowAny]

    def post(self, request):
        serializer = UserRegistrationSerializer(data=request.data)
        if not serializer.is_valid():
            return ErrorResponse(serializer.errors, status=400)

        try:
            user = serializer.save()
            # 发送验证邮件（异步调用 Celery 任务更佳，此处为演示省略）
            send_verification_email(user.email, user.id)

            # 生成 JWT 令牌
            refresh = RefreshToken.for_user(user)

            return SuccessResponse({
                'user': {
                    'id': str(user.id),
                    'username': user.username,
                    'email': user.email,
                    'phone': user.phone,
                },
                'tokens': {
                    'refresh': str(refresh),
                    'access': str(refresh.access_token),
                },
                'message': '注册成功，请检查邮箱完成验证'
            }, status=201)
        except Exception as e:
            logger.error(f"用户注册失败: {str(e)}")
            return ErrorResponse({'detail': '注册失败，请稍后重试'}, status=500)

# services/product/product_service/models.py
class Product(models.Model):
    """商品"""
    PRODUCT_STATUS_CHOICES = [
        ('draft', '草稿'),
        ('pending_review', '待审核'),
        ('approved', '已审核'),
        ('active', '已上架'),
        ('inactive', '已下架'),
        ('discontinued', '停止销售'),
    ]

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=200, verbose_name="商品名称")
    slug = models.SlugField(unique=True, max_length=250)
    description = models.TextField(verbose_name="商品描述")
    category = models.ForeignKey(Category, on_delete=models.SET_NULL,
                                 null=True, related_name='products')
    brand = models.ForeignKey(Brand, on_delete=models.SET_NULL,
                              null=True, related_name='products')
    sku = models.CharField(max_length=100, unique=True, verbose_name="SKU")
    price = models.DecimalField(max_digits=10, decimal_places=2,
                                validators=[MinValueValidator(0)])
    status = models.CharField(max_length=20, choices=PRODUCT_STATUS_CHOICES,
                              default='draft', verbose_name="商品状态")
    rating = models.DecimalField(max_digits=3, decimal_places=2,
                                 default=0, validators=[MinValueValidator(0),
                                                        MaxValueValidator(5.0)])
    review_count = models.PositiveIntegerField(default=0)
    view_count = models.PositiveIntegerField(default=0)
    sales_count = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'products'

# services/order/order_service/views.py
class ShoppingCartView(APIView):
    """购物车管理"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        """获取当前用户的购物车"""
        cart, _ = ShoppingCart.objects.get_or_create(
            user_id=request.user.id,
            defaults={'items': [], 'total_items': 0, 'total_amount': 0.00}
        )
        self.update_cart_totals(cart)
        serializer = ShoppingCartSerializer(cart)
        return SuccessResponse(serializer.data)

    def post(self, request):
        """添加商品到购物车"""
        product_id = request.data.get('product_id')
        quantity = int(request.data.get('quantity', 1))

        if not product_id:
            return ErrorResponse({'error': '商品ID不能为空'}, status=400)

        # 检查商品是否存在且库存充足
        product = self.check_product_availability(product_id, quantity)
        if not product:
            return ErrorResponse({'error': '商品不存在或库存不足'}, status=400)

        cart, _ = ShoppingCart.objects.get_or_create(
            user_id=request.user.id,
            defaults={'items': [], 'total_items': 0, 'total_amount': 0.00}
        )

        # 更新购物车商品项
        cart.items.append({
            'product_id': str(product_id),
            'quantity': quantity,
            'unit_price': float(product.price),
            'total_price': float(product.price * quantity),
            'added_at': timezone.now().isoformat()
        })
        cart.save()
        self.update_cart_totals(cart)

        serializer = ShoppingCartSerializer(cart)
        return SuccessResponse({
            'cart': serializer.data,
            'message': '已加入购物车'
        })

# services/payment/payment_service/gateways/base.py
from abc import ABC, abstractmethod
from decimal import Decimal
from typing import Dict, Any

class BasePaymentGateway(ABC):
    """支付网关抽象基类"""

    def __init__(self, config: Dict[str, Any]):
        self.config = config

    @abstractmethod
    def create_payment(self, amount: Decimal, currency: str,
                       order_info: Dict[str, Any]) -> Dict[str, Any]:
        """发起支付请求"""
        pass

    @abstractmethod
    def verify_payment(self, transaction_id: str) -> Dict[str, Any]:
        """验证支付结果"""
        pass

    @abstractmethod
    def refund_payment(self, transaction_id: str,
                       amount: Decimal = None) -> Dict[str, Any]:
        """执行退款"""
        pass

# services/gateway/gateway_app/views.py
class GatewayView(View):
    """API 网关主视图"""

    def __init__(self):
        super().__init__()
        self.service_discovery = ServiceDiscovery()  # 服务发现
        self.load_balancer = LoadBalancer()          # 负载均衡
        self.api_client = APIClient()                # HTTP 客户端
        self.circuit_breaker = CircuitBreaker()      # 熔断器

    def dispatch(self, request, *args, **kwargs):
        """请求分发"""
        path = request.path
        method = request.method

        # 1. 根据路由表找到对应的微服务
        try:
            route = APIRoute.objects.get(
                path=path,
                methods__contains=[method],
                is_active=True
            )
        except APIRoute.DoesNotExist:
            return JsonResponse({'error': '路由未找到'}, status=404)

        # 2. 从服务发现获取一个可用实例
        instance = self.service_discovery.get_instance(route.target_service.name)
        if not instance:
            return JsonResponse({'error': '服务暂不可用'}, status=503)

        # 3. 转发请求，并启用熔断保护
        headers = self._build_headers(request)
        body = request.body.decode('utf-8') if request.body else None
        query_params = dict(request.GET)

        try:
            response_data = self.circuit_breaker.call(
                route.target_service.name,
                self.api_client.forward_request,
                instance, path, method, headers, body, query_params
            )
            # 记录访问日志
            self._log_request(route, request, response_data)

            # 4. 构造响应返回客户端
            response = HttpResponse(
                content=response_data['body'],
                status=response_data['status_code'],
                content_type='application/json'
            )
            for key, value in response_data['headers'].items():
                response[key] = value
            return response

        except Exception as e:
            logger.error(f"网关转发异常: {e}")
            return JsonResponse({'error': '内部服务器错误'}, status=500)