继续è°workflowï:调整目录结构

applications/common/admin/dept_curd.py

@@ -1,8 +1,8 @@
-from applications.common.utils.validate import xss_escape
 from applications.extensions import db
 from applications.models import Dept, DeptSchema
 from applications.models import User
 from applications.common.curd import model_to_dicts
+from flask import escape
 
 
 def get_dept_dict():
@@ -12,14 +12,14 @@ def get_dept_dict():
 
 
 def save_dept(req):
-    address = xss_escape(req.get("address"))
-    deptName = xss_escape(req.get("deptName"))
-    email = xss_escape(req.get("email"))
-    leader = xss_escape(req.get("leader"))
-    parentId = xss_escape(req.get("parentId"))
-    phone = xss_escape(req.get("phone"))
-    sort = xss_escape(req.get("sort"))
-    status = xss_escape(req.get("status"))
+    address = escape(req.get("address"))
+    deptName = escape(req.get("deptName"))
+    email = escape(req.get("email"))
+    leader = escape(req.get("leader"))
+    parentId = escape(req.get("parentId"))
+    phone = escape(req.get("phone"))
+    sort = escape(req.get("sort"))
+    status = escape(req.get("status"))
     dept = Dept(
         parent_id=parentId,
         dept_name=deptName,
@@ -35,25 +35,26 @@ def save_dept(req):
     return r
 
 
-def get_dept_by_id(id):
-    d = Dept.query.filter_by(id=id).first()
+def get_dept_by_id(_id):
+    """根据 id 获取部门"""
+    d = Dept.query.filter_by(id=_id).first()
     return d
 
 
-# 启动权限
-def enable_status(id):
+def enable_status(_id):
+    """ 启用权限 """
     enable = 1
-    d = Dept.query.filter_by(id=id).update({"status": enable})
+    d = Dept.query.filter_by(id=_id).update({"status": enable})
     if d:
         db.session.commit()
         return True
     return False
 
 
-# 停用权限
-def disable_status(id):
+def disable_status(_id):
+    """ 停用权限 """
     enable = 0
-    d = Dept.query.filter_by(id=id).update({"status": enable})
+    d = Dept.query.filter_by(id=_id).update({"status": enable})
     if d:
         db.session.commit()
         return True
@@ -61,27 +62,28 @@ def disable_status(id):
 
 
 def update_dept(json):
-    id = json.get("deptId"),
+    """ 更新部门信息 """
+    _id = json.get("deptId"),
     data = {
-        "dept_name": xss_escape(json.get("deptName")),
-        "sort": xss_escape(json.get("sort")),
-        "leader": xss_escape(json.get("leader")),
-        "phone": xss_escape(json.get("phone")),
-        "email": xss_escape(json.get("email")),
-        "status": xss_escape(json.get("status")),
-        "address": xss_escape(json.get("address"))
+        "dept_name": escape(json.get("deptName")),
+        "sort": escape(json.get("sort")),
+        "leader": escape(json.get("leader")),
+        "phone": escape(json.get("phone")),
+        "email": escape(json.get("email")),
+        "status": escape(json.get("status")),
+        "address": escape(json.get("address"))
     }
-    d = Dept.query.filter_by(id=id).update(data)
+    d = Dept.query.filter_by(id=_id).update(data)
     if not d:
         return False
     db.session.commit()
     return True
 
 
-def remove_dept(id):
-    d = Dept.query.filter_by(id=id).delete()
+def remove_dept(_id):
+    d = Dept.query.filter_by(id=_id).delete()
     if not d:
         return False
-    User.query.filter_by(dept_id=id).update({"dept_id": None})
+    User.query.filter_by(dept_id=_id).update({"dept_id": None})
     db.session.commit()
     return True

applications/common/admin/index_curd.py

@@ -1,3 +1,6 @@
+from collections import OrderedDict
+import copy
+
 from io import BytesIO
 from flask import session, make_response, current_app
 from flask_login import current_user
@@ -22,16 +25,8 @@ def add_auth_session():
 
 # 生成菜单树
 def make_menu_tree():
-    # power0 = Power.query.filter(
-    #     Power.type == 0,
-    # ).all()
-    # power1 = Power.query.filter(
-    #     Power.type == 1
-    # ).all()
-    # 获取当前用户的角色
     role = current_user.role
-    power0 = []
-    power1 = []
+    powers = []
     for i in role:
         # 如果角色没有被启用就直接跳过
         if i.enable == 0:
@@ -41,31 +36,28 @@ def make_menu_tree():
             # 如果权限关闭了就直接跳过
             if p.enable == 0:
                 continue
-            # 一级菜单
-            if int(p.type) == 0:
-                power0.append(p)
-            # 二级菜单
-            else:
-                power1.append(p)
+            # 一二级菜单
+            if p.type == 0 or p.type == 1:
+                powers.append(p)
 
     power_schema = PowerSchema(many=True)  # 用已继承 ma.ModelSchema 类的自定制类生成序列化类
-    power0_dict = power_schema.dump(power0)  # 生成可序列化对象
-    power1_dict = power_schema.dump(power1)  # 生成可序列化对象
-    power0_dict = sorted(power0_dict, key=lambda i: i['sort'])
-    power1_dict = sorted(power1_dict, key=lambda i: i['sort'])
-    # print(power0)
-    # print(power1)
+    power_dict = power_schema.dump(powers)  # 生成可序列化对象
+    power_dict.sort(key=lambda x: x['id'], reverse=True)
 
-    menu = []
+    menu_dict = OrderedDict()
+    for _dict in power_dict:
+        if _dict['id'] in menu_dict:
+            # 当前节点添加子节点
+            _dict['children'] = copy.deepcopy(menu_dict[_dict['id']])
+            # 删除子节点
+            del menu_dict[_dict['id']]
 
-    for p0 in power0_dict:
-        for p1 in power1_dict:
-            if p0.get('id') == p1.get('parent_id'):
-                if p0.get("children") is None:
-                    p0['children'] = []
-                p0['children'].append(p1)
-        menu.append(p0)
-    return menu
+        if _dict['parent_id'] not in menu_dict:
+            menu_dict[_dict['parent_id']] = [_dict]
+        else:
+            menu_dict[_dict['parent_id']].append(_dict)
+
+    return menu_dict.get(0)
 
 
 # 生成验证码

applications/common/admin/rights_curd.py

@@ -108,5 +108,5 @@ def remove_power(id):
 
 # 批量删除权限
 def batch_remove(ids):
-    for id in ids:
-        remove_power(id)
+    for _id in ids:
+        remove_power(_id)

applications/common/admin/role_curd.py

@@ -18,15 +18,15 @@ def get_role_data(page, limit, filters):
     return role, count
 
 
-# 获取角色dict
 def get_role_data_dict(page, limit, filters):
+    """ 获取角色dict """
     role, count = get_role_data(page, limit, filters)
     data = model_to_dicts(Schema=RoleSchema, model=role.items)
     return data, count
 
 
-# 增加角色
 def add_role(req):
+    """ 增加角色 """
     details = xss_escape(req.get("details"))
     enable = xss_escape(req.get("enable"))
     roleCode = xss_escape(req.get("roleCode"))
@@ -43,15 +43,15 @@ def add_role(req):
     db.session.commit()
 
 
-# 通过id获取角色
-def get_role_by_id(id):
-    r = Role.query.filter_by(id=id).first()
+def get_role_by_id(_id):
+    """ 通过id获取角色 """
+    r = Role.query.filter_by(id=_id).first()
     return r
 
 
-# 更新角色
 def update_role(req_json):
-    id = req_json.get("roleId")
+    """ 更新角色 """
+    _id = req_json.get("roleId")
     data = {
         "code": xss_escape(req_json.get("roleCode")),
         "name": xss_escape(req_json.get("roleName")),
@@ -59,14 +59,14 @@ def update_role(req_json):
         "enable": xss_escape(req_json.get("enable")),
         "details": xss_escape(req_json.get("details"))
     }
-    role = Role.query.filter_by(id=id).update(data)
+    role = Role.query.filter_by(id=_id).update(data)
     db.session.commit()
     return role
 
 
-# 获取角色的权限
-def get_role_power(id):
-    role = Role.query.filter_by(id=id).first()
+def get_role_power(_id):
+    """ 获取角色的权限 """
+    role = Role.query.filter_by(id=_id).first()
     check_powers = role.power
     check_powers_list = []
     for cp in check_powers:
@@ -82,14 +82,12 @@ def get_role_power(id):
     return output
 
 
-# 更新角色权限
-def update_role_power(id, power_list):
-    role = Role.query.filter_by(id=id).first()
+def update_role_power(_id, power_list):
+    """ 更新角色权限 """
+    role = Role.query.filter_by(id=_id).first()
     power_id_list = []
     for p in role.power:
         power_id_list.append(p.id)
-        # print(p.id)
-    # print(power_id_list)
     powers = Power.query.filter(Power.id.in_(power_id_list)).all()
     for p in powers:
         role.power.remove(p)
@@ -99,29 +97,29 @@ def update_role_power(id, power_list):
     db.session.commit()
 
 
-# 启动角色
-def enable_status(id):
+def enable_status(_id):
+    """ 启用角色 """
     enable = 1
-    role = Role.query.filter_by(id=id).update({"enable": enable})
+    role = Role.query.filter_by(id=_id).update({"enable": enable})
     if role:
         db.session.commit()
         return True
     return False
 
 
-# 停用角色
-def disable_status(id):
+def disable_status(_id):
+    """ 停用角色 """
     enable = 0
-    role = Role.query.filter_by(id=id).update({"enable": enable})
+    role = Role.query.filter_by(id=_id).update({"enable": enable})
     if role:
         db.session.commit()
         return True
     return False
 
 
-# 删除角色
-def remove_role(id):
-    role = Role.query.filter_by(id=id).first()
+def remove_role(_id):
+    """ 删除角色 """
+    role = Role.query.filter_by(id=_id).first()
     # 删除该角色的权限
     power_id_list = []
     for p in role.power:
@@ -141,9 +139,7 @@ def remove_role(id):
     return r
 
 
-# 批量删除
 def batch_remove(ids):
-    # role = Role.query.filter(Role.id.in_(ids)).delete(synchronize_session=False)
-    # db.session.commit()
-    for id in ids:
-        remove_role(id)
+    """ 批量删除 """
+    for _id in ids:
+        remove_role(_id)

applications/common/admin/user_curd.py

@@ -24,73 +24,75 @@ def get_user_data(page, limit, filters, deptId):
     return user, count
 
 
-# 获取用户的dict数据分页器
 def get_user_data_dict(page, limit, filters, deptId):
+    """ 获取用户的dict数据分页器 """
     user, count = get_user_data(page, limit, filters, deptId)
     data = model_to_dicts(Schema=UserSchema, model=user.items)
     return data, count
 
 
-# 通过名称获取用户
 def get_user_by_name(username):
+    """ 通过名称获取用户 """
     return User.query.filter_by(username=username).first()
 
 
-# 获取当前用户日志
 def get_current_user_logs():
+    """ 获取当前用户日志 """
     log = AdminLog.query.filter_by(url='/admin/login').filter_by(uid=current_user.id).order_by(
         desc(AdminLog.create_time)).limit(10)
     return log
 
 
-# 判断用户是否存在
 def is_user_exists(username):
+    """ 判断用户是否存在 """
     res = User.query.filter_by(username=username).count()
     return bool(res)
 
 
-# 增加用户
-def add_user(username, realName, password):
-    user = User(username=username, realname=realName)
+def add_user(username, real_name, password):
+    """ 增加用户 """
+    user = User()
+    user.username = username
+    user.realname = real_name
     user.set_password(password)
     db.session.add(user)
     db.session.commit()
     return user.id
 
 
-# 增加用户角色
-def add_user_role(id, roles_list):
-    user = User.query.filter_by(id=id).first()
+def add_user_role(_id, roles_list):
+    """ 增加用户角色 """
+    user = User.query.filter_by(id=_id).first()
     roles = Role.query.filter(Role.id.in_(roles_list)).all()
     for r in roles:
         user.role.append(r)
     db.session.commit()
 
 
-# 更新用户头像
 def update_avatar(url):
+    """ 更新用户头像 """
     r = User.query.filter_by(id=current_user.id).update({"avatar": url})
     db.session.commit()
     return r
 
 
-# 更新用户信息
-def update_user(id, username, realname, deptId):
-    user = User.query.filter_by(id=id).update({'username': username, 'realname': realname, 'dept_id': deptId})
+def update_user(_id, username, realname, deptId):
+    """ 更新用户信息 """
+    user = User.query.filter_by(id=_id).update({'username': username, 'realname': realname, 'dept_id': deptId})
     db.session.commit()
     return user
 
 
-# 更新当前用户信息
 def update_current_user_info(req_json):
+    """ 更新当前用户信息 """
     r = User.query.filter_by(id=current_user.id).update(
         {"realname": req_json.get("realName"), "remark": req_json.get("details")})
     db.session.commit()
     return r
 
 
-# 修改当前用户密码
 def edit_password(res_json):
+    """ 修改当前用户密码 """
     if res_json.get("newPassword") == '':
         return jsonify(success=False, msg="新密码不得为空")
     if res_json.get("newPassword") != res_json.get("confirmPassword"):
@@ -105,48 +107,48 @@ def edit_password(res_json):
     return jsonify(success=True, msg="更改成功")
 
 
-# 删除用户
-def delete_by_id(id):
-    user = User.query.filter_by(id=id).first()
+def delete_by_id(_id):
+    """ 删除用户 """
+    user = User.query.filter_by(id=_id).first()
     roles_id = []
     for role in user.role:
         roles_id.append(role.id)
     roles = Role.query.filter(Role.id.in_(roles_id)).all()
     for r in roles:
         user.role.remove(r)
-    res = User.query.filter_by(id=id).delete()
+    res = User.query.filter_by(id=_id).delete()
     db.session.commit()
     return res
 
 
-# 启用用户
-def enable_status(id):
+def enable_status(_id):
+    """ 启用用户 """
     enable = 1
-    user = User.query.filter_by(id=id).update({"enable": enable})
+    user = User.query.filter_by(id=_id).update({"enable": enable})
     if user:
         db.session.commit()
         return True
     return False
 
 
-# 停用用户
-def disable_status(id):
+def disable_status(_id):
+    """ 停用用户 """
     enable = 0
-    user = User.query.filter_by(id=id).update({"enable": enable})
+    user = User.query.filter_by(id=_id).update({"enable": enable})
     if user:
         db.session.commit()
         return True
     return False
 
 
-# 批量删除
 def batch_remove(ids):
-    for id in ids:
-        delete_by_id(id)
+    """ 批量删除 """
+    for _id in ids:
+        delete_by_id(_id)
 
 
-def update_user_role(id, roles_list):
-    user = User.query.filter_by(id=id).first()
+def update_user_role(_id, roles_list):
+    user = User.query.filter_by(id=_id).first()
     roles_id = []
     for role in user.role:
         roles_id.append(role.id)

applications/common/utils/rights.py

@@ -9,7 +9,7 @@ def authorize(power: str, log: bool = False):
         @login_required
         @wraps(func)
         def wrapper(*args, **kwargs):
-            if not power in session.get('permissions'):
+            if power not in session.get('permissions'):
                 if log:
                     admin_log(request=request, is_access=False)
                 if request.method == 'GET':

applications/common/utils/validate.py

@@ -2,14 +2,6 @@
 from flask import abort, make_response, jsonify
 
 
-def xss_escape(s: str):
-    if s is None:
-        return None
-    else:
-        return s.replace("&", "&amp;").replace(">", "&gt;").replace("<", "&lt;").replace("'", "&#39;").replace('"',
-                                                                                                               "&#34;")
-
-
 def check_data(schema, data):
     errors = schema.validate(data)
     for k, v in errors.items():