DRF实操学习——购物车及订单生成

最新推荐文章于 2024-11-01 13:45:28 发布
最新推荐文章于 2024-11-01 13:45:28 发布
阅读量506 收藏 11
点赞数 22
分类专栏： django项目 文章标签： 学习 django python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51453764/article/details/142635008
版权

DRF实操学习——购物车及订单生成


目标：实现购物车功能及订单生成功能

分析：
技术点：事务控制
模型：
购物车表
订单表
订单商品表
在这里插入图片描述

1.基础配置

1. 创建模型

在shopping的models文件下创建模型

# 购物车表
class ShoppingCart(DateTimeModelMixin):
    number = models.IntegerField(default=1,verbose_name='数量')
    community = models.ForeignKey(Commodity,on_delete=models.CASCADE,verbose_name='商品')
    user = models.ForeignKey(User,on_delete=models.CASCADE,verbose_name='用户')

    class Meta:
        ordering=['-update_time']
        db_table = 'shopping_cart'
        verbose_name = '购物车'
        verbose_name_plural = verbose_name

# 订单表
class Order(DateTimeModelMixin):
    PAY_METHOD_CHOICES = (
        (1,'支付宝'),
        (2,'货到付款'),
    )
    STATUS_CHOICES = (
        (1,'待支付'),
        (2,'待发货'),
        (3,'待收货'),
        (4,'待评价'),
        (5,'已完成'),
        (6,'已取消'),
        (7,'申请退款'),
        (8,'退款成功'),
    )
    # 将订单号定义为主键字段
    order_id = models.CharField(max_length=64,primary_key=True,verbose_name='订单号')
    total_count = models.IntegerField(default=1,verbose_name='商品数')
    total_amount = models.DecimalField(max_digits=10,decimal_places=2,verbose_name='商品总金额')
    pay_method = models.IntegerField(verbose_name='支付方式',default=1,choices=PAY_METHOD_CHOICES)
    status = models.IntegerField(verbose_name='订单状态',default=1,choices=STATUS_CHOICES)
    address = models.TextField(verbose_name='收货地址')

    user = models.ForeignKey(User,on_delete=models.PROTECT,verbose_name='用户')

    class Meta:
        ordering=['-create_time']
        db_table = 'order'
        verbose_name = '订单表'
        verbose_name_plural = verbose_name


# 订单商品表
class OrderGoods(DateTimeModelMixin):
    SCORE_CHOICES = (
        (0,'零星'),
        (1,'一星'),
        (2,'二星'),
        (3,'三星'),
        (4,'四星'),
        (5,'五星'),
    )
    number = models.IntegerField(default=1,verbose_name='商品数')
    price = models.DecimalField(max_digits=10,decimal_places=2,verbose_name='单价')
    comment = models.TextField(verbose_name='评价',null=True,blank=True)
    score = models.IntegerField(null=True,blank=True,verbose_name='评分',choices=SCORE_CHOICES)

    is_anonymous = models.BooleanField(default=False,verbose_name='匿名评价')

    order = models.ForeignKey(Order,on_delete=models.CASCADE,verbose_name='订单')
    commodity = models.ForeignKey(Commodity,on_delete=models.SET_NULL,null=True,blank=True,verbose_name='商品')


    class Meta:
        db_table = 'order_goods'
        verbose_name = '订单商品'
        verbose_name_plural = verbose_name

2. 创建序列化器

class ShoppingCartSerializer(ModelSerializer):
    # 调用get_commodityDetail
    commodityDetail = SerializerMethodField() 

    class Meta:
        model = ShoppingCart
        fields = '__all__'
    
    # 使用对象级别的额外校验：校验加入购物车的商品数量不能大于商品库存数量
    def validate(self,data):
        if data['number'] <=0:
            raise serializers.ValidationError('要购买的商品数量错误')
        elif data['number'] > data['commodity'].stock:
            raise serializers.ValidationError('商品数量超出库存')
        else:
            return data

    def get_commodityDetail(self,shoppingcart):
        return CommodityImgSerializer(shoppingcart.community).data

class OrderCartSerializer(ModelSerializer):
    class Meta:
        model = Order
        fields = '__all__'

3. 创建视图

