腾讯云短信开发，短信验证码接口，短信登录接口，短信注册接口

腾讯云短信开发，短信验证码接口，短信登录接口，短信注册接口

课前小知识点：
1. 在公司里面我们使用的开发软件不一定是pycharm,有些公司会介意版权的问题，会使用社区版的pychram,或者是使用viscode、用vim搭建开发环境，无论用哪个软件，都是万变不离其中，操作都是差不多的

2.如何保证发送短信接口安全，不被第三方盗用？
	(1).加频率限制(频率限制，限制一个手机只能一分钟发一次，坏处：不能限制接口一分钟访问一次)
    (2).加随机字符串
    	例如：在同一个浏览器中，登录一个网站，登录成功，cookie就存在了浏览器中，如果进入一个恶意的网站，就会自动携带cookie登录成功，个人信息也就被泄露了
        解决方案：
        来到要发送post请求的页面，后端就生产出一个随机字符串给前端，如果发送post请求(一般用来增加，修改数据)，需要携带一个随机字符串，如果没有带的话，就禁止、自动拦截
        
3.raise的对象必须是错误对象 KeyError、APIException、LqzException(xxException)

接口幂等性为啥会出现？怎么去解决他？

1.什么是接口幂等性？

幂等性本来是数学上的概念，用在接口上可以理解为：同一个接口，多次发出同一个请求，必须保证操作只执行一次。
它是系统服务对外的一种承诺，接口服务提供方承诺只要调用接口成功了，外部多次调用对系统的影响是一致的。

举一个最常见的例子，用户购买商品后支付扣款成功，但是此时网络发生了异常，导致返回结果失败。因为没收到返回结果，用户就会再次点击付款按钮，就会多付了一笔钱，一旦用户发现余额少了，开发人员就等着被祭天吧，这就是没有保证接口的幂等性。

声明为幂等的服务会认为调用方调用失败是常态，并且调用失败后必然会有重试。

2.需要保证幂等性的场景分析

只有第三种场景需要开发人员使用策略来保证幂等性：
1.场景一：查询
 SELECT column1 FROM table1 WHERE column2 = 2
无论执行多少次都不会改变状态，是天然的幂等。 

2. 场景二：常量赋值更新
UPDATE table1 SET column1 = 1 WHERE column2 = 2
无论执行成功多少次状态都是一致的，因此也是幂等操作。

3. 场景三：变量赋值更新
UPDATE table1 SET column1 = column1 + 1 WHERE column2 = 2
每次执行的结果都会发生变化，这种场景就不是幂等的。

3.怎么去解决接口幂等性

1.乐观锁
这里的乐观锁指的是用乐观锁的原理去实现，为数据字段增加一个 version 字段
2.悲观锁
乐观锁可以实现的往往用悲观锁也能实现，是指在获取数据时进行加锁，当同时有多个重复请求时其他请求都无法进行操作。

腾讯云短信开发

# 安装sdk
	-方式一：pip install tencentcloud-sdk-python
    -方式二源码安装：
    	-下载源码
        -执行 python steup.py install

1 封装发送短信

setting.py:
SMSSDKAPPID = "1400799914"
SIGNNAME = "Python程序Yuan"
TEMPLATEID = "1720471"

sms.py:
    
import random

from tencentcloud.common import credential
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException

from tencentcloud.sms.v20210111 import sms_client, models

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

def get_code(number=4):
    code = ''
    for i in range(number):
        code += str(random.randint(0, 9))
    return code


def send_sms(code, mobile):
    try:
        cred = credential.Credential("AKIDGLL9i3A1eN92gAbppZIsDI7g9spfFdt8", "91gAbNxIPJ7g18oKkxwspcASWLvFSaUA")
        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-guangzhou", clientProfile)
        req = models.SendSmsRequest()
        req.SmsSdkAppId = "setting.APP_ID"
        req.SignName = "setting.SIGN_NAME"
        req.TemplateId = "setting.TEMPLATE_ID"
        req.TemplateParamSet = [code, '5']
        req.PhoneNumberSet = ["+86" + mobile,]
        req.SessionContext = ""
        req.ExtendCode = ""
        req.SenderId = ""

        resp = client.SendSms(req)
        # 输出json格式的字符串回包
        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)
        return False

2 短信验证码接口

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

    
    @action(methods=['POST'], detail=False)
    def send_sms(self, request):
        try:
            mobile = request.data['mobile']
            # 生成验证码
            code = get_code()
            res = send_sms_ss(code, mobile)  # 同步发送，后期可以改成异步  后期学了celery可以加入异步 目前咱们可以使用 多线程
            if res:
                return APIResponse(msg='发送成功')
            else:
                return APIResponse(code=101, msg='发送失败')

        except Exception as e:

短信登录接口

# 视图类的方法中的逻辑
	1 取出手机号和验证码
    2 校验验证码是否正确（发送验证码接口，存储验证码）
    	-session：根本不用
        -全局变量：不好，可能会取不到，集群环境中
        -缓存：django 自带缓存
        	-from django.core.cache import cache
        	-cache.set()
            -cache.get()
    3 根据手机号查询用户，如果能查到
    4 签发token
    5 返回给前端

视图类

