def get_image_code(): """提供图片验证码""" # 取得uuid号码 uuid = request.args.get('uuid') global last_uuid # 判定uuid是否为空 if not uuid: abort(403) # 生成图片验证码的名字,文字信息,图片 name, text, image = captcha.generate_captcha() current_app.logger.debug(text) try: if redis_store.get('ImageCode:' + last_uuid): redis_store.delete('ImageCode:' + last_uuid) redis_store.set('ImageCode:' + uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.errer(e) return jsonify(error_no=RET.DBERR, error_msg=u'存储图片验证码失败') #响应图片验证码 response = make_response(image) last_uuid = uuid # 响应头的文件类型改为图片类型 response.headers['Content-Type'] = 'image/jpg' return response
def get_image_code(): """提供图片验证码 1.接受请求,获取uuid 2.生成图片验证码 3.使用UUID存储图片验证码内容到redis 4.返回图片验证码 """ # 1.接受请求,获取uuid uuid = request.args.get('uuid') last_uuid = request.args.get('last_uuid') if not uuid: abort(403) # return jsonify(errno=RET.PARAMERR, errmsg=u'缺少参数') # 2.生成验证码:text是验证码的文字信息,image验证码的图片信息 name, text, image = captcha.generate_captcha() # 3.使用UUID存储图片验证码内容到redis try: if last_uuid: # 上次的uuid还存在,删除上次的uuid对应的记录 redis_store.delete('ImageCode:' + last_uuid) # 保存本次需要记录的验证码数据 redis_store.set('ImageCode:' + uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: print e return jsonify(errno=RET.DBERR, errmsg=u'保存验证码失败') # 4.返回图片验证码 resposne = make_response(image) resposne.headers['Content-Type'] = 'image/jpg' return resposne
def get_image_code(): uuid = request.args.get('uuid') print(uuid) last_uuid = request.args.get('last_uuid') print(last_uuid) if not uuid: abort(403) name, text, image = captcha.generate_captcha() logging.debug('图片验证码文字信息:' + text) try: if last_uuid: redis_store.delete('ImageCode:' + last_uuid) redis_store.set('ImageCode:' + uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: print e logging.error(e) # restful要求返回响应状态 return jsonify(errno=RET.DBERR, errmsg=u'保存验证码失败') # 4.返回图片验证码 resposne = make_response(image) resposne.headers['Content-Type'] = 'image/jpg' return resposne
def get_image_code(): #1.接收html定义的uuid值,并校验uuid uuid = request.args.get('uuid') if not uuid: abort(403) #2.生成图片验证码 name, text, image = captcha.generate_captcha() current_app.logger.debug(text) #debug只能在测试模式下使用 #logging.debug(text) # current_app.logger.warning(text) #3.使用redis数据库存储图片验证码,ImageCode:uuid作为key try: if uuid: redis_store.delete('ImageCode:%s' % last_uuid) redis_store.set('ImageCode:%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: print e #有可能使服务器崩溃的警报,线上要用error模式 # logging.error(e) #两种显示日志方法都可以使用 current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='存储验证码错误') #记录当前uuid,方便下一次使用时作为上一次的uuid,删除text global last_uuid last_uuid = uuid #4.响应图片验证码 #修改响应头的信息,指定响应内容是image.jpg respone = make_response(image) respone.headers['Content-Type'] = 'image.jpg' return respone
def get_image_code(): ''' 1. 获取传入的验证码id 2. 生成新的验证码 3. 删除旧的验证码信息, 保存新的验证码信息 4. 返回验证码图片 :return: ''' # 获取新验证码和旧验证码ID args = request.args cur = args.get('cur') pre = args.get('pre') if not cur: abort(403) # 获取验证码图片及内容 _, text, image = captcha.generate_captcha() current_app.logger.debug(text) # 保存新验证码内容, 删除旧验证码内容 try: redis_store.set('ImageCode_' + cur, text, constants.IMAGE_CODE_REDIS_EXPIRES) redis_store.delete('ImageCode_' + pre) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='验证码保存失败') response = make_response(image) response.headers['Content-Type'] = 'image/jpg' return response
def verify(): # 获取参数:uuid # 生成验证码 # 删除之前验证码并保存当前验证码 # 保存'验证码'&'uuid'到redis # 返回验证码 # 获取参数:uuid cur = request.args.get('cur') pre = request.args.get('pre') # 生成验证码 name, text, image = captcha.generate_captcha() # 删除之前验证码并保存当前验证码 # 保存'验证码'&'uuid'到redis # 格式:redis.set(key, value, 过期时间) print '验证码:', text try: if pre != '': redis_store.delete('image_code:%s' % pre) redis_store.set('image_code:%s' % cur, text, IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存验证码失败') # 返回验证码 res = make_response(image) # 修改响应的类型 res.headers['Content-Type'] = 'image/jpg' return res
def get_imae_code(): """ 1. 获取传入的验证码编号,并编号是否有值 2. 生成图片验证码 3. 保存编号和其对应的图片验证码内容到redis 4. 返回验证码图片 :return: """ # current_app.logger.error("error log") # 1. 获取传入的验证码编号,并编号是否有值 args = request.args cur = args.get("cur") pre = args.get("pre") if not cur: abort(403) # 2. 生成图片验证码 _, text, image = captcha.generate_captcha() current_app.logger.debug(text) # 删除之前保存的数据 # 3. 保存编号和其对应的图片验证码内容到redis try: redis_store.delete("ImageCode_" + pre) redis_store.set("ImageCode_" + cur, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) # 保存出现错误,返回JSON数据提示错误 return jsonify(errno=RET.DBERR, errmsg="保存验证码失败") # 4. 返回验证码图片 reponse = make_response(image) return reponse
def send_sms(): """1 接收参数, 判断是否有值 2 校验手机号是否合理 3 取出传过来的图片ID, 去Redis查询对应的数值, 是否相等 4 校验图片验证码是否正确 5 生成内容, 给手机发送验证码 6 保存手机验证码的内容和手机号ID 7 返回发送成功的响应""" data = request.data data_dict = json.loads(data) mobile = data_dict.get("mobile") image_code = data_dict.get("image_code") image_code_id = data_dict.get("image_code_id") # print mobile if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数不全") if not re.match("^1[3578][0-9]{9}$", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") try: real_image_code = redis_store.get("ImageCode_" + image_code_id) if real_image_code: redis_store.delete("ImageCode_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(rerrno=RET.DBERR, errmsg="获取图片验证码失败") print real_image_code if image_code.lower() != real_image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: user = None # 如果查询时出现错误,也需要给user初始化,如果不初始化,会报未定义的异常 current_app.logger.error(e) if user: return jsonify(errno=RET.DATAEXIST, errmsg="该手机已被注册") # 5生成内容, 给手机发送验证码 phone_code = random.randint(0, 999999) sms_code = "%06d" % phone_code # current_app.logger.info(sms_code) current_app.logger.debug("短信验证码的内容:%s" % sms_code) #result = CCP().send_template_sms(mobile,[sms_code,constants.SMS_CODE_REDIS_EXPIRES / 60],"1") # if result != 1: # return jsonify(error=RET.THIRDERR,errmsg="发送短信失败") # # 6. redis中保存短信验证码内容 try: print mobile redis_store.set("SMS_" + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="保存短信验证码失败") # 7. 返回发送成功的响应 return jsonify(errno=RET.OK, errmsg="发送成功")
def register(): """ 1.获取参数并判断是否为空 2.取到本地的验证码 3.将本地验证码和传入的短信进行对比 4.创建用户模型,并设置数据,并添加到数据库 5.返回结果 :return: """ # 1. 获取参数并判断是否有值 data_dict = request.json mobile = data_dict.get('mobile') phonecode = data_dict.get('phonecode') password = data_dict.get('password') if not all([mobile, phonecode, password]): return jsonify(errno=RET.PARAMERR, errmsg='参数不全') # 2.取到本地的验证码 try: sms_code = redis_store.get('SMS_' + mobile) redis_store.delete('SMS_' + mobile) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='本地验证码获取失败') if not sms_code: return jsonify(errno=RET.NODATA, errmsg='验证码过期') # 3.将本地验证码传入的短信验证码进行对比 if phonecode != sms_code: return jsonify(errno=RET.DATAERR, errmsg='验证码错误') # 4.创建用户模型,并设置数据,并添加到数据库中 user = User() # 设置数据 user.name = mobile user.mobile = mobile user.password = password # 保存用户数据 try: db.session.add(user) db.session.commit() except Exception as e: db.session.rollback() current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存数据失败') # 保存登录状态 session['name'] = mobile session['mobile'] = mobile session['password'] = password # 5.返回结果 return jsonify(errno=RET.OK, errmsg='注册成功')
def save_order_comment(order_id): """保存订单评论信息""" user_id = g.user_id # 获取参数 req_data = request.get_json() comment = req_data.get("comment") # 评价信息 # 检查参数 if not comment: return jsonify(errno=RET.PARAMERR, errmsg="参数错误") try: # 需要确保只能评论自己下的订单,而且订单处于待评价状态才可以 order = Order.query.filter(Order.id == order_id, Order.user_id == user_id, Order.status == "WAIT_COMMENT").first() house = order.house except Exception as ex: current_app.logger.error(ex) return jsonify(errno=RET.DBERR, errmsg="无法获取订单数据") if not order: return jsonify(errno=RET.REQERR, errmsg="操作无效") try: # 将订单的状态设置为已完成 order.status = "COMPLETE" # 保存订单的评价信息 order.comment = comment # 将房屋的完成订单数增加1 house.order_count += 1 db.session.add(order) db.session.add(house) db.session.commit() except Exception as ex: current_app.logger.error(ex) db.session.rollback() return jsonify(errno=RET.DBERR, errmsg="操作失败") # 因为房屋详情中有订单的评价信息,为了让最新的评价信息展示在房屋详情中,删除redis中关于本订单房屋的详情 try: redis_store.delete(f"house_info_{order.house_id}") except Exception as ex: current_app.logger(ex) return jsonify(errno=RET.OK, errmsg="OK")
def get_image_code(): """提供图片验证码 1.获取uuid,并校验uuid 2.生成图片验证码 3.使用redis数据库缓存图片验证码,uuid作为key 4.响应图片验证码 """ # 1.获取uuid,并校验uuid uuid = request.args.get('uuid') if not uuid: abort(403) # 2.生成图片验证码 name, text, image = captcha.generate_captcha() # print text # logging.debug('验证码内容为:' + text) current_app.logger.debug('app验证码内容为:' + text) try: # 3.使用redis数据库缓存图片验证码,uuid作为key # 如果有last_uuid if last_uuid: redis_store.delete('ImageCode:%s' % last_uuid) # 过期时间300秒 redis_store.set('ImageCode:%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: logging.error(e) current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存验证码失败') # 记录当前的uuid,方便下次使用时作为上一次的uuid,删除上次的text global last_uuid last_uuid = uuid # 4.响应图片验证码 # 修改响应头信息,指定响应的内容是image/jpg response = make_response(image) response.headers['Content-Type'] = 'image/jpg' # 响应图片验证码 return response
def order_comment(): """ 订单评价 1. 获取参数 2. 校验参数 3. 修改模型 :return: """ # 1. 获取参数 data_json = request.json order_id = data_json.get("order_id") comment = data_json.get("comment") # 2. 2. 校验参数 if not all([order_id, comment]): return jsonify(errno=RET.PARAMERR, errmsg="参数错误") try: order = Order.query.filter(Order.id == order_id, Order.status == "WAIT_COMMENT").first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="查询数据错误") if not order: return jsonify(errno=RET.NODATA, errmsg="该订单不存在") # 3. 修改模型并且保存到数据库 # 3. 修改模型并且保存到数据库 order.comment = comment order.status = "COMPLETE" try: db.session.commit() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="保存数据失败") # 删除房屋详情信息缓存 try: redis_store.delete("house_detail_%d" % order.house_id) except Exception as e: current_app.logger.error(e) # 4 返回结果 return jsonify(errno=RET.OK, errmsg="ok")
def get_image_code(): """提供图片验证码""" # 1.获取uuid,并校验uuid # 2.生成图片验证码 # 3.使用redis数据库缓存图片验证码,uuid作为key # 4.响应图片验证码 # 1.获取之前的uuid和当前的uuid cur_image_uuid = request.args.get('cur') if not cur_image_uuid: abort(403) # 2.生成图片验证码 name, text, image = captcha.generate_captcha() logging.debug('验证码:%s' % text) # current_app.logger.debug('app验证码内容是:' + text) # 3.使用redis数据库缓存图片验证码,uuid作为key try: # 删除之前的验证码 if prev_image_uuid: redis_store.delete('ImageCode:%s' % prev_image_uuid) global prev_image_uuid prev_image_uuid = cur_image_uuid # 保存当前的验证码 redis_store.setex('ImageCode:%s' % cur_image_uuid, constants.IMAGE_CODE_REDIS_EXPIRES, text) except Exception as e: logging.error(e) current_app.logger.error(e) # 返回响应内容 return make_response(jsonify(errno=RET.DBERR, errmsg='保存图片验证码失败')) resp = make_response(image) # 设置内容类型 resp.headers['Content-Type'] = 'image/jpg' # 4.响应图片验证码 return resp
def get_image_code(): """提供图片验证码""" # 1. 获取uuid,并校验uuid # 2.上传图片验证码 # 3.使用redis数据库缓存图片验证码,uuid作为key # 4.响应图片验证码 # 1. 获取uuid,并校验uuid uuid = request.args.get('uuid') if not uuid: abort(403) # 2.上传图片验证码 # 生成图片验证码的名字,文本该信息,图片 name, text, image = captcha.generate_captcha() # logging.debug('验证码内容为:' + text) # 这个输入日志会定位到哪个文件那一行,比较详细 current_app.logger.debug('app验证码内容为:' + text) # 3.使用redisreids数据库缓存图片验证码,uuid作为key try: # 如果有lst_uuid if last_uuid: redis_store.delete('ImageCode%s' % last_uuid) # 过期时间300秒 redis_store.set('ImageCode%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: # logging.error(e) current_app.logger.debug(e) return jsonify(error=RET.DBERR, errmsg='保存验证码失败') # 记录当前的uuid,方便下次使用时作为上一次的的uuid,删除上一次的text global last_uuid last_uuid = uuid # 响应图片验证码 response = make_response(image) # 设置响应头中的文件类型 response.headers['Content-Type'] = 'image/jpg' return response
def get_image_code(): """提供图片验证码 1.获取uuid,并校验uuid 2.生成图片验证码 3.使用redis数据库缓存图片验证码,uuid作为key 4.响应图片验证码 """ # 1.获取uuid,并校验uuid uuid = request.args.get('uuid') if not uuid: abort(403) #2.⽣成图⽚验证码的名字,⽂本信息,图⽚ name, text, image = captcha.generate_captcha() # logging.debug('验证码:'+text) current_app.logger.debug('验证码:' + text) # 3.使用redis数据库缓存图片验证码,uuid作为key try: if last_uuid: redis_store.delete('ImageCode:%s' % last_uuid) redis_store.set('ImageCode:%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg=u'保存验证码失败') global last_uuid last_uuid = uuid # 4.响应图片验证码 response = make_response(image) # 设置响应头中的⽂件类型,指定响应的内容是image/jpg response.headers['Content-Type'] = 'image/jpg' return response
def get_image_code(): """" 1、获取uuid,并校验uuid 2、生成图片验证码 3、使用redis数据库缓存图片验证码,uuid作为key 4、响应图片验证码 """ uuid = request.args.get('uuid') if not uuid: abort(403) #生成图片验证码 text验证码文本信息image验证码图片信息 name, text, image = captcha.generate_captcha() # current_app.logger.debug('app验证码内容为:' + text) # 3、使用redis数据库缓存图片验证码,uuid作为key try: if last_uuid: redis_store.delete('ImageCode:%s' % last_uuid) redis_store.set('ImageCode:%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: # print e current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存验证码失败') global last_uuid last_uuid = uuid # 4.响应图片验证码 # 修改响应头信息,指定响应的内容是image/jpg response = make_response(image) response.headers['Content-Type'] = 'image/jpg' #相应是记得要转img图片格式,不然默认是html # 响应图片验证码 return response
def get_image_code(): """提供图片验证码""" # 1,获取uuid,并效验uuid uuid = request.args.get('uuid') if not uuid: abort(403) # 2,上传图片验证码 name, text, image = captcha.generate_captcha() # print text # logging.debug('AAA验证码为' + text) current_app.logger.debug('验证码为' + text) # 3,使用redis数据库缓存图片验证码,uuid作为key try: if last_uuid: redis_store.delete('ImageCode:%s' % last_uuid) # 过期时间为300秒 redis_store.set('ImageCode:%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES) # redis_store.delete('key:last_uuid') except Exception as e: # print e # logging.error(e) current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存验证码失败') # 记录当前的uuid global last_uuid last_uuid = uuid # 4,修改响应头信息,指定响应的内容是image/jpg response = make_response(image) response.headers['Content-Type'] = 'image/jpg' # 响应图片验证码 return response
def get_image_code(): """ 图片验证码的视图函数 1. 取到图片编码 2. 生成图片验证码 3. 将图片验证码内容通过图片编码保存到redis中 4. 返回图片 :return: """ # 1. 取到图片编码 cur_id = request.args.get("cur_id") pre_id = request.args.get("pre_id") if not cur_id: abort(403) # 2. 生成图片验证码 _, text, image = captcha.generate_captcha() current_app.logger.debug("图片验证码为:" + text) # 3. 将图片验证码内容通过图片编码保存到redis中 try: redis_store.set("ImageCode:" + cur_id, text, constants.IMAGE_CODE_REDIS_EXPIRES) if pre_id: redis_store.delete("ImageCode:" + pre_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="保存验证码数据失败") # 返回图片验证码的图片 response = make_response(image) # 设置响应的内容类型 response.headers["Content-Type"] = "image/jpg" # 进行返回 return response
def register(): """用户注册 请求的参数:手机号,短信验证码,密码,确认密码 参数各式:json """ # 获取请求的json数据,返回字典 request_dict = request.get_json() # 获取参数 mobile = request_dict.get("mobile") sms_code = request_dict.get("sms_code") password = request_dict.get("password") password2 = request_dict.get("password2") # 校验参数 if not all([mobile, sms_code, password, password2]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") if not re.match(r"1[3-9]\d{9}", mobile): # 格式不对 return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") if password != password2: # 两次密码不一致 return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致") # 从Redis中取出短信验证码 try: real_sms_code = redis_store.get("sms_code_{}".format(mobile)) if real_sms_code is not None: real_sms_code = redis_store.get( "sms_code_{}".format(mobile)).decode("UTF-8") except Exception as ex: current_app.logger.error(ex) return jsonify(errno=RET.DBERR, errmsg="读取真实短信验证码异常") # 判断短信验证码是否过期 if real_sms_code is None: return jsonify(errno=RET.NODATA, errmsg="短信验证码失效") # 判断用户填写的短信验证码的正确性 if real_sms_code != sms_code: return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误") # 删除Redis中的短信验证码,防止重复使用校验 try: redis_store.delete("sms_code_{}".format(mobile)) except Exception as ex: current_app.logger.error(ex) # 判断用户的手机号是否注册过 # try: # user = User.query.filter_by(mobile=mobile).first() # except Exception as ex: # current_app.logger.error(ex) # return jsonify(errno=RET.DBERR, errmsg="数据库异常") # else: # if user is not None: # # 手机号已存在 # return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在") # 保存的用户的数据到数据库中 user = User(name=mobile, mobile=mobile) # user.generate_password_hash(origin_password=password) user.password = password # 设置属性 try: db.session.add(user) db.session.commit() except IntegrityError as ie: # 事务回滚 db.session.rollback() # 表示手机号出现了重复值,即手机号已经注册过 current_app.logger.error(ie) return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在") except Exception as ex: current_app.logger.error(ex) return jsonify(errno=RET.DBERR, errmsg="查询数据库异常") # 保存登录状态到Session中 session["name"] = mobile session["mobile"] = mobile session["user_id"] = user.id # 返回结果 return jsonify(errno=RET.OK, errmsg="注册成功")
def send_sms_code(): ''' 获取手机号, 图片验证码 对比图片验证码 成功后生成短信验证码 保存验证码, 发送短信 手机号: 短信验证码 redis :return: ''' # json_data = request.data # data_dict = json.loads(json_data) data_dict = request.json image_code = data_dict['image_code'] image_code_id = data_dict['image_code_id'] mobile = data_dict['mobile'] # 判断数据是否完整 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg='参数不完整') # 判断手机号是否合法 if not re.match("^1[3578][0-9]{9}$", mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号不正确') # 判断图片验证码是否正确 # 获取真实验证码 try: real_image_code = redis_store.get('ImageCode_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='查询数据异常') # 验证码不存在 if not real_image_code: return jsonify(errno=RET.DATAERR, errmsg='验证码已过期') # 验证码不正确 if real_image_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg='验证码不正确') # 删除图片验证码 try: redis_store.delete('ImageCode_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='删除本地验证码错误') try: user = User.quert.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) user = None if user: return jsonify(errno=RET.DATAEXIST, errmsg='手机号已被注册') sms_code = '%06d' % random.randint(0, 999999) current_app.logger.debug('短信验证码' + sms_code) # result = CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES / 60], '1') # # if result != 1: # return jsonify(errno=RET.THIRDERR, errmsg='发送短信验证码失败') try: redis_store.set('SMS_' + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存短信验证码错误') # 发送成功 return jsonify(errno=RET.OK, errmsg='发送成功')
def get_sms_code(mobile): """获取短信验证码""" image_code = request.args.get("code") image_code_id = request.args.get("codeId") if not all([image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR]) try: real_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=error_map[RET.DBERR]) if real_code is None: return jsonify(errno=RET.NODATA, errmsg=error_map[RET.NODATA]) # 删除redis中的图片验证码,防止用户使用同一个图片验证码验证多次 try: redis_store.delete("image_code_%s" % image_code_id) except Exception as e: current_app.logger.error(e) # 与用户填写的值进行对比 if real_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg=error_map[RET.DATAERR]) 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=error_map[RET.REQERR]) # 判断手机号是否存在 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=error_map[RET.DATAEXIST]) # 如果手机号不存在,则生成短信验证码 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=error_map[RET.DBERR]) try: sms = SMS.instance() result = sms.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=error_map[RET.THIRDERR]) if result == 0: return jsonify(errno=RET.OK, errmsg=error_map[RET.OK]) else: return jsonify(errno=RET.THIRDERR, errmsg=error_map[RET.THIRDERR])
def register(): """"用户注册 请求的参数: 手机号, 验证码, 密码, 确认密码 参数格式: json """ # 获取参数: # 获取请求的json数据,返回字典 req_dict = request.get_json() mobile = req_dict.get('mobile') sms_code = req_dict.get('sms_code') password = req_dict.get('password') password2 = req_dict.get('password2') print(mobile, sms_code, password, password2) # 校验参数: # 校验参数是否完整 if not all([mobile, sms_code, password, password2]): # 参数不完整 return jsonify(errno=RET.PARAMERR, errmsg="参数信息不完整") # 校验手机格式是否正确 if not re.match(r'1[34578]\d{9}', mobile): # 手机格式不正确 return jsonify(errno=RET.PARAMERR, errmsg="手机格式不正确") # 校验两次密码是否一致 if password != password2: # 两次密码不一致 return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致") # 业务逻辑处理: # 从redis中取出短信验证码 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="读取真实短信验证码异常") # 判断从redis中取出的短信验证码是否过期 if real_sms_code is None: return jsonify(errno=RET.NODATA, errmsg="短信验证码失效") # 删除redis中的短信验证码,防止重复使用校验 try: redis_store.delete("sms_code_%s" % mobile) except Exception as e: # 记录日志 current_app.logger.error(e) # 判断用户填写的短信验证码与从redis中取出的短信验证码是否一致 if real_sms_code != sms_code: return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误") # 判断用户手机号是否注册过 # try: # user = User.query.filter_by(mobile=mobile).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="手机号已存在") # 保存用户注册信息到数据库 # password_hash = generate_password_hash(password) # 密码加密 # user = User(name=mobile, password_hash=password_hash, mobile=mobile) user = User(name=mobile, password_hash=password, mobile=mobile) user.password = password # 设置密码属性,即给密码进行加密 try: db.session.add(user) db.session.commit() except IntegrityError as e: # 数据库操作错误后的事务回滚 db.session.rollback() # 记录日志, 表示手机号出现重复值,即手机号已被注册 current_app.logger.error(e) return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在") except Exception as e: # 数据库操作错误后的事务回滚 db.session.rollback() # 记录日志 current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="查询数据库异常") # 保存登录状态到session中 session['name'] = mobile session['mobile'] = mobile session['user_id'] = user.id # 返回值: return jsonify(errno=RET.OK, errmsg="注册成功")
def get_sms_code(mobile): """使用celery异步任务发送短信验证码""" # 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: 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) # 保存真实的短信验证码到redis中 try: redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRE, sms_code) # 保存发送给这个手机号的验证码记录,防止用户在60秒内再次触发发送短信验证码的操作 # redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1) redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, "保存发送验证码记录,防止60秒内再次发送的操作") except Exception as e: # 记录日志 current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="保存短信验证码异常") # 发送短信 # 使用celery异步发送手机短信验证码,delay调用后立即返回 send_sms.delay( mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRE / 60)], 1) # 4.返回值 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_{}".format(image_code_id)).decode("UTF-8") except Exception as ex: current_app.logger.error(ex) return jsonify(errno=RET.DBERR, errmsg="redis数据库异常") # print("验证码", image_code) # print("真实验证码", real_image_code) print("判断验证码是否过期") # 判断验证码是否过期 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 ex: current_app.logger.error(ex) # print("验证码", image_code.lower()) # print("真实验证码", real_image_code.lower()) print(" 判断用户输入的验证码是否正确") # 判断用户输入的验证码是否正确 if real_image_code.lower() != image_code.lower(): # 用户输入的验证码错误 return jsonify(errno=RET.DATAERR, errmsg="图片验证码错误") # 判断对于这个手机号的操作在60秒内有没有之前的记录, 如果有则认为用户操作频繁,不接受处理 try: # send_flag = redis_store.get("send_sms_code_{}".format(mobile)).decode("UTF-8") send_flag = redis_store.get("send_sms_code_{}".format(mobile)) if send_flag is not None: send_flag = redis_store.get("send_sms_code_{}".format(mobile)).decode("UTF-8") print("!" * 100) print("数据类型:", type(send_flag)) except Exception as ex: current_app.logger.error(ex) else: if send_flag is not None: # 表示60秒内之前有发送过的记录 return jsonify(errno=RET.REQERR, errmsg="请求过于频繁,请60秒后重试") # 进行对比与用户填写的值 print("进行对比与用户填写的值") # 判断手机号是否已经注册 try: user = User.query.filter_by(mobile=mobile).first() except Exception as ex: current_app.logger.error(ex) else: if user is not None: # 手机号已存在 return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在") # 如果手机号不存在,则生成短信验证码(6位整数) sms_code = "%06d" % randint(0, 999999) # 保存真实验证码 try: redis_store.setex("sms_code_{}".format(mobile), constains.SMS_CODE_REDIS_EXPIRE, sms_code) # 保存发送给这个手机号的记录,防止用户在60秒内再次触发发送短信的操作 redis_store.setex("send_sms_code_{}".format(mobile), constains.SEND_SMS_CODE_INTERVAL, 1) except Exception as ex: current_app.logger.error(ex) return jsonify(errno=RET.DBERR, errmsg="保存短信验证码异常") print("保存真实验证码") print("准备异步发送短信") # 发送短信 # 使用celery异步发送短信,delay函数调用后会立即返回 # send_sms.delay(mobile, [sms_code, int(constains.SMS_CODE_REDIS_EXPIRE / 60)], 1) # result = tasks.send_sms.delay(mobile, [sms_code, int(constains.SMS_CODE_REDIS_EXPIRE / 60)], 1) result = send_sms.delay(mobile, [sms_code, int(constains.SMS_CODE_REDIS_EXPIRE / 60)], 1) print(result.id) # 通过get方法能获取celery异步执行的结果 # get方法默认是阻塞行为,会等到有了执行结果之后才会返回 # get方法也接受参数timeout, 超时时间,超过超时时间还拿不到结果则返回 ret = result.get() print("异步发送短信成功") print(ret) # ccp.send_template_sms(mobile, [sms_code,int(constains.SMS_CODE_REDIS_EXPIRE / 60)],1) # 发送成功 return jsonify(errno=RET.OK, errmsg="发送成功")