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())