def login(): """ 用户登录 传递参数: 手机号 密码 格式: json :return: """ # 接收参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 判断参数是否完整 if not all([mobile, password]): return jsonify(errnum=RET.PARAMERR, errmsg=u"参数不完整") # 判断手机格式是否正确 if not re.match(r"1[345678]\d{9}", mobile): return jsonify(errnum=RET.PARAMERR, errms=u"手机格式不正确") # 输入错误5次, 封ip10分钟 # 查询ip user_ip = request.remote_addr try: access_num = redis_store.get("access_num_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_num is not None and int(access_num) >= LOGIN_ERROR_MAX_TIMES: return jsonify(errnum=RET.REQERR, errmsg=u"请求次数过多, 请稍后再试") # 根据手机号查询数据库, 判断有没该用户 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errnu=RET.DBERR, errmsg=u"获取用户信息失败") # 判断是否有该用户并且进行密码比对 if user is None or not user.check_password(password): # 记录登录次数, 并且设置有效期 try: redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errnum=RET.ROLEERR, errmsg=u"没有该用户") # 业务处理 # 保存用户登录状态到session中 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id # 返回应答 return jsonify(errnum=RET.OK, errmsg=u"登录成功")
def login(): """ 用户注册 参数:手机号 密码 格式:json :return: """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 参数完整的校验 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 手机号的格式 if not re.match(r"1[345678]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") # 判断错误次数是否超过限制,如果超过限制,则限制后续操作时间 # redis记录:"acess_num_"请求的IP: 次数 user_ip = request.remote_addr # 用户的IP地址 try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int(access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果验证失败,记录错误次数,反回信息 try: redis_store.incr("access_nums_%s" % user_ip) redis_store.expire("access_nums_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证相同成功,保存登录状态,在session中 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id # 登录成功删除redis登录错误次数记录 redis_store.delete("access_nums_%s" % user_ip) return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): ''' 登录 :return: ''' # 接收数据 (手机号, 密码) req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验数据 if not all([mobile, password]): return jsonify(error=RET.PARAMERR, errmsg="参数不完整") # 判断手机号是否符合 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(error=RET.PARAMERR, errmsg="手机格式错误") # 限制登录错误次数 redis "access_nums_ip": "次数" user_ip = request.remote_addr # 用户ip try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= current_app.config.get( "LOGIN_ERROR_MAX_TIMES"): return jsonify(error=RET.REQERR, errmsg="超过登录限制次数") # 手机号是否存在 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DBERR, errmsg="数据库查询错误") else: # 判断密码是否正确 if user is None or user.check_password_hash(password) is False: # 记录错误次数 try: # incr(name, amount=1) 默认自动+1, 如果为空,则初始化为0 redis_store.incr("access_nums_%s" % user_ip) # 设置限制时间 redis_store.expire( "access_nums_%s" % user_ip, current_app.config.get("LOGIN_ERROR_FORBID_TIME")) except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DATAERR, errmsg="用户名或密码错误") # 保存登录状态session session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id # reutnr OK return jsonify(error=RET.OK, errmsg="登录成功")
def login(): """登录模块""" #获取参数,用户的手机号码,密码 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") #校验参数 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") #判断手机号码的格式是否正确 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号码格式不正确") # 判断用户的登录次数防止用户暴力破解密码 #从redis 中获取错误次数 user_ip = request.remote_addr try: access_counts = redis_store.get("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: #如果有错误次数纪录,并且超过最大次数,直接返回 if access_counts is not None and int( access_counts) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(errno=RET.REQERR, errmsg="登录频繁") #查询数据库,判断用户的信息与密码是否正确 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户信息查询失败") if user is None or not user.check_password(password): #出现错误,开始累加错误次数 try: redis_store.incr("access_%s" % user_ip) redis_store.expire("access_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.LOGINERR, errmsg="用户名或者密码错误") #登陆成功,设置session #清除用户的登录错误次数 try: redis_store.delete("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) #保存用户的登录状态 session["user_id"] = user.id session["user_name"] = user.name session["mobile"] = user.mobile return jsonify(errno=RET.OK, errmsg="用户登录成功")
def login(): """ 用户登录 参数: 手机号、密码 :return: """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 参数完整的校验 if not all([mobile, password]): return jsonify(error=RET.PARAMERR, errmsg="参数不完整") # 手机号的格式 if not re.match(r"1[3456789]\d{9}", mobile): return jsonify(error=RET.PARAMERR, errmsg="手机格式错误") # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录: "access_nums_请求的ip": 次数 user_ip = request.remote_addr # 用户的ip地址 try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(error=RET.REQERR, errmsg="错误次数太多,请稍后再试") # 从数据中根据手机号查询用户的数据对象 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DBERR, errmsg="获取用户信息失败") if user is None: return jsonify(error=RET.DATAERR, errmsg="用户名或密码错误") # 用数据库的密码与用户填写的密码进行对比验证 if user is None or not user.check_password(password): # 验证失败,记录错误次数,返回信息 try: redis_store.incr("access_nums_%s" % user_ip) redis_store.expire("axxess_num_%s" % user_ip, constants.LOGIN_ERROR_DORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证相同成功,保持登录状态,在session中 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(error=RET.OK, errmsg="登录成功")
def login(): """用户登录 参数:手机号、密码 """ #获取参数 req_dict=request.get_json() mobile=req_dict.get('mobile') password=req_dict.get("password") print(mobile,password) #校验参数 #参数完整的校验 if not all([mobile,password]): return jsonify(errno=RET.PARAMERR,errmsg='参数不完整') # 手机号的格式 if not re.match(r"1[34578]\d{9}",mobile): return jsonify(errno=RET.PARAMERR,errmsg='手机号格式错误') #判断错误次数是否超过限制,如果超过限制,则返回 #redis记录:"access_nums_请求的ip":次数 user_ip=request.remote_addr #拿到用户的ip地址 try: # redis数据库的特性决定就算没有存这个进去也会返回一个None access_nums=redis_store.get("access_num_%s"%user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int(access_nums)>=constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR,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="获取用户信息失败") #用数据库的密码与用户填写的密码进行对比验证 print(user,user.password,password,type(user.password),type(password)) if user is None or user.password!=password: #如果验证失败,记录错误次数,返回信息 try: #redis的incr可以对字符串类型的数字数据进行加一操作,如果数据一开始不存在,则初始化为1 redis_store.incr("access_num_%s"%user_ip) redis_store.expire("access_num_%s"%user_ip,constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR,errmsg="用户名或密码错误") #如验证相同成功,保存登录状态,在session中 session['name']=user.name session['mobile']=user.mobile session['user_id']=user.id return jsonify(errno=RET.OK,errmsg="登陆成功")
def login(): """ 用户登录 参数:手机号,密码 :return: """ # 提取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 参数完整性校验 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 校验手机号的格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的手机号") # 判断错误次数是超过限制,如果超过限制,则返回 # redis记录:"access_nums_请求的ip地址":"次数" user_ip = request.remote_addr # 用户的ip地址 try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 记录错误次数 try: # redis的incr ,加一操作 redis_store.incr("access_nums_%s" % user_ip) # 设置有效期 redis_store.expire("access_nums_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) # 如果验证失败,记录错误次数,返回信息 return jsonify(errno=RET.DATAERR, errmsg="用户名或者密码错误") # 如果验证相同,保存登录状态,在session中 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """登录""" # 获取参数、用户手机号 密码 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 检验参数 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 判断手机号格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 判断用户的错误次数 # 从redis中获取错误次数 user_ip = request.remote_addr try: access_counts = redis_store.get("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: # 如果有错误次数记录,并且超过最大次数,直接返回 if access_counts is not None and int( access_counts) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 出现错误,累加错误次数 try: redis_store.incr("access_%s" % user_ip) redis_store.expire("access_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.LOGINERR, errmsg="用户名或密码失败") # 登录成功, # 清除用户的登录错误次数 try: redis_store.delete("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) # 保存用户的登录状态 session["user_id"] = user.id session["user_name"] = user.name session["mobile"] = user.mobile return jsonify(errno=RET.OK, errmsg="用户登录成功")
def login(): """登录""" # 获取参数, 用户名 密码 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 if not all([mobile, password]): resp = {"error_code": RET.PARAMERR, "errmsg": "参数不完整"} return jsonify(resp) if not re.match(r"1[34578]\d{9}", mobile): resp = {"error_code": RET.PARAMERR, "errmsg": "手机号格式错误"} return jsonify(resp) # 判断用户的错误次数 # 从redis中获取错误次数 user_ip = request.remote_addr try: access_count = redis_store.get("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_count is not None and int( access_count) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(error_code=RET.REQERR, errmsg="登录过于频繁") # 业务处理 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 and user.check_password(password): # 清除用户的登录错误此时 try: redis_store.delete("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) # 记录用户的登录状态 session["user_id"] = user.id session["username"] = user.name session["mobile"] = mobile resp = {"error_code": RET.OK, "errmsg": "登录成功"} return jsonify(resp) else: try: redis_store.incr("access_%s" % user_ip) redis_store.expire("access_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) resp = {"error_code": RET.LOGINERR, "errmsg": "用户名或密码错误"} return jsonify(resp)
def login(): '''登陆''' # 获取参数,用户手机号,密码 req_dict = request.get_json() mobile = req_dict.get('mobile') password = req_dict.get('password') # 校验参数 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg='参数不完整') # 判读手机号格式 if not re.match(r'1[34578]\d{9}', mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确') # 判断用户的错误次数,从redis中获取错误次数 user_ip = request.remote_addr print(user_ip) try: access_counts = redis_store.get('access_%s' % user_ip) except Exception as e: current_app.logger.error(e) else: # 如果有错误次数记录,并且超过最大次数,直接返回 if access_counts is not None and int( access_counts) > constants.LOGIN_ERROR_MAX_NUM: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 出现错误,累加错误次数 try: redis_store.incr('access_%s' % user_ip) redis_store.expire('access_%s' % user_ip, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.LOGINERR, errmsg='用户名或密码错误') # 登陆成功,清除用户的登陆错误次数 try: redis_store.delete('access_%s' % user_ip) except Exception as e: current_app.logger.error(e) # 保存用户的登陆状态 session['user_id'] = user.id session['user_name'] = user.name session['mobile'] = user.mobile return jsonify(errno=RET.OK, errmsg='用户登陆成功')
def login(): """ 用户登陆 参数:手机号,密码 json :return: """ # 获取参数 req_dict = request.get_json() print(req_dict) mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 参数完整的校验 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 手机号的格式 if not re.match('1[34578]\d{9}', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不完整") # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录: "access_nums_请求的IP": 次数 user_ip = request.remote_addr # 用户的IP try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果校验失败,记录错误次数,返回信息 try: redis_store.incr("access_nums_%s" % user_ip) redis_store.expire("access_nums_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证通过,保存登陆状态,在session中 session['name'] = user.name session['mobile'] = user.mobile session['user_id'] = user.id return jsonify(errno=RET.OK, errmsg="登陆成功")
def login(): """login """ # get parameters req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # check parameters if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="Parameter Incomplete") # phone number format if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="The format of mobile phone number is wrong") # Determine if the number of errors exceeded the limit user_ip = request.remote_addr # ip address try: access_nums = redis_store.get("access_num_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, errmsg="Too many errors, please try again later") # Query the user's data object from the database based on the phone number try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="Failed to obtain user information") # Use the database password and the user to fill in the password for comparison verification if user is None or not user.check_password(password): #If validation fails, log the number of errors and return a message try: # Redis incr can add one to string numeric data # initializing it to 1 if the data does not exist to begin with redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="Incorrect user name or password") # If the validation is equally successful, save the login status in the session session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="login successfully")
def login(): """ 用户登录 ::param: 手机号码,密码 :return: """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # > 完整性 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # > 手机号码的格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") # > 判断错误次数是否超过限制,如果超过则返回 # 获取用户IP user_ip = request.remote_addr try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或者密码错误") # 如果验证相同则成功,保存登录状态 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """ 登录函数——实现用户登录操作 请求参数:手机号, 密码 前端传递参数格式:json (后端数据库手机号和密码进行比对) :return:成功会失败的结果 """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 业务逻辑处理 # 检验数据完整 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 检验手机号格式 if not re.match(r"1[34689]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 判断用户登录错误次数,超过限制,则返回停止一下操作 # 使用redis存储用户登录次数,String类型 redis次数:"access_num_%s": 次数 user_ip = request.remote_addr # 获取用户IP地址 try: access_nums = redis_store.get("access_num_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: # 用户登录次数不是None而且错误次数超过限制数 if access_nums is not None and int(access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or user.check_password(password) is False: if user is None or not user.check_password(password): try: redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIMES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证通过,保存用户状态,返回结果 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): '''登录 请求参数:mobile、password 参数格式:json :return: ''' # 获取数据 req_dict = request.get_json() mobile = req_dict.get('mobile') password = req_dict.get('password') # 校验参数的完整性 if not all([mobile,password]): return jsonify(errno=RET.PARAMERR,errmsg='参数不完整') # 手机号的格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录: "access_nums_请求的ip": "次数" user_ip = request.remote_addr # 获取用户的ip地址 try: access_nums = redis_store.get("access_num_%s" % user_ip) except Exception as e: logging.error(e) else: if access_nums is not None and int(access_nums) >=constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, errmsg="错误次数过多,请稍后重试") # 查询数据库中是否存在该账号 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: logging.error(e) return jsonify(errno=RET.DBERR, errmsg="获取用户信息失败") # 使用数据库封装的函数检查用户的密码 if user is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: # redis的incr可以对字符串类型的数字数据进行加一操作,如果数据一开始不存在,则会初始化为1 redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip,constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: logging.error(e) # 用户名或者密码不正确 return jsonify(errno=RET.PWDERR,errmsg='用户名或密码不正确') # 如果验证成功,保存用户的登录状态在session中 session['name']=user.name session['mobile']=user.mobile session['user_id']=user.id return jsonify(errno=RET.OK,errmsg='登录成功')
def login(): """ 用户登录 参数: 手机号、密码, 格式:json """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 校验参数完整性 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 手机号格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.DBERR, errmsg="手机号格式错误") # 判断错误次数是否超限,如果超限,则返回 # redis 记录请求次数: “access_nums_请求的ip” user_ip = request.remote_addr # 用户的ip地址 try: access_nums = redis_store.get("sccess_nums_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: # redis的incr可以对字符串类型的数字数据进行加以操作,如果数据不存在则初始化为1 redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证成功,保存登录状态到session session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """ :param mobile :param password json格式 :return: """ # 接受参数 # 校验参数 req_dict = request.get_json() mobile = req_dict.get('mobile') pwd = req_dict.get('password') if not all([mobile, pwd]): return jsonify(errno=RET.PARAMERR, msg=u'用户名密码为空') # 判断手机号格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, msg=u'手机号格式错误') # 判断错误次数,超过次数限制,则返回 # access_nums_请求ip:次数 ip = request.remote_addr try: access_num = redis_store.get('access_nums_%s' % ip) except Exception as e: current_app.logger.error(e) else: if access_num is not None and int(access_num) >= constants.ACCESS_NUM: return jsonify(errno=RET.REQERR, msg=u'错误次数过多,请稍后再试') # 判断用户 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, msg=u'数据库错误') if user is None or not user.check_password_hash(pwd): print('=====================' + ip) try: redis_store.incr('access_nums_%s' % ip) redis_store.expire('access_nums_%s' % ip, constants.ERR_ACCESS_EXPIRE_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, msg=u'用户名或密码错误') # 保存登录状态到session session['name'] = user.name session['mobile'] = user.mobile session['user_id'] = user.id return jsonify(errno=RET.OK, msg=u'登录成功')
def login(): """用户登录 :param 手机号,密码 :json """ # 前端接受数据 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验数据 # 校验数据完整性 if not all([mobile, password]): return jsonify(errno=RET.DATAERR, errmsg="数据不完整") # 校验手机格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录: "access_nums_请求ip地址": 次数 user_ip = request.remote_addr # 用户ip try: access_nums = redis_store.get("access_nums_%s" % user_ip) except Exception as e: # current_app.logger.error(e) pass else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果验证失败,记录错误次数 try: redis_store.incr("access_nums_%s" % user_ip) redis_store.expire("access_nums_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIMES) except Exception as e: current_app.logger.error(e) pass return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 记录用户登录状态 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): logging = Use_Loggin() # 参数提取 reqs_dice = request.get_json() mobile = reqs_dice.get("mobile") pwd = reqs_dice.get("password") # 参数校验 if not all([mobile, pwd]): return jsonify(error_num=RET.PARAMERR, errmsg="参数不完整") mobile_re = re.match(r'1[34578]\d{9}', mobile) if mobile_re == None: return jsonify(error_num=RET.PARAMERR, errmsg="手机号格式错误") # 判断错误次数, 保存到redis中, 时间限制 try: user_ip = request.remote_addr # "access_nums_ip地址": "次数" access_conut = redis_store.get("access_nums_%s" % user_ip) except Exception as e: logging.warning("警告: redis查询用户ip地址次数错误, 这里不限制访问, 让用户继续访问") else: if access_conut != None: if int(access_conut.decode( 'utf-8')) >= constants.LOGIN_MUNS_COUNTS: return jsonify(error_num=RET.REQERR, errmsg="请求次数过于频繁") else: pass # 比对数据库账号密码 try: user = User.query.filter_by(mobile=mobile).first() except: logging.error("错误: 数据库查询错误") return jsonify(error_num=RET.DATAERR, errmsg="获取用户信息失败") # 如果输入错误, 记录错误次数, 次数过多, 封ip if user is None or not user.check_pwd(pwd): # 如果找不到用户 or 密码 返回错误信息 try: # 额外配置, 错误后计数访问主机的ip地址 redis_store.incr("access_nums_%s" % user_ip, amount=1) redis_store.expire("access_nums_%s" % user_ip, time=constants.LOGIN_MUNS_NOTIME) except: pass # 因为用户名或者密码错误, 这里直接返回错误信息 return jsonify(error_num=RET.NODATA, errmsg="用户名或密码不存在") # 验证成功 from flask import session session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errms="登录成功")
def login(): """用户登录 参数:手机号,密码,json """ #获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") #校验参数 # 参数完整性 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 手机号格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") #业务逻辑 # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录:"access_nums_请求的ip":"次数" user_ip = request.remote_addr #用户的ip地址 try: access_num = redis_store.get("access_num_{}".format(user_ip)) access_num = bytes.decode(access_num) except Exception as e: current_app.logger.error(e) else: if access_num is not None and int( access_num) >= constants.LOGIN_ERROR_MAX_TIEMS: return jsonify(errno=RET.REQERR, errmsg="错误次数过多,请稍后再试") # 从数据库中根据手机号查询用户的数据 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="获取用户信息失败") # 用数据库的密码与用户填写的密码进行对比验证 if user is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: redis_store.incrby("access_num_{}".format(user_ip)) redis_store.expire("access_num_{}".format(user_ip), constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户或密码错误") # 如果验证成功,保存登录状态,在session中 session['name'] = user.name session['session'] = user.mobile session['user_id'] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """用户登陆 参数接收: 参数验证: 发放session: """ #接收参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") #校验参数 #参数完整的验证 if not all([mobile, password]): return jsonify(errno=RET.PARAMER, errmsg="参数不完整") #手机号的格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") #判断错误次数是否超过限制 #使用字符串格式,access_num_请求ip:"次数" user_ip = request.remote_addr try: access_nums = redis_store.get("access_num_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) > constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, errmsg="错误次数过多,请稍后重试") #从数据库查询此手机号的用户 try: user = User.query.filter_by(mobile=mobile).first except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, error="获取用户信息失败") #校验密码 if user is None or user.check_password(password): try: # redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") #验证成功,发放session session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """登陆操作 参数:手机号, 密码 参数类型:json 请求方式:post """ # 获取参数 user_dict = request.get_json() mobile = user_dict.get("mobile") password = user_dict.get("password") # 校验参数 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 校验手机号 if not re.match(r'1[34579]\d{9}', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号不正确") # 判断用户登陆请求是否过多 # redis记录 "redis_num_ip": "次数" user_ip = request.remote_addr # 从redis中获取请求次数 try: login_num = redis_store.get("redis_num_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if login_num is not None and login_num > constants.LOGIN_MAX_TIME: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果验证失败记录验证次数信息,返回 try: redis_store.incr("redis_num_%s" % user_ip) redis_store.expire("redis_num_%s" % user_ip, constants.LOGIN_FORBIDEN_TIEM) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.USERERR, errmsg="请输入正确的账户密码") # 密码一致,登陆成功 # 设置登陆状态 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id # 返回 return jsonify(errno=RET.OK, errmsg="登陆成功")
def login(): """用户登录""" # 获取参数 req_data = request.get_json() if not req_data: return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") mobile = req_data.get("mobile") password = req_data.get("password") # 检查参数 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 手机号格式校验 if not re.match(r"^1[34578]\d{9}$", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") # 判断访问次数是否超过限制 try: access_count = redis_store.get("access_%s" % request.remote_addr) except Exception as e: current_app.logger.error(e) else: if access_count is not None and int( access_count) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(errno=RET.REQERR, 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="数据库异常") # 调用user模型中实现的检验用户密码的方法 if user is None or not user.check_password(password): try: redis_store.incr("access_%s" % request.remote_addr) redis_store.expire("access_%s" % request.remote_addr, constants.LOGIN_ERROR_LOCKED_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="手机号或密码错误") # 删除访问次数记录 try: redis_store.delete("access_%s" % request.remote_addr) except Exception as e: current_app.logger.error(e) # 用户验证成功,保存用户的session数据 session["user_id"] = user.id session["name"] = user.name session["mobile"] = user.mobile return jsonify(errno=RET.OK, errmsg="登录成功", data={"user_id": user.id})
def login(): """ 用户登录 参数“手机号码、密码 :return: """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get('mobile') password = req_dict.get('password') # 校验参数 # 参数完整的校验 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg='参数不完整') # 手机号的格式 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误') # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录:”access_nums_请求的ip" user_ip = request.remote_addr # 用户的ip地址 try: access_nums = redis_store.get("access_num_%s" % user_ip) print('access_nums', access_nums) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int( access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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='获取用户信息失败') # 用数据库的密码与用户填写的密码进行对比验证 print('check_password', user.check_password(password)) print('user', user) if user is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg='用户名或密码错误') # 如果验证相同,保存登录状态session session['name'] = user.name session['mobile'] = user.mobile session['user_id'] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """登录""" # 获取参数,手机号,密码 # 使用request.get_json 或 json.loads(request.data)将json数据转化为字典类型 req_dict = request.get_json() # 获取手机号 mobile = req_dict.get("mobile") # 获取密码 password = req_dict.get("password") # 校验参数 # 判断数据是否完整 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="数据不完整") # 判断手机格式是否正确 if not re.match(r"1[34578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机格式不正确") # 业务处理 # 判断用户的错误次数,从redis获取错误次数 remote_addr取出ip地址信息 user_ip = request.remote_addr try: access_count = redis_store.get("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: # 如果错误记录超过最大次数,则直接返回 if access_count is not None and int( access_count) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(errno=RET.REQERR, errmsg="登录太过频繁,请稍后在登录") # 用户的user用户名是否存在,密码是否一致 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="查询用户信息异常") # 判断用户的user用户名是否存在,密码是否正确 if user is None or not user.check_password(password): # 出现错误则累加错误次数,incr try: redis_store.incr("access_%s" % user_ip) redis_store.expire("access_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.LOGINERR, errmsg="用户登录失败") # 登录成功,则清除用户登录错误次数 try: redis_store.delete("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) # 记住用户当前的登录状态 session["user_name"] = user.name session["user_id"] = user.id session["mobile"] = user.mobile # 返回数据 登录成功 return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """ 用户登录 参数: 手机号、密码 """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 参数完整的校验 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 手机号的格式 if not re.match(r"1[0-9]{10}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的手机号") # 判断错误次数是否超过限制,如果超过限制则返回 # redis记录: "access_nums_请求的ip": 次数 user_ip = request.remote_addr # 用户的ip地址 try: access_nums = redis_store.get("access_num_{}".format(user_ip)) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int(access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): try: redis_store.incr("access_num_{}".format(user_ip)) # 设置有效期 redis_store.expire("access_num_{}".format(user_ip),constants.LOGIN_ERROR_FORBID_TIME ) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证相同成功,保存登录状态在session中 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): # 获取参数 resp_json = request.get_json() mobile = resp_json.get('mobile') password = resp_json.get('password') # 参数校验 # 1 数据完整性 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg='数据不完整') # 2 手机号格式 if not re.match(r"1[345678]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确') # 业务处理 # 用户ip user_ip = request.remote_addr try: real_count = redis_store.get('access_' + user_ip) except Exception as e: logging.error(e) return jsonify(errno=RET.DBERR, errmsg='查询Redis失败') # Redis存储错误次数 不大于5次 if real_count and int(real_count) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(errno=RET.REQERR, errmsg='请求已超过最大次数') # 用户名是否存在 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: logging.error(e) return jsonify(errno=RET.DBERR, errmsg='用户查询失败') # 用户是否存在或者密码是否正确 if user is None or not user.check_password(password): # 错误一次加一 设置过期时间 try: redis_store.incr('access_' + user_ip) redis_store.expire('access_' + user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: logging.error(e) return jsonify(errno=RET.DBERR, errmsg='Redis操作失败') return jsonify(errno=RET.LOGINERR, errmsg='用户名或密码输入错误') # 如果输入正确 错误次数清零 try: redis_store.delete('access_' + user_ip) except Exception as e: logging.error(e) return jsonify(errno=RET.DBERR, errmsg='删除Redis数据失败') # 保存登录状态 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='用户登录失败') # 返回数据 return jsonify(errno=RET.OK, errmsg='用户登录成功')
def login(): #1.获取参数(手机号,密码) req_json = request.data req_dict = json.loads(req_json) mobile = req_dict.get("mobile") password = req_dict.get("password") #2.校验参数 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") #验证手机号的格式 if not re.match(r"1[356789]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式有误") #记录用户的登录次数 try: ip = request.remote_addr #获取用户的ip account = redis_store.get("access_%s" % ip) except Exception as e: current_app.logger.error(e) else: if account is not None and int(account) >= constants.LOGIN_ERROR_COUNT: return jsonify(errno=RET.DBERR, errmsg="登录次数用完,请十分钟再试") #3.根据手机号取出用户对象 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="查询异常") #4.判断用户名,密码 if user is None or not user.check_password(password): try: redis_store.incr("access_%s" % ip) redis_store.expire("access_%s" % ip, constants.LOGIN_ERROR_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或者密码错误") #登录成功,清除redis中的登录错误次数 try: redis_store.delete("access_%s" % ip) except Exception as e: current_app.logger.error(e) #5.记录用户的登录状态 session["user_id"] = user.id session["user_name"] = user.name session["mobile"] = user.mobile #6.响应 return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """ 用户登陆 请求参数: 手机号、密码 :return: 正确返回 ok 错误 就error """ # 获取参数 # 获取来自前端的json对象 req = request.get_json() mobile = req.get("mobile") password = req.get("password") # 参数检测 # 判断是否参数完整 if not all([mobile, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 判断手机号格式 if not re.match(r"1[3578]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误") # 不存在,返回错误 # 获取当前用户登陆的ip地址 user_ip = request.remote_addr # 获取redis中错误的次数 try: access_num = redis_store.get("error_limit_time_%s" % user_ip) except Exception as e: redis_store.logger.error(e) else: # 判断错误次和限制错误次数 if access_num is not None and int( access_num) >= constants.LOGIN_LIMIT_ERROR_TIME: return jsonify(errno=RET.IPERR, errmsg="错误次数过多,请10分钟之后再试") # 查手机号是否已经存在 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: redis_store.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据库查询异常") # 在限定的错误次数范围中 if user is None or not user.check_password(password): print("密码检验:", user.check_password(password)) try: redis_store.incr("error_limit_time_%s" % user_ip) redis_store.expire("error_limit_time_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.PWDERR, errmsg="用户和密码错误") # 验证成功保存登陆状态 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登陆成功")
def login(): """ 用户登录 :param: 手机号,密码 :return: """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get('mobile', '') password = req_dict.get('password') # 效验参数 if not all([mobile, password]): return jsonify(errno=RET.DATAERR, errmsg='参数不完整') # 手机号的格式 if not re.match(r'1[345678]\d{9}', mobile): return jsonify(errno=RET.DATAERR, errmsg='手机号格式不正确') # 判断错误次数是否超过限制,如果超过限制,则返回 # redis记录: "access_nums_请求的ip": "次数" user_ip = request.remote_addr # 用户的ip地址 try: access_nums = redis_store.get('access_nums_%s' % user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int(access_nums) >= constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: # redis的incr可以对字符串类型的数字数据进行加一操作,如果数据一开始不存在,则会初始化为1 redis_store.incr('access_nums_%s' % user_ip) redis_store.expire('access_nums_%s' % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg='用户名或密码错误') # 如果验证通过,在session中保存登陆状态 session['name'] = user.name session['mobile'] = user.mobile session['user_id'] = user.id return jsonify(errno=RET.OK, errmsg='登陆成功')
def login(): """ 用户登录 参数: 手机号 密码 json :return: """ # 获取参数 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 # 参数完整的校验 if not all([mobile,password]): return jsonify(errno=RET.PARAMERR,errmsg = "参数不完整") # 手机号格式 if not re.match(r"1[02345678]\d{9}",mobile): return jsonify(errno=RET.PARAMERR,errmsg="手机号格式错误") # 判断错误次数是否超过限制,如果超过限制,则返回 # redis 记录:"access_nums_请求的ip":次数 user_ip = request.remote_addr # 用户ip try: access_nums = redis_store.get("access_num_%s"%user_ip) except Exception as e: current_app.logger.error(e) else: if access_nums is not None and int(access_nums)>constants.LOGIN_ERROR_MAX_TIMES: return jsonify(errno=RET.REQERR, errmsg="错误次数太多,请稍后再试") # 从数据库中根据手机号查询用户的数据对象 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.REQERR, errmsg="获取用户信息失败") # 用数据库的密码和用户填写的密码进行对比验证 if user is None or not user.check_password(password): # 如果验证失败,记录错误次数,返回信息 try: # redis的incr可以对字符串类型的数字数据进行加一操作,如果数据一开始不存在,则会初始化为1 redis_store.incr("access_num_%s" % user_ip) redis_store.expire("access_num_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) # expire设置有效期 except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误") # 如果验证相同成功,保存登录状态, 在session中 session["name"] = user.name session["mobile"] = user.mobile session["user_id"] = user.id return jsonify(errno=RET.OK, errmsg="登录成功")
def login(): """登录""" # 获取参数, 用户名 密码 req_dict = request.get_json() mobile = req_dict.get("mobile") password = req_dict.get("password") # 校验参数 if not all([mobile, password]): resp = { "error_code": RET.PARAMERR, "errmsg": "参数不完整" } return jsonify(resp) if not re.match(r"1[34578]\d{9}", mobile): resp = { "error_code": RET.PARAMERR, "errmsg": "手机号格式错误" } return jsonify(resp) # 判断用户的错误次数 # 从redis中获取错误次数 user_ip = request.remote_addr try: access_count = redis_store.get("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) else: if access_count is not None and int(access_count) >= constants.LOGIN_ERROR_MAX_NUM: return jsonify(error_code=RET.REQERR, errmsg="登录过于频繁") # 业务处理 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 and user.check_password(password): # 清除用户的登录错误此时 try: redis_store.delete("access_%s" % user_ip) except Exception as e: current_app.logger.error(e) # 记录用户的登录状态 session["user_id"] = user.id session["username"] = user.name session["mobile"] = mobile resp = { "error_code": RET.OK, "errmsg": "登录成功" } return jsonify(resp) else: try: redis_store.incr("access_%s" % user_ip) redis_store.expire("access_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME) except Exception as e: current_app.logger.error(e) resp = { "error_code": RET.LOGINERR, "errmsg": "用户名或密码错误" } return jsonify(resp)