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="发送成功")
