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="请求过于频繁,请60秒以后再试") # 判断手机号时都存在 # 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) # 保存发送给这个手机号的记录,防止用户在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一步发送短信 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判断对于这个手机号的操作,在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(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) # 保存这个手机号的记录,防止用户在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(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="发送成功")