def register():
req_dict = request.json
mobile = req_dict.get('mobile')
phonecode = req_dict.get('phonecode')
password = req_dict.get('password')
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
try:
sms_code = redis_store.get('sms_code:%s' % mobile)
except Exception as e:
current_app.logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
if sms_code != phonecode:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
try:
user = User.query.filter(User.mobile == mobile).first()
except Exception as e:
current_app.logger.error(e)
if user:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已被注册')
user = User()
user.mobile = mobile
user.name = mobile
# todo:注册用户密码加密
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.loggging.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存用户信息失败')
session['user_id'] = user.id
session['username'] = user.name
session['mobile'] = user.mobile
return jsonify(errno=RET.OK, errmsg='注册成功')
def get_area():
"""提供城区信息
1.直接查询所有城区信息
2.构造城区信息响应数据
3.响应城区信息
"""
# 在查询数据库之前,读取缓存的城区信息
# eval: 会根据字符串的数据的结构,自动生成对应的对象
try:
area_dict_list = redis_store.get('Areas')
if area_dict_list:
return jsonify(errno=RET.OK, errmsg='OK', data=eval(area_dict_list))
except Exception as e:
logging.error(e)
current_app.logger.error(e)
# 1.直接查询所有城区信息
try:
areas = Area.query.all()
except Exception as e:
logging.error(e)
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询城区信息失败')
# 2.构造城区信息响应数据
area_dict_list = []
for area in areas:
area_dict_list.append(area.to_dict())
# 缓存城区数据,set:存储字符串,hset:存储hash,lpush:列表
# 非常重要的注意点:缓存时,如果出现了异常,不需要return,因为如果return了,会影响主线逻辑的正常执行
# 缓存时附带逻辑,可有可无
try:
redis_store.set('Areas', area_dict_list, constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
logging.error(e)
current_app.logger.error(e)
# 3.响应城区信息
return jsonify(errno=RET.OK, errmsg='OK', data=area_dict_list)
def get_areas():
try:
areas_dict = redis_store.get('areas_dict')
except Exception as e:
current_app.logger.error(e)
if areas_dict:
return jsonify(errno=RET.OK, errmsg='ok', data=eval(areas_dict))
try:
areas = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据查询错误')
areas_dict = []
for area in areas:
areas_dict.append(area.to_dict())
try:
redis_store.set('areas', areas_dict, constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg='OK', data=areas_dict)
def get_area_info():
"""获取城区信息"""
# 尝试从redis中读取数据
try:
resp_json = redis_store.get("area_info")
except Exception as ex:
current_app.logger.error(ex)
else:
if resp_json is not None:
# redis存在缓存数据
current_app.logger.info("hit redis area_info")
return resp_json, 200, {"Content-Type": "application/json"}
# 查询数据库，读取城区信息
try:
area_list = Area.query.all()
except Exception as ex:
current_app.logger.error(ex)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
area_dict_li = []
# 将对象转换为字典
for area in area_list:
area_dict_li.append(area.to_dict())
# 将数据转换为json字符串
resp_dict = dict(errno=RET.OK, errmsg="OK", data=area_dict_li)
resp_json = json.dumps(resp_dict)
# 将数据保存到redis中
try:
redis_store.setex("area_info", constains.AREA_INFO_REDIS_CACHE_EXPIRE,
resp_json)
except Exception as ex:
current_app.logger.error(ex)
return resp_json, 200, {"Content-Type": "application/json"}
def get_house_detail(house_id):
user_id = session.get('user_id', -1)
# if not user_id:
# user_id = -1
if not house_id:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
house_info = redis_store.get('house_%d' % house_id)
if house_info:
return jsonify(errno=RET.OK, errmsg='OK', data={'house_info': house_info, 'user_id': user_id})
except Exception as e:
current_app.logger.error(e)
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据查询错误')
house_info = house.to_full_dict()
return jsonify(errno=RET.OK, errmsg='OK', data={'house_info': house_info, 'user_id': user_id})
def get_areas():
"""提供城区信息 将城区信息提供给主页的中的 需要一个列表：向视图
1.直接查询所有城区信息
2.构造城区信息响应数据
3.响应城区信息
"""
# 在查询数据库之前读取缓存的城区信息
# 现在的代码形式：
try:
area_dict_list = redis_store.get('Areas') #查
if area_dict_list:
return jsonify(errno=RET.OK,
errmsg='OK',
data=eval(area_dict_list))
except Exception as e:
current_app.logger.error(e)
# 原来的代码形式：
try:
areas = Area.query.all() #获取所有城区信息 areas里面存的是Area的模型对象
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询地区数据失败')
# 2、构造城区信息响应数据，将aresa转成字典列表
area_dict_list = []
for area in areas:
area_dict_list.append(area.to_dict())
try: #键：Areas 值：area_dict_list 缓存时间：constants.AREA_INFO_REDIS_EXPIRES
redis_store.set("Areas", area_dict_list,
constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
# 响应城区信息：jsonify只认识字典或字典列表，所以把data中的内容都转换成了字典列表
return jsonify(errno=RET.OK, errmsg='OK', data=area_dict_list)
def get_areas():
"""提供城区信息
1.查询所有的城区信息
2.构造响应数据
3.响应结果
"""
# 查询缓存数据，如果有缓存数据，就使用缓存数据，反之，就查询，并缓存新查询的数据
try:
area_dict_list = redis_store.get('Areas')
if area_dict_list:
return jsonify(errno=RET.OK,
errmsg='OK',
data=eval(area_dict_list))
except Exception as e:
current_app.logger.error(e)
# 1.查询所有的城区信息 areas == [Area,Area,Area,...]
try:
areas = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询城区信息失败')
# 2.构造响应数据
area_dict_list = []
for area in areas:
area_dict_list.append(area.to_dict())
# 缓存城区信息到redis : 没有缓存成功也没有影响，因为前爱你会判断和查询
try:
redis_store.set('Areas', area_dict_list,
constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
# 3.响应结果
return jsonify(errno=RET.OK, errmsg='OK', data=area_dict_list)
def get_areas():
"""提供城区的信息
1.直接查询所有城区信息
2.构造城区信息响应数据
3.响应城区信息
"""
# 先从缓存中去取，如果缓存中没有，再去数据库中取
try:
area_dict_list = redis_store.get('Areas')
# 如果缓存的城区数据存在，就转成字典列表响应出去
if area_dict_list:
return jsonify(errno=RET.OK,
errmsg="OK",
data=eval(area_dict_list))
except Exception as e:
current_app.logger.error(e)
# 1.直接查询所有城区信息areas == [Area, Area, Area]
try:
areas = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询地区数据失败")
# 2.构造城区信息响应数据
area_dict_list = []
for area in areas:
area_dict_list.append(area.to_dict())
# 缓存城区数据，set：储存
try:
redis_store.set('Areas', area_dict_list,
constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
# 3.响应城区信息
return jsonify(errno=RET.OK, data=area_dict_list)
def get_index_houses():
try:
houses = redis_store.get('house_index')
if houses:
return jsonify(errno=RET.OK, errmsg='ok', data=eval(houses))
except Exception as e:
current_app.logger.error(e)
try:
houses = House.query.order_by(House.order_count.desc()).limit(constants.HOME_PAGE_MAX_HOUSES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据错误')
houses_dict = []
for house in houses:
houses_dict.append(house.to_basic_dict())
try:
redis_store.set('house_index', houses_dict, constants.HOME_PAGE_DATA_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg='ok', data=houses_dict)
def get_areas():
"""提供城区信息
1.直接查询所有城区信息
2.构造城区信息响应数据
3.响应城区信息
"""
# 1.直接查询所有城区信息
try:
area_dict_list = redis_store.get('Areas')
if area_dict_list:
return jsonify(error_no=RET.OK,
error_msg=u'成功',
data=eval(area_dict_list))
except Exception as e:
current_app.logger.error(e)
try:
areas = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(error_no=RET.DBERR, error_msg=u'查询地区数据失败')
# 2.构造城区信息响应数据
area_dict_list = []
for area in areas:
area_dict_list.append(area.to_dict())
# 3.响应城区信息
try:
redis_store.set('Areas', area_dict_list,
constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_no=RET.OK, error_msg=u'成功', data=area_dict_list)
def get_area_info():
"""获取城区信息"""
# 先从redis缓存中获取城区信息
try:
resp_json = redis_store.get("area_info")
except Exception as e:
current_app.logger.error(e)
else:
if resp_json is not None:
# redis中有缓存数据
current_app.logger.info("hit redis area_info")
return resp_json, 200, {"Content-Type": "application/json"}
# 查询数据库,读取城区信息
try:
area_li = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# 将area对象转换为字典,并保存在列表中
# area_dict_li = [ {"aid":area.id, "aname":area.name} for area in area_li]
area_dict_li = [area.to_dict() for area in area_li] # 使用模型中定义的对象转为字典的方法
# 将数据保存到redis中 - 缓存
# 将数据转换为json字符串
resp_dict = dict(errno=RET.OK, errmsg="OK", data=area_dict_li)
resp_json = json.dumps(resp_dict)
# 将json字符串保存到redis中
try:
redis_store.setex("area_info", constants.AREA_INFO_REDIS_CACHE_EXPIRE,
resp_json)
except Exception as e:
current_app.logger.error(e)
return resp_json, 200, {"Content-Type": "application/json"}
def get_areas():
"""
获取所有的城区信息
1. 查询所有的Areas数据
2. 返回
:return:
"""
# 先从缓存中取。如果取到直接返回，如果没有取到，那么再执行后面的逻辑
try:
areas_dict_li = redis_store.get("Areas")
if areas_dict_li:
return jsonify(errno=RET.OK, errmsg="ok", data=eval(areas_dict_li))
except Exception as e:
current_app.logger.error(e)
try:
areas = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
# 定义空列表，用于保存遍历的时候所转换的字典
areas_dict_li = []
# 转模型转字典
for area in areas:
areas_dict_li.append(area.to_dict())
# 缓存数据到Redis中
try:
redis_store.set("Areas", areas_dict_li,
constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
# 返回
return jsonify(errno=RET.OK, errmsg="ok", data=areas_dict_li)
def get_areas():
try:
area_json_str = redis_store.get('areas')
if area_json_str:
areas_dict_li = json.loads(area_json_str)
return jsonify(errno=RET.OK, errmsg='ok', data=areas_dict_li)
except Exception as e:
current_app.logger.error(e)
try:
areas = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询城区信息失败')
areas_dict_li = []
for area in areas:
areas_dict_li.append(area.to_dict())
try:
redis_store.set('areas', json.dumps(areas_dict_li),
constants.AREA_INFO_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg='ok', data=areas_dict_li)
def register():
"""
注册
1.获取用户的手机号码 密码 短信验证码
2.判断参数是否缺少
3.获取服务器存储的验证码
4.服务器的验证码与客户端的验证码进行对比
5.如果对比成功，则创建用户模型User对象，并给属性赋值
6.将属性写入数据库
7.响应注册结果
"""
#获取用户的手机号码 密码 短信验证码
#有3种方法获取前端ajax发来的json字符串
#1. # json_str = request.data
# json_dict = json.loads(json_str)
#下面两种要确保发来的数据是json字符串
#2.json_dict = request.get_json()
#第3种
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
#2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1[3456789][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机格式错误')
#3.获取服务器存储的验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
current_app.logger.debug(sms_code_server)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
#4.服务器的验证码与客户端的验证码进行对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输出错误')
#判断手机后是否已经存在
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已经存在')
#5.如果对比成功，则创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile
#需要将密码加密后保存到数据库：调用password属性的setter方法
user.password = password
#6.将属性写入数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户信息失败')
session['user_id'] = user.id
session['user_name'] = user.name
#7.响应注册结果
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 send_sms_code():
"""发送短信验证码
1.获取参数:手机号，验证码，uuid
2.判断是否缺少参数，并对手机号格式进行校验
3.获取服务器存储的验证码
4.跟客户端传入的验证码进行对比
5.如果对比成功就生成短信验证码
6.调用单例类发送短信
7.如果发送短信成功，就保存短信验证码到redis数据库
8.响应发送短信的结果
"""
# 获取参数:手机号，验证码，uuid
josn_str = request.data
josn_dict = json.loads(josn_str)
print ">" * 50, josn_dict
mobile = josn_dict.get("mobile")
imageCode_client = josn_dict.get("imageCode")
uuid = josn_dict.get("uuid")
# 判断是否缺少参数，并对手机号格式进行校验
if not all([mobile, imageCode_client, uuid]):
return jsonify(errno=RET.PARAMERR, errmsg="缺少参数")
if not re.match(r"^1([358][0-9]|4[579]|66|7[0135678]|9[89])[0-9]{8}$",
mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误")
# 获取服务器存储的验证码
try:
imageCode_server = redis_store.get('ImageCode:%s' % uuid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询验证码错误")
# 判断取得的数据是否为空
if not imageCode_server:
return jsonify(errno=RET.DBERR, errmsg="查询验证码不存在")
# 跟客户端传入的验证码进行对比
if imageCode_client.lower() != imageCode_server.lower():
return jsonify(errno=RET.DBERR, errmsg="验证码输入有误")
# 如果对比成功就生成短信验证码
# "%06d"-不够六位补零
sms_code = "%06d" % random.randint(0, 999999)
# result = CCP().send_sms_code(mobile, [sms_code, 5], 1)
#
#
# if result != 1:
# return jsonify(errno=RET.THIRDERR, errmsg="发送短信验证码失败")
print "_" * 30, sms_code
try:
redis_store.set("SMS:%s" % mobile, sms_code,
constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='存储短信验证码失败')
# 8.响应发送短信的结果
return jsonify(errno=RET.OK, errmsg='发送短信验证码成功')
def register():
"""实现注册
1.获取请求参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器的短信验证码
4.并与客户端传入的验证码比较,如果一致
5.创建User模型类对象
6.保存注册数据到数据库
7.响应结果
"""
# 1.获取请求参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 3.获取服务器的短信验证码
try:
sms_code_server = redis_store.get('Mobile:' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
# 判断数据是否为空
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.并与客户端传入的验证码比较,如果一致
if sms_code_server != sms_code_client:
return jsonify(errno=RET.DATAERR, errmsg='输入验证码有误')
# 判断该用户是否已经注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='用户已注册')
# 5.创建User模型类对象
user = User()
# 注册时，默认手机号就是用户名，如果后面需要更换用户名，也是提供的有接口和界面
user.name = mobile
user.mobile = mobile
# 密码需要加密后才能存储
# user.password_hash = '加密后的密码'
user.password = password
# 6.保存注册数据到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存注册数据失败')
# 实现注册成功即登录：记住状态保持信息即可
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7.响应结果
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():
"""注册
1.获取注册参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器存储的短信验证码
4.与客户端传入的短信验证码对比
5.如果对比成功，就创建用户模型User对象，并给属性赋值
6.将模型属性写入到数据库
7.响应注册结果
"""
# 1.获取注册参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
# 当我们后端确定前端发来的是json字符串时
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 3.获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.与客户端传入的短信验证码对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 判断该手机号是否注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已注册')
# 5.如果对比成功，就创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile # 默认把手机号作为用户名，如果不喜欢，后面会提供修改用户名的接口
# 需要将密码加密后保存到数据库:调用password属性的setter方法
user.password = password
# 6.将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户注册数据失败')
# 7.响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def send_sms_code():
"""
#发送短信验证码
json
1. 获取参数（手机号，验证码， uuid）
2. 验证参数完整和校验
3. 从redis中获取图片验证码，（取不到，验证码过期）
4. 对比图片验证码
5. 生成短信验证码
6. 保存redis短信验证码，
7. 发送短信验证码
8. 返回信息，发送验证码成功
"""
# 1. 获取参数（手机号，验证码， uuid）
req_data = request.data
req_dict = json.loads(req_data)
mobile = req_dict.get('mobile')
image_code = req_dict.get('image_code')
image_code_id = req_dict.get('image_code_id')
# 2. 验证参数完整和校验
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='手机号格式不正确')
if User.query.filter_by(name=mobile).all():
return jsonify(errno=RET.PARAMERR, errmsg='用户已注册')
# 3. 从redis中获取图片验证码，（取不到，验证码过期）
try:
real_image_id = redis_store.get('imagecode:%s' % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询图片验证码错误')
if not real_image_id:
return jsonify(errno=RET.NODATA, errmsg='图片验证码已过期')
# 4. 对比图片验证码
if lower(real_image_id) != lower(image_code):
return jsonify(errno=RET.DATAERR, errmsg='图片验证码错误')
# 5. 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
current_app.logger.info('短信验证码：' + sms_code)
# 6. 保存redis短信验证码，
try:
redis_store.set('sms_code:%s' % mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存验证码失败')
# 7. 发送短信验证码
# res = CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES/60],1)
# if res != 1:
# return jsonify(errno=RET.THIRDERR, errsmg='发送短信失败')
# 8. 返回信息，发送验证码成功
return jsonify(errno=RET.OK, errmsg='发送短信成功')
def register():
"""注册
1.获取注册参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器存储的短信验证码
4.与客户端传入的短信验证码对比
5.如果对比成功，就创建用户模型User对象，并给属性赋值
6.将模型属性写入到数据库
7.响应注册结果
"""
# 1.获取注册参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
json_dict = request.get_json()
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 手机格式
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 检测手机号是否注册过
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已存在')
# 3.获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.与客户端传入的短信验证码对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 5.如果对比成功，就创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile
user.password = password
# 6.将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
logging.error(e)
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存用户数据失败')
# 注册即登录，也就是保存注册时生成的数据
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7.响应注册结果
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="发送成功")
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 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 login():
"""用户登录
请求参数: 手机号 密码
参数格式: json
"""
print "bbb"
# 获取参数
print request.get_json()
req_dict = request.get_json()
mobile = req_dict.get('mobile')
password = req_dict.get('password')
# 校验参数
# 校验参数是否完整
if not all([mobile, password]):
# 参数信息不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 校验手机号格式是否正确
if not re.match(r'1[34578]\d{9}', mobile):
# 手机格式不正确
return jsonify(errno=RET.PARAMERR, errmsg="手机格式不正确")
# 判断用户输入错误次数是否超过限制,如果超过限制,则不允许继续操作
# redis记录: "access_nums_请求的IP":"次数"
user_ip = request.remote_addr # 用户请求的IP地址
try:
access_nums = redis_store.get("access_num_%s" % user_ip)
except Exception as e:
# 记录日志
current_app.logger.error(e)
else:
if access_nums is not None and int(
access_nums) >= constants.LOGIN_ERROR_MAX_TIMES:
# redis中有记录并且错误次数大于5,阻止继续执行操作
return jsonify(errno=RET.REQERR, 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="获取用户信息失败")
# 用数据库中的密码与用户填写的密码进行对比验证是否一致
if user is None or not user.check_password(password):
# 如果登录验证失败,记录错误次数,返回信息
try:
redis_store.incr("access_num_%s" % user_ip)
redis_store.expire("access_num_%s" % user_ip,
constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
# 记录日志
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误")
# 如果登录验证相同,保存登录状态,在session中
session["name"] = user.name
session["mobile"] = user.mobile
session["user_id"] = user.id
# 返回值
return jsonify(errno=RET.OK, errmsg="登录成功")
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 register():
"""
注册逻辑
1. 获取参数：手机号, 短信验证码, 密码,
2. 取到真实的短信验证码
3. 进行验证码的对比
4. 初始化User模型，保存相关数据
5. 将user模型存到数据库中
6. 给出响应：{"errno": "0", "errmsg": "注册成功"}
: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:
real_phonecode = redis_store.get("Mobile:" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询短信验证码失败")
if not real_phonecode:
return jsonify(errno=RET.NODATA, errmsg="短信验证码过期")
# 3. 进行验证码的对比
if phonecode != real_phonecode:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码输入错误")
# 3.1 判断当前手机是已经被注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg="该手机号已被注册")
# 4. 初始化User模型，保存相关数据
user = User()
user.mobile = mobile
user.name = mobile
# 保存密码
user.password = password
# 5. 将user模型存到数据库中
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
session["user_id"] = user.id
session["name"] = user.name
session["mobile"] = user.mobile
# 6. 给出响应：{"errno": "0", "errmsg": "注册成功"}
return jsonify(errno=RET.OK, errmsg="注册成功")
def send_sms_code():
"""
发送短信验证码
1. 接收前端发送过来的参数：手机号，用户输入图片验证码的内容，图片验证码的编号
2. 判断参数是否都有值与参数校验
3. 从redis中取出正确的图片验证码(如果没有到，代表验证码过期)
4. 进行验证码的对比，如果用户输入的验证码与真实的验证码一样
5. 生成短信验证码
6. 发送短信
7. 保存短信验证到redis中
8. 告诉前端发送短信成功
:return:
"""
# 1. 接收前端发送过来的参数
# JSON字符串
json_data = request.data
# 转成字典
json_dict = json.loads(json_data)
mobile = json_dict.get("mobile")
image_code = json_dict.get("image_code")
image_code_id = json_dict.get("image_code_id")
# 2. 判断参数是否有值和参数校验
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if not re.match("^1[34578][0-9]{9}$", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式有误")
# 3. 从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, errmsg="验证码已过期")
# 4. 进行验证码的对比，如果用户输入的验证码与真实的验证码一样
if image_code.lower() != real_image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg="验证码输入不正确")
# 5. 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
current_app.logger.debug("短信验证码为：" + sms_code)
# 6. 发送短信
# result = CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES / 60], "1")
# if result != 1:
# # 发送短信失败
# return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败")
# 7. 保存短信验证到redis中
try:
redis_store.set("Mobile:" + mobile, sms_code,
constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存验证码失败")
# 8. 告诉前端发送短信成功
return jsonify(errno=RET.OK, errmsg="发送成功")
def send_sms_code():
"""发送短信验证码
1.接受参数：手机号，图片验证码，uuid
2.判断参数是否缺少，并且要对手机号进行校验
3.获取服务器存储的图片验证码，uuid作为key
4.与客户端传入的图片验证码对比，如果对比成功
5.生成短信验证码
6.使用云通讯将短信验证码发送到注册用户手中
7.存储短信验证码到redis中
8.响应短信发送的结果
"""
# 1.接受参数：手机号，图片验证码，uuid
# data : 保存请求报文里面的原始的字符串，开发文档约定，客户端发送的是json字符串
json_str = request.data
json_dict = json.loads(json_str)
mobile = json_dict.get('mobile')
imageCode_client = json_dict.get('imagecode')
uuid = json_dict.get('uuid')
# 2.判断参数是否缺少，并且要对手机号进行校验
if not all([mobile, imageCode_client, uuid]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 校验手机号码是否合法
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号码格式错误')
# 3.获取服务器存储的图片验证码，uuid作为key
try:
imageCode_server = redis_store.get('ImageCode:' + uuid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询服务器验证码失败')
# 判断是否为空或者过期
if not imageCode_server:
return jsonify(errno=RET.NODATA, errmsg='验证码不存在')
# 4.与客户端传入的图片验证码对比，如果对比成功
if imageCode_server.lower() != imageCode_client.lower():
return jsonify(errno=RET.DATAERR, errmsg='验证码输入有误')
# 5.生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
current_app.logger.debug('短信验证码为：' + sms_code)
# 6.使用云通讯将短信验证码发送到注册用户手中
# 注释以下代码，是在我们验证逻辑通过的前提下，为了方便不在频繁的发送短信验证码，我就使用假的手机号绑定我们自己生产的验证码
# result = CCP().send_template_sms(mobile, [sms_code , constants.SMS_CODE_REDIS_EXPIRES/60], '1')
# if result != 1:
# return jsonify(errno=RET.THIRDERR, errmsg='发送短信验证码失败')
# 7.存储短信验证码到redis中:短信验证码在redis中的有效期一定要和短信验证码的提示信息一致
try:
redis_store.set('Mobile:' + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='存储短信验证码失败')
# 8.响应短信发送的结果
return jsonify(errno=RET.OK, errmsg='发送短信验证码成功')
def register():
""""注册
1，获取注册参数：手机号，短信验证码，密码
2，判断参数是否缺少
3，获取服务器存储的短信验证码
4，与客户端传入的短信验证码对比
5，对比成功，创建User对象，给属性赋值
6，将模型属性写入到数据库
7，响应注册结果
"""
# 1，获取注册参数：手机号，短信验证码，密码
# 当确定前端发来的是json字符串
json_dict = request.get_json()
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
print '11111111111'
print mobile
print u'短信验证码为：' + sms_code_client
print password
print '22222222222'
# 2，判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 3，获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4，与客户端传入的短信验证码对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 判断该手机号是否注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已注册')
# 5，对比成功，创建User对象，给属性赋值
user = User()
user.mobile = mobile
user.name = mobile # 后面会有改用户名的逻辑
# TODO 密码需要加密后加入到数据库
# 调用password属性的setter方法
user.password = password
# 6，将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户注册数据失败')
# 注册即登录
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7，响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
