def get_image_code():
"""
1.接收参数（随机的字符串）
2.验证参数是否存在
3.生成验证码
4.把随机生成的字符串和文本验证码以key，value的形式存储到redis数据库
5.把图片验证码返回给浏览器
:return:
"""
# 1、接收参数
image_code_id = request.args.get("imageCodeId")
# 2、验证参数
if not image_code_id:
abort(404)
# 3、生成验证码
_, 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)
# 5、把图片验证码返回给浏览器
response = make_response(image)
response.headers["Content-Type"] = "image/jpg"
return response
def get_image_code():
"""
获取图片验证码
1.接收请求，获取UUID和上一个uuid
2.判断数据库保存的uuid是否等于last_uuid等于删除，
3.生成图片验证码
4.保存新的uuid，对应的图片文本信息
:return: josnify 验证码图片
"""
# 1.接收请求，获取UUID，last_uuid
data = request.get_json(silent=True)
if not data:
return '参数不完整'
uuid = data.get('uuid')
last_uuid = data.get('last_uuid')
if not uuid:
return '参数不完整'
# 2.生成图片验证码 名字，文字信息，图片信息
name, text, image = captcha.generate_captcha()
# 4.删除上次生成的验证码图片
try:
if last_uuid:
redis_conn.delete('ImageCode:' + last_uuid)
# 3.保存UUID对应的验证码文字信息,设置时长
redis_conn.set('ImageCode:' + uuid, text, 600)
except Exception as e:
print e
return '保存图片验证码失败'
print redis_conn.get('ImageCode:' + uuid)
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
"""
:return:
"""
# 1.接受参数
image_code_id = request.args.get('imageCodeID')
# 2.校验参数
if not image_code_id:
abort(400) # 缺少参数
# 3.生成图片及验证码
name, text, image = captcha.generate_captcha()
try:
redis_store.set("imageID:" + image_code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
logging.error(e)
abort(500)
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 image_code():
'''
生成图片验证码
'''
# 获取图片验证的UUID
# 1：获取参数
image_code_id = request.args.get('image_Code')
# 2：检验参数
if not image_code_id:
abort(403)
# 3：生成图片验证码，其返回为名字、文本、以及图片
name, text, image = captcha.generate_captcha()
# 将图片存到redis中，并设置过期时间
redis_store.set('image_code_' + image_code_id, text,
IMAGE_CODE_REDIS_EXPIRES)
resp = make_response(image)
# 设置请求头属性-Content-Type响应的格式
resp.headers['Content-Type'] = 'image/jpg'
print('图片验证码为: %s' % text)
return resp
def get(self, request, img_codes):
code, image = captcha.generate_captcha()
con_redis = get_redis_connection('verify_codes')
redis_key = 'img_{}'.format(img_codes)
con_redis.setex(redis_key, 60, code)
logger.info("IMAGE_CODE {}".format(code))
return HttpResponse(content=image, content_type="image/jpg")
def generate_image_code(image_code_id):
"""
生成图片验证码
1. 调用captcha 扩展包生成图片验证码，name,text, image
2. 在服务器保存图片验证码内容，在缓存redis数据库中存储
3. 使用响应对象返回前端图片验证码
:param image_code_id:
:return:
"""
# 生成图片验证码，调用captcha 扩展包
name, text, image = captcha.generate_captcha()
# 在服务器redis缓存中存储图片验证码的内容，指定过期时间
try:
redis_store.setex('ImageCode_'+ image_code_id, 300, text)
except Exception as e:
# 日志记录
current_app.logger.error(e)
# jsonify 序列化数据
return jsonify(statucode.DATABASE_ERROR, errmsg='保存图片验证码失败')
# 返回前图片验证码，需要使用响应对象
# finally是无论是否有异常，都会被执行，else如未异常执行
else:
response = make_response(image)
# 设置响应的数据类型
response.headers['Content-Type'] = 'image/jpg'
# 返回前端图片验证码
return response
def get(self):
code_id = self.get_argument('codeid')
pre_code_id = self.get_argument('pcodeid')
"如果有pcodeid，删除再redis的缓存"
if pre_code_id:
"image_code 在redis储存时，增加一个前缀，容易识别"
"尝试删除，否则捕获异常，放到日志里"
try:
self.redis.delete('image_code_%s' % pre_code_id)
except Exception as e:
logging.error(e)
"如果没有，则获取验证码，"
"""
name 图片验证码名称
text 图片验证码文本
image 图片验证码二进制数据
"""
"captcha 二维码生成函数"
name, text, image = captcha.generate_captcha()
try:
"储存时间"
save_time = constants.IMAGE_CODE_EXPIRES_SECONDS
"想缓存redis里面存codeid，存时间，文本"
self.redis.setex('image_code_%s' % code_id, save_time, text)
except Exception as e:
logging.error(e)
self.write("")
else:
"设置传入文件格式"
self.set_header("Content-Type", 'image/jpg')
"将图片返回给前端"
self.write(image)
def get(self):
# 接收前端传递过来的id，用来作为redis的key
image_code_id = self.get_argument("id")
# 调用第三方接口，用来生成验证码
# name: 表示验证码名称
# text: 表示验证码的内容
# image: 验证码图片，该值是一个二进制数据
name, text, image = captcha.generate_captcha()
try:
# 写入redis，并设置过期时间
self.redis.setex("image_code_%s" %image_code_id, constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
# 将错误信息写入日志，并通过json将错误信息返回
logging.error(e)
resp_data = {
"errno": RET.DBERR,
"errmsg": "插入redis失败"
}
self.write(resp_data)
else:
# 将验证码返回，并设置响应头
self.write(image)
self.set_header("Content-Type", "image/jpg")
def get(self, request, image_code_id):
text, image = captcha.generate_captcha()
conn_redis = get_redis_connection('verify_codes') # 连接到redis数据库
conn_redis.setex('img_{}'.format(image_code_id), 300, text) # 设置图片验证码过期时间
logger.info('图片验证码:{}'.format(text))
return HttpResponse(content=image, content_type='image/jpg')
def image_code(image_code_id):
""" 获取图片验证码
Args:
image_code_id: 图片验证码编号
Retruns:
正常情况(验证码图片) 错误情况(错误信息)
"""
# 1. 业务逻辑处理
if not image_code_id:
return jsonify(errcode=RET.NODATA, errmsg='缺少数据')
# 2. 生成验证码图片
name, text, image_data = captcha.generate_captcha()
# print(text)
# 将验证码真实值与编号保存到redis中, 使用字符串数据存储单条记录: 'image_code_编号': '验证码真实值'
try:
redis_conn.set('image_code_{}'.format(image_code_id),
text,
ex=current_app.config.get('IMAGE_CODE_REDIS_EXPIRE'))
except Exception as e:
# 记录日志
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmsg='保存图片验证码失败')
# 3. 返回图片
resp = make_response(image_data)
resp.headers['Content-Type'] = 'image/jpg'
return resp
def get(self):
code_id = self.get_argument("codeid")
pre_code_id = self.get_argument("pcodeid")
logging.error("++++++")
logging.error(code_id)
logging.error("******")
# 如果缓存中存在删除。
if pre_code_id:
try:
self.redis.delete("ImageCode_%s" % pre_code_id)
except Exception as e:
logging.error(e)
#name 图片验证码名称
name, text, image = captcha.generate_captcha()
self.set_header("Content-Type", "image/jpg")
# self.write(image)
# self.set_header("Content-Type", "image/jpg")
try:
self.redis.setex("ImageCode_%s" % code_id,
constants.PIC_CODE_EXPIRES_SECONDS, text)
except Exception as e:
logging.error(e)
self.write("")
else:
self.set_header("Content-Type", "image/jpg")
self.write(image)
class ImageCodeHanlder(BaseHandler):
"""
图片验证码处理类
"""
def get(self):
code_id = self.get_argument("codeid")
pre_code_id = self.get_argument("precodeid")
if pre_code_id:
try:
self.redis.delete("image_code_%s" % pre_code_id)
except Exception, e:
logging.error(e)
# name 图片验证码名称
# text 图片验证码文本
# image 图片验证码二进制数据
name, text, image = captcha.generate_captcha()
# print "This is",text
# print "This is",code_id
try:
self.redis.setex("image_code_%s" % code_id,
constants.IMAGE_CODE_EXPIRES_SECONDS, text)
image_code_id = "image_code_" + code_id
# print "插入前", image_code_id
# print "This is", self.redis.get(image_code_id)
# print "插入成功"
except Exception, e:
logging.error(e)
self.write("")
def GetCode(request):
name, text, image = captcha.generate_captcha()
# 存入session,用户提交的时候进行对比
request.session['code'] = text
request.session['codes'] = text.lower()
#
return HttpResponse(image, 'image/jpg')
def make_code(request):
name, text, img = captcha.generate_captcha()
# 写入session
# request.session['code'] = text # 可以成功设置
# 将验证码存入到cache，设置生命周期
cache.set('code', text, 360)
return HttpResponse(img)
def get(self, request, image_code_id):
text, image = captcha.generate_captcha()
con_redis = get_redis_connection(alias='verify_codes')
img_key = 'img_{}'.format(image_code_id)
logger.info(img_key)
con_redis.setex(img_key, constants.IMAGE_CODE_REDIS_EXPIRES, text)
logger.info('Image Code: {}'.format(text))
return HttpResponse(content=image, content_type="images/jpg")
def get(self, request, image_code_id):
text, image = captcha.generate_captcha()
print(text)
conn_redis = get_redis_connection('verify_codes')
conn_redis.setex('img_{}'.format(image_code_id),
constants.IMAGE_CODE_REDIS_EXPIRES, text)
logger.info('Image code {}'.format(text))
return HttpResponse(content=image, content_type="image/jpg")
def get(self, request, image_code_id):
# 接入图片验证码接口
text, image_bytes = captcha.generate_captcha()
connect = get_redis_connection('verify_codes')
img_key = f'img_{image_code_id}'
logger.info(f'图片验证码：{text}')
connect.setex(img_key, constants.IMAGE_CODE_REDIS_EXPIRES, text)
return HttpResponse(content=image_bytes, content_type='image/jpg')
def get_image():
# name, text , StringIO.value
# text : 验证码图片对应到文本
# image_url : 验证码图片IO流 理解为：二进制数据，并没有实际转换成图片呢
name,text,image_url = captcha.generate_captcha()
session['img_code'] = text
response = make_response(image_url) #生成图片到响应
# 告诉浏览器，我要返回到是一张图片
response.headers['Content-Type'] = 'image/jpg'
return response
def get(self, request, image_code_id):
#见captcha.py的最后一行，即输出的元组
text, image = captcha.generate_captcha() #获取元组
# 连接设置中的redis的库名，这种短暂存储一般用redis
con_redis = get_redis_connection(alias='verify_codes')
#键值对方式
img_key = 'img_{}'.format(image_code_id)
#第一个参数是键，第二个参数是图形验证码有效时长，单位是秒，第三个参数是值
con_redis.setex(img_key, 300, text)
return HttpResponse(content=image, content_type='image/jpg')
def image_code():
#生成图片验证码
name, text, image = captcha.generate_captcha()
response = make_response(image)
#文件标准，告诉前端是啥类型的
response.mimetype = 'image/png'
# 验证码的文本
print(text)
session['image_code'] = text
return response
def get(self, request, image_code_id): # 调用View的方法
# 使用第三方的captcha工具来生成验证码图片
text, image = captcha.generate_captcha() # 生成文本和图片
# 连接redis数据库
redis_conn = get_redis_connection('verify_codes')
# 保存真实值到redis；三个参数为key，有效期，value
redis_conn.setex('img{}'.format(image_code_id),
constants.IMAGE_CODE_REDIS_EXPIRES, text)
return HttpResponse(image, content_type='image/jpg')
def get(self, request, image_id):
# 调用验证码生成库得到验证码图片和验证码
text, image = captcha.generate_captcha()
# 连接数据库
con_redis = get_redis_connection('verify_codes')
# 保存到数据库
con_redis.setex('img_{}'.format(image_id), 300, text)
# 日志器
logger.info('log图片验证码：{}'.format(text))
return HttpResponse(content=image, content_type='image/jpg')
def get(self, request, image_code_id):
# 3.生成验证码和验证码图片
text, image = captcha.generate_captcha()
# 4.建立redis连接，并且将图片验证码保存到redis
# 确保settings.py文件中配置redis CACHE
con_redis = get_redis_connection(alias='verify_codes')
img_key = "img_{}".format(image_code_id)
con_redis.setex(img_key, constants.IMAGE_CODE_REDIS_EXPIRES, text)
logger.info("Image code:{}".format(text))
# 5.把验证码图片返回给前端,输出图片文件
return HttpResponse(content=image, content_type='images/jpg')
def get(self, request, uuid):
try:
text, image = captcha.generate_captcha()
except Exception as e:
logger.error("验证码生成错误")
else:
request.session.set_expiry(60 * 60 * 2)
request.session["captcha_%s" % uuid] = text
return HttpResponse(image, content_type='images/jpg')
def get(self,request,image_code_id):
text, image = captcha.generate_captcha()
# 确保settings.py文件中有配置redis CACHE
# Redis原生指令参考 http://redisdoc.com/index.html
# Redis python客户端 方法参考 http://redis-py.readthedocs.io/en/latest/#indices-and-tables
con_redis = get_redis_connection(alias='verify_codes')
img_key = "img_{}".format(image_code_id).encode('utf-8')
# 将图片验证码的key和验证码文本保存到redis中，并设置过期时间
con_redis.setex(img_key, constants.IMAGE_CODE_REDIS_EXPIRES, text)
logger.info("Image code: {}".format(text))
return HttpResponse(content=image, content_type="images/jpg")
def get(self):
pre_code_id = self.get_argument("p")
cur_code_id = self.get_argument("c")
try:
name, text, image = captcha.generate_captcha()
except Exception as e:
logging.error(e)
if pre_code_id:
self.application.redis.delete("ImageCode" + pre_code_id)
self.application.redis.setex("ImageCode" + cur_code_id, constants.IMAGE_CODE_VALIDITY, text)
self.set_header("Content-Type", "image/jpg")
self.write(image)
def image_code():
# 生成图片验证码
name, text, image = captcha.generate_captcha()
# 构造响应对象
response = make_response(image)
# 设置返回数据的类型image/png
response.mimetype = 'image/png'
# 验证码的文本
print(text)
# 保存验证码文本
session['image_code'] = text
return response
def image_yzm():
from utils.captcha.captcha import captcha
# name表示一个随机名称, yzm表示验证码字符串, buffer是图片的二进制数据
name, yzm, buffer = captcha.generate_captcha()
# 把验证码存入session,用于后续请求的时候对比
session['image_yzm'] = yzm
# 将图片数据返回，浏览器会默认按text/html解析，需要设置为image/png
response = make_response(buffer)
response.mimetype = 'image/png'
return response
def get(self):
pre_code_id = self.get_argument("p")
cur_code_id = self.get_argument("c")
try:
name, text, image = captcha.generate_captcha()
except Exception as e:
logging.error(e)
if pre_code_id:
self.application.redis.delete("ImageCode" + pre_code_id)
self.application.redis.setex("ImageCode" + cur_code_id,
constants.IMAGE_CODE_VALIDITY, text)
self.set_header("Content-Type", "image/jpg")
self.write(image)
def get(self, request, image_code_id):
# 生成验证码以及图片
text, image = captcha.generate_captcha()
# 与redis数据库建立连接
redis_conn = get_redis_connection(alias='verify_codes')
# 生成图片验证码的键
img_key = 'img_{}'.format(image_code_id)
# 存入redi数据库，并设置过期时间
redis_conn.setex(img_key, IMAGE_CODE_EXPIRE_TIME, text)
# 输出日志，打印验证码信息，便于调试
logger.info('image_code: {}'.format(text))
# 返回给前端图片验证码，并指定图片格式
return HttpResponse(content=image, content_type='image/jpg')
def get(self):
"""获取图片验证码id"""
pre_code_id = self.get_argument("pre","")
cur_code_id = self.get_argument("cur")
#生成图片验证码
name, text, pic = captcha.generate_captcha()
try:
if pre_code_id:
self.redis.delete("pic_code_%s"% pre_code_id)
self.redis.setex("pic_code_%s" % cur_code_id, PIC_CODE_EXPIRES_SECONDS,text)
except Exception as e:
logging.error(e)
self.write("")
else:
self.set_header("Content-Type", "image/jpg")
return self.write(pic)
