DRF实战--用户的购物支付

用户的购物支付

购物车的实现

• views

class ShopCartViewset(viewsets.ModelViewSet):

    serializer_class = ShopCartSerializer
    permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)
    authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)
    # 我们希望让前端通过goods_id来查询数据，实际上在Serializer中我们也会将goods_id返回给前端
    lookup_field = "goods_id"

    def get_serializer_class(self):
        if self.action == 'list':
            return ShopCartDetailSerializer
        else:
            return ShopCartSerializer
        # return ShopCartDetailSerializer

    def get_queryset(self):
        return ShoppingCart.objects.filter(user=self.request.user)

    def perform_create(self, serializer):
        shop_cart = serializer.save()
        goods = shop_cart.goods
        nums = serializer.validated_data['nums']
        goods.goods_num -= nums
        # goods.goods_num -= shop_cart.nums 错了
        goods.save()

    def perform_destroy(self, instance):
        goods = instance.goods
        goods.goods_num += instance.nums
        goods.save()
        instance.delete()

    def perform_update(self, serializer):
        # 修改商品的库存，通过比对购物车更新前后该商品的数量
        # newstorage = oldstorage + (after-before)
        existed_record = ShoppingCart.objects.get(id=serializer.instance.id)
        existed_nums = existed_record.nums
        saved_record = serializer.save()
        nums = saved_record.nums-existed_nums
        goods = saved_record.goods
        goods.goods_num -= nums
        goods.save()

• serializer (重要)

class ShopCartSerializer(serializers.Serializer):
    # 这里不用ModelSerializer的原因是, 这里需要使用user, goods联合索引
    #
    # 我们当然可以使用联合索引来控制唯一性，但问题是，当我们重复添加商品时（只是希望他更新nums字段时（但是实际上是用update方法更新的）），
    # 第二条就会报错，因为会验证失败，所以我们不能再此使用联合索引，而需要使用更加灵活的Serializer并重写create方法
    #
    # 如果是ModelSerializer, 那么重复添加同一个商品时View中继承的CreateMinx中create方法中的验证就会报错 == serializer.is_valid(
    #     raise_exception=True) == 报错（因为是联合索引）
    #
    # 这样就不会再执行serializer.save()
    # 方法保存了，所有这里必须使用Serializer，重写create方法，而不使用联合索引
    #
    # 总结，使用联合索引时，如果需要重复创建商品，但实际上只更新某个字段，CreateMinx中的create方法验证不通过，必须使用Serializer，重写create方法
    user = serializers.HiddenField(
        default=serializers.CurrentUserDefault()
    )
    nums = serializers.IntegerField(required=True,label="数量",min_value=1,
                                    error_messages={
                                        "min_value": "商品数量不能小于一",
                                        "required": "请选择购买数量"
                                    })
    goods = serializers.PrimaryKeyRelatedField(queryset=Goods.objects.all(),required=True)

    # 重写create方法，判断是否存在，存在加1，不存在添加数据
    def create(self, validated_data):
        # 拿到user,nums,good
        user = self.context['request'].user
        nums = validated_data['nums']
        goods = validated_data['goods']

        existed = ShoppingCart.objects.filter(user=user,goods=goods)
        if existed:
            existed = existed[0]
            # existed.objects.update(nums=(nums+1))
            existed.nums += nums
            existed.save()
        else:
            existed = ShoppingCart.objects.create(**validated_data)

        return existed
        
    def update(self, instance, validated_data):
    # 修改商品数量
    instance.nums = validated_data['nums']
    instance.save()
    return instance

注意点一

这里不用ModelSerializer的原因是, 这里需要使用user, goods联合索引

我们当然可以使用联合索引来控制唯一性，但问题是，当我们重复添加商品时（只是希望他更新nums字段时（但是实际上是用update方法更新的）），
第二条就会报错，因为会验证失败，所以我们不能再此使用联合索引，而需要使用更加灵活的Serializer并重写create方法

如果是ModelSerializer, 那么重复添加同一个商品时View中继承的CreateMinx中create方法中的验证就会报错 serializer.is_valid(
raise_exception=True) 报错（因为是联合索引）

这样就不会再执行serializer.save()
方法保存了，所有这里必须使用Serializer，重写create方法，而不使用联合索引

总结，使用联合索引时，如果需要重复创建商品，但实际上只更新某个字段，CreateMinx中的create方法验证不通过，必须使用Serializer，重写create方法

注意点二

serializer中使用外键字段，参考官方文档可知

goods = serializers.PrimaryKeyRelatedField(queryset=Goods.objects.all(),required=True)

这里的外键与直接写一个类不同的是，只会将主键（goods_id）返回给前端，而不是返回goods中的所有字段。

注意点三

init_data 指的是最原始的没有经过验证的数据

validated_data 指定是已经验证转换过的数据，比如nums已经验证无误并转换成了int类型

注意点四