class ShoppingCartViewSet(ModelViewSet):
    serializer_class = ShoppingCartSerializer
    permission_classes = [IsAuthenticated]
    
    # 返回当前登录用户的购物车数据
    def get_queryset(self):
        # 使用管理器：源模型类小写_set
        return self.request.user.shoppingcart_set.all()
    
    @auto_user #自动将当前登录的用户作为创建者
    def create(self, request, *args, **kwargs):
        return ModelViewSet.create(self, request, *args, **kwargs)

    @update_auto_user
    def update(self, request, *args, **kwargs):
        return ModelViewSet.create(self, request, *args, **kwargs)

    @destory_auto_user
    def destroy(self, request, *args, **kwargs):
        return ModelViewSet.create(self, request, *args, **kwargs)

class OrderCartViewSet(ReadOnlyModelViewSet,CreateModelMixin):
    serializer_class = OrderCartSerializer

    # 返回当前登录用户的数据
    def get_queryset(self):
        # 使用管理器：源模型类小写_set
        return self.request.user.order_set.all()

4. 创建路由


from django.urls import path
from rest_framework.routers import DefaultRouter
from rest_framework_jwt.views import obtain_jwt_token
from .views import *

urlpatterns = []
router = DefaultRouter()
router.register('classifications', ClassificationViewSet)
router.register('commoditys', CommodityViewSet)
router.register('commodity_img', CommodityImgViewSet)
router.register('cart', ShoppingCartViewSet,basename='shoppingcart')
router.register('order', OrderCartViewSet,basename='order')
urlpatterns += router.urls

2. 接口的编写

知识补充：事务

使用场景，保证代码在一个事务中执行，比如购买商品时进行结算，代码执行到一半时突然断电或宕机，所有的事务都要撤销，不能让金额或购物信息出现错误，保证数据的一致性。
在这里插入图片描述

1. 在事务开始时创建保存点

在这里插入图片描述

2. 在事务出现问题时回滚到保存点

在这里插入图片描述

3. 执行成功，提交从保存点到当前的所有事务操作

在这里插入图片描述

使用方法
1. 装饰器用法

在这里插入图片描述##### 2. with语句用法
在这里插入图片描述

1. 重写订单创建接口：事务的实操

在序列化器重写创建，完成自定义的创建功能

class OrderCartSerializer(ModelSerializer):
    # 得到前端传入过来要结算的购物车商品id列表
    cart = serializers.ListField(write_only=True)
    class Meta:
        model = Order
        fields = '__all__'
        # 定义只读字段，不允许前端传入，前端传入有直接通过页面检查修改的风险
        read_only_fields = ['order_id','total_count','total_amount','status','user']


    #在序列化器重写创建，完成自定义的创建功能
    # validated_data保存前端传入的所有数据
    def create(self,validated_data):
        """
        自定义创建订单功能
        """
        #生成订单编号：唯一性，标识性。 日期+时间+六位数的用户id+两位随机数  22位
        #在视图集中self.request参数保存请求对象，在序列化器中是self.context['request']
        user = self.context['request'].user 
        # '%06d%02d'格式化 d表示整数，6表示6位，不够补0
        order_id = datetime.now().strftime('%Y%m%d%H%M%S') + '%06d%02d'%(user.id,randint(1,99))
        # 获取前端传入的支付方式
        pay_method = validated_data.get('pay_method')
        # 如果没有传入id，只传入了地址，说明传入的是假地址
        try:
            address = Address.objects.get(id=validated_data.get('address'))
        except Address.DoesNotExist:
            raise serializers.ValidationError('address error')
        # 格式化收货地址信息
        adress_s = f'{address.province.name}{address.city.name}{address.district.name}{address.place}[{address.receive} 收]{address.mobile}'
        with transaction.atomic():
            #开启事务，在with缩进里面的代码执行完毕之后自动关闭事务，with上下文协议
            # 里面的代码都是在一个原子，事务中
            save_point = transaction.savepoint()#创建保存点
            try:
                #创建订单信息
                order = Order.objects.create(
                    order_id = order_id,
                    total_count=0,
                    total_amount=Decimal('0.00'),
                    pay_method = pay_method,
                    # 支付宝支付，状态待支付。货到付款，状态为代发货 三目运算
                    status = 1 if pay_method == 1 else 2 ,
                    user =user,
                    address =adress_s,

                )

                #获取购物车中要结算的商品
                carts = validated_data.get('cart') #要结算的商品id列表
                for cart_id in carts:
                    try:
                        cart = ShoppingCart.objects.get(id=cart_id)
                    except:
                        transaction.savepoint_rollback(save_point) #回滚到指定保存点
                        raise serializers.ValidationError('购物信息不存在')
                    # 得到购物车中的商品信息，库存数量，销量
                    commodity = cart.commodity #关联查询
                    # 原本的库存与销量
                    origin_stock = commodity.stock
                    origin_sales = commodity.sales
                    #核算 购买的数量是否超过库存
                    if cart.number>origin_stock:
                        raise serializers.ValidationError('库存不足')

                    # 库存操作：减少库存，销量增加
                    new_stock = origin_stock-cart.number
                    new_sales = origin_sales+cart.number
                    # 更新商品信息：模型对象是修改属性调用save方法保存，查询集才是用update方法做修改
                    # 所以这里不用get，用filter
                    Commodity.objects.filter(id=commodity.id).update(stock=new_stock,sales=new_sales)

                    # 创建订单对应的商品数据
                    OrderGoods.objects.create(
                        number=cart.number,
                        price = commodity.price,
                        order=order,
                        commodity=commodity
                    )
                    # 更新订单表
                    order.total_count += cart.number
                    order.total_amount +=(cart.number * commodity.price)
                #保存订单信息
                order.save()
                #清除购物车
                # id__in=carts 查询出id在carts中的数据
                ShoppingCart.objects.filter(id__in=carts).delete()
            except Exception as e:
                transaction.savepoint_rollback(save_point) #回滚到指定保存点
                raise serializers.ValidationError(e) #结束方法 响应给客户端错误信息
            else:
                transaction.savepoint_commit(save_point) #提交保存点的所有信息
        return order

