（项目）生鲜超市（六）

七、用户登录与手机注册

1、drf的token

　　在INSTALLED_APPS中注册：

INSTALLED_APPS = (
    'rest_framework.authtoken'
)

　　然后迁移数据库，会生成一张表authtoken_token，存放用户的token信息：

　　配置token的url：

from rest_framework.authtoken import views


urlpatterns = [
    path('api-token-auth/', views.obtain_auth_token),  # drf-token
]

　　然后现在测试发起post请求登录，我们使用postman工具来发起请求：

　　drf返回的token值会保存到数据库中并与用户进行关联：

　　然后客户端需要进行身份验证，令牌密钥包含在 Authorization HTTP header 中。关键字应以字符串文字 “Token” 为前缀，用空格分隔两个字符串。例如：

Authorization: Token 30fc1a3cab2d97a6ab3431d603a0bfc40145785b

　　通过验证TokenAuthentication 将提供以下凭据：

• request.user
• request.auth

　　要想获取这两个实例，还要在settings.py中添加以下设置：

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication'
    )
}

　　drf的token也有很大的缺点：

• token信息是保存在数据库中的，如果是一个分布式的系统，就比较麻烦
• token永久有效，没有过期时间

2、json web token方式完成用户认证（JWT）

　　在虚拟环境中pip install djangorestframework-jwt

　　将settings中的REST_FRAMEWORK的TokenAuthentication改成JSONWebTokenAuthentication：

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework.authentication.SessionAuthentication',
        # 'rest_framework.authentication.TokenAuthentication'
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
    )
}

　　然后修改jwt的url：

from rest_framework_jwt.views import obtain_jwt_token

urlpatterns = [
    path('jwt-auth/', obtain_jwt_token )
]

　　通过postman发起请求：

3、Vue和JWT接口调试

　　vue中登录接口是login：

//登录
export const login = params => {
  return axios.post(`${host}/login/`, params)
}

　　后台的接口要与前端保持一致：

urlpatterns = [
    path('login/', obtain_jwt_token ),  # jwt-token
]

　　jwt接口默认采用的是用户名和密码登录验证，如果用手机登录的话，就会验证失败，所以我们需要自定义一个用户验证，在users/view.py中编写：

from django.shortcuts import render
from django.contrib.auth.backends import ModelBackend
from django.contrib.auth import get_user_model
from django.db.models import Q

# Create your views here.


User = get_user_model()


class CustomBackend(ModelBackend):
    """jwt自定义用户验证"""

    def authenticate(self, request, username=None, password=None, **kwargs):
        try:
            user = User.objects.get(Q(username=username) | Q(mobile=username))
            if user.check_password(password):
                return user
        except Exception as e:
            return None

　　然后在setting中配置定义好的类：

AUTHENTICATION_BACKENDS = (
    'users.views.CustomBackend',
)

　　jwt过期时间的设置，在setting中配置：

# jwt过期时间
JWT_AUTH = {
    'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7),  # 也可以设置seconds=20
    'JWT_AUTH_HEADER_PREFIX': 'JWT',  # JWT跟前端保持一致，比如“token”这里设置成JWT
}

4、云片网发送短信验证码

　　在云片网进行注册，完善开发者信息，然后新增签名和模板，审核通过之后，添加ip白名单，测试的时候使用本地ip，线上部署的时候一定要换成服务器的ip。

　　然后编写发送验证码的逻辑，在apps下新建utils文件夹，新建yunpian.py文件：

import requests
import json


class YunPian(object):
    def __init__(self, api_key):
        self.api_key = api_key
        self.single_send_url = 'https://sms.yunpian.com/v2/sms/single_send.json'

    def send_sms(self, code, mobile):
        # 向云片网发起请求的参数
        parmas = {
            "apikey": self.api_key,
            "mobile": mobile,
            "text": "【倍思乐】您的验证码是{code}。如非本人操作，请忽略本短信".format(code=code)
        }

        # 发起请求
        response = requests.post(self, self.single_send_url, data=parmas)
        re_dict = json.loads(response.text)
        return re_dict


