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]):
# 参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 3. 业务逻辑
# 3.1 对比图片验证码
try:
real_image_code = redis_store.get(image_code_id).decode('utf-8')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis获取图片验证码失败")
if real_image_code is None:
# 如果图片验证码过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 图片验证码仅可使用一次，删除图片验证码
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
if real_image_code.upper() != image_code.upper():
# 填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断该手机号是否在60s内操作过
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag == 1:
# 操作频繁
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60s后重试")
# 3.2 判断手机号是否已注册
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 手机号已经注册
return jsonify(errno=RET.DATAEXIST, errmsg="用户已存在")
# 3.3 如果未注册，生成短信验证码并保存，发送短信验证码
sms_code = "%06d" % random.randint(0, 999999)
try:
redis_store.setex("sms_code_%s" % mobile, SMS_CODE_REDIS_EXPIRES,
sms_code)
# 保存发送给这个号码的记录，防止用户在60s内再次重复发送
redis_store.setex("send_sms_code_%s" % mobile, SEND_SMS_CODE_INTERVAL,
1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# ccp = CCP()
# try:
# result = ccp.send_template_sms(mobile, [sms_code, int(SMS_CODE_REDIS_EXPIRES/60)], 1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="第三方发送短信异常")
# if result == 0:
# # 发送成功
# return jsonify(errno=RET.OK, errmsg="发送成功")
# else:
# return jsonify(errno=RET.THIRDERR, errmsg="发送失败")
# 异步发送短信
send_sms.delay(mobile, [sms_code, int(SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 4. 返回值
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码"""
# 初始化
# 判断短信验证码是否已存在，若存在则删除
real_sms_code = redis_store.get("sms_code_{}".format(mobile))
if real_sms_code:
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 获取参数
image_code = request.args.get("image_code")
# print("*"*20)
# print(image_code)
image_code_id = request.args.get("image_code_id")
# 校验参数
if not all([image_code_id, image_code]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务逻辑处理
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get(
"image_code_{}".format(image_code_id))
# print("*"*20)
# print(real_image_code)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效，请刷新验证码")
# 与用户填写的值进行对比
if real_image_code.decode().lower() != image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码输入错误，请重新输入")
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_{}".format(image_code_id))
except Exception as e:
current_app.logger.error(e)
# 发送手机号之前，判断在60秒内有没有对该手机号的操作，若有，则不接受处理
try:
send_flag = redis_store.get("send_sms_code_{}".format(mobile))
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内有发送记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果手机号不存在，则生成短信验证码
sms_code = "{:0>6d}".format(random.randint(0, 999999))
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_{}".format(mobile),
constants.SMS_CODE_REDIES_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次触发发送短信的操作
redis_store.setex("send_sms_code_{}".format(mobile),
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# 使用celery发送异步短信，delay函数调用后立即返回
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIES_EXPIRES / 60)], 1)
# 返回值
# 发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码"""
# 获取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
# 校验参数,mobile参数已经在正则表达式那里校验了，校验不成功也就不会进入函数内部
if not all([image_code, image_code_id]):
# 参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务逻辑处理
# 从redis中取出真实的图片验证码
try:
# 设置了过期时间，如果存储的数据过期了是以None的方式返回的，而不是返回数据
real_image_code = redis_store.get("image_code_%s"%image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s"%image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的进行对比校验
if real_image_code.decode().lower() != image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s"%mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内之前有过发送的记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请６０秒后重试")
# 判断手机号是否存在,单条记录不存在返回None
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s"%mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s秒内再次发出发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# 使用celery发送异步短信,delay调用后立即返回
send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# 返回值
# 发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码--使用celery方式进行"""
# 获取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
print("image_code：", image_code, "image_coed_id:", image_code_id)
# 校验参数
if not all([image_code_id, image_code]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 业务逻辑
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 比较后，删除图片验证码，需要放在这个位置
# 删除redis中的图片验证码，在验证1次后，用于防止用户使用同一个验证码进行多次校验
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的值进行对比
if real_image_code.lower() != image_code.lower():
# 表示用户验证码填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# **********************************************************
#判断对于这个手机号的操作在60秒内是否有之前的记录，如果有就说明操作频繁，不做处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示60秒内有发送记录
return jsonify(errno=RET.DATAERR, errmsg="请求过于频繁，请60秒后重新访问！")
# 判断手机号码是否已经注册
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user:
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999) # 生成6位随机短信验证码
print("sms_code:", sms_code)
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60S内重复发送
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="短信验证码异常")
# 发送短信
# 使用celery异步发送短信,delay函数调用后立即返回（非阻塞）
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 返回异步任务的对象
result_obj = send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
print(result_obj.id)
# 通过异步任务对象的get方法获取异步任务的结果, 默认get方法是阻塞的
ret = result_obj.get()
print("ret=%s" % ret)
# 返回值
# 发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证"""
# 提取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
# 校验参数
if not all([image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务处理:发送短信
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 删除图片验证码，防止用户使用同一个验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的值进行对比
if real_image_code.decode('utf-8').upper() != image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg="验证码错误")
# 判断发送短信是否超过60秒
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
# 记录错误日志
current_app.logger.error(e)
else:
if send_flag:
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，60秒后重试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
# return jsonify(errno=RET.DATAERR, errmsg="数据库出错")
# 这里不要return，这是数据库问题，万一手机号真的没有注册过
# 你在这里抛出已被注册，不就浪费一个客户了码。
# 我们在最终用户点击，注册按钮的时候，会再次判断手机号是否被注册过
# 所以这里，当做没被注册过，往下面执行
else:
if user is not None:
# 表示手机号已经存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已被注册")
# 手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999) # 最少是6位数，不够补0
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_EXPIRES,
sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL_EXPIRES, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信验证码
# 使用celery异步发送短信，delay函数调用后立即返回
from ihome.tasks.task_sms import send_sms
send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_EXPIRES / 60)], 1)
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码
:params mobile: 手机号
:return: 正常：短信验证码
异常：json
"""
# 接收参数
image_code = request.args.get('image_code')
image_code_id = request.args.get('image_code_id')
# 校验参数
if not all([image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg=u"参数不完整")
# 业务逻辑处理
# 1. 校验图片验证码
try:
real_image_code = redis_store.get('image_code_%s' % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'校验图片验证码异常')
if real_image_code is None:
return jsonify(errno=RET.NODATA, errmsg=u'图片验证码失效')
try:
# 删除过期或已尝试验证的图片验证码
redis_store.delete('image_code_%s' % image_code_id)
except Exception as e:
current_app.logger.error(e)
if real_image_code.lower() != image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg=u'图片验证码错误')
# 2. 校验手机号是否已注册
# 判断手机号60s内是否有发送记录，防止频繁触发
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
return jsonify(errno=RET.REQERR, errmsg=u'请求过于频繁，60s后重试')
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg=u'手机号已注册')
# 3. 生成短信验证码并保存到redis
sms_code = "%06d" % random.randint(0, 999999)
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送记录，方式60s内再次触发
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u"保存短信验证码异常")
# 4. 发送短信验证码
# 使用celery异步发送
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 返回响应
return jsonify(errno=RET.THIRDERR, errmsg=u"发送失败")
def get_sms_code(mobile):
"""
获取短信验证码
:param mobile:手机号
:return:
"""
# 获取参数
# 验证码图片数据获取
image_code_id = request.args.get("image_code_id") # 编号
image_code = request.args.get("image_code") # 验证码数据
# 检测参数NODATA
# 判断数据是否都获取到了
if not all([image_code_id, image_code]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务逻辑
# 判断获取到的验证图片数据是否正确
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="数据库异常")
if real_image_code is None:
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 防止用户使用一个图片验证码来一直验证不同的手机用户是否存在
# 删除redis中原有的图片验证码
try:
redis_store.delete("image_code%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 将传入的验证数据和真实值比较
if real_image_code.lower() != image_code.lower():
print(real_image_code.lower())
print(image_code.lower())
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断手机号是否在60秒内发送过短信验证码
# 如果有则用户操作频繁
try:
send_flg = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flg is not None:
# 表示在60秒内发送过短信
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，60秒后重试")
# 对手机验证码进行操作
# 查询当前的手机号是否已经
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 手机号已存在就返会错误，用户已注册
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 生成随机数据
real_sms_code = "%6d" % random.randint(0, 999999) # 固定格式
# 将生成的验证码数据存放到redis中
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_TIME, real_sms_code)
# 保存防止手机验证码多次发送的记录
redis_store.setex("send_sms_code_%s" % mobile,
constants.SMS_LIMIT_REDIS_TIME, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="短信验证码数据保存失败")
# 判断当前的短信验证码是否过期s
try:
real_sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码已过期")
# 发送短信
send_sms.delay(mobile, [real_sms_code, constants.SMS_CODE_REDIS_TIME / 60],
1)
# # 发送信息
# ccp = CCP()
# try:
# ret = ccp.send_template_sms(mobile,[real_sms_code,constants.SMS_CODE_REDIS_TIME/60],1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="网络异常")
# 返回值
# if ret == -1:
# return jsonify(errno=RET.ok, errmsg="发送成功")
# else :
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码"""
# 获取参数
image_code = request.args.get('image_code')
image_code_id = request.args.get('image_code_id')
# 检验参数
if not all([image_code, image_code_id]):
# 参数不完整
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 逻辑处理
# 从redis中取出验证码图片的真实值
try:
real_image_code = redis_store.get('image_code_%s' % image_code_id)
print(real_image_code)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常')
# 判断真实值是否过期,redis中如果过期则返回None
if real_image_code is None:
return jsonify(errno=RET.NODATA, errmsg='验证码失效')
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
print(real_image_code.decode('utf-8').lower())
print(image_code.lower())
# 验证用户填写的验证码与redis中的真实值是否相等
if real_image_code.decode('utf-8').lower() != image_code.lower():
return jsonify(errno=RET.DATAERR, errmssg='图片验证码错误')
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内之前有过发送的记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已注册')
# 生成短信验证码 6 位
# import random
sms_code = "%06d" % random.randint(0, 999999) # %06d 表示生成6位整数，不够的前边补0 ，如029541
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# try:
# ccp = CCP()
# result = ccp.send_template_sms(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="发送异常")
# 发送短信验证码
send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 发送成功
return jsonify(errno=RET.OK, errmsg='发送成功')
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]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 3. 业务处理
# 从redis中取出真实的图片验证码
try: # redis连接，可能网络发生故障，必须try起来
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的值进行对比
if real_image_code.lower() != image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断对于这个手机号的操作，60秒内有记录就不接受处理
try: # 获取不到说明没有记录，可以通过
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒之前有记录
return jsonify(errno=RET.REQERR, errmsg="请60秒后进行重试")
# 判断手机号是否注册过
try: # mysql连接，可能网络发生故障，必须try起来
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已经存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 生成短信验证码: 000000~999999之间的数字
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码到redis数据库
try: # redis连接，可能网络发生故障，必须try起来 key 有效时间 短信验证码
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60秒反复发短信
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="短信验证码异常")
# 使用celery异步发送短信，delay函数钓鱼能后立即返回
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 4. 返回值
# 发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码"""
# 获取数据
image_codes_id = request.args.get("image_codes_id")
image_code = request.args.get("image_code")
# 验证数据
if not all([image_codes_id, image_code]):
return jsonify(errno=RET.PARAMERR, errmsg="数据不完整")
# 业务逻辑处理
# 1. 验证图片验证码正确性
# 从redis中读取真实的图片验证码
try:
real_image_code = redis_store.get("image_codes_%s" %
image_codes_id) # 此时读取出来的值是二进制格式的！
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 图片验证码不存在或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码过期")
# 删除redis中的图片验证码，防止用户使用同一个验证码验证多次
try:
redis_store.delete("image_codes_%s" % image_codes_id)
except Exception as e:
current_app.logger.error(e)
# 与用户输入的进行对比
if real_image_code.decode('utf-8').lower() != image_code.lower(
): # 在比较时，必须转为字符串才能比较，否则一直报图片验证码填写错误
# 用户填写的图片验证码错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码填写错误")
# 2. 发送短信验证码逻辑
# 判断此手机号是否在60s内已经发送过短信验证码，如果是，则直接返回
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示发送过
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否已经存在
# try:
# user = User.query.filter_by(mobile=mobile).first()
# except Exception as e:
# current_app.logger.error(e)
# else: # 如果发生异常 user变量不存在
# if user is not None:
# # 用户已经存在
# return jsonify(errno=RET.DATAEXIST, errmsg="手机号已经存在")
# 如果不存在，就可以生成短信验证码
sms_code = "%06d" % random.randint(0, 999999) # %06d 表示六位数，不满六位用0补充
# 保存真实的短信验证码到redis数据库
try:
redis_store.setex("sms_codes_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存给这个手机号发送过短信的记录，防止用户在60s内多次点击获取短信验证码
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 发送短信
try:
ccp = CCP()
result = ccp.send_template_sms(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="发送短信异常")
# 改用celery异步执行发送短信的任务
# 调用后立即返回,返回值是一个对象
# result_obj = send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# print("result_obj = " % result_obj)
# 暂时发不出短信，报网络错误
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 通过异步任务对象，获取任务结果
# get方法默认是阻塞的
# ret = result_obj.get()
# print("ret = %s" % ret)
# 返回
# if result == 0:
# return jsonify(errno=RET.OK, errmsg="发送成功")
# else:
# return jsonify(errno=RET.THIRDERR, errmsg="发送失败")
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码"""
#http://127.0.0.1:5000/api/v1.0/sms_codes/19929978964
#获取图片验证码
image_code = request.args.get("image_code")
#获取图片验证码id
image_code_id = request.args.get('image_code_id')
#校验参数
if not all([image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
#删除验证码
try:
redis_store.delete("image_code_%s" % image_code_id)
except:
current_app.logger.error(e)
#与用户填写值进行比较
if real_image_code.lower() != image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
#判断手机号在60秒之内有没有操作记录
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
# 表示在60秒内之前有过发送的记录
if send_flag is not None:
return jsonify(erron=RET.REQERR, errmsg="请求归于频繁")
#判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已注册")
#如果手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 99999)
try:
#保存验证码
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
redis_store.setex("send_sms_code%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, error="保存短信验证码异常")
from ihome.tasks.task_sms import send_sms
result_obj = send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
print(result_obj.id)
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信"""
# 获取 参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
# 验证参数
if not all([image_code_id, image_code]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务处理 从redis数据库u取出验证码进行对比
try:
redis_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="redis数据库出错")
# 验证验证码是否过期
if redis_image_code is None:
return jsonify(errno=RET.DATAERR, errmsg="验证码已过期")
# 删除redis中的图片验证码，防止用户使用同一验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 进行对比
if redis_image_code.decode(encoding='utf-8').lower() != image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断这个手机号的操作，在60秒内也没有以前的记录
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示60内有记录
return jsonify(errno=RET.REQERR, errmsg="请求频繁，清在60秒后再试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 说明手机号已经存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 生成随机6位数验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60S内再次发送
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存验证码异常")
# 使用celery异步发送短信
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 发送短信
# try:
# ccp = CCP()
# res = ccp.send_sms_code(mobile, [sms_code, int(constants.IMAGE_CODE_REDIS_EXPIRES/60)], 1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="短信发送异常")
#
# if res == "000000":
# return jsonify(errno=RET.OK, errmsg="发送短信成功")
# else:
# return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败")
return jsonify(errno=RET.OK, errmsg="发送短信成功")
def get_sms_code(mobile):
"""
云片网发送短信验证码
:param mobile: 手机号码
:return: 状态码
"""
# 实例云片
yun = YunPian()
# 获取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
# 校验参数
if not all([image_code_id, image_code]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务逻辑处理
# 从redis中取出真实的图片验证码
try:
# real_image_code = redis_store.get("image_code_%s" % image_code_id)
real_image_code = redis_store.get(image_code_id)
if real_image_code is None:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的值进行对比
real_image_code = str(real_image_code, encoding='utf8')
if real_image_code.lower() != image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内之前有过发送的记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果手机号不存在，则生成短信验证码
# sms_code = "%06d" % random.randint(0, 999999)
sms_code = yun.make_code()
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# 使用celery异步发送短信, delay函数调用后立即返回（非阻塞）
# 返回异步任务的对象
# result_obj = send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
result_obj = send_sms.delay(mobile, sms_code)
print(result_obj)
# 通过异步任务对象的get方法获取异步任务的结果, 默认get方法是阻塞的
ret = result_obj.get()
print("ret=%s" % ret)
# 返回值
# 发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""
根据用户输入的手机号，获取短信验证码
:param mobile: 用户输入的手机号
:return: 短信验证码
"""
# 获取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
# 校验参数
if not all([image_code_id, image_code]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务逻辑处理
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 与用户填写的值进行对比
if real_image_code.lower().decode() != image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 删除redis中的图片验证码，防止用户使用一个验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有则认为该用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内之前有发送的记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已注册")
# 如果手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999) # 随机生成6位数,不够的前面补零
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次发送短信的操作
# redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# try:
# ccp = CCP()
# result = ccp.send_template_sms(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="发送异常")
# 通过引入celery异步发送短信，delay函数调用后立即返回
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 返回值
# if result == 0:
# 通过celery发送异步消息，保证它一定发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code():
"""获取短信验证码"""
# 获取参数
mobile = request.args.get("mobile")
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
if not all([mobile, image_code, image_code_id]):
# 表示参数不完整
return jsonify(code=RET.PARAMERR, errmsg='参数不完整')
if re.search('1[345789]\d{9}', mobile) is None:
return jsonify(code=RET.DATAERR, errmsg='手机号格式不对')
# 业务逻辑处理
# 从redis中取出真实的图片验证码--(凡是redis操作都需要写try)
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, errmsg='redis 数据错误')
# 判断图片验证码是否过期
if real_image_code is None:
return jsonify(code=RET.NODATA, errmsg='验证码过期')
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的值进行对比
if real_image_code.lower() != image_code.lower():
return jsonify(code=RET.DATAERR, errmsg='验证码输入错误')
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内之前有过发送的记录
return jsonify(code=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否存在-从数据库查-(存在则返回数据，不存在则返回None)
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示数据库存在
return jsonify(code=RET.DATAERR, errmsg='手机号已经存在')
# 如果手机号不存在，则生成验证码-6为数字，不足补0
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# try:
# ccp = CCP()
# result = ccp.send_message(1,mobile,(sms_code,int(constants.SMS_CODE_REDIS_EXPIRES/60)))
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.THIRDERR,errmsg="发送异常")
# # 返回值
# if result == 0:
# # 发送成功
# return jsonify(code=RET.OK, errmsg="发送成功")
# else:
# return jsonify(code=RET.THIRDERR, errmsg="发送失败")
# 发送短信，使用celery发送异步短信，
send_sms.delay(1, mobile,
(sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)))
return jsonify(code=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""获取短信验证码"""
# 获取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
# 校验参数
if not all([image_code_id, image_code]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 业务逻辑处理
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码失效")
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
ss = str(real_image_code.lower())
sms_code_re = re.findall('{names}'.format(names=image_code), ss)[0]
if sms_code_re != image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内之前有过发送的记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后重试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# 使用celery异步发送短信, delay函数调用后立即返回
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 返回值
# 发送成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile_num):
"""
验证图片验证码， 再发送手机短信验证码
:param mobile_num 手机号码
:return sms_code 手机验证码
"""
# 1. 验证图片验证码
image_code = request.args.get('image_code')
image_code_id = request.args.get('image_code_id')
# 检验参数完整性
if not all([image_code_id, image_code]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 检验参数正确性
try:
real_image_code = redis_store.get(f'image_code_{image_code_id}')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='redis数据库异常')
if not real_image_code:
return jsonify(errno=RET.NODATA, errmsg='图片验证码失效')
# 删除redis中图片验证码，防止用户多次尝试, 生产环境开启
try:
redis_store.delete(f'image_code_{image_code_id}')
except Exception as e:
current_app.logger.error(e)
if real_image_code.lower() == image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg='图片验证失败')
# 验证手机是否在一分钟内已发送验证码，限制一分钟内只能发送一次
try:
send_flag = redis_store.get(f'send_sms_code_{mobile_num}')
except Exception as e:
current_app.logger.error(e)
else:
if send_flag:
return jsonify(errno=RET.REQERR, errmsg='请求过于频繁，请60秒后重试')
# 2. 验证手机是否以注册
try:
user = User.query.filter_by(mobile=mobile_num).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常')
else:
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg='手机已注册，请直接登录')
# 3. 验证通过，保存到redis中
sms_code = '%06d' % randint(0, 999999)
try:
redis_store.setex(
f'sms_code_{mobile_num}',
constants.SMS_CODE_REDIS_EXPIRES,
sms_code
)
# 保存手机发送短信验证码的记录，限制60秒内重复发送
redis_store.setex(
f'send_sms_code_{mobile_num}',
constants.SEND_SMS_CODE_INTERVAL,
1
)
except Exception as e:
return jsonify(errno=RET.DBERR, errmsg='redis数据库异常')
# 4. 发送手机验证码
# try:
# status = ccp.send_template_sms(
# mobile_num,
# [sms_code, str(constants.SMS_CODE_REDIS_EXPIRES//60)],
# 1
# )
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg='短信发送异常')
# celery 发布异步任务
send_sms.delay(mobile_num, sms_code, str(
constants.SMS_CODE_REDIS_EXPIRES//60), 1)
return jsonify(errno=RET.OK, errmsg='短信发送成功')