接口整理

一.课程接口

class CourseModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=Course
        fields="__all__"
    level=serializers.CharField(source="get_level_display")
    coursedetail_id=serializers.IntegerField(source="coursedetail.id")

class CoursesView(mixins.ListModelMixin,mixins.CreateModelMixin,generics.GenericAPIView):
    queryset = Course.objects.all()
    serializer_class = CourseModelSerializer
    def get(self, request, *args, **kwargs):
        response=self.list(self, request, *args, **kwargs)
        response["Access-Control-Allow-Origin"] = "*"
        response["Access-Control-Allow-Headers"] = "Content-Type"
        return response

课程接口数据结构

[
    {
        "id": 1,
        "level": "初级",
        "coursedetail_id": 1,
        "name": "Python开发21天入门",
        "course_img": "https://hcdn1.luffycity.com/static/frontend/course/5/21%E5%A4%A9_1544059695.5584881.jpeg",
        "course_type": 0,
        "brief": "Python开发21天入门的课程概述",
        "pub_date": "2018-12-01",
        "period": 7,
        "order": 1,
        "attachment_path": null,
        "status": 0
    },
    {
        "id": 2,
        "level": "中级",
        "coursedetail_id": 2,
        "name": "Linux系统基础五周精讲",
        "course_img": "https://hcdn1.luffycity.com/static/frontend/course/12/Linux_1544069008.0915537.jpeg",
        "course_type": 1,
        "brief": "Linux系统基础五周精讲的课程概述",
        "pub_date": "2018-12-02",
        "period": 5,
        "order": 2,
        "attachment_path": null,
        "status": 0
    },
    {
        "id": 3,
        "level": "高级",
        "coursedetail_id": 3,
        "name": "Django入门与实践",
        "course_img": "https://hcdn1.luffycity.com/static/frontend/course/42/git-pc%E5%88%97%E8%A1%A8_1544420927.8406003.jpeg",
        "course_type": 2,
        "brief": "Django入门与实践的课程概述",
        "pub_date": "2018-12-03",
        "period": 23,
        "order": 3,
        "attachment_path": null,
        "status": 0
    }
]

二.课程详情接口

class CourseDetailModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=CourseDetail
        fields="__all__"
    name=serializers.CharField(source="course.name")
    prices=serializers.SerializerMethodField()
    teachers=serializers.SerializerMethodField()
    brief=serializers.CharField(source="course.brief")
    stay_all_time=serializers.CharField(source="hours")
    level=serializers.CharField(source="course.get_level_display")
    teachers_info=serializers.SerializerMethodField()
    is_online=serializers.CharField(source="course.get_status_display")
    recommend_coursesinfo=serializers.SerializerMethodField()
    def get_teachers(self,coursedetail_obj):
        s=""
        for obj in coursedetail_obj.teachers.all():
            s=s+obj.name
        return s
    def get_prices(self,coursedetail_obj):
        price_policy_queryset=coursedetail_obj.course.price_policy.all()
        print(price_policy_queryset)
        return [{"price":price_policy.price,"valid_period":price_policy.get_valid_period_display()} for price_policy in price_policy_queryset]
    def get_teachers_info(self,coursedetail_obj):
        teachers_queryset=coursedetail_obj.teachers.all()
        return [{"name":teacher.name,"brief":teacher.brief,"image":teacher.image} for teacher in  teachers_queryset]
    def get_recommend_coursesinfo(self,coursedetail_obj):
        recommend_courses_queryset=coursedetail_obj.recommend_courses.all()
        return [{"name": recommend_courses.name, "pk": recommend_courses.pk} for recommend_courses in recommend_courses_queryset]

class CourseDetailView(mixins.RetrieveModelMixin,generics.GenericAPIView):
    queryset = CourseDetail.objects.all()
    serializer_class = CourseDetailModelSerializer
    def get(self, request, *args, **kwargs):
        response=self.retrieve(self, request, *args, **kwargs)
        response["Access-Control-Allow-Origin"] = "*"
        response["Access-Control-Allow-Headers"] = "Content-Type"
        return response

课程详情接口数据结构

