路飞项目----day08（腾讯云发送短信，发送短信验证码接口，短信登录接口，短信注册账号接口）

上节回顾

# 1 git 回顾
# 2 pycharm操作git
	-版权---》收费软件---vscode，社区版  vim搭建开发环境
    -项目右键---》git---》很多操作，之前使用命令的，现在都可以通过 点点点 完成
# 3 jetbrains 全家桶
	-go
    -java
# 4 登录注册页功能分析
	-多方式登录接口  ---》完成
    -验证手机号是否存在---完成
    -发送短信接口 ----》借助于第三方
    -短信登录接口
    -短信注册接口
    
    
# 5 验证手机号是否存在
	- 保证发送短信接口安全，不被第三方盗用
    	-1 加频率限制（频率限制，只能限制手机号一分钟发一次，不能限制接口一分钟访问一次）
        -2 随机字符串：
        	-跨站请求伪造：csrf
            同一个浏览器里：
            	登录 招商银行---》cookie存在浏览器中了
                进入了一个恶意网站，恶意网站有个按钮，一点击，向招商银行发请求，能发成功，服务器可以正常响应，浏览器拦截
                一旦登录招商银行成功，只要向招商银行发送请求，就会自动携带携带cookie
                
            -解决方案：
            	来到要发送post请求的页面，后端就生产个一个随机字符串，给前端
            	如果要发送post请求(一般用来增加，修改数据)，需要携带一个随机字符串，如果没有带，就禁止
    -以后写视图类，有个统一模板
    try:
        逻辑
    except Exception as e:
        再抛出来
        retrun APIResponse()
	
                
   	-以后记住：
    	视图函数，视图类的方法，返回值一定是响应对象(django原生的4个，drf的一个，自己封装了一个)
        raise 的对象，必须是错误对象  KeyError，APIException，LqzException

# 6 多方式登录接口  
	-前端--》post请求--》{username:lqz,password:123}---->后端----》login_mul---》
    -正常逻辑：
    	1 取出用户名，取出密码
        2 判断用户名对应的值是手机号，还是邮箱，还是姓名
        3 去数据库根据 手机号  或 邮箱 或 用户名查询
        4 查到签发token，返回给前端


 # 补充
	1 接口幂等性：这是啥，为啥会出现，如何解决它？
    2 异常捕获，可以捕获粒度更细一些
    3 自定义异常类
    class LqzException(Exception):
        def __init__(self,message):
            pass

今日内容

1 腾讯云短信开发

# 给手机发送短信---》第三方平台：腾讯云短信----》

# API和SDK，有sdk优先用sdk
# sdk：
	3.0版本，云操作的sdk，不仅仅有发送短信，还有云功能的其他功能
	2.0版本，简单，只有发送短信功能

-----------------------------------------------

# 安装sdk
方式一：pip install tencentcloud-sdk-python

方式二源码安装：
	下载源码(后期有些第三方模块可能从pip上面搜不到，所以就会使用到源码安装)
	来到下载源码的setup文件所在的目录下，复制路径
	来到pycharm里面的terminal里面，先cd到复制的路径下
	执行 python steup.py install


# 发送短信测试

源码先下载到本地

.
来到下载源码的setup文件所在的目录下，复制路径

.
来到pycharm里面的terminal里面，先cd到复制的路径下
python setup.py install
就会安装到当前所在的解释器环境下

.
.
.
.

1.1 封装发送短信

-libs下：
    send_sms_v3
        settings.py
        init.py
        send_mes.py

# 双下init里面
from libs.send_mes_v3.send_mes import get_code, send_sms888

# 这样写的目的就是以后在其他文件里面想要使用get_code, send_sms888函数名的时候
# 就可以不用导这么长了，直接from libs.send_mes_v3 import get_code, send_sms888
# 导包名就是导包下的双下init文件，双下init文件里面如果有导的函数名，就可以直接通过import导出来了
--------------------------------------------

# settings.py
SECRET_ID = ''
SECRET_KEY = ''
APP_ID = ''
SIGN_NAME = ''
TEMPLATE_ID = ''

