def get_image_code():
image_code_id = request.args.get("imageCodeId")
if not image_code_id:
abort(404)
_, text, image = captcha.generate_captcha()
current_app.logger.info("图片验证码为" + text) # TEST
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():
code_id = request.args.get('code_id')
name,text,image = captcha.generate_captcha()
try:
redis_store.setex('img_'+ code_id,constants.IMAGE_CODE_REDIS_EXPIRES,text)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno = RET.DATAERR,errmsg='redis保存失败')
current_app.logger.info(text)
response= make_response(image)
response.headers['Content-Type']='image/jpeg'
return response
def iamge_code():
"""图片验证码后端实现"""
# 1.取值（取出前端发过来的图片验证码随机编号
code_id = request.args.get('code_id', None)
# 2.判断，校验是否为空
if not code_id:
abort(404)
# 3.生成图片验证码
name, text, image = captcha.generate_captcha()
# 4.将验证编号作为键，验证码内容作为值保存在redis中
try:
redis_store.setex('imageCodeId_' + code_id,
constants.SMS_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
return make_response(jsonify(errno=RET.DATAERR, errmsg='数据错误'))
# 5.返回图片验证码
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def get_sms_code():
dict_data = request.json
mobile = dict_data.get("mobile")
image_code = dict_data.get("image_code")
image_code_id = dict_data.get("image_code_id")
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
if not re.match(r"1[35678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
try:
real_image_code = redis_store.get("ImageCodeID_" + 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.NODATA, errmsg="图片验证码已经过期")
if image_code.upper() != real_image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg="图片验证码输入错误")
sms_code_str = "%06d" % random.randint(0, 999999)
current_app.logger.info("短信验证码为" + sms_code_str) # TEST
# Call yuntongxun to send sms verification code
# result = CCP().send_template_sms('mobile', [sms_code_str, 5], 1)
# if result != 0:
# return jsonify(errno=RET.THIRDERR, errmsg="短信验证码发送失败")
try:
redis_store.setex("SMS_" + mobile, constants.SMS_CODE_REDIS_EXPIRES,
sms_code_str)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="短信验证码保存失败")
return jsonify(errno=RET.OK, errmsg="成功发送短信验证码")
def get_image_code():
# 1.接受参数
image_code_id = request.args.get("imageCodeId_")
# 2.校验参数是否存在
if not image_code_id:
print("*" * 89)
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():
"""
获取图片验证码
:return:
"""
# 1. 获取到当前的图片编号id
code_id = request.args.get('code_id')
# 2. 生成验证码
name, text, image = captcha.generate_captcha()
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='保存图片验证码失败'))
# 返回响应内容
resp = make_response(image)
# 设置内容类型
resp.headers['Content-Type'] = 'image/jpg'
return resp
def get_image_code():
image_code_id = request.args.get('image_code_id')
if not image_code_id:
return jsonify(errno=RET.NODATA, errmsg='uuid生成错误')
else:
name, text, image = captcha.generate_captcha()
if not all([name, text, image]):
return make_response(jsonify(errno=RET.PARAMERR, errmsg=''))
# 在redis存储生成的验证码text与uuid
try:
redis_store.setex('ImageCode_'+image_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='验证码图片保存失败'))
# 发送验证码图片至前端
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def passport():
# 1.接收参数
image_code = request.args.get("imageCodeId")
# 2.判断参数是否存在
if not image_code:
abort(404)
name, text, image = captcha.generate_captcha()
current_app.logger.info("图片验证码%" + text)
# 3.添加到后台redis
try:
redis_store.setex("ImageCode_" + image_code,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
current_app.logger.error(e)
return abort(500)
# 4.返回验证码
# 设置验证码请求格式
response = make_response(image)
response.headers["Content-Type"] = "image/jpg"
return response
def generate_image_code():
'''
生成图片验证码：
参数名：cur，验证码编号，str
1. 利用args在前端地址？后获取uuid，
前端地址:
var url = "/api/v1.0/imagecode?cur=" + imageCodeId + "&pre=" + preImageCodeId
2. 判断uuid是否存在，不存在return
3. 利用captcha工具，生成图片验证码 （name，text，image）
4. 把图片验证码内容text存入redis
5. 把图片image通过makeresponse传给浏览器
:return:
''' ''
cur = request.args.get('cur')
pre = request.args.get('pre', None)
if not cur:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# a = cur.split('&')
# cur = a[0]
# 使用captcha工具生成图片验证码
name, text, image = captcha.generate_captcha()
# 把text存入redis数据库中
try:
redis_store.setex('ImageCode_' + cur,
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():
"""获取验证码图片的接口 (GET)"""
"""
1.获取参数
1.1 获取code_id全球唯一的uuid编号
2.参数校验
2.1 判断code_id是否有值
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 判断code_id是否有值
if not code_id:
# code_id不存在
abort(404)
#3.1 生成验证码图片&生成验证码图片上面的真实值
image_name, real_image_code, image_data = captcha.generate_captcha()
try:
# 3.2 以code_id作为key将验证码图片上面的真实值存储到redis中
redis_store.setex("imageCodeId_%s" % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, real_image_code)
except Exception as e:
current_app.logger.error(e)
# 如果保存数据到redis异常，就报错
abort(500)
#4.1 返回图片给前端展示
#构建响应对象
response = make_response(image_data)
#设置响应数据的类型 , Content-Type:返回值类型
#作用：能够兼容所有浏览器的数据格式
response.headers["Content-Type"] = 'image/JPEG'
return response
def get_image_code():
'''
生成图片验证码
:return:
'''
# 1. 获取参数
image_Code = request.args.get('image_Code')
# 2. 校验参数
if not image_Code:
return
# 3. 生成图片验证码
cid, text, img = captcha.generate_captcha()
tag = imghdr.what(None, img)
# 4. 保存图片验证码
try:
redis_store.setex('image_' + image_Code,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
return
# 5.返回图片验证码
return make_response(send_file(BytesIO(img), mimetype="image/" + tag))
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 返回验证码图片
"""
#1.1 获取code_id，全球唯一的编码（uuid）
code_id = request.args.get('code_id', '')
#2.1 非空判断，判断code_id是否有值
if not code_id:
current_app.logger.error("参数不足")
# 参数不存在404错误
abort(404)
#3.1 生成验证码图片 & 生成验证码图片的真实值（文字）
image_name, real_image_code, image_data = captcha.generate_captcha()
#3.2 以code_id作为key 将生成验证码图片的真实值（文字）存储到redis数据库
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)
# 设置响应数据的内容类型 Content-Type："image/JPEG"
response.headers["Content-Type"] = "image/JPEG"
return response
def image_code():
# 获取查询字符串code_id，虽然在生成图片验证码的时候不需要用到，但是在存到redis中需要识别出是哪个
code_id = request.args.get('code_id') # 这个值一定要传，不然因为为None导致存储失败
# 利用验证码工具，生成图片验证码，验证码，名字
name, text, image = captcha.generate_captcha()
print(text)
try:
# 将验证码信息存入redis中,setex的参数分别是，key，有效期，value
redis_store.setex('ImageCode_' + code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
# current_app输出log
current_app.logger.error(e)
# 返回一个图片响应
# 这个函数一般用于返回有响应体头的响应
return make_response(jsonify(errno=RET.DATAERR, errmsg='保存图片验证码失败'))
# 返回图片验证码响应
resp = make_response(image)
# 添加请求头
resp.headers["Content-Type"] = 'image/jpg' # 将http的Content-Type的值设为图片
return resp
def get_image_code():
"""
生成图片验证码
1、接收uuid
2、校验uuid是否存在
3、生成验证码
4、文本验证码保存到redis数据库中
5、返回图片验证码
:return:
"""
# 1.获取uuid,从main.js中，在点击函数中
image_code = request.args.get("imageCodeId")
# 2.校验uuid是否存在
if not image_code:
return abort("404")
# 3.获取验证码，调用的captcha工具生成的验证码图片
# 返回三个数据，第一个没用，第二个验证码文本，第三个对应的图片
_, test, image = captcha.generate_captcha()
print(test)
# 4.文本验证码test保存在redis中，其中uuid为key,test为值，
# 其中三个参数，第一个key,可以拼接下好区分，第二个存活时间，在constants.py文件中导入
# 第三个是刚刚通过图片验证码的工具包生成的图片，为二进制格式保存的图片
# 一般在保存到数据库中时候使用try ，出现错误时候可以保存到日志
try:
redis_store.setex("ImageCode_"+ image_code, constants.IMAGE_CODE_REDIS_EXPIRES, test)
except Exception as e:
current_app.logger.error(e)
return abort("500")
# 修改返回的图片格式，如果不修改，默认test/html,避免浏览器不能识别,
# 使用response对象，调用make_response函数，函数中传入需要返回的对象
# 这样可以设置响应报文中的一些属性，最后将response返回，既返回本来需要返回的
# 也将响应报文内容做出更改,返回"image/png"格式
response = make_response(image)
response.headers["Content-Type"] = "image/png"
return response
def get_sms_code():
# 1.接受的参数摸moble image_code, image_code_id
dict_data = request.json
mobile = dict_data.get("mobile")
image_code = dict_data.get("image_code")
image_code_id = dict_data.get("image_code_id")
# 全局做个校验
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 2.校验参数 moble 正则
if not re.match(r"1[35678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
# 3.校验用户输入的验证码 和通过image_code_id查出来的验证码是否一致
try:
real_image_code = redis_store.get("ImageCodeId_" + 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.NODATA, errmsg="图片验证码过期")
if image_code.upper() != real_image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg="图片验证码输入错误")
# 4.先去定义一个随机的验证码
sms_code_str = "%06d" % random.randint(0, 999999)
current_app.logger.info("短信验证码为%s" % sms_code_str)
# 5.调用云通讯发送验证码
# result = CCP().send_template_sms(mobile,[sms_code_str,5],1)
# if result != 0:
# return jsonify(errno=RET.THIRDERR, errmsg="短信验证码发送失败")
# 6.将验证码保存到redis
try:
redis_store.setex("SMS_" + mobile, constants.IMAGE_CODE_REDIS_EXPIRES,
sms_code_str)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="手机验证码保存失败")
# 7.返回给前段一个响应
return jsonify(errno=RET.OK, errmsg="发送短信验证码OK")
def smscode():
'''生成短信验证码，并发送短信'''
# 1.接收
mobile = request.json.get('mobile')
image_request = request.json.get('image_code')
code_id = request.json.get('image_code_id')
# 2.验证
# 2.1非空
if not all([mobile, image_request, code_id]):
return jsonify(errno=RET.NODATA, errmsg='数据不完整')
# 2.2获取图形验证码
image_redis = redis_store.get(code_id)
if image_redis is None:
return jsonify(errno=RET.NODATA, errmsg='图形验证码过期')
# 2.3两个验证码是否一致
# 注意：所有从redis中读取出来的数据，都是bytes类型
if image_request != image_redis.decode():
return jsonify(errno=RET.DATAERR, errmsg='图形验证码错误')
# 2.4验证手机号格式
if not re.match(r'^1[3-9]\d{9}$', mobile):
return jsonify(errno=RET.DATAERR, errmsg='手机号错误')
# 2.5手机号是否已经被注册
mobile_count = User.query.filter_by(mobile=mobile).count()
if mobile_count > 0:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已经被注册')
# 3.处理
# 3.1随机生成6位值
code = str(random.randint(100000, 999999))
# 3.2保存到redis
redis_store.setex(mobile, constants.SMS_CODE_REDIS_EXPIRES, code)
# 3.3发送短信
send_sms(mobile, [code, '5'], 1)
print(code)
# 4.响应
return jsonify(errno=RET.OK, errmsg='')
def gentate_image_code():
"""
生成图片验证码：写接口步骤：获取参数，校验参数，业务处理，返回结果
1.获取参数，uuid。使用查询字符串形式，requst.args
2.校验参数uuid是否存在，不存在，直接return
3.调用第三方接口captcha生成图片验证码：name,text,img
4.在服务器redis数据库存储图片验证码
5.返回图片本身，使用响应对象
response = make_response(img)
:return = response
6.修改返回数据格式
:return:
"""
# 1.获取前端生成并传入的uuid，作为图片验证码名称的后缀名保存到redis中
image_code_id = request.args.get('image_code-id')
# 2.判断获取结果，不存在的化，返回json数据，使用jsonify和自定义的状态码，
# 实现前后端的数据交互
if not image_code_id:
return jsonify(errno=RET.PARAMERR,errmsg='参数确实')
# 3.使用captcha工具生成图片验证码
name,text,img = captcha.generate_captcha()
print(text)
# 4.将图片验证码存储在redis中，必须现在实例化redis对象13.5
# 在对数据库操作是，都需要异常处理，try，在数据库中保存，并设置有效时间
try:
redis_store.setex('ImageCode_'+ image_code_id,constants.IMAGE_CODE_REDIS_EXPIRES,text)
except Exception as e: # 如果保存发生异常，执行
current_app.logger.error(e) # 使用current_app 保存日志中的错误信息
return jsonify(error=RET.DBERR,errmsg='保存图片验证码，失败')
else: # 这是不发生异常需要执行的
# 返回图片给前端
response = make_response(img)
# 修改响应数据类型
response.headers['Content-Type']= 'image/jpg'
return response
def generate_image_code():
"""
生成图片验证码
1、获取参数，前端生成图片验证码的后缀名，uuid
request.args.get()
2、校验参数是否存在；
3、调用扩展包，生成图片验证码，name,text,image
4、在redis数据库中保存图片验证码的内容；
5、使用响应对象,来返回图片，修改默认响应的数据类型
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
6、返回结果
return response
:return:
"""
# 获取参数
image_code_id = request.args.get('image_code_id')
# 判断参数不存在
if not image_code_id:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 调用扩展来生成图片验证码
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:
# 记录操作redis数据库的异常信息
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():
"""获取验证码图片的后端接口 （GET）"""
"""
1、获取参数
1.1 获取code_id,全球唯一的编码（uuid）
2、校验参数
2.1非空判断，判断code_id是否有值
3、逻辑处理
3.1生成验证码图片&生成验证码图片的真实值（文字）
3.2以code_id作为key将生成验证码图片的真实值（文字）
4、返回值
4.1返回验证码图片
"""
# 1.1 获取code_id,全球唯一的编码（uuid）
code_id = request.args.get('code_id', '')
# 2.1非空判断，判断code_id是否有值
if not code_id:
current_app.logger.error('参数不足')
# 参数不存在404错误
abort(404)
# 3.1生成验证码图片&生成验证码图片的真实值（文字）
image_name, real_image_code, image_data = captcha.generate_captcha()
# 3.2以code_id作为key将生成验证码图片的真实值（文字）
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)
# 设置响应数据的内容类型 Content-Type:'image/JPEG‘
response.headers['Content-Type'] = 'image/JPEG'
return response
def get_image_code():
"""生成验证码图片的后端接口"""
"""
1.获取参数
1.1 code_id: UUID唯一编码
2.参数校验
2.1 code_id非空判断
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 code_id非空判断
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中，并且设置有效时长，方便下一个接口提取正确的值
# Iamge_Code_UUID编号： 1234
# 参数1：存储的key 参数2：有效时长， 参数3：存储的真实值
redis_store.setex("Iamge_Code_%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_image_code():
"""获取图片验证码"""
# 1.获取当前的图片编号id
code_id = request.args.get("code_id", None)
# 2.判断是否有值
if not code_id:
return abort(403)
# 2.生成验证码
name, text, image = captcha.generate_captcha()
try:
# 保存当前生成的图片验证码内容
# redis_store.setex("ImageCode_" + code_id, constants.IMAGE_CODE_REDIS_EXPIRES, text)
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="保存图片验证码失败"))
# 返回相应内容
resp = make_response(image)
# 设置内容类型
resp.headers["Content-Type"] = "image/jpg"
return resp
def send_image():
"""
1，取出其参数，
2，判断是否有值
3，生成图片
4，把生成的唯一的值作为键，生成图片的内容作为键存入redis 中，
5，把图片作为响应传给前端
:return:
"""
imageCode=request.args.get('imagecode')
print(imageCode)
if not imageCode:
abort(404)
# 生成图片
name,text,image=captcha.generate_captcha()
try:
redis_store.setex('imageCodeId_'+imageCode,constants.IMAGE_CODE_REDIS_EXPIRES,text)
except Exception as e:
return jsonify(errno=RET.PARAMERR,errmes='参数错误')
# 把值传给前端界面
response=make_response(image)
response.headers['ContentType']='image/jpg'
return response
def get_image_code():
# 1.获取到当前的图片编号id
image_code_id = request.args.get('imageCodeId')
# 2.效验参数是否存在
if not image_code_id:
abort(404)
# 3.生成验证码 captche
_, text, image = captcha.generate_captcha()
print(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():
"""
1、接受参数
２、校对参数是否存在
３、生成验证码
４、把随机的字符串和生成的文本文档以key,value形式存入redis
5、返回图片
"""
image_code_id = request.args.get("imageCodeId")
if not image_code_id:
abort(404)
_, text, image = captcha.generate_captcha()
try:
redis_store.setex("ImageCodeId_" + image_code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, text)
print(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():
"""获取验证码图片"""
"""
1.获取参数
1.1 获取code_id：唯一编码UUID
2.校验参数
2.1 判断code_id是否有值
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 判断code_id是否有值
if not code_id:
current_app.logger.error("参数不足")
abort(403)
# 3.1 生成验证码图片 & 生成验证码图片上的真实值
image_name, image_code, image_data = captcha.generate_captcha()
try:
# 3.2 根据code_id编号作为key将生成验证码图片上的真实值存储到redis数据，并且设置有效时长（后续接口需要校验）
redis_store.setex("ImageCode_%s" % code_id,
constants.IMAGE_CODE_REDIS_EXPIRES, image_code)
except Exception as e:
# 记录日志
current_app.logger.error(e)
abort(500)
# 4.1 生成验证码图片,返回给前端(如果返回的是二进制数据不能兼容所有前端浏览器)
response = make_response(image_data)
# 返回数据的类型"image/JPEG"
response.headers["Content-Type"] = "image/JPEG"
return response
def send_sms_code():
mobile=request.json.get('mobile')
image_code=request.json.get('image_code')
image_code_id=request.json.get('image_code_id')
if not all([mobile,image_code,image_code_id]):
return jsonify(errno=RET.PARAMERR,errmsg='参数错误')
if not re.match(r'1[3456789]\d{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.NODATA,errmsg='数据已过期')
try:
redis_store.delete('ImageCode_'+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='图片验证码错误')
sms_code='%06d' % random.randint(0,999999)
try:
redis_store.setex('SMSCode_'+mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code)
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,constants.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='发送失败')
def generate_image_code():
"""
生成图片验证码
接受参数－－检查参数－－业务处理－－返回结果
参数：前端传入uuid
１．获取前端传入的uuid，查询字符串args
２．如果没有uuid返回相应的提示信息
３．调用captcha工具，生成图片验证码
captcha 返回name.text.image三个值
４．把图片验证码的内容text，根据uuid来存入redis数据库中
５．返回图片
:return:
"""
# 获取参数
image_code_id = request.args.get('image_code_id')
# 检查参数是否存在，导入response_code.py文件
if not image_code_id:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 存在则调用工具captcha生成图片验证码
name, text, image = captcha.generate_captcha()
# 把text存入redis数据库中再info/__init__文件中实例化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:
# 没有异常返回图片，但image是路径，需要通过make_response返回
response = make_response(image)
# 修改响应的类型
response.headers['Content-Type'] = 'image/jpg'
# 返回响应
return response
def send_sms_code():
"""发送短信验证后端接口"""
"""
1.获取参数
1.1 mobile:手机号码 , image_code:用户填写的图片验证码 , image_code_id:UUID编码
2.参数校验
2.1 非空判断
2.2 正则校验手机号码格式
3.逻辑处理
3.1 根据image_code_id编号去redis数据库获取真是的图片验证码值real_image_code
3.1.1 real_image_code没有值:图片验证码过期
3.1.2 real_image_code有值:将图片验证码从redis中删除(防止多次适用同一个验证码来进行多次验证码验证)
3.2 对比用户添加的图片验证码值和真实的图片验证码值
3.2.1 不相等:提示图片验证码填写错误
3.2.2 相等:发送短信验证码
TODO:判断用户填写的手机号码是否注册(提高用户体验)
3.3 发送短信验证码具体流程
3.3.1 生成6位的随机短信验证码值
3.3.2 调用ccp类中方法发送短信验证码
3.3.3 发送短信验证码失败:提示前端重新发送
3.3.4 将6位的短信验证码使用redis数据库保存起来,设置有效时长(方便注册接口获取真实的短信验证值)
4.返回值
4.1 发送短信验证码成功
"""
# 1.1 mobile: 手机号码, image_code: 用户填写的图片验证码, image_code_id: UUID编码（格式：json）
# 将前端发送的json数据转换成python对象
param_dict = request.json
mobile = param_dict.get("mobile")
image_code = param_dict.get("image_code")
image_code_id = param_dict.get("image_code_id")
# 2.1非空判断
if not all([mobile, image_code, image_code_id]):
err_dict = {"errno": RET.PARAMERR, "errmsg": "参数不足"}
"""
{
"errno":4103,
"errmsg":"参数不足"
}
"""
return jsonify(err_dict)
# 2.2正则校验手机号码格式
if not re.match("1[3456789][0-9]{9}", mobile):
current_app.logger.error("手机格式错误")
return jsonify(errno=RET.PARAMERR, errmsg="手机格式错误")
# 3.1根据image_code_id编号去redis数据库获取真是的图片验证码值real_image_code
try:
real_image_code = redis_store.get("CODEID_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取真实的图片验证码错误")
# 3.1.1 real_image_code没有值: 图片验证码过期
if not real_image_code:
current_app.logger.error("图片验证码过期了")
return jsonify(errno=RET.NODATA, errmsg="图片验证码过期了")
# 3.1.2 real_image_code有值: 将图片验证码从redis中删除(防止多次适用同一个验证码来进行多次验证码验证)
else:
try:
redis_store.delete("CODEID_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="删除真实的图片验证码异常")
"""
细节：1.忽略大小写 2.对比时数据格式要一致,将从redis中获取的真实图片验证码值转换成字符串
"""
if image_code.lower() != real_image_code.lower():
# 3.2.1不相等: 提示图片验证码填写错误
return jsonify(errno=RET.DATAERR, errmsg="图片验证码填写错误")
# 3.2.2相等: 发送短信验证码
# TODO: 判断用户填写的手机号码是否注册(提高用户体验)
try:
user = User.query.filter(User.mobile == mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询用户对象异常")
# 表示用户已经注册过
if user:
return jsonify(errno=RET.DATAEXIST, errmsg="用户已经注册过")
# 3.3.1生成6位的随机短信验证码值
import random
sms_code = random.randint(0, 999999)
# 不足6位在前面补0
sms_code = "%06d" % sms_code
# 3.3.2调用ccp类中方法发送短信验证码
# 参数1:手机号码 参数2：{6位短信验证码，5分钟过期时长} 参数3：模板编号
result = CCP().send_template_sms(
mobile, {sms_code, constants.SMS_CODE_REDIS_EXPIRES / 60}, 1)
if result == -1:
# 3.3.3发送短信验证码失败: 提示前端重新发送
return jsonify(errno=RET.THIRDERR, errmsg="云通讯发送短信验证码失败")
elif result == 0:
# 3.3.4将6位的短信验证码使用redis数据库保存起来, 设置有效时长(方便注册接口获取真实的短信验证值)
# 手机号码 短信内容 过期时长
redis_store.setex("SMS_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES,
sms_code)
# 4.1发送短信验证码成功
return jsonify(errno=RET.OK, errmsg="发送短信验证码成功")
def get_sms_code():
"""
1、接收参数 mobile， image_code， image_code_id
2、校验参数：mobile 正则
3、校验用户输入的验证码和通过image_code_id查询出来的验证码是否一致
4、先去定义一个随机的6验证码
5、调用云通讯发送手机验证码
6、将验证码保存到reids
7、给前端一个响应
:return:
"""
# 因为json类型实际是一个字符串类型无法用到.get("mobile")
# 需要将json类型转化为字典对象
# json_data = request.data
# dict_data = json.loads(json_data)
# 如何去接受一个前端传入的json类型的数据
dict_data = request.json
# 1、接收参数 mobile， image_code， image_code_id
mobile = dict_data.get("mobile")
image_code = dict_data.get("image_code")
image_code_id = dict_data.get("image_code_id")
# 2、全局的做一个检验
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 3、mobile 正则
if not re.match(r"1[35678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号的格式不正确")
# 4、取出真实的验证码
try:
real_image_code = redis_store.get("ImageCodeId_" + 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.NODATA, errmsg="图片验证码已经过期")
if image_code.upper() != real_image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg="图片验证码输入错误")
# 核心逻辑 5、先去定义一个随机的6验证码,
# "%06d" 将一个数字转化为6位数字，如果位数不够，用0填充 1234 001234
sms_code_str = "%06d" % random.randint(0, 999999)
current_app.logger.info("短信验证码为%s" % sms_code_str)
# result = CCP().send_template_sms(mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 60], 1)
#
# if result != 0:
# return jsonify(errno=RET.THIRDERR, errmsg="短信验证码发送失败")
# 6、将验证码保存到reids
try:
redis_store.setex("SMS_" + mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code_str)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="手机验证码保存失败")
# 7、给前端一个响应
return jsonify(errno=RET.OK, errmsg="成功发送短信验证码")
def send_sms_code():
"""
发送短信：写接口、调接口
获取参数-----检查参数-----业务处理-----返回结果
1、获取参数mobile，image_code,image_code_id
2、检查参数的完整性
3、检查手机号的格式，正则
4、尝试从redis数据库中获取真实的图片验证码
5、判断获取结果是否存在，图片验证码有可能过期
6、删除图片验证码
7、比较图片验证码是否一致
8、构造短信随机码，6位数
9、调用云通讯发送短信方法
10、判断发送结果是否成功
11、返回结果
:return:
"""
# 获取参数
mobile = request.json.get("mobile")
image_code = request.json.get("image_code")
image_code_id = request.json.get("image_code_id")
# 检查参数的完整性
# if mobile and image_code and image_code_id:
if not all([mobile,image_code,image_code_id]):
return jsonify(errno=RET.PARAMERR,errmsg='参数不完整')
# 检查手机号的格式
if not re.match(r'1[3456789]\d{9}$',mobile):
return jsonify(errno=RET.PARAMERR,errmsg='手机号格式错误')
# 获取redis数据库中存储的真实图片验证码
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.NODATA,errmsmg='数据已过期')
# 删除redis数据库中存储的图片验证码，因为图片验证码只能比较一次，本质是只能读取redis数据库一次
try:
redis_store.delete('ImageCode_' + 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:
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='用户已存在')
# 构造短信随机数,保存到redis数据库中
sms_code = '%06d' % random.randint(0, 999999)
print(sms_code)
try:
redis_store.setex('SMSCode_' + mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg='存储数据异常')
# 调用云通讯接口，发送短信
try:
ccp = sms.CCP()
results = ccp.send_template_sms(mobile,[sms_code,constants.SMS_CODE_REDIS_EXPIRES/60],1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR,errmsg='发送短信异常')
# 判断发送结果
if results == 0:
return jsonify(errno=RET.OK,errmsg='发送成功')
else:
return jsonify(errno=RET.THIRDERR,errmsg='发送失败')
