def get_image_code():
"""获取验证码图片的后端接口 （GET）"""
"""
1.获取参数
1.1 获取code_id，全球唯一的编码（uuid）
2.校验参数
2.1 非空判断，判断code_id是否有值
3.逻辑处理
3.1 生成验证码图片 & 生成验证码图片的真实值（文字）
3.2 以code_id作为key 将生成验证码图片的真实值（文字）存储到redis数据库
4.返回值
4.1 返回验证码图片
"""
code_id = request.args.get("code_id", "")
if not code_id:
current_app.logger.error("参数不足")
abort(404)
# 图片的名字 图片上面的文字 图片二进制数据要回传给浏览器的 # 他是用来生成图片验证码的
image_name, real_image_code, image_data = captcha.generate_captcha()
# print(image_name)
try:
redis_store.setex('imageCodeId--->%s' % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, real_image_code)
except Exception as e:
current_app.logger.error(e)
abort("500")
# 4.1返回验证码图片(二进制图片数据，不能兼容所有浏览器)
# 创建响应对象
response = make_response(image_data)
# print(response)
# 设置响应数据的内容类型 Content-Type："image/JPEG"
response.headers["Content-Type"] = "image/JPEG"
# print(response)
return response
def get_image_code():
"""获取验证码图片的后端接口"""
"""
1.获取参数
1.1 code_id:UUID通用的唯一编码,作为key将验证码真实值存储到redis数据库
2.校验参数
2.1 非空判断code_id不能为空
3.逻辑处理
3.1 生成验证码图片,验证码图片的真实值
3.2 code_id作为key将验证码图片的真实值保存懂啊redis数据库,并且设置有效时长(5分钟)
4.返回值
4.1 返回验证码图片
"""
# 1.1 code_id: UUID通用的唯一编码, 作为key将验证码真实值存储到redis数据库
code_id = request.args.get("code_id")
# 2.1非空判断code_id不能为空
if not code_id:
current_app.logger.error("参数不足")
abort(404)
# 3.1生成验证码图片, 验证码图片的真实值
image_name, real_image_code, image_data = captcha.generate_captcha()
# 3.2code_id作为key将验证码图片的真实值保存懂啊redis数据库, 并且设置有效时长(5分钟)
try:
redis_store.setex("CODEID_%s" % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, real_image_code)
except Exception as e:
current_app.logger.error(e)
# 4.1返回验证码图片(返回的数据默认是二进制格式,不一定适用与所有的浏览器)
response = make_response(image_data)
response.headers["Content-Type"] = "image/JPEG"
return response
def image_code():
"""提供图片验证码
1.接受参数（图片验证码唯一标识uuid）
2.校验参数（判断参数是否存在）
3.生成图片验证码
4.存储图片验证码
5.将图片的类型指定为image/jpg
6.响应图片验证码
"""
# 1.接受参数（图片验证码唯一标识uuid）
imageCodeId = request.args.get('imageCodeId')
# 2.校验参数（判断参数是否存在）
if not imageCodeId:
abort(403)
# 3.生成图片验证码:text写入到redis,image响应到浏览器
name,text,image = captcha.generate_captcha()
current_app.logger.debug(text)
# 4.存储图片验证码
try:
redis_store.set('ImageCode:'+imageCodeId, text, constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 5.将图片的类型指定为image/jpg
response = make_response(image)
# 设置响应头信息
response.headers['Content-Type'] = 'image/jpg'
# 6.响应图片验证码
return response
def generate_image_code():
"""
生成图片验证码
1、前端传入uuid给后端，用来实现图片验证码的存储
2、获取参数uuid，如果参数不存在，返回错误信息
3、使用captcha工具，生成图片验证码，name,text,image
4、根据uuid来存储图片验证码，存储在redis中text，
5、返回图片
:return:
"""
# 获取参数uuid
image_code_id = request.args.get('image_code_id')
# 判断参数是否存在，返回的自定义的状态码，用来实现前后端的数据交互
if not image_code_id:
return jsonify(errno=RET.PARAMERR,errmsg='参数缺失')
# 调用captcha工具生成图片验证码
name,text,image = captcha.generate_captcha()
# 把图片验证码的text存储到redis数据库中
try:
redis_store.setex('ImageCode_' + image_code_id,constants.IMAGE_CODE_REDIS_EXPIRES,text)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg='保存数据失败')
else:
# 如果没有发生异常，返回图片
response = make_response(image)
# 设置响应的报文信息，响应的类型为图片
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
"""
/passport/image_code?imageCodeId=c1a16ab9-31d7-4a04-87c2-57c01c303828
1、接收参数（随机的字符串）
2、校验参数是否存在
3、生成验证码 captche
4、把随机的字符串和生成的文本验证码以key，value的形式保存到redis
5、把图片验证码返回给浏览器
:return:
"""
# 1、接收参数（随机的字符串）
image_code_id = request.args.get("imageCodeId")
# 2、校验参数是否存在
if not image_code_id:
abort(404)
# 3、生成验证码 captche
_, text, image = captcha.generate_captcha()
current_app.logger.info("图片验证码为%s" % text)
# 4、把随机的字符串和生成的文本验证码以key，value的形式保存到redis
try:
redis_store.setex("ImageCodeId_" + image_code_id, constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
abort(500)
response = make_response(image)
response.headers["Content-Type"] = "image/jpg"
return response
def get_image_code():
"""
获取图片验证码
:return:
"""
# 1、获取图片验证码id
code_id = request.args.get("code_id")
# 2、生成图片验证码
name, text, image = captcha.generate_captcha()
# 3、保存图片验证码
try:
redis_store.setex("ImageCode_" + code_id, constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
return make_response(jsonify(errno=RET.DATAERR, errmsg="保存图片验证码失败"))
# 4、返回验证码图片
# resp = make_response(image)
# # 设置响应类型
# resp.headers["Content-Type"] = "image/jpg"
# return resp
print("图片验证码：%s" % text)
resp = Response(image, content_type="image/jpg")
return resp
def image_code():
"""
图片验证码的实现逻辑
1. 获取参数 图片验证码的随机值
！ 切记！ 一定要判断
2. 生成图片验证码
3. 将图片文字和随机值保存到redis中
4. 将图片验证码 返回
:return:
"""
image_code_id = request.args.get("imageCodeId", None)
# 判断参数是否有值
if not image_code_id:
abort(403)
# 生成图片验证码
name, text, image = captcha.generate_captcha()
# 将图片验证码文字保存到redis中
try:
redis_store.set("imageCodeId_" + image_code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as ret:
current_app.logger.error(ret)
abort(500)
# 将图片验证码返回
response = make_response(image)
# 让浏览器可以识别图片类型
response.headers["Content-Type"] = "image/jpg"
return response
def get_image_code():
# 1 获取参数 url中？后面的参数
# 2 判断参数是否有值。没有值返回404
# 3 生成图片验证码 使用三个参数接收
# 4 保存图片验证码文字内容到redis
# 5 返回验证码图片，并设置数据类型，以便浏览器识别其类型
image_code_id = request.args.get("imageCodeId", None)
if not image_code_id:
return abort(403)
name, text, image = captcha.generate_captcha()
try:
redis_store.set("ImageCodeId_" + image_code_id, text, constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
response = make_response(image)
response.headers["Content-Type"] = "image/jpg"
return response
def get_image_code():
"""生成图形验证码的后端接口"""
"""
1.获取参数
1.1 code_id: UUID唯一编号
2.校验参数
2.1 非空判断
3.逻辑处理
3.1 调用工具类，生成图形验证码图片，图形验证码的真实值
3.2 以code_id作为key图形验证码的真实值，存储到redis数据库
4.返回值
4.1 将图片数据返回
"""
# 1.1 获取参数 code_id: UUID唯一编号
code_id = request.args.get("code_id")
# 2.1 非空判断
if not code_id:
return abort(404)
# 3.1 调用工具类，生成图形验证码图片，图形验证码的真实值
image_name, real_image_code, image_data = captcha.generate_captcha()
# 3.2 以code_id作为key图形验证码的真实值，存储到redis数据库
redis_store.setex("imageCode_%s" % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, real_image_code)
# 4.1 将图片数据返回
# 注意：如果不设置响应数据格式，返回的就是普通文件数据，不能兼容所有浏览器
response = make_response(image_data)
# 将响应数据格式设置为：图片的png格式
response.headers["Content-Type"] = "png/image"
return response
def get_img_code():
"""
生成图片验证码并返回
:return:
"""
# 1：取到参数
image_code_id = request.args.get("imageCodeId", None)
# 2：判断参数是否为空
if not image_code_id:
return abort(403)
# 3：从工具包中生成图片验证码,返回值是元组
name, text, image = captcha.generate_captcha()
print(text)
# 4：将图片验证码保存到redis中
try:
redis_store.setex("ImageCodeId:" + image_code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger(e)
abort(500)
# 5：返回验证码图片到前端
response = make_response(image)
# 设置响应数据类型
response.headers['Content-Type'] = "image/jpg"
return response
def generate_image_code():
"""
生成图片验证码
1、获取参数，uuid，使用request.args查询字符串参数
2、判断参数是否存在，如果不存在，直接return
3、调用captcha工具，生成图片验证码
name,text,image
4、在redis数据库中存储图片验证码的text内容
5、返回图片给前端
"""
# 获取查询字符串形式的参数
image_code_id=request.args.get("image_code_id")
# 如果参数不存在，直接return
if not image_code_id:
return jsonify(errno=RET.PARAMERR,errmsg="参数缺失")
# 调用captcha生成图片验证码
name,text,image=captcha.generate_captcha()
# 存储图片验证码的text到redis数据库中
try:
redis_instance.setex('ImageCode'+image_code_id,constants.IMAGE_CODE_REDIS_EXPIRES,text)
except Exception as e:
current_app.logger(e)
return jsonify(errno=RET.DBERR, errmsg='保存数据失败')
# 返回图片
response=make_response(image)
# 设置响应的类型为image/jpg
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
"""
获取请求参数
生成图片验证码
保存到redis
返回图片验证码
:return:
"""""
# 获取用户利用get请求发送的数据cur_id
cur_id = request.args.get('cur_id')
prcur_id = request.args.get('prcur_id')
name, text, image_data = captcha.generate_captcha()
# 将图片验证码写入到redis中
try:
redis_store.set('image_code:%s'%cur_id, text, constants.IMAGE_CODE_REDIS_EXPIRES)
if prcur_id:
redis_store.delete('image_code:%s'%prcur_id)
except Exception as e:
current_app.logger.error(e)
response = make_response(image_data)
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
"""
１．获取查询参数
２．判断查询参数是否为空
３．不为空，则生成验证码并保存在redis中
４．生成验证码图片，返回给浏览器
:return:
"""
# 1.接收查询参数imageCodeId
image_code_id=request.args.get('imageCodeId',None)
# ２．判断查询参数是否为空
if not image_code_id:
abort(403)
# ３．不为空，则生成验证码并保存在redis中
name,text,image = captcha.generate_captcha()
# 保存验证码内容，并设置失效时间
try:
redis_store.set('imageCodeId'+image_code_id,text,constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 创建响应并添加响应类型
response=make_response(image)
response.headers['Content-Type']='image/jpg'
return response
def image_code():
"""图片验证码"""
# 接收uuid
code_id = request.args.get("code_id")
# 生成图片验证
name, text, image = captcha.generate_captcha()
print(text)
# 把图片验证码的文本内容和uuid组合保存到redis中
try:
# setex设置一个具有指定有效期的数据
redis_store.setex("image_code_%s" % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
# 记录日志
current_app.logger.error(e)
# 返回错误信息给客户端
return make_response(jsonify(error=RET.DATAERR, errmsg="保存图片验证码失败"))
response = make_response(image)
# 图片必须设置相应的数据类型，否则默认是text/html
response.headers["Content-Type"] = "image/jpeg"
return response
def get_image_code():
"""
注册页面请求图片验证码
:return:
"""
# 获取到当前的图片编号id
code_id = request.args.get('imageCodeId', None)
# 判断code_id是否有值
if code_id is None:
return abort(403)
# 使用captcha生成图片验证码
name, text, image = captcha.generate_captcha()
# 将图片验证码的内容保存的Redis中
try:
redis_store.setex('ImageCode_' + code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
# 使用log记录
current_app.logger.error(e)
response = make_response(jsonify(errno=RET.DATAERR, errmsg='保存验证码失败'))
return response
# 将图片验证码加入响应报文
response = make_response(image)
# 设置响应报文类型
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
"""
返回图片验证码
1. 获取参数
2. 校验参数
3. 生成验证码
4. 将验证码内容保存到redis
5. 设置返回数据格式
6. 返回图片验证码
"""
# 1.获取参数
image_code_id = request.args.get('imageCodeId', None)
# 2.校验参数
if not image_code_id:
abort(403)
# 3. 生成验证码
name, text, image = captcha.generate_captcha()
# 4.将验证码内容保存到redis
try:
redis_store.setex('ImageCodeId_' + image_code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 5.设置返回数据格式
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
"""
1.获取请求参数
2.生成图片验证码
3.保存到reids
4.返回图片验证码
:return:
"""
# 1.获取请求参数,args是获取?后面的参数 www.baidu.com?name=zhangsan&age=13
cur_id = request.args.get("cur_id")
pre_id = request.args.get("pre_id")
# 2.生成图片验证码
name, text, image_data = captcha.generate_captcha()
# 3.保存到reids
try:
# key + value +time
redis_store.set("image_code:%s" % cur_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
#判断是否有上一个uuid,如果存在则删除
if pre_id:
redis_store.delete("image_code:%s" % pre_id)
except Exception as e:
current_app.logger.error(e)
# 4.返回图片验证码
response = make_response(image_data)
response.headers["Content-Type"] = "image/jpg"
return response
def passport():
# print("前端请求的url地址 = " + request.url)
# 获取从前端传递过来的一个验证码.?后面的属性内容request.args.get("code_id")
code_id = request.args.get("code_id")
# name表示图片验证码的名字
# test表示图片验证码的内容
# image表示包含验证码的图片
# 生成图片验证码
name, text, image = captcha.generate_captcha()
print("图片验证码的内容 = " + text)
# 我们需要把图片验证码内容存在redis的数据库当中
# image_code_xxxx
# 第一个参数表示key
# 第二个参数表示图片验证码的内容
# 第三个参数表示过期时间
redis_store.set("image_code" + code_id, text, 300)
# 获取到redis里面的值的byte,所以在读取的时候需要解码
# make_response表示响应体对象,这个对象的参数表示图片形式的验证码
resp = make_response(image)
# 告诉系统,我们当前需要展示的是图片
resp.headers["Content-Type"] = "image/jpg"
return resp
def get_image_code():
"""
1,获取参数
1.1获取code_id值
2,校验参数
2.1判断code_id是否有值
3,逻辑处理
3.1 生成验证码图片 & 生成验证码图片上的真实值
3.2 根据code_id编号作为key将生成验证码图片上的真实值存储到redis数据，并且设置有效时长（后续接口需要校验）
4,返回值
"""
# 1, 获取参数
code_id = request.args.get("code_id")
# 2, 校验参数
if not code_id:
current_app.logger.error("参数不足")
abort(403)
# 3,逻辑处理
image_name, image_code, image_data = captcha.generate_captcha()
try:
redis_store.setex("Image_%s" % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, image_code)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 4,返回值
response = make_response(image_data)
response.headers["Content-Type"] = "image/JPEG"
return response
def generate_image_code():
"""
生成图片验证码
uuid：全局唯一的标识符，redis.setex('ImageCode_' + uuid )
1、获取前端生成的uuid
request.args.get("image_code_id")
2、判断参数是否存在，如果不存在直接return
3、使用工具captcha生成图片验证码,name,text,image
4、保存图片验证码的text文本，redis数据库中
5、返回图片
:return:
"""
# 获取前端传入的图片验证码的编号uuid
image_code_id = request.args.get('image_code_id')
# 判断参数是否存在
if not image_code_id:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 调用captcha工具，生成图片验证码
name, text, image = captcha.generate_captcha()
print(text)
# 保存图片验证码的文本到redis数据库中
try:
redis_store.setex('ImageCode_' + image_code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存数据异常')
else:
response = make_response(image)
# 修改默认的响应类型，text/html,
response.headers['Content-Type'] = 'image/jpg'
return response
def image_code():
"""
获取 图形验证码 -- json访问
:return: 验证码图片
"""
# 获取uuid
code_id = request.args.get("code_id")
# 生成图形验证码 ( 文件名, 验证码内容, 验证码图片 )
name, text, image = captcha.generate_captcha()
# 捕获异常
try:
# 使用时才导入, 不要放在文件头, 文件头没有上下文环境
# from info import redis_db
# 设置限时数据 (key, 限时时间, value)
# redis_db = redis.StrictRedis(connection_pool=redis_pool["pool_0"])
get_redis().setex('ImageCode_' + code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
# 处理异常
except Exception as e:
# 写日志 -- error级别
current_app.logger.error(e)
# 返回json格式数据 -- 保存失败
return make_response(jsonify(errno=RET.DATAERR, errmsg='保存图形验证码失败'))
# 根据图片生成响应体
response = make_response(image)
# 设置响应头 -- 数据类型
response.headers["Content-Type"] = "image/jpg"
# 返回
return response
def get_image_code():
""""生成图片验证码
1 取参数
2 判断参数是否有值
3 生成图片验证码
4 保存图片验证码内容到redis
5 返回验证码图片
"""
# args取到URL中？后面的参数
image_code_id = request.args.get("imageCodeId", "")
if not image_code_id:
return abort(403)
# 生成图片验证码
name, text, image = captcha.generate_captcha()
# 保存图片验证码内容到redis
try:
redis_store.set("ImageCodeId" + image_code_id, text, 300)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 返回验证码图片
# 返回的content—type应该是图片而不是html/ ，谷歌可以正确识别，其他的浏览器不一定识别所以需要指定
response = make_response(image)
response.headers["Content_Type"] = "image/jpg"
return response
def image_code():
"""提供图片验证码
1.接受参数（uuid）
2.校验参数（判断uuid是否为空）
3.生成图片验证码
4.保存图片验证码到redis
5.修改image的ContentType = 'image/jpg'
6.响应图片验证码
"""
# 1.接受参数（uuid）
imageCodeId = request.args.get('imageCodeId')
# 2.校验参数（判断uuid是否为空）
if not imageCodeId:
abort(403)
# 3.生成图片验证码
name, text, image = captcha.generate_captcha()
current_app.logger.debug(text)
# 4.保存图片验证码到redis
try:
redis_store.set('ImageCode:' + imageCodeId, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 5.修改image的ContentType = 'image/jpg'
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
# 5.响应图片验证码
return response
def get_image_code():
"""
Generate a image code and return
:return:
"""
# Get url params with request.args method
image_code_id = request.args.get('imageCodeId', None)
if not image_code_id:
return abort(404)
# Generate a image code
name, text, image = captcha.generate_captcha()
try:
# Save image code to redis
redis_store.set('imageCodeId_' + image_code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
current_app.logger.debug('生成的图片验证码为: %s' % text)
except Exception as e:
current_app.logger.error(e)
abort(500)
# Return image code to browser
response = make_response(image)
# Set response header data type
response.headers['Content-Type'] = 'image/jpg'
return response
def image_passport():
'''
1.获取浏览器传过来的参数uuid
2.校验参数
3.生成图片验证码
4.redis保存uuid和图验证码文本信息
5.返回验证码图片
'''
# 1. 获取当前的图片编号ID
image_code_id = request.args.get("code_id")
# 2校验是否有参数
if not image_code_id:
current_app.logger.debug("未获取到参数")
abort(403)
# 3. 生成图片验证码
name, text, image = captcha.generate_captcha()
print(text)
# 4. 将验证码保存到Redis中
try:
redis_store.set("ImageCode_" + image_code_id, text,
constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="数据保存错误")
return image
def get_image_code():
"""
生成图片验证码并返回
1.获取到当前的图片编号id
2.判断参数是否有值
3.生成验证码
4.保存图片验证码文字内容到redis
5.返回图片
:return:
"""
# 1.取到参数
image_code_id = request.args.get('imageCodeId', None)
# 2.判断参数是否有值
if not image_code_id:
return abort(403)
# 3.生成图片验证码
name, text, image = captcha.generate_captcha()
print("图片验证码是%s" % text)
# 4.保存图片验证码文字内容到redis
try:
# 保存当前生成的图片验证码内容
redis_store.set('ImageCodeId_' + image_code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 返回响应内容
resp = make_response(image)
# 设置内容类型,以便浏览器更加只能识别其是什么类型
resp.headers['Content-Type'] = 'image/jpg'
return resp
def get_image_code():
"""
生成图片验证码
:return: 返回图片验证码给浏览器
"""
# 1. 获取参数
url_params = request.args
if not url_params:
return jsonify(errno=RET.REQERR, errmsg="请求错误")
image_code_id = url_params.get("imageCodeId", None)
# 2. 校验参数
if not image_code_id:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 3. 生成图片验证码
name, text, image = captcha.generate_captcha()
# 4. 保存生成的验证码内容至redis中
try:
redis_store.set("ImageCodeId_" + image_code_id,
text,
ex=constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
# 5. 返回图片验证码给浏览器,设置响应头中的数据格式
response = make_response(image)
response.headers["Content-Type"] = "image/jpg"
return response
def get_image_code():
'''生成图片验证码并返回
1.取到参数
2.判断参数是否有值
3.生成图片验证码
4.保存图片验证码文字内容到redis
5.返回图片验证码
'''
# 1.取到参数
image_code_id = request.args.get('imageCodeId', None)
# 2.判断参数是否有值
if not image_code_id:
return abort(403)
# 3.生成图片验证码
name, text, image = captcha.generate_captcha()
current_app.logger.debug('图片验证码是 %s' % text)
# 4.保存图片验证码文字内容到redis
try:
redis_store.set('ImageCodeId_' + image_code_id, text, constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.debug(e)
abort(500)
# 5.返回图片验证码
response = make_response(image)
response.headers['Content_Type'] = 'image/jpg'
return response
def get_image_code():
"""
生成图片验证码并返回"
1. 取到参数
2. 判断参数是否有值
3. 生成图片验证码
4. 保存图片验证码文字内容到redis
5. 返回验证码图片
"""
# 1. 取到参数
# args: 取到url中 ? 后面的参数
image_code_id = request.args.get("imageCodeId", None)
# 2. 判断参数是否有值
if not image_code_id:
return abort(403)
# 3. 生成图片验证码
name, text, image = captcha.generate_captcha()
# 4. 保存图片验证码文字内容到redis
try:
redis_store.setex("ImageCodeId_" + image_code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
abort(500)
# 5. 返回验证码图片
response = make_response(image)
current_app.logger.debug(text)
# 设置数据的类型, 以便浏览器更加智能识别其是什么类型
response.headers["Content-Type"] = "image/jpg"
return response
def image_code():
"""图片验证功能"""
name, text, image = captcha.generate_captcha()
# 1.调用图片验证码模块生成的图片验证码
# name表示验证码图片的文件名（这里不需要使用）
# text 表示验证码图片中的文本信息
# image 表示验证码图片的二进制内容
# 2. 保存图片验证的文本到redis中，以uuid作为key，以文本作为value
image_code_id = request.args.get("image_code_id") # 把图片的UUID拿到
# print(image_code_id)
# 判断是否存在UUID
if not image_code_id:
current_app.logger.error("图片验证码缺少uuid") # 记录日志
# return make_response("图片验证码缺少") # 有时存在编码问题，需要返回json格式
return make_response(jsonify(error=RET.PARAMERR, errmsg="缺少UUID"))
# 保存在redis
try:
redis_store.setex("image_code_" + image_code_id,
constants.IMAGE_CODE_REDIS_EXPIRES,
text) # 以第一个参数uuid作为key，以text作为value；把text内容保存300秒
except Exception as e:
current_app.logger.error("保存图片验证文本失败")
return make_response(jsonify(errno=RET.DATAERR,
errmsg="保存验证文本失败")) # 错误码和错误信息
# 3. 把图片返回给客户端浏览器
response = make_response(image)
response.headers["Content-Type"] = "image/jpeg" # 【设置响应头】告诉浏览器，返回内容的格式是图片
return response