{
    "id": 1,
    "name": "Python开发21天入门",
    "prices": [
        {
            "price": 100,
            "valid_period": "1个月"
        },
        {
            "price": 200,
            "valid_period": "2个月"
        },
        {
            "price": 300,
            "valid_period": "3个月"
        }
    ],
    "teachers": "alex",
    "brief": "Python开发21天入门的课程概述",
    "stay_all_time": "7",
    "level": "初级",
    "teachers_info": [
        {
            "name": "alex",
            "brief": "alex的Brief",
            "image": "https://hcdn1.luffycity.com/static/frontend/course/46/Zabbiix-pc%E5%88%97%E8%A1%A8_1544431586.4417293.jpeg"
        }
    ],
    "is_online": "上线",
    "recommend_coursesinfo": [
        {
            "name": "Linux系统基础五周精讲",
            "pk": 2
        }
    ],
    "hours": 7,
    "course_slogan": "Python开发21天入门的Course slogan",
    "video_brief_link": "Python开发21天入门的Video brief link:",
    "why_study": "Python开发21天入门的学习原因",
    "what_to_study_brief": "Python开发21天入门的学习内容",
    "career_improvement": "Python开发21天入门的此项目如何有助于我的职业生涯:",
    "prerequisite": "Python开发21天入门的先修要求",
    "course": 1,
    "recommend_courses": [
        2
    ]
}

三.登录接口

class LoginView(APIView):
    def post(self,request):
        user=request.data.get("user")
        pwd=request.data.get("pwd")
        user_obj=authenticate(username=user,password=pwd)
        res={"user": None, "msg": None}
        if user_obj:
            random_str=uuid.uuid4()
            Token.objects.update_or_create(user=user_obj,defaults={"key":random_str,"created":datetime.datetime.now()})
            res["user"]=user_obj.username
            res["token"]=random_str
        else:
            res["msg"]="用户名或密码错误"
        return Response(res)

四.认证接口

class AuthUser(BaseAuthentication):
    def authenticate(self, request):
        token=request.META.get("HTTP_AUTHORIZATION")
        token_obj=Token.objects.filter(key=token).first()
        if not token_obj:
            raise AuthenticationFailed("验证失败!")
        return (token_obj.user,token_obj)

在需要热认证的接口中加上

authentication_classes = [AuthUser]

五.token的缓存与时效

Django自带的cache,用来缓存,默认缓存到内存中

from django.core.catch import cache
cache.set("name","shy",5)#存储时间为5秒钟
catch.get("name")  #shy

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from django.core.cache import cache
from app01.models import Token
import datetime
import pytz
#认证
class AuthUser(BaseAuthentication):
    def authenticate(self, request):
        token=request.META.get("HTTP_AUTHORIZATION")
        token_obj=Token.objects.filter(key=token).first()
        print('token_obj',token_obj)
        print('token_obj',type(token_obj))
        if not token_obj:
            raise AuthenticationFailed("验证失败!")
        #检验token是否正确
        token_obj=Token.objects.filter(key=token).first()
        if token_obj:
        # 校验是否在有效期内
            now=datetime.datetime.now()
            now=now.replace(tzinfo=pytz.timezone("UTC"))
            state=now-token_obj.created<datetime.timedelta(weeks=2)
            if state:
                delta = now - token_obj.created
                delta = datetime.timedelta(weeks=2) - delta
                #缓存时间不能太长,七天
                cache.set(token_obj.key,token_obj.user,min(60*60*24*7,delta.total_seconds()))
                return (token_obj.user,token_obj)
            else:
                raise AuthenticationFailed("认证超时")

六.登录接口

from rest_framework.views import APIView

from rest_framework.response import Response
from app01.models import UserInfo,Token
from django.contrib.auth import authenticate
from django.http import HttpResponse
from app01.utils.response import BaseResponse
import uuid
import datetime
#登录接口
class LoginView(APIView):
    def post(self,request):
        resture=BaseResponse()
        user=request.data.get("username")
        pwd=request.data.get("password")
        print(user,pwd)
        user_obj=authenticate(username=user,password=pwd)
        res={"user": None, "msg": None}
        if user_obj:
            random_str=uuid.uuid4()
            Token.objects.update_or_create(user=user_obj,defaults={"key":random_str,"created":datetime.datetime.now()})
            res["user"]=user_obj.username
            res["token"]=random_str
            resture.data=res
            resture.code=1000
        else:
            res["msg"]="用户名或密码错误"
            resture.msg="用户名或密码错误"
            resture.code = 1003
        print(res)
        return Response(resture.dict())

    def get(self,request):
        return HttpResponse("ok")

七.级验接口

from rest_framework.views import APIView
from app01.utils.geetest import GeeTestLib
from django.conf import settings
import json
from rest_framework.response import Response


