Esempio n. 1
0
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
Esempio n. 2
0
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
Esempio n. 3
0
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
Esempio n. 4
0
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
Esempio n. 5
0
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
Esempio n. 6
0
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
Esempio n. 7
0
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
Esempio n. 8
0
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
Esempio n. 9
0
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
Esempio n. 10
0
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
Esempio n. 11
0
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
Esempio n. 12
0
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
Esempio n. 13
0
def get_image_code():
    """
    1.获取查询参数
    2.判断查询参数是否为空
    3.不为空,则生成验证码并保存在redis中
    4.生成验证码图片,返回给浏览器
    :return:
    """
    # 1.接收查询参数imageCodeId
    image_code_id=request.args.get('imageCodeId',None)
    # 2.判断查询参数是否为空
    if not image_code_id:
        abort(403)

    # 3.不为空,则生成验证码并保存在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
Esempio n. 14
0
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
Esempio n. 15
0
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
Esempio n. 16
0
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
Esempio n. 17
0
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
Esempio n. 18
0
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
Esempio n. 19
0
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
Esempio n. 20
0
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
Esempio n. 21
0
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
Esempio n. 22
0
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
Esempio n. 23
0
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
Esempio n. 24
0
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
Esempio n. 25
0
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
Esempio n. 26
0
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
Esempio n. 27
0
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
Esempio n. 28
0
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
Esempio n. 29
0
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
Esempio n. 30
0
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