def exist_UserName_email(username: str, email: str):
""" 判断用户名或者邮箱是否存在，有一个存在就返回True,都不存在返回False
本地数据库username，email字段为unique类型,保证唯一
:param username: 需要查询的用户名
:param email: 需要查询的邮箱
:return: bool
"""
db = pymysql.Connect('localhost',
'root',
mysql_passwd,
mysql_base,
charset='utf8')
cursor = db.cursor(cursor=pymysql.cursors.DictCursor)
flag = True
sql = 'select USER_NAME,USER_MAIL from {} where (USER_NAME=%s) or (USER_MAIL=%s);'.format(
mysql_table)
try:
cursor.execute(sql, (username, email))
result_mysql = cursor.fetchall()
# 查询到本地数据库存在该数据的时候
if result_mysql:
flag = True
logger.warning("查询%s用户或%s邮箱本地信息存在" % (username, email))
# 本地没有任何同名用户名和email
else:
flag = False
except Exception as e:
print("查询用户%s失败" % username)
logger.error("查询%s用户和%s邮箱信息失败,原因是: %s" % (username, email, e))
db.rollback()
db.close()
return flag
def query_redis(username: str):
"""读取Redis数据或者Mysql,然后返回json
:param username: 需要查询的用户名
:return: json格式结果
"""
# 与Redis建立连接(连接池)
# result_redis返回的结果是字符串，需要json.loads()才返回dict
# db = pymysql.Connect(host='localhost', user='******', password=mysql_passwd,
# database=mysql_base, charset='utf8')
# 通过docker部署需要使用下面的配置连接
db = pymysql.Connect(host=mysql_host,
user='******',
password=mysql_passwd,
database=mysql_base,
charset='utf8')
cursor = db.cursor(cursor=pymysql.cursors.DictCursor)
result_json = {"code": '', "data": '', "msg": ''}
# 查不到返回None 对应布尔值为False
result_redis = r.get(username)
print("query redis结果", result_redis)
# 如果数据存在则输出，不存在则重新查询mysql数据库
if result_redis:
# 成功返回json数据
result_json["code"] = '0'
result_json["data"] = loads(result_redis)
result_json["msg"] = 'Success'
logger.info("查询redis中%s用户数据为%s:" % (username, result_redis))
else:
# 连接mysql
# 查询数据库 userinfo 表格中是否存有数据
sql = "select USER_TYPE, USER_LOCK, USER_NAME, USER_PASSWD, USER_SALT, USER_MAIL, SUBMISSION_DATE from {0} where USER_NAME='{1}';".format(
mysql_table, username)
print('检查未知列字段sql', sql)
cursor.execute(sql)
result_mysql = cursor.fetchall()
# print(result_mysql)
# print("result结果:%s" % result_mysql)
# 数据库没有数据返回Failed;有数据写入Redis并返回
if not result_mysql:
print('Mysql中没有该 %s 用户' % username)
result_json["code"] = '-1'
result_json["msg"] = 'Failed'
logger.warning("MySQL中无%s用户" % username)
else:
# 查询到数据的时候写入Redis存储并设置过期时间（秒）
print("Mysql中查询到{0}用户数据为: {1}".format(username, result_mysql))
if dict_into_redis(result_mysql[0]['USER_NAME'], result_mysql[0]):
print("{}写入Redis存储成功".format(username))
result_redis = dict_outof_redis(username)
result_json["code"] = '1'
result_json["data"] = result_redis
result_json["msg"] = 'Success'
logger.info("MySQL写入redis中%s用户数据为%s:" % (username, result_redis))
db.close()
r.close()
return result_json
def deleteUSER():
""" 管理员或者super用户在用户管理界面删除其他用户(低权限用户)
:return:
"""
tup = ("user", "admin", "super") # 用下标 0, 1, 2 来比较权限的大小！！
# 当前修改者属性
username = request.form.get("username", type=str, default="")
# 被修改者的属性
othername = request.form.get('othername', type=str, default="")
otheremail = request.form.get("otheremail", type=str, default="")
result = DB_Sync.query_redis(othername)
# print(result)
othertype = result["data"]["USER_TYPE"]
# 判断当前用户是否在线
if session.get("username") == username and session.get('isLogin'):
# 获取当前用户的权限和锁定情况
result = DB_Sync.query_redis(username)
usertype = result["data"]["USER_TYPE"]
userlock = result["data"]["USER_LOCK"]
# 判断当前用户是否有权限删除,自己删除不了自己
if userlock == 0 and tup.index(usertype) > tup.index(othertype):
is_delete = DB_Sync.sync_redis_delete(othername, otheremail)
if is_delete:
code = "0"
msg = "用户账号注销成功"
logger.info("%s管理员注销%s用户成功" % (username, othername))
# 用户删除成功时候，删除用户目录
if User_Action.remove_user_homedir(username):
logger.warning("注销删除%s用户文件目录数据成功" % username)
else:
logger.error("注销删除%s用户文件目录数据失败" % username)
else:
code = "-1"
msg = "用户账号注销失败"
logger.error("%s管理员注销%s用户失败" % (username, othername))
else:
code = "1"
msg = "您没有权限执行操作"
else:
code = "-1"
msg = "您当前不处于登录状态，请先登录"
resp = jsonify(code=code, msg=msg)
resp.set_cookie("datetime", getlocaltime())
return resp
def change_user_permission(username: str, new_user_type: str,
new_user_lock: int):
"""
根据username来重置user_type和user_lock
:param username: 需要修改的用户名
:param new_user_type: 新的用户类型
:param new_user_lock: 用户是否锁定 0不锁定，1锁定
:return: bool
"""
# db = pymysql.Connect(host='localhost', user='******', password=mysql_passwd,
# database=mysql_base, charset='utf8')
# 通过docker部署需要使用下面的配置连接
db = pymysql.Connect(host=mysql_host,
user='******',
password=mysql_passwd,
database=mysql_base,
charset='utf8')
cursor = db.cursor(cursor=pymysql.cursors.DictCursor)
# username = "******".format(username)
flag = False
sql = "UPDATE {0} SET USER_TYPE='{1}', USER_LOCK={2} WHERE USER_NAME='{3}';".format(
mysql_table, new_user_type, new_user_lock, username)
print("你想改权限的sql是:%s" % sql)
isRedis = False
try:
cursor.execute(sql)
# 这里必须要加commit,因为MySQL的默认存储引擎就是事务型InnoDB表的结构
# 所以对数据库数据的操作会在事先分配的缓存中进行，只有在commit之后，数据库的数据才会改变
db.commit()
isRedis = True
# 将修改后的数据同步到redis里面
if refresh_redis(username):
logger.warning("修改%s用户权限[user_type:%s; user_lock=%d]成功..." %
(username, new_user_type, new_user_lock))
flag = True
else:
logger.error("修改%s用户权限[user_type:%s; user_lock=%d]失败..." %
(username, new_user_type, new_user_lock))
except:
if not isRedis:
db.rollback()
logger.error("修改用户权限后,同步redis出错" if isRedis else "mysql中修改{0}用户权限出错".
format(username))
db.close()
return flag
def eraseUSER():
""" 清空redis数据并删除本地数据库用户信息，同步redis
:return: json结果
"""
username = request.form.get("username", type=str, default="")
email = request.form.get("email", type=str, default="")
captureCode = request.form.get("capture", type=str, default="")
# 判断是否处于登录状态
if session["isLogin"] and session.get("username") == username:
# 判断验证码是否正确
isConsist = DB_Sync.is_consistent(email, username)
if captureCode == DB_Sync.query_redis_Capture(email) and isConsist:
# 删除redis数据，然后删除本地mysql数据
isDelete = DB_Sync.sync_redis_delete(username, email)
if isDelete:
code = "0"
msg = "用户账号注销成功"
session["isLogin"] = False
# 清除服务器数据
session.clear()
logger.info("%s用户账号注销成功" % username)
# 用户删除成功时候，删除用户目录
if User_Action.remove_user_homedir(username):
logger.warning("注销删除%s用户文件目录数据成功" % username)
else:
logger.error("注销删除%s用户文件目录数据失败" % username)
else:
code = "-1"
msg = "用户账号注销失败"
logger.warning("%s用户账户注销失败" % username)
else:
code = "-1"
msg = "验证码不一致"
logger.info("%s用户输入验证码不一致" % username)
# 当前不是处于登录状态
else:
code = "-1"
msg = "您当前不处于登录状态，请先登录"
logger.warning("%s用户删除数据失败,原因:当前处于非登录状态" % username)
resp = jsonify(code=code, msg=msg)
resp.set_cookie("datetime", getlocaltime())
return resp
def updatePWD():
"""Post方式用户更新密码,需要核实用户登录状态,用原来的salt加密后新密码入库,并要求重新登录。
:return: json结果
"""
username = session.get("username")
if session.get("isLogin") and username is not None:
# 处于登录的状态的时候，重新生成密码存储到mysql而且同步刷新Redis
old_pwd = request.form.get("old_passwd", type=str, default="")
new_pwd = request.form.get("new_passwd", type=str, default="")
# 下面获取该用户原始数据进行验证
result = DB_Sync.query_redis(username)
print("查询用户本地结果为:", result)
localPW = result["data"]["USER_PASSWD"]
salt = result["data"]["USER_SALT"]
# 用户原始密码输入正确，允许修改mysql然后同步redis
print('计算结果:', computePW(old_pwd, salt))
if checkPW(computePW(old_pwd, salt), localPW):
# 用原来的盐加密生成新的用户密码
compute_new_pwd = computePW(new_pwd, salt)
isOK = DB_Sync.sync_redis_insert(username, compute_new_pwd, salt)
if isOK:
resp = jsonify(code="0", msg="密码修改成功，请用新的密码登录")
resp.set_cookie("datetime", getlocaltime())
logger.warning("%s用户修改密码成功,并退出登录" % username)
# 修改了密码后,需要重新登录,应该清除session数据。然后刷新redis，不然会导致login时候的redis用之前的
DB_Sync.refresh_redis(username)
session["isLogin"] = False
session.clear()
else:
resp = jsonify(code="-1", msg="密码修改失败，请重试")
print("{0}用户修改密码失败,原密码:{1}|新密码:{2}".format(
username, localPW, compute_new_pwd))
logger.warning("%s用户修改密码失败" % username)
else:
# 传递过来的用户原始密码为假
resp = jsonify(code="-1", msg="您原始密码输入有误，请重新输入")
logger.error("%s用户修改密码失败,原始密码不正确" % username)
else:
# 该用户已经退出登录了，不处于登录状态
resp = jsonify(code="1", msg="您当前不处于登录状态，请先登录")
logger.warning("%s用户当前处于非登录状态,修改密码失败" % username)
return resp
def login():
""" 前端登录请求post请求，从数据库中验证params完整性和正确性,并设置相应的cookies和session
:return: json结果
"""
logintime = ""
if request.method == 'POST':
# 这里进行了折衷的处理为了实现登录顶掉他人登录的需求.(人性化的做法应该是提示在他处登录，询问要不要踢掉或者在其他地方先推出，这边在登陆)
quit()
print(request.form.get("username", type=str, default=""))
# 判断用户名密码是否正确
username = request.form.get("username", type=str, default="")
passwd = request.form.get("passwd", type=str, default="")
if username == "" or passwd == "":
code = "-1"
msg = "用户名或密码为空或不合法"
# 用户名不空查询后端数据
else:
result = DB_Sync.query_redis(username)
# 用户不存在
if result["code"] == "-1":
code = "-1"
msg = "用户名或密码错误"
# 用户存在 result["code"]返回0,1
else:
salt = ""
# 判断密码是否正确
if result["data"] != "":
salt = result["data"]["USER_SALT"]
localPW = result["data"]["USER_PASSWD"]
print("redis data", result["data"])
print("computePasswd", computePW(passwd, salt))
# 验算用户传递的密码是否和数据库中保存的一致
isConsistent = checkPW(computePW(passwd, salt), localPW)
# 密码输入正确
if isConsistent:
code = "0"
msg = "登录验证成功"
session["logintime"] = getlocaltime()
if session.get("isLogin"):
logger.warning("%s用户登录失败,原因是已在其他地方登录" % username)
return jsonify(code="-1", msg="您已在其他地方登录")
session["isLogin"] = True
session["username"] = username
logintime = getlocaltime()
logger.info("%s用户登录成功" % username)
# 密码输入错误
else:
code = "-1"
msg = "用户名或密码错误"
logger.warning("%s用户登录输入密码错误,登录失败" % username)
resp = jsonify(code=code, msg=msg)
resp.set_cookie('datetime', getlocaltime())
resp.set_cookie('logintime', logintime)
resp.set_cookie('username',
request.form.get("username", type=str, default="null"),
expires=max_ageTime) # max_age单位是秒，过期时间
return resp
# 如果是其他请求方法
else:
resp = jsonify(code='-1',
msg='{} Method is not allowed !'.format(request.method))
resp.set_cookie('datetime', getlocaltime())
resp.set_cookie('logintime', logintime)
resp.set_cookie('username',
request.form.get("username", type=str, default="null"),
expires=max_ageTime) # max_age单位是秒，过期时间
return resp