class CaptchaView(APIView):
    def get(self, request):
        gt = GeeTestLib(settings.GEE_TEST["gee_test_access_id"], settings.GEE_TEST["gee_test_access_key"])
        gt.pre_process()
        # 设置 geetest session, 用于是否启用滑动验证码向 geetest 发起远程验证, 如果取不到的话只是对本地轨迹进行校验
        # self.request.session[gt.GT_STATUS_SESSION_KEY] = status
        # request.session["user_id"] = user_id
        response_str = gt.get_response_str()
        response_str = json.loads(response_str)

        return Response({"error_no": 0, "data": response_str})

八.购物车接口

from app01.models import *
from app01.utils.response import BaseResponse
from app01.utils.exception import PricePoliceError

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

from rest_framework.views import APIView
from rest_framework.response import Response
import json
import redis
pool = redis.ConnectionPool(port=6379,decode_responses=True)
cache=redis.Redis(connection_pool=pool)

class ShoppingcartView(APIView):
    #还没加认证
    def post(self,request):
        #前端数据
        #课程id
        course_id=request.POST.get("course_id")
        #价格策略id
        price_policy_id=request.POST.get("price_policy_id")
        # print(course_id,price_policy_id)

        #用户id先写死1
        # user_id=request.user.id
        user_id=request.user.id
        #校验数据
        res = BaseResponse()
        try:
            #校验课程是否存在
            course_obj=Course.objects.get(pk=course_id)
            #校验价格策略是否合法

            price_policy_dict = {}
            for price_policy in course_obj.price_policy.all():
                price_policy_dict[price_policy.pk] = {
                    "pk": price_policy.pk,
                    "valid_period": price_policy.valid_period,
                    "valid_period_text": price_policy.get_valid_period_display(),
                    "price": price_policy.price,
                    "default": price_policy_id == price_policy.pk
                }

            print("price_policy_dict", price_policy_dict)

            if int(price_policy_id) not in [obj.pk for obj in course_obj.price_policy.all()]:
                raise PricePoliceError
        except ObjectDoesNotExist as e:
            res.code=1001
            res.msg="课程不存在"
        except PricePoliceError as e:
            res.code = 1002
            res.msg = "价格策略错误"

        #将购物车信息写入redis
        '''
        redis数据结构
        redis={
            shoppingcar_userid_course_id:{
                title:'',
                img:'',
            },
            shoppingcar_1_1:{
                title:'',
                img:'',
            },
            shoppingcar_1_2:{
                title:'',
                img:'',
            }
        }
        '''
        pp = PricePolicy.objects.get(pk=price_policy_id)
        #将这个人的购物车信息存到redis中
        shoppingcar_key=settings.SHOPPINGCAR_KEY%(user_id,course_id)
        shoppingcar_val={
            "id":course_obj.pk,
            "name":course_obj.name,
            "course_img":course_obj.course_img,
            "relate_price_policy": price_policy_dict,
            "choose_price_policy_id": price_policy_id,
            "default_price": pp.price,
            "valid_period": pp.valid_period,
            "valid_period_text": pp.get_valid_period_display(),
        }
        cache.set(shoppingcar_key, json.dumps(shoppingcar_val))
        # cache.set(shoppingcar_key, [0,1])
        res.data = "加入购物车成功！"
        print("执行完了")
        res.data=shoppingcar_val
        return Response(res.dict())

    def get(self,request):
        res = BaseResponse()
        # cache.delete("shoppingcar_1_3")
        # cache.delete("shoppingcar_1_1")

        shopping_car_keys_list=cache.keys(pattern='shoppingcar_%s_*' % (request.user.id,))
        print(shopping_car_keys_list)
        shopping_car_list=[]
        num=0
        for key in shopping_car_keys_list:
            dict=json.loads(cache.get(key))
            shopping_car_list.append(dict)
            num=num+1
        total=num

        res.data= {
            "total": total,
            "shopping_car_list":shopping_car_list ,
                  }
        res.code= 1000,
        res.msg=""
        return Response(res.dict())

'''
理想数据类型
"shopping_car_list": [

                {
                    "id": 4,
                    "default_price_period": 30,
                    "relate_price_policy": {
                        "4": {
                            "valid_period": 30,
                            "valid_period_text": "1个月",
                            "default": True,
                            "prcie": 1000
                        },
                        "5": {
                            "valid_period": 60,
                            "valid_period_text": "2个月",
                            "default": False,
                            "prcie": 1500
                        }
                    },
                    "name": "Linux系统基础5周入门精讲",
                    "course_img": "https://luffycity.com/static/frontend/course/12/Linux5周入门_1509589530.6144893.png",
                    "default_price": 1000
                }
            ]
        },
'''

