def register():
"""用户注册"""
# 从json中获取参数
user_data = request.get_json()
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
mobile = user_data.get("mobile") # 手机号
sms_code = user_data.get("sms_code") # 短信验证码
password = user_data.get("password") # 密码
# 检查参数
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 手机号格式校验
if not re.match(r"1[34578]\d{9}$", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
# 检查短信验证码
# 从redis中读取真实的短信验证码
try:
real_sms_code = redis_store.get("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="读取验证码异常")
# 判断验证码是否过期
if not real_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码过期")
# 判断用户输入的验证码的正确性
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg="短信验证码无效")
# 已经进行过短信验证码的对比校验，所以删除redis中的smscode
try:
redis_store.delete("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
# 保存用户信息
user = User(name=mobile, mobile=mobile)
# 通过设置user模型的password属性，实际调用了设置密码的方法，对密码进行了加密
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 保存用户的session数据
session["user_id"] = user.id
session["name"] = mobile
session["mobile"] = mobile
return jsonify(errno=RET.OK, errmsg="OK", data=user.to_dict())
def register():
"""
:return:
"""
# request.json.get() 获取单个json数据
# 获取整个json数据包
json_data = request.get_json()
if not json_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 从json数据包中挨个提取参数
mobile = json_data.get('mobile')
sms_code = json_data.get('sms_code')
password = json_data.get('password')
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少必传参数')
# 校验手机号
if not re.match(r'1[3-9]\d{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机格式错误')
# 从redis中取出真实的短信验证码
try:
server_sms_code = redis_cli.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据失败')
# 判断查询结果
if not server_sms_code:
return jsonify(errno=RET.DATAERR, errmsg='数据失效')
# 先比较 再删除
if server_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
try:
redis_cli.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 实例化模型类对象, 保存用户信息
user = User()
user.mobile = mobile
user.name = mobile
user.password = password
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对象，存到redis中
session['user_id'] = user.id
session['name'] = mobile
session['mobile'] = mobile
# 返回结果,
# data表示用户数据，是注册业务完成后，返回注册结果相关的附属信息
return jsonify(errno=RET.OK, errmsg='注册成功', data=user.to_dict())
def register():
"""
1.获取参数--request.get_json()
2.判断获取结果
3.获取详细的参数，mobile,sms_code,password
4.校验是否缺少参数
5.检查手机号格式
6.查询数据库判断用户是否已注册--放在try中，查到说明已注册
7.获取本地存储的真实短信验证码，放在try中
8.判断查询redis的结果,没有就说明验证码过期
9.比较获取的短信验证码和本地存储的是否一致
10.正确就删除短信验证码
11.保存用户信息
12.缓存用户信息
13.返回结果
"""
user_data = request.get_json()
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
mobile = user_data['mobile']
sms_code = user_data['sms_code']
password = user_data['password']
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'1[3456789]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmgs='手机格式错误')
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:
return jsonify(errno=RET.DATAEXIST, errmsg='用户已注册')
try:
real_sms_code = redis_store.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据库异常')
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='用户验证码过期')
#比较真实sms_code和获取到的sms_code
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg='验证码错误')
#删除短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
#保存用户信息
user = User(mobile=mobile, name=mobile)
user.password = password
#提交数据到数据库
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['mobile'] = mobile
session['name'] = mobile
#返回结果
return jsonify(errno=RET.OK, errmsg='OK', data=user.to_dict())
def register():
"""
注册用户
1/获取参数,user_data = request.get_json()获取请求体中的data数据
2/校验参数存在
3/获取详细的参数信息,mobile,sms_code,password
4/校验参数的完整性
5/校验手机号格式
6/获取本地存储的真实短信验证码
7/判断获取结果
8/比较短信验证码是否一致
9/删除短信验证码
10/判断用户是否已注册
11/保存用户信息,
user = User(mobile=mobile,name=mobile)
实际上调用了generate_password_hash()
user.password = password
12/提交数据到数据库,如果发生异常需要进行回滚
13/缓存用户信息
flask_session扩展包:实现用户信息缓存的位置,对session加密签名,指定过期时间;
请求上下文对象session:用来从redis中获取缓存的用户信息
session['user_id'] = user.id
session.get('user_id')
14/返回结果,返回附属信息user.to_dict()
:return:
"""
# 获取post参数,get_json()
user_data = request.get_json()
# 校验参数存在
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 进一步获取详细的参数信息
# user_data['mobile']
mobile = user_data.get('mobile')
smscode = user_data.get('sms_code')
password = user_data.get('password')
# 校验参数的完整性
if not all([mobile, smscode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 对手机号进行校验
if not re.match(r'1[3456789]\d{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 获取本地存储的真实短信验证码
try:
real_sms_code = redis_store.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取短信验证码失败')
# 判断获取结果
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
# 比较短信验证码是否一致
if real_sms_code != str(smscode):
return jsonify(errno=RET.DATAERR, errmsg='短信验证码不一致')
# 删除redis中存储的短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 判断用户是否已注册
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:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已注册')
# 保存用户信息
user = User(name=mobile, mobile=mobile)
# 调用了模型类中密码加密方法
user.password = password
# 提交数据到数据库中
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='保存用户信息失败')
# 缓存用户信息到redis数据库中,需要使用请求上下文对象session
session['user_id'] = user.id
session['name'] = mobile
session['mobile'] = mobile
# 返回结果
return jsonify(errno=RET.OK, errmsg='OK', data=user.to_dict())
def register():
"""
注册:
1/获取参数,request对象的get_json()获取前端发送过来post请求的data数据
2/进一步获取data数据里的详细的参数,mobile,sms_code,password
3/参数的完整性校验
4/手机号格式检查,手机号存在检查
5/获取本地存储的真实短信验证码
6/校验获取结果
7/先比较短信验证码,如果正确的情况下,删除短信验证码
8/构造模型类对象,准备存储用户信息
user = User(name=mobile,mobile=mobile)
user.password = password
9/提交数据到数据库
db.session.add(user)
db.session.commit()
db.session.rollback()
10/缓存用户的session信息
session['name'] = mobile
session['name'] = user.name
session['user_id'] = user.id
session['mobile'] = mobile
11/返回结果
return jsonify(errno=RET.OK,errmsg='OK',data=user.to_dict())
:return:
"""
# 获取参数,post请求的参数使用get_json()方法
"""
req = {'mobile':mobile,'sms_code':sms_code,'password':password}
JSON.stringify(req)
JSON.parse(resp)
DataType:json;指明了接收后端返回的数据格式;
"""
user_data = request.get_json()
# 校验参数的存在
if not user_data:
return jsonify(errno=RET.PARAMERR,errmsg='参数错误')
# 获取详细的参数信息,user_data['mobile']
mobile = user_data.get('mobile')
sms_code = user_data.get('sms_code')
password = user_data.get('password')
# 参数完整性检查
if not all([mobile,sms_code,password]):
return jsonify(errno=RET.PARAMERR,errmsg='参数缺失')
# 检查手机号格式
if not re.match(r'^1[3456789]\d{9}$',mobile):
return jsonify(errno=RET.PARAMERR,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:
# return jsonify(errno=RET.DATAEXIST,errmsg='手机号已注册')
# 获取真实的短信验证码
try:
real_sms_code = redis_store.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg='获取本地短信验证码失败')
# 判断获取结果
if not real_sms_code:
return jsonify(errno=RET.NODATA,errmsg='短信验证码已过期')
# 判断短信验证码是否一致
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR,errmsg='短信验证码不一致')
# 如果短信验证码一致,删除redis中的短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 准备存储数据,使用模型类
user = User(name=mobile,mobile=mobile)
# 调用了模型类中的password方法,实现了密码的加密
user.password = password
# 提交数据到数据库中
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已经注册")
except Exception as e:
current_app.logger.error(e)
# 存储数据如果发生异常,需要进行回滚
db.session.rollback()
return jsonify(errno=RET.DBERR,errmsg='保存用户信息异常')
# 缓存用户信息,使用session
session['user_id'] = user.id
session['name'] = mobile
session['mobile'] = mobile
# 返回结果,data数据为附属信息
return jsonify(errno=RET.OK,errmsg='OK',data=user.to_dict())
def register():
"""
用户注册模块
1. 获取用户参数：POST请求：手机号、短信验证码、密码
2. 校验用户参数：是否均不为空
3. 通过正则校验手机号是否合法
4. 校验验证码是否正确
5. 校验手机号是否已经注册过
6. 删除比较之后的验证码
7. 构造模型类，存储用户数据
8. 缓存用户信息
9. 返回结果
:return:
"""
# 1.获取用户参数:
user_data = request.get_json()
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='获取参数错误')
# 获取详细参数：手机号、短信验证码、 密码
mobile = user_data.get('mobile')
sms_code = user_data.get('sms_code')
password = user_data.get('password')
# 2. 校验三个参数均存在
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 3. 校验手机号是否合法
if not re.match(r'^1[3-9]\d{9}$', mobile):
return jsonify(errcode=RET.PARAMERR, errmsg='手机号不合法')
# 4. 查询数据库，确认该手机号是否已经注册过
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 not None:
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已经注册过')
# 5. 从redis数据库中查询真实的短信验证码，与用户输入的验证码进行比较
try:
real_sms_code = redis_store.get('smscode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据库异常')
# 如果查询结果为空，说明验证码已过期
if not real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='验证码已过期')
# 如果验证不为空，则进行比较
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg='验证码错误')
# 6. 如果验证码已经校验通过后，从redis数据库中删除
try:
redis_store.delete('smscode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 7. 当参数校验无问题之后，保存用户数据到数据库,
# 首先构造模型类对象，要对密码进行加密
new_user = User(mobile=mobile, name=mobile)
new_user.password = password
try:
db.session.add(new_user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存数据失败')
# 8. 缓存用户信息到redis中
session['mobile'] = mobile
session['use_id'] = new_user.id
session['name'] = mobile
return jsonify(errno=RET.OK, errmsg='OK', data=new_user.to_dict())
def register():
"""
注册
1/获取参数,使用user_data = request.get_json()
2/校验参数的存在
3/进一步获取详细的参数信息,mobile,smscode,password
4/校验参数的完整性
5/进一步校验详细的参数信息,mobile
6/校验短信验证码,获取本地存储的短信验证码
7/判断短信验证码是否过期
8/比较短信验证码是否正确
9/删除短信验证码
10/判断用户是否已注册
11/保存用户信息,
user = User(mobile=mobile,name=mobile)
user.password = password
12/缓存用户信息:flask_session扩展包的作用:指定用户的缓存信息存放位置,加密签名,指定有效期;
我们需要使用请求上下文对象session来从redis中获取或设置用户信息;
session.get('user_id')
session[user_id] = user_id
13/返回结果
:return:
"""
# 获取参数
user_data = request.get_json()
# 判断获取结果
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 进一步获取详细的参数信息
mobile = user_data.get('mobile')
smscode = user_data.get('sms_code')
password = user_data.get('password')
# 校验参数的完整性
if not all([mobile, smscode, password]):
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_sms_code = redis_store.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
# 判断获取结果
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
# 比较短信验证码
if real_sms_code != str(smscode):
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
# 删除短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 判断用户是否已注册
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='手机号已注册')
# 调用模型类对象，保存用户信息
user = User(mobile=mobile, name=mobile)
# 对密码存储,这里调用了模型类generate_password_hash方法,对密码进行加密存储
user.password = password
# 提交数据到数据库中
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
session['user_id'] = user.id
session['name'] = mobile
session['mobile'] = mobile
# 返回结果，data 为附属消息
return jsonify(errno=RET.OK, errmsg='OK', data=user.to_dict())
def register():
"""
request的get_json()方法获取前端post发送过来的data数据
1.获取参数mobile,sms_code,password
2.校验参数，判断参数是否完整
3.正则匹配手机号
4.查询redis中存储的短信验证码
5.判断短信验证码是否一致
6.如果一致删除短信验证码
7.构造模型类，存储用户信息
8.提交数据到数据库中
9.缓存用户的session信息
10.返回结果
:return:
"""
user_data = request.get_json()
# 校验参数的存在
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数获取失败")
# 获取参数的详细信息
mobile = user_data.get("mobile")
sms_code = user_data.get("sms_code")
password = user_data.get("password")
# 校验参数的完整性
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 判断手机号是否正确
if not re.match(r'1[3456789]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, 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:
return jsonify(errno=RET.DATAEXIST, errmsg="用户已经注册")
# 查询redis中存储的验证码信息
try:
real_sms_code = redis_store.get("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="获取本地验证码失败")
# 判断获取的结果
if not real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg="本地验证码不存在")
# 判断用户输入的验证码和本地验证码是否一致
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg="验证码不一致")
# 删除短信验证码
try:
redis_store.delete("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
# 使用User模型类，存储用户信息
user = User(mobile=mobile, name=mobile)
# 调用模型类的password方法，实现密码加密
user.password = password
# 保存数据到数据库中
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'] = mobile
session['mobile'] = mobile
# 返回结果
return jsonify(errno=RET.OK, errmsg="保存数据成功", data=user.to_dict())
def register():
"""
:return:
"""
# 获取参数,字典格式
user_data = request.get_json()
# 判断获取结果
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 获取详细参数信息
mobile = user_data.get("mobile")
sms_code = user_data.get("sms_code")
password = user_data.get("password")
# 检查参数完整性
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数缺失")
# 校验手机号格式
if not re.match(r"1[3-9]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, 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:
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已注册")
# 获取redis中正确的短信验证码
try:
real_sms_code = redis_store.get("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
# 判断验证码是否过期
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg="短信验证码过期")
# 直接比较短信验证码是否正确
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 删除短信验证码
try:
redis_store.delete("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
# 创建User实例，用于保存数据操作
user = User(mobile=mobile, name=mobile)
# 调用模型类中额的方法generate_password_hash,对密码进行加密sha256处理
user.password = password
# 提交数据到数据库
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["mobile"] = mobile
session["name"] = mobile
# 返回结果
# 返回data，前段若需要就可以直接使用了
return jsonify(errno=RET.OK, errmsg="OK", data=user.to_dict())
def register():
"""
注册
1/获取参数,使用user_data = request.get_json()
2/校验参数的存在
3/进一步获取详细的参数信息,mobile,smscode,password
4/校验参数的完整性
5/进一步校验详细的参数信息,mobile
6/校验短信验证码,获取本地存储的短信验证码
7/判断短信验证码是否过期
8/比较短信验证码是否正确
9/删除短信验证码
10/判断用户是否已注册
11/保存用户信息,
user = User(mobile=mobile,name=mobile)
user.password = password
12/缓存用户信息:flask_session扩展包的作用:指定用户的缓存信息存放位置,加密签名,指定有效期;
我们需要使用请求上下文对象session来从redis中获取或设置用户信息;
session.get('user_id')
session[user_id] = user_id
13/返回结果
:return:
"""
# 获取参数
user_data = request.get_json()
# 判断获取结果
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 进一步获取详细的参数信息
mobile = user_data.get('mobile')
smscode = user_data.get('sms_code')
password = user_data.get('password')
# 校验参数的完整性
if not all([mobile, smscode, password]):
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_sms_code = redis_store.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
# 判断获取结果
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
# 比较短信验证码
if real_sms_code != str(smscode):
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
# 删除短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 判断用户是否已注册
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='手机号已注册')
# 调用模型类对象，保存用户信息
user = User(mobile=mobile, name=mobile)
# 对密码存储,这里调用了模型类generate_password_hash方法,对密码进行加密存储
user.password = password
# 提交数据到数据库中
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
session['user_id'] = user.id
session['name'] = mobile
session['mobile'] = mobile
# 返回结果，data 为附属消息
return jsonify(errno=RET.OK, errmsg='OK', data=user.to_dict())
def register():
"""
注册用户
1/获取参数,request.get_json()
2/校验参数存在
3/获取详细的参数,mobile,sms_code,password
4/校验手机号格式
5/校验短信验证码
6/获取本地存储的真实短信验证码
7/判断查询结果
8/比较短信验证码是否正确
9/删除短信验证码
10/保存用户数据
user = User(mobile=mobile,name=mobile)
user.password = password
11/缓存用户信息
12/返回结果
:return:
"""
# 获取参数
user_data = request.get_json()
# 判断获取结果
if not user_data:
return jsonify(errno=RET.PARAMERR,errmsg='参数错误')
# 获取详细的参数信息，mobile,sms_code,password
# user_data['mobile']
mobile = user_data.get('mobile')
sms_code = user_data.get('sms_code')
password = user_data.get('password')
# 检查参数的完整性
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 手机号格式检查
if not re.match(r'1[3456789]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, 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:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已注册')
# 获取本地存储的真实短信验证码
try:
real_sms_code = redis_store.get('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据库异常')
# 验证码是否存在
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
# 直接比较短信验证是否正确
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
# 删除短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 准备保存用户注册信息
user = User(mobile=mobile,name=mobile)
# 调用模型类中的方法generate_password_hash, 对密码进行加密sha256处理
user.password = password
# 提交数据到数据库
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['mobile'] = mobile
session['name'] = mobile
# 返回结果
return jsonify(errno=RET.OK, errmsg='OK', data=user.to_dict())
