diff --git a/Crud/AppCrud.py b/Crud/AppCrud.py
index e00f6a3..3f2bed7 100644
--- a/Crud/AppCrud.py
+++ b/Crud/AppCrud.py
@@ -8,8 +8,8 @@ def get_app_by_id(db: Session, app_id):
     return app
 
 
-def add_app(db: Session, app_id: str, secret_key: str) -> App:
-    app = App(id=app_id, secret_key=secret_key)
+def add_app(db: Session, app_id: str, name: str, secret_key: str, allowed: bool) -> App:
+    app = App(id=app_id, secret_key=secret_key, name=name, allowed=allowed)
     db.add(app)
     db.commit()
     db.flush(app)
diff --git a/Crud/AuthRuleCrud.py b/Crud/AuthRuleCrud.py
index 0f8fccd..17604b0 100644
--- a/Crud/AuthRuleCrud.py
+++ b/Crud/AuthRuleCrud.py
@@ -3,104 +3,110 @@ from typing import Union, List
 from sqlalchemy.orm import Session
 
 from Exceptions.common import CommonException
-from Model.AuthRuleModel import AuthRuleNode, DefaultAuthRuleConfig
+from Model.AuthRuleModel import AuthRule, DefaultAuthRuleConfig, AuthCategory
 from Schemas import AuthRuleSchemas
 
 
-def add_auth_rule_node(db: Session, name: str, belong: Union[int, None], node_type: str) -> AuthRuleNode:
-    if belong:
-        parent_node = get_auth_rule_node_by_id(belong)
-        if not parent_node:
-            raise CommonException("父节点不存在")
-        if parent_node.node_type != 'category':
-            raise CommonException("父节点类型不为分类节点")
-    item = AuthRuleNode(name=name, belong=belong, node_type=node_type)
-    db.add(item)
-    db.commit()
-    db.refresh(item)
-    return item
+def add_auth_rule(db: Session, name: str, category1: str = "", category2: str = "") -> AuthRule:
+    if db.query(AuthCategory).filter_by(id=category1).first() and db.query(AuthCategory).filter_by(
+            id=category2).first():
+        item = AuthRule(name=name, category1=category1, category2=category2)
+        db.add(item)
+        db.commit()
+        db.refresh(item)
+        return item
+    else:
+        raise CommonException('分类信息不正确')
 
 
-def get_auth_rule_node_by_id(db: Session, node_id: int) -> AuthRuleNode:
-    auth_rule_node = db.query(AuthRuleNode).filter_by(id=node_id).first()
-    return auth_rule_node
-
-
-def delete_auth_rule_node_by_id_list(db: Session, node_id_list: List[int]):
-    delete_id_set = set(node_id_list)
-    node_id_set_temp = set(node_id_list)
-    n = 0
-    while True:
-        n += 1
-        node_id_set_temp = [item.id for item in
-                            db.query(AuthRuleNode).filter(AuthRuleNode.belong.in_(node_id_set_temp))]
-        if node_id_set_temp:
-            for node_id in node_id_set_temp:
-                delete_id_set.add(node_id)
-        else:
-            break
-        # 可能出现死循环？
-        if n > 15:
-            raise CommonException("接口出现错误")
-    db.query(AuthRuleNode).filter(AuthRuleNode.belong.in_(delete_id_set)).delete()
-
-
-# test_list = [
-#     {'id': 1, "belong": 7},
-#     {'id': 2, "belong": 1},
-#     {'id': 3, "belong": 2},
-#     {'id': 4, "belong": 3},
-#     {'id': 5, "belong": 8},
-#     {'id': 6, "belong": 5},
-#     {'id': 7, "belong": None},
-#     {'id': 8, "belong": None},
-# ]
-
-
-def get_auth_rule_tree(db: Session) -> dict:
-    item_list = db.query(AuthRuleNode).all()
-    node_list = []
-    for item in item_list:
-        item_dic = item.to_dict()
-        item_dic['children'] = []
-        node_list.append(item_dic)
-
-    nodes_dic = {node["id"]: node for node in node_list}
-    rule_tree = []
-    for node in node_list:
-        belong = node['belong']
-        if belong:
-            if belong in nodes_dic:
-                nodes_dic[belong]['children'].append(node)
-            else:
-                print(f"不存在{belong}")
-        else:
-            rule_tree.append(node)
-    return rule_tree
-
-
-def change_auth_rule_node(db: Session, node_id: int, name: str, belong: Union[int, None]):
-    if belong:
-        parent_node = get_auth_rule_node_by_id(belong)
-        if not parent_node:
-            raise CommonException("父节点不存在")
-        if parent_node.node_type != 'category':
-            raise CommonException("父节点类型不为分类节点")
-    db.query(AuthRuleNode).filter_by(node_id).update({'name': name, 'belong': belong})
+def delete_auth_rule(db: Session, auth_rule_id: int):
+    db.query(AuthRule).filter_by(id=auth_rule_id).delete()
     db.commit()
 
 
