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():
"""用户注册处理"""
# 接收参数
# 获取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():
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():
"""
用户注册模块
:参数：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 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 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():
"""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():
"""
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():
"""
注册
请求参数 手机号 验证码 秘密 确认密码
请求方式 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():
"""注册
请求的参数：手机号，短信验证码，密码
参数格式：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():
# 获取手机号,短信验证码,密码
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():
"""
注册
: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():
"""用户注册
请求的参数：手机号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():
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():
"""
手机号 密码
"""
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 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. 获取参数和判断是否有值
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():
if request.method == 'POST':
phone = request.form.get('mobile')
captcha = request.form.get('imgcode')
password = request.form.get('password')
password2 = request.form.get('password2')
print(phone)
user = User.query.filter(User.phone == 'phone').first()
if not user:
phone_rule = r'^1[345789]\d{9}$'
if re.fullmatch(phone_rule, phone):
if captcha == session['code']:
if password == password2:
user = User()
user.phone = phone
user.name = phone
user.password = password
user.add_update()
return jsonify(SUCCESS)
else:
return jsonify(USER_REGISTER_WRONG_CONFIRM_PASSWORD)
else:
return jsonify(USER_REGISTER_PHONE_WRONG_FORMAT)
return jsonify(USER_REGISTER_USER_IS_EXISTED)
def register():
# 405 --> 检查模块是否导入, 检查是否有POST
# 前后端分离的项目, 要求都用JSON传递数据
# 一. 获取参数
# request.args
# request.form
# request.data --> 获取的是JSON字符串 --> 需要转换JSON格式
# request.get_data()
# request.get_json() --> 直接可以获取json格式的数据
# 测试时, 先去掉csrf保护
# resp_data = request.get_data()
# print 'get_data(: mobile %s' % resp_data.get('mobile')
# resp_json = request.get_json()
# print 'get_json: mobile %s' % resp_json.get('mobile')
# 获取JSON数据, 并将数据转为字典
resp_json = request.get_json()
mobile= resp_json.get('mobile')
sms_code= resp_json.get('sms_code')
password= resp_json.get('password')
# 二. 效验参数
# 2.1 完整性
if not all([mobile, sms_code, password]):
return jsonify({'errno': RET.PARAMERR, 'errmsg': '参数不完整'})
# 2.2 手机号正则
if not re.match(r'1[34578]\d{9}', mobile):
return jsonify({'errno': RET.PARAMERR, 'errmsg': '不正确的手机号'})
# 三. 逻辑处理
# 3.1 从redis中获取短信验证码 try
try:
real_sms_code = redis_store.get('sms_code_' + mobile)
except Exception as e:
# logging.error(e)
# current_app里, 有loggin模块, 也可以实现日志记录. 但是不如logging好用
current_app.logger.error(e)
return jsonify({'errno': RET.DBERR, 'errmsg': '访问数据库异常'})
# 3.2 判断是否为None(5分钟就过期了)
if real_sms_code is None:
return jsonify({'errno': RET.NODATA, 'errmsg': '短信验证码已过期'})
# 如果先删除再判断. 用 1. 服务器要重发验户输入错误的体验不好.证码 2. 发送时间可能较长, 可能会流失用户
# 正常开发中, 允许短信验证码输入错误, 不会立刻删除
# 3.3 对比短信验证码
if sms_code != real_sms_code:
return jsonify({'errno': RET.DATAERR, 'errmsg': '短信验证码输入错误'})
# 3.4 删除redis中的验证码 try
try:
redis_store.delete('sms_code_' + mobile)
except Exception as e:
logging.error(e)
# 这里不删除, 一会也会过期. 而且用户没有做错事情, 只是服务器有点异常. 我们可以此此错误不返回信息
# 3.5 增加用户信息-->密码加密
# 这里不需要再次查询用户是否存在
# 原因: 1. 获取短信验证码的时候已经判断过了. 2. 数据模型中已经增加了unique, 无法重复添加相同的数据
user = User(name=mobile, mobile=mobile)
# 调用user的password的setter方法
user.password = password
# 密码记录时, 会保存盐值和加密方式. 目的是为了登录时验证用的
# pbkdf2:sha256:50000$HDEvpuI3$23f026797d7b9f507f4ccd7b88dd5e39a9bbd0b833451fcb1ae78d9d22298743
# user1 123456 aserwq
# user2 123456 zxdifa
# password --> 做加密处理
# user.password_hash
# TODO(zhubo) 未设置密码
# 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': '数据库错误请重试'})
# 3.6 可以返回首页(设置session, 达到状态保持), 也可以返回登录页((登录成功设置session, 达到状态保持))
# 如果要返回的登录页面, 那么这里就不用设置session
# session['user_id'] = user.id
# session['mobile'] = mobile
# session['user_name'] = mobile
# 四. 返回数据
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, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmag="参数不完整")
# 判断手机号格式
if not re.match(r"1[34578]\d{9}", mobile):
# 表示格式不对
return jsonify(errno=RET.PARAMERR, errmag="手机号格式错误")
if password != password2:
return jsonify(errno=RET.PARAMERR, errmag="两次密码不一致")
# 从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, errmag="读取真实短信验证码异常")
# 判断短信验证码是否过期
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmag="短信验证码失效")
#删除redis中的短信验证码,防止重复使用校验
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.NODATA, errmag="短信验证码错误")
# 判断手机号是否存在,是否已注册
# try:
# user = User.query.filter_by(mobile=mobile).first()
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.DBERR, errmag="数据库异常")
# else:
# if user is not None:
# # 表示手机号已存在
# return jsonify(errno=RET.DATAEXIST, errmag="手机号已存在")
# 注册
# 用户1 password="******" + "abc" sha1 abc$ifmgivmopape
# 用户2 password="******" + "dfc" sha1 dfc$dfefivmopape
# 用户登录 password = ”123456“ + sha256
# 保存用户的注册数据到数据库中
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, errmag="手机号已存在")
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmag="查询数据库异常")
# 保存登录状态到session中
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# 返回结果
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
"""
注册
请求参数: 手机号，短信验证码，密码
参数格式: json
:return:
"""
# 获取请求的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]):
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="短信验证码失效")
# 删除redis中的短信验证码，防止重复使用校验
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 判断用户填写的短信验证码的正确性
if real_sms_code.decode("utf-8") != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 判断用户的手机号是否注册过 为了减少对数据库的操作 和保存的时候一起操作
# 因为设置了mobile属性是唯一外键 若手机号注册过 则抛出异常
# 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, 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.获取参数--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():
"""注册
请求的参数： 手机号、短信验证码、密码、确认密码
参数格式：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, 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="短信验证码失效")
# 删除redis中的短信验证码，防止重复使用校验
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="短信验证码错误")
# 判断用户的手机号是否注册过
# 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="手机号已存在")
# 盐值 salt
# 注册
# 用户1 password="******" + "abc" sha1 abc$hxosifodfdoshfosdhfso
# 用户2 password="******" + "def" sha1 def$dfhsoicoshdoshfosidfs
#
# 用户登录 password ="******" "abc" sha256 sha1 hxosufodsofdihsofho
# 保存用户的注册数据到数据库中
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中
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# 返回结果
return jsonify(errno=RET.OK, errmsg="注册成功")
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")
# 校验参数
if not all([mobile, sms_code, password]):
resp = {"errno": RET.PARAMERR, "errmsg": "参数不完整"}
return jsonify(resp)
# 判断手机格式
if not re.match(r"1[345678]\d{9}", mobile):
resp = {"erron": 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 = {"erron": RET.DBERR, "errmsg": "查询验证码错误"}
return jsonify(resp)
# 判断短信验证码是否过期
if real_sms_code is None:
resp = {"errno": RET.NODATA, "errmsg": "短信验证码过期"}
return jsonify(resp)
# 对于用户输入的短信验证码是否正确
if real_sms_code != sms_code:
resp = {"errno": RET.DATAERR, "errmsg": "短信验证码错误"}
return jsonify(resp)
# 删除短信验证码
# 当验证码验证通过之后删除
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 删除短信验证码
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 = {
# "errno": RET.DBERR,
# "errmsg": "数据库异常"
# }
# return jsonify(resp)
#
# if user is not None:
# # 表示已经注册过
# resp = {
# "errno": 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)
# 当出现异常时,回滚
db.session.rollback()
# 表示已经注册过
resp = {"errno": RET.DATAEXIST, "errmsg": "用户手机号已经注册"}
return jsonify(resp)
# 利用session记录用户的登录状态
session["user_id"] = user.id
session["user_name"] = mobile
session["mobile"] = mobile
# 返回值
resp = {"errno": RET.OK, "errmsg": "注册成功"}
return jsonify(resp)
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():
"""
用户注册功能:
1. 接收参数(手机号，短信验证码，密码)并进行参数校验
2. 从redis中获取短信验证码(如果取不到，说明短信验证码已过期)
3. 对比短信验证码，如果一致
4. 创建User对象并保存注册用户的信息
5. 把注册用户的信息添加进数据库
6. 返回应答，注册成功
"""
# 1. 接收参数(手机号，短信验证码，密码)并进行参数校验
req_dict = request.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]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
if not re.match(r"^1[35789]\d{9}$", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
# 2. 从redis中获取短信验证码(如果取不到，说明短信验证码已过期)
try:
real_sms_code = redis_store.get("smscode:%s" % 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="短信验证码已过期")
# 3. 对比短信验证码，如果一致
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 判断手机号是否已经被注册
try:
user = User.query.filter(User.mobile == mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询用户信息失败")
if user:
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已注册")
# 4. 创建User对象并保存注册用户的信息
user = User()
user.mobile = mobile
user.name = mobile
user.password = password
# 5. 把注册用户的信息添加进数据库
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["user_id"] = user.id
session["username"] = user.name
session["mobile"] = mobile
# 6. 返回应答，注册成功
return jsonify(errno=RET.OK, errmsg="注册成功")
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():
# 获取请求的json数据，转换为字典
req_dict = request.get_json()
mobile = req_dict.get('mobile')
sms_code = req_dict.get('sms_code')
password = req_dict.get('passwd')
password2 = req_dict.get('passwd2')
# 校验参数完整性
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 password2 != password:
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
# 此处可以继续添加密码长度格式等校验条件
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="redis数据库异常")
# 判断短信验证码是否失效
if not redis_store:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(mobile))
except Exception as e:
current_app.logger.error(e)
# 判断用户填写短信验证码是否一致
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:
# # 表示手机号已存在
# return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 判断并添加用户信息
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="手机号已存在")
except Exception as e:
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():
"""
注册
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())