知识补充：悲观锁和乐观锁

并发问题：资源抢夺问题
问题的描述：A商品库存为6，张三加入购物车A商品为6，李四加入购物车A商品为6，两人同时结算支付，因为购买的数量小于等于库存数量，所以都可以支付成功
解决办法： 加锁、队列

1. 悲观锁

悲观锁是mysql级别的锁，需要配合事务进行使用。
BEGIN:
SELECT ‘stock’ FROM ‘commodity’ where ‘id’=1 for UPDATE;
UPDATE ‘commodity’ SET ‘stock’=0 WHERE ‘id’=1;

django实现这个sql语句：
Commodity.objects.select_for_update().get(id=1)

不推荐使用悲观锁，容易死锁。

在这里插入图片描述

2. 乐观锁

.乐观锁为逻辑锁，并不是真实存在的锁
UPDATE ‘commodity’ SET ‘stock’=0 WHERE ‘id’=1 AND ‘stock’=6；

django实现这个sql语句：
Commodity.objects.filter(id=1,stock=6).update(stock=0)
在这里插入图片描述
使用乐观锁，修改代码如下：

class OrderCartSerializer(ModelSerializer):
    # 得到前端传入过来要结算的购物车商品id列表
    cart = serializers.ListField(write_only=True)
    class Meta:
        model = Order
        fields = '__all__'
        # 定义只读字段，不允许前端传入，前端传入有直接通过页面检查修改的风险
        read_only_fields = ['order_id','total_count','total_amount','status','user']


    #在序列化器重写创建，完成自定义的创建功能
    # validated_data保存前端传入的所有数据
    def create(self,validated_data):
        """
        自定义创建订单功能
        """
        #生成订单编号：唯一性，标识性。 日期+时间+六位数的用户id+两位随机数  22位
        #在视图集中self.request参数保存请求对象，在序列化器中是self.context['request']
        user = self.context['request'].user 
        # '%06d%02d'格式化 d表示整数，6表示6位，不够补0
        order_id = datetime.now().strftime('%Y%m%d%H%M%S') + '%06d%02d'%(user.id,randint(1,99))
        # 获取前端传入的支付方式
        pay_method = validated_data.get('pay_method')
        # 如果没有传入id，只传入了地址，说明传入的是假地址
        try:
            address = Address.objects.get(id=validated_data.get('address'))
        except Address.DoesNotExist:
            raise serializers.ValidationError('address error')
        # 格式化收货地址信息
        adress_s = f'{address.province.name}{address.city.name}{address.district.name}{address.place}[{address.receive} 收]{address.mobile}'
        with transaction.atomic():
            #开启事务，在with缩进里面的代码执行完毕之后自动关闭事务，with上下文协议
            # 里面的代码都是在一个原子，事务中
            save_point = transaction.savepoint()#创建保存点
            try:
                #创建订单信息
                order = Order.objects.create(
                    order_id = order_id,
                    total_count=0,
                    total_amount=Decimal('0.00'),
                    pay_method = pay_method,
                    # 支付宝支付，状态待支付。货到付款，状态为代发货 三目运算
                    status = 1 if pay_method == 1 else 2 ,
                    user =user,
                    address =adress_s,

                )

                #获取购物车中要结算的商品
                carts = validated_data.get('cart') #要结算的商品id列表
                for cart_id in carts:
                    while True:
                        try:
                            cart = ShoppingCart.objects.get(id=cart_id)
                        except:
                            transaction.savepoint_rollback(save_point) #回滚到指定保存点
                            raise serializers.ValidationError('购物信息不存在')
                        # 得到购物车中的商品信息，库存数量，销量
                        commodity = cart.commodity #关联查询
                        # 原本的库存与销量
                        origin_stock = commodity.stock
                        origin_sales = commodity.sales
                        #核算 购买的数量是否超过库存
                        if cart.number>origin_stock:
                            raise serializers.ValidationError('库存不足')

                        # 库存操作：减少库存，销量增加
                        new_stock = origin_stock-cart.number
                        new_sales = origin_sales+cart.number
                        # 更新商品信息：模型对象是修改属性调用save方法保存，查询集才是用update方法做修改
                        # 所以这里不用get，用filter
                        
                        res = Commodity.objects.filter(id=commodity.id, stock=origin_stock).update(stock=new_stock,sales=new_sales)
                        # 增加乐观锁,在循环开始用while True:
                        if not res:
                            continue
                        # 创建订单对应的商品数据
                        OrderGoods.objects.create(
                            number=cart.number,
                            price = commodity.price,
                            order=order,
                            commodity=commodity
                        )
                        # 更新订单表
                        order.total_count += cart.number
                        order.total_amount +=(cart.number * commodity.price)

                        break
                #保存订单信息
                order.save()
                #清除购物车
                # id__in=carts 查询出id在carts中的数据
                ShoppingCart.objects.filter(id__in=carts).delete()
            except Exception as e:
                transaction.savepoint_rollback(save_point) #回滚到指定保存点
                raise serializers.ValidationError(e) #结束方法 响应给客户端错误信息
            else:
                transaction.savepoint_commit(save_point) #提交保存点的所有信息
        return order