这里取出user,是从self.context[‘request’].user中取出来的

注意点五

goods = validated_data['goods']

这里取出的goods是Good对象

注意点六

创建的时候使用的是**validated_data,并将创建的实例返回

existed =ShoppingCart.objects.create(**validated_data)
return existed

注意点七

如果要更新数据，serializer中必须重新update方法，该方法在BaseSerializer中,Serializer继承时并没有重写，所以需要我们手动重写

添加显示商品的购物车列表的serializer，用于返回带商品数据购物车信息

class ShopCartDetailSerializer(serializers.ModelSerializer):
    # 每个用户下的相同商品只会存在一条纪录
    goods = GoodsSerializer(many=False, read_only=True)
    class Meta:
        model = ShoppingCart
        fields = ("goods", "nums")

注意:每个用户下的相同商品只会存在一条纪录，所以many=False

重写get_serializer_class 动态获取类

  def get_serializer_class(self):
        if self.action == 'list':
            return ShopCartDetailSerializer
        else:
            return ShopCartSerializer
    #    return ShopCartDetailSerializer

订单

• views

class OrderViewset(mixins.ListModelMixin, mixins.RetrieveModelMixin, mixins.CreateModelMixin, mixins.DestroyModelMixin,
                   viewsets.GenericViewSet):
    """
    订单管理
    list:
        获取个人订单
    delete:
        删除订单
    create：
        新增订单
    """
    permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)
    authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)
    serializer_class = OrderSerializer

    def get_queryset(self):
        return OrderInfo.objects.filter(user=self.request.user)

    def get_serializer_class(self):
        # delete不会调用这个方法
        print('......',self.action)
        if self.action == "retrieve":
            return OrderDetailSerializer
        return OrderSerializer

    def perform_create(self, serializer):
        order = serializer.save()
        shop_carts = ShoppingCart.objects.filter(user=self.request.user)
        for shop_cart in shop_carts:
            order_goods = OrderGoods()
            order_goods.goods = shop_cart.goods
            order_goods.goods_num = shop_cart.nums
            order_goods.order = order
            order_goods.save()

            shop_cart.delete()
        return order

• serializers

class OrderSerializer(serializers.ModelSerializer):
    user = serializers.HiddenField(
        default=serializers.CurrentUserDefault()
    )
    # 不允許前端提交
    pay_status = serializers.CharField(read_only=True)
    trade_no = serializers.CharField(read_only=True)
    order_sn = serializers.CharField(read_only=True)
    pay_time = serializers.DateTimeField(read_only=True)
    # alipay_url = serializers.SerializerMethodField(read_only=True)

    # def get_alipay_url(self, obj):
    #     alipay = AliPay(
    #         appid="",
    #         app_notify_url="http://127.0.0.1:8000/alipay/return/",
    #         app_private_key_path=private_key_path,
    #         alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
    #         debug=True,  # 默认False,
    #         return_url="http://127.0.0.1:8000/alipay/return/"
    #     )
    #
    #     url = alipay.direct_pay(
    #         subject=obj.order_sn,
    #         out_trade_no=obj.order_sn,
    #         total_amount=obj.order_mount,
    #     )
    #     re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(data=url)
    #
    #     return re_url

    def generate_order_sn(self):
        # 当前时间+userid+随机数
        from random import Random
        random_ins = Random()
        order_sn = "{time_str}{userid}{ranstr}".format(time_str=time.strftime("%Y%m%d%H%M%S"),
                                                       userid=self.context["request"].user.id, ranstr=random_ins.randint(10, 99))
        return order_sn

    def validate(self, attrs):
        attrs["order_sn"] = self.generate_order_sn()
        return attrs

    class Meta:
        model = OrderInfo
        fields = "__all__"

class OrderDetailSerializer(serializers.ModelSerializer):
    # 注意，这个goods其实是ordergoods，是与OrderInfo表关联的
    goods = OrderGoodsSerialzier(many=True)
    # alipay_url = serializers.SerializerMethodField(read_only=True)

    # def get_alipay_url(self, obj):
    #     alipay = AliPay(
    #         appid="",
    #         app_notify_url="http://127.0.0.1:8000/alipay/return/",
    #         app_private_key_path=private_key_path,
    #         alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
    #         debug=True,  # 默认False,
    #         return_url="http://127.0.0.1:8000/alipay/return/"
    #     )
    #
    #     url = alipay.direct_pay(
    #         subject=obj.order_sn,
    #         out_trade_no=obj.order_sn,
    #         total_amount=obj.order_mount,
    #     )
    #     re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(data=url)
    #
    #     return re_url

    class Meta:
        model = OrderInfo
        fields = "__all__"
        
    class OrderGoodsSerialzier(serializers.ModelSerializer):
    # 每个订单下的相同商品只会存在一条纪录	
    goods = GoodsSerializer(many=False)
    class Meta:
        model = OrderGoods
        fields = "__all__"