def get(self, request):
# 获取并校验token
access_token = request.query_params.get('access_token')
if access_token is None:
return Response({"message": "token不存在"},
status=status.HTTP_404_NOT_FOUND)
# 从token中取出手机号
mobile = User.check_send_sms_code_token(access_token)
if mobile is None:
return Response({"message": "无效的access_token"},
status=status.HTTP_400_BAD_REQUEST)
# 检验发送短信验证码频次
redis_conn = get_redis_connection("verify_codes")
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return Response({"message": "发送短信过于频繁"},
status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码并发送短信验证码
sms_code = "%06d" % random.randint(0, 999999)
print('短信验证码是：%s' % sms_code)
# 使用redis的pipeline管道一次执行多个命令
pl = redis_conn.pipeline()
pl.setex('SMS_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
# 让管道执行命令
pl.execute()
send_sms_code.delay(mobile, sms_code)
return Response({"message", "OK"})
def get(self, request: Request):
# 获取并校验access_token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({'message': '缺少access_token'},
status=status.HTTP_400_BAD_REQUEST)
# 从access_token中获取手机号
mobile = User.check_send_sms_code_token(access_token)
if not mobile:
return Response({'message': '无效的access_token'},
status=status.HTTP_400_BAD_REQUEST)
# 判断手机号发送频次
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return Response({'message': '发送短信次数过于频繁'},
status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存并发送短信验证码
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
pl.execute()
send_sms_code.delay(mobile, sms_code)
return Response({'message': 'OK'})
def get(self, request):
#验证access_Token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({'message': '缺少accesstoken'},
status=status.HTTP_400_BAD_REQUEST)
mobile = User.check_send_sms_code_token(access_token)
if not mobile:
return Response({'message': 'access token 无效'},
status=status.HTTP_400_BAD_REQUEST)
#判断是否在60秒内
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return Response({'message': '请求次数过于频繁'},
status=status.HTTP_429_TOO_MANY_REQUESTS)
#生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
#保存短信验证码和发送记录
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
#发送短信验证码
pl.execute()
sms_tasks.send_sms_code.delay(mobile, sms_code,
constants.SMS_CODE_REDIS_EXPIRES / 60)
return Response({'message': 'ok'}, status=status.HTTP_200_OK)
def get(self, request):
# 获取并校验accss_token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({'message': '缺少access token'},
status=status.HTTP_400_BAD_REQUEST)
# 从access_token中取出手机号
mobile = User.check_send_sms_code_token(access_token)
if mobile is None:
return Response({'message': '无效的access token'},
status=status.HTTP_400_BAD_REQUEST)
# 判断手机号发送的次数
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return Response({"message": "发送短信次数过于频"},
status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
# 发送短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 使用redis的pipeline管道一次执行多个命令
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
# 让管道执行命令
pl.execute()
# 发送短信
# 使用celery发布异步任务
send_sms_code.delay(mobile, sms_code)
# 返回
return Response({'message': 'OK'})
def get(self, request):
# 获取并校验 access_token
# REST framework的Request类扩展自标准的HttpRequest，request.query_params 用来代替Django's标准 request.GET
# request.data返回request body解析后的内容。
access_token = request.query_params.get('access_token')
if not access_token:
return Response({"message": "缺少access token"},
status=status.HTTP_400_BAD_REQUEST)
# 从access_token中取出手机号
mobile = User.check_send_sms_code_token(access_token)
if mobile is None:
return Response({"message": "无效的access token"},
status=status.HTTP_400_BAD_REQUEST)
# 判断手机号发送的次数
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return Response({"message": "发送短信次数过于频"},
status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
# 发送短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存验证码及发送记录
# redis_conn.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# redis_conn.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
# 使用redis的pipeline管道一次执行多个命令
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
# 让管道执行命令
pl.execute()
# 发送短信
# ccp = CCP()
# time = str(constants.SMS_CODE_REDIS_EXPIRES / 60)
# ccp.send_template_sms(mobile, [sms_code, time], constants.SMS_CODE_TEMP_ID)
# 使用celery异步任务的方式 发送短信
send_sms_code.delay(mobile, sms_code)
# 返回
return Response({'message': 'OK'})
def get(self, request):
# 获取并校验access_token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({"message":"缺少acces_token "}, status=status.HTTP_400_BAD_REQUEST)
# 从access_token取出手机号
mobile = User.check_send_sms_code_token(access_token)
if mobile is None:
return Response({"message": "无效的access_token"}, status=status.HTTP_400_BAD_REQUEST)
# 判断手机号发送的次数
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get("send_flag_%s" % mobile)
if send_flag:
return Response({"message":"发送短信次数过于频繁"}, status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
print(sms_code)
# 保存短信验证码与发送记录
# redis_conn.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# redis_conn.setex('send_flag_%s' % mobile, contants.SEND_SMS_CODE_INTERVAL, 1)
# 保存验证码及发送记录
# 使用redis的pipeline管道一次执行多条命令
pl = redis_conn.pipeline()
pl.setex("sms_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex("send_flag_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
# 让管道执行命令
pl.execute()
# 发送短信验证码
# ccp = CCP()
# time = str(constants.SMS_CODE_REDIS_EXPIRES // 60)
# ccp.send_template_sms(mobile, [sms_code, time], constants.SMS_CODE_TEMP_ID)
# 使用celery发布异步任务
send_sms_code.delay(mobile, sms_code)
# 返回
return Response({"message": "OK"})
def get(self, request):
"""
凭借token发送短信验证码
"""
# 验证access_token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({'message': '缺少access token'},
status=status.HTTP_400_BAD_REQUEST)
mobile = User.check_send_sms_code_token(access_token)
# 使用的itsdangerouse模块
# 使用一个序列化器
# 通过手机号生成一个access_token,然后通过反序列化来验证这个token是刚才那个手机的吗
# 如果前端乱传token也找不到手机
if not mobile:
return Response({'message': 'access token无效'},
status=status.HTTP_400_BAD_REQUEST)
# 判断是否在60s内
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get("send_flag_%s" % mobile)
if send_flag:
return Response({"message": "请求次数过于频繁"},
status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存短信验证码与发送记录
pl = redis_conn.pipeline()
pl.setex("sms_%s" % mobile, 300, sms_code)
pl.setex("send_flag_%s" % mobile, 60, 1)
pl.execute()
# 发送短信验证码
# send_sms_code.delay(mobile, sms_code)
print(sms_code)
return Response({"message": "OK"}, status.HTTP_200_OK)
def get(self,request):
# 获取并校验 access_token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({'message':'缺少access_token'},status=status.HTTP_400_BAD_REQUEST)
# 从access_token中取出手机号
mobile = User.check_send_sms_code_token(access_token)
if mobile is None:
return Response({'message':'无效的access_token'},status=status.HTTP_400_BAD_REQUEST)
# 判断手机号发送次数
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return Response({'message':'发送短信次数过于频繁'},status=status.HTTP_429_TOO_MANY_REQUESTS)
# 校验通过
# 生产短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存验证码及发送记录
redis_conn = get_redis_connection("verify_codes")
# redis_conn.setex('sms_{}'.format(mobile),constants.SMS_CODE_REDIS_EXPIRES,sms_code)
# redis_conn.setex('send_flag_{}'.format(mobile),constants.SEND_SMS_CODE_INTERVAL,1)
# 使用redis的pipeline管道一次执行多个命令
pl = redis_conn.pipeline()
pl.setex('sms_{}'.format(mobile), constants.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('send_flag_{}'.format(mobile), constants.SEND_SMS_CODE_INTERVAL, 1)
# 让管道执行命令
pl.execute()
# 发送短信验证码
# ccp = CCP()
# ccp.send_tempate_sms(mobile,[sms_code,"5"],constants.SMS_CODE_TEMP_ID)
# 使用celery发布异步任务
send_sms_code.delay(mobile, sms_code)
# 返回
return Response({'message': 'OK'})
def get(self, request):
access_token = request.query_params.get('access_token')
# 发送验证码
sms_code = "%06d" % random.randint(0, 999999)
mobile = User.check_send_sms_code_token(access_token)
print('短信验证码是:', sms_code)
# 保存短信验证码与发送记录
redis_conn = get_redis_connection('image_code_store_redis')
# pl = redis_conn.pipeline()
# pl.multi()
redis_conn.setex("sms_%s" % mobile, contains.SMS_CODE_REDIS_EXPIRES,
sms_code)
# 设置一个短信已发状态
# redis_conn.setex("send_flag_%s" % mobile, contains.SEND_SMS_CODE_INTERVAL, 1)
sms_code_expires = contains.SMS_CODE_REDIS_EXPIRES // 60
# 服务商发送短信验证码
send_sms_code.delay(mobile, sms_code, sms_code_expires)
# ccp = CCP()
# ccp.send_template_sms(mobile, [sms_code, sms_code_expires], contains.SMS_CODE_TEMP_ID)
return Response({"message": "OK"}, status.HTTP_200_OK)
def get(self, request):
"""
凭借token发送短信验证码
:param request:
:return:
"""
# 验证access_token
access_token = request.query_params.get('access_token')
if not access_token:
return Response({'message': '缺少access token'},
status=status.HTTP_400_BAD_REQUEST)
mobile = User.check_send_sms_code_token(access_token)
if not mobile:
return Response({'message': 'access_token'},
status=status.HTTP_400_BAD_REQUEST)
# 判断是否在60s内
redis_conn = get_redis_connection('verify_codes')
send_flag = redis_conn.get("send_flag_%s" % mobile)
if send_flag:
return Response({"message": "请求次数过于频繁"},
status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存短信验证码与发送记录
p1 = redis_conn.pipeline()
p1.setex("sms_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
p1.setex("send_flag_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
p1.execute()
# 发送短信验证码
send_sms_code.delay(mobile, sms_code)
return Response({"message": "ok"}, status.HTTP_200_OK)