JiayinX
关注
专栏目录
Django项目使用DRF生成登录图形验证码
09-18
Django项目使用DRF生成登录图形验证码
DRF基本视图——高级过滤
user_san的博客
09-25 444
具体需求说明： 假设请求定义如下，参数bread__gt=100表示过滤出bread阅读量大于100的所有书本返回； 请求方式：GET 请求路径: /books/?bread__gt=100 参考文档链接： drf官方文档： https://www.django-rest-framework.org/ django-filter官方文档链接: https://django-filter.readthedocs.io/en/latest/index.html 1、在views.py文件中，新建一个对应模
django+drf 第九天 购物车，订单管理和支付
qq_40604197的博客
07-06 410
10.1.添加商品到购物车 （1）trade/serializers.py __author__="wtt" from .models import ShoppingCar from rest_framework import serializers from apps.goods.serializers import GoodsSerializer from apps.goods.models import Goods from apps.trade.models import OrderGoods,O
学习DRF
02-25
标题"学习DRF"指的是学习Django REST Framework（DRF），它是一个用于构建Web API的强大框架，基于Python编程语言，并且与Django Web框架紧密结合。DRF提供了一系列工具和功能，使得开发者能够高效地构建RESTful API...
DRF的序列化——Serializers 序列化组件
01-20
为什么要用序列化组件 当我们做前后端分离的项目~~ 我们前后端交互一般都选择JSON数据格式，JSON是一个轻量级的数据交互格式。 那么我们给前端数据的时候都要转成json格式，那就需要对我们从数据库拿到的数据进行...
drf使用及虛擬環境使用
07-28
drf
DRF:学习DRF
03-13
**标题**: 学习DRF (Django Rest Framework) **描述**: Django Rest Framework（DRF）是基于Python的Django Web框架的一个强大扩展，专为构建API而设计。它提供了许多高级功能，使得开发RESTful API变得更加高效和...
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 447
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
点云学习笔记3——读取点云文件、进行统计滤波/直通滤波后可视化
qq_64095888的博客
10-29 185
【代码】点云学习笔记3——读取点云文件、进行统计滤波后可视化。
diffusion model 学习笔记
最新发布
wubing's 博客
11-01 604
郎之万公式: 描述了粒子做随机布朗运动 (粒子位置随时间变化的关系), 是一种 SDE, 描述了 由梯度力(即.即我们在无条件模型 DDPM 估计的噪声中添加一个微小的扰动(. 基本上,在采样一半时,基本上预测的。输出的是噪声的估计, 这个估计的噪声。通过上面的公式，我们可以知道，当知道。),就可以作为条件模型的噪声估计.首先,假设我们已经有了一个训练好的。: 每一步中保留的原始信号的比例。的计算有各种不同的方法，). 已经接近于真实的。)影响的系统的时间演化.也就是,我们训练的网络。
jsp web学习二(比较老的啦)
qq_52122048的博客
10-29 1042
JavaBean模式(MVC)适合开发复杂的web应用，在这种模式下，servlet负责处理用户请求，jsp负责数据显示，javabean负责封装数据。Servlet+JSP+JavaBean模式程序各个模块之间层次清晰，web开发推荐采用此种模式。一个良好的JavaWeb项目架构应该具有以上的11个包，这样显得层次分明，各个层之间的职责也很清晰明了，搭建JavaWeb项目架构时，就。
学习力体系
m0_46221544的博客
10-29 343
在一个小镇上，有一位年轻的学者小明，梦想成为一名科 学家。然而，他总是感到学习困难，知识无法长久保持。有一天，他遇到了一位智者，智者告诉他：“学习的力量能够改变命运。”小明意识到，提升学习力是实现梦想的关键，从此开始探索学习方法的旅程。通过以上方法，小明的学习能力不断提升，最后实现了自己的梦想。每个人都可以通过这些方法来加强自身的学习力，迎接更加美好的未来。怎样才能让知识长久保持？如何有效地提升学习力？
人工智能入门要学习多久？
cd_farsight的博客
10-31 224
人工智能是一个快速发展的领域，新的技术和算法不断涌现。这可能需要你定期投入时间，比如每月至少花费几个小时来跟踪最新的研究和发展。如果你是计算机科学或相关专业的学生，或者对计算机科学有较深的兴趣，可能能更快地掌握。实践项目的时间可以因项目的复杂性和范围而异，通常需要几个月的时间来完成。学习人工智能所需的时间可以根据个人的学习速度、目标和深度有所不同。这通常需要几个月的时间，具体取决于个人的数学背景。：Python是进行人工智能学习的主要语言，建议从基础开始学习，这也是一个月左右的时间可以掌握。
【我的 PWN 学习手札】setcontext + ROP
Mr_Fmnwon的博客
10-28 819
setcontext的gadget能够“恢复上下文”，即设置寄存器的值。除了可以利用其执行shellcode，还可以实现ROP来getshell。本篇介绍了利用setcontext+ROP的方法，ORW地打印flag信息。
Qt中的QCustomPlot学习记录
weixin_51904054的博客
10-29 283
【代码】Qt中的QCustomPlot学习记录。
TypeScript 学习笔记
weixin_57796792的博客
10-29 1110
TypeScript 中文网: https://www.tslang.cn/docs/home.html。
TS学习笔记
Seven_Ting的博客
11-01 234
安装命令第一步：新建index.html和demo.ts第二步：在index.html引入demo.ts文件第三步：运行TS的命令注意：运行命令后，会将ts文件转换成js文件如果想要实时转换运行命令。
SAP ABAP开发学习——第三代增强（BADI)
m0_64077397的博客
10-31 575
打完断点，新开窗口执行VA01，自动跳进debug界面。通过REPORT工具查询。
快速入门并学习uni-app
Zhao_0912的博客
10-31 526
的开发技能，并能够高效地开发跨平台应用。记住，实践是最好的老师，不断动手实践是学习的关键。通过以上步骤，你可以逐步掌握。
DRF框架实操教程：掌握API开发的关键步骤
DRF的ModelSerializer可以自动生成序列化器，但开发者也可以根据需求自定义序列化器。序列化器是处理数据传输过程中的关键部分。 5.定义路由： DRF允许使用专门的Router对象来定义和管理API路由。Router类能够自动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值