def get(self, reqeust, mobile):
"""
:param reqeust: 请求对象
:param mobile: 手机号
:return: JSON
"""
# 生成短信验证码：生成6位数验证码
sms_code = '%06d' % random.randint(0, 999999)
looger.info(sms_code)
# print(sms_code)
# 创建连接到redis的对象
redis_conn = get_redis_connection('verify_code')
# 保存短信验证码
# 短信验证码有效期，单位：300秒
redis_conn.setex('sms_%s' % mobile, 300, sms_code)
# 发送短信验证码
# 短信模板
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 响应结果
return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self, request):
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
uuid = request.GET.get('uuid')
if not all([mobile, image_code, uuid]):
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少必要参数'
})
redis_conn = get_redis_connection('default')
redis_image_code = redis_conn.get('img:%s' % uuid)
if redis_image_code is None:
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图片验证码已过期'
})
try:
redis_conn.delete('img:%s' % uuid)
except Exception as e:
logger.error(e)
if redis_image_code.decode().lower() != image_code.lower():
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图片验证码错误'
})
sms_code = '%06d' % randint(0, 999999)
logger.info(sms_code)
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
CCP().send_template_sms(mobile, [sms_code, 5], 1)
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def ccp_send_sms_code(mobile, sms_code):
'''发送短信异步任务'''
from libs.yuntongxun.sms import CCP
send_result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
print(send_result)
return send_result
def send_sms_code(mobile, sms_code):
from libs.yuntongxun.sms import CCP
# 手机号 验证码 过期时间 1短信模板
result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
print("celery验证码:", sms_code)
return result
def get(self, request):
pass
# 1、接收参数
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('uuid')
mobile = request.GET.get('mobile')
logging.info(image_code_client, uuid, mobile)
# 2、校验参数
# 2.1验证参数是否齐全
if not all([image_code_client, uuid, mobile]):
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少必传参数'
})
# 2.2图片验证码的验证
# 创建连接到redis的对象，连接redis，获取redis中的图片验证码
redis_conn = get_redis_connection('default')
# 提取图形验证码
image_code_server = redis_conn.get('img:%s' % uuid)
# 判断图片验证码是否存在
if image_code_server is None:
# 图形验证码过期或者不存在
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图形验证码失效'
})
# 如果图片验证码未过期，我们获取到之后，就可以删除图片验证码了
# 删除图形验证码，避免恶意测试图形验证码
try:
redis_conn.delete('img:%s' % uuid)
except Exception as e:
logger.error(e)
# 对比图形验证码，注意大小写的问题，redis的数据是bytes类型
image_code_server = image_code_server.decode() # bytes转字符串
if image_code_client.lower() != image_code_server.lower(): # 转小写后比较
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '输入图形验证码有误'
})
# 3、生成短信验证码：生成6位数验证码
sms_code = '%06d' % randint(0, 999999)
#将验证码输出在控制台，以方便调试
logger.info("短信验证码是： " + sms_code)
# 4、保存短信验证码到redis中，并设置有效期
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
# 5、发送短信验证码
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 6、响应结果
# 没有注册短信发送的这个，直接返回true
return JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功'})
def get(self, request):
uuid = request.GET.get('uuid')
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
# verify parameters
if not all([uuid, mobile, image_code]):
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': 'Input parameters have problems'
})
redis_conn = get_redis_connection('default')
saved_image_code = redis_conn.get('img:' + str(uuid))
if saved_image_code is None:
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': 'Image code has run out of time'
})
try:
redis_conn.delete('img' + str(uuid))
except Exception as e:
logger.error(e)
if saved_image_code.decode().lower() != image_code.lower():
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': 'Image code is incompatible'
})
ccp = CCP()
sms_code = random.randint(100000, 999999)
ccp.send_template_sms(mobile, [sms_code, 5], 1)
# save the sms code in redis for following register authentication
redis_conn.setex('mob:' + str(mobile), 300, sms_code)
return JsonResponse({'code': RETCODE.OK})
def send_sms_code( self,mobile, sms_code):
try:
result = CCP().send_template_sms(mobile, [sms_code, YUNTONGXUN_EXPIRE_TIME], 1)
if result != 0:
raise Exception('下单失败')
except Exception as exc:
logger.error(exc)
raise self.retry(exc=exc,max_retries=3)
def send_sms_code_ccp(mobile, sms_code):
# 手机号 6位码 过期时间分钟 短信模板
result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
print(sms_code)
return result
def ccp_send_sms_code(mobile, sms_code):
# 5.发送短信-- 第三方联容云--
from libs.yuntongxun.sms import CCP
# CCP().send_template_sms('手机号', ['验证码', '过期时间5分钟'], 短信模板1)
result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
print("当前验证码是:", sms_code)
return result
def get(self, request, mobile):
# ① 获取数据
# mobile
# 用户的输入的图形验证码: image_code
# uuid: image_code_id
image_code = request.GET.get('image_code')
image_code_id = request.GET.get('image_code_id')
# ② 验证数据
if not all([image_code, image_code_id]):
return http.HttpResponseBadRequest('参数不全')
# 省略 用户验证码长度验证
# 省略 image_code_id 的正则验证
# ③ 比对用户输入的验证码和redis的验证码是否一致
# 3.1 连接redis
from django_redis import get_redis_connection
redis_conn = get_redis_connection('code')
# 3.2 获取指定的数据
redis_text = redis_conn.get('img_%s' % image_code_id)
# 3.3 判断验证码是否过期
if redis_text is None:
return http.HttpResponseBadRequest('图片验证码以过期')
# 3.4 比对
if redis_text.decode().lower() != image_code.lower():
return http.HttpResponseBadRequest('图片验证码不一致')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'errmsg': '短信发送太频繁', 'code': '4001'})
# ④ 生成一个随机短信验证码
# 6位数值
from random import randint
sms_code = '%06d' % randint(0, 999999)
# ⑤ 保存短信验证码
# redis_conn.setex('sms_%s'%mobile,300,sms_code)
from apps.verifications.constants import SMS_CODE_EXPIRES_SECONDS
redis_conn.setex('sms_%s' % mobile, SMS_CODE_EXPIRES_SECONDS, sms_code)
# 添加一个标记
redis_conn.setex('send_flag_%s' % mobile, 60, 1)
# ⑥ 发送短信
# 免费开发测试使用的模板ID为1，形式为：
# 【云通讯】您使用的是云通讯短信模板，您的验证码是{1}，请于{2}分钟内正确输入。
# 其中{1}和{2}为短信模板的参数
from libs.yuntongxun.sms import CCP
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# from celery_tasks.sms.tasks import send_sms_code
# # 任务的参数,平移到delay中
# # delay 中 添加函数的参数
# send_sms_code.delay(mobile, sms_code)
# ⑦ 返回相应
return http.JsonResponse({'msg': 'ok', 'code': RETCODE.OK})
def ccp_send_sms_code(self, mobile, sms_code):
try:
from libs.yuntongxun.sms import CCP
send_result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
print("当前验证码是:", sms_code)
except Exception as e:
# 有异常自动重试三次
raise self.retry(exc=e, max_retries=3)
return send_result
def sms_send(self,mobile,random_code):
try:
rect = CCP().send_template_sms(mobile, [random_code, 2], 1)
except Exception as e:
logger.error(e)
return self.retry(exc=e,max_retries=3)
if rect!=0:
return self.retry(exc=Exception('发送失败'),max_retries=3)
def send_sms_code(self, mobile, sms_code):
try:
result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
except Exception as e:
raise self.retry(exc=e, max_retries=10)
if result != 0:
# 不是0 都是失败 ,失败就应该重试
raise self.retry(exc=Exception('重试'), max_retries=10)
def get(self, request):
"""
1.接收参数
2.参数的验证
2.1 验证参数是否齐全
2.2 图片验证码的验证
连接redis，获取redis中的图片验证码
判断图片验证码是否存在
如果图片验证码未过期，我们获取到之后就可以删除图片验证码
比对图片验证码
3.生成短信验证码
4.保存短信验证码到redis中
5.发送短信
6.返回响应
:param request:
:return:
"""
# 1.接收参数 （查询字符串的形式传递过来）
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
uuid = request.GET.get('uuid')
'''
# 2.参数的验证
# 2.1 验证参数是否齐全
if not all([mobile,image_code,uuid]):
return JsonResponse({'code':RETCODE.NECESSARYPARAMERR,'errmsg':'缺少必要的参数'})
# 2.2 图片验证码的验证
# 连接redis，获取redis中的图片验证码
redis_conn=get_redis_connection('default')
redis_image_code=redis_conn.get('img:%s'%uuid)
# 判断图片验证码是否存在
if redis_image_code is None:
return JsonResponse({'code':RETCODE.IMAGECODEERR,'errmsg':'图片验证码已过期'})
# 如果图片验证码未过期，我们获取到之后就可以删除图片验证码
try:
redis_conn.delete('img:%s'%uuid)
except Exception as e:
logger.error(e)
# 比对图片验证码, 注意大小写的问题， redis的数据是bytes类型
if redis_image_code.decode().lower() != image_code.lower():
return JsonResponse({'code':RETCODE.IMAGECODEERR,'errmsg':'图片验证码错误'})
# 3.生成短信验证码
'''
sms_code = '%06d' % randint(0, 999999)
# 为了后期比对方便，我们可以将短信验证码记录到日志中
logger.info(sms_code)
#mobile = '18202788550'
# 4.保存短信验证码到redis中
#redis_conn.setex('sms:%s'%mobile,300,sms_code)
# 5.发送短信
# 参数1： 测试手机号
# 参数2：模板内容列表： {1} 短信验证码 {2} 分钟有效
# 参数3：模板 免费开发测试使用的模板ID为1
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 6.返回响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def send_sms_code(self, mobile, sms_code):
# 没有的变量,以参数的形式传递
try:
rect = CCP().send_template_sms(mobile, [sms_code, 5], 1)
except Exception as e:
raise self.retry(exc=e, max_retries=3)
if rect != 0:
#重试
raise self.retry(exc=Exception('发送失败'), max_retries=3)
def cpp_send_sms_code(mobile, sms_code):
"""
发送短信异步任务
:param mobile: 手机号
:param sms_code: 短信验证码
:return: 成功0 失败1
"""
from libs.yuntongxun.sms import CCP
send_result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
return send_result
def send_sms_code(self, mobile, sms_code):
"""
发送短信异步任务
:param mobile: 手机号
:param sms_code: 短信验证码
:return: 成功0 或 失败-1
"""
CCP().send_template_sms(
mobile, [sms_code, constants.IMAGE_CODE_REDIS_EXPIRES // 60],
constants.SEND_SMS_TEMPLATE_ID)
def send_sms_code(mobile, sms_code):
'''
发送短信异步任务
:param mobile:
:param sms_code:
:return: 成功0或失败1
'''
result = CCP().send_template_sms('13914070562', [sms_code, 5], 1)
print('当前验证码是:', sms_code)
return result
def send_sms_code(self, mobile, sms_code):
try:
send_ret = CCP().send_template_sms(mobile, [sms_code, 5], 1)
except Exception as e:
# 有异常自动重试三次
raise self.retry(exc=e, max_retries=3)
if send_ret != 0:
# 有异常自动重试三次
raise self.retry(exc=Exception('发送短信失败'), max_retries=3)
return send_ret
def get(self, request):
'''
1、接受参数
2、参数的验证
2.1验证参数是否齐全
2.2图片验证码的验证
连接redis，获取redis中的图片验证码
判断图片验证码是否存在
如果图片验证码未过期，我们获取到之后就可以删除图片验证码
比对图片验证码
3、生成短信验证码
4、保存短信验证码到redis中
5、发送短信
6、返回响应
:param request:
:return:
'''
# 1、接受参数（查询字符串的形式传递过来）
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
uuid = request.GET.get('uuid')
# 2、参数的验证
# 2.1验证参数是否齐全
if not all([mobile, image_code, uuid]):
return JsonResponse({'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必要的参数'})
# 2.2图片验证码的验证
# 连接redis，获取redis中的图片验证码
redis_conn = get_redis_connection('default')
redis_image_code = redis_conn.get('img:%s' % uuid)
# 判断图片验证码是否存在
if redis_image_code is None:
return JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码已过期'})
# 如果图片验证码未过期，我们获取到之后就可以删除图片验证码
try:
redis_conn.delete('img:%s' % uuid)
except Exception as e:
logger.error(e)
# 比对图片验证码,注意大小写问题，redis的数据是bytes类型
if redis_image_code.decode().lower() != image_code.lower():
return JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码错误'})
# 3、生成短信验证码
sms_code = '%06d' % randint(0, 999999)
# 为了后期比对方便，我们可以将短信验证码记录到日志中
logger.info(sms_code)
# 4、保存短信验证码到redis中
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
# 5、发送短信
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 6、返回响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def send_sms_code(
self,
mobile,
sms_code,
):
try:
result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
if result != 0:
logger.error('发送失败,%s' % result)
raise Exception('发送失败')
except Exception as e:
self.retry(exc=e, max_retries=3)
def send_sms_code(self, mobile, sms_code):
try:
result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
except Exception as e:
raise self.retry(exc=e, max_retries=10)
if result != 0:
# 不是0 都是失败 ,失败就应该重试
raise self.retry(
exc=Exception('baby,just check your configuration parameter!!!'),
max_retries=3)
def get_sms_code():
"""获取短信验证码"""
request_data = request.get_json()
image_code = request_data.get("imgCode")
mobile = request_data.get("mobile")
image_id = request.args.get("imgID")
print(image_id)
if not all([mobile, image_code]):
return jsonify(error="-1", errmsg="参数填写不完整")
if not re.match(r"1[35789]\d{9}", mobile):
return jsonify(error="-1", errmsg="手机号格式错误")
try:
flag = redis_store.get("sended_sms_code_%s" % mobile)
except Exception:
pass
else:
if flag:
return jsonify(error="-1", errmsg="请求过于频繁,请稍后再试!")
# 判断手机号是否存在
try:
real_image_code = redis_store.get("img_code_%s" % image_id)
except Exception:
return jsonify(error="-1", errmsg="数据库异常")
print(real_image_code.decode("utf-8"), image_code)
if real_image_code.decode("utf-8").lower() != image_code.lower():
return jsonify(error="-1", errmsg="图片验证码填写错误")
# 发送短信
sms_code = "%06d" % random.randint(0, 999999)
try:
redis_store.setex("sms_code_%s" % mobile, 3600, sms_code)
redis_store.setex("sended_sms_code_%s" % mobile, 300, 1)
except Exception:
pass
ccp = CCP()
try:
ret = ccp.send_template_sms(mobile, datas=[sms_code, 5], temp_id=1)
except Exception:
return jsonify(error="-1", errmsg="发送短信错误")
if ret == 0:
return jsonify(errno="0", errmsg="发送成功")
else:
return jsonify(errno="-1", errmsg="发送失败")
def get(self, request):
"""
# 1.接收参数
# 2.参数验证
# 2.1验证参数是否齐全
# 2.2图片验证码的验证
# 3.生产短信验证码
# 4.保存短信验证码到redis中
# 5.发送短信
# 6.返回响应
:param request:
:return:
"""
# 1.接收参数
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
uuid = request.GET.get('uuid')
# 2.参数验证
# 2.1验证参数是否齐全
if not all([mobile, image_code, uuid]):
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少必要的参数 '
})
# 2.2图片验证码的验证
redis_conn = get_redis_connection('default')
redis_image_code = redis_conn.get('img:%s' % uuid)
if redis_image_code is None:
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图片验证码已过期'
})
try:
redis_conn.delete('img:%s' % uuid)
except Exception as e:
logger.error(e)
if redis_image_code.decode().lower() != image_code.lower():
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图片验证码错误'
})
# 3.生产短信验证码
sms_code = '%06d' % randint(0, 999999)
logger.info(sms_code)
# 4.保存短信验证码到redis中
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
# 5.发送短信
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 6.返回响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def get(self, request, mobile):
# 1.接收数据
query_params = request.query_params
# 2.校验数据
serializer = RegisterSmsSerializer(data=query_params)
# 3.生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
print(sms_code)
# 4.发送短信
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# send_sms_code.delay(mobile,sms_code)
# 5.保存短信
redis_conn = get_redis_connection('code')
redis_conn.setex('sms_' + mobile, 5 * 60, sms_code)
return Response({'msg': 'ok'})
def get(self, request):
# 1.参数接收（查询字符串的形式传递过来）
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
uuid = request.GET.get('uuid')
#18294202694
# 2.参数的验证
# 验证参数是否齐全
redis_conn = get_redis_connection('default')
if not all([mobile, image_code, uuid]):
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少是参数'
})
# 连接redis，获取redis中的图片验证码
redis_image_code = redis_conn.get('img:%s' % uuid)
# 判断图片验证码是否存在
if redis_image_code is None:
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图片验证码已过期'
})
# 如果图片验证码未过期，获取到验证码之后就可以删除图片验证码
try:
redis_conn.delete('img:%s' % uuid)
except Exception as e:
logger.error(e)
# 对比图片验证码(注意大小写)
if redis_image_code.decode().lower() != image_code.lower():
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '图片验证码错误'
})
# 3.生成短信验证码
sms_code = '%06d' % randint(0, 999999)
# 为了比对方便，可以记录日志
logger.info(sms_code)
# 4.保存短信验证码到redis中
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
# 5.发送短信
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 6. 返回响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def send_sms_code(self, mobile, sms_code):
try:
ccp = CCP()
send_ret = ccp.send_template_sms('13581824252', [sms_code, 5], 1)
except Exception as e:
raise self.retry(exc=e, max_retries=3)
if send_ret != 0:
# 有异常自动重试三次
raise self.retry(exc=Exception('发送短信失败'), max_retries=3)
else:
redis_conn = get_redis_connection('message_code')
redis_conn.setex('sms_%s' % mobile, 3000, sms_code)
# 设置发送 flag 有效期60秒 用于判断和控制用户频繁调用接口
redis_conn.setex('send_flag_%s' % mobile, 60, 1)
return send_ret
def send_code():
"""
1,接受前端ajax传入的参数,前端是post 请求，一定要注意，把传入进来的数据转换成字典，三个参数分别
为mobile , imagecode ,imageCodeId
2,判断值是否为空，
3,取出存储在redis 里面的真是的图片内容,判断是否取的出来
4进行比对，
5，生成发送的验证码
6，把验证码存入ｒｅｄｉｓ中，过期时间
7，把手机号，生成的验证码，发送给第三方平台，
8，发送成功就返回状态码
:return:
"""
params=request.json
print(params)
mobile = params.get('mobile')
image_code =params.get('imagecode')
image_code_id = params.get("imagecodeid")
if not all([mobile,image_code,image_code_id]):
return jsonify(errno=RET.PARAMERR,errmes='参数错误')
try:
real_image_code=redis_store.get('imageCodeId_'+image_code_id)
except Exception as e:
return jsonify(errno=RET.DBERR , errmes='数据库查询失败')
if not real_image_code:
return jsonify(errno=RET.DBERR , errmes='数据已过期')
print(real_image_code)
print(image_code)
if real_image_code.upper() != image_code.upper():
current_app.logger.debug("111")
return jsonify(errno=RET.PARAMERR , errmes='验证码不正确')
mes_num = '%06d' % random.randint(0,999999)
try:
redis_store.setex('imagecode_'+mobile,constants.IMAGE_CODE_REDIS_EXPIRES,mes_num)
except Exception as e:
current_app.logger.debug("222")
return jsonify(errno=RET.PARAMERR, errmes='数据保存不成功')
result=CCP().send_template_sms(mobile, [mes_num, constants.SMS_CODE_REDIS_EXPIRES], '1')
if result != 0:
# 代表发送不成功
current_app.logger.debug("333")
return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败")
return jsonify(errno=RET.OK, errmsg="发送成功")
def get(self, request):
# 接收参数
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('uuid')
mobile = request.GET.get('mobile')
# 校验参数
if not all([image_code_client, uuid, mobile]):
return JsonResponse({
'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少必传参数'
})
# 创建连接到redis的对象
redis_conn = get_redis_connection('default')
# 提取图形验证码
image_code_server = redis_conn.get('img:%s' % uuid)
if image_code_server is None:
# 图形验证码过期或者不存在
return 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() # bytes转字符串
if image_code_client.lower() != image_code_server.lower(): # 转小写后比较
return JsonResponse({
'code': RETCODE.IMAGECODEERR,
'errmsg': '输入图形验证码有误'
})
# 生成短信验证码：生成6位数验证码
sms_code = '%06d' % randint(0, 999999)
#将验证码输出在控制台，以方便调试
logger.info(sms_code)
# 保存短信验证码到redis中，并设置有效期
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
# 发送短信验证码
CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 响应结果
return JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功'})
def get(self, request):
'''
1、接收参数
2、验证参数
2.1 验证参数是否齐全
2.2 图片验证码的验证
2.2.1 链接redis，获取redis中的图片验证码，
判断图片验证码是否存在
如果验证码未过期，则获取之后删除验证码
比对图片验证码（注意大小写问题的处理）
3、生成短信验证码
4、保存短信验证码至redis中
5、发送短信
6、返回响应
:param request:
:return:
'''
mobile = request.GET.get('mobile')
image_code = request.GET.get('image_code')
uuid = request.GET.get('uuid')
if not all([mobile, image_code, uuid]):
return JsonResponse({'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必要的参数'})
redis_conn = get_redis_connection('default')
redis_image_code = redis_conn.get('img:%s' % uuid)
if redis_image_code is None:
return JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码已过期'})
try:
redis_conn.delete('img:%s' % uuid)
except Exception as e:
logger.error(e)
# 比对图片验证码，注意大小写的问题，redis的数据是bytes类型
if redis_image_code.decode().lower() != image_code.lower():
return JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码错误'})
sms_code = "%06d" % randint(0, 999999)
# 为了以后验证方便，可以将其记录至日志中
logger.info(sms_code)
redis_conn.setex('sms:%s' % mobile, 300, sms_code)
CCP().send_template_sms(mobile, [sms_code, 5], 1)
return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
