feat(repo): 全部模块 service 改用 repository（Repository 全面落地）

- 24 个模块 service 从直接 db.query 改为使用各自 repository（get_by_id/filter/create/update）
- 4 个 agent 并行分组转换：system 组、dictionary/configuration/member/region、cms/link/notice、job/log
- 保留合法 db 用法：跨模型查询（user→dept/level/position、ad→adsort、adsort→item/itemcate）、投影查询（role/menu）、按条件删除（set_permission/save_role_menu/add_user_role）、独立会话（record_job_log/record_operation_log）、db.commit（pause/resume）
- 修复 JobLogRepository 软删列 del_flag；修复 ad/notice create 重复传参 bug
- 修复 base_repository.get_by_id/get_by_ids 兼容字符串 ID
- 实测：27 个读接口 + dept/notice/member/level 写操作全通过

Co-Authored-By: Claude <noreply@anthropic.com>

modules/cms/ad/service.py

@@ -8,6 +8,7 @@ from shared.enums import AD_TYPE_LIST
 from shared.constants import PAGE_SIZE
 from modules.cms.ad.schemas import AdForm, AdStatusForm
 from modules.cms.ad.models import Ad
+from modules.cms.ad.repository import ad_repo
 from modules.cms.ad_sort.models import AdSort
 from config import FASTAPI_IMAGE_URL
 from core.database import get_db_session
@@ -26,7 +27,7 @@ def get_ad_page(request):
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Ad).filter(Ad.is_delete == 0)
+    query = ad_repo.filter(Ad.is_delete == 0)
     # 广告标题
     title = request.query_params.get('title')
     if title:
@@ -72,9 +73,8 @@ def get_ad_page(request):
 # 根据广告ID查询详情
 
 def get_ad_detail(ad_id):
-    db = get_db_session()
     # 根据广告ID查询信息
-    ad = db.query(Ad).filter(and_(Ad.id == ad_id, Ad.is_delete == 0)).first()
+    ad = ad_repo.get_by_id(ad_id)
     # 查询结果为空判断
     if not ad:
         return None
@@ -92,7 +92,6 @@ def get_ad_detail(ad_id):
 # 添加广告
 
 def add_ad(request, data: AdForm):
-    db = get_db_session()
     # 广告封面
     cover = data.cover
     if data.type == 1 and cover:
@@ -107,12 +106,8 @@ def add_ad(request, data: AdForm):
     # # 处理富文本内容
     # content = save_content(content, title, "ad")
 