# 测试
if __name__ == '__main__':
    yun_pian = YunPian('9b11127a9701975c734b8aee81ee3526')
    yun_pian.send_sms('2018', '13993601652')

　　现在开始编写发送短信验证码的接口，首先在settings中配置手机号码的正则表达式：

# 手机号码正则表达式
REGEX_MOBILE = "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$"

　　然后对手机号码进行序列化，在users下新建serializers.py：

import re
from datetime import datetime, timedelta

from rest_framework import serializers
from django.contrib.auth import get_user_model

from MxShop.settings import REGEX_MOBILE
from .models import VerifyCode

User = get_user_model()


class SmsSerializer(serializers.Serializer):
    mobile = serializers.CharField(max_length=11)

    # 函数名必须是validate + 验证的字段名
    def validate_mobile(self, mobile):
        """手机号验证"""

        # 查询手机号是否已注册
        if User.objects.filter(mobile=mobile).count():
            raise serializers.ValidationError('用户已存在')

        # 验证手机号码是否合法
        if not re.match(REGEX_MOBILE, mobile):
            raise serializers.ValidationError('手机号码非法')

        # 限制验证码的发送频率，60秒发送一次
        one_mintes_ago = datetime.now() - timedelta(hours=0, minutes=1, seconds=0)
        if VerifyCode.objects.filter(add_time__gt=one_mintes_ago, mobile=mobile).count():
            raise serializers.ValidationError('距离上一次发送未超过60秒')

        return mobile

　　将云片网的apikey配置到settings中：

# 云片网的apikey
APIKEY = "xxxxx327d4be01608xxxxxxxxxx"

　　现在开始完善发送短信验证码的接口：

class SmsCodeViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    """手机验证码"""

    serializer_class = SmsSerializer

    # 随机生成code
    def generate_code(self):
        seeds = "1234567890"
        random_str = []
        for i in range(4):
            random_str.append(choice(seeds))

        return "".join(random_str)

    # 重写CreateModelMixin的create方法，加入发送验证码的逻辑
    def create(self, request, *args, **kwargs):
        # 验证手机号码
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        # 发送验证码
        mobile = serializer.validated_data["mobile"]
        yun_pian = YunPian(APIKEY)
        code = self.generate_code()
        sms_status = yun_pian.send_sms(code=code, mobile=mobile)
        if sms_status["code"] != 0:  # 发送失败
            return Response({
                "mobile": sms_status["msg"]
            }, status=status.HTTP_400_BAD_REQUEST)
        else:
            code_record = VerifyCode(code=code, mobile=mobile)
            code_record.save()
            return Response({
                "mobile": mobile
            }, status=status.HTTP_201_CREATED)

　　然后注册url：

router.register(r'code', SmsCodeViewSet, base_name='code')  # 短信验证码

　　现在开是在接口中进行验证，输入不合法的手机号：

　　输入合法的手机号后，会发送短信验证码到你的手机。

5、注册接口编写

　　在编写注册接口之前，需要修改UserProfile中的mobile字段为可以为空，因为前端只有一个值，是username，所以mobile可以为空：

class UserProfile(AbstractUser):
    """用户信息"""

    GENDER_CHOICES = (
        ("male", u"男"),
        ("female", u"女")
    )
    name = models.CharField("姓名", max_length=30, null=True, blank=True)
    birthday = models.DateField("出生年月", null=True, blank=True)
    gender = models.CharField("性别", max_length=6, choices=GENDER_CHOICES, default="female")
    mobile = models.CharField("电话", max_length=11, null=True, blank=True)
    email = models.EmailField("邮箱", max_length=100, null=True, blank=True)

    class Meta:
        verbose_name = "用户信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.username

　　然后编写用户注册的serializer：