九.结算接口

from app01.models import *
from app01.utils.response import BaseResponse
from app01.utils.exception import PricePoliceError
from app01.utils.exception import CommonException

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

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

import redis
import json
import datetime
cache=redis.Redis(decode_responses=True)

class AccountView(APIView):
    # authentication_classes = [LoginAuth]
    def get_coupon_list(self, request, course_id=None):
        # print('11111111111112222222',course_id)
        now = datetime.datetime.utcnow()
        # course_id=str(course_id)
        coupon_record_list = CouponRecord.objects.filter(
            #####################3改
            account=1,
            status=0,
            coupon__valid_begin_date__lte=now,
            coupon__valid_end_date__gt=now,
            coupon__content_type_id=9,
            coupon__object_id=course_id

        )

        coupon_list = []

        for coupon_record in coupon_record_list:
            coupon_list.append({

                "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,
            })
        # print('coupon_list-----',coupon_list)
        return coupon_list

    def get(self,request):
        res = BaseResponse()
        try:

            account_key = settings.ACCOUNT_KEY % (request.user.id, "*")

            all_keys = cache.scan_iter(account_key)
            print('all_keys',all_keys)
            # 3.2 循环所有的keys 得到每个可以
            account_course_list = []
            for key in all_keys:
                account_course = json.loads(cache.get(key))
                account_course_list.append(account_course)
            # print('account_course_list',account_course_list)
            global_coupons_detail=cache.get("global_coupons_%s" % request.user.id)
            # print("global_coupons_detail-----------",global_coupons_detail)
            global_coupons = json.loads(str(global_coupons_detail))
            global_coupons_list=[]
            # print('global_coupons',global_coupons)
            for val in global_coupons:
                global_coupons_list.append(val)
            # print('global6565',global_coupons_list)
            # total_price = cache.get("total_price")
            # print(11111111)
            total_price =0
            #对account_course_list的处理
            new_account_course_list=[]
            print(account_course_list)
            for item in account_course_list:
                new_account_course_dict=item["course_info"]
                coupons=item["coupons"]
                new_account_course_dict["coupon_list"]=coupons
                new_account_course_list.append(new_account_course_dict)

                # print('-----------',item["default_price"])
                total_price +=int(item["course_info"]["default_price"])
                print(total_price)

            res.data = {
                "account_course_list": new_account_course_list,
                "total": len(account_course_list),
                "global_coupons": global_coupons_list,
                "total_price": total_price
            }
            # print("res.data",res.data)
        except Exception as e:
            print('----------------',e)
            res.code = 1033
            res.error = "获取购物车失败"

        return Response(res.dict())

    def post(self,request):
        #获取数据
        course_id_list=request.data.get("course_id_list")
        print(course_id_list)
        #校验数据
            #有可能直接购买,也有可能在购物车中购买
        res = BaseResponse()
        #构建结算字典
        account_val = {}
        course_info={}
        res.data = {}
        try:
            for course_id in course_id_list:
                account_key=settings.ACCOUNT_KEY%(request.user.id,course_id)
                #校验课程是否存在
                course_obj=Course.objects.get(pk=course_id)
                #            用户id先写死为1
                #1.课程信息
                shopping_car_key = settings.SHOPPINGCAR_KEY % (request.user.id, course_id)
                course_info=json.loads(cache.get(shopping_car_key))
                account_val["course_info"] = course_info

                #2.优惠券信息
                coupons = self.get_coupon_list(request, course_id)
                account_val["coupons"]=coupons

                #添加到redis中
                cache.set(account_key,json.dumps(account_val))

                res.data[account_key] = account_val
             #通用优惠券
            global_coupons = self.get_coupon_list(request)
            print('111global_coupons',global_coupons)
            global_coupons_val=cache.set("global_coupons_%s" % request.user.id, json.dumps(global_coupons))
            res.data["global_coupons_%s" % request.user.id]=global_coupons_val


        except ObjectDoesNotExist as e:
            res.code=1001
            res.msg="课程不存在"
        except PricePoliceError as e:
            res.code = 1002
            res.msg = "价格策略错误"
        return Response(res.dict())

    def cal_coupon_price(self,price,coupon_info):

        print("coupon_info",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 == "折扣券":
            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")
        # print("choose_coupons",choose_coupons)
        is_beli=request.data.get("is_beli")
        #############################1
        user_pk=request.user.id

        # 2 获取结算课程列表
        cal_price={}
        data=self.get(request).data.get("data")
        # print("data",data)
        account_course_list=data.get("account_course_list")
        # print("account_course_list",account_course_list)
        '''
           account_course_list=[{
                'id': 4,
                'coupon_list': [{
                    'off_percent': None,
                    'pk': 4,
                    'money_equivalent_value': 300.0,
                    'coupon_type': '立减券',
                    'minimum_consume': 0,
                    'name': '51劳动节'
                }],
                'course_img': 'https://luffycity.com/static/frontend/course/12/Linux5周入门_1509589530.6144893.png',
                'default_price': 1500.0,
                'default_price_period': 60,
                'relate_price_policy': {
                    '5': {
                        'valid_period_text': '2个月',
                        'default': True,
                        'valid_period': 60,
                        'prcie': 1500.0
                    },
                    '4': {
                        'valid_period_text': '1个月',
                        'default': False,
                        'valid_period': 30,
                        'prcie': 1000.0
                    }
                },
                'default_price_policy_id': 5,
                'name': 'Linux系统基础5周入门精讲'
            }, {
                'id': 2,
                'coupon_list': [{
                    'off_percent': 80,
                    'pk': 3,
                    'money_equivalent_value': 0.0,
                    'coupon_type': '折扣券',
                    'minimum_consume': 0,
                    'name': '清明节活动'
                }],
                'course_img': 'https://luffycity.com/static/frontend/course/3/Django框架学习_1509095212.759272.png',
                'default_price': 300.0,
                'default_price_period': 30,
                'relate_price_policy': {
                    '3': {
                        'valid_period_text': '1个月',
                        'default': True,
                        'valid_period': 30,
                        'prcie': 300.0
                    },
                    '1': {
                        'valid_period_text': '1周',
                        'default': False,
                        'valid_period': 7,
                        'prcie': 100.0
                    },
                    '2': {
                        'valid_period_text': '2周',
                        'default': False,
                        'valid_period': 14,
                        'prcie': 200.0
                    }
                },
                'default_price_policy_id': 3,
                'name': 'Django框架学习'
            }]
        '''
        account_courses_info={}
        # print("account_course_list",account_course_list)
        for account_course in account_course_list:
            temp={
                "coupon":{},
                "default_price":account_course["default_price"]
            }
            account_courses_info[account_course["id"]]=temp

            for item in account_course["coupon_list"]:

                # print("choose_coupons",choose_coupons) # {'4': 4}
                # print(str(account_course["id"]))

                coupon_id=choose_coupons.get(str(account_course["id"]))
                # print("-----------------")
                # print(type(coupon_id))
                # print(type(item["pk"]))
                # print(item)
                # print(coupon_id == item["pk"])
                if coupon_id == str(item["pk"]):
                    temp["coupon"]=item
        print('temp',temp)
        print("account_course_info",account_courses_info)
        price_list=[]
        total_price=0
        '''
           {
                2: {
                    'coupon': {  
                        'money_equivalent_value': 0.0,
                        'name': '清明节活动',
                        'pk': 3,
                        'off_percent': 80,
                        'coupon_type': '折扣券',
                        'minimum_consume': 0
                    },
                    'default_price': 200.0
                }
            }
        '''
        for key,val in account_courses_info.items():
            if not val.get("coupon"):
                price_list.append(val["default_price"])
                cal_price[key]=val["default_price"]
            else:
                coupon_info=val.get("coupon")
                default_price=val["default_price"]
                rebate_price=self.cal_coupon_price(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)

        # 计算贝里
        print("beili",is_beli,type(is_beli))
        print("北里",is_beli)
        # if is_beli:
        #     print("request.user.beli",request.user.beli)
        #     total_price=total_price-request.user.beli/10
        #     if total_price<0:
        #         total_price=0
        #     print("贝里数计算后",total_price)
        print('total_price',total_price)
        cal_price["total_price"]=total_price
        res.data=cal_price
        print("res.data",res.data)
        # except Exception as e:
        #     res.code=500
        #     res.msg="结算错误!"+str(e)

        return Response(res.dict())

十.公钥,私钥

特点:彼此互解

作用:

1.加密数据(公钥加密)

2.数字签名(私钥加密)