def register():
"""注册
1.获取注册参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器存储的短信验证码
4.与客户端传入的短信验证码对比
5.如果对比成功，就创建用户模型User对象，并给属性赋值
6.将模型属性写入到数据库
7.响应注册结果
"""
# 1.获取注册参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
# 当我们后端确定前端发来的是json字符串时
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1([358][0-9]|4[579]|66|7[0135678]|9[89])[0-9]{8}$',
mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 3.获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.与客户端传入的短信验证码对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 5.如果对比成功，就创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile # 默认把手机号作为用户名，如果不喜欢，后面会提供修改用户名的接口
# 需要将密码加密后保存到数据库:调用password属性的setter方法
user.password = password
# 6.将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户注册数据失败')
# 7.响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""实现注册
1.获取请求参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器的短信验证码
4.并与客户端传入的验证码比较,如果一致
5.创建User模型类对象
6.保存注册数据到数据库
7.响应结果
"""
# 1.获取请求参数：手机号，短信验证码，密码
json_dict = request.json
# json_str = request.data
# json_dict = json.loads(json_str)
mobile = json_dict.get('mobile')
mes_code = json_dict.get('mes_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, mes_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 3.匹配手机号
# 4.对短信验证码进行验证
try:
redis_code = redis_store.get('Mobile:' + mobile)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not redis_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
if mes_code != redis_code:
return jsonify(errno=RET.DATAERR, errmsg='输入验证码有误')
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该⼿手机号已注册')
# 5.创建用户类的模型类对象（存储于数据库中）
user = User()
user.name = mobile
user.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='保存注册数据失败')
# 注册成功后保存用户状态保持信息到session
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 6.给前端响应数据
return jsonify(errno=RET.OK, errmsg='保存注册数据成功')
def register_new_user():
"""处理注册逻辑的视图"""
# 0.获取请求报文
datas_dict = request.json
# 1.获取参数:手手机号,短信验证码,密码
mobile = datas_dict.get('mobile')
smscode = datas_dict.get('smscode')
password = datas_dict.get('password')
print datas_dict
# 2.判断参数是否缺少
if not all([mobile, smscode, password]):
return jsonify(error_no=RET.PARAMERR, error_msg=u'缺少参数')
if re.match(r'^1[2345678][\d]{9}&', mobile):
return jsonify(error_no=RET.PARAMERR, error_msg=u'手机号格式不正确！')
# 3.获取服务器器端短信验证码
try:
print 'Mobile:' + mobile
smscode_server = redis_store.get('Mobile:' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_no=RET.DBERR, error_msg=u'获取服务器短信验证码错误')
# 4.对比比短信验证码
if smscode != smscode_server:
print smscode_server, smscode
return jsonify(error_no=RET.PARAMERR, error_msg=u'短信验证码错误！')
# 判断该手机是否已经注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(error_no=RET.DATAEXIST, error_msg=u'用户已注册！')
# 5.初始化User模型,保存相关数据
user = User()
user.name = mobile
user.mobile = mobile
# TODO: 保存加密后的密码暂缓实现
user.password = password
# 6.将User模型存储到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(error_no=RET.DBERR, error_msg=u'保存注册数据失败！')
# 7.把登陆状态写入session
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 8.响应结果:状态码和错误信息或用用户数据
print user
return jsonify(error_no=RET.OK, error_msg=u'注册成功！')
def register():
"""
注册用户功能
2.从redis中获取短信验证码（如果获取不到说明短信验证码过期）
3.对比短信验证码
4.创建用户信息到数据库
5.返回应答，提示注册成功
:return:
"""
# 1.获取请求中的参数
req_dict = request.json
mobile = req_dict.get('mobile')
phonecode = req_dict.get('phonecode')
password = req_dict.get('password')
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 2. 从redis中获取短信验证码（如果获取不到，短信验证码过期)
try:
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 sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
# 3. 对比短信验证码，如果一致
if sms_code != phonecode:
return jsonify(errno=RET.DATAERR, 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['user_name'] = user.name
session['mobile'] = user.mobile
# 6. 返回应答，告诉注册成功
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""
1.获取参数并判断是否为空
2.取到本地的验证码
3.将本地验证码和传入的短信进行对比
4.创建用户模型,并设置数据,并添加到数据库
5.返回结果
:return:
"""
# 1. 获取参数并判断是否有值
data_dict = request.json
mobile = data_dict.get('mobile')
phonecode = data_dict.get('phonecode')
password = data_dict.get('password')
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不全')
# 2.取到本地的验证码
try:
sms_code = redis_store.get('SMS_' + mobile)
redis_store.delete('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.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.DBERR, errmsg='保存数据失败')
# 保存登录状态
session['name'] = mobile
session['mobile'] = mobile
session['password'] = password
# 5.返回结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""
注册功能实现
1. 获取参数（手机号，短信验证码，密码），并校验
2. redis读取短信验证码，
3. 对比短信验证码
4. 创建用户，并保存用户信息
5. 添加信息到数据库
6. 返回应答
:return:
"""
# 1. 获取参数（手机号，短信验证码，密码），并校验
req_dict = request.json
mobile = req_dict.get('mobile')
phonecode = req_dict.get('phonecode')
password = req_dict.get('password')
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 2. redis读取短信验证码，
try:
sms_code = redis_store.get('sms_code:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.NODATA, errmsg='查询短信验证码失败')
# 3. 对比短信验证码
if sms_code != phonecode:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
# 验证手机号是否已经注册
try:
user = User.query.filter(User.mobile == mobile).first()
except Exception as e:
current_app.logger.error(e)
if user:
return jsonify(errno=RET.DATAERR, errmsg='手机已注册')
# 4. 创建用户，并保存用户信息
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, errsmg='保存用户信息失败')
# 6. 返回应答
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""注册用户
1. 获取参数 phone_code，mobile, password
2. 校验参数完整性 手机合法性
3. 使用mobile查询redis， 比较phone_code
4. 查询数据库，确认mobile是否已注册
5. 创建用户记录，保存数据库
6. 默认登陆用户
7. 返回响应
"""
# 1. 获取参数 phone_code，mobile, password
request_json_dict = request.json
mobile = request_json_dict.get('mobile')
phone_code = request_json_dict.get('phone_code')
password = request_json_dict.get('password')
# 2. 校验参数完整性 手机合法性
if not all([mobile, phone_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg=u'参数不完整')
if not re.match(r'1[345678][0-9]{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg=u'手机号格式不合法')
# 3. 使用mobile查询redis， 比较phone_code
try:
phone_code_server = redis_client.get('Mobile:' + mobile)
if not phone_code_server:
return jsonify(errno=RET.NODATA, errmsg=u'手机验证码不存在')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'手机验证码查询失败')
if phone_code_server != phone_code:
return jsonify(errno=RET.PARAMERR, errmsg=u'手机验证码不正确')
# 4. 查询数据库，确认mobile是否已注册
try:
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.PARAMERR, errmsg=u'手机号已注册')
except Exception as e:
current_app.logger.debug(e)
# 5. 创建用户记录，保存数据库
try:
user = User()
user.mobile = mobile
user.name = mobile
user.password = password
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'用户保存数据库失败')
# 6. 默认登陆用户
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7. 返回响应
return jsonify(errno=RET.OK, errmsg=u'注册成功')
def register():
"""
1.获取json参数,并转换为python字典,并校验参数
2.取到真实的短信验证码
3.对比短信验证码是否与真实验证码匹配
4.初始化user,保存相关数据
5.将数据存储到数据库
6.给出响应
:return:
"""
# 1.获取json参数
data_dict = request.json
mobile = data_dict.get('mobile')
phonecode = data_dict.get('phonecode')
password = data_dict.get('password')
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 2.取到真实的短信验证码
try:
real_phonecode = redis_store.get(mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not real_phonecode:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已经过期')
# 3.进行短信验证码的对比
if real_phonecode != phonecode:
return jsonify(errno=RET.DATAERR, 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='保存用户数据失败')
# 6.给出响应
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
'''
1. 获取参数
2. 校验参数
3. 对比验证码, 密码是否合法
4. 保存用户
5. 保存用户登录状态返回数据
:return:
'''
data_dict = request.json
mobile = data_dict['mobile']
phonecode = data_dict['phonecode']
password = data_dict['password']
password2 = data_dict['password2']
if not all([mobile, phonecode, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg='数据不完整')
try:
real_phonecode = redis_store.get('SMS_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='短信验证码查询错误')
if not real_phonecode:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
if real_phonecode != phonecode:
return jsonify(errno=RET.DBERR, errmsg='短信验证码错误')
if password != password:
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 Exception as e:
current_app.logger.error(e)
db.rollback()
return jsonify(errno=RET.DBERR, errmsg='数据保存错误')
# 保存登录状态
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
mobile = request.form.get("mobile")
phoneCode = request.form.get("phoneCode")
password = request.form.get("password")
password2 = request.form.get("password2")
if not all([mobile, phoneCode, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
try:
sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
if sms_code is None:
return jsonify(errno=RET.NODATA, errmsg=error_map[RET.NODATA])
if sms_code != phoneCode:
return jsonify(errno=RET.DATAERR, errmsg=error_map[RET.DATAERR])
try:
user = User(name=mobile, mobile=mobile)
user.password = password
db.session.add(user)
db.session.commit()
except IntegrityError as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DATAEXIST, errmsg=error_map[RET.DATAEXIST])
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
session["name"] = user.mobile
session["mobile"] = user.mobile
session["user_id"] = user.id
resp = make_response(jsonify(errno=RET.OK, errmsg=error_map[RET.OK]))
resp.set_cookie("mobile", user.mobile)
resp.set_cookie("user_id", str(user.id))
return resp
def register():
"""
1. 获取参数和判断是否有值
2. 从redis中获取指定手机号对应的短信验证码的
3. 校验验证码
4. 初始化 user 模型，并设置数据并添加到数据库
5. 保存当前用户的状态
6. 返回注册的结果
:return:
"""
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 = redis_store.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
# aODO: 对密码进行处理
# 对密码进行处理
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="数据保存错误")
return jsonify(errno=RET.OK, errmsg="注册成功")
def user_register():
register_dict = request.form
mobile = register_dict.get('mobile')
password = register_dict.get('password')
password2 = register_dict.get('password2')
if not all([mobile, password, password2]):
return jsonify(status_code.USER_REGISTER_PARAMS_ERROR)
if not re.match(r'^1[34578]\d{9}$', mobile):
return jsonify(status_code.USER_REGISTER_MOBILE_ERROR)
if User.query.filter(User.phone == mobile).count():
return jsonify(status_code.USER_REGISTER_MOBILE_IS_EXISTS)
if password != password2:
return jsonify(status_code.USER_REGISTER_PASSWORD_IS_ERROR)
user = User()
user.phone = mobile
user.name = mobile
user.password = password
try:
user.add_update()
return jsonify(status_code.SUCCESS)
except Exception as e:
return jsonify(status_code.DATABASE_ERROR)
def register():
req_dict = request.json
mobile = req_dict.get('mobile')
phonecode = req_dict.get('phonecode')
password = req_dict.get('password')
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
try:
sms_code = redis_store.get('sms_code:%s' % mobile)
except Exception as e:
current_app.logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
if sms_code != phonecode:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
try:
user = User.query.filter(User.mobile == mobile).first()
except Exception as e:
current_app.logger.error(e)
if user:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已被注册')
user = User()
user.mobile = mobile
user.name = mobile
# todo:注册用户密码加密
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.loggging.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存用户信息失败')
session['user_id'] = user.id
session['username'] = user.name
session['mobile'] = user.mobile
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""
注册逻辑
1. 获取参数：手机号, 短信验证码, 密码,
2. 取到真实的短信验证码
3. 进行验证码的对比
4. 初始化User模型，保存相关数据
5. 将user模型存到数据库中
6. 给出响应：{"errno": "0", "errmsg": "注册成功"}
:return:
"""
# 1. 获取参数：手机号, 短信验证码, 密码,
data_dict = request.json
mobile = data_dict.get("mobile")
phonecode = data_dict.get("phonecode")
password = data_dict.get("password")
# 判断参数是否都有值
if not all([mobile, phonecode, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 2. 取到真实的短信验证码
try:
real_phonecode = redis_store.get("Mobile:" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询短信验证码失败")
if not real_phonecode:
return jsonify(errno=RET.NODATA, errmsg="短信验证码过期")
# 3. 进行验证码的对比
if phonecode != real_phonecode:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码输入错误")
# 3.1 判断当前手机是已经被注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg="该手机号已被注册")
# 4. 初始化User模型，保存相关数据
user = User()
user.mobile = mobile
user.name = mobile
# 保存密码
user.password = password
# 5. 将user模型存到数据库中
try:
db.session.add(user)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存用户数据失败")
# 保存当前用户信息到session
session["user_id"] = user.id
session["name"] = user.name
session["mobile"] = user.mobile
# 6. 给出响应：{"errno": "0", "errmsg": "注册成功"}
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
"""注册
1.获取注册参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器存储的短信验证码
4.与客户端传入的短信验证码对比
5.如果对比成功，就创建用户模型User对象，并给属性赋值
6.将模型属性写入到数据库
7.响应注册结果
"""
# 1.获取注册参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
json_dict = request.get_json()
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 手机格式
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 检测手机号是否注册过
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已存在')
# 3.获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.与客户端传入的短信验证码对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 5.如果对比成功，就创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile
user.password = password
# 6.将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
logging.error(e)
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存用户数据失败')
# 注册即登录，也就是保存注册时生成的数据
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7.响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""
注册
1.获取用户的手机号码 密码 短信验证码
2.判断参数是否缺少
3.获取服务器存储的验证码
4.服务器的验证码与客户端的验证码进行对比
5.如果对比成功，则创建用户模型User对象，并给属性赋值
6.将属性写入数据库
7.响应注册结果
"""
#获取用户的手机号码 密码 短信验证码
#有3种方法获取前端ajax发来的json字符串
#1. # json_str = request.data
# json_dict = json.loads(json_str)
#下面两种要确保发来的数据是json字符串
#2.json_dict = request.get_json()
#第3种
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
#2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1[3456789][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机格式错误')
#3.获取服务器存储的验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
current_app.logger.debug(sms_code_server)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
#4.服务器的验证码与客户端的验证码进行对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输出错误')
#判断手机后是否已经存在
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已经存在')
#5.如果对比成功，则创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile
#需要将密码加密后保存到数据库：调用password属性的setter方法
user.password = password
#6.将属性写入数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户信息失败')
session['user_id'] = user.id
session['user_name'] = user.name
#7.响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""用户注册
请求的参数：手机号，短信验证码，密码，确认密码
参数各式：json
"""
# 获取请求的json数据，返回字典
request_dict = request.get_json()
# 获取参数
mobile = request_dict.get("mobile")
sms_code = request_dict.get("sms_code")
password = request_dict.get("password")
password2 = request_dict.get("password2")
# 校验参数
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
if not re.match(r"1[3-9]\d{9}", mobile):
# 格式不对
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误")
if password != password2:
# 两次密码不一致
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
# 从Redis中取出短信验证码
try:
real_sms_code = redis_store.get("sms_code_{}".format(mobile))
if real_sms_code is not None:
real_sms_code = redis_store.get(
"sms_code_{}".format(mobile)).decode("UTF-8")
except Exception as ex:
current_app.logger.error(ex)
return jsonify(errno=RET.DBERR, errmsg="读取真实短信验证码异常")
# 判断短信验证码是否过期
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
# 判断用户填写的短信验证码的正确性
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 删除Redis中的短信验证码，防止重复使用校验
try:
redis_store.delete("sms_code_{}".format(mobile))
except Exception as ex:
current_app.logger.error(ex)
# 判断用户的手机号是否注册过
# try:
# user = User.query.filter_by(mobile=mobile).first()
# except Exception as ex:
# current_app.logger.error(ex)
# return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# else:
# if user is not None:
# # 手机号已存在
# return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 保存的用户的数据到数据库中
user = User(name=mobile, mobile=mobile)
# user.generate_password_hash(origin_password=password)
user.password = password # 设置属性
try:
db.session.add(user)
db.session.commit()
except IntegrityError as ie:
# 事务回滚
db.session.rollback()
# 表示手机号出现了重复值，即手机号已经注册过
current_app.logger.error(ie)
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
except Exception as ex:
current_app.logger.error(ex)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
# 保存登录状态到Session中
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# 返回结果
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
"""注册
1.获取注册参数：手机号码，短信验证码，密码
2.判断参数是否缺少
3.获取服务器储存的短信验证码
4.与客户端传入的短信验证码做对比
5.如果成功，就创建用户模型User对象，并给属性赋值
6.将模型属性写入到数据库
7.响应注册结果
"""
# 1.获取注册参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
# 当我们后端确定前端发来的是json字符串时
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 3.获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.与客户端传入的短信验证码对比
if sms_code_server != sms_code_client:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 判断用户是否已注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg="该手机号已经注册")
# 5.如果对比成功，就创建用户模型User对象，并给属性赋值
user = User()
user.mobile = mobile
user.name = mobile # 默认把手机号作为用户名，如果不喜欢，后面会提供修改用户名的接口
# TODO:需要将密码加密后保存到数据库:调用password属性的setter方法
user.password = password
# 6.将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户注册数据失败')
# 注册即登录，也就是保存注册时生成的状态保持数据
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7.响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
""""用户注册
请求的参数: 手机号, 验证码, 密码, 确认密码
参数格式: json
"""
# 获取参数:
# 获取请求的json数据,返回字典
req_dict = request.get_json()
mobile = req_dict.get('mobile')
sms_code = req_dict.get('sms_code')
password = req_dict.get('password')
password2 = req_dict.get('password2')
print(mobile, sms_code, password, password2)
# 校验参数:
# 校验参数是否完整
if not all([mobile, sms_code, password, password2]):
# 参数不完整
return jsonify(errno=RET.PARAMERR, errmsg="参数信息不完整")
# 校验手机格式是否正确
if not re.match(r'1[34578]\d{9}', mobile):
# 手机格式不正确
return jsonify(errno=RET.PARAMERR, errmsg="手机格式不正确")
# 校验两次密码是否一致
if password != password2:
# 两次密码不一致
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
# 业务逻辑处理:
# 从redis中取出短信验证码
try:
real_sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
# 记录日志
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="读取真实短信验证码异常")
# 判断从redis中取出的短信验证码是否过期
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
# 删除redis中的短信验证码,防止重复使用校验
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
# 记录日志
current_app.logger.error(e)
# 判断用户填写的短信验证码与从redis中取出的短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 判断用户手机号是否注册过
# try:
# user = User.query.filter_by(mobile=mobile).first()
# except Exception as e:
# # 记录日志
# current_app.logger.error(e)
# return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# else:
# if user is not None:
# # 表示手机号存在
# return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
# 保存用户注册信息到数据库
# password_hash = generate_password_hash(password) # 密码加密
# user = User(name=mobile, password_hash=password_hash, mobile=mobile)
user = User(name=mobile, password_hash=password, mobile=mobile)
user.password = password # 设置密码属性,即给密码进行加密
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
# 数据库操作错误后的事务回滚
db.session.rollback()
# 记录日志, 表示手机号出现重复值,即手机号已被注册
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
except Exception as e:
# 数据库操作错误后的事务回滚
db.session.rollback()
# 记录日志
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
# 保存登录状态到session中
session['name'] = mobile
session['mobile'] = mobile
session['user_id'] = user.id
# 返回值:
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
"""实现注册
1.获取请求参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器的短信验证码
4.并与客户端传入的验证码比较,如果一致
5.创建User模型类对象
6.保存注册数据到数据库
7.响应结果
"""
# 1.获取请求参数：手机号，短信验证码，密码
# json_str = request.data
# json_dict = json.loads(json_str)
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
# 2.判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 3.获取服务器的短信验证码
try:
sms_code_server = redis_store.get('Mobile:' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
# 判断数据是否为空
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4.并与客户端传入的验证码比较,如果一致
if sms_code_server != sms_code_client:
return jsonify(errno=RET.DATAERR, errmsg='输入验证码有误')
# 判断该用户是否已经注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='用户已注册')
# 5.创建User模型类对象
user = User()
# 注册时，默认手机号就是用户名，如果后面需要更换用户名，也是提供的有接口和界面
user.name = mobile
user.mobile = mobile
# 密码需要加密后才能存储
# user.password_hash = '加密后的密码'
user.password = password
# 6.保存注册数据到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存注册数据失败')
# 实现注册成功即登录：记住状态保持信息即可
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7.响应结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
""""注册
1，获取注册参数：手机号，短信验证码，密码
2，判断参数是否缺少
3，获取服务器存储的短信验证码
4，与客户端传入的短信验证码对比
5，对比成功，创建User对象，给属性赋值
6，将模型属性写入到数据库
7，响应注册结果
"""
# 1，获取注册参数：手机号，短信验证码，密码
# 当确定前端发来的是json字符串
json_dict = request.get_json()
mobile = json_dict.get('mobile')
sms_code_client = json_dict.get('sms_code')
password = json_dict.get('password')
print '11111111111'
print mobile
print u'短信验证码为：' + sms_code_client
print password
print '22222222222'
# 2，判断参数是否缺少
if not all([mobile, sms_code_client, password]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 3，获取服务器存储的短信验证码
try:
sms_code_server = redis_store.get('SMS:%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询短信验证码失败')
if not sms_code_server:
return jsonify(errno=RET.NODATA, errmsg='短信验证码不存在')
# 4，与客户端传入的短信验证码对比
if sms_code_client != sms_code_server:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入有误')
# 判断该手机号是否注册
if User.query.filter(User.mobile == mobile).first():
return jsonify(errno=RET.DATAEXIST, errmsg='该手机号已注册')
# 5，对比成功，创建User对象，给属性赋值
user = User()
user.mobile = mobile
user.name = mobile # 后面会有改用户名的逻辑
# TODO 密码需要加密后加入到数据库
# 调用password属性的setter方法
user.password = password
# 6，将模型属性写入到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户注册数据失败')
# 注册即登录
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 7，响应注册结果
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""注册
1.获取注册参数：手机号，短信验证码，密码
2.判断参数是否缺少
3.获取服务器存储的短信验证码
4.与客户端传入的短信验证码对比
5.如果对比成功，就创建用户模型User对象，并给属性赋值
6.将模型属性写入到数据库
7.响应注册结果
"""
# 获取注册参数：手机号，短信验证码，密码
# 拿到所有的数据，三种方法
# json_str = request.data
# json_dict = json.loads(json_str)
# 如果肯定传过来的是json数据，可以用以下两种简便的方法
# json_dict = request.get_json()
json_dict = request.json
mobile = json_dict.get('mobile')
sms_code = json_dict.get('sms_code')
password = json_dict.get('password')
# 判断参数是否缺少
if not all([mobile, sms_code, password]):
return jsonify(reeno=RET.PARAMERR, errmsg='缺少参数')
# 判断手机号是否符合格式
if not re.match(r'^1[345678][0-9]{9}$', mobile):
return jsonify(reeno=RET.PARAMERR, errmsg='手机还格式错误')
# 获取服务器短信验证码，有可能过期类获取不到
try:
sms_code_server = redis_strict.get('SMS：%s' % mobile.encode('utf-8'))
except Exception as e:
current_app.logger.error(e)
return jsonify(reeno=RET.DBERR, errmsg='获取服务器验证码错误')
# 对比用户输入的验证码，通过的话就进行注册功能
if sms_code != sms_code_server:
return jsonify(reeno=RET.PARAMERR, errmsg='短信验证码输入有误！！')
# 把用户信息保存到数据库，完成注册流程
user = User()
user.mobile = mobile
# 需要将密码加密后保存到数据库:调用password属性的setter方法,这里只是赋一个属性，并不是表中的字段
user.password = password
user.name = mobile
# 将对象保存到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
"""回滚操作"""
db.session.rollback()
return jsonify(reeno=RET.DBERR, errmsg='保存信息错误')
"""注册即登录，生成注册时数据的保持状态"""
session['user_id'] = user.id
session['name'] = user.name
session['mobile'] = user.mobile
# 注册成功，响应
return jsonify(reeno=RET.OK, errmsg='注册成功')
