lf 前后端分离 (6) 支付

支付

 import datetime

 from django.core.exceptions import ObjectDoesNotExist

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

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

 class PaymentView(APIView):
     '''
        模拟请求数据格式：

          {
          is_beli:true,
          course_list=[
                      {  course_id:1
                       default_price_policy_id:1,
                       coupon_record_id:2
                       },
                      { course_id:2
                       default_price_policy_id:4,
                       coupon_record_id:6
                       }
                   ],
           global_coupon_id:3,
           pay_money:298

           }

         状态码：
             1000:  成功
             1001:  课程不存在
             1002:  价格策略不合法
             1003:  加入购物车失败
             1004:  获取购物车失败
             1005:  贝里数有问题
             1006:  优惠券异常
             1007:  优惠券未达到最低消费
             1008:  支付总价格异常

        '''
     authentication_classes = [LoginAuth]

     def get_alipay(self):
         # 沙箱环境地址：https://openhome.alipay.com/platform/appDaily.htm?tab=info
         app_id = ""
         # POST请求，用于最后的检测
         notify_url = "http://47.94.172.250:8804/page2/"
         # notify_url = "http://www.wupeiqi.com:8804/page2/"
         # GET请求，用于页面的跳转展示
         return_url = "http://47.94.172.250:8804/page2/"
         # return_url = "http://www.wupeiqi.com:8804/page2/"
         merchant_private_key_path = "keys/app_private_2048.txt"
         alipay_public_key_path = "keys/alipay_public_2048.txt"

         alipay = AliPay(
             appid=app_id,
             app_notify_url=notify_url,
             return_url=return_url,
             app_private_key_path=merchant_private_key_path,
             alipay_public_key_path=alipay_public_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥
             debug=True,  # 默认False,
         )
         return alipay

     def cal_coupon_price(self, price, coupon_record_obj):
         coupon_type = coupon_record_obj.coupon.coupon_type
         money_equivalent_value = coupon_record_obj.coupon.money_equivalent_value
         off_percent = coupon_record_obj.coupon.off_percent
         minimum_consume = coupon_record_obj.coupon.minimum_consume
         rebate_price = 0
         if coupon_type == 0:  # 立减券
             rebate_price = price - money_equivalent_value
             if rebate_price <= 0:
                 rebate_price = 0
         elif coupon_type == 1:  # 满减券
             if minimum_consume > price:
                 raise CommonException(1007, "优惠券未达到最低消费")
             else:
                 rebate_price = price - money_equivalent_value
         elif coupon_type == 2:
             rebate_price = price * off_percent / 100

         return rebate_price

     def post(self, request):
         print(request.data)
         response = BaseResponse()
         #         1.获取数据

         user_id = request.user.pk
         global_coupon_id = request.data.get("global_coupon_id")
         pay_money = request.data.get("pay_money")
         course_list = request.data.get("course_list")
         is_beli = request.data.get("is_beli")
         now = datetime.datetime.now()

         try:
             # 2 校验数据
             # 2.2 校验课程

             course_price_list = []
             for course_dict in course_list:
                 # 2.2.1 校验课程id
                 course_id = course_dict.get("course_id")
                 course_obj = Course.objects.get(pk=course_id)
                 # 2.2.2 价格策略id
                 if course_dict.get("default_price_policy_id") not in [obj.pk for obj in course_obj.price_policy.all()]:
                     raise CommonException(1002, "价格策略异常")
                 # 2.2.3 课程优惠券id
                 price_policy_obj = PricePolicy.objects.get(pk=course_dict.get("default_price_policy_id"))
                 course_dict["original_price"] = price_policy_obj.price
                 course_dict["valid_period_display"] = price_policy_obj.get_valid_period_display()
                 course_dict["valid_period"] = price_policy_obj.valid_period
                 coupon_record_id = course_dict.get("coupon_record_id")
                 if coupon_record_id:
                     coupon_record_list = CouponRecord.objects.filter(account=request.user,
                                                                      status=0,
                                                                      coupon__valid_begin_date__lte=now,
                                                                      coupon__valid_end_date__gte=now,
                                                                      coupon__content_type_id=9,
                                                                      coupon__object_id=course_id
                                                                      )
                     print("coupon_record_id", coupon_record_id)
                     print([obj.pk for obj in coupon_record_list])
                     # 默认获取没有选择的优惠券和筛选后优劵
                     if coupon_record_id not in [obj.pk for obj in coupon_record_list]:
                         raise CommonException(1006, "课程优惠劵异常")
                     # 计算循环课程的课程优惠券优惠后的价格
                     coupon_record_obj = CouponRecord.objects.get(pk=coupon_record_id)
                     rebate_price = self.cal_coupon_price(price_policy_obj.price, coupon_record_obj)
                     course_price_list.append(rebate_price)
                     course_dict["rebate_price"] = rebate_price
                 else:
                     course_price_list.append(price_policy_obj.price)

             #             2.3 校验通用优惠券id
             global_coupon_record_list = CouponRecord.objects.filter(account=request.user,
                                                                     status=0,
                                                                     coupon__valid_begin_date__lte=now,
                                                                     coupon__valid_end_date__gte=now,
                                                                     coupon__content_type_id=9,
                                                                     coupon__object_id=None
                                                                     )
             print("global_coupon_record_list", global_coupon_record_list)

             if global_coupon_id:
                 if global_coupon_id not in [obj.pk for obj in global_coupon_record_list]:
                     raise CommonException("通用优惠券异常", 1006)
                 global_coupon_record_obj = CouponRecord.objects.get(pk=global_coupon_id)
                 final_price = self.cal_coupon_price(sum(course_price_list), global_coupon_record_obj)
             else:
                 final_price = sum(course_price_list)
             #     2.4 计算实际支付价格与money 校验
             if is_beli:
                 final_price = final_price - request.user.beli / 10
                 if final_price < 0:
                     final_price = 0
                 print(final_price)

             if final_price != float(pay_money):
                 raise CommonException("支付总价格异常！", 1008)

         #     4.调用alipay 接口
             alipay = self.get_alipay()
             query_params = alipay.direct_pay(
                 subject="路飞学成",
                 out_trade_no="x345" + str(datetime.datetime.now()),
                 total_amount=pay_money,
             )
             pay_url = "https://openapi.alipaydev.com/gateway.do?{}".format(query_params)
             response.data = {
                 "url": pay_url
             }

         except ObjectDoesNotExist as e:
             response.code = 1001
             response.msg = "课程不存在！"
         except CommonException as e:
             response.code = e.code
             response.msg = e.msg
         # except Exception as e:
         #     response.code = 500
         #     response.msg = str(e)

         return Response(response.dict)

pay