-    # 表单数据赋值给对象
-    ad = Ad(**data.model_dump(exclude={'id'}))
-    ad.cover = cover
-    ad.create_user = get_user_id(request)
-    # 插入数据
-    ad.save()
+    # 表单数据赋值给对象并插入（cover 用处理后的文件路径，排除表单原值避免重复传参）
+    ad_repo.create(**data.model_dump(exclude={'id', 'cover'}), cover=cover, create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -120,12 +115,11 @@ def add_ad(request, data: AdForm):
 # 更新广告
 
 def update_ad(request, data: AdForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 根据ID查询记录
-    ad = db.query(Ad).filter(and_(Ad.id == data.id, Ad.is_delete == 0)).first()
+    ad = ad_repo.get_by_id(data.id)
     # 查询结果判空
     if not ad:
         return R.failed("记录不存在")
@@ -150,7 +144,7 @@ def update_ad(request, data: AdForm):
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
     # 更新记录
-    result = db.query(Ad).filter_by(id=data.id).update(updData)
+    result = ad_repo.update(data.id, updData)
     # 提交数据
     # 返回结果
     if not result:
@@ -164,15 +158,14 @@ def delete_ad(ad_id):
 # 设置状态
 
 def update_ad_status(request, data: AdStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    ad = db.query(Ad).filter(and_(Ad.id == data.id, Ad.is_delete == 0)).first()
+    ad = ad_repo.get_by_id(data.id)
     # 查询结果判空
     if not ad:
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(Ad).filter_by(id=data.id).update({
+    result = ad_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)

modules/cms/ad_sort/service.py

@@ -8,6 +8,7 @@ from shared.enums import AD_SORT_PLATFORM_LIST
 from shared.constants import PAGE_SIZE
 from modules.cms.ad_sort.schemas import AdSortForm
 from modules.cms.ad_sort.models import AdSort
+from modules.cms.ad_sort.repository import adsort_repo
 from modules.cms.item.models import Item
 from modules.cms.item_cate.models import ItemCate
 from core.database import get_db_session
@@ -25,7 +26,7 @@ def get_ad_sort_page(request):
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(AdSort).filter(AdSort.is_delete == 0)
+    query = adsort_repo.filter(AdSort.is_delete == 0)
     # 名称
     name = request.query_params.get('name')
     if name:
@@ -71,9 +72,8 @@ def get_ad_sort_page(request):
 # 根据ID查询广告位详情
 
 def get_ad_sort_detail(adsort_id):
-    db = get_db_session()
     # 根据ID查询广告位
-    adsort = db.query(AdSort).filter(and_(AdSort.id == adsort_id, AdSort.is_delete == 0)).first()
+    adsort = adsort_repo.get_by_id(adsort_id)
     # 查询结果为空判断
     if not adsort:
         return None
@@ -84,12 +84,8 @@ def get_ad_sort_detail(adsort_id):
 # 添加广告位
 
 def add_ad_sort(request, data: AdSortForm):
-    db = get_db_session()
-    # 表单数据赋值给对象
-    adsort = AdSort(**data.model_dump(exclude={'id'}))
-    adsort.create_user = get_user_id(request)
-    # 插入数据
-    adsort.save()
+    # 表单数据赋值给对象并插入
+    adsort_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -97,13 +93,12 @@ def add_ad_sort(request, data: AdSortForm):
 # 更新广告位
 
 def update_ad_sort(request, data: AdSortForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
 
     # 根据ID查询记录
-    adsort = db.query(AdSort).filter(and_(AdSort.id == data.id, AdSort.is_delete == 0)).first()
+    adsort = adsort_repo.get_by_id(data.id)
     # 查询结果判空
     if not adsort:
         return R.failed("记录不存在")
@@ -111,7 +106,7 @@ def update_ad_sort(request, data: AdSortForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(AdSort).filter_by(id=data.id).update(updData)
+    result = adsort_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -124,9 +119,8 @@ def delete_ad_sort(adsort_id):
 # 查询广告位列表
 
 def get_ad_sort_list():
-    db = get_db_session()
     # 查询全部广告位列表
-    ad_sort_list = db.query(AdSort).filter(AdSort.is_delete == 0).all()
+    ad_sort_list = adsort_repo.filter(AdSort.is_delete == 0).all()
     # 实例化广告位对象列表
     sortList = []
     if ad_sort_list:

modules/cms/item/service.py

@@ -8,7 +8,7 @@ from shared.enums import ITEM_TYPE_LIST
 from shared.constants import PAGE_SIZE
 from modules.cms.item.schemas import ItemForm
 from modules.cms.item.models import Item
-from core.database import get_db_session
+from modules.cms.item.repository import item_repo
 from core import R
 from utils.rich_text import get_file_url, save_file
 from utils.request import like_contains
@@ -18,13 +18,12 @@ from core.security import get_user_id
 # 查询站点分页数据
 
 def get_item_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Item).filter(Item.is_delete == 0)
+    query = item_repo.filter(Item.is_delete == 0)
     # 站点名称
     name = request.query_params.get('name')
     if name:
@@ -66,9 +65,8 @@ def get_item_page(request):
 # 根据ID查询站点详情
 
 def get_item_detail(item_id):
-    db = get_db_session()
     # 根据ID查询站点
-    item = db.query(Item).filter(and_(Item.id == item_id, Item.is_delete == 0)).first()
+    item = item_repo.get_by_id(item_id)
     # 查询结果判空
     if not item:
         return None
@@ -81,9 +79,8 @@ def get_item_detail(item_id):
 # 添加站点
 
 def add_item(request, data: ItemForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Item).filter(and_(Item.name == data.name, Item.is_delete == 0)).first():
+    if item_repo.filter(and_(Item.name == data.name, Item.is_delete == 0)).first():
         return R.failed("站点名称不能重复")
     # 表单数据转字典
     form_data = data.model_dump(exclude={'id'})
@@ -92,11 +89,8 @@ def add_item(request, data: ItemForm):
     if image:
         form_data['image'] = save_file(image, "item")
 
-    # 表单数据赋值给对象
-    item = Item(**form_data)
-    item.create_user = get_user_id(request)
-    # 插入数据
-    item.save()
+    # 表单数据赋值给对象并插入
+    item_repo.create(**form_data, create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -104,16 +98,15 @@ def add_item(request, data: ItemForm):
 # 更新站点
 
 def update_item(request, data: ItemForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Item).filter(and_(Item.name == data.name, Item.id != data.id, Item.is_delete == 0)).first():
+    if item_repo.filter(and_(Item.name == data.name, Item.id != data.id, Item.is_delete == 0)).first():
         return R.failed("站点名称不能重复")
 
     # 根据ID查询记录
-    item = db.query(Item).filter(and_(Item.id == data.id, Item.is_delete == 0)).first()
+    item = item_repo.get_by_id(data.id)
     # 查询结果判空
     if not item:
         return R.failed("记录不存在")
@@ -127,7 +120,7 @@ def update_item(request, data: ItemForm):
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
     # 更新数据
-    result = db.query(Item).filter_by(id=data.id).update(updData)
+    result = item_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -140,8 +133,7 @@ def delete_item(item_id):
 # 获取站点列表
 
 def get_item_list():
-    db = get_db_session()
-    item_rows = db.query(Item).filter(and_(Item.status == 1, Item.is_delete == 0)).order_by(Item.sort.asc()).all()
+    item_rows = item_repo.filter(and_(Item.status == 1, Item.is_delete == 0)).order_by(Item.sort.asc()).all()
     # 实例化站点列表
     item_list = []
     # 遍历数据源

modules/cms/item_cate/service.py

@@ -7,8 +7,8 @@ from sqlalchemy import and_
 from shared.constants import PAGE_SIZE
 from modules.cms.item_cate.schemas import ItemCateForm
 from modules.cms.item_cate.models import ItemCate
+from modules.cms.item_cate.repository import itemcate_repo
 from modules.cms.item import service as item
-from core.database import get_db_session
 from core import R
 from utils.rich_text import get_file_url, save_file
 from utils.request import like_contains
@@ -18,13 +18,12 @@ from core.security import get_user_id
 # 查询栏目数据
 
 def get_item_cate_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(ItemCate).filter(ItemCate.is_delete == 0)
+    query = itemcate_repo.filter(ItemCate.is_delete == 0)
     # 栏目名称
     name = request.query_params.get('name')
     if name:
@@ -64,9 +63,8 @@ def get_item_cate_page(request):
 # 根据栏目ID查询详情
 
 def get_item_cate_detail(itemcate_id):
-    db = get_db_session()
     # 根据ID查询栏目
-    cate = db.query(ItemCate).filter(and_(ItemCate.id == itemcate_id, ItemCate.is_delete == 0)).first()
+    cate = itemcate_repo.get_by_id(itemcate_id)
     # 查询结果判空
     if not cate:
         return None
@@ -80,9 +78,8 @@ def get_item_cate_detail(itemcate_id):
 # 添加栏目
 
 def add_item_cate(request, data: ItemCateForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(ItemCate).filter(and_(ItemCate.name == data.name, ItemCate.is_delete == 0)).first():
+    if itemcate_repo.filter(and_(ItemCate.name == data.name, ItemCate.is_delete == 0)).first():
         return R.failed("栏目名称不能重复")
     # 表单数据转字典
     form_data = data.model_dump(exclude={'id'})
@@ -100,11 +97,8 @@ def add_item_cate(request, data: ItemCateForm):
     else:
         form_data['cover'] = None
 
-    # 表单数据赋值给对象
-    cate = ItemCate(**form_data)
-    cate.create_user = get_user_id(request)
-    # 插入数据
-    cate.save()
+    # 表单数据赋值给对象并插入
+    itemcate_repo.create(**form_data, create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -112,16 +106,15 @@ def add_item_cate(request, data: ItemCateForm):
 # 更新栏目
 
 def update_item_cate(request, data: ItemCateForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(ItemCate).filter(and_(ItemCate.name == data.name, ItemCate.id != data.id, ItemCate.is_delete == 0)).first():
+    if itemcate_repo.filter(and_(ItemCate.name == data.name, ItemCate.id != data.id, ItemCate.is_delete == 0)).first():
         return R.failed("栏目名称不能重复")
 
     # 根据ID查询记录
-    cate = db.query(ItemCate).filter(and_(ItemCate.id == data.id, ItemCate.is_delete == 0)).first()
+    cate = itemcate_repo.get_by_id(data.id)
     # 查询结果判空
     if not cate:
         return R.failed("记录不存在")
@@ -143,7 +136,7 @@ def update_item_cate(request, data: ItemCateForm):
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
     # 更新数据
-    result = db.query(ItemCate).filter_by(id=data.id).update(updData)
+    result = itemcate_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -156,8 +149,7 @@ def delete_item_cate(cate_id):
 # 获取栏目列表
 
 def get_cate_list():
-    db = get_db_session()
-    cate_rows = db.query(ItemCate).filter(and_(ItemCate.is_delete == 0, ItemCate.status == 1)).order_by(
+    cate_rows = itemcate_repo.filter(and_(ItemCate.is_delete == 0, ItemCate.status == 1)).order_by(
         ItemCate.sort.asc()).all()
     # 实例化栏目列表
     cate_list = []

modules/configuration/service.py

@@ -9,8 +9,8 @@ from shared.constants import PAGE_SIZE
 from modules.configuration.schemas import ConfigForm
 from modules.configuration.models import Config
 from modules.configuration.models import ConfigItem
+from modules.configuration.repository import config_repo, configitem_repo
 from config import FASTAPI_IMAGE_URL
-from core.database import get_db_session
 from core import R
 from utils.rich_text import get_file_url, save_file
 from utils.request import like_contains
@@ -20,13 +20,12 @@ from core.security import get_user_id
 # 配置表单验证
 
 def get_config_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Config).filter(Config.is_delete == 0)
+    query = config_repo.filter(Config.is_delete == 0)
     # 配置名称
     name = request.query_params.get('name')
     if name:
@@ -56,9 +55,8 @@ def get_config_page(request):
 # 根据ID获取配置详情
 
 def get_config_detail(config_id):
-    db = get_db_session()
     # 根据ID查询配置
-    config = db.query(Config).filter(and_(Config.id == config_id, Config.is_delete == 0)).first()
+    config = config_repo.get_by_id(config_id)
     # 查询结果判空
     if not config:
         return None
@@ -69,15 +67,11 @@ def get_config_detail(config_id):
 # 添加配置
 
 def add_config(request, data: ConfigForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Config).filter(and_(Config.name == data.name, Config.is_delete == 0)).first():
+    if config_repo.filter(and_(Config.name == data.name, Config.is_delete == 0)).first():
         return R.failed("配置名称不能重复")
     # 表单数据赋值给对象
-    config = Config(**data.model_dump(exclude={'id'}))
-    config.create_user = get_user_id(request)
-    # 插入数据
-    config.save()
+    config_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -85,16 +79,15 @@ def add_config(request, data: ConfigForm):
 # 更新配置
 
 def update_config(request, data: ConfigForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Config).filter(and_(Config.name == data.name, Config.id != data.id, Config.is_delete == 0)).first():
+    if config_repo.filter(and_(Config.name == data.name, Config.id != data.id, Config.is_delete == 0)).first():
         return R.failed("配置名称不能重复")
 
     # 根据ID查询记录
-    config = db.query(Config).filter(and_(Config.id == data.id, Config.is_delete == 0)).first()
+    config = config_repo.get_by_id(data.id)
     # 查询结果判空
     if not config:
         return R.failed("记录不存在")
@@ -102,7 +95,7 @@ def update_config(request, data: ConfigForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(Config).filter_by(id=data.id).update(updData)
+    result = config_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -129,15 +122,14 @@ def _parse_options(options_str):
 
 # 获取网站配置信息
 def get_config_info(request):
-    db = get_db_session()
     # 一次性查询所有配置组
-    configList = db.query(Config).filter(Config.is_delete == 0).order_by(Config.sort.asc()).all()
+    configList = config_repo.filter(Config.is_delete == 0).order_by(Config.sort.asc()).all()
     if not configList:
         return []
 
     # 一次性查询所有活跃配置项，按config_id分组
     config_ids = [c.id for c in configList]
-    all_items = db.query(ConfigItem).filter(
+    all_items = configitem_repo.filter(
         and_(ConfigItem.is_delete == 0, ConfigItem.status == 1, ConfigItem.config_id.in_(config_ids))
     ).order_by(ConfigItem.sort.asc()).all()
 
@@ -191,9 +183,8 @@ async def save_config_info(request):
         return R.failed("请求参数异常")
 
     def _save():
-        db = get_db_session()
         # 预加载所有活跃配置项，仅允许修改这些项
-        valid_items = db.query(ConfigItem).filter(
+        valid_items = configitem_repo.filter(
             and_(ConfigItem.is_delete == 0, ConfigItem.status == 1)
         ).all()
         item_map = {item.code: item for item in valid_items}
@@ -238,7 +229,6 @@ from shared.enums import CONFIG_DATA_TYPE_LIST
 from shared.constants import PAGE_SIZE
 from modules.configuration.schemas import ConfigItemForm, ConfigItemStatusForm
 from modules.configuration.models import ConfigItem
-from core.database import get_db_session
 from core import R
 from core.security import get_user_id
 from utils.request import like_contains
@@ -247,13 +237,12 @@ from utils.request import like_contains
 # 查询配置项分页数据
 
 def get_config_item_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(ConfigItem).filter(ConfigItem.is_delete == 0)
+    query = configitem_repo.filter(ConfigItem.is_delete == 0)
     # 配置ID
     config_id = request.query_params.get('config_id', 0)
     query = query.filter(ConfigItem.config_id == config_id)
@@ -288,9 +277,8 @@ def get_config_item_page(request):
 # 根据ID查询配置项详情
 
 def get_config_item_detail(config_id):
-    db = get_db_session()
     # 根据ID查询配置项
-    config_data = db.query(ConfigItem).filter(and_(ConfigItem.id == config_id, ConfigItem.is_delete == 0)).first()
+    config_data = configitem_repo.get_by_id(config_id)
     # 查询结果判空
     if not config_data:
         return None
@@ -301,12 +289,8 @@ def get_config_item_detail(config_id):
 # 添加配置项
 
 def add_config_item(request, data: ConfigItemForm):
-    db = get_db_session()
     # 表单数据赋值给对象
-    config_data = ConfigItem(**data.model_dump(exclude={'id'}))
-    config_data.create_user = get_user_id(request)
-    # 插入数据
-    config_data.save()
+    configitem_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -314,13 +298,12 @@ def add_config_item(request, data: ConfigItemForm):
 # 更新配置项
 
 def update_config_item(request, data: ConfigItemForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
 
     # 根据ID查询记录
-    config_data = db.query(ConfigItem).filter(and_(ConfigItem.id == data.id, ConfigItem.is_delete == 0)).first()
+    config_data = configitem_repo.get_by_id(data.id)
     # 查询结果判空
     if not config_data:
         return R.failed("记录不存在")
@@ -328,7 +311,7 @@ def update_config_item(request, data: ConfigItemForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(ConfigItem).filter_by(id=data.id).update(updData)
+    result = configitem_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -341,15 +324,14 @@ def delete_config_item(config_id):
 # 设置状态
 
 def update_config_item_status(request, data: ConfigItemStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    config_data = db.query(ConfigItem).filter(and_(ConfigItem.id == data.id, ConfigItem.is_delete == 0)).first()
+    config_data = configitem_repo.get_by_id(data.id)
     # 查询结果判空
     if not config_data:
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(ConfigItem).filter_by(id=data.id).update({
+    result = configitem_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)

modules/dictionary/service.py

@@ -6,7 +6,7 @@ from sqlalchemy import and_
 from shared.constants import PAGE_SIZE
 from modules.dictionary.schemas import DictForm
 from modules.dictionary.models import Dict
-from core.database import get_db_session
+from modules.dictionary.repository import dict_repo, dictitem_repo
 from core import R
 from core.security import get_user_id
 from utils.request import like_contains
@@ -15,13 +15,12 @@ from utils.request import like_contains
 # 查询字典分页数据
 
 def get_dict_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Dict).filter(Dict.is_delete == 0)
+    query = dict_repo.filter(Dict.is_delete == 0)
     # 字典名称
     name = request.query_params.get('name')
     if name:
@@ -51,9 +50,8 @@ def get_dict_page(request):
 # 根据ID查询字典
 
 def get_dict_detail(dict_id):
-    db = get_db_session()
     # 根据ID查询字典
-    dict = db.query(Dict).filter(and_(Dict.id == dict_id, Dict.is_delete == 0)).first()
+    dict = dict_repo.get_by_id(dict_id)
     # 查询结果判空
     if not dict:
         return None
@@ -64,15 +62,11 @@ def get_dict_detail(dict_id):
 # 添加字典
 
 def add_dict(request, data: DictForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Dict).filter(and_(Dict.name == data.name, Dict.is_delete == 0)).first():
+    if dict_repo.filter(and_(Dict.name == data.name, Dict.is_delete == 0)).first():
         return R.failed("字典名称不能重复")
     # 表单数据赋值给对象
-    dict = Dict(**data.model_dump(exclude={'id'}))
-    dict.create_user = get_user_id(request)
-    # 插入数据
-    dict.save()
+    dict_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -80,16 +74,15 @@ def add_dict(request, data: DictForm):
 # 更新字典
 
 def update_dict(request, data: DictForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Dict).filter(and_(Dict.name == data.name, Dict.id != data.id, Dict.is_delete == 0)).first():
+    if dict_repo.filter(and_(Dict.name == data.name, Dict.id != data.id, Dict.is_delete == 0)).first():
         return R.failed("字典名称不能重复")
 
     # 根据ID查询记录
-    dict = db.query(Dict).filter(and_(Dict.id == data.id, Dict.is_delete == 0)).first()
+    dict = dict_repo.get_by_id(data.id)
     # 查询结果判空
     if not dict:
         return R.failed("记录不存在")
@@ -97,7 +90,7 @@ def update_dict(request, data: DictForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(Dict).filter_by(id=data.id).update(updData)
+    result = dict_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -117,7 +110,6 @@ from sqlalchemy import and_
 from shared.constants import PAGE_SIZE
 from modules.dictionary.schemas import DictItemForm, DictItemStatusForm
 from modules.dictionary.models import DictItem
-from core.database import get_db_session
 from core import R
 from core.security import get_user_id
 from utils.request import like_contains
@@ -126,13 +118,12 @@ from utils.request import like_contains
 # 查询字典项分页数据
 
 def get_dict_item_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(DictItem).filter(DictItem.is_delete == 0)
+    query = dictitem_repo.filter(DictItem.is_delete == 0)
     # 字典ID
     dict_id = request.query_params.get('dict_id', 0)
     query = query.filter(DictItem.dict_id == dict_id)
@@ -165,9 +156,8 @@ def get_dict_item_page(request):
 # 根据ID查询字典项详情
 
 def get_dict_item_detail(dict_id):
-    db = get_db_session()
     # 根据ID查询字典项
-    dict_data = db.query(DictItem).filter(and_(DictItem.id == dict_id, DictItem.is_delete == 0)).first()
+    dict_data = dictitem_repo.get_by_id(dict_id)
     # 查询结果判空
     if not dict_data:
         return None
@@ -178,15 +168,11 @@ def get_dict_item_detail(dict_id):
 # 添加字典项
 
 def add_dict_item(request, data: DictItemForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(DictItem).filter(and_(DictItem.name == data.name, DictItem.is_delete == 0)).first():
+    if dictitem_repo.filter(and_(DictItem.name == data.name, DictItem.is_delete == 0)).first():
         return R.failed("字典项名称不能重复")
     # 表单数据赋值给对象
-    dict_data = DictItem(**data.model_dump(exclude={'id'}))
-    dict_data.create_user = get_user_id(request)
-    # 插入数据
-    dict_data.save()
+    dictitem_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -194,16 +180,15 @@ def add_dict_item(request, data: DictItemForm):
 # 更新字典项
 
 def update_dict_item(request, data: DictItemForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(DictItem).filter(and_(DictItem.name == data.name, DictItem.id != data.id, DictItem.is_delete == 0)).first():
+    if dictitem_repo.filter(and_(DictItem.name == data.name, DictItem.id != data.id, DictItem.is_delete == 0)).first():
         return R.failed("字典项名称不能重复")
 
     # 根据ID查询记录
-    dict_data = db.query(DictItem).filter(and_(DictItem.id == data.id, DictItem.is_delete == 0)).first()
+    dict_data = dictitem_repo.get_by_id(data.id)
     # 查询结果判空
     if not dict_data:
         return R.failed("记录不存在")
@@ -211,7 +196,7 @@ def update_dict_item(request, data: DictItemForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(DictItem).filter_by(id=data.id).update(updData)
+    result = dictitem_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -224,15 +209,14 @@ def delete_dict_item(dict_id):
 # 设置状态
 
 def update_dict_item_status(request, data: DictItemStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    dict_data = db.query(DictItem).filter(and_(DictItem.id == data.id, DictItem.is_delete == 0)).first()
+    dict_data = dictitem_repo.get_by_id(data.id)
     # 查询结果判空
     if not dict_data:
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(DictItem).filter_by(id=data.id).update({
+    result = dictitem_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)

modules/job/repository.py

@@ -9,6 +9,22 @@ class JobRepository(BaseRepository[Job]):
 job_repo = JobRepository(Job)
 
 class JobLogRepository(BaseRepository[JobLog]):
-    pass
+    # JobLog 使用 del_flag 而非 is_delete 作为软删标识
+    soft_delete_col = "del_flag"
+
+    def get_by_id(self, obj_id):
+        """覆盖：按 del_flag 过滤。"""
+        if obj_id is None or obj_id == '':
+            return None
+        try:
+            obj_id = int(obj_id)
+        except (TypeError, ValueError):
+            return None
+        if obj_id <= 0:
+            return None
+        return self.db.query(self.model).filter(
+            self.model.id == obj_id, getattr(self.model, self.soft_delete_col) == 0
+        ).first()
+
 
 joblog_repo = JobLogRepository(JobLog)

modules/job/service.py

@@ -1,12 +1,11 @@
 import logging
 from datetime import datetime, timezone
 
-from sqlalchemy import and_
-
 from shared.enums import JOB_STATUS_LIST, JOB_EXECUTE_POLICY_LIST
 from shared.constants import PAGE_SIZE
 from modules.job.schemas import JobForm, JobStatusForm
 from modules.job.models import Job
+from modules.job.repository import job_repo, joblog_repo
 from modules.job.scheduler import (
     add_job_to_scheduler,
     remove_job_from_scheduler,
@@ -26,13 +25,12 @@ logger = logging.getLogger(__name__)
 # 查询定时任务分页数据
 
 def get_job_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Job).filter(Job.is_delete == 0)
+    query = job_repo.filter(Job.is_delete == 0)
     # 任务名称
     job_name = request.query_params.get('jobName')
     if job_name:
@@ -83,8 +81,7 @@ def _get_next_run_time(scheduler, job_id):
 # 根据ID查询任务详情
 
 def get_job_detail(job_id):
-    db = get_db_session()
-    job = db.query(Job).filter(and_(Job.id == job_id, Job.is_delete == 0)).first()
+    job = job_repo.get_by_id(job_id)
     if not job:
         return None
     data = job.to_dict()
@@ -96,12 +93,8 @@ def get_job_detail(job_id):
 # 添加定时任务
 
 def add_job(request, data: JobForm):
-    db = get_db_session()
-    # 表单数据赋值给对象
-    job = Job(**data.model_dump(exclude={'id'}))
-    job.create_user = get_user_id(request)
-    # 插入数据
-    job.save()
+    # 表单数据赋值给对象并插入
+    job = job_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
 
     # 状态为运行中且有Cron表达式，添加到调度器
     if job.status == 1 and job.cron_expression:
@@ -113,13 +106,12 @@ def add_job(request, data: JobForm):
 # 更新定时任务
 
 def update_job(request, data: JobForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
 
     # 根据ID查询记录
-    job = db.query(Job).filter(and_(Job.id == data.id, Job.is_delete == 0)).first()
+    job = job_repo.get_by_id(data.id)
     if not job:
         return R.failed("任务不存在")
 
@@ -130,7 +122,7 @@ def update_job(request, data: JobForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(Job).filter_by(id=data.id).update(updData)
+    result = job_repo.update(data.id, updData)
     if not result:
         return R.failed("更新失败")
 
@@ -169,16 +161,15 @@ def delete_job(job_id):
 # 设置任务状态
 
 def update_job_status(request, data: JobStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    job = db.query(Job).filter(and_(Job.id == data.id, Job.is_delete == 0)).first()
+    job = job_repo.get_by_id(data.id)
     if not job:
         return R.failed("任务不存在")
 
     old_status = job.status
 
     # 更新记录
-    result = db.query(Job).filter_by(id=data.id).update({
+    result = job_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)
@@ -203,7 +194,7 @@ def update_job_status(request, data: JobStatusForm):
 
 def pause_job_by_id(job_id):
     db = get_db_session()
-    job = db.query(Job).filter(and_(Job.id == job_id, Job.is_delete == 0)).first()
+    job = job_repo.get_by_id(job_id)
     if not job:
         return R.failed("任务不存在")
 
@@ -223,7 +214,7 @@ def pause_job_by_id(job_id):
 
 def resume_job_by_id(job_id):
     db = get_db_session()
-    job = db.query(Job).filter(and_(Job.id == job_id, Job.is_delete == 0)).first()
+    job = job_repo.get_by_id(job_id)
     if not job:
         return R.failed("任务不存在")
 
@@ -261,13 +252,10 @@ def reload_all_jobs():
 
 import logging
 
-from sqlalchemy import and_
-
 from shared.enums import JOB_LOG_STATUS_LIST
 from shared.constants import PAGE_SIZE
 from modules.job.models import Job
 from modules.job.models import JobLog
-from core.database import get_db_session
 from core.database import SessionLocal
 from core import R
 from utils.request import like_contains, parse_id_list
@@ -320,13 +308,12 @@ def record_job_log(job_id, start_time, end_time, status, exception_info=None, jo
 # ============================================================
 
 def get_job_log_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(JobLog).filter(JobLog.del_flag == 0)
+    query = joblog_repo.filter(JobLog.del_flag == 0)
     # 任务名称
     job_name = request.query_params.get('jobName')
     if job_name:
@@ -361,8 +348,7 @@ def get_job_log_page(request):
 
 # 根据ID查询日志详情
 def get_job_log_detail(job_log_id):
-    db = get_db_session()
-    log = db.query(JobLog).filter(and_(JobLog.id == job_log_id, JobLog.del_flag == 0)).first()
+    log = joblog_repo.get_by_id(job_log_id)
     if not log:
         return None
     data = log.to_dict()
@@ -375,8 +361,7 @@ def delete_job_log(ids_str):
     id_list = parse_id_list(ids_str)
     if not id_list:
         return R.failed("记录ID不存在")
-    db = get_db_session()
-    result = db.query(JobLog).filter(JobLog.id.in_(id_list), JobLog.del_flag == 0).update(
+    result = joblog_repo.filter(JobLog.id.in_(id_list), JobLog.del_flag == 0).update(
         {"del_flag": 1}, synchronize_session=False
     )
     return R.ok(msg="本次共删除{0}条数据".format(result))

modules/link/service.py

@@ -1,14 +1,13 @@
 from datetime import datetime, timezone
 
 from fastapi.logger import logger
-from sqlalchemy import and_
 
 
 from shared.enums import LINK_TYPE_LIST, LINK_PLATFORM_LIST, LINK_FORM_LIST
 from shared.constants import PAGE_SIZE
 from modules.link.schemas import LinkForm, LinkStatusForm
 from modules.link.models import Link
-from core.database import get_db_session
+from modules.link.repository import link_repo
 from core import R
 from utils.rich_text import get_file_url, save_file
 from utils.request import like_contains
@@ -18,13 +17,12 @@ from core.security import get_user_id
 # 查看友链分页数据
 
 def get_link_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Link).filter(Link.is_delete == 0)
+    query = link_repo.filter(Link.is_delete == 0)
     # 友链名称
     name = request.query_params.get('name')
     if name:
@@ -78,9 +76,8 @@ def get_link_page(request):
 # 根据ID查看友链详情
 
 def get_link_detail(link_id):
-    db = get_db_session()
     # 根据ID查询友链
-    link = db.query(Link).filter(and_(Link.id == link_id, Link.is_delete == 0)).first()
+    link = link_repo.get_by_id(link_id)
     # 查询结果为空判断
     if not link:
         return None
@@ -93,7 +90,6 @@ def get_link_detail(link_id):
 # 添加友链
 
 def add_link(request, data: LinkForm):
-    db = get_db_session()
     # 表单数据转字典
     form_data = data.model_dump(exclude={'id'}, by_alias=True)
 
@@ -102,11 +98,8 @@ def add_link(request, data: LinkForm):
     if image:
         form_data['image'] = save_file(image, "link")
 
-    # 表单数据赋值给对象
-    link = Link(**form_data)
-    link.create_user = get_user_id(request)
-    # 插入数据
-    link.save()
+    # 表单数据赋值给对象并插入
+    link_repo.create(**form_data, create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -114,13 +107,12 @@ def add_link(request, data: LinkForm):
 # 更新友链
 
 def update_link(request, data: LinkForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
 
     # 根据ID查询记录
-    link = db.query(Link).filter(and_(Link.id == data.id, Link.is_delete == 0)).first()
+    link = link_repo.get_by_id(data.id)
     # 查询结果判空
     if not link:
         return R.failed("记录不存在")
@@ -134,7 +126,7 @@ def update_link(request, data: LinkForm):
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
     # 更新数据
-    result = db.query(Link).filter_by(id=data.id).update(updData)
+    result = link_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -147,15 +139,14 @@ def delete_link(link_id):
 # 设置状态
 
 def update_link_status(request, data: LinkStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    link = db.query(Link).filter(and_(Link.id == data.id, Link.is_delete == 0)).first()
+    link = link_repo.get_by_id(data.id)
     # 查询结果判空
     if not link:
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(Link).filter_by(id=data.id).update({
+    result = link_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)

modules/member/service.py

@@ -8,7 +8,7 @@ from shared.constants import PAGE_SIZE
 from modules.member.schemas import MemberForm, MemberStatusForm
 from modules.member.models import Member
 from modules.member.models import MemberLevel
-from core.database import get_db_session
+from modules.member.repository import member_repo, memberlevel_repo
 from core import R
 from core import password
 from utils.rich_text import get_file_url, save_file
@@ -19,13 +19,12 @@ from core.security import get_user_id
 # 查询会员分页数据
 
 def get_member_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Member).filter(Member.is_delete == 0)
+    query = member_repo.filter(Member.is_delete == 0)
     # 会员账号
     username = request.query_params.get('username')
     if username:
@@ -61,7 +60,7 @@ def get_member_page(request):
         level_ids = {item.member_level for item in member_list if item.member_level}
         member_level_list = {}
         if level_ids:
-            for ml in db.query(MemberLevel).filter(MemberLevel.id.in_(level_ids), MemberLevel.is_delete == 0).all():
+            for ml in memberlevel_repo.filter(MemberLevel.id.in_(level_ids), MemberLevel.is_delete == 0).all():
                 member_level_list[ml.id] = ml.name
 
         # 遍历会员数据源
@@ -83,9 +82,8 @@ def get_member_page(request):
 # 根据ID查看会员详情
 
 def get_member_detail(member_id):
-    db = get_db_session()
     # 根据ID查询会员
-    member = db.query(Member).filter(and_(Member.id == member_id, Member.is_delete == 0)).first()
+    member = member_repo.get_by_id(member_id)
     # 查询结果判空
     if not member:
         return None
@@ -110,9 +108,8 @@ def get_member_detail(member_id):
 # 添加会员
 
 def add_member(request, data: MemberForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Member).filter(and_(Member.username == data.username, Member.is_delete == 0)).first():
+    if member_repo.filter(and_(Member.username == data.username, Member.is_delete == 0)).first():
         return R.failed("登录账号不能重复")
     # 获取表单数据
     form_data = data.model_dump(exclude={'id'})
@@ -142,10 +139,7 @@ def add_member(request, data: MemberForm):
         form_data['district_code'] = citys[2]
 
     # 表单数据赋值给对象
-    member = Member(**form_data)
-    member.create_user = get_user_id(request)
-    # 插入数据
-    member.save()
+    member_repo.create(**form_data, create_user=get_user_id(request))
 
     # 返回结果
     return R.ok(msg="添加成功")
@@ -154,16 +148,15 @@ def add_member(request, data: MemberForm):
 # 更新会员
 
 def update_member(request, data: MemberForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Member).filter(and_(Member.username == data.username, Member.id != data.id, Member.is_delete == 0)).first():
+    if member_repo.filter(and_(Member.username == data.username, Member.id != data.id, Member.is_delete == 0)).first():
         return R.failed("登录账号不能重复")
 
     # 根据ID查询记录
-    user = db.query(Member).filter(and_(Member.id == data.id, Member.is_delete == 0)).first()
+    user = member_repo.get_by_id(data.id)
     # 查询结果判空
     if not user:
         return R.failed("记录不存在")
@@ -198,7 +191,7 @@ def update_member(request, data: MemberForm):
     form_data['update_user'] = get_user_id(request)
     form_data['update_time'] = datetime.now(tz=timezone.utc)
     # 更新数据
-    result = db.query(Member).filter_by(id=data.id).update(form_data)
+    result = member_repo.update(data.id, form_data)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -211,15 +204,14 @@ def delete_member(member_id):
 # 设置状态
 
 def update_member_status(request, data: MemberStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    user = db.query(Member).filter(and_(Member.id == data.id, Member.is_delete == 0)).first()
+    user = member_repo.get_by_id(data.id)
     # 查询结果判空
     if not user:
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(Member).filter_by(id=data.id).update({
+    result = member_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)
@@ -239,7 +231,6 @@ from sqlalchemy import and_
 from shared.constants import PAGE_SIZE
 from modules.member.schemas import MemberLevelForm
 from modules.member.models import MemberLevel
-from core.database import get_db_session
 from core import R
 from core.security import get_user_id
 from utils.request import like_contains
@@ -248,13 +239,12 @@ from utils.request import like_contains
 # 查询会员登记分页数据
 
 def get_member_level_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(MemberLevel).filter(MemberLevel.is_delete == 0)
+    query = memberlevel_repo.filter(MemberLevel.is_delete == 0)
     # 会员等级名称
     name = request.query_params.get('name')
     if name:
@@ -284,10 +274,8 @@ def get_member_level_page(request):
 # 根据会员等级ID查询详情
 
 def get_member_level_detail(member_level_id):
-    db = get_db_session()
     # 根据ID查询会员等级
-    member_level = db.query(MemberLevel).filter(
-        and_(MemberLevel.id == member_level_id, MemberLevel.is_delete == 0)).first()
+    member_level = memberlevel_repo.get_by_id(member_level_id)
     # 查询结果判空
     if not member_level:
         return None
@@ -298,15 +286,11 @@ def get_member_level_detail(member_level_id):
 # 添加会员等级
 
 def add_member_level(request, data: MemberLevelForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(MemberLevel).filter(and_(MemberLevel.name == data.name, MemberLevel.is_delete == 0)).first():
+    if memberlevel_repo.filter(and_(MemberLevel.name == data.name, MemberLevel.is_delete == 0)).first():
         return R.failed("会员等级名称不能重复")
     # 表单数据赋值给对象
-    member_level = MemberLevel(**data.model_dump(exclude={'id'}))
-    member_level.create_user = get_user_id(request)
-    # 插入数据
-    member_level.save()
+    memberlevel_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -314,16 +298,15 @@ def add_member_level(request, data: MemberLevelForm):
 # 更新会员等级
 
 def update_member_level(request, data: MemberLevelForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(MemberLevel).filter(and_(MemberLevel.name == data.name, MemberLevel.id != data.id, MemberLevel.is_delete == 0)).first():
+    if memberlevel_repo.filter(and_(MemberLevel.name == data.name, MemberLevel.id != data.id, MemberLevel.is_delete == 0)).first():
         return R.failed("会员等级名称不能重复")
 
     # 根据ID查询记录
-    member_level = db.query(MemberLevel).filter(and_(MemberLevel.id == data.id, MemberLevel.is_delete == 0)).first()
+    member_level = memberlevel_repo.get_by_id(data.id)
     # 查询结果判空
     if not member_level:
         return R.failed("记录不存在")
@@ -331,7 +314,7 @@ def update_member_level(request, data: MemberLevelForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(MemberLevel).filter_by(id=data.id).update(updData)
+    result = memberlevel_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -344,8 +327,7 @@ def delete_member_level(member_level_id):
 # 获取会员等级列表
 
 def get_member_level_list():
-    db = get_db_session()
-    member_level_list = db.query(MemberLevel).filter(MemberLevel.is_delete == 0).order_by(MemberLevel.sort.asc()).all()
+    member_level_list = memberlevel_repo.filter(MemberLevel.is_delete == 0).order_by(MemberLevel.sort.asc()).all()
     # 实例化对象
     result = []
     # 遍历数据源

modules/notice/service.py

@@ -1,14 +1,13 @@
 from datetime import datetime, timezone
 
 from fastapi.logger import logger
-from sqlalchemy import and_
 
 from shared.enums import NOTICE_SOURCE_LIST
 from shared.constants import PAGE_SIZE
 from modules.notice.schemas import NoticeForm
 from modules.notice.models import Notice
+from modules.notice.repository import notice_repo
 from config import FASTAPI_IMAGE_URL
-from core.database import get_db_session
 from core import R
 from utils.rich_text import save_content
 from utils.request import like_contains
@@ -18,13 +17,12 @@ from core.security import get_user_id
 # 查询通知公告分页数据
 
 def get_notice_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Notice).filter(Notice.is_delete == 0)
+    query = notice_repo.filter(Notice.is_delete == 0)
     # 通知公告标题
     title = request.query_params.get('title')
     if title:
@@ -64,9 +62,8 @@ def get_notice_page(request):
 # 根据通知ID查询详情
 
 def get_notice_detail(notice_id):
-    db = get_db_session()
     # 根据ID查询通知公告
-    notice = db.query(Notice).filter(and_(Notice.id == notice_id, Notice.is_delete == 0)).first()
+    notice = notice_repo.get_by_id(notice_id)
     # 查询结果判空
     if not notice:
         return None
@@ -82,7 +79,6 @@ def get_notice_detail(notice_id):
 # 添加通知公告
 
 def add_notice(request, data: NoticeForm):
-    db = get_db_session()
     # 通知标题
     title = data.title
     # 通知内容
@@ -90,12 +86,8 @@ def add_notice(request, data: NoticeForm):
     # 处理富文本内容
     content = save_content(content, title, "notice")
 
-    # 表单数据赋值给对象
-    notice = Notice(**data.model_dump(exclude={'id'}))
-    notice.content = content
-    notice.create_user = get_user_id(request)
-    # 插入数据
-    notice.save()
+    # 表单数据赋值给对象并插入（content 用处理后的富文本，排除表单原值避免重复传参）
+    notice_repo.create(**data.model_dump(exclude={'id', 'content'}), content=content, create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -103,13 +95,12 @@ def add_notice(request, data: NoticeForm):
 # 更新通知公告
 
 def update_notice(request, data: NoticeForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
 
     # 根据ID查询记录
-    notice = db.query(Notice).filter(and_(Notice.id == data.id, Notice.is_delete == 0)).first()
+    notice = notice_repo.get_by_id(data.id)
     # 查询结果判空
     if not notice:
         return R.failed("记录不存在")
@@ -126,7 +117,7 @@ def update_notice(request, data: NoticeForm):
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
     # 更新记录
-    result = db.query(Notice).filter_by(id=data.id).update(updData)
+    result = notice_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")

modules/region/service.py

@@ -48,7 +48,7 @@ from sqlalchemy import and_
 from shared.enums import CITY_LEVEL_LIST
 from modules.region.schemas import CityForm
 from modules.region.models import City
-from core.database import get_db_session
+from modules.region.repository import city_repo
 from core import R
 from core.security import get_user_id
 from utils.request import like_contains
@@ -57,9 +57,8 @@ from utils.request import like_contains
 # 查询城市数据
 
 def get_city_page(request):
-    db = get_db_session()
     # 实例化查询对象
-    query = db.query(City).filter(City.is_delete == 0)
+    query = city_repo.filter(City.is_delete == 0)
     # 上级ID
     pid = request.query_params.get('pid', 0)
     query = query.filter(City.pid == pid)
@@ -88,9 +87,8 @@ def get_city_page(request):
 # 根据城市ID获取详情
 
 def get_city_detail(city_id):
-    db = get_db_session()
     # 根据ID查询城市
-    city = db.query(City).filter(and_(City.id == city_id, City.is_delete == 0)).first()
+    city = city_repo.get_by_id(city_id)
     # 查询结果判空
     if not city:
         return None
@@ -101,12 +99,8 @@ def get_city_detail(city_id):
 # 添加城市
 
 def add_city(request, data: CityForm):
-    db = get_db_session()
     # 表单数据赋值给对象
-    city = City(**data.model_dump(exclude={'id'}))
-    city.create_user = get_user_id(request)
-    # 插入数据
-    city.save()
+    city_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -114,13 +108,12 @@ def add_city(request, data: CityForm):
 # 更新城市
 
 def update_city(request, data: CityForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
 
     # 根据ID查询记录
-    city = db.query(City).filter(and_(City.id == data.id, City.is_delete == 0)).first()
+    city = city_repo.get_by_id(data.id)
     # 查询结果判空
     if not city:
         return R.failed("记录不存在")
@@ -128,7 +121,7 @@ def update_city(request, data: CityForm):
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(City).filter_by(id=data.id).update(updData)
+    result = city_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -141,9 +134,8 @@ def delete_city(city_id):
 # 根据城市ID获取子级城市
 
 def get_child_list(city_code):
-    db = get_db_session()
     # 查询子级城市
-    childList = db.query(City).filter(and_(City.parent_code == city_code, City.is_delete == 0)).all()
+    childList = city_repo.filter(and_(City.parent_code == city_code, City.is_delete == 0)).all()
     # 实例化子级城市对象
     city_list = []
     # 遍历数据源

modules/system/dept/service.py

@@ -1,10 +1,10 @@
 from datetime import datetime, timezone
 
 from fastapi.logger import logger
-from sqlalchemy import and_
 
 from modules.system.dept.schemas import DeptForm
 from modules.system.dept.models import Dept
+from modules.system.dept.repository import dept_repo
 from core.database import get_db_session
 from core import R
 
@@ -15,9 +15,8 @@ from utils.request import like_contains, parse_id_list
 # 查询部门数据
 
 def get_dept_page(request):
-    db = get_db_session()
     # 实例化查询对象
-    query = db.query(Dept).filter(Dept.is_delete == 0)
+    query = dept_repo.filter(Dept.is_delete == 0)
     # 部门名称
     name = request.query_params.get('name')
     if name:
@@ -39,9 +38,8 @@ def get_dept_page(request):
 # 根据ID查询部门
 
 def get_dept_detail(dept_id):
-    db = get_db_session()
     # 根据ID查询部门
-    dept = db.query(Dept).filter(and_(Dept.id == dept_id, Dept.is_delete == 0)).first()
+    dept = dept_repo.get_by_id(dept_id)
     # 查询结果判空
     if not dept:
         return None
@@ -52,15 +50,11 @@ def get_dept_detail(dept_id):
 # 添加部门
 
 def add_dept(request, data: DeptForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Dept).filter(and_(Dept.name == data.name, Dept.is_delete == 0)).first():
+    if dept_repo.filter(Dept.name == data.name, Dept.is_delete == 0).first():
         return R.failed("部门名称不能重复")
-    # 表单数据赋值给对象
-    dept = Dept(**data.model_dump(exclude={'id'}))
-    dept.create_user = get_user_id(request)
-    # 插入数据
-    dept.save()
+    # 表单数据赋值给对象并插入
+    dept_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -68,24 +62,21 @@ def add_dept(request, data: DeptForm):
 # 更新部门
 
 def update_dept(request, data: DeptForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Dept).filter(and_(Dept.name == data.name, Dept.id != data.id, Dept.is_delete == 0)).first():
+    if dept_repo.filter(Dept.name == data.name, Dept.id != data.id, Dept.is_delete == 0).first():
         return R.failed("部门名称不能重复")
 
     # 根据ID查询记录
-    dept = db.query(Dept).filter(and_(Dept.id == data.id, Dept.is_delete == 0)).first()
-    # 查询结果判空
-    if not dept:
+    if not dept_repo.get_by_id(data.id):
         return R.failed("记录不存在")
     # 构造更新数据（排除 id）
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(Dept).filter_by(id=data.id).update(updData)
+    result = dept_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -98,9 +89,8 @@ def delete_dept(dept_id):
 # 获取部门列表
 
 def get_dept_list():
-    db = get_db_session()
     # 查询部门数据列表
-    dept_rows = db.query(Dept).filter(Dept.is_delete == 0).order_by(Dept.sort.asc()).all()
+    dept_rows = dept_repo.filter(Dept.is_delete == 0).order_by(Dept.sort.asc()).all()
     # 实例化列表
     dept_list = []
     # 遍历数据源

modules/system/level/service.py

@@ -47,7 +47,6 @@ from datetime import datetime, timezone
 from fastapi.logger import logger
 from openpyxl.reader.excel import load_workbook
 from openpyxl.workbook import Workbook
-from sqlalchemy import and_
 
 
 from shared.constants import PAGE_SIZE
@@ -201,13 +200,12 @@ async def import_level(request, file):
                 # 职级状态
                 status = ws.cell(item, 4).value
                 # 创建数据
-                level = Level(
+                level_repo.create(
                     name=name,
                     status=1 if status == "正常" else 2,
                     sort=sort,
+                    create_user=get_user_id(request)
                 )
-                level.create_user = get_user_id(request)
-                level.save()
 
                 count += 1
             # 关闭工作簿
@@ -229,7 +227,7 @@ async def import_level(request, file):
 def export_level(request):
     db = get_db_session()
     # 查询数据
-    query = db.query(Level).filter(Level.is_delete == 0)
+    query = level_repo.filter(Level.is_delete == 0)
     # 职级名称
     name = request.query_params.get('name')
     if name:
@@ -282,9 +280,8 @@ def export_level(request):
 # 获取职级数据列表
 
 def get_level_list():
-    db = get_db_session()
     # 查询职级数据列表
-    level_rows = db.query(Level).filter(and_(Level.is_delete == 0, Level.status == 1)).order_by(Level.sort.asc()).all()
+    level_rows = level_repo.filter(Level.is_delete == 0, Level.status == 1).order_by(Level.sort.asc()).all()
     # 实例化列表
     level_list = []
     # 遍历数据源

modules/system/menu/service.py

@@ -48,6 +48,7 @@ from sqlalchemy import and_, or_
 
 from modules.system.menu.schemas import MenuForm
 from modules.system.menu.models import Menu
+from modules.system.menu.repository import menu_repo
 from modules.system.role.models import RoleMenu
 from modules.system.user.models import UserRole
 from core.database import get_db_session
@@ -60,9 +61,8 @@ from utils.perm_cache import get_cached_permissions, set_cached_permissions, get
 # 查询菜单列表
 
 def get_menu_page(request):
-    db = get_db_session()
     # 实例化查询对象
-    query = db.query(Menu).filter(Menu.is_delete == 0)
+    query = menu_repo.filter(Menu.is_delete == 0)
     # 菜单名称
     name = request.query_params.get('name')
     if name:
@@ -84,9 +84,8 @@ def get_menu_page(request):
 # 根据ID查询菜单详情
 
 def get_menu_detail(menu_id):
-    db = get_db_session()
     # 根据ID查询菜单
-    menu = db.query(Menu).filter(and_(Menu.id == menu_id, Menu.is_delete == 0)).first()
+    menu = menu_repo.get_by_id(menu_id)
     # 查询结果判空
     if not menu:
         return None
@@ -94,8 +93,8 @@ def get_menu_detail(menu_id):
     data = menu.to_dict()
 
     # 查询菜单权限节点
-    permission_list = db.query(Menu).filter(
-        and_(Menu.parent_id == menu_id, Menu.type == 1, Menu.is_delete == 0)).all()
+    permission_list = menu_repo.filter(
+        Menu.parent_id == menu_id, Menu.type == 1, Menu.is_delete == 0).all()
     # 选中的权限节点
     checked_list = []
     if permission_list:
@@ -109,12 +108,11 @@ def get_menu_detail(menu_id):
 
 async def add_menu(request, data: MenuForm):
     def _add():
-        db = get_db_session()
         # 权限节点
         checkedList = data.checked_list or []
 
-        # 表单数据赋值给对象
-        menu = Menu(
+        # 表单数据赋值给对象并插入
+        menu = menu_repo.create(
             title=data.title,
             icon=data.icon,
             path=data.path,
@@ -125,11 +123,9 @@ async def add_menu(request, data: MenuForm):
             status=data.status,
             hide=data.hide,
             target=data.target,
-            sort=data.sort
+            sort=data.sort,
+            create_user=get_user_id(request)
         )
-        menu.create_user = get_user_id(request)
-        # 插入数据
-        menu.save()
 
         # 保存节点数据
         set_permission(data.type, checkedList, data.title, data.path, menu.id, get_user_id(request))
@@ -146,13 +142,12 @@ async def add_menu(request, data: MenuForm):
 
 async def update_menu(request, data: MenuForm):
     def _update():
-        db = get_db_session()
         # 记录ID判空
         if not data.id or data.id <= 0:
             return R.failed("记录ID不能为空")
 
         # 根据ID查询记录
-        menu = db.query(Menu).filter(and_(Menu.id == data.id, Menu.is_delete == 0)).first()
+        menu = menu_repo.get_by_id(data.id)
         # 查询结果判空
         if not menu:
             return R.failed("记录不存在")
@@ -165,7 +160,7 @@ async def update_menu(request, data: MenuForm):
         updData['update_user'] = get_user_id(request)
         updData['update_time'] = datetime.now(tz=timezone.utc)
         # 更新数据源
-        result = db.query(Menu).filter_by(id=data.id).update(updData)
+        result = menu_repo.update(data.id, updData)
         # 提交数据
         if not result:
             return R.failed("更新失败")
@@ -188,7 +183,6 @@ async def update_menu(request, data: MenuForm):
 
 async def delete_menu(menu_id):
     def _delete():
-        db = get_db_session()
         # 记录ID为空判断
         if not menu_id:
             return R.failed("记录ID不存在"), None
@@ -197,7 +191,7 @@ async def delete_menu(menu_id):
         if not id_list:
             return R.failed("记录ID不存在"), None
         # 批量查询并校验
-        records = db.query(Menu).filter(and_(Menu.id.in_(id_list), Menu.is_delete == 0)).all()
+        records = menu_repo.filter(Menu.id.in_(id_list), Menu.is_delete == 0).all()
         if len(records) != len(id_list):
             return R.failed("记录不存在"), None
         # 批量设置删除标识
@@ -323,14 +317,13 @@ def set_permission(menu_type, checkedList, title, path, parent_id, user_id):
 
 def get_permissions_list_sync(user_id):
     """同步查询用户权限节点（直查DB，不读缓存），供同步鉴权路径使用"""
-    db = get_db_session()
     if user_id == 1:
         # 超级管理员
-        menu_list = db.query(Menu).filter(and_(Menu.is_delete == 0, Menu.type == 1)).all()
+        menu_list = menu_repo.filter(Menu.is_delete == 0, Menu.type == 1).all()
     else:
         # 其他用户：通过 ORM join 查询权限节点
         menu_list = (
-            db.query(Menu)
+            menu_repo.filter()
             .join(RoleMenu, RoleMenu.menu_id == Menu.id)
             .join(UserRole, UserRole.role_id == RoleMenu.role_id)
             .filter(
@@ -363,16 +356,15 @@ async def get_permissions_list(user_id):
 
 def get_permission_menu_list_sync(user_id):
     """同步查询用户菜单树（直查DB，不读缓存），供线程池内使用"""
-    db = get_db_session()
     if user_id == 1:
         # 超级管理员
         # 查询全部菜单列表
-        menu_list = db.query(Menu).filter(and_(Menu.is_delete == 0, Menu.status == 1, Menu.type == 0)).order_by(
+        menu_list = menu_repo.filter(Menu.is_delete == 0, Menu.status == 1, Menu.type == 0).order_by(
             Menu.sort.asc())
         return get_tree_list(menu_list)
     # 其他用户：通过 ORM join 查询菜单列表
     menu_list = (
-        db.query(Menu)
+        menu_repo.filter()
         .join(RoleMenu, RoleMenu.menu_id == Menu.id)
         .join(UserRole, UserRole.role_id == RoleMenu.role_id)
         .filter(

modules/system/position/service.py

@@ -1,11 +1,11 @@
 from datetime import datetime, timezone
 
 from fastapi.logger import logger
-from sqlalchemy import and_
 
 from shared.constants import PAGE_SIZE
 from modules.system.position.schemas import PositionForm, PositionStatusForm
 from modules.system.position.models import Position
+from modules.system.position.repository import position_repo
 from core.database import get_db_session
 from core import R
 from core.security import get_user_id
@@ -15,13 +15,12 @@ from utils.request import like_contains
 # 查询岗位分页数据
 
 def get_position_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(Position).filter(Position.is_delete == 0)
+    query = position_repo.filter(Position.is_delete == 0)
     # 岗位名称
     name = request.query_params.get('name')
     if name:
@@ -55,9 +54,8 @@ def get_position_page(request):
 # 根据ID查询岗位详情
 
 def get_position_detail(position_id):
-    db = get_db_session()
     # 根据ID查询岗位
-    position = db.query(Position).filter(and_(Position.id == position_id, Position.is_delete == 0)).first()
+    position = position_repo.get_by_id(position_id)
     # 查询结果判空
     if not position:
         return None
@@ -68,15 +66,11 @@ def get_position_detail(position_id):
 # 添加岗位
 
 def add_position(request, data: PositionForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Position).filter(and_(Position.name == data.name, Position.is_delete == 0)).first():
+    if position_repo.filter(Position.name == data.name, Position.is_delete == 0).first():
         return R.failed("岗位名称不能重复")
-    # 表单数据赋值给对象
-    position = Position(**data.model_dump(exclude={'id'}))
-    position.create_user = get_user_id(request)
-    # 插入数据
-    position.save()
+    # 表单数据赋值给对象并插入
+    position_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -84,24 +78,21 @@ def add_position(request, data: PositionForm):
 # 更新岗位
 
 def update_position(request, data: PositionForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Position).filter(and_(Position.name == data.name, Position.id != data.id, Position.is_delete == 0)).first():
+    if position_repo.filter(Position.name == data.name, Position.id != data.id, Position.is_delete == 0).first():
         return R.failed("岗位名称不能重复")
 
     # 根据ID查询记录
-    position = db.query(Position).filter(and_(Position.id == data.id, Position.is_delete == 0)).first()
-    # 查询结果判空
-    if not position:
+    if not position_repo.get_by_id(data.id):
         return R.failed("记录不存在")
     # 构造更新数据（排除 id）
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(Position).filter_by(id=data.id).update(updData)
+    result = position_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -114,15 +105,12 @@ def delete_position(position_id):
 # 设置状态
 
 def update_position_status(request, data: PositionStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    position = db.query(Position).filter(and_(Position.id == data.id, Position.is_delete == 0)).first()
-    # 查询结果判空
-    if not position:
+    if not position_repo.get_by_id(data.id):
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(Position).filter_by(id=data.id).update({
+    result = position_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)
@@ -135,9 +123,8 @@ def update_position_status(request, data: PositionStatusForm):
 # 获取岗位数据列表
 
 def get_position_list():
-    db = get_db_session()
     # 查询岗位数据列表
-    position_rows = db.query(Position).filter(and_(Position.is_delete == 0, Position.status == 1)).order_by(
+    position_rows = position_repo.filter(Position.is_delete == 0, Position.status == 1).order_by(
         Position.sort.asc()).all()
     # 实例化列表
     position_list = []

modules/system/role/service.py

@@ -2,11 +2,11 @@ import asyncio
 from datetime import datetime, timezone
 
 from fastapi.logger import logger
-from sqlalchemy import and_
 
 from shared.constants import PAGE_SIZE
 from modules.system.role.schemas import RoleForm, RoleStatusForm
 from modules.system.role.models import Role
+from modules.system.role.repository import role_repo
 from core.database import get_db_session
 from core import R
 from core.security import get_user_id
@@ -17,13 +17,12 @@ from utils.perm_cache import invalidate_role_perms
 # 查询角色分页数据
 
 def get_role_page(request):
-    db = get_db_session()
     # 页码
     page = int(request.query_params.get("pageNo", 1))
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 分页查询
-    query = db.query(Role).filter(Role.is_delete == 0)
+    query = role_repo.filter(Role.is_delete == 0)
     # 角色名称
     name = request.query_params.get('name')
     if name:
@@ -53,9 +52,8 @@ def get_role_page(request):
 # 根据角色ID查询详情
 
 def get_role_detail(role_id):
-    db = get_db_session()
     # 根据ID查询角色
-    role = db.query(Role).filter(and_(Role.id == role_id, Role.is_delete == 0)).first()
+    role = role_repo.get_by_id(role_id)
     # 查询结果判空
     if not role:
         return None
@@ -66,15 +64,11 @@ def get_role_detail(role_id):
 # 添加角色
 
 def add_role(request, data: RoleForm):
-    db = get_db_session()
     # 唯一性校验
-    if db.query(Role).filter(and_(Role.name == data.name, Role.is_delete == 0)).first():
+    if role_repo.filter(Role.name == data.name, Role.is_delete == 0).first():
         return R.failed("角色名称不能重复")
-    # 表单数据赋值给对象
-    role = Role(**data.model_dump(exclude={'id'}))
-    role.create_user = get_user_id(request)
-    # 插入数据
-    role.save()
+    # 表单数据赋值给对象并插入
+    role_repo.create(**data.model_dump(exclude={'id'}), create_user=get_user_id(request))
     # 返回结果
     return R.ok(msg="添加成功")
 
@@ -82,24 +76,21 @@ def add_role(request, data: RoleForm):
 # 更新角色
 
 def update_role(request, data: RoleForm):
-    db = get_db_session()
     # 记录ID判空
     if not data.id or data.id <= 0:
         return R.failed("记录ID不能为空")
     # 唯一性校验（排除自身）
-    if db.query(Role).filter(and_(Role.name == data.name, Role.id != data.id, Role.is_delete == 0)).first():
+    if role_repo.filter(Role.name == data.name, Role.id != data.id, Role.is_delete == 0).first():
         return R.failed("角色名称不能重复")
 
     # 根据ID查询记录
-    role = db.query(Role).filter(and_(Role.id == data.id, Role.is_delete == 0)).first()
-    # 查询结果判空
-    if not role:
+    if not role_repo.get_by_id(data.id):
         return R.failed("记录不存在")
     # 构造更新数据（排除 id）
     updData = data.model_dump(exclude={'id'})
     updData['update_user'] = get_user_id(request)
     updData['update_time'] = datetime.now(tz=timezone.utc)
-    result = db.query(Role).filter_by(id=data.id).update(updData)
+    result = role_repo.update(data.id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -109,7 +100,6 @@ def update_role(request, data: RoleForm):
 
 async def delete_role(role_id):
     def _delete():
-        db = get_db_session()
         # 记录ID为空判断
         if not role_id:
             return R.failed("记录ID不存在"), None
@@ -118,7 +108,7 @@ async def delete_role(role_id):
         if not id_list:
             return R.failed("记录ID不存在"), None
         # 批量查询并校验
-        records = db.query(Role).filter(and_(Role.id.in_(id_list), Role.is_delete == 0)).all()
+        records = role_repo.filter(Role.id.in_(id_list), Role.is_delete == 0).all()
         if len(records) != len(id_list):
             return R.failed("记录不存在"), None
         # 批量设置删除标识
@@ -140,15 +130,12 @@ async def delete_role(role_id):
 # 设置状态
 
 def update_role_status(request, data: RoleStatusForm):
-    db = get_db_session()
     # 根据ID查询记录
-    role = db.query(Role).filter(and_(Role.id == data.id, Role.is_delete == 0)).first()
-    # 查询结果判空
-    if not role:
+    if not role_repo.get_by_id(data.id):
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(Role).filter_by(id=data.id).update({
+    result = role_repo.update(data.id, {
         "status": data.status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)
@@ -161,9 +148,8 @@ def update_role_status(request, data: RoleStatusForm):
 # 获取角色列表
 
 def get_role_list():
-    db = get_db_session()
     # 查询角色列表
-    role_rows = db.query(Role).filter(and_(Role.is_delete == 0, Role.status == 1)).order_by(Role.sort.asc()).all()
+    role_rows = role_repo.filter(Role.is_delete == 0, Role.status == 1).order_by(Role.sort.asc()).all()
     # 实例化角色列表
     role_list = []
     # 遍历数据源
@@ -185,6 +171,7 @@ from sqlalchemy import and_
 from modules.system.role.schemas import RoleMenuForm
 from modules.system.menu.models import Menu
 from modules.system.role.models import RoleMenu
+from modules.system.role.repository import rolemenu_repo
 from core.database import get_db_session
 from core import R
 from utils.perm_cache import invalidate_role_perms
@@ -199,7 +186,7 @@ def get_role_menu_list(role_id):
     if len(menuList) == 0:
         return None
     # 根据角色ID查询角色菜单关系数据
-    role_menu = db.query(RoleMenu).filter(RoleMenu.role_id == role_id).all()
+    role_menu = rolemenu_repo.filter(RoleMenu.role_id == role_id).all()
     # 菜单ID集合
     idList = []
     # 遍历角色菜单数据源

modules/system/user/service.py

@@ -2,7 +2,6 @@ from datetime import datetime, timezone
 import asyncio
 
 from fastapi.logger import logger
-from sqlalchemy import and_
 
 from shared.enums import GENDER_LIST
 from shared.constants import PAGE_SIZE, DEFAULT_PASSWORD
@@ -12,6 +11,7 @@ from modules.system.level.models import Level
 from modules.system.position.models import Position
 from modules.system.user.models import User
 from modules.system.user.models import UserRole
+from modules.system.user.repository import user_repo
 from core.database import get_db_session
 from core import R
 from core import password
@@ -30,7 +30,7 @@ def get_user_page(request):
     # 每页数
     limit = int(request.query_params.get("pageSize", PAGE_SIZE))
     # 实例化查询对象
-    query = db.query(User).filter(User.is_delete == 0)
+    query = user_repo.filter(User.is_delete == 0)
     # 用户账号
     username = request.query_params.get('username')
     if username:
@@ -118,7 +118,7 @@ def get_user_page(request):
 def get_user_detail(user_id):
     db = get_db_session()
     # 根据ID查询用户
-    user = db.query(User).filter(and_(User.id == user_id, User.is_delete == 0)).first()
+    user = user_repo.get_by_id(user_id)
     # 查询结果判空
     if not user:
         return None
@@ -153,9 +153,8 @@ def get_user_detail(user_id):
 
 async def add_user(request, data: UserForm):
     def _add():
-        db = get_db_session()
         # 唯一性校验
-        if db.query(User).filter(and_(User.username == data.username, User.is_delete == 0)).first():
+        if user_repo.filter(User.username == data.username, User.is_delete == 0).first():
             return R.failed("登录账号不能重复"), None
         # 获取表单数据（排除非数据列）
         formData = data.model_dump(exclude={'city', 'roles'})
@@ -178,11 +177,8 @@ async def add_user(request, data: UserForm):
             formData['city_code'] = citys[1]
             formData['district_code'] = citys[2]
 
-        # 表单数据赋值给对象
-        user = User(**formData)
-        user.create_user = get_user_id(request)
-        # 插入数据
-        user.save()
+        # 表单数据赋值给对象并插入
+        user = user_repo.create(**formData, create_user=get_user_id(request))
         return None, user.id
 
     # 同步DB/文件操作放入线程池，避免阻塞事件循环
@@ -201,19 +197,16 @@ async def add_user(request, data: UserForm):
 
 async def update_user(request, data: UserForm):
     def _update():
-        db = get_db_session()
         # 记录ID判空
         user_id = data.id
         if not user_id or int(user_id) <= 0:
             return R.failed("记录ID不能为空"), None
         # 唯一性校验（排除自身）
-        if db.query(User).filter(and_(User.username == data.username, User.id != data.id, User.is_delete == 0)).first():
+        if user_repo.filter(User.username == data.username, User.id != data.id, User.is_delete == 0).first():
             return R.failed("登录账号不能重复"), None
 
         # 根据ID查询记录
-        user = db.query(User).filter(and_(User.id == user_id, User.is_delete == 0)).first()
-        # 查询结果判空
-        if not user:
+        if not user_repo.get_by_id(user_id):
             return R.failed("记录不存在"), None
 
         # 获取表单数据（排除敏感字段和非数据列）
@@ -242,7 +235,7 @@ async def update_user(request, data: UserForm):
         updData['update_user'] = get_user_id(request)
         updData['update_time'] = datetime.now(tz=timezone.utc)
         # 更新数据
-        result = db.query(User).filter_by(id=user_id).update(updData)
+        result = user_repo.update(user_id, updData)
         if not result:
             return R.failed("更新失败"), None
         return None, user_id
@@ -284,19 +277,16 @@ def delete_user(user_id):
 # 设置状态
 
 def update_user_status(request, data: UserStatusForm):
-    db = get_db_session()
     # 记录ID
     id = data.id
     # 状态值
     status = data.status
     # 根据ID查询记录
-    user = db.query(User).filter(and_(User.id == id, User.is_delete == 0)).first()
-    # 查询结果判空
-    if not user:
+    if not user_repo.get_by_id(id):
         return R.failed("记录不存在")
 
     # 更新记录
-    result = db.query(User).filter_by(id=id).update({
+    result = user_repo.update(id, {
         "status": status,
         "update_user": get_user_id(request),
         "update_time": datetime.now(tz=timezone.utc)
@@ -309,18 +299,15 @@ def update_user_status(request, data: UserStatusForm):
 # 更新用户信息
 
 def update_user_info(request, data: UserInfoForm):
-    db = get_db_session()
     # 用户ID
     user_id = get_user_id(request)
     # 根据ID查询记录
-    user = db.query(User).filter(and_(User.id == user_id, User.is_delete == 0)).first()
-    # 查询结果判空
-    if not user:
+    if not user_repo.get_by_id(user_id):
         return R.failed("记录不存在")
 
     # 更新记录
     updData = data.model_dump()
-    result = db.query(User).filter_by(id=user_id).update(updData)
+    result = user_repo.update(user_id, updData)
     # 提交数据
     if not result:
         return R.failed("更新失败")
@@ -329,12 +316,11 @@ def update_user_info(request, data: UserInfoForm):
 # 更新密码
 
 def update_pwd(request, data: UpdatePwdForm):
-    db = get_db_session()
     # 用户ID
     user_id = get_user_id(request)
 
     # 根据ID查询用户
-    user = db.query(User).filter(and_(User.is_delete == 0, User.id == user_id)).first()
+    user = user_repo.get_by_id(user_id)
     if not user:
         return R.failed("用户不存在")
 
@@ -345,7 +331,7 @@ def update_pwd(request, data: UpdatePwdForm):
     # 加密新密码
     salt = password.generate_salt()
     new_hash = password.encrypt_password(data.newPassword, salt)
-    result = db.query(User).filter_by(id=user_id).update({
+    result = user_repo.update(user_id, {
         "password": new_hash,
         "salt": salt
     })
@@ -357,19 +343,17 @@ def update_pwd(request, data: UpdatePwdForm):
 # 重置密码
 
 def reset_user_pwd(request, data: ResetPwdForm):
-    db = get_db_session()
     # 用户ID
     user_id = data.id
 
     # 根据ID查询用户
-    user = db.query(User).filter(and_(User.is_delete == 0, User.id == user_id)).first()
-    if not user:
+    if not user_repo.get_by_id(user_id):
         return R.failed("用户不存在")
 
     # 加密新密码
     salt = password.generate_salt()
     new_hash = password.encrypt_password(DEFAULT_PASSWORD, salt)
-    result = db.query(User).filter_by(id=user_id).update({
+    result = user_repo.update(user_id, {
         "password": new_hash,
         "salt": salt
     })