class UserRegSerializer(serializers.ModelSerializer):
    # UserProfile中没有code字段，这里需要自定义一个code序列化字段
    code = serializers.CharField(required=True, write_only=True, max_length=4, min_length=4,
                                 error_messages={
                                     "blank": "请输入验证码",
                                     "required": "请输入验证码",
                                     "max_length": "验证码格式错误",
                                     "min_length": "验证码格式错误"
                                 },
                                 help_text="验证码")
    # 验证用户名是否存在
    username = serializers.CharField(label="用户名", help_text="用户名", required=True, allow_blank=False,
                                     validators=[UniqueValidator(queryset=User.objects.all(), message="用户已经存在")])

    # 验证code
    def validate_code(self, code):
        # 用户注册，post方式提交注册信息，post的数据都保存在initial_data里面
        # username就是用户注册的手机号，验证码按添加时间倒序排序，为了后面验证过期，错误等
        verify_records = VerifyCode.objects.filter(mobile=self.initial_data["username"]).order_by("-add_time")

        if verify_records:
            # 最近的一个验证码
            last_record = verify_records[0]
            # 有效期为五分钟
            five_mintes_ago = datetime.now() - timedelta(hours=0, minutes=5, seconds=0)
            if five_mintes_ago > last_record.add_time:
                raise serializers.ValidationError("验证码过期")

            if last_record.code != code:
                raise serializers.ValidationError("验证码错误")

        else:
            raise serializers.ValidationError("验证码错误")

    # 所有字段。attrs是字段验证合法之后返回的总的dict
    def validate(self, attrs):
        # 前端没有传mobile值到后端，这里添加进来
        attrs["mobile"] = attrs["username"]
        # code是自己添加得，数据库中并没有这个字段，验证完就删除掉
        del attrs["code"]
        return attrs

    class Meta:
        model = User
        fields = ('username', 'code', 'mobile')

　　然后在views.py中编写用户注册的接口：

class UserViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    """用户注册"""

    serializer_class = UserRegSerializer

　　注册url：

router.register(r'users', UserViewSet, base_name='users')  # 用户注册

　　然后在接口中进行测试：

6、django信号量实现用户密码修改

　　完善用户注册接口：

class UserViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    """用户注册"""

    serializer_class = UserRegSerializer
    queryset = User.objects.all()

　　然后在serializers.py中添加密码字段：

fields = ('username', 'code', 'mobile', 'password')

　　需要注意的是密码不能明文显示，需要加密保存， 这是重载Create方法：

class UserRegSerializer(serializers.ModelSerializer):
    # UserProfile中没有code字段，这里需要自定义一个code序列化字段
    code = serializers.CharField(required=True, write_only=True, max_length=4, min_length=4,
                                 error_messages={
                                     "blank": "请输入验证码",
                                     "required": "请输入验证码",
                                     "max_length": "验证码格式错误",
                                     "min_length": "验证码格式错误"
                                 },
                                 help_text="验证码")
    # 验证用户名是否存在
    username = serializers.CharField(label="用户名", help_text="用户名", required=True, allow_blank=False,
                                     validators=[UniqueValidator(queryset=User.objects.all(), message="用户已经存在")])

    # 输入密码的时候不显示明文
    password = serializers.CharField(
        style={'input_type': 'password'}, label=True, write_only=True
    )

    # 密码加密保存
    def create(self, validated_data):
        user = super(UserRegSerializer, self).create(validated_data=validated_data)
        user.set_password(validated_data["password"])
        user.save()
        return user

    # 验证code
    def validate_code(self, code):
        # 用户注册，post方式提交注册信息，post的数据都保存在initial_data里面
        # username就是用户注册的手机号，验证码按添加时间倒序排序，为了后面验证过期，错误等
        verify_records = VerifyCode.objects.filter(mobile=self.initial_data["username"]).order_by("-add_time")

        if verify_records:
            # 最近的一个验证码
            last_record = verify_records[0]
            # 有效期为五分钟
            five_mintes_ago = datetime.now() - timedelta(hours=0, minutes=5, seconds=0)
            if five_mintes_ago > last_record.add_time:
                raise serializers.ValidationError("验证码过期")

            if last_record.code != code:
                raise serializers.ValidationError("验证码错误")

        else:
            raise serializers.ValidationError("验证码错误")

    # 所有字段。attrs是字段验证合法之后返回的总的dict
    def validate(self, attrs):
        # 前端没有传mobile值到后端，这里添加进来
        attrs["mobile"] = attrs["username"]
        # code是自己添加得，数据库中并没有这个字段，验证完就删除掉
        del attrs["code"]
        return attrs

    class Meta:
        model = User
        fields = ('username', 'code', 'mobile', 'password')

　　下面通过信号量的方式来保存密码，在users下新建signals.py文件：

from django.dispatch import receiver
from django.db.models.signals import post_save
from django.contrib.auth import get_user_model


User = get_user_model()


# post_save接收信号的方法, sender接收信号的model
@receiver(post_save, sender=User)
def create_user(sender, instance=None, created=False, **kwargs):
    # 是否新建，因为update的时候也会进行post_save
    if created:
        # instance相当于user
        password = instance.password
        instance.set_password(password)
        instance.save()

　　然后在users/apps.py中重载配置：

from django.apps import AppConfig


class UsersConfig(AppConfig):
    name = 'users'
    verbose_name = "用户管理"

    def ready(self):
        import users.signals

　　AppConfig自定义的函数，会在django启动时被运行，现在添加用户的时候，密码就会自动加密存储了。

7、Vue和注册接口联调

　　完善注册接口：

class UserViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    """用户注册"""

    serializer_class = UserRegSerializer
    queryset = User.objects.all()

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        user = self.perform_create(serializer)
        re_dict = serializer.data
        payload = jwt_payload_handler(user)
        re_dict["token"] = jwt_encode_handler(payload)
        re_dict["name"] = user.name if user.name else user.username

        headers = self.get_success_headers(serializer.data)
        return Response(re_dict, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        return serializer.save()

　　然后将Vue中register的接口的host修改：

//注册

export const register = parmas => { return axios.post(`${host}/users/`, parmas) }

　　然后在注册页面进行测试，发送短信注册成功跳转到首页：

　　如果没有在云片网审核通过的童靴想要测试接口是否正确，可以先暂时修改发送短信的接口，将随机生成的验证码打印出来，暂时不同云片网发送短信，修改发送短信的接口：

class SmsCodeViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    """手机验证码"""

    serializer_class = SmsSerializer

    # 随机生成code
    def generate_code(self):
        seeds = "1234567890"
        random_str = []
        for i in range(4):
            random_str.append(choice(seeds))

        print("".join(random_str))

        return "".join(random_str)

    # 重写CreateModelMixin的create方法，加入发送验证码的逻辑
    # def create(self, request, *args, **kwargs):
    #     # 验证手机号码
    #     serializer = self.get_serializer(data=request.data)
    #     serializer.is_valid(raise_exception=True)
    #
    #     # 发送验证码
    #     mobile = serializer.validated_data["mobile"]
    #     yun_pian = YunPian(APIKEY)
    #     code = self.generate_code()
    #     sms_status = yun_pian.send_sms(code=code, mobile=mobile)
    #     if sms_status["code"] != 0:  # 发送失败
    #         return Response({
    #             "mobile": sms_status["msg"]
    #         }, status=status.HTTP_400_BAD_REQUEST)
    #     else:
    #         code_record = VerifyCode(code=code, mobile=mobile)
    #         code_record.save()
    #         return Response({
    #             "mobile": mobile
    #         }, status=status.HTTP_201_CREATED)

    # 以下为没有使用云片网
    def create(self, request, *args, **kwargs):
        # 验证手机号码
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        # 获取打印验证码
        mobile = serializer.validated_data["mobile"]
        code = self.generate_code()

        code_record = VerifyCode(code=code, mobile=mobile)
        code_record.save()
        return Response({
            "mobile": mobile
        }, status=status.HTTP_201_CREATED)