-def get_default_auth_rule_config_by_id(db: Session, item_id: int):
+# def delete_auth_rule_by_id_list(db: Session, auth_rule_id: int):
+#     db.query(AuthRule).filter_by(id=auth_rule_id).delete()
+#     db.commit()
+
+
+def change_auth_rule(db: Session, rule_id, new_data: dict):
+    # if "category1" in new_data:
+    #     if not db.query(AuthCategory).filter_by(id=new_data['category1']).first():
+    #         raise CommonException('分类信息不正确')
+    # if "category2" in new_data:
+    #     if not db.query(AuthCategory).filter_by(id=new_data['category2']).first():
+    #         raise CommonException('分类信息不正确')
+    db.query(AuthRule).filter_by(id=rule_id).update(new_data)
+    db.commit()
+
+
+def get_auth_rule_list(db: Session, query_params: AuthRuleSchemas.AuthRuleQueryParams):
+    query = db.query(AuthRule)
+    for key, value in query_params.dict().items():
+        query = query.filter_by(**{key: value})
+    count = query.count()
+    if query_params.page is not None and query_params.page_size is not None:
+        query = query.offset((query_params.page - 1) * query_params.page_size).limit(query_params.page).all()
+    return query, count
+
+
+def get_default_auth_rule_config(db: Session, item_id: int):
     return db.query(DefaultAuthRuleConfig).filter_by(id=item_id).first()
 
 
 def get_default_auth_rule_config_list(db: Session, params: AuthRuleSchemas.AuthRuleConfigQueryParams):
     query = db.query(DefaultAuthRuleConfig)
     if params.id:
-        query = query.filter(DefaultAuthRuleConfig.name.like(params.name))
+        query = query.filter(DefaultAuthRuleConfig.id.like(params.id))
     if params.name:
         query = query.filter(DefaultAuthRuleConfig.name.like(params.name))
     count = query.count()
     if params.page and params.page_size:
         query = query.offset((params.page - 1) * params.page_size).limit(params.page).all()
     return count, query
+
+
+def add_auth_category(db: Session, name: str, belong: int = None,category_level:int=None) -> AuthCategory:
+    item = AuthCategory(name=name, belong=belong,category_level=category_level)
+    if not db.query(AuthCategory).filter_by(id=belong).first():
+        raise CommonException("错误的分类信息")
+    db.add(item)
+    db.commit()
+    db.refresh(item)
+    return item
+
+
+def delete_auth_category(db: Session, auth_rule_id: int):
+    db.query(AuthRule).filter_by(id=auth_rule_id).delete()
+    db.commit()
+
+
+def change_auth_category(db: Session, auth_rule_id: int, new_data: dict):
+    db.query(AuthCategory).filter_by(auth_rule_id).update(new_data)
+    db.commit()
+    pass
+
+
+def get_auth_category_by_id(db: Session, item_id):
+    return db.get(item_id)
+
+
+def change_auth_rule(db: Session, rule_id, new_data: dict):
+    if "category1" in new_data:
+        if not db.query(AuthCategory).filter_by(id=new_data['category1']).first():
+            raise CommonException('分类信息不正确')
+    if "category2" in new_data:
+        if not db.query(AuthCategory).filter_by(id=new_data['category2']).first():
+            raise CommonException('分类信息不正确')
+    db.query(AuthRule).filter_by(id=rule_id).update(new_data)
+    db.commit()
+
+
+def get_auth_rule_list(db: Session, query_params: AuthRuleSchemas.AuthRuleQueryParams):
+    query = db.query(AuthRule)
+    for key, value in query_params.dict().items():
+        query = query.filter_by(**{key: value})
+    count = query.count()
+    if query_params.page is not None and query_params.page_size is not None:
+        query = query.offset((query_params.page - 1) * query_params.page_size).limit(query_params.page).all()
+    return query, count
diff --git a/Model/AuthRuleModel.py b/Model/AuthRuleModel.py
index 95d2e75..82acff5 100644
--- a/Model/AuthRuleModel.py
+++ b/Model/AuthRuleModel.py
@@ -4,17 +4,17 @@ from sqlalchemy import Column, String, Boolean, ForeignKey, Enum, Text, DateTime
 from Utils.SqlAlchemyUtils import Base
 
 
-class AuthRuleNode(Base):
-    __tablename__ = "AUTH_RULE_NODE_TABLE"
-    id = Column(Integer, primary_key=True, comment="规则节点id")
-    name = Column(String(32), unique=True, comment="规则节点名称")
-    node_type = Column(Enum("category", "rule", name="节点类型"))
-    belong = Column(Integer, comment="所属节点")
-
-    def to_dict(self):
-        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
-
-
+# class AuthRuleNode(Base):
+#     __tablename__ = "AUTH_RULE_NODE_TABLE"
+#     id = Column(Integer, primary_key=True, comment="规则节点id")
+#     name = Column(String(32), unique=True, comment="规则节点名称")
+#     node_type = Column(Enum("category", "rule", name="节点类型"))
+#     belong = Column(Integer, comment="所属节点")
+#
+#     def to_dict(self):
+#         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+#
+#
 class DefaultAuthRuleConfig(Base):
     __tablename__ = "default_auth_rule_config_table"
     id = Column(Integer, primary_key=True, comment="默认权限规则配置id")
@@ -23,3 +23,22 @@ class DefaultAuthRuleConfig(Base):
 
     def to_dict(self):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+
+class AuthRule(Base):
+    __tablename__ = "AUTH_RULE_TABLE"
+    id = Column(Integer, primary_key=True, comment="权限规则id")
+    name = Column(String(32), unique=True, comment="权限规则名称")
+    category1 = Column(String(64), comment="一级分类")
+    category2 = Column(String(64), comment="二级分类")
+
+    def to_dict(self):
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+
+class AuthCategory(Base):
+    __tablename__ = "AUTH_CATEGORY_TABLE"
+    id = Column(Integer, primary_key=True, comment="权限分类id")
+    name = Column(String(32), unique=True, comment="权限分类名称")
+    category_level = Column(Integer, comment="权限分类级别")  # 1为一级分类 2为二级分类
+    belong = Column(Integer, comment="所属级别")
diff --git a/Router/AppManageRouter.py b/Router/AppManageRouter.py
index e778da5..521b228 100644
--- a/Router/AppManageRouter.py
+++ b/Router/AppManageRouter.py
@@ -14,14 +14,14 @@ router = APIRouter(
 
 
 @router.post("/add_app", summary="添加应用")
-def add_app(app: AppSchemas.AppInfo, db: Session = Depends(get_db)):
+def add_app(app: AppSchemas.AppAddInfo, db: Session = Depends(get_db)):
     AppCrud.add_app(db, app.name)
     return {"msg": "", "state": 1}
 
 
 @router.post("/change_app", summary="修改应用")
-def change_app(app: AppSchemas.AppInfo, db: Session = Depends(get_db)):
-    AppCrud.change_app(db, app.id, app.name)
+def change_app(app: AppSchemas.AppChangeInfo, db: Session = Depends(get_db)):
+    AppCrud.change_app(db, app.id, {'name': app.name, "token_key": app.token_key, "secret_key": app.secret_key})
     return {"msg": "", "state": 1}
 
 
diff --git a/Router/AuthRuleRouter.py b/Router/AuthRuleRouter.py
index d592ac4..94322c4 100644
--- a/Router/AuthRuleRouter.py
+++ b/Router/AuthRuleRouter.py
@@ -13,27 +13,27 @@ router = APIRouter(
 )
 
 
-@router.post("/add_auth_rule_node", summary="添加权限规则节点", response_model=AuthRuleSchemas.AuthRuleNodeInfo)
-def add_auth_rule_node(body: AuthRuleSchemas.AuthRuleNodeAddInfo, db: Session = Depends(get_db)):
-    new_auth_rule_node = AuthRuleCrud.add_auth_rule_node(db, body.name, body.belong, body.node_type)
-    return new_auth_rule_node
+@router.post("/add_auth_rule", summary="添加权限规则", response_model=AuthRuleSchemas.AuthRuleInfo)
+def add_auth_rule(body: AuthRuleSchemas.AuthRuleAddInfo, db: Session = Depends(get_db)):
+    new_auth_rule = AuthRuleCrud.add_auth_rule(db, body.name, body.belong)
+    return new_auth_rule
 
 
-# @router.post("/delete_auth_rule_node_by_id", summary="删除权限规则节点")
-# def delete_auth_rule_node(body: AuthRuleSchemas.AuthRuleNodeId, db: Session = Depends(get_db)):
-#     AuthRuleCrud.delete_auth_rule_node_by_id(db, body.id)
-#     return {"msg": "删除成功", "state": 1}
-
-
-@router.post("/delete_auth_rule_node_by_id_list", summary="批量删除权限规则节点")
-def delete_auth_rule_node_by_id_list(body: AuthRuleSchemas.AuthRuleNodeIdList, db: Session = Depends(get_db)):
-    AuthRuleCrud.delete_auth_rule_node_by_id_list(db, body.id_list)
+@router.post("/delete_auth_rule", summary="删除权限规则")
+def delete_auth_rule(body: AuthRuleSchemas.AuthRuleId, db: Session = Depends(get_db)):
+    AuthRuleCrud.delete_auth_rule(db, body.id)
     return {"msg": "删除成功", "state": 1}
 
 
-@router.post("/change_auth_rule_node", summary="修改权限规则节点")
-def change_auth_rule_node(body: AuthRuleSchemas.AuthRuleNodeChangeInfo, db: Session = Depends(get_db)):
-    AuthRuleCrud.change_auth_rule_node(db, body.name, body.belong)
+# @router.post("/delete_auth_rule_by_id_list", summary="批量删除权限规则节点")
+# def delete_auth_rule_node_by_id_list(body: AuthRuleSchemas.AuthRuleIdList, db: Session = Depends(get_db)):
+#     AuthRuleCrud.delete_auth_rule_by_id_list(db, body.id_list)
+#     return {"msg": "删除成功", "state": 1}
+
+
+@router.post("/change_auth_rule", summary="修改权限规则")
+def change_auth_rule(body: AuthRuleSchemas.AuthRuleChangeInfo, db: Session = Depends(get_db)):
+    AuthRuleCrud.change_auth_rule(db, body.id, {'name': body.name, 'belong': body.belong})
     return {"msg": "修改成功", "state": 1}
 
 
@@ -43,9 +43,27 @@ def get_auth_rule_tree(db: Session = Depends(get_db)):
     return auth_rule_tree
 
 
-@router.post("/get_default_auth_rule_config_list", summary="获取默认权限规则配置列表",
-             response_model=AuthRuleSchemas.AuthRuleConfigInfoList)
-def get_default_auth_rule_config(query_params: AuthRuleSchemas.AuthRuleConfigQueryParams,
-                                 db: Session = Depends(get_db)):
-    default_auth_rule_config_list = AuthRuleCrud.get_default_auth_rule_config_list(db, query_params)
-    return default_auth_rule_config_list
+# @router.post("/add_auth_category", summary="添加权限规则分类", response_model=AuthRuleSchemas.AuthCategoryAddInfo)
+# def add_auth_category(body: AuthRuleSchemas.AuthCategoryAddInfo, db: Session = Depends(get_db)):
+#     new_auth_rule = AuthRuleCrud.add_auth_category(db, body.name, body.belong, body.category_level)
+#     return new_auth_rule
+
+
+# @router.post("/change_auth_category", summary="修改权限规则分类信息")
+# def change_auth_category(body: AuthRuleSchemas.AuthCategoryChangeInfo, db: Session = Depends(get_db)):
+#     AuthRuleCrud.change_auth_category(db, body.id, {'name': body.name, 'belong': body.belong,'':"category_level"})
+#     return {"msg": "修改成功", "state": 1}
+#
+#
+# @router.post("/delete_auth_category", summary="删除权限规则分类")
+# def delete_auth_category(body: AuthRuleSchemas.AuthCategoryId, db: Session = Depends(get_db)):
+#     new_auth_rule = AuthRuleCrud.delete_auth_category(db, body.name, body.belong, body.category_level)
+#     return new_auth_rule
+#
+#
+# @router.post("/get_default_auth_rule_config_list", summary="获取默认权限规则配置列表",
+#              response_model=AuthRuleSchemas.AuthRuleConfigInfoList)
+# def get_default_auth_rule_config(query_params: AuthRuleSchemas.AuthRuleConfigQueryParams,
+#                                  db: Session = Depends(get_db)):
+#     default_auth_rule_config_list = AuthRuleCrud.get_default_auth_rule_config_list(db, query_params)
+#     return default_auth_rule_config_list
diff --git a/Schemas/AppSchemas.py b/Schemas/AppSchemas.py
index ef73e10..c819631 100644
--- a/Schemas/AppSchemas.py
+++ b/Schemas/AppSchemas.py
@@ -25,16 +25,20 @@ class AppAddInfo(BaseModel):
     secret_key: str
 
 
-class AppInfo(BaseModel):
-    id: str
+class AppAddInfo(BaseModel):
+    name: str
+    secret_key: str
+
+
+class AppInfoList(BaseModel):
+    app_info_list: List[AppAddInfo]
+
+
+class AppChangeInfo(BaseModel):
     name: str
     secret_key: str
     token_key: str
 
 
-class AppInfoList(BaseModel):
-    app_info_list: List[AppInfo]
-
-
 class AppId(BaseModel):
     app_id: str
diff --git a/Schemas/AuthRuleSchemas.py b/Schemas/AuthRuleSchemas.py
index ec8892e..0cd2e04 100644
--- a/Schemas/AuthRuleSchemas.py
+++ b/Schemas/AuthRuleSchemas.py
@@ -1,7 +1,7 @@
 from enum import Enum
 
 from pydantic import BaseModel
-from typing import Union,List
+from typing import Union, List
 
 
 class AuthRuleNodeTypeEnum(Enum):
@@ -9,31 +9,41 @@ class AuthRuleNodeTypeEnum(Enum):
     category = 'category'
 
 
-class AuthRuleNodeAddInfo(BaseModel):
+class AuthRuleAddInfo(BaseModel):
     name: str
-    belong: Union[None, int]
-    node_type: AuthRuleNodeTypeEnum
+    category1: Union[None, str]
+    category2: Union[None, str]
 
 
-class AuthRuleNodeInfo(BaseModel):
+class AuthRuleInfo(BaseModel):
     id: int
     name: str
-    belong: Union[None, int]
-    node_type: AuthRuleNodeTypeEnum
+    category1: Union[None, str]
+    category2: Union[None, str]
 
 
-class AuthRuleNodeId(BaseModel):
+class AuthRuleId(BaseModel):
     id: int
 
 
-class AuthRuleNodeIdList(BaseModel):
+class AuthRuleIdList(BaseModel):
     id_list: int
 
 
-class AuthRuleNodeChangeInfo(BaseModel):
+class AuthRuleChangeInfo(BaseModel):
     id: int
     name: str
-    belong: Union[None, int]
+    category1: Union[None, str]
+    category2: Union[None, str]
+
+
+class AuthRuleQueryParams(BaseModel):
+    id: int
+    name: Union[str, None]
+    category1: Union[int, None]
+    category2: Union[int, None]
+    page_size: Union[str, None]
+    page: Union[str, None]
 
 
 class AuthRuleConfigQueryParams(BaseModel):
@@ -43,10 +53,38 @@ class AuthRuleConfigQueryParams(BaseModel):
     page: Union[int, None]
 
 
+class AuthRuleConfigAddInfo(BaseModel):
+    id: int
+    name: str
+    auth_data: str
+
+
 class AuthRuleConfigInfo(BaseModel):
     id: int
     name: str
-    auth_data:str
+    auth_data: str
+
 
 class AuthRuleConfigInfoList(BaseModel):
-    data:List[AuthRuleConfigInfo]
\ No newline at end of file
+    data: List[AuthRuleConfigInfo]
+
+
+class AuthRuleInfoList(BaseModel):
+    data: List[AuthRuleConfigInfo]
+
+
+class AuthCategoryAddInfo(BaseModel):
+    name: str
+    category_level: int
+    belong: Union[int, None]
+
+
+class AuthCategoryChangeInfo(BaseModel):
+    id: int
+    name: str
+    category_level: int
+    belong: Union[int, None]
+
+
+class AuthCategoryId(BaseModel):
+    id: str
diff --git a/requirements.txt b/requirements.txt
index 3861679..fa05e30 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,4 +8,5 @@ python-jose==3.3.0
 cryptography==39.0.0
 requests==2.28.2
 captcha==0.4
-pymysql==1.0.2
\ No newline at end of file
+pymysql==1.0.2
+fastapi-crudrouter==0.8.6