from threading import Thread
from django.core.cache import cache
from rest_framework.mixins import CreateModelMixin

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

    @action(methods=['GET'],detail=False)
    def check_mobile(self,request,*args,**kwargs):
        try:
            mobile = request.query_params.get('mobile')
            print(1)
            User.objects.get(mobile=mobile)
        except Exception as e:
            raise e
        return APIResponse(msg='手机号存在')

    @action(methods=['POST'],detail=False)
    def login_mul(self,request,*args,**kwargs):
        return self._login(request,*args,**kwargs)

    @action(methods=['POST'],detail=False)
    def send_sms(self,request):
        try:
            mobile = request.data['mobile']
            # 生成验证码
            code = get_code()
            # 要找个地方将数据缓存下来
            # 我们现在将数据暂时缓存在内存中，后期要使用redis作为缓存
            cache.set('sms_code_%s' % mobile,code)
            t = Thread(target=send_sms_ss,args=[code,mobile])
            t.start()
            return APIResponse(msg='短信已发送')
        except Exception as e:
            raise APIException(str(e))

    # 重写方法
    def get_serializer_class(self):
        if self.action == 'login_sms':
            return UserMobileLoginSerializer
        else:
            return super().get_serializer_class()

    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)

    @action(methods=['POST'],detail=False)
    def login_sms(self,request,*args,**kwargs):
        return self._login(request)

序列化类

from rest_framework import serializers
from .models import User
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 BaseUserSerializer:
    def validate(self,attrs):
        user = self._get_user(attrs)
        token = self._get_token(user)
        self.context['token'] = token
        self.context['username'] = user.username
        return attrs

    def _get_user(self,attrs):
        raise Exception('今天你得重写他')

    def _get_token(self,user):
        payload = jwt_payload_handler(user)
        token = jwt_encode_handler(payload)
        return token


'这个序列化类不做序列化和反序列化，只是用于登陆的校验'
class UserLoginSerializer(BaseUserSerializer,serializers.ModelSerializer):
    username = serializers.CharField()
    '''
        这里需要我们重新定义字段自己的校验
        否则就会因为用户表中定义的时候，规定的唯一限制导致报错
        unique=True
    '''
    class Meta:
        model = User
        fields = ['username', 'password']

    def _get_user(self,attrs):
        username = attrs.get('username')
        password = attrs.get('password')
        '接下来我们使用正则来匹配电话的格式'
        if re.match(r'^[3-9][0-9]{9}$', username):
            user = User.objects.filter(mobile=username).first()
        elif re.match(r'^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*\.[a-zA-Z0-9]{2,6}$', username):
            user = User.objects.filter(email=username).first()
        else:
            user = User.objects.filter(username=username).first()
        if user and user.check_password(password):
            return user
        else:
            raise APIException('用户名不存在或密码错误')

class UserMobileLoginSerializer(BaseUserSerializer,serializers.ModelSerializer):
    code = serializers.CharField()
    mobile = serializers.CharField()
    '''
        这里需要我们重新定义字段自己的校验
        否则就会因为用户表中定义的时候，规定的唯一限制导致报错
        unique=True
    '''

    class Meta:
        model = User
        fields = ['mobile', 'code']
    def _get_user(self, attrs):
        code = attrs.get('code')
        mobile = attrs.get('mobile')
        # 从缓存中取出来
        old_code = cache.get('sms_code_%s' % mobile)
        if old_code and old_code == code:
            # 根据手机号，查到用户
            user = User.objects.filter(mobile=mobile).first()
            if user:
                return user
            else:
                raise APIException('用户不存在')
        else:
            raise APIException('验证码验证失败')

短信注册接口

视图类

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

    def create(self, request, *args, **kwargs):
        # 使用父类的，会触发序列化，一定要让code只写
        super().create(request, *args, **kwargs)

        # 另一种写法，不用序列化
        # serializer = self.get_serializer(data=request.data)
        # serializer.is_valid(raise_exception=True)
        # self.perform_create(serializer)
        return APIResponse(msg='注册成功')

序列化类

# 数据校验，反序列化          有没有用序列化？有，但是你还不知道   只要调用ser.data,就会触发序列化，而code不是表的字段，一序列化报错了
class RegisterSerializer(serializers.ModelSerializer):
    # code 不是数据库字段，重写
    code = serializers.CharField(max_length=4, write_only=True)

    class Meta:
        model = User
        fields = ['mobile', 'code', 'password']
        extra_kwargs = {
            'password': {'write_only': True}
        }

    def validate(self, attrs):  # 全局钩子
        '''
        1 取出前端传入的code，校验code是否正确
        2 把username设置成手机号（你可以随机生成），用户名如果不传，存库进不去
        3 code 不是数据库的字段，从attrs中剔除
        '''
        mobile = attrs.get('mobile')
        code = attrs.get('code')
        old_code = cache.get('sms_code_%s' % mobile)
        if old_code and old_code == code:
            attrs['username'] = mobile
            attrs.pop('code')
        else:
            raise APIException('验证码验证失败')

        return attrs

    def create(self, validated_data):  # 一定要重写create，因为密码是明文，如果不重写，存入到数据库的也是明文
        # validated_data={username:18888,mobile:18888,password:123}
        # 创建用户
        user = User.objects.create_user(**validated_data)

        # 不要忘了return，后期，ser.data 会使用当前返回的对象做序列化
        return user