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():
"""
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():
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 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():
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 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():
"""
用户注册功能:
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():
"""实现注册
1.获取请求参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器的短信验证码
4.并与客户端传入的验证码比较,如果一致
5.创建User模型类对象
6.保存注册数据到数据库
7.响应结果
"""
# 1.获取请求参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_clinet = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_clinet, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 3.获取服务器的短信验证码
try:
sms_code_server = redis_store.get('Mobile:' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
# 判断数据是否为空
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.并与客户端传入的验证码比较,如果一致
if sms_code_server != sms_code_clinet:
return jsonify(errno=RET.DATAERR, errmsg='输入验证码有误')
# 5.创建User模型类对象
user = User()
# 注册时，默认手机号就是用户名，如果后面需要更换用户名，也是提供的有接口和界面
user.name = mobile
user.mobile = mobile
# 密码需要加密后才能存储
# user.password_hash = '加密后的密码'
user.password = password
# 6.保存注册数据到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存注册数据失败')
# 实现注册成功即登陆:记住状态保持信息即可
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7.响应结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""
注册:
简单提示：
获取参数
校验参数
查询数据
模型对象
提交数据
保存状态
返回结果
:return:
"""
# TODO 完成注册代码
params_dict = request.json
mobile = params_dict.get("mobile")
password = params_dict.get("password")
sms_code = params_dict.get("sms_code")
if not all([mobile, password, sms_code]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 验证手机号的格式
if not re.match("^1[356789][0-9]{9}$", mobile):
return jsonify(erron=RET.PARAMERR, errmsg="手机格式有误")
# 查询数据库，是否存在该手机号
try:
user = User.query.filter_by(mobile=mobile).first()
if user:
return jsonify(errno=RET.DATAEXIST, errmsg="用户已存在")
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据库异常')
# 根据手机号的验证编码，取出数据库的验证码，进行比较
try:
real_sms_code = redis_store.get('SMSCode_' + mobile)
if real_sms_code:
redis_store.delete("sms_%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="短信验证码过期")
if sms_code != real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg="短信验证码填写错误")
# 创建用户对象 给对应属性赋值
user = User()
user.mobile = mobile
user.name = mobile
# 需要将加密的密码加密
user.password = password
# 记录一下最后一次保存的登录时间
user.create_time = datetime.now()
# 保存数据
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["mobile"] = user.mobile
session["name"] = user.name
# 返回响应对象
return jsonify(errno=RET.OK, errmsg="注册成功！")
def register():
"""
1. 获取参数
2. 判断是否为空
3. 获取redis保存的短信验证码
4. 验证对比,并删除验证码
5. 将用户数据保存到数据库,并缓存到Session
6. 返回用户信息
:return:
"""
# 1. 获取参数
dict_data = request.json
mobile = dict_data.get("mobile")
sms_code = dict_data.get("phoneCode")
password = dict_data.get("password")
# 2. 判断是否为空
if not all([mobile,sms_code,password]):
return jsonify(errno=RET.PARAMERR,errmsg="参数不完整")
if not re.match(r"1[35678]\d{9}",mobile):
return jsonify(errno=RET.DATAERR,errmsg="手机号格式错误")
# 3. 获取redis保存的短信验证码
try:
redis_sms_code = redis_store.get('SMSCode_'+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.DATAERR, errmsg='短信验证码已过期')
# 4. 验证对比,并删除验证码
# print sms_code
# print type(sms_code)
# print redis_sms_code
if sms_code != redis_sms_code:
return jsonify(errno=RET.DATAERR,errmsg="短信验证错误")
# 5.删除短信验证码
try:
redis_store.delete('SMSCode_'+mobile)
except Exception as e:
# logging.error(e)
current_app.logger.error(e)
user = User()
user.name = mobile # 用户名默认是手机号
user.mobile = mobile
# TODO 手机号稍后处理, 不能以明文的形式存储
# print user.password_hash
user.password_hash = generate_password_hash(password)
print user.password_hash
# 7.保存到数据库中
try:
print "正在保存用户信息...."
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="用户保存异常")
# 8.可以记录用户登录状态(通过session)
session["user_id"] = user.id
session["user_name"] = user.name
session["mobile"] = user.mobile
# 9.返回注册的结果给前端
print "注册成功"
return jsonify(errno=RET.OK,errmsg="注册成功")
def register():
"""
用户注册功能
1.接受参数（手机号，短信验证码，密码）并进行参数校验
2.从redis中获取短信验证码（如果取不到，说明短信验证码过期）
3.对比短信验证码，
4.如果一致，创建User对象并保存注册用户的信息
5.把注册用户的信息添加进数据库
6.返回应答，注册成功
:return:
"""
# 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
# todo: 注册码加密
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='保存注册用户信息失败')
# 6.记住用户登录的状态
session['user_id'] = user.id
session['username'] = user.name
session['mobile'] = user.mobile
# 7.返回应答，注册成功
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
# 注册视图
'''
该接口做用户注册
1.图片验证码的生成,显示---使用工具包
'''
# 1.获取参数,手机号,密码,用户短信验证码,uuid
# 2.判断参数完整性
# 3.获取服务器存储的短信验证码,比较两个验证码
# 4.验证码相同就创建新用户---添加数据,保存数据
# 5.返回结果
# 1.获取参数
json_dict = request.json #获取前端传递的json数据转换成字典类型数据
mobile = json_dict.get('mobile') # 获取手机号码
psw = json_dict.get('password') # 获取密码
# uuid = json_dict.get('uuid')
sms_code_client = json_dict.get('sms_code')
# 2.判断完整性
if not all([mobile,psw,sms_code_client]):
jsonify(errno=RET.DATAERR, errmsg=u'数据不完整')
# 判断手机号码的有效性
# if User.query.filter(User.mobile == mobile).first():
# return jsonify(errno=RET.DATAEXIST, errmsg='用户已经存在')
user = None
try:
user = User.query.filter(User.mobile == mobile).first()
except Exception as e:
current_app.logger.debug(e)
if user:
return jsonify(errno=RET. USERERR , errmsg=u'该手机号已注册')
# 3.获取服务器存储的短信验证码 拼接key
sms_key = 'sms:%s' %mobile
try:
sms_code_server = redis_store.get(sms_key)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET. NODATA , errmsg=u'找不到验证码')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg=u'短信验证码不存在')
# 4.判断短信验证码是否一致
if sms_code_server != sms_code_client:
jsonify(errno=RET.DATAERR , errmsg=u'短信验证码不正确')
# 5.验证码相同就创建新用户
user = User()
user.name = mobile
user.mobile = mobile
# user.password_hash = psw
user.password = psw # 这里是设置了一个password属性来接受明文密码 然后在models进行加密
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=u'用户创建失败')
try:
session['user_id'] = user.id
session['user_mobile'] = user.mobile
session['user_name'] = user.name
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg=u'登陆状态保存失败')
return jsonify(errno=RET.OK , errmsg=u'用户创建成功')
def register():
"""
注册
:param: 手机号，短信验证码，密码，确认密码
: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, 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='两次密码不一致')
# 从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)
# 判断用户填写的短信验证码是否正确
# 从redis中取出的是bytes类型，需要解码
real_sms_code = real_sms_code.decode()
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
# 保存用户注册数据到数据库
user = User()
user.name = mobile
user.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.DATAERR, errmsg='查询数据库异常')
# 保存登录状态到session
session['name'] = mobile
session['mobile'] = mobile
session['user_id'] = user.id
return jsonify(errno=RET.OK, errmsg='注册成功')
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[356789]\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
# todo:密码加密
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='保存用户信息失败')
# 记住用户登陆状态
session['user_id'] = user.id
session['user_name'] = user.name
session['mobile'] = mobile
# 6、返回应答，注册成功
return jsonify(errno=RET.OK, errmsg='注册成功')
