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 get(self, request, mobile):
query_params = request.query_params
print(query_params)
serializer = self.get_serializer(data=query_params)
serializer.is_valid(raise_exception=True)
redis_conn = get_redis_connection('code')
if redis_conn.get('sms_flag_%s' % mobile):
return Response(status=status.HTTP_429_TOO_MANY_REQUESTS)
sms_code = '%06d' % randint(0, 999999)
print(sms_code)
redis_conn.setex('sms_%s' % mobile, 5 * 60, sms_code)
redis_conn.setex('sms_flag_%s' % mobile, 60, 1)
ccp = CCP()
ccp.send_template_sms(mobile, [sms_code, 5], 1)
return Response({'message': 'ok'})
def get(self,request,mobile):
# 创建序列化器, 定义text和image_code_id
serializer = self.get_serializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
# redis
redis_conn = get_redis_connection('code')
# 判断该用户是否频繁获取
if redis_conn.get('sms_flag_%s'%mobile):
return Response(status=status.HTTP_429_TOO_MANY_REQUESTS)
# 生成短信验证码
sms_code = '%06d'%randint(0,999999)
# redis增加记录
redis_conn.setex('sms_%s'%mobile,5*60,sms_code)
redis_conn.setex('sms_flag_%s'%mobile,60,1)
# 发送短信
ccp = CCP()
ccp.send_template_sms(mobile,[sms_code,5],1)
# 返回响应
return Response({'message':'ok'})
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 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_sms_code(mobile, sms_code):
ccp = CCP()
ccp.send_template_sms(mobile, [sms_code, 5], 1)
def get_sms_code():
"""
1.获取参数,request.data, json.loads(json)
2.校验参数为空情况
3.验证手机号格式
4.通过image_code_id取出redis中的图片验证码
5.判断取出的图片验证码是否过期
6.判断两者图片验证码是否相等
7.生成短信验证码
8.调用云通讯发送(手机号,短信验证码,有效期,模板id)
9.保存到redis
10.返回前端
:return:
"""
# 1.获取参数,request.data, json.loads(json)
dict_data = request.json
mobile = dict_data.get('mobile')
image_code_id = dict_data.get('image_code_id')
image_code = dict_data.get('image_code')
# print(image_code)
# 2.校验参数为空情况
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 3.验证手机号格式
if not re.match('1[356789]\d{9}', mobile):
return jsonify(errno=RET.DATAERR, errmsg='手机号格式错误')
# 4.通过image_code_id取出redis中的图片验证码
try:
redis_image_code = redis_store.get('image_code:%s' % image_code_id)
current_app.logger.error(redis_image_code)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查找图片验证码失败')
# 5.判断取出的图片验证码是否过期
if not redis_image_code:
return jsonify(errno=RET.NODATA, errmsg='图片验证码已经过期')
# 6.判断两者图片验证码是否相等
if not redis_image_code.lower() == image_code.lower():
# print(redis_image_code)
# current_app.logger.error(redis_image_code)
# current_app.logger.error(image_code)
return jsonify(errno=RET.DATAERR, errmsg='图片验证码输入错误')
# 7.生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 8.调用云通讯发送(手机号,短信验证码,有效期,模板id)
ccp = CCP()
result = ccp.send_template_sms(mobile, [sms_code, 5], 1)
if result == -1:
return jsonify(errno=RET.THIRDERR, errmsg='短信验证码发送失败')
current_app.logger.debug('短信验证码是:%s' % sms_code)
# 9.保存到redis
try:
redis_store.set('msg_code:%s' % mobile, sms_code,
constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='短信保存到数据库失败')
# 10.返回前端
return jsonify(errno=RET.OK, errmsg='发送成功!')
def send_sms_code(mobile, sms_code):
# 任务就是发送短信
ccp = CCP() # mobile:向谁发 []:发什么, 5/分钟:过期时间, 1:模板 ,
ccp.send_template_sms(mobile, [sms_code, 5], 1)
print()
def get_sms_code(mobile):
# 1. 获取参数
image_code = request.args.get('image_code')
image_code_id = request.args.get('image_code_id')
# 2. 效验参数
if not all([image_code, image_code_id]):
response_dict = {
'errno': RET.PARAMERR,
'errmsg': '参数不全, 请填写完整'
}
return jsonify(response_dict)
# 3. 逻辑处理
# 1. 和redis数据对比: 获取redis数据, 判断是否为None, 无论正确与否都要删除, 和用户传入的数据做对比
# 2. 判断用户是否已经注册过, 判断是否为空
# 3. 发送短信验证码: 自行生成验证码, 保存到redis, 调用云通信接口发送验证码
# 3.1 获取redis数据 --> try
try:
real_image_code = redis_store.get('image_code_' + image_code_id)
except Exception as e:
logging.error(e)
response_dict = {
'errno': RET.DBERR,
'errmsg': '访问数据库异常'
}
return jsonify(response_dict)
# 3.2判断是否为None
# 数据库, 获取空值就是None
if real_image_code is None:
response_dict = {
'errno': RET.NODATA,
'errmsg': '验证码已过期/或已删除'
}
return jsonify(response_dict)
# 3.3 无论正确与否都要删除 try
# 图片验证码通常只能用一次
try:
redis_store.delete('image_code_' + image_code_id)
except Exception as e:
logging.error(e)
# 理论上应该返回错误信息. 但是从用户体验的角度来说. 用户没有做错事, 只是服务器删除失败.
# 就算没有立即删掉, 2分钟后也会过期. 可以考虑不删除 --> 产品经理角度(将来和产品经理商量一下)
# 3.4 和用户传入的数据做对比
# 142B 142b 为了忽略大小写的问题, 建议全大写或小写
if image_code.lower() != real_image_code.lower():
response_dict = {
'errno': RET.DATAERR,
'errmsg': '验证码输入错误'
}
return jsonify(response_dict)
# 3.5 判断用户是否已经注册过, 判断是否为空 try
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
logging.error(e)
# 理论上, 需要返回错. 从体验角度讲, 后面的立即注册也会去检测用户是否注册. 因此可以考虑本次错误不返回
else:
# 判断用户不为空, 说明已经注册过
if user is not None:
response_dict = {
'errno': RET.DATAEXIST,
'errmsg': '该手机号已存在'
}
return jsonify(response_dict)
# 3.6 自行生成验证码
# 06d: 要求6位数, 不足以0补齐
sms_code = '%06d' % random.randint(0, 999999)
# 3.7 保存到redis try
try:
# 第一个参数: key , 第二个参数: 过期时间 第三个参数: value
redis_store.setex('sms_code_' + mobile, constants.SMS_CODE_REDIS_EXPIRE, sms_code)
except Exception as e:
logging.error(e)
response_dict = {
'errno': RET.DBERR,
'errmsg': '访问redis出错'
}
return jsonify(response_dict)
# 3.8 调用云通信接口发送验证码 try
ccp = CCP()
try:
status_code = ccp.send_template_sms(mobile, [sms_code, str(constants.SMS_CODE_REDIS_EXPIRE / 60)], 1)
except Exception as e:
logging.error(e)
response_dict = {
'errno': RET.THIRDERR,
'errmsg': '发送异常'
}
return jsonify(response_dict)
# 4. 返回数据
if status_code == '000000':
# 发送成功
response_dict = {
'errno': RET.OK,
'errmsg': '发送成功'
}
return jsonify(response_dict)
else:
# 发送失败
response_dict = {
'errno': RET.THIRDERR,
'errmsg': '发送失败'
}
return jsonify(response_dict)
def send_sms_code(mobile, sms_code):
"""发送短信任务"""
ccp = CCP()
ccp.send_template_sms(mobile, [sms_code, 5], 1)
return "短信发送成功!"
def ccp_send_sms_code(mobile, sms_code):
from libs.yuntongxun.sms import CCP
ccp = CCP()
send_result = ccp.send_template_sms(mobile, [sms_code, 5], 1)
return send_result
def send_sms_code(mobile, sms_code):
CCP.send_template_sms(mobile, [sms_code, 5], 1)
def send_template_sms(to, datas, temp_id):
"""发送短信"""
ccp = CCP()
ccp.send_template_sms(to, datas, temp_id)
