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():
"""
用户登录
传递参数: 手机号 密码
格式: 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.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]):
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():
"""
用户登录
参数：手机号，密码
: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]):
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():
"""
用户登录
参数： 手机号、密码
: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():
"""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():
"""
用户登陆
参数：手机号，密码 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():
"""
用户登录
：: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():
'''登录
请求参数：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 （后端数据库手机号和密码进行比对）
: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():
"""
用户登录
参数： 手机号、密码， 格式：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 手机号，密码 ：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():
"""
: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():
"""用户登陆
参数接收：
参数验证：
发放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():
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():
"""
用户登录
参数“手机号码、密码
: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():
"""
用户登录
: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():
"""登录"""
# 获取参数,手机号,密码
# 使用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():
#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():
"""
用户登录
参数： 手机号 密码 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():
"""
用户登陆
请求参数: 手机号、密码
: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():
# 获取参数
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 get_login():
"""
用户登录
"""
# 获取参数信息
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 校验参数
if not all([mobile, password]):
return jsonify(code=RET.DATAERR, errmsg="数据不能为空")
# 手机号的格式
if not re.match(r"1[3456789]\d{9}", mobile):
return jsonify(code=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(code=RET.REQERR, errmsg="错误次数过多，请稍后重试")
# 查询数据库--从数据库中根据手机号查询用户的数据对象
try:
user = User.query.filter_by(mobile=mobile).first()
print('*' * 20)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=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(err=RET.DATAERR, errmsg="用户名或密码错误")
# 如果验证相同成功，保存登录状态， 在session中
session["name"] = user.name
session["mobile"] = user.mobile
session["user_id"] = user.id
# check_pwd = check_password_hash(user.password_hash,password)
# print(check_pwd)
# if not check_password_hash(user.password_hash,password):
# return jsonify(code=RET.DATAERR,errmsg="密码错误")
return jsonify(code=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)
