def set_auth():
# 获取参数
request_dict = request.json
real_name = request_dict.get('real_name')
id_card = request_dict.get('id_card')
# 验证有效性
if not all([real_name, id_card]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少必要参数')
# 查询用户
try:
user = User().query.get(g.user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询用户信息失败')
if (user.real_name is not None) & (user.id_card is not None):
return jsonify(errno=RET.DATAEXIST, errmsg='该用户已实名认证')
user.real_name = real_name
user.id_card = id_card
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户信息失败')
return jsonify(errno=RET.OK, errmsg='OK')
def register():
"""注册"""
# 获取参数
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")
# 校验参数
# 1. 参数完整性
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg=u"参数不完整")
# 2. 手机号
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg=u"手机号格式错误")
# 3. 密码
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg=u"两次密码不一致")
# 4. 短信验证码
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=u"读取短信验证码异常")
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg=u"短信验证码失效")
try:
# 删除redis中的短信验证码，防止重复使用校验
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg=u"短信验证码错误")
# 业务处理
# 1. 保存用户的注册数据到数据库中
user = User(name=mobile, mobile=mobile)
user.password = password # 设置属性，调用模型类中password.setter装饰方法
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
# 模型类中设置mobile为unique，因此手机号若存在会在保存时抛出异常
db.session.rollback() # 回滚到异常commit提交前的状态
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg=u"手机号已存在")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u"查询数据库异常")
# 2. 保存登录状态到session中
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# 返回结果
return jsonify(errno=RET.OK, errmsg=u"注册成功")
def register():
try:
req_data = request.get_json()
except Exception as e:
return jsonify(errno=RET.PARAMERR, errmsg='请传入json数据')
if not req_data:
return jsonify(errno=RET.PARAMERR, errmsg='请传入json数据')
mobile = req_data.get('mobile')
sms_code = req_data.get('sms_code')
password = req_data.get('password')
password2 = req_data.get('password2')
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
elif not re.match('1\d{10}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
elif password != password2:
return jsonify(errno=RET.PARAMERR, errmsg='两次输入密码不相等')
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数据库错误')
else:
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
elif real_sms_code != sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码错误')
# 删除redis中的短信验证码，防止重复使用校验
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 保存用户的注册数据到数据库中
user = User(name=mobile, mobile=mobile)
# user.generate_password_hash(password)
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['name'] = user.name
session['mobile'] = user.mobile
session['user_id'] = user.id
return jsonify(errno=RET.OK, errmsg='注册用户成功')
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():
"""用户注册处理"""
# 接收参数
# 获取json数据，返回字典
req_data = request.get_json()
mobile = req_data.get('mobile')
sms_code = req_data.get('sms_code')
password = req_data.get('password')
cpassword = req_data.get('cpassword')
# 校验参数
if not all([mobile, sms_code, password, cpassword]):
return jsonify(errcode=RET.PARAMERR, errmsg='数据不完整')
# 校验手机号
if not re.match(r'1[34578]\d{9}', mobile):
return jsonify(errcode=RET.PARAMERR, errmsg='手机号格式错误')
# 两次密码是否相同
if password != cpassword:
return jsonify(errcode=RET.PARAMERR, errmsg='两次密码不相同')
# 短信验证码是否正确
try:
redis_sms_code = redis_store.get('sms_code_%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmsg='读取验证码数据库错误')
if redis_sms_code is None:
return jsonify(errcode=RET.DATAERR, errmsg='短信验证码过期')
if sms_code != redis_sms_code:
return jsonify(errcode=RET.DATAERR, errmsg='短信验证码错误')
# 手机号是否注册
user = User(name=mobile, 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(errcode=RET.DATAERR, errmsg='手机号已被注册')
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmsg='数据库异常')
# 业务逻辑处理
session['user_id'] = user.id
session['username'] = mobile
session['mobile'] = mobile
# 返回
return jsonify(errcode=RET.OK, errmsg='注册成功')
def register():
"""
用户注册模块
:参数：mobile, mobile_code,password,password2
:return:jsonfiy{"errno":data,
“errmsg”:data}
"""
#获取json数据
dir_Json = request.get_json()
mobile = dir_Json.get('mobile')
mobile_code = dir_Json.get('mobile_code')
password = dir_Json.get('password')
password2 = dir_Json.get('password2')
#判断数据完整性
if not all([mobile, mobile_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg="missing data")
#判断手机号格式
if not re.match(r'1[345678]\d{9}', mobile):
return jsonify(errno=RET.DATAERR, errmsg="mobile Incorrect data")
#判断密码
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
#验证手机验证码
try:
redis_mobile_code = redis_store.get("mobile_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="rediss error")
if not mobile_code:
return jsonify(errno=RET.DATAERR, errmsg="missing mobile_code")
if redis_mobile_code != mobile_code:
return jsonify(errno=RET.DATAERR, errmsg=" mobile_code error")
#判断手机是否存在,设置密码
try:
user = User(name=mobile, mobile=mobile)
user.password = password
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=" data exist ")
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="mysql error")
#保存session数据
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
return jsonify(errno=RET.OK, errmsg="register ok ")
def register():
"""signup
"""
# Gets the requested JSON data and returns the dictionary
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")
# Calibration parameters
#if not all([mobile, sms_code, password, password2]):
#return jsonify(errno=RET.PARAMERR, errmsg="Parameter Incomplete")
if not all([mobile, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg="Parameter Incomplete")
# Determine the format of the phone number
if not re.match(r"1[34578]\d{9}", mobile):
# wrong format
return jsonify(errno=RET.PARAMERR,
errmsg="The format of mobile phone number is wrong")
if password != password2:
return jsonify(errno=RET.PARAMERR,
errmsg="The two passwords don't match")
# Save the user's registration data to the database
user = User(name=mobile, mobile=mobile)
# user.generate_password_hash(password)
user.password = password # set attributes
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
# A rollback after a database operation error
db.session.rollback()
# It indicates that the phone number has a duplicate value
# the phone number has been registered
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg="existent phone number")
except Exception as e:
db.session.rollback()
# It indicates that the phone number has a duplicate value,
# the phone number has been registered
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="Query Database Exception")
# Save the login state to the session
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# reture result
return jsonify(errno=RET.OK, errmsg="registered successfully ")
def user():
# 获取参数
phonecode = request.json.get("phonecode")
mobile = request.json.get("mobile")
password = request.json.get("password")
# 校验参数
# print(sms_code,mobile,password)
if not all([phonecode, mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 手机号校验
if not re.match(r"1[345678]\d{9}$", mobile):
# print("手机校验失败")
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 判断用户是否一存在
try:
user = User.query.filter(User.mobile == mobile).first()
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
if user:
return jsonify(errno=RET.DATAEXIST, errmsg=error_map[RET.DATAEXIST])
# 校验短信验证码，更具手机号取出短信验证码
# print("手机校验通过了")
try:
real_phonecode = sr.get("sms_code_id" + mobile)
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
# 如获取到了验证码
if real_phonecode != phonecode:
# print("验证码错误")
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 记录用户数据
user = User()
user.mobile = mobile
user.name = mobile
# user.password_hash=password # 直接存储密码为明文密码 不安全
# 使用计算属性封装密码
user.password = password
db.session.add(user)
try:
db.session.commit()
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
# 使用session 记录用户登录状态，记录主键就可以查询出其他的数据
session["user_id"] = user.id
# json 返回结果
return jsonify(errno=RET.OK, errmsg=error_map[RET.OK])
def register():
"""
1. 获取参数和判断是否有值
2. 从redis中获取指定手机号对应的短信验证码的
3. 校验验证码
4. 初始化 user 模型，并设置数据并添加到数据库
5. 保存当前用户的状态
6. 返回注册的结果
: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. 从redis中获取指定手机号对应的短信验证码的
try:
sms_code = sr.get("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()
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.DATAERR, errmsg="数据保存错误")
session["user_id"] = user.id
session["name"] = user.name
session["mobile"] = user.mobile
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
"""register
:return:
"""
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
pwd = req_dict.get("password")
pwd2 = req_dict.get("password2")
# 数据是否完整
if not all([mobile, sms_code, pwd]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 判断手机格式
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机格式错误")
if pwd != pwd2:
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
# 判断短信验证码是否正确
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="读取短信验证码异常")
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 验证码是否正确
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 保存用户信息
user = User(name=mobile, mobile=mobile)
user.password = pwd
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="手机号存在")
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["user_id"] = user.id
# return
return jsonify(errno=RET.OK, errmsg="ok")
def register():
"""
注册
请求参数 手机号 验证码 秘密 确认密码
请求方式 json
:return:
"""
req_data = request.get_json()
mobile = req_data.get("mobile")
sms_code = req_data.get("sms_code")
password = req_data.get("password")
password2 = req_data.get("password2")
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg="两次秘密不一样")
if not re.match(r'1[34678]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不对")
try:
redis_sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取手机验证码错误")
if redis_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="手机验证码失效")
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
if sms_code != redis_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="验证码不对")
user = User(name=mobile, 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["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
# 获取手机号,短信验证码,密码
requ_dict = request.get_json()
mobile = requ_dict.get("mobile")
sms_code = requ_dict.get("sms_code")
password = requ_dict.get("password")
password2 = requ_dict.get("password2")
# 手机号和短信验证码的校验
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg="数据不完整")
if not re.match(r"1[35689]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机格式不正确")
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
# 判断短信验证码是否正确
try:
real_sms_code = redis_store.get(mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis查询错误")
else:
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)
# else:
# if user is not None:
# return jsonify(errno=RET.DATAEXIST, errmsg="用户已注册")
# 把手机号保存为user类的对象
user = User(mobile=mobile, name=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["name"] = mobile
session["mobile"] = 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')
# 检验参数的完整性
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='手机号格式不正确')
# 判断两次密码是否一致
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg='两次密码不一致')
# 判断手机号是否注册过，将注册信息保存到数据库中
user = User(name=mobile, mobile=mobile)
user.password = password
# from sqlalchemy.exc import IntegrityError
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.获取参数phone_num 手机号，phonecode 短信验证码，password 密码
2.校验数据
3.从Redis获取短信验证码，和传来的数据校验，如果正确
4.新增user对象，
5.跳转首页，保持登录状态
:return 返回注册信息{ 're_code':'0','msg':'注册成功'}
"""
# 1.获取参数phone_num 手机号，phonecode 短信验证码，password 密码
json_dict = request.json
phone_num = json_dict.get('phone_num')
phonecode_client = json_dict.get('phonecode')
password = json_dict.get('password')
# 2.校验数据
if not all([phone_num, phonecode_client, password]):
return jsonify(re_code=RET.PARAMERR, msg='参数不完整')
# 校验手机号是否正确
if not re.match(
r'^1([38][0-9]|4[579]|5[0-3,5-9]|6[6]|7[0135678]|9[89])\d{8}$',
phone_num):
return jsonify(re_code=RET.PARAMERR, msg='手机号不正确')
# 3.从Redis获取短信验证码，和传来的数据校验，如果正确
try:
phonecode_server = redis_conn.get('PhoneCode:' + phone_num)
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DBERR, msg='查询短信验证码失败')
if phonecode_server.decode() != phonecode_client:
return jsonify(re_code=RET.PARAMERR, msg='短信验证码错误')
# 4.新增user对象，
user = User()
user.name = phone_num
user.phone_num = phone_num
user.password_hash = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
db.session.rollback()
return jsonify(re_code=RET.DBERR, msg='注册失败')
# 5.跳转首页，保持登录状态
session['user_id'] = user.id
session['name'] = user.name
session['phone_num'] = user.phone_num
# 6.响应结果
return jsonify(re_code=RET.OK, msg='注册成功')
def register():
"""
注册
:return:
"""
req_dict=request.get_json()
mobile=req_dict.get("mobile")
password=req_dict.get("password")
password2=req_dict.get("password2")
if not all([mobile,password,password2]):
return jsonify(code=RET.PARAMERR,msg="参数不完整")
if not re.match(r"1[34578]\d{9}",mobile):
return jsonify(code=RET.PARAMERR,msg="手机格式错误")
if password!=password2:
return jsonify(code=RET.PARAMERR,msg="两次密码不一致")
try:
user=User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR,msg="数据库异常")
else:
if user is not None:
return jsonify(code=RET.DATAEXIST,msg="手机号已存在")
user=User(name=mobile,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(code=RET.DATAEXIST,msg="手机号已存在")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAEXIST, msg="查询数据库异常")
session['name']=mobile
session['mobile']=mobile
session['user_id']=user.id
return jsonify(code=RET.OK,msg="注册成功")
def register():
'''注册
请求的参数： 手机号、短信验证码、密码、确认密码
参数格式：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")
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="两次密码不一致")
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="读取真实短信验证码异常")
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
if real_sms_code.decode() != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误,请重新获取验证码")
# 盐值加密
user = User(name=mobile, mobile=mobile)
# user.generate_password_hash(password)
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["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
resq = request.json
if not resq:
return jsonify(errno=RET.PARAMERR, errmsg='请求参数缺失')
mobile = resq.get('mobile')
clien_sms_code = resq.get('smscode')
password = resq.get('password')
if not all([mobile, clien_sms_code, password]):
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='校对用户表失败')
if user:
return jsonify(errno=RET.DATAERR, errmsg='用户已注册')
try:
server_sms_code = redis_store.get('mobile:' + 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.DATAEXIST, errmsg='短信验证码失效')
if server_sms_code != clien_sms_code:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码不正确')
try:
redis_store.delete('mobile:' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='删除短信验证码失败')
# user = User(name=mobile, mobile=mobile)
user = User()
user.name = mobile
user.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='写入用户表错误')
session['name'] = user.name
session['user_id'] = user.id
session['mobile'] = mobile
return jsonify(errno=RET.OK, errmsg='OK')
def register():
"""用户注册
请求的参数：手机号mobile、学生姓名name、密码password 确认密码password2
参数格式：json
返回：json数据
"""
# 获取请求的json数据，返回字典
req_dict = request.get_json()
mobile = req_dict.get("mobile")
name = req_dict.get("name")
password = req_dict.get("password")
password2 = req_dict.get("password2")
# 校验参数
if not all([mobile, name, 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='两次密码不一致')
# 判断手机号是否注册过，将注册信息保存到数据库中
user = User(name=name, mobile=mobile)
user.password = password # 密码加密
# from sqlalchemy.exc import IntegrityError
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'] = name
session['mobile'] = mobile
session['user_id'] = user.id
# 返回结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""
手机号 密码
"""
req_dict = request.get_json()
mobile = req_dict.get('mobile')
password = req_dict.get('password')
password2 = req_dict.get('password2')
print(mobile, password, password2)
if not all([mobile, password, password2]):
return jsonify(errno = RET.PARAMERR, errmsg = '参数不完整')
if not re.match(r"1[345678]\d{9}", mobile):
return jsonify(errno = RET.PARAMERR, errmsg = "手机号格式错误")
if password != password2:
return jsonify( errno= RET.PARAMERR, errmsg = "两次输入的密码不一致" )
user = User(name=mobile, mobile=mobile)
# 对密码的加密：使用sha256算法加密
# pbkdf2:sha256:50000 $ cK0U6uNi $ 7ff2b0e361172433e8d391b3865a35d5cf252a30db0f3bf42b0f719771430225
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():
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")
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="读取真实验证码异常")
# 判断短信验证码是否过期
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
# 判断用户填写短信验证码的正确性
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="手机号已经存在！")
# 保存用户的注册数据到数据库中
user = User(name=mobile, password_hash=password, mobile)
try:
db.session.add(user)
db.session.commit()
except IndentationError as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已经存在")
except Exception as e:
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 registe():
# 获取参数判断是否空
date_dict = request.json
mobile = date_dict.get("mobile")
phonecode = date_dict.get("phonecode")
password = date_dict.get("password")
if not all([mobile,phonecode,password]):
return jsonify(erron=RET.PARAMERR,errmsg="参数不全")
#取到本地验证码
try:
sms_code = redis_store.get("SMS_"+mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(erron=RET.DATAERR,errmsg="本地短信验证码获取失败")
if not sms_code:
return jsonify(erron=RET.NODATA,errmsg="短信验证码过期")
# 本地验证码和传入的短信验证码进行对比
if phonecode != sms_code:
return jsonify(erron=RET.DATAERR,errmsg="短信验证码错误")
user = User()
user.name = mobile
user.mobile = mobile
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(erron=RET.DBERR,errmsg="保存数据失败")
# 保存登陆状态
session["name"] = mobile
session["moblie"] = mobile
session["user_id"] = user.id
return jsonify(erron=RET.OK,errmsg="注册成功")
def register():
"""用户注册接口"""
# 1.获取参数phone_num 手机号，phonecode 短信验证码，password 密码
phone_num = request.json.get('phone_num')
phonecode_client = request.json.get('phonecode')
password = request.json.get('password')
#2.校验数据
if not all([phone_num, phonecode_client, password]):
return jsonify(re_code=RET.PARAMERR, msg='参数不完整')
# 校验手机号是否正确
if not re.match(r'1[3456789]\d{9}$', phone_num):
return jsonify(re_code=RET.PARAMERR, msg='手机号不正确')
# 3.从Redis获取短信验证码，和传来的数据校验，如果正确
try:
phonecode_server = redis_conn.get('PhoneCode:' + phone_num)
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DBERR, msg='查询短信验证码失败')
if phonecode_server != phonecode_client:
return jsonify(re_code=RET.PARAMERR, msg='短信验证码错误')
#4.新增user对象，
user = User()
user.name = phone_num
user.phone_num = phone_num
user.password_hash = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
db.session.rollback()
return jsonify(re_code=RET.DBERR, msg='注册失败')
#5.跳转首页，保持登录状态
session['user_id'] = user.id
session['name'] = user.name
session['phone_num'] = user.phone_num
#6.响应结果
return jsonify(re_code=RET.OK, msg='注册成功')
def register():
# 获取参数
mobile = request.form.get('mobile')
password = request.form.get('password')
name = request.form.get('name')
# 判断完整性
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg='用户名密码不完整')
# 写入数据库
b = User(mobile=mobile, password_hash=password, name=name)
db.session.add(b)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
dict_data = request.json
mobile = dict_data.get("mobile")
sms_code = dict_data.get("sms_code")
password = dict_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.DATAERR, errmsg="手机号码格式不对")
try:
redis_sms_code = redis_store.get("sms_code:%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取短信验证码")
if not redis_sms_code:
return jsonify(errno=RET.DBERR, errmsg="短信验证码已经过期")
try:
redis_store.delete("sms_code:%s" % mobile)
except Exception as e:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码填写出错")
user = User()
user.name = mobile
user.mobile = mobile
user.pasword = 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="用户注册失败")
return jsonify(errno=RET.OK, errmsg="注册成功")
def get_auth():
try:
user = User().query.get(g.user_id)
houses = House.query.filter(House.user_id == g.user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询用户信息失败')
real_name = user.real_name
id_card = user.id_card
houses = [house.to_basic_dict() for house in houses]
return jsonify(errno=RET.OK, errmsg='OK', data={'real_name': real_name, 'id_card': id_card, 'houses': houses})
def set_user_image():
"""设置用户头像"""
# 判断是否登录
# 获取头像参数
try:
img_data = request.files.get('avatar')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='传入参数错误')
# 校验参数合法性
# 上传图片
try:
key = upload_image(img_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传用户头像失败')
# 查询用户
try:
user = User().query.get(g.user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询用户信息失败')
# 给用户添加图片链接
user.avatar_url = key
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户头像失败')
# 响应结果
avatar_url = constants.QINIU_DOMIN_PREFIX + key
return jsonify(errno=RET.OK, errmsg='OK', data={'avatar_url': avatar_url})
def register():
# 1. 获取参数和判断是否有值
Post_register = request.json
mobile = Post_register.get('mobile')
ses_code = Post_register.get('phonecode')
password = Post_register.get('password')
if not all([mobile, ses_code, password]):
current_app.logger.error("参数不足")
return jsonify(errno=RET.PARAMERR, errsmg="参数不足")
# 判断手机号码
if not re.match(r"1[2345678][0-9]{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号码格式错误")
# 2. 从redis中获取指定手机号对应的短信验证码的
try:
real_sms_code = sr.get("SMS_CODE_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询redis中短信验证码异常")
# 3. 校验验证码
if ses_code != real_sms_code:
# 3.3 不相等：短信验证码填写错误
return jsonify(errno=RET.DATAERR, errmsg="短信验证码填写错误")
# 4. 初始化 user 模型，并设置数据并添加到数据库
user = User()
user.name = mobile
user.mobile = mobile
user.password = password
# 5. 保存当前用户的状态
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存对象异常")
# 6. 返回注册的结果
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
# 获取参数
request_dict = request.json
mobile = request_dict.get('mobile')
sms_code_client = request_dict.get('sms_code')
password = request_dict.get('password')
password2 = request_dict.get('password2')
# 判断参数有效性
if not all([mobile, sms_code_client, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
if not re.match(r'^1[3-8]\d{9}$', mobile):
return jsonify(errom=RET.PARAMERR, errmsg='手机号码格式不合法')
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg='两次输入的密码不一致')
try:
sms_code_server = redis_store.get('sms_code:%s' % mobile)
except Exception as e:
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
if not sms_code_server:
return jsonify(errno=RET.DATAERR, errmsg='验证码不存在，请先获取验证码')
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='手机验证码错误')
user = User()
user.mobile = mobile
user.name = mobile
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
return jsonify(errno=RET.OK, errmsg='注册成功')
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 login():
"""用户登录
参数： 手机号 密码
"""
# 获取参数
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_nums_%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:
return jsonify(errno=RET.REQERR, errnsg="错误次数过多，请稍后重试")
# 从数据库中根据手机号查询用户的数据对象
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 User.check_password(password):
# 如果验证失败，记录错误次数，返回信息
try:
# access_nums is
return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误")
def register():
"""用户注册"""
# 接收参数，手机号 短信验证码 密码
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
password = req_dict.get("password")
# 校验参数
if not all([mobile, sms_code, password]):
resp = {
"error_code": RET.PARAMERR,
"errmsg": "参数不完整"
}
return jsonify(resp)
if not re.match(r"1[34578]\d{9}", mobile):
resp = {
"error_code": RET.DATAERR,
"errmsg": "手机号格式错误"
}
return jsonify(resp)
# 业务处理
# 获取真实的短信验证码
try:
real_sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DBERR,
"errmsg": "查询短信验证码错误"
}
return jsonify(resp)
# 判断短信验证码是否过期
if real_sms_code is None:
resp = {
"error_code": RET.NODATA,
"errmsg": "短信验证码已过期"
}
return jsonify(resp)
# 判断用户输入的短信验证码是否正确
if real_sms_code != sms_code:
resp = {
"error_code": RET.DATAERR,
"errmsg": "短信验证码错误"
}
return jsonify(resp)
# 删除短信验证码
try:
redis_store.delete("sms_code_%s" % 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)
# resp = {
# "error_code": RET.DBERR,
# "errmsg": "数据库异常"
# }
# return jsonify(resp)
#
# if user is not None:
# resp = {
# "error_code": RET.DATAEXIST,
# "errmsg": "手机号已经注册"
# }
# return jsonify(resp)
# 保存用户的数据到数据库中
user = User(name=mobile, mobile=mobile)
# 对于password属性的设置，会调用属性方法
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DATAEXIST,
"errmsg": "手机号已经注册"
}
return jsonify(resp)
# 记录用户的登录状态
session["user_id"] = user.id
session["username"] = mobile
session["mobile"] = mobile
# 返回响应
resp = {
"error_code": RET.OK,
"errmsg": "注册成功"
}
return jsonify(resp)
def register():
# 获取参数
resp_json = request.get_json()
mobile = resp_json.get('mobile')
sms_code = resp_json.get('sms_code')
password = resp_json.get('password')
# 参数校验
# 1 数据完整性
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='数据不完整')
# 2 手机号格式
if not re.match(r"1[345678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确')
# 业务处理
# Redis中取出短信验证码
try:
real_sms_code = redis_store.get('sms_code_' + mobile)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取Redis数据错误')
# 短信验证码是否失效
if not real_sms_code:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码过期或不存在')
# 对比短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入错误，请重新输入')
# 删除短信Redis--》可以修改后重新输入
try:
redis_store.delete('sms_code_' + mobile)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='删除Redis数据错误')
# 查询用户是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='用户表查询失败')
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:
logging.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='添加用户失败')
# 保存用户登录状态并跳转到登录页
try:
session['id'] = user.id
session['name'] = user.mobile
session['mobile'] = user.mobile
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='session存储错误')
# 返回数据
return jsonify(errno=RET.OK, errmsg='用户注册成功')
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())
