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

目录

• 回顾
• 腾讯云短信开发
  • 把短信封装成包
• 短信验证码接口
• 短信登录接口
  • 视图类方法中的逻辑
  • 代码
• 短信注册接口
  • 分析
  • 代码
• 补充
  • 接口幂等性
  • 异常捕获，可以捕获粒度更细一些
  • 自定义异常类

回顾

1.git回顾
2.pycharm操作git
	版权 --->>> 收费软件 --->>> vscode,社区版 vim搭建开发环境
  项目右键 --->>> git --->>> 很多操作，之前使用命令的，现在都可以通过， 点点点 完成
3.jecbrains 全家桶
	go
  java
4.登录注册页功能分析
	多方式登录接口	--->>> 完成
  验证手机号是否存在 --->>> 完成
  
  发送短信接口 --->>> 借助于第三方
  短信登录接口
  短信注册接口

腾讯云短信开发

给手机发送短信 --->>> 第三方平台：腾讯云短信 --->>>
# API和SDK,有SDK优先操作SDK

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

# 安装SDK
	方式一：pip install tencetcloud-sdk-python
  方式二源码安装：
  	下载源码
    	执行 python steup.py install
      
# 发送短信测试

把短信封装成包

-libs下：
    send_sms_v3
        __init__.py
        settings.py
        sms.py
        
       
    
# __init__.py
from .sms import get_code,send_sms


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

# sms.py
# 生成 n 位数字验证码的函数
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
from . import settings
import json


def get_code(number=4):
    code = ''
    for i in range(number):
        code += str(random.randint(0, 9))  # python 是强类型语言，不同类型运算不允许
    return code


# 发送短信函数
def send_sms(code, mobile):
    try:
        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-guangzhou", clientProfile)
        req = models.SendSmsRequest()

        req.SmsSdkAppId = settings.APP_ID
        req.SignName = settings.SIGN_NAME
        req.TemplateId = settings.TEMPLATE_ID
        # 模板参数: 模板参数的个数需要与 TemplateId 对应模板的变量个数保持一致，，若无模板参数，则设置为空
        req.TemplateParamSet = [code, '1']
        # 下发手机号码，采用 E.164 标准，+[国家或地区码][手机号]
        # 示例如：+8613711112222， 其中前面有一个+号 ，86为国家码，13711112222为手机号，最多不要超过200个手机号
        req.PhoneNumberSet = ["+86" + mobile, ]
        # 用户的 session 内容（无需要可忽略）: 可以携带用户侧 ID 等上下文信息，server 会原样返回
        req.SessionContext = ""
        # 短信码号扩展号（无需要可忽略）: 默认未开通，如需开通请联系 [腾讯云短信小助手]
        req.ExtendCode = ""
        # 国际/港澳台短信 senderid（无需要可忽略）: 国内短信填空，默认未开通，如需开通请联系 [腾讯云短信小助手]
        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

这样包以后无论在哪里都能使用

传的手机号码，但是还有验证码，而验证码我们还得存起来用于后面比对，不同的框架存储的位置不一样

短信验证码接口

class UserView(GenericViewSet):
  serilizer_class = UserLoginSerializer
  queryset = User.obujects.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 APIRsponse(msg='发送成功')
      else:
        return APIResponse(code=101,msg='发送失败')
      exception Exception as e:
				raise APIException(str(e))

多线程：

短信登录接口

# 前端 --->>> 以如下数据格式传入 {mobie:2452525,code:34525} --->>> post --->>>

视图类方法中的逻辑

1.取出手机号和验证码

2.校验验证码是否正确(发送验证码接口，存储验证码)

session：根本不用
全局变量：不好，可能取不到，因为集群环境中中
缓存：Django 自带缓存
	from django.core.cache import cache
  cache.set() 存，以key value的形式
  cache.get() 取

一开始请求过来是被某一条进程接收处理，而在进程中是在某一条线程上，同一进程中，数据能够共享。但在不同进程中数据是无法共享的。当发送请求过来的时候，你所定义的全局变量不在当前的进程中就无法拿到了

Django自带缓存，cache缓存，在内存中，重启就没了。

3.根据手机号查询用户，如果能查到

4.签发token

5.返回给前端

代码

视图类

class UserView(GenericViewSet):
    # class UserView(ViewSetMixin, GenericAPIView):
    serializer_class = UserLoginSerializer
    queryset = User.objects.all().filter(is_active=True)
    # 重写
    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 .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 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 UserMobileLoginSerializer(BaseUserSerializer, serializers.ModelSerializer):
    code = serializers.CharField()
    mobile = serializers.CharField()

    class Meta:
        model = User
        fields = ['mobile', 'code']  # code 不是表的字段，要重写 ，mobile 有唯一约束，需要重写
    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('验证码验证失败')

短信注册接口

分析

# 前端 --->>> 以如下形式传递过来	{mobie:18237534, code:3225, password:123} --->>> post请求

代码

路由

# http://127.0.0.1:8000/api/v1/user/register/   --->post 请求

视图类

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='注册成功')

序列化类

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

为啥要重写create，因为我们的密码是明文，不重写的话触发的是create，那么存的就是明文。我们要用create_user，这样存的就是密文

creat会基于你序列化类create所返回的数据做序列化，

补充

接口幂等性

接口幂等性就是用户对于统一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生副作用。

举例：用户在购买商品后支付，支付扣款成功，但是返回结果的时候网络异常，此时前已扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额发现多扣钱了，流水记录也变成两条，这就是没有保证接口的幂等性。

异常捕获，可以捕获粒度更细一些

自定义异常类

class WyfException(Exception):
  def __init__(self, massage):
    pass