常用数据参考

                                                                                                                                             登录时用户名和密码的校验

from django.contrib.auth.hashers import check_password（导包）

user = User.objects.filter(models.Q(username=username) | models.Q(mobile=username)).first()
check_password(password, user.password):

                                                                                                                                                  # 注册时 加密存储
User.objects.create_user(username=username, password=password, mobile=mobile) 

                                                                                                                                                            生成token

包含难导的包

from django.contrib.auth.hashers import check_password
from django.db import models
from django0806 import settings
import time,jwt

 @staticmethod
    def gen_token(user):
        """
        :param user:
        :return: jwt token
        """
        payload = {
            'uid':user.id,
            'username':user.username,
            'exp':time.time() + 10*1000*84000
        }
        # 编码生成token
        token = jwt.encode(payload,settings.SECRET_KEY,algorithm='HS256')
        return token

再返回200之前存入token

 token = self.gen_token(user)
            return Response({
                'code':200,
                ',msg':'登录成功',
                'token':token,
                'username':user.username
            })

                                                                      

                                                                               解码token

 from user.models import *
from rest_framework.response import Response
import jwt
from django0806 import settings

def check_login(func):
    def wrapper(self, request, *args, **kwargs):
        token = request.data.get('Authorization')
        if token == None:
            token = request.query_params.get('Authorization')
        print('\033[1;33;40m获取的token\033[0m', token)
        try:
            payload = jwt.decode(token,key=settings.SECRET_KEY,algorithm='HS256')
        except Exception as e:
            print(e)
            print('解码token失败')
            return Response({
                'code':401,
                'msg':'未认证',
            })
        print('解码出的用户信息',payload)
        request.uid = payload.get('uid')
        # 拿到用的查询对象
        request.user = User.objects.filter(id=request.uid).first()
        return func(self,request,*args,**kwargs)
    return wrapper

                                                                                                                                                                          前端储存token

 localStorage.setItem('token',err.data.token)              
 localStorage.setItem('username',err.data.username)   

 
                                                                                                                                                                       前端向后端传递token数据

{headers:{Authorization:localStorage.token || ""} }

                                                                                                                                                                          清楚本地缓存中存放的token 和用户名

      localStorage.removeItem("username");
      localStorage.removeItem("token");

                                                                                                                                                                    添加购物车

class APPcatsAdd(APIView):
    @check_login
    def post(self,request):
        # 1.接收前段的数据
        good_id = request.data.get('productID')
        uid = request.uid
        # 2. 根据商品id 查询商品对象
        good = Goods.objects.filter(id=good_id).first()
        if not good:
            return Response({
                'code': 400,
                'msg': '加购商品不存在'
            })
        # 判断商品的库存
        redis_conn = redis.Redis(host='localhost', port=6379, db=5)
        # 构造用户的key
        # cart_key = 'cart_%s'%uid 表示用户 如cart_1 就是用户1
        # cart_selected_key = 'cart_selected_%s'%uid  表示收藏的商品id
        cart_key = 'cart_%s' % uid
        cart_selected_key = 'cart_selected_%s' % uid
        # 商品的库存大于0才可以继续加购
        if good.stock > 0:
            # 能查询到 说明 有商品 已经不是第一次加购了
            num = redis_conn.hget(cart_key, good_id)
            if num:
                # 不是第一次加购
                num = int(num.decode()) + 1
                # 添加购物的的数量小于等于库存；
                if num <= good.stock:
                    # cart_key（表示用户）  good_idb（表示收藏的商品） num(表示收藏的商品 表示数量)
                    redis_conn.hset(cart_key, good_id, num)
                    # 加入购物车 设置默认勾选状态  放在集里面的都都是被勾选的
                    redis_conn.sadd(cart_selected_key, good_id)
                    # 可以继续加购
                    return Response({
                        'code': 201,
                        'msg': '改商品已经在购物车数量+1'
                    })
                # 超过库存不能再加购了      # 加购到达限制数量
                else:
                    return Response({
                        'code': 202,
                        'msg': '加购到达限购数量'
                    })
            else:
                # 第一次加购 将加购的数据返回给前段
                redis_conn.hset(cart_key, good_id, 1)
                redis_conn.sadd(cart_selected_key, good_id)
                return Response({
                    'code': 200,
                    'msg': '新加入购物车成功',
                    'shoppingCateDate': {
                        'id': cart_key,
                        'productID': good.id,
                        'productName': good.sku_name,
                        'productImg': good.img,
                        'price': good.selling_price,
                        'maxNum': good.stock,
                        'check': True
                    }
                })
        # 这是库存不大于0的情况下
        else:
            return Response({
                'code': 203,
                'msg': '库存不足，无法购买'
            })

                               

                                                                                                                                              查看和删除购物车商品购物车

 @check_login
    def get(self, request):
        # 获取用户id
        uid = request.uid
        # 构造Redis里面的key
        redis_conn = redis.Redis(host='localhost', port=6379, db=5)
        cart_key = 'cart_%s' % uid
        cart_selected_key = 'cart_selected_%s' % uid
        # 将字节串转换为字符串
        #  smembers  查看所有的数据  decode()进行一个转码    此时拿到的是集合里面的每一条数据
        cart_selected_data = [int(i.decode()) for i in redis_conn.smembers(cart_selected_key)]
        # 拿到里面里面的所有数据
        cart_data = redis_conn.hgetall(cart_key)
        # 初始化一个空列表，为储存所有的购物车商品字典
        shopping_cart_data = []
        # 此时拿到了每一条商品的 id 和 数量
        for good_id, num in cart_data.items():
            num = int(num.decode())
            # 组织商品字典结构
            if good_id in cart_selected_data:
                data = org_good_json(cart_key, good_id, num, check=True)
            else:
                data = org_good_json(cart_key, good_id, num, check=False)
            shopping_cart_data.append(data)
        # 返回响应
        return Response({
            'code': 200,
            'msg': '加载购物车商品id成功',
            'shoppingCartData': shopping_cart_data
        })

    # 删除购物车商品的视图
    @check_login
    def delete(self,request):
        good_id = request.data.get('ipp')
        uid = request.uid
        print('接收的商品id',good_id)
        # 1.连接redis数据库
        redis_conn = redis.Redis(host='localhost',port=6379,db=5)
        # 构造key
        cart_key = 'cart_%s' % uid
        # 2.将数据从redis里面删除掉
        redis_conn.hdel(cart_key,good_id)
        # 3.返回响应
        return Response({
            'code':200,
            'msg':'购物车数据删除成功'
        })

 
                                                                                     单选和取消单选

class APPgou(APIView):
    @check_login
    def post(self,request):
        good_id = request.data.get('app')
        uid  =request.uid
        # print('接收的商品id',good_id)
        # 1.获取前段传过来的数据
        # 构造key
        redis_selecete_key = 'cart_selected_%s' % uid
        redis_conn = redis.Redis(host='localhost',port=6379,db=5)
        redis_conn.sadd(redis_selecete_key,good_id)
        # 2.将勾选的商品id放放进集合中
        #  3.返回响应
        return Response({
            'code':200,
            'msg':'单选true状态设置成功'
        })

# 取消单选状态的的视图
class Appfalse(APIView):
    @check_login
    def post(self,request):
        good_id = request.data.get('app')
        uid  =request.uid
        # print('接收的商品id',good_id)
        # 1.获取前段传过来的数据
        # 构造key
        redis_selecete_key = 'cart_selected_%s' % uid
        redis_conn = redis.Redis(host='localhost',port=6379,db=5)
        redis_conn.srem(redis_selecete_key,good_id)
        # 2.将勾选的商品id放放进集合中
        #  3.返回响应
        return Response({
            'code':200,
            'msg':'单选false状态设置成功'
        })

                                                                                                                                                        setting里面的配置

                                                                                      跨域：

CORS_ORIGIN_WHITELIST = (
    "http://localhost:8080",
    "http://localhost:8081"
)

# 跨域的允许方法
CORS_ALLOW_METHODS = (
    "GET",
    "POST",
    "PUT",
    "DELETE",
    "OPTIONS",
)

# 跨域允许的请求头
CORS_ALLOW_HEADERS = (
    "authorization",
    "content-type",
    "x-requested-with",

)

子应用.模型类
AUTH_USER_MODEL = "user.User"
图片相关配置
STATICFILES_DIRS = ("static",)

                                                                                                                                                   模型类相关导包

from django.contrib.auth.models import AbstractUser

# Create your models here.
# 用户模型类
class User(AbstractUser):
    mobile = models.CharField(max_length=11, verbose_name="手机号")

    class Meta:
        db_table = "user"
        verbose_name_plural = "用户表"

    def __str__(self):
        return self.username

                                                                                                                       查看收藏

class Apptoken(APIView):
    @check_login
    def get(self,request):
       uid = request.uid
       temp = []
       # 拿到了查询集
       goods_collecion = GoodCollection.objects.filter(user_id=uid)
       if goods_collecion:
           #  用户列表推导式 拿到了 商品查询集
           goods = [i.good for i in goods_collecion]
           for i in goods:
               data = {
                   'cate': i.cate_id,
                   'goodid': i.id,
                   'price': i.price,
                   'selling_price': i.selling_price,
                   'count': i.count,
                   'stock': i.stock,
                   'img': i.img,
                   'instruction': i.instruction,
                   'sku_name': i.sku_name,
                   'title': i.title
               }
               temp.append(data)
           return Response({
               'code': 200,
               'msg': '加载收藏数据成功',
               'data': temp
           })

       else:
          return Response({
               'code':400,
               'msg':'你没有收藏'
           })