567 lines
22 KiB
Python
567 lines
22 KiB
Python
import json
|
|
from typing import Any
|
|
|
|
from redis.asyncio.client import Redis
|
|
from sqlalchemy import update as sa_update
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.api.v1.module_system.dict.model import DictDataModel
|
|
from app.common.enums import RedisInitKeyConfig
|
|
from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema
|
|
from app.core.database import async_db_session
|
|
from app.core.exceptions import CustomException
|
|
from app.core.logger import logger
|
|
from app.core.redis_crud import RedisCURD
|
|
from app.utils.common_util import search_to_dict
|
|
from app.utils.excel_util import ExcelUtil
|
|
|
|
from .crud import DictDataCRUD, DictTypeCRUD
|
|
from .schema import (
|
|
DictDataCreateSchema,
|
|
DictDataOutSchema,
|
|
DictDataQueryParam,
|
|
DictDataUpdateSchema,
|
|
DictTypeCreateSchema,
|
|
DictTypeOutSchema,
|
|
DictTypeQueryParam,
|
|
DictTypeUpdateSchema,
|
|
)
|
|
|
|
|
|
class DictTypeService:
|
|
"""字典类型管理服务
|
|
|
|
设计：实例方法承载「当前用户上下文 (auth)」，``redis`` 仍是方法参数
|
|
（因为不是每个端点都用到）。调用方写法由 ``XxxService.method_service(auth=...)``
|
|
改为 ``XxxService(auth).method(...)``。
|
|
"""
|
|
|
|
def __init__(self, auth: AuthSchema, db: AsyncSession) -> None:
|
|
self.auth = auth
|
|
self.db = db
|
|
|
|
async def detail(self, id: int) -> DictTypeOutSchema:
|
|
"""获取数据字典类型详情
|
|
|
|
参数:
|
|
- id (int): 数据字典类型ID
|
|
|
|
返回:
|
|
- DictTypeOutSchema: 字典类型响应模型
|
|
"""
|
|
obj = await DictTypeCRUD(self.auth, self.db).get_or_404(id=id)
|
|
return DictTypeOutSchema.model_validate(obj)
|
|
|
|
async def get_list(
|
|
self,
|
|
search: DictTypeQueryParam | None = None,
|
|
order_by: list[dict] | None = None,
|
|
) -> list[DictTypeOutSchema]:
|
|
"""获取数据字典类型列表
|
|
|
|
参数:
|
|
- search (DictTypeQueryParam | None): 搜索条件模型
|
|
- order_by (list[dict] | None): 排序字段列表
|
|
|
|
返回:
|
|
- list[DictTypeOutSchema]: 字典类型响应模型列表
|
|
"""
|
|
obj_list = await DictTypeCRUD(self.auth, self.db).get_list(search=search_to_dict(search), order_by=order_by)
|
|
return [DictTypeOutSchema.model_validate(obj) for obj in obj_list]
|
|
|
|
@staticmethod
|
|
def export_list(dict_type_list: list[dict[str, Any]]) -> bytes:
|
|
"""导出字典类型列表为 Excel。"""
|
|
if not dict_type_list:
|
|
raise CustomException(msg="没有数据可导出")
|
|
mapping_dict = {
|
|
"id": "字典类型ID",
|
|
"dict_name": "字典名称",
|
|
"dict_type": "字典类型编码",
|
|
"status": "状态",
|
|
"description": "描述",
|
|
"created_time": "创建时间",
|
|
"updated_time": "更新时间",
|
|
}
|
|
data = dict_type_list.copy()
|
|
for item in data:
|
|
item["status"] = "正常" if item.get("status") == 0 else "停用"
|
|
return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
|
|
|
|
async def page(
|
|
self,
|
|
page_no: int,
|
|
page_size: int,
|
|
search: DictTypeQueryParam | None = None,
|
|
order_by: list[dict] | None = None,
|
|
) -> PageResultSchema[DictTypeOutSchema]:
|
|
"""分页查询字典类型（数据库 OFFSET/LIMIT）。
|
|
|
|
参数:
|
|
- page_no (int): 页码（从 1 开始）
|
|
- page_size (int): 每页条数
|
|
- search (DictTypeQueryParam | None): 查询条件
|
|
- order_by (list[dict] | None): 排序字段列表
|
|
|
|
返回:
|
|
- PageResultSchema[DictTypeOutSchema]: 分页结果
|
|
"""
|
|
offset = (page_no - 1) * page_size
|
|
return await DictTypeCRUD(self.auth, self.db).page(
|
|
offset=offset,
|
|
limit=page_size,
|
|
order_by=order_by or [{"id": "asc"}],
|
|
search=search_to_dict(search),
|
|
out_schema=DictTypeOutSchema,
|
|
)
|
|
|
|
async def create(self, redis: Redis, data: DictTypeCreateSchema) -> DictTypeOutSchema:
|
|
"""创建数据字典类型
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- data (DictTypeCreateSchema): 数据字典类型创建模型
|
|
|
|
返回:
|
|
- DictTypeOutSchema: 字典类型响应模型
|
|
"""
|
|
exist_obj = await DictTypeCRUD(self.auth, self.db).get(dict_name=data.dict_name)
|
|
if exist_obj:
|
|
raise CustomException(msg="创建失败，该数据已存在")
|
|
obj = await DictTypeCRUD(self.auth, self.db).create(data=data)
|
|
|
|
new_obj_dict = DictTypeOutSchema.model_validate(obj)
|
|
|
|
redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{data.dict_type}"
|
|
|
|
try:
|
|
await RedisCURD(redis).set(
|
|
key=redis_key,
|
|
value="[]",
|
|
expire=None,
|
|
)
|
|
logger.info(f"创建字典类型成功: {new_obj_dict}")
|
|
except Exception as e:
|
|
logger.error(f"创建字典类型失败: {e}")
|
|
raise CustomException(msg="同步字典类型缓存失败") from e
|
|
|
|
return new_obj_dict
|
|
|
|
async def update(
|
|
self,
|
|
redis: Redis,
|
|
id: int,
|
|
data: DictTypeUpdateSchema,
|
|
) -> DictTypeOutSchema:
|
|
"""更新数据字典类型
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- id (int): 数据字典类型ID
|
|
- data (DictTypeUpdateSchema): 数据字典类型更新模型
|
|
|
|
返回:
|
|
- DictTypeOutSchema: 字典类型响应模型
|
|
"""
|
|
exist_obj = await DictTypeCRUD(self.auth, self.db).get_or_404(id=id, msg="更新失败，该数据不存在")
|
|
if exist_obj.dict_name != data.dict_name:
|
|
raise CustomException(msg="更新失败，数据字典类型名称不可以修改")
|
|
|
|
# 如果字典类型修改或状态变更，则修改对应字典数据的类型和状态
|
|
if exist_obj.dict_type != data.dict_type or exist_obj.status != data.status:
|
|
# 批量更新所有关联字典数据
|
|
update_data: dict[str, Any] = {"status": data.status}
|
|
if exist_obj.dict_type != data.dict_type:
|
|
update_data["dict_type"] = data.dict_type
|
|
stmt = (
|
|
sa_update(DictDataModel)
|
|
.where(DictDataModel.dict_type == exist_obj.dict_type)
|
|
.values(**update_data)
|
|
)
|
|
await self.db.execute(stmt)
|
|
await self.db.flush()
|
|
|
|
obj = await DictTypeCRUD(self.auth, self.db).update(id=id, data=data)
|
|
|
|
new_obj_dict = DictTypeOutSchema.model_validate(obj)
|
|
|
|
redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{data.dict_type}"
|
|
try:
|
|
# 获取当前字典类型的所有字典数据，确保包含最新状态
|
|
dict_data_list = await DictDataCRUD(self.auth, self.db).get_list(search={"dict_type": data.dict_type})
|
|
dict_data = [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in dict_data_list if row]
|
|
|
|
value = json.dumps(dict_data, ensure_ascii=False)
|
|
await RedisCURD(redis).set(
|
|
key=redis_key,
|
|
value=value,
|
|
expire=None,
|
|
)
|
|
logger.info(f"更新字典类型成功并刷新缓存: {new_obj_dict}")
|
|
except Exception as e:
|
|
logger.error(f"更新字典类型缓存失败: {e}")
|
|
raise CustomException(msg="同步字典类型缓存失败") from e
|
|
|
|
return new_obj_dict
|
|
|
|
async def delete(self, redis: Redis, ids: list[int]) -> None:
|
|
"""删除数据字典类型
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- ids (list[int]): 数据字典类型ID列表
|
|
|
|
返回:
|
|
- None
|
|
"""
|
|
if not ids:
|
|
raise CustomException(msg="删除失败，删除对象不能为空")
|
|
existing = await DictTypeCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)})
|
|
existing_map = {obj.id: obj for obj in existing}
|
|
# 收集所有 dict_type 去重后批量查询是否有字典数据
|
|
dict_types = {obj.dict_type for obj in existing if obj.id in ids}
|
|
dict_type_has_data: set[str] = set()
|
|
for dt in dict_types:
|
|
if await DictDataCRUD(self.auth, self.db).get_list(search={"dict_type": dt}):
|
|
dict_type_has_data.add(dt)
|
|
for nid in ids:
|
|
if nid not in existing_map:
|
|
raise CustomException(msg="删除失败，该数据不存在")
|
|
exist_obj = existing_map[nid]
|
|
if exist_obj.dict_type in dict_type_has_data:
|
|
raise CustomException(msg="删除失败，该数据字典类型下存在字典数据")
|
|
# 验证通过后统一删除 Redis 缓存
|
|
existing_dict_types = {obj.dict_type for obj in existing if obj.id in ids}
|
|
for dt in existing_dict_types:
|
|
redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dt}"
|
|
try:
|
|
await RedisCURD(redis).delete(redis_key)
|
|
logger.info(f"删除字典类型缓存: {dt}")
|
|
except Exception as e:
|
|
logger.error(f"删除字典类型缓存失败: {e}")
|
|
raise CustomException(msg="同步删除字典缓存失败") from e
|
|
await DictTypeCRUD(self.auth, self.db).delete(ids=ids)
|
|
|
|
async def set_available(self, data: BatchSetAvailable) -> None:
|
|
"""设置数据字典类型状态
|
|
|
|
参数:
|
|
- data (BatchSetAvailable): 批量设置状态模型
|
|
|
|
返回:
|
|
- None
|
|
"""
|
|
await DictTypeCRUD(self.auth, self.db).set(ids=data.ids, status=data.status)
|
|
|
|
class DictDataService:
|
|
"""字典数据管理服务
|
|
|
|
设计同 DictTypeService：实例方法 + ``__init__(auth)``。
|
|
"""
|
|
|
|
def __init__(self, auth: AuthSchema, db: AsyncSession) -> None:
|
|
self.auth = auth
|
|
self.db = db
|
|
|
|
async def detail(self, id: int) -> DictDataOutSchema:
|
|
"""获取数据字典数据详情
|
|
|
|
参数:
|
|
- id (int): 数据字典数据ID
|
|
|
|
返回:
|
|
- DictDataOutSchema: 字典数据响应模型
|
|
"""
|
|
obj = await DictDataCRUD(self.auth, self.db).get_or_404(id=id)
|
|
return DictDataOutSchema.model_validate(obj)
|
|
|
|
async def get_list(
|
|
self,
|
|
search: DictDataQueryParam | None = None,
|
|
order_by: list[dict] | None = None,
|
|
) -> list[DictDataOutSchema]:
|
|
"""获取数据字典数据列表
|
|
|
|
参数:
|
|
- search (DictDataQueryParam | None): 搜索条件模型
|
|
- order_by (list[dict] | None): 排序字段列表
|
|
|
|
返回:
|
|
- list[DictDataOutSchema]: 字典数据响应模型列表
|
|
"""
|
|
obj_list = await DictDataCRUD(self.auth, self.db).get_list(search=search_to_dict(search), order_by=order_by)
|
|
return [DictDataOutSchema.model_validate(obj) for obj in obj_list]
|
|
|
|
@staticmethod
|
|
def export_list(dict_data_list: list[dict[str, Any]]) -> bytes:
|
|
"""导出字典数据列表为 Excel。"""
|
|
if not dict_data_list:
|
|
raise CustomException(msg="没有数据可导出")
|
|
mapping_dict = {
|
|
"id": "字典数据ID",
|
|
"dict_type": "字典类型编码",
|
|
"dict_sort": "排序",
|
|
"dict_label": "字典标签",
|
|
"dict_value": "字典键值",
|
|
"is_default": "是否默认",
|
|
"status": "状态",
|
|
"description": "描述",
|
|
"created_time": "创建时间",
|
|
"updated_time": "更新时间",
|
|
}
|
|
data = dict_data_list.copy()
|
|
for item in data:
|
|
item["status"] = "正常" if item.get("status") == 0 else "停用"
|
|
item["is_default"] = "是" if item.get("is_default") else "否"
|
|
return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
|
|
|
|
async def page(
|
|
self,
|
|
page_no: int,
|
|
page_size: int,
|
|
search: DictDataQueryParam | None = None,
|
|
order_by: list[dict] | None = None,
|
|
) -> PageResultSchema[DictDataOutSchema]:
|
|
"""分页查询字典数据（数据库 OFFSET/LIMIT）。
|
|
|
|
参数:
|
|
- page_no (int): 页码（从 1 开始）
|
|
- page_size (int): 每页条数
|
|
- search (DictDataQueryParam | None): 查询条件
|
|
- order_by (list[dict] | None): 排序字段列表
|
|
|
|
返回:
|
|
- PageResultSchema[DictDataOutSchema]: 分页结果
|
|
"""
|
|
offset = (page_no - 1) * page_size
|
|
return await DictDataCRUD(self.auth, self.db).page(
|
|
offset=offset,
|
|
limit=page_size,
|
|
order_by=order_by or [{"id": "asc"}],
|
|
search=search_to_dict(search),
|
|
out_schema=DictDataOutSchema,
|
|
)
|
|
|
|
@staticmethod
|
|
async def init_cache(redis: Redis) -> None:
|
|
"""应用初始化: 获取所有字典类型对应的字典数据信息并按租户缓存（无 auth）。
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
|
|
返回:
|
|
- None
|
|
"""
|
|
try:
|
|
async with async_db_session() as session, session.begin():
|
|
init_auth = AuthSchema()
|
|
obj_list = await DictTypeCRUD(init_auth, session).get_list()
|
|
if not obj_list:
|
|
logger.warning("未找到任何字典类型数据")
|
|
return
|
|
|
|
for obj in obj_list:
|
|
dict_type = obj.dict_type
|
|
try:
|
|
dict_data_list = await DictDataCRUD(init_auth, session).get_list(search={"dict_type": dict_type})
|
|
dict_data = [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in dict_data_list if row]
|
|
redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dict_type}"
|
|
value = json.dumps(dict_data, ensure_ascii=False)
|
|
await RedisCURD(redis).set(
|
|
key=redis_key,
|
|
value=value,
|
|
expire=None,
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"❌ 初始化字典数据失败 [{dict_type}]: {e}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌️ 字典初始化过程发生错误: {e}")
|
|
raise CustomException(msg="字典数据初始化失败") from e
|
|
|
|
@staticmethod
|
|
async def get_init_cache(redis: Redis, dict_type: str) -> list[dict]:
|
|
"""从缓存获取字典数据列表信息（无 auth）。
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- dict_type (str): 字典类型
|
|
|
|
返回:
|
|
- list[dict]: 字典数据列表
|
|
"""
|
|
|
|
def _parse(data: str | list | None) -> list[dict] | None:
|
|
"""尝试反序列化 Redis 返回的字典缓存数据"""
|
|
if data is None:
|
|
return None
|
|
if isinstance(data, list):
|
|
return data
|
|
try:
|
|
return json.loads(data)
|
|
except (json.JSONDecodeError, TypeError):
|
|
return None
|
|
|
|
try:
|
|
redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dict_type}"
|
|
obj_list_dict = await RedisCURD(redis).get(redis_key)
|
|
|
|
result = _parse(obj_list_dict)
|
|
if result is not None:
|
|
return result
|
|
|
|
# 缓存未命中或格式异常，重新初始化
|
|
logger.warning(f"字典缓存未命中或格式异常，重新初始化缓存: {dict_type}")
|
|
await DictDataService.init_cache(redis)
|
|
obj_list_dict = await RedisCURD(redis).get(redis_key)
|
|
|
|
result = _parse(obj_list_dict)
|
|
if result is None:
|
|
raise CustomException(msg="该数据不存在")
|
|
return result
|
|
except CustomException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"获取字典缓存失败: {e!s}")
|
|
raise CustomException(msg="获取字典数据失败") from e
|
|
|
|
async def _refresh_dict_cache(self, redis: Redis, dict_type: str) -> None:
|
|
"""刷新指定字典类型的 Redis 缓存
|
|
|
|
从数据库拉取全量数据，序列化后写入 Redis。
|
|
|
|
参数:
|
|
- redis (Redis): Redis 客户端
|
|
- dict_type (str): 字典类型
|
|
"""
|
|
redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dict_type}"
|
|
dict_data_list = await DictDataCRUD(self.auth, self.db).get_list(search={"dict_type": dict_type})
|
|
dict_data = [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in dict_data_list if row]
|
|
value = json.dumps(dict_data, ensure_ascii=False)
|
|
await RedisCURD(redis).set(key=redis_key, value=value, expire=None)
|
|
|
|
async def create(self, redis: Redis, data: DictDataCreateSchema) -> DictDataOutSchema:
|
|
"""创建数据字典数据
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- data (DictDataCreateSchema): 数据字典数据创建模型
|
|
|
|
返回:
|
|
- DictDataOutSchema: 字典数据响应模型
|
|
"""
|
|
# 检查相同字典类型下dict_label是否已存在
|
|
exist_label_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_label=data.dict_label)
|
|
if exist_label_obj:
|
|
raise CustomException(msg=f'创建失败，该字典类型下的字典标签"{data.dict_label}"已存在')
|
|
|
|
# 检查相同字典类型下dict_value是否已存在
|
|
exist_value_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_value=data.dict_value)
|
|
if exist_value_obj:
|
|
raise CustomException(msg=f'创建失败，该字典类型下的字典键值"{data.dict_value}"已存在')
|
|
|
|
obj = await DictDataCRUD(self.auth, self.db).create(data=data)
|
|
|
|
try:
|
|
await self._refresh_dict_cache(redis, data.dict_type)
|
|
logger.info(f"创建字典数据写入缓存成功: {obj}")
|
|
except Exception as e:
|
|
logger.error(f"创建字典数据写入缓存失败: {e}")
|
|
raise CustomException(msg="同步字典数据缓存失败") from e
|
|
|
|
return DictDataOutSchema.model_validate(obj)
|
|
|
|
async def update(
|
|
self,
|
|
redis: Redis,
|
|
id: int,
|
|
data: DictDataUpdateSchema,
|
|
) -> DictDataOutSchema:
|
|
"""更新数据字典数据
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- id (int): 数据字典数据ID
|
|
- data (DictDataUpdateSchema): 数据字典数据更新模型
|
|
|
|
返回:
|
|
- DictDataOutSchema: 字典数据响应模型
|
|
"""
|
|
exist_obj = await DictDataCRUD(self.auth, self.db).get_or_404(id=id, msg="更新失败，该数据不存在")
|
|
|
|
# 检查相同字典类型下dict_label是否已存在（排除当前记录）
|
|
if exist_obj.dict_label != data.dict_label:
|
|
exist_label_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_label=data.dict_label)
|
|
if exist_label_obj:
|
|
raise CustomException(msg=f'更新失败，该字典类型下的字典标签"{data.dict_label}"已存在')
|
|
|
|
# 检查相同字典类型下dict_value是否已存在（排除当前记录）
|
|
if exist_obj.dict_value != data.dict_value:
|
|
exist_value_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_value=data.dict_value)
|
|
if exist_value_obj:
|
|
raise CustomException(msg=f'更新失败，该字典类型下的字典键值"{data.dict_value}"已存在')
|
|
|
|
# 如果字典类型变更，仅刷新旧类型缓存，不联动字典类型状态
|
|
if exist_obj.dict_type != data.dict_type:
|
|
dict_type = await DictTypeCRUD(self.auth, self.db).get(dict_type=exist_obj.dict_type)
|
|
if dict_type:
|
|
try:
|
|
await self._refresh_dict_cache(redis, dict_type.dict_type)
|
|
except Exception as e:
|
|
logger.error(f"刷新旧字典缓存失败: {e}")
|
|
raise CustomException(msg="同步旧字典数据缓存失败") from e
|
|
|
|
obj = await DictDataCRUD(self.auth, self.db).update(id=id, data=data)
|
|
|
|
# 刷新新/当前字典类型缓存（仅一次）
|
|
try:
|
|
await self._refresh_dict_cache(redis, data.dict_type)
|
|
logger.info(f"更新字典数据写入缓存成功: {obj}")
|
|
except Exception as e:
|
|
logger.error(f"更新字典数据写入缓存失败: {e}")
|
|
raise CustomException(msg="同步字典数据缓存失败") from e
|
|
|
|
return DictDataOutSchema.model_validate(obj)
|
|
|
|
async def delete(self, redis: Redis, ids: list[int]) -> None:
|
|
"""删除数据字典数据
|
|
|
|
参数:
|
|
- redis (Redis): Redis客户端
|
|
- ids (list[int]): 数据字典数据ID列表
|
|
|
|
返回:
|
|
- None
|
|
"""
|
|
if not ids:
|
|
raise CustomException(msg="删除失败，删除对象不能为空")
|
|
existing = await DictDataCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)})
|
|
existing_map = {obj.id: obj for obj in existing}
|
|
for nid in ids:
|
|
if nid not in existing_map:
|
|
raise CustomException(msg="删除失败，该数据不存在")
|
|
# 按 dict_type 分组，每组的缓存只刷新一次
|
|
type_groups: dict[str, list[int]] = {}
|
|
for obj in existing:
|
|
if obj.id in ids:
|
|
type_groups.setdefault(obj.dict_type, []).append(obj.id)
|
|
for dt in type_groups:
|
|
try:
|
|
await self._refresh_dict_cache(redis, dt)
|
|
logger.info(f"删除字典数据并刷新缓存: dict_type={dt}")
|
|
except Exception as e:
|
|
logger.error(f"删除字典数据刷新缓存失败: {e}")
|
|
raise CustomException(msg="同步删除字典数据缓存失败") from e
|
|
await DictDataCRUD(self.auth, self.db).delete(ids=ids)
|
|
|
|
async def set_available(self, data: BatchSetAvailable) -> None:
|
|
"""设置数据字典数据状态
|
|
|
|
参数:
|
|
- data (BatchSetAvailable): 批量设置状态模型
|
|
|
|
返回:
|
|
- None
|
|
"""
|
|
await DictDataCRUD(self.auth, self.db).set(ids=data.ids, status=data.status)
|