lf 前后端分离 (5) 优惠券

关于优惠券

优惠券主要通过前端传回来的course_id_list 创建数据结构

首先清空操作,将所有的优惠券清空,

并将所有优惠劵放到redis中的过程

 import datetime
 import json
 import redis

 REDIS_CONN = redis.Redis(decode_responses=True)

 from rest_framework.views import APIView
 from rest_framework.response import Response

 from app01.models import *
 from app01.utils.auth import LoginAuth
 from app01.utils.response import BaseResponse
 from app01.utils.exception import CommonException

 from django.core.exceptions import ObjectDoesNotExist
 from django.conf import settings

 class AccountView(APIView):
     authentication_classes = [LoginAuth]

     def get_coupon_dict(self, request, course_id=None):
         now = datetime.datetime.now()
         coupon_record_list = CouponRecord.objects.filter(
             account=request.user,
             coupon__content_type=9,
             coupon__object_id=course_id,
             status=0,
             coupon__valid_begin_date__lte=now,
             coupon__valid_end_date__gte=now
         )
         coupons = {}

         for coupon_record in coupon_record_list:
             coupons[coupon_record.pk] = {

                 "pk": coupon_record.pk,
                 "name": coupon_record.coupon.name,
                 "coupon_type": coupon_record.coupon.get_coupon_type_display(),
                 "money_equivalent_value": coupon_record.coupon.money_equivalent_value,
                 "off_percent": coupon_record.coupon.off_percent,
                 "minimum_consume": coupon_record.coupon.minimum_consume,
                 "valid_begin_date": coupon_record.coupon.valid_begin_date.strftime("%Y-%m-%d"),
                 "valid_end_date": coupon_record.coupon.valid_end_date.strftime("%Y-%m-%d"),
             }
         print("coupons", coupons)

         return coupons

     def post(self, request, *args, **kwargs):
         # 1 获取数据
         user = request.user
         course_id_list = request.data.get("course_id_list")
         response = BaseResponse()
         try:
             # 2 创建数据结构
             # 清空操作
             # 找到所有以account_userid_*，全部清空
             del_list = REDIS_CONN.keys(settings.ACCOUNT_KEY % (user.pk, "*"))
             if del_list:
                 REDIS_CONN.delete(*del_list)

             price_list = []
             for course_id in course_id_list:

                 account_key = settings.ACCOUNT_KEY % (user.pk, course_id)
                 account_dict = {}
                 shopping_car_key = settings.SHOPPING_CAR_KEY % (user.pk, course_id)

                 # 判断课程是否存在购物车中
                 if not REDIS_CONN.exists(shopping_car_key):
                     raise CommonException("购物车不存在该课程", 1040)

                 # 将课程信息加入到每一个课程结算字典中
                 course_info = json.loads(REDIS_CONN.get(shopping_car_key))
                 account_dict["course_info"] = course_info

                 # 课程价格加入到价格列表
                 price_list.append(float(course_info["default_price"]))

                 # 查询当前用户拥有未使用的，在有效期的且与当前课程相关的优惠券
                 account_dict["course_coupons"] = self.get_coupon_dict(request, course_id)

                 # 存储结算信息
                 REDIS_CONN.set(account_key, json.dumps(account_dict))

                 print("account_dict",account_dict)

             # 获取通用优惠券,加入redis中

             REDIS_CONN.set("global_coupon_%s" % user.pk, json.dumps(self.get_coupon_dict(request)))
             REDIS_CONN.set("total_price", sum(price_list))

         except CommonException as e:
             response.code = e.code
             response.msg = e.msg

         except ObjectDoesNotExist as e:
             response.code = 1001
             response.msg = "课程不存下"

         return Response(response.dict)

     def get(self, request, *args, **kwargs):

         res = BaseResponse()
         try:
             # 1 取到user_id
             user_id = request.user.id
             # 2 拼接购物车的key
             account_key = settings.ACCOUNT_KEY % (user_id, "*")
             # shopping_car_1_*
             # shopping_car_1_asdgnlaksdj
             # 3 去redis读取该用户的所有加入购物车的课程
             # 3.1 先去模糊匹配出所有符合要求的key
             all_keys = REDIS_CONN.scan_iter(account_key)

             # 3.2 循环所有的keys 得到每个可以
             account_course_list = []
             for key in all_keys:

                 course = json.loads(REDIS_CONN.get(key))
                 temp = {}
                 for key, val in course["course_info"].items():
                     temp[key] = val
                 coupon_list = []
                 for key, val in course["course_coupons"].items():
                     val["pk"] = key
                     coupon_list.append(val)
                 temp["coupon_list"] = coupon_list

                 account_course_list.append(temp)

             global_coupons_dict = json.loads(REDIS_CONN.get("global_coupon_%s" % request.user.pk))
             total_price = REDIS_CONN.get("total_price")
             global_coupons = []
             for key, val in global_coupons_dict.items():
                 global_coupons.append(val)
             res.data = {
                 "account_course_list": account_course_list,
                 "total": len(account_course_list),
                 "global_coupons": global_coupons,
                 "total_price": total_price
             }

         except Exception as e:
             res.code = 1033
             res.error = "获取购物车失败"

         return Response(res.dict)

     def cal_coupon_price(self,price,coupon_info):

         coupon_type=coupon_info["coupon_type"]
         money_equivalent_value=coupon_info.get("money_equivalent_value")
         off_percent=coupon_info.get("off_percent")
         minimum_consume=coupon_info.get("minimum_consume")
         rebate_price=0
         if coupon_type == "立减券": # 立减券
             rebate_price=price-money_equivalent_value
             if rebate_price <= 0:
                 rebate_price=0
         elif coupon_type == "满减券": # 满减券
              if minimum_consume > price:
                  raise CommonException(3000,"优惠券未达到最低消费")
              else:
                  rebate_price=price-money_equivalent_value
         elif coupon_type == "折扣券":
             print("VVVV",price,off_percent)
             rebate_price=price*off_percent/100

         return rebate_price

     def put(self,request, *args, **kwargs):
         '''
         choose_coupons:
             {
             choose_coupons={"1":"2","2":"3","global_coupon_id":5}
             is_beli:true
             }
         '''
         res=BaseResponse()
         try:

             # 1 获取数据
             choose_coupons=request.data.get("choose_coupons")
             is_beli=request.data.get("is_beli")
             user_pk=request.user.pk

             # 2 获取结算课程列表
             cal_price={}
             data=self.get(request).data.get("data")
             account_course_list=data.get("account_course_list")
             account_course_info={}
             for account_course in account_course_list:
                 temp={
                     "coupons":{},
                     "default_price":account_course["default_price"]
                 }
                 account_course_info[account_course["id"]]=temp

                 for item in account_course["coupon_list"]:
                     temp["coupons"][item["pk"]]=item

             print("account_course_info",account_course_info)

             price_list=[]
             total_price=0
             for key,val in account_course_info.items():
                 if str(key) not in choose_coupons:
                     price_list.append(val["default_price"])
                     cal_price[key]=val["default_price"]
                 else:
                     coupon_info=val.get("coupons").get(str(choose_coupons[str(key)]))
                     rebate_price=self.cal_coupon_price(val["default_price"],coupon_info)
                     price_list.append(rebate_price)
                     cal_price[key]=rebate_price

             print("课程优惠券后价格列表price_list",price_list)
             total_price=sum(price_list)
             # 3 计算通用优惠券的价格
             global_coupon_id=choose_coupons.get("global_coupon_id")
             if global_coupon_id:

                 global_coupons=data.get("global_coupons")
                 print("global_coupons",global_coupons)
                 global_coupon_dict={}
                 for item in global_coupons:
                     global_coupon_dict[item["pk"]]=item

                 total_price=self.cal_coupon_price(total_price,global_coupon_dict[global_coupon_id])
                 print("通用优惠券",global_coupon_dict[global_coupon_id]["coupon_type"])
                 print("计算后total_price=",total_price)

             # 计算贝里
             if json.loads(is_beli):
                 total_price=total_price-request.user.beli/10
                 if total_price<0:
                     total_price=0
                 print("贝里数计算后",total_price)

             #res.total_price=total_price
             cal_price["total_price"]=total_price
             res.data=cal_price

         except Exception as e:
             res.code=500
             res.msg="结算错误!"+str(e)

         return Response(res.dict)

优惠券