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数据库异常")
# 判断图片验证码是否过期
print(real_image_code)
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:
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, errmag="手机号已存在")
# 如果手机号不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码
try:
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函数调用后立即返回
# celery返回结果也是同步
send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# 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="发送异常")
# 返回值
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(f"image_code_{image_code_id}")
print(image_code_id, 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="图片验证码失效")
# 删除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="图片验证码错误")
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get(f"send_sms_code_{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:
# if user is not None:
# # 表示手机号存在
# return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果不存在，则生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码
try:
redis_store.setex(f"sms_code_{mobile}",
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex(f"send_sms_code_{mobile}",
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# 使用celery异步发送短信，delay函数调用后立即返回
reslult = send_sms.delay(
1, 18618350418, (sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)))
# 返回的是异步执行结果对象
print(reslult.id)
# 通过get方法能获取celery异步执行的结果
# get方法默认是阻塞行为，会等到
# reslult.get()
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=u'参数不完整')
# 业务处理
# 获取图片验证码真实值
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'redis连接错误')
# 判断图片验证码是否过期
if real_image_code is None:
return jsonify(errno=RET.DATAERR, errmsg=u'图片验证码已过期')
# 删除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=u'图片验证码错误')
# 判断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.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'用户已存在')
# 生成手机号验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存手机验证码
try:
redis_store.setex('sms_code_%s' % mobile,
constants.SMS_CODE_REDIS_EXPIRE, 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.DATAERR, errmsg=u'手机验证码保存失败')
# 发送手机验证码
# try:
# ccp = CCP()
# ret = ccp.send_temp_sms(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRE / 60)], 1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg=u'手机验证码发送异常')
# 利用celery发送短信
send_sms.delay(
mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRE / 60)], 1)
# 返回响应
return jsonify(errno=RET.OK, errmsg=u'发送成功')
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.DATAERR, errmsg="参数不完整")
#业务逻辑
#从redis取出真实图片验证码
try:
real_image_code = redis_store.get(
"image_code_{}".format(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_{}".format(image_code_id))
except Exception as e:
current_app.logger.error(e)
#对比验证码
real_image_code = bytes.decode(real_image_code)
if real_image_code.upper() != image_code.upper():
#表示用户填写错误
return jsonify(errno=RET.PARAMERR, errmsg="图片验证码错误")
#判断对于这个手机号的操作，在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.DATAEXIST, 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, 999999)
#保存真实验证码
try:
redis_store.setex("sms_code_{}".format(mobile),
constants.SMS_CODE_REDIS_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="保存短信验证码异常")
#发送短信
#ccp = CCP()
#try:
# result = ccp.send_template_sms(mobile,sms_code,str(int(constants.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 jsonifg(errno=RET.THIRDERR,errmsg="发送失败")
#返回异步任务对象
result_obj = send_sms.delay(
mobile, sms_code, str(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中取出真实的图片验证码
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:
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)
# 返回异步任务的对象
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():
"""获取短信验证码"""
# 1. 获取参数
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
mobile = request.args.get("mobile")
# 1. 校验参数
if not all([image_code, image_code_id]):
# 表示参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 1. 业务逻辑处理
# 从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="请求过于频繁，请６０秒以后再试")
# 判断手机号时都存在
# db.session(User)
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)
# 保存发送给这个手机号的记录，防止用户在６０ｓ内重复发送短信的操作
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一步发送短信
result = send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
print(result) # 返回的标记
print(result.get()) # 返回值
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="图片验证码失效")
# 删除redis中图片验证码，防止一个验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
## 与用户填写的对比
if image_code.lower() != real_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:
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，60秒后在试")
## 判断手机号是否注册过
try:
user = User.query.filter_vy(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)
# 保存该手机号发送短信的记录，防止60秒内再次发送短信
redis_store.setex("send_sms_code_%s" % mobile,
constants.SEND_SMS_CODE_INTERAVL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存验证码异常")
## 发送短信
# try:
# ccp = CCP()
# ret = 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)
# 返回
return jsonify(errno=RET.OK, errmsg="发送成功")
def get_sms_code(mobile):
"""
获取短信验证码
:param mobile: 注册用手机号,图片验证码,验证码的uuid
:return: json字符串{'errno':'xxx', 'errmsg': 'xxx'}
"""
# 获取数据
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='验证码已失效')
# 删除redis中的图片验证码，防止用户使用同一个图片验证码多次验证
try:
redis_store.delete('image_code_%s' % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 与用户填写的值进行对比
# print(real_image_code, '---', image_code)
# print(type(real_image_code))
# 从redis中取出的是bytes类型，需要解码
real_image_code = real_image_code.decode()
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:
# 表示在60秒之内有过发送的记录
return jsonify(errno=RET.REQERR, errmssg='请求过于频繁，请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)
# 保存真实的短信验证码
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='保存短信验证码异常')
# 发送短信
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="图片验证码失效")
# 删除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:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
# return jsonify(errno=RET.DBERR, errmsg="mysql数据库异常")
else:
if user is not None:
# 手机号码已存在
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 如果不存在，生成短信验证码
sms_code = "%6d" % random.randint(0,999999)
# 保存真实的短信验证码
try:
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异步发送短信
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):
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, msg=u"参数错误")
# 从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, msg=u'redis数据库异常')
# 判断是否过期
if real_image_code is None:
return jsonify(errno=RET.NODATA, msg=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, msg=u'填写错误')
# 判断对于这个手机的操作在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:
# 表示60s内之前有过发送短信记录
return jsonify(errno=RET.REQERR, msg=u'请求过于频繁，60s后重试')
# 判断用户是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user != None:
return jsonify(errno=RET.DATAEXIST, msg=u'手机号已存在')
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
try:
redis_store.setex('sms_code_%s' % mobile,
constants.SMS_CODE_EXPIRED_TIME, sms_code)
# 保存发送这个手机号的记录，防止60s再次发送的操作
redis_store.setex('send_sms_code_%s' % mobile,
constants.SEND_SMS_CODE_EXPIRED_TIME, 1)
except Exception as e:
# 记录日志
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, msg='save sms code id failed')
#celery 异步 发送短信
result = send_sms.delay(
mobile, [sms_code, int(constants.SMS_CODE_EXPIRED_TIME / 60)], 1)
print(result.id)
# get方法获取celery异步执行结果
# get方法默认阻塞，会等到执行结果才返回
# 可接受参数timeout，超时时间，超过时间还拿不到结果，直接返回
ret = result.get()
print ret
return jsonify(errno=RET.OK, msg=u'发送成功')
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, 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:
logging.error(e)
return jsonify(errno=RET.DATAERR, errmsg='redis数据库异常')
# 判断图片验证码是否过期,取出来的是None表示过期
if real_image_code is None:
return jsonify(errno=RET.NODATA, errmsg='图片验证码过期')
# todo:删除redis中image_code的值，防止用户用一张图片验证码多次验证
try:
redis_store.delete('image_code_%s' % image_code_id)
except Exception as e:
logging.error(e)
# 与用户输入的值进行对比
if image_code.lower() != real_image_code.lower():
# 表示用户填写错误
return jsonify(errno=RET.DATAERR, errmsg='图片验证码输入错误')
# todo: 在用户图片验证码校验完成后，我们进行redis数据库中的查询手机号在60s是否发送过操作短信，查询手机号的记录
try:
send_flag = redis_store.get('send_sms_code_%s' % mobile)
except Exception as e:
logging.error(e)
else:
if send_flag is not None:
# 表示在60s内有操作过
return jsonify(errno=RET.REQERR, errmsg='请求过于频繁,请60秒后重试')
# 判断输入的手机是否已经注册
# 连接可能出错，放在try中
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
logging.error(e)
else:
# 手机号已经注册
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已注册')
# todo: 如果用户未注册，则生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存真实的短信验证码
try:
redis_store.setex('sms_code_%s' % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# todo: 保存发送短信了的这个手机号的记录，防止用户在60s内再次发送短信的操作
redis_store.setex('send_sms_code_%s' % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='验证码保存失败')
# todo：普通发送短信的方式
#发送短信
# try:
# ccp = CCP()
# result = ccp.send_template_sms(mobile, [sms_code,int(constants.SMS_CODE_REDIS_EXPIRES/60)],1)
# except Exception as e:
# logging.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg='发送发送异常')
#
# if result==0:
# # 发送成功
# return jsonify(errno=RET.OK,errmsg='发送成功')
# else:
# # 发送失败
# return jsonify(errno=RET.THIRDERR, errmsg='发送失败')
# todo: 使用celery发送短信方式
result = send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 返回异步结果对象的编号
print(result.id)
# 通过get能获取celery异步执行的结果
# get方法默认是阻塞行为，会等到有结果的再返回
# get也能接收超时时间timeout，超过时间，还没有拿到返回结果自动返回
ret = result.get()
print(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="paramas lost")
# 业务逻辑处理
# 从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 database failed")
# 判断图片验证码是不是已经过期
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="图片验证码错误")
# 判断对于这个手机号在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:
#表示60s内有过发送记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁")
# 并且判断手机号是否已注册
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
# 如果user不是None，表示手机号已经注册
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已经存在")
# 如果没有注册，生成六位短信验证码，并将其保存到redis中
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的验证码
try:
redis_store.setex("sms_code_%s" % mobile,
constant.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发给这个手机的记录，避免60s内重复请求发短信验证码
redis_store.setex("send_sms_code_%s" % mobile,
constant.SEND_SMS_CODE_REDIS_EXPIRES, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常")
# 发送短信
# celery异步发送短信
result = send_sms.delay(
mobile, [sms_code, int(constant.SMS_CODE_REDIS_EXPIRES / 60)],
1) # delay（）调用后立即返回，相当于将任务放入了celery任务队列
# 返回的是异步执行结果对象,就是存在redis2号数据库中的BACKEND的一个对象
print(result.id)
# 通过这个get方法来获取redis中的结果,默认是阻塞的，会等到celery有了执行结果后再返回
# get方法也接收参数timeout，即超时时间，超过这个时间celery还拿不到结果则直接返回
ret = result.get()
print(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:
# 有值则返回，无值则返回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数据库异常")
# 删除图片验证码，防止用户使用同一个图片验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
# current_app.logger.error(e)
pass
# 判断图片验证码是否过期
if real_image_code is None:
# 图片验证码已过期
return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期")
# 与用户填写的值进行对比
if real_image_code.lower() != image_code.lower():
# 用户填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误")
# 判断对于这个手机号的操作在60秒内有没有之前的记录，如果有，则认为操作频发，不予处理
try:
send_flag = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
# current_app.logger.error(e)
pass
else:
if send_flag is not None:
# 表示在60秒内有过之前的记录
return jsonify(errno=RET.REQERR, errmsg="请求过于频繁，请60秒后再试")
# 判断手机号是否存在
# 有则为对象，无则返回None
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
# current_app.logger.error(e)
pass
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)
# 保存发送给这个手机号的记录，防止用户在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="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="发送异常")
#
# if result == 0:
# # 表示发送成功
# return jsonify(errno=RET.OK, errmsg="发送成功")
# else:
# # 发送不成功
# return jsonify(errno=RET.THIRDERR, errmsg="发送失败")
# 使用celery异步发送短信, delay函数调用后，立即返回
send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# 发送成功，返回值
return jsonify(errno=RET.OK, errmsg="ok")
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(error=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(error=RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 图片中验证码过期
return jsonify(error=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(error=RET.DATAERR, errmsg="图片验证码错误")
# p判断对于这个手机号的操作，在６０秒没有没有记录，如果有，则认为用户操作频繁，就不做处理
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(error=RET.REQERR, errmsg="请求过于频繁，请于60秒以后再试")
# 判断这个手机号的操作，在60秒之内有没有之前的记录，如果有则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.loger.error(e)
else:
if send_flag is not None:
# 表示在60秒内有过发送的记录
return jsonify(error=RET.REQERR, errmsg="请求过于频繁，请60秒之后再试")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
if user is not None:
return jsonify(error=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)
# 保存这个手机号的记录，防止用户在６０s内再次发送短信验证码
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(error=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(error=RET.THIRDERR, errmsg="短信服务器发送失败")
# 使用celery异步发送短信， delay函数滴啊用后立即返回
# send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
# 查看返回值
result = send_sms.delay(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
print('*'*30)
print(result)
print(result.id)
print('*' * 30)
# 通过get方法能获取celery异步执行的结果
# get方法默认阻塞行为,会等到执行结果之后才返回
# get方法也接受参数timeout，超时时间，超过超时间拿不到结果，则返回
print('-' * 10)
ret = result.get()
print(ret)
print('-' * 10)
# 返回值
# if result == 0:
# return jsonify(error=RET.OK, errmsg="发送成功")
# else:
# return jsonify(error=RET.THIRDERR, errmsg="发送失败")
return jsonify(error=RET.OK, errmsg="发送成功")