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="请求过于频繁,请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(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='短信发送成功')