def get(self, request):
# 接收token
access_token = request.GET.get('access_token')
# 解密
token = CookieSecret.loads(access_token)
# 验证token
user_id = token['user_id']
user_mobile = token['mobile']
try:
user = User.objects.get(id=user_id, mobile=user_mobile)
except:
return http.JsonResponse({'error': '数据错误'}, status=400)
# 生成短信验证码
sms_code = '%06d' % randint(0, 999999)
# 写入redis
redis_conn = get_redis_connection('sms_code')
redis_conn.setex('sms_%s' % user_mobile, 300, sms_code)
# 异步发送短信验证码
ccp_send_sms_code.delay(user_mobile, sms_code)
print("短信验证码是:", sms_code)
# 响应结果
return http.JsonResponse({'message': 'ok'})
def get(self, request):
"""验证用户名"""
# 接收查询字符串参数access_token
access_token = request.GET.get('access_token')
# 验证
user_info = json.loads(access_token)
try:
user = User.objects.get(mobile=user_info['mobile'])
except User.DoesNotExist:
return JsonResponse({'data': '用户不存在'})
# 发送短信验证码
# 防止用户不停刷新页面重发短信， 规定短信一分钟只能发一次
redis_conn = get_redis_connection('verify_code')
pl = redis_conn.pipeline()
flag = redis_conn.get('get_flag: %s' % user.mobile)
if flag:
return JsonResponse({'data': '访问过于频繁'})
sms_code = '%06d' % random.randint(0, 999999)
# 打印出sms_code的值
logger.info(sms_code)
# 保存短信验证码的值， 便于之后的校验
pl.setex('sms: %s' % user.mobile, constants.SMS_CODE_REDIS_EXPIRY, sms_code)
# 发送验证码
# CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRY // 60], 1)
pl.setex('get_flag: %s' % user.mobile, constants.SMS_CODE_REDIS_EXPIRY // 5, 1)
pl.execute()
ccp_send_sms_code.delay(user.mobile, sms_code)
return JsonResponse({'message': '短信发送成功'})
def get(self, request):
access_token = request.GET.get('access_token')
user_dict = SecretOauth().loads(access_token)
if user_dict is None:
return http.JsonResponse({'status': 400, 'errmsg': '参数不全'})
mobile = user_dict['mobile']
try:
User.objects.get(mobile=mobile)
except:
return http.JsonResponse({'status': 400, 'errmsg': '手机号不存在'})
# 验证
redis_cli_sms = get_redis_connection('sms_code')
# 是否60秒内
if redis_cli_sms.get(mobile + '_flag') is not None:
return http.JsonResponse({
'status': 400,
'errmsg': '发送短信太频繁，请稍候再发'
})
# 处理
# 1.生成随机6位数
sms_code = '%06d' % random.randint(0, 999999)
print(sms_code)
# 2.优化：使用管道
redis_pl = redis_cli_sms.pipeline()
redis_pl.setex(mobile, contants.SMS_CODE_REDIS_EXPIRE, sms_code)
redis_pl.setex(mobile + '_flag', contants.SEND_SMS_CODE_INTERVAL, 1)
redis_pl.execute()
# 3.发短信
# 通过delay调用，可以将任务加到队列中，交给celery去执行
ccp_send_sms_code.delay(mobile, sms_code)
return http.JsonResponse({'status': RETCODE.OK, 'errmsg': 'OK'})
def get(self, request, mobile):
from random import randint
sms_code = "%06d" % randint(0, 999999)
# sms_code = randint(100000, 999999)
print(sms_code)
sms_redis_client = get_redis_connection('sms_code')
# 1.取出标识
send_flag = sms_redis_client.get('send_flag_%s' % mobile)
# 2.判断标识
if send_flag:
return http.HttpResponseForbidden('短信发送频繁')
# 1.实例化管道
pipeline = sms_redis_client.pipeline()
# 2.将任务添加管道
pipeline.setex('send_flag_%s' % mobile, 60, 1)
pipeline.setex("sms_%s" % mobile, 300, sms_code)
# 3.实行管道'
pipeline.execute()
# 4.让第三方 容联云-给手机号-发送短信
from celery_tasks.sms.tasks import ccp_send_sms_code
ccp_send_sms_code.delay(mobile, sms_code)
# 5.告诉前端短信发送完毕
return Response({
'success': True,
'sms_code': sms_code,
'message': 'OK'
})
def get(self,request):
# 接收参数
access_token = request.GET.get('access_token')
# 解密
token = CookieSecret.loads(access_token)
# 提取用户id和手机号
user_id = token['user_id']
user_mobile = token['mobile']
print("提出来的用户手机号:",user_mobile)
# 校验用户的手机号是否存在
try:
mobile = User.objects.get(id=user_id,mobile=user_mobile)
except:
return http.JsonResponse({'error':'手机号不正确'},status=400)
# 生成短信验证码
from random import randint
sms_code = '%06d' % randint(0,999999)
# 写入redis中
redis_conn = get_redis_connection('sms_code')
redis_conn.setex('sms_%s' % user_mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code)
# 异步发送短信
ccp_send_sms_code.delay(user_mobile,sms_code)
print("手机验证码是:", sms_code)
# 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def send_sms_code(self, mobile):
"""
发送验证码
:param mobile: 手机号
:return:
"""
# 链接数据库
redis_conn = get_redis_connection('verify_code')
# 校验频繁发送
send_flag= redis_conn.get('sms_flag_%s' % mobile)
if send_flag:
return JsonResponse(
{'code': response_code.RET.REQERR, 'errmsg': '请勿频繁操作'})
# 生成随机验证码
sms_code = '%06d' % random.randint(0, 999999)
print(sms_code)
# 保存短信验证码
pl = redis_conn.pipeline()
pl.setex('sms_code_%s' % mobile, 300, sms_code)
pl.setex('sms_flag_%s' % mobile, 60, 1)
pl.execute()
# 发送短信验证码
# celery 用delay 去调用,开启异步
ccp_send_sms_code.delay(mobile,sms_code)
return JsonResponse(
{'code': response_code.RET.OK, 'errmsg': 'OK'})
def get(self, request, mobile):
# 检验标记
redis_conn = get_redis_connection("verify_code")
send_flag = redis_conn.get("send_flag_%s" % mobile)
# 检验是否有标记,有的话就是已经发过验证码
if send_flag:
return JsonResponse({"code": "dgjhc", "errmsg": "已经发过验证码了"})
# 获取对象
image_code_client = request.GET.get("image_code")
uuid = request.GET.get("uuid")
# 判断参数是否齐全
if not all([image_code_client, uuid]):
return JsonResponse({"code": RETCODE.NECESSARYPARAMERR, "errmsg": "缺少参数"})
# 从redis中取出uuid
image_code_server = redis_conn.get('img_%s' % uuid)
# 拿出后删除redis中验证码使失效
redis_conn.delete('img_%s' % uuid)
# 检验验证码是否过期
if not image_code_server:
return JsonResponse({"code": RETCODE.IMAGECODEERR, "errmsg": "图形验证码失效"})
# 比对图形验证码
image_code_server = image_code_server.decode()
print(image_code_client,"\n",image_code_server)
if image_code_client.lower() != image_code_server.lower():
return JsonResponse({"code": RETCODE.IMAGECODEERR, "errmsg": "图形验证码错误"})
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
logger.info(sms_code)
print(sms_code)
# 管道应用
p1 = redis_conn.pipeline()
# 保存短信验证码
p1.setex("sms_%s" % mobile,60, sms_code)
# 写入标记,设置60s过期
p1.setex("send_flag_%s" % mobile, contants.SMS_CODE_REDIS_EXPIRES, 1)
# info(redis_conn.get("send_flag%s")%mobile)
# 执行管道
p1.execute()
# 发送短信验证码
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({"code": RETCODE.OK, "errmsg": "短信发送成功"})
def get(self, reqeust, mobile):
"""
:param reqeust: 请求对象
:param mobile: 手机号
:return: JSON
"""
#1 创建连接到redis的对象
redis_conn = get_redis_connection('verify_code')
#2 判断60秒内是否重复访问
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'})
#3 接收参数
image_code_client = reqeust.GET.get('image_code')
uuid = reqeust.GET.get('image_code_id')
#4 验证参数
if not all([image_code_client,uuid]):
return http.JsonResponse({'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必传参数'})
#5 提取图形验证码
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
# 图形验证码过期或者不存在
return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码失效'})
#6 删除图形验证码，避免同一个图形验证码多次比较
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
#7 对比图形验证码
image_code_server = image_code_server.decode() # bytes转字符串
if image_code_client.lower() != image_code_server.lower(): # 转小写后比较
return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '输入图形验证码有误'})
#8 生成短信验证码：生成6位数验证码
sms_code = random.randint(0,999999) #sms_code = 6位随机验证码
logger.info(sms_code)
print(sms_code)
#9 创建Redis管道
pl = redis_conn.pipeline()
# 将Redis请求添加到队列
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 异步发送短信验证码
ccp_send_sms_code.delay(mobile, sms_code)
#11 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功'})
def get(self, request, mobile):
# 1.解析校验参数--mobile 不用校验
uuid = request.GET.get('image_code_id')
image_code = request.GET.get('image_code')
# 2.校验图形验证码 如果正确 发送验证码, 不正确 直接返回
# 2.1 根据uuid 去redis数据库查询 图片验证码
from django_redis import get_redis_connection
image_redis_client = get_redis_connection('verify_image_code')
redis_img_code = image_redis_client.get('img_%s' % uuid)
# 判断服务器返回的验证
if redis_img_code is None:
return http.HttpResponseForbidden('图形验证码失效了')
# 如果有值 删除redis服务器上的图形验证码
try:
image_redis_client.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 2.2 和前端传过来的进行做对比
# 千万注意: 在redis取出来的是 bytes 类型不能直接做对比 decode()
if image_code.lower() != redis_img_code.decode().lower():
return http.HttpResponseForbidden({'输入图形验证码有误'})
# 3.生成短信验证码,redis-存储
from random import randint
sms_code = "%06d" % randint(0, 999999)
sms_redis_client = get_redis_connection('sms_code')
# 4.让第三方 容联云-给手机号-发送短信
# from libs.yuntongxun.sms import CCP
# # 手机号 验证码 过期时间5分钟 ,类型默认1
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# # CCP().send_template_sms(mobile, [sms_code, 5], 1)
# print("当前验证码是:", sms_code)
# 发送短信验证码
# CCP().send_template_sms(mobile,[sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60], constants.SEND_SMS_TEMPLATE_ID)
# Celery异步发送短信验证码
from celery_tasks.sms.tasks import ccp_send_sms_code
ccp_send_sms_code.delay(mobile, sms_code)
print("当前验证码是:", sms_code)
# (异步发短信)
# 管道
pipeline = sms_redis_client.pipeline()
pipeline.setex("sms_%s" % mobile, 300, sms_code)
pipeline.setex('send_flag%s' % mobile, 60, 1)
pipeline.execute()
# 获取redis里面的标识
send_sms_flag = sms_redis_client.get('send_flag%s' % mobile)
if send_sms_flag:
return http.HttpResponseForbidden({'发送短信过于频繁'})
# 如果 倒计时标识 不在
# 5.告诉前端短信发送完毕
return JsonResponse({'code': '0', 'errmsg': '发送短信成功'})
def post(self, request):
# 提取参数
# image_code = request.GET.get('image_code') # 用户填写的图片验证码
# uuid = request.GET.get('image_code_id') # 用户图形验证码的uuid
# mobile =
data = json.loads(request.body.decode())
mobile = data.get('mobile')
text = data.get('text') # 用户输入的图形验证码
id = data.get('id')
# 校验参数
if not all([mobile, id, text]):
return JsonResponse({'code': 4101, 'errmsg': '缺少必要参数'})
# if not re.match(r'^[a-zA-Z0-9]{4}$', image_code):
# return JsonResponse({'code': 4101, 'errmsg': '图形验证码格式有误'})
# if not re.match(r'^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$', uuid):
# return JsonResponse({'code': 4101, 'errmsg': 'uuid格式有误'})
# 图形验证码校验 —— 根据uuid获取redis中的图形验证码，和用户填写的比对
conn = get_redis_connection('verify_code') # 2号
text1 = conn.get('img_%s' % id) # b"TYUP", redis客户端读取返回的数据统一是"字节"类型
# 为了保证图片验证码之后被使用一次，只需要读一次立刻删除
conn.delete('img_%s' % id)
if not text1:
# 如果图形验证码过期，text返回为空
return JsonResponse({'errno': 4101, 'errmsg': '图形验证码过期'})
# b"YUPO".decode() --> "YUPO"
if text.lower() != text1.decode().lower(): # 统一转化小写对比，意味着忽略大小写
return JsonResponse({'errno': 4101, 'errmsg': '图形验证码错误！'})
# 业务数据处理 —— 发送短信
# 用户每次发送短信时,给该手机号标记一段唯一码,持续60s
# 当用户再次发送短信时,判断是否有该唯一编码
flag = conn.get('send_flag_%s' % mobile)
if flag:
# 若有唯一编码,证明该手机号60s内发送过短信,直接返回
return JsonResponse({'errno': 4101, 'errmsg': '请勿频繁发送短信'})
# 生成固定6位数长度的0-9字符组成的验证码
sms_code = "%06d" % random.randrange(0, 999999)
print('短信：', sms_code)
# 把短信验证码写入redis
conn.setex('sms_%s' % mobile, 300, sms_code)
# 用户成功发送短信,给该手机号写入一段唯一编码
conn.setex('send_flag_%s' % mobile, 60, 1)
# 使用redis的pipline功能,把多个redis指令打包执行
# 1.获取redis的pipeline对象
p = conn.pipeline()
# 2.使用pipeline的对象方法实现调用指令
p.setex('sms_%s' % mobile, 300, sms_code) # 此处调用对象方法不会通信,只是把需求放入队列中
# 3.提交pipeline把指令通过网络一次性提交
p.execute()
# 发送短信
ccp_send_sms_code.delay(mobile, sms_code)
# 4、构建响应
return JsonResponse({'errno': 0, 'errmsg': 'ok'})
def get(self,request,mobile):
# 接收uuid和用户输入的验证码
uuid = request.GET.get('image_code_id')
image_code = request.GET.get('image_code')
# 连接redis,根据uuid取出图片验证码
image_client_redis = get_redis_connection('verify_image_code')
image_code_redis = image_client_redis.get('img_%s' % uuid)
# 判None
if image_code_redis is None:
return http.JsonResponse({'code': "4001", 'errmsg': '图形验证码失效了'})
# 删除redis数据库中的uuid中的图片验证码
try:
image_client_redis.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 判断redis取出来的数据和用户输入的验证码是否相等
if image_code.lower() != image_code_redis.decode().lower():
return http.JsonResponse({'code': "4001", 'errmsg': '图形验证码有误'})
# 生成短信验证码
from random import randint
sms_code = "%06d" % randint(0,999999)
# 保存验证码到redis数据库
sms_client_redis = get_redis_connection('sms_code')
# sms_client_redis.setex('sms_%s' % mobile ,300 ,sms_code)
# 避免频繁发送短信验证码
send_flag = sms_client_redis.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'})
# 创建Redis管道
pl = sms_client_redis.pipeline()
# 将Redis请求添加到队列
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()
# 使用第三方平台荣联云给手机号发短信
# from libs.yuntongxun.sms import CCP
# CCP().send_template_sms(mobile,[sms_code,5],1)
# Celery异步发送短信验证码
from celery_tasks.sms.tasks import ccp_send_sms_code
ccp_send_sms_code.delay(mobile, sms_code)
print("当前验证码是:",sms_code)
print("手机号:",mobile)
# 告诉前端 短信发送完毕
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功！'})
def get(self, request, mobile):
"""
:param request:
:param mobile: 手机号
:return:
"""
# 接收获取参数
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('uuid')
# 校验参数
if not all([image_code_client, uuid]):
return http.JsonResponse({'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必传参数'})
# 连接到redis 获取验证码对象
redis_conn = get_redis_connection('verify_code')
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
# 图形验证码不存在或者过期
return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码失效'})
# 删除已经验证过的验证码, 避免重复使用
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 对比图片验证码
image_code_server = image_code_server.decode()
if image_code_client.lower() != image_code_server.lower():
return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码有误'})
# 生成6位数字短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存验证码到redis中
# 创建redis对象
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)
# CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60],
# constants.SEND_SMS_TEMPLATE_ID)
# 异步发送验证码
ccp_send_sms_code.delay(mobile, sms_code)
print(sms_code)
# 相应发送结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功'})
def get(self, request, mobile):
# 获取redis对象
redis_conn = get_redis_connection('verify_code')
# 获取redis中设置的判断
# 用于判断用户是否中60秒内重复发送短信
sms_flag = redis_conn.get('sms_flag_%s' % mobile)
if sms_flag:
return JsonResponse({'code': 404, 'errmsg': '发送短信过于频繁'})
# 获取用户输入的图形验证码
image_code_client = request.GET.get('image_code')
# 获取该图形验证码的uuid
uuid = request.GET.get('image_code_id')
# 判断用户是否输入
if not all([image_code_client, uuid]):
return JsonResponse({'code': 404, 'errmsg': '缺少必传参数'})
# 获取redis中的图形验证码用于与用户的进行对比
image_code_server = redis_conn.get('image_%s' % uuid)
# 判断uuid是否过期
if not image_code_server:
return JsonResponse({'code': 404, 'errmsg': '验证码已失效'})
# 对获取的验证码进行解码成字符串
image_code_server = image_code_server.decode()
try:
# 获取图形验证码后进行删除
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 设置小写后，进行图形验证码对比
if image_code_server.lower() != image_code_client.lower():
return JsonResponse({'code': 404, 'errmsg': '验证码错误'})
# 生成6位数短信验证码
sms_code = '%06d' % randint(0, 999999)
print(sms_code)
# 设置管道，提高效率，减少握手次数
pl = redis_conn.pipeline()
redis_conn.setex('sms_%s' % mobile, 300, sms_code)
redis_conn.setex('sms_flag_%s' % mobile, 60, 1)
# 执行管道
pl.execute()
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 使用了celery程序进行发送短信---'异步'
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({'code': 0, 'errmsg': '发送成功'})
def get(self, request, mobile):
# 创建连接到redis数据库的对象
redis_conn = get_redis_connection('verify_code')
# 进入函数，获取redis里面的值，如果获取成功，说明没过60s
time_redis = redis_conn.get('time_%s' % mobile)
if time_redis:
return JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'})
# 接受查询参数参数
image = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 校验参数
if not all([image, uuid]):
return JsonResponse({"code": 400, "errmsg": '缺少必传参数'})
# 提取图片验证码
image_redis = redis_conn.get('img_%s' % uuid)
# 验证验证码过期或不存在
if image_redis is None:
return JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
# 删除redis中的图形验证码
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 对比图形验证码
image_new = image_redis.decode('utf-8')
if image.lower() != image_new.lower():
return JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'})
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
# 创建 Redis 管道
pl = redis_conn.pipeline()
# 将 Redis 请求添加到队列
pl.setex('sms_%s' % mobile, 300, sms_code)
pl.setex('time_%s' % mobile, 60, 1)
# 执行请求, 这一步千万别忘了
pl.execute()
# 保存短信验证码
# 短信验证码有效时间，300秒
# 发送短信验証码
ccp_send_sms_code.delay(mobile, sms_code)
# return JsonResponse({'code':0,'errmsg':'短信发送成功'})
return JsonResponse({'code': 0, 'errmsg': 'ok'})
def get(self, request, mobile):
# 在一开始,先对提取标志数据,判断相同的电话操作是否超过60秒了, 避免短信频繁操作
# 3.创建链接到redis的对象
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
logger.warning('短信发送过于频繁')
return http.JsonResponse({'code': 400, 'errmsg': '短信发送过于频繁'})
# 1.接受参数:图形验证码,uuid,电话号码
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 2.整体校验参数
if not all([image_code_client, uuid]):
return http.JsonResponse({'code': 400, 'errmsg': '缺少比传参数'})
# 4.提取图形验证码
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
# 5.删除redis的图形验证码,避免恶意测试图形验证码
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 6.对比图形验证码
image_code_server = image_code_server.decode()
if image_code_client.lower() != image_code_server.lower():
return http.JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'})
# 7.生成短信验证码:生成6位数验证码
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
# 通过管道方式优化客户端与redis通讯次数
# 创建管道
pl = redis_conn.pipeline()
# 将redis请求添加到队列
# 8.保存短信验证码
pl.setex('sms_%s' % mobile, 300, sms_code)
# 同时保存一个标记60秒, 用于避免短信轰炸
pl.setex('send_flag_%s' % mobile, 60, 1)
# 执行请求
pl.execute()
# 9.发送短信验证码
# CCP().send_template_sms(mobile,[sms_code,5],1)
ccp_send_sms_code.delay(mobile, sms_code)
# 10.响应结果
return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self, request, mobile):
# '/sms_codes/' + this.mobile + '/ ?image_code=' + this.image_code + '&image_code_id=' + this.image_code_id;
# 接受路径查询参数 用户输入的验证码 及 UUID
image_code = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 连接 验证码的redis 数据库
image_redis_client = get_redis_connection('verify_image_code')
redis_image_code = image_redis_client.get(uuid)
# 判断 取出验证码是否为空， 如果为空则说明验证码过期
if redis_image_code is None:
return http.JsonResponse({'code': "4001", 'errmsg': '图形验证码失效了'})
# 判断 取出验证码与输入验证码是否一直, 注意大小写的转换, 注意 从redis 数据库中取出的数据为 bytes 类型
if image_code.lower() != redis_image_code.decode().lower():
return http.JsonResponse({'code': "4001", 'errmsg': '输入图形验证码有误'})
# 删除 redis 数据库中的验证码
try:
image_redis_client.delete(uuid)
except Exception as e:
logger.error(e)
# 开始生成随机的六位数的验证码
sms_code = randint(100000, 999999)
# 连接保存短信验证码的redis数据库
sms_redis_client = get_redis_connection('sms_code')
# 判断是否已经发送过短信
send_flag = sms_redis_client.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'})
# 保存生成的短信验证码, 用手机号作为键
# sms_redis_client.setex(mobile, 300, sms_code)
# 在redis中保存已经发送过短信的记录
# sms_redis_client.setex('send_flag_%s' % mobile, 60, 1)
# redis 的管道操作 ， 将多个要进行的操作装进管道中，一起进行操作
p1 = sms_redis_client.pipeline()
p1.setex(mobile, 300, sms_code)
p1.setex('send_flag_%s' % mobile, 60, 1)
p1.execute()
# 1. 发送短信
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 2. 调用celery 异步发送短信
ccp_send_sms_code.delay(mobile, sms_code)
print('当前的验证码是：', sms_code)
return http.JsonResponse({'code': '0', 'errmsg': '发送短信成功'})
def get(self, request, mobile):
conn = get_redis_connection("verify_code")
send_sms = conn.get('sms_code_%s' % mobile)
if send_sms:
return http.HttpResponseForbidden('短信验证码发送频繁')
image_code_cilent = request.GET.get("image_code")
uuid = request.GET.get("image_code_id")
# 判断参数
if not all([image_code_cilent, uuid]):
return http.JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': "缺少必传参数"
})
# 教研参数
image_code = conn.get('img_%s' % uuid)
if image_code is None:
return http.JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': "图片验证码过期"
})
try:
conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
image_code_server = image_code.decode()
if image_code_cilent.lower() != image_code_server.lower():
return http.JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': "图片验证码错误"
})
# 生成验证码
sms_code = '%06d' % random.randint(0, 999999)
print(sms_code)
# 保存到redis
pl = conn.pipeline()
pl.setex('sms_code_%s' % mobile, constants.IMAGE_CODE_REDIS_EXPIRES,
sms_code)
pl.setex('send_flag_%s' % mobile, constants.IMAGE_CODE_REDIS_EXPIRES,
1)
pl.execute()
# 发送验证码
# CCP().send_template_sms(mobile,[sms_code,5],constants.SMS_CDDE_ID)
ccp_send_sms_code.delay(mobile, sms_code)
return http.JsonResponse({'code': RETCODE.OK, 'error': 'ok'})
def get(self, request):
access_token = request.GET.get("access_token")
mobile = check_openid_signature(access_token)
sms_code = "%06d" % random.randint(0, 999999)
print(mobile, sms_code)
logger.info(sms_code, "jafjsdkajfk")
# 调用发短信
ccp_send_sms_code.delay(mobile, sms_code)
# 存入redis
redis_coon = get_redis_connection("verify_code")
redis_coon.setex("sms_code_%s" % mobile, 60, sms_code)
# 响应结果
return JsonResponse({"code": RETCODE.OK, "errmsg": "OK"})
def get(self, request, mobile):
redis_conn = get_redis_connection('verify_code')
time_redis = redis_conn.get('time_%s' % mobile)
if time_redis:
return JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'})
# 接收参数
image_code_c = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 校验参数
if not all([image_code_c, uuid]):
return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
# 创建连接到redis的对象
# 提取图片验证码
image_code_s = redis_conn.get('img_%s' % uuid)
if image_code_s is None:
return JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
image_new = image_code_s.decode()
# 对比图形验证码
if image_code_c.lower() != image_new.lower():
return JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'})
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
pl = redis_conn.pipeline()
# 保存短信验证码
# 有效时间为300秒
pl.setex('sms_%s' % mobile, 300, sms_code)
pl.setex('time_%s' % mobile, 60, 1)
pl.execute()
# 发送短信验证码
# CCP().send_template_sms(mobile,[sms_code,5],1)
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self,request,mobile):
#获取图形验证码的值
uuid = request.GET.get('image_code_id')
image_code = request.GET.get('image_code')
#获取数据库中图形验证码的值
image_redis_client = get_redis_connection('verify_image_code')
redis_image_code = image_redis_client.get(uuid)
#进行托图片验证码对比
if redis_image_code is None:
return http.JsonResponse({'code':'4001','errmsg':'图形验证码失效了'})
#删除uuid
try :
image_redis_client.delete('uuid')
except Exception as e:
logger.error(e)
if image_code.lower() != redis_image_code.decode().lower():
return http.JsonResponse({'code':'4001','errmsg':'输入图形验证码有误'})
#随机生成六位随机码
sms_cod = '%06d' % randint(0,999999)
sms_redis_cilent = get_redis_connection('sms_code')
sms_redis_cilent.setex(mobile,300,sms_cod)
#获取频繁发送短信的标识
send_flag = sms_redis_cilent.get('send_flag_%s' % mobile)
print(send_flag)
if send_flag:
return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'})
#重新写入send_flag的值，设置过期时间为60s
#管道写法
p1 = sms_redis_cilent.pipeline()
p1.setex('send_flag_%s' % mobile, 60, 1)
p1.setex('sms_%s' % mobile, 60, sms_cod)
p1.execute()
# sms_redis_cilent.setex('send_flag_%s' % mobile,60,1)
# sms_redis_cilent.setex('sms_%s' % mobile, 60, sms_cod)
#通过第三方软件发送手机验证码
#异步触发任务
from celery_tasks.sms.tasks import ccp_send_sms_code
ccp_send_sms_code.delay(mobile, sms_cod)
# from libs.yuntongxun.sms import CCP
# CCP().send_template_sms(18742078950,[sms_cod,5],1)
print('当前验证码是',sms_cod)
return http.JsonResponse({'code':'0','errmsg':'发送短信成功'})
def get(self, request, mobile):
# GET http: // www.meiduo.site: 8000/sms_codes/18500000000/?image_code=IIJB&image_code_id=846b06a7-5766-4175-8d1f-c05625d0679c
# *补充逻辑: 先判断用户是否频繁发送短信
redis_conn = get_redis_connection('verify_code')
send_flag_mobile = redis_conn.get('send_flag_%s' % mobile)
if send_flag_mobile:
return http.JsonResponse({'code': 400, 'errmsg': '请勿频繁发送短信验证码'})
# 1. 接收参数
image_code_client = request.GET.get('image_code')
image_code_id_client = request.GET.get('image_code_id') # 其实就是获取到uuid
# 2. 校验参数
if not all([image_code_client, image_code_id_client]):
return http.JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
# 3. 对比图形验证码，从redis数据库中取图形验证码
redis_conn = get_redis_connection('verify_code')
redis_image_code = redis_conn.get('img_%s' % image_code_id_client)
# 3.1 *小细节：提取可能没数据
if not redis_image_code:
return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
# 3.2 每提取一次立即删除redis数据库中的图形验证码，防止被恶意用户利用
redis_conn.delete('img_%s' % image_code_id_client)
# 3.3 比对图形验证码
redis_image_code = redis_image_code.decode()
if image_code_client.lower() != redis_image_code.lower():
return http.JsonResponse({'code': 400, 'errmsg': '图形验证码错误'})
# 3.4 生成随机短信验证码并保存到redis数据库，发送短信给客户手机
random_num = random.randint(0, 999999)
sms_code = '%06d' % random_num
logger.info(sms_code) # 小技巧：可以在终端输出，测试的时候绕过云通讯，查看生成的短信验证码
# redis_conn.setex('sms_%s' % mobile, 300, sms_code)
# redis_conn.setex('send_flag_%s' % mobile, 60, 1) # *小细节：设置send_flag_mobile，标识，防止恶意用户再次刷新页面就可以频繁再次发送短信
# *小细节：创建pipline管道提升redis读写性能
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, 300, sms_code)
pl.setex('send_flag_%s' % mobile, 60, 1)
pl.execute()
# 3.5 发送短信
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# *小细节: 由于客户收到短信可能是会有延迟，他会在页面一直等待，直到短信发送成功后，才开始计时60秒，
# 用户交互-->美多商城-->发送短信-->响应结果 + 倒计时， 其中发送的短信是一个耗时操作。
# 所以，应该做异步处理，把相应结果+倒计时解耦出来，展示给用户应该是先计时，增强用户体验
# 异步函数.delay()
ccp_send_sms_code.delay(mobile, sms_code)
# 4.响应结果
return http.JsonResponse({'code': 0, 'errmsg': 'ok'})
def get(self, request, mobile):
# 防止用户不停刷新页面重发短信， 规定短信一分钟只能发一次
redis_conn = get_redis_connection('verify_code')
pl = redis_conn.pipeline()
flag = redis_conn.get('get_flag: %s' % mobile)
if flag:
return JsonResponse({
'code': RETCODE.THROTTLINGERR,
'errmsg': '访问过于频繁'
})
image_code_cli = request.GET.get('image_code')
uuid = request.GET.get('uuid')
if all([image_code_cli, uuid]) is False:
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少必传参数'
})
image_code_server = redis_conn.get('img: %s' % uuid)
# 在数据库获取图片验证码后立即删掉， 防止一直输入相同的验证码，恶意点击发送短信
redis_conn.delete('img: %s' % uuid)
if image_code_server is None or image_code_cli.lower(
) != image_code_server.decode().lower():
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图形验证码不正确'
})
sms_code = '%06d' % random.randint(0, 999999)
# 打印出sms_code的值
logger.info(sms_code)
# 保存短信验证码的值， 便于之后的校验
pl.setex('sms: %s' % mobile, constants.SMS_CODE_REDIS_EXPIRY, sms_code)
# 发送验证码
# CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRY // 60], 1)
pl.setex('get_flag: %s' % mobile, constants.SMS_CODE_REDIS_EXPIRY // 5,
1)
pl.execute()
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def get(self, request, mobile):
# 获取传入参数 验证码，之前存入的uuid
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 创建redis链接对象
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'})
if not all([image_code_client, uuid]):
return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
# 获取uid对应的value(二进制)
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
return JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 判断验证码是否正确
if image_code_client.lower() != image_code_server.decode().lower():
logger.info('输入图形验证码有误')
return JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'})
sms_code = '%06d' % random.randint(1, 999999)
# 日志输出验证码
logger.info('短信验证码:%s' % sms_code)
# 管道创建
p1 = redis_conn.pipeline()
# redis保存电话与验证码，保存倒计时时间
p1.setex('sms_%s' % mobile, 300, sms_code)
p1.setex('send_flag_%s' % mobile, 300, 1)
# 管道执行
p1.execute()
# 发送短信
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 代码优化 celery 异步
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({'code': 0, 'errmsg': '发送短信验证码成功'})
def get(self, reqeust, mobile):
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'})
image_code_client = reqeust.GET.get('image_code')
uuid = reqeust.GET.get('image_code_id')
if not all([image_code_client, uuid]):
return http.JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
image_code_server = image_code_server.decode()
if image_code_client.lower() != image_code_server.lower():
return http.JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'})
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
pl = redis_conn.pipeline()
pl.setex('sms_code_%s' % mobile, 300, sms_code)
pl.setex('send_flag_%s' % mobile, 60, 1)
pl.execute()
# 原来的写法:
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 改为现在的写法, 注意: 这里的函数,调用的时候需要加: .delay()
# ccp_send_sms_code.delay(mobile, sms_code)
ccp_send_sms_code.delay(mobile, sms_code)
return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self, request, mobile):
# - 1.接收参数 解析参数
image_code = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# - 2.校验图形验证码 redis
# img_client = get_redis_connection('verify_image_code')
# redis_img_code = img_client.get('img_%s' % uuid)
#
# if image_code.lower() != redis_img_code.decode().lower():
# return http.HttpResponseForbidden('验证码输入有误!')
# - 3.生成随机6位码
import random
sms_code = random.randint(100000, 999999)
# 4.使用 容联云 发送短信
sms_client = get_redis_connection('sms_code')
# 获取redis里面的标识
send_sms_flag = sms_client.get('send_flag%s' % mobile)
# 如果 倒计时的标识 在
if send_sms_flag:
return http.HttpResponseForbidden('短信发送太频繁,请稍后!')
# 如果 倒计时的标识 不在
# 使用异步任务 celery工具 发短信
from celery_tasks.sms.tasks import ccp_send_sms_code
ccp_send_sms_code.delay(mobile, sms_code)
print('项目里面的短信:', sms_code)
# 5.存储短信
pipeline = sms_client.pipeline()
pipeline.setex("sms_%s" % mobile, 300, sms_code)
pipeline.setex('send_flag%s' % mobile, 60, 1)
pipeline.execute()
# - 6.返回响应对象a
return http.JsonResponse({'code': '0', 'errmsg': '发送短信成功'})
def get(self,request):
password = request.COOKIES.get('access_token')
try:
user = User.objects.get(password=password)
# pbkdf2_sha256$36000$pYlJBXo314NN$ijot9M902M4+CMxN7qh6W9NW542JTfH9krY+Io/NnjM=
except User.DoesNotExist:
return JsonResponse({'code':RETCODE.DBERR,'errmsg':'无效密码'})
mobile = user.mobile
redis_connet = get_redis_connection('verify_code')
send_flag = redis_connet.get('send_flag_%s' % mobile)
if send_flag:
return JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'})
import random
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
pl = redis_connet.pipeline()
pl.setex('sms_%s' % mobile, 300, sms_code)
pl.setex('send_flag_%s' % mobile, 60, 1)
pl.execute()
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def get(self, request, mobile):
# 0.检验短信标志是否存在, 避免短信轰炸
# 需要先链接数据库, 提取短信标志, 才能判断
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': 400, 'errmsg': '短信发送过于频繁'})
# 1.获取参数
uuid = request.GET.get('image_code_id')
image_code_client = request.GET.get('image_code')
# 2.验证参数(整体验证, 单个验证)
if not all([uuid, image_code_client]):
return http.JsonResponse({'code': 400, 'errmsg': '参数有误'})
# 图形验证码检验(提取,删除,对比)
# 提取
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
return http.JsonResponse({'code': 400, 'errmsg': '图形码失效'})
# 删除
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 对比
if image_code_client.lower() != image_code_server.decode().lower():
return http.JsonResponse({'code': 400, 'errmsg': '图形码验证失败'})
# 3.生成短信验证码
sms_code = '%d' % random.randint(100000, 999999)
logger.info(sms_code)
# 4.保存短信验证码
# 用管道pipeline
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, 300, sms_code)
pl.setex('send_flag_%s' % mobile, 60, 1)
pl.execute()
# 5.发送短信验证码
#采用异步方案
ccp_send_sms_code.delay(mobile, sms_code)
# 6.返回响应结果
return http.JsonResponse({'code': 200, 'errmsg': 'ok'})
def get(self, request):
access_token = request.GET.get('access_token')
user_dict = CookieSecret.loads(access_token)
if user_dict is None:
return JsonResponse({}, status=400)
mobile = user_dict['mobile']
try:
User.objects.get(mobile=mobile)
except:
return JsonResponse({}, status=400)
# 验证
redis_cli_sms = get_redis_connection('sms_code')
# 0.是否60秒内
if redis_cli_sms.get(mobile + '_flag') is not None:
return JsonResponse({
'code': RETCODE.SMSCODERR,
'errmsg': '发送短信太频繁，请稍候再发'
})
# # 处理
# # 1.生成随机6位数
sms_code = '%06d' % random.randint(0, 999999)
print(sms_code)
# 优化：使用管道
redis_pl = redis_cli_sms.pipeline()
redis_pl.setex(mobile, constants.SMS_CODE_EXPIRES, sms_code)
redis_pl.setex(mobile + '_flag', constants.SMS_CODE_FLAG, 1)
redis_pl.execute()
# 3.发短信
# 通过delay调用，可以将任务加到队列中，交给celery去执行
from celery_tasks.sms.tasks import ccp_send_sms_code
ccp_send_sms_code.delay(mobile, sms_code)
# 响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def get(self, request, mobile):
# 链接到redis数据库,获取手机号
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': 400, 'errmsg': '发送过于频繁'})
# 接受前端参数
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 整体校验
if not all([image_code_client, uuid]):
return http.JsonResponse({'code': 400, 'errmsg': '缺少必要参数'})
# 获取图形验证码
image_code_server = redis_conn.get('img_%s' % uuid)
# 图形验证码校验
if image_code_server is None:
return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
# 删除redis中图形验证码
try:
redis_conn.delete('img_%s' % uuid)
except Exception as error:
logger.error(error)
# 服务端图形验证码转换
image_code_server = image_code_server.decode()
# 图形验证码对比
if image_code_client.lower() != image_code_server.lower():
return http.JsonResponse({'code': 400, 'errmsg': '输入有误'})
# 生成6位短信验证码
# sms_code = '%06d' % random.randint(0, 999999)
sms_code = 123456
logger.info(sms_code)
# 创建管道并执行
pl = redis_conn.pipeline()
pl.setex('sms_%s' % mobile, 300, sms_code)
pl.setex('send_flag_%s' % mobile, 60, 1)
pl.execute()
# 发送短信
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
ccp_send_sms_code.delay(mobile, sms_code)
return http.JsonResponse({'code': 0, 'errmsg': '发送成功'})
def get(self, request, mobile):
img_code_cli = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
if not all([uuid, img_code_cli]):
return JsonResponse({'code': 400, 'errmsg': '参数获取不全'})
redis_conn = get_redis_connection('verify_code')
img_code_server = redis_conn.get(f'img_{uuid}')
if not img_code_server:
return JsonResponse({'code': 400, 'errmsg': '验证码过期'})
try:
redis_conn.delete(f'img_{uuid}')
except Exception as e:
logger.info(e)
if img_code_cli.lower() != img_code_server.decode().lower():
return JsonResponse({'code': 400, 'errmsg': '验证码错误'})
if redis_conn.ttl(f'sms_{mobile}') > 240 and redis_conn.get(
f'sms_{mobile}'):
return JsonResponse({'code': 400, 'errmsg': '请勿频繁发送'})
sms_code = randomNumber()
redis_conn.setex(f'sms_{mobile}', 300, sms_code)
print(sms_code)
# CCP().send_template_sms(mobile, (sms_code, 5), 1)
ccp_send_sms_code.delay(mobile, sms_code)
return JsonResponse({'code': 0, 'errmsg': '短信发送成功'})
def get(self, request, mobile):
"""
:param request:
:param mobile:手机号
:return: JSON
"""
#校验是否已发送过短信验证码，避免重复发送
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
# 查看数据是否存在, 如果存在, 说明60s没过, 返回
if send_flag:
return http.JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'})
# 接受参数
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 参数校验
if not all([image_code_client, uuid]):
return http.JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
# 链接redis库，提取图形验证码
redis_conn = get_redis_connection('verify_code')
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
# 图形验证码过期
return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'})
# 删除图形验证码，避免恶意测试图形验证码
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 对比图形验证码
image_code_server = image_code_server.decode()
if image_code_client.lower() != image_code_server.lower():
return http.JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'})
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
#pipeline,减少客户端与redis的通信次数，降低往返延时
pl = redis_conn.pipeline()
# 保存短信验证码，为了注册时校验
pl.setex('sms_%s' % mobile, 300, sms_code)
#设置一个send_flag，用于访问接口时先校验是否存在，从而判断是否重复发送短信验证码
pl.setex('send_flag_%s' % mobile, 60, 1)
#执行和redis的请求
pl.execute()
# 调用celery发送短信验证码
ccp_send_sms_code.delay(mobile, sms_code)
# 10. 响应结果
return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