---------------------------------------------------

# send_mes.py
from tencentcloud.common import credential
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
# 导入对应产品模块的client models。
from tencentcloud.sms.v20210111 import sms_client, models

# 导入可选配置类
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile

from luffy_api.libs.send_mes_v3 import settings
import random
import json


# 生成随机验证码的函数
def get_code():
    code = ''
    for i in range(4):
        code += str(random.randint(1, 9))
    return code


def send_sms888(code, mobile):
    try:
        # 1 秘钥查询 SecretId、SecretKey 查询: https://console.cloud.tencent.com/cam/capi
        cred = credential.Credential(settings.SECRET_ID, settings.SECRET_KEY)

        #
        httpProfile = HttpProfile()
        httpProfile.reqMethod = "POST"  # post请求(默认为post请求)
        httpProfile.reqTimeout = 30  # 请求超时时间，单位为秒(默认60秒)
        httpProfile.endpoint = "sms.tencentcloudapi.com"  # 指定接入地域域名(默认就近接入)
        clientProfile = ClientProfile()
        clientProfile.signMethod = "TC3-HMAC-SHA256"  # 指定签名算法
        clientProfile.language = "en-US"
        clientProfile.httpProfile = httpProfile
        client = sms_client.SmsClient(cred, "ap-nanjing", clientProfile)
        req = models.SendSmsRequest()

        #
        # 2  应用的id
        req.SmsSdkAppId = settings.APP_ID
        # 3  签名内容
        req.SignName = settings.SIGN_NAME
        # 4  模板id
        req.TemplateId = settings.TEMPLATE_ID
        # 5  模板替换的地方
        req.TemplateParamSet = [code, '20']
        # 6  发送短信的号码
        req.PhoneNumberSet = ["+86" + mobile, ]

        #
        req.SessionContext = ""
        req.ExtendCode = ""
        req.SenderId = ""
        resp = client.SendSms(req)
        # 输出json格式的字符串回包
        # print(resp.to_json_string(indent=2))
        # 下面几行代码是自己根据需求改的
        res = json.loads(resp.to_json_string(indent=2))
        if res.get('SendStatusSet')[0].get('Code') == 'Ok':
            return True
        else:
            return False

    except TencentCloudSDKException as err:
        print(err)

# 这个代码整体没啥，就是拿的sdk的标准代码，自己封装成函数，里面根据自己
# 的需求稍微代码改改，就行了。

.
.
.
.
.

2 发送短信验证码接口

class UserView(GenericViewSet):
    serializer_class = UserLoginSerializer
    queryset = User.objects.all().filter(is_active=True)

    # 发送短信验证码的接口，发送验证码前自己先存一份
    @action(methods=['post'], detail=False)
    def send_msg(self, request):
        try:
            mobile = request.data['mobile']
            # 生成验证码
            code = get_code()
     # 把验证码放到缓存里面去,要保证key唯一，所以给手机号码前面加了前缀
     # 暂时先存在内存中，后期使用redis作为缓存，因为集群环境下，
     # 在一台服务器存的缓存，请求打到另一台服务器是拿不到该缓存的！！！
            cache.set('msg_code_%s' % mobile, code)

            # res = send_sms888(code, mobile)
    # 同步发送短信，后期可以改成异步操作发送短信,目前可以使用多线程操作
            # if res:
            #     return APIResponse(msg='发送成功')
            # else:
            #     return APIResponse(code=102, msg='发送失败')

            t = Thread(target=send_sms888, args=[code, mobile])
            t.start()
            return APIResponse(msg='短信已发送')  # 只管发了，发没发成功不管了

        except Exception as e:
            raise APIException(str(e))

# 这个能不能不要异常捕获了，已经有全局异常捕获了，此处捕了又抛，多此一举了吧？？？

# 根据传进来的手机号码，调用生成验证码的函数，再调用发送短信的函数
# 发送短信的函数可以用多线程

.
.
.
.
.

3 短信登录接口

# 前端---》{mobile:122334,code:8888}---->post----》

# 视图类的方法中的逻辑

1 取出手机号和验证码

2 校验验证码是否正确（需要在发送验证码接口，存储验证码）
	session：根本不用
	全局变量：不好，可能会取不到，在多进程状态下，
	一个进程里的全局变量，另一个进程拿不到该全局变量！！！
	缓存：django 自带缓存

# django自带的缓存怎么用
from django.core.cache import cache
cache.set()  # 往缓存里放
cache.get()  # 从缓存里取


3 根据手机号查询用户，如果能查到，签发token

4 返回给前端

-------------------------------------------

.
.
.
.

3.1 视图类

class UserView(GenericViewSet):
    # class UserView(ViewSetMixin, GenericAPIView):
    serializer_class = UserLoginSerializer
    queryset = User.objects.all().filter(is_active=True)

    # 重写 GenericAPIView里面的get_serializer_class
    def get_serializer_class(self):
        # 如果访问login_msg函数，使用单独的序列化类
        if self.action == 'login_msg':
            return UserMobileLoginSerializer
        else:
            return super().get_serializer_class()



    # 短信登录接口，前端传过来手机号与验证码，校验手机号与
    @action(methods=['post'], detail=False)
    def login_msg(self, request, *args, **kwargs):
        ser = self.get_serializer(data=request.data)
        ser.is_valid(raise_exception=True)
        # 走这句话，就会先执行字段自己的校验，然后局部钩子，全局钩子

        token = ser.context.get('token')
        username = ser.context.get('username')
        return APIResponse(token=token, username=username)

    # @action(methods=['post'], detail=False)
    # def login_msg(self, request, *args, **kwargs):
    #     return self._login(request, *args, **kwargs)
    #     上面的代码就简化成这样了，同理校验用户名与密码是否正确接口里面也可以通过self._login简化代码


    # 可以把校验用户名与密码是否正确接口的函数与短信登录接口的函数里面一样的代码抽取出来,用一个函数接收一下
    def _login(self, request, *args, **kwargs):
        ser = self.get_serializer(data=request.data)
        ser.is_valid(raise_exception=True)  # 走这句话，就会先执行字段自己的校验，然后局部钩子，全局钩子
        token = ser.context.get('token')
        username = ser.context.get('username')
        return APIResponse(token=token, username=username)

.
.
.
.

3.2 序列化类

from .models import User
from rest_framework import serializers
import re
from rest_framework.exceptions import APIException, ValidationError
from rest_framework_jwt.settings import api_settings

jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
from django.core.cache import cache


class UserMobileLoginSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['mobile', 'code']

    # code 字段不是表的字段，所以需要重写
    code = serializers.CharField()
    mobile = serializers.CharField()

    # 执行全局钩子函数
    def validate(self, attrs):

        user_obj = self._get_user(attrs)
        token = self._get_token(user_obj)

        self.context['token'] = token  # context是序列化类的基类Field里面的方法伪装成属性，返回值是字典
        self.context['username'] = user_obj.username

        return attrs

    #
    def _get_user(self, attrs):
        code = attrs.get('code')
        mobile = attrs.get('mobile')
        # 从缓存中取出
        true_code = cache.get('msg_code_%s' % mobile)
        if true_code == code:
            # 根据手机号，查到用户
            user_obj = User.objects.filter(mobile=mobile).first()
            if user_obj:
                return user_obj
            else:
                raise APIException('用户不存在')
        else:
            raise APIException('验证码验证失败')

    #
    def _get_token(self, user_obj):
        payload = jwt_payload_handler(user_obj)
        token = jwt_encode_handler(payload)
        # 这两行代码可以到jwt的源码里面的序列化类的文件里面去复制
        return token


# 代码可以继续抽取，把全局钩子函数与_get_token函数封到一个公共的类里面去

class BaseUserSerializer:
    def validate(self, attrs):
        user_obj = self._get_user(attrs)
        token = self._get_token(user_obj)
        self.context['token'] = token  # context是序列化类的基类Field里面的方法伪装成属性，返回值是字典
        self.context['username'] = user_obj.username

        return attrs

    def _get_user(self, attrs):
        raise APIException('_get_user函数必须要被重写')

    def _get_token(self, user_obj):
        payload = jwt_payload_handler(user_obj)
        token = jwt_encode_handler(payload)
        # 这两行代码可以到jwt的源码里面的序列化类的文件里面去复制
        return token


# 这样上面两个类里面只要继承BaseUserSerializer公共类，就可以不写全局钩子函数与_get_token函数了！！！
# 但是要注意 公共类要放在前面，因为Serializer里面也有个validate方法！！！所以位置不能反！！！
class UserMobileLoginSerializer222(BaseUserSerializer, serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['mobile', 'code']

    # code 字段不是表的字段，所以需要重写
    code = serializers.CharField()
    mobile = serializers.CharField()

    def _get_user(self, attrs):
        code = attrs.get('code')
        mobile = attrs.get('mobile')
        # 从缓存中取出
        true_code = cache.get('msg_code_%s' % mobile)
        if true_code == code:
            # 根据手机号，查到用户
            user_obj = User.objects.filter(mobile=mobile).first()
            if user_obj:
                return user_obj
            else:
                raise APIException('用户不存在')
        else:
            raise APIException('验证码验证失败')

.
.
.
.
.

4 短信注册账号接口

# 前端---》{mobile:1888344,code:8888,password:123}--->post

# 后端  再写个视图类

.
.

4.1 路由

# http://127.0.0.1:8000/api/v1/user/register/   --->post 请求
router.register('register',views.RegisterUserView,'register')

.
.

4.2 视图类

class RegisterUserView(GenericViewSet, CreateModelMixin):
    serializer_class = RegisterSerializer
    queryset = User.objects.all().filter(is_active=True)

    # 短信注册接口
    def create(self, request, *args, **kwargs):
        # 方式二 如果用父类的create方法，就一定要将code字段变成只写字段！！
        super().create(request, *args, **kwargs)

        # 方式一 直接复制CreateModelMixin里面的create源码，最后两行不要，不要序列化
        # serializer = self.get_serializer(data=request.data)
        # serializer.is_valid(raise_exception=True)
        # self.perform_create(serializer)
        # 源码里面下面两行不要，会触发序列化
        # headers = self.get_success_headers(serializer.data)
        # return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

        return APIResponse(code=101, msg='注册成功')

.
.
.

4.3 序列化类

# 数据校验，反序列化
class RegisterSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['mobile', 'code', 'password']
        extra_kwargs = {
            'password': {'write_only': True}
        }

    code = serializers.CharField(max_length=4, write_only=True)

    # 全局钩子
    def validate(self, attrs):
        """
        1 取出前端传入的code  校验code是否正确
        2 把username设置成手机号(也可以随机生成)，用户名如果不传，一整条数据往数据库里存不进去
        3 code字段不是数据库的字段，所以要从attrs中剔除掉，方便后面往数据库存
        """
        mobile = attrs.get('mobile')
        code = attrs.get('code')
        true_code = cache.get('msg_code_%s' % mobile)
        if true_code == code:
            attrs['username'] = mobile
            attrs.pop('code')
        else:
            raise APIException('验证码不正确')

        return attrs

    # 一定要重写create方法，因为密码是明文，如果不重写，传到数据库也是明文
    def create(self, validated_data):
        # validated_data={'username':18752888888,'mobile':18752888888,password:123}
        # 往数据库里添加用户数据！
        user_obj = User.objects.create_user(**validated_data)
        return user_obj

    # 虽然我们只做数据校验与反序列化，不做序列化
    # 但是CreateModelMixin里面的create方法里面有用到序列化对象去点data
    # 序列化对象只要点data，就会触发序列化，

    # 最后不要忘了return 查出来的模型表对象，因为ser.data 会使用返回的对象做序列化！！

.
.
.
.
.
.

作业

1 封装腾讯云短信
2 写完：发送短信接口，短信登录接口，短信注册接口