1628 lines
64 KiB
Python
1628 lines
64 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
表单元数据管理服务（异步版本）
|
||
|
||
数据权限：
|
||
- 使用 list_with_data_scope() 自动应用数据权限
|
||
- 支持本人、本部门、本部门及下级、全部等数据范围
|
||
"""
|
||
import logging
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
from sqlalchemy import select, update, delete, func, and_, or_
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from core.application.model import Application
|
||
from online_dev.form_manager.model import FormMeta, FormSubTable
|
||
from app.data_scope_utils import get_data_scope_filter, apply_data_scope_to_conditions
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# 资源类型（用于数据权限配置）
|
||
RESOURCE_TYPE = "form"
|
||
RESOURCE_DISPLAY_NAME = "表单管理"
|
||
|
||
|
||
class FormServiceException(Exception):
|
||
"""表单服务异常"""
|
||
pass
|
||
|
||
|
||
class FormService:
|
||
"""表单元数据管理服务"""
|
||
|
||
@staticmethod
|
||
def build_app_scope_condition(
|
||
application_id: str = None,
|
||
*,
|
||
for_selection: bool = False,
|
||
):
|
||
"""
|
||
构建表单应用范围过滤条件。
|
||
for_selection=True 时，除本应用表单外，还包含其他应用中已发布且全局可见的表单。
|
||
"""
|
||
if application_id:
|
||
local = FormMeta.application_id == application_id
|
||
else:
|
||
local = FormMeta.application_id.is_(None)
|
||
|
||
if not for_selection:
|
||
return local
|
||
|
||
shared = and_(
|
||
FormMeta.globally_visible == True,
|
||
FormMeta.status == "published",
|
||
)
|
||
return or_(local, shared)
|
||
|
||
# ============ 查询 ============
|
||
|
||
@staticmethod
|
||
async def list(
|
||
db: AsyncSession,
|
||
page: int = 1,
|
||
page_size: int = 20,
|
||
application_id: str = None,
|
||
name: str = None,
|
||
code: str = None,
|
||
form_type: str = None,
|
||
status: str = None,
|
||
include_globally_visible: bool = False,
|
||
) -> Dict[str, Any]:
|
||
"""分页查询表单列表（包含应用名称）"""
|
||
conditions = [FormMeta.is_deleted == False]
|
||
|
||
# 应用过滤
|
||
conditions.append(
|
||
FormService.build_app_scope_condition(
|
||
application_id,
|
||
for_selection=include_globally_visible,
|
||
)
|
||
)
|
||
|
||
if name:
|
||
conditions.append(FormMeta.name.ilike(f"%{name}%"))
|
||
if code:
|
||
conditions.append(FormMeta.code.ilike(f"%{code}%"))
|
||
if form_type:
|
||
conditions.append(FormMeta.form_type == form_type)
|
||
if status:
|
||
conditions.append(FormMeta.status == status)
|
||
|
||
# 获取总数
|
||
count_stmt = select(func.count(FormMeta.id)).where(and_(*conditions))
|
||
total_result = await db.execute(count_stmt)
|
||
total = total_result.scalar() or 0
|
||
|
||
# 获取列表（使用 LEFT JOIN 查询应用名称和编码）
|
||
offset = (page - 1) * page_size
|
||
stmt = (
|
||
select(
|
||
FormMeta,
|
||
Application.name.label('application_name'),
|
||
Application.code.label('application_code'),
|
||
)
|
||
.outerjoin(Application, FormMeta.application_id == Application.id)
|
||
.where(and_(*conditions))
|
||
.order_by(FormMeta.sort, FormMeta.sys_create_datetime.desc())
|
||
.offset(offset)
|
||
.limit(page_size)
|
||
)
|
||
|
||
result = await db.execute(stmt)
|
||
items = []
|
||
for form, app_name, app_code in result:
|
||
form.application_name = app_name or "主应用"
|
||
form.application_code = app_code or ""
|
||
items.append(form)
|
||
|
||
return {
|
||
"items": items,
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": page_size
|
||
}
|
||
|
||
@staticmethod
|
||
async def list_with_data_scope(
|
||
db: AsyncSession,
|
||
page: int = 1,
|
||
page_size: int = 20,
|
||
application_id: str = None,
|
||
name: str = None,
|
||
code: str = None,
|
||
form_type: str = None,
|
||
status: str = None,
|
||
include_globally_visible: bool = False,
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
分页查询表单列表（带数据权限过滤）
|
||
|
||
自动从上下文获取当前用户信息，应用数据权限过滤
|
||
"""
|
||
conditions = [FormMeta.is_deleted == False]
|
||
|
||
# 应用过滤
|
||
conditions.append(
|
||
FormService.build_app_scope_condition(
|
||
application_id,
|
||
for_selection=include_globally_visible,
|
||
)
|
||
)
|
||
|
||
if name:
|
||
conditions.append(FormMeta.name.ilike(f"%{name}%"))
|
||
if code:
|
||
conditions.append(FormMeta.code.ilike(f"%{code}%"))
|
||
if form_type:
|
||
conditions.append(FormMeta.form_type == form_type)
|
||
if status:
|
||
conditions.append(FormMeta.status == status)
|
||
|
||
# 获取数据权限过滤条件并应用
|
||
data_scope_filter = await get_data_scope_filter(db, RESOURCE_TYPE)
|
||
scope_conditions = apply_data_scope_to_conditions(FormMeta, data_scope_filter)
|
||
conditions.extend(scope_conditions)
|
||
|
||
# 获取总数
|
||
count_stmt = select(func.count(FormMeta.id)).where(and_(*conditions))
|
||
total_result = await db.execute(count_stmt)
|
||
total = total_result.scalar() or 0
|
||
|
||
# 获取列表（使用 LEFT JOIN 查询应用名称和编码）
|
||
offset = (page - 1) * page_size
|
||
stmt = (
|
||
select(
|
||
FormMeta,
|
||
Application.name.label('application_name'),
|
||
Application.code.label('application_code'),
|
||
)
|
||
.outerjoin(Application, FormMeta.application_id == Application.id)
|
||
.where(and_(*conditions))
|
||
.order_by(FormMeta.sort, FormMeta.sys_create_datetime.desc())
|
||
.offset(offset)
|
||
.limit(page_size)
|
||
)
|
||
|
||
result = await db.execute(stmt)
|
||
items = []
|
||
for form, app_name, app_code in result:
|
||
form.application_name = app_name or "主应用"
|
||
form.application_code = app_code or ""
|
||
items.append(form)
|
||
|
||
return {
|
||
"items": items,
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": page_size
|
||
}
|
||
|
||
@staticmethod
|
||
async def get(db: AsyncSession, form_id: str) -> FormMeta:
|
||
"""获取表单详情"""
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.id == form_id,
|
||
FormMeta.is_deleted == False
|
||
)
|
||
result = await db.execute(stmt)
|
||
form = result.scalar_one_or_none()
|
||
|
||
if not form:
|
||
raise FormServiceException(f"表单不存在: {form_id}")
|
||
|
||
return form
|
||
|
||
@staticmethod
|
||
async def get_sub_tables(db: AsyncSession, form_id: str) -> List[FormSubTable]:
|
||
"""获取表单子表配置"""
|
||
stmt = select(FormSubTable).where(
|
||
FormSubTable.form_id == form_id,
|
||
FormSubTable.is_deleted == False
|
||
).order_by(FormSubTable.sort)
|
||
|
||
result = await db.execute(stmt)
|
||
return list(result.scalars().all())
|
||
|
||
@staticmethod
|
||
async def get_by_code(db: AsyncSession, code: str) -> FormMeta:
|
||
"""根据编码获取表单"""
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.code == code,
|
||
FormMeta.is_deleted == False
|
||
)
|
||
result = await db.execute(stmt)
|
||
form = result.scalar_one_or_none()
|
||
|
||
if not form:
|
||
raise FormServiceException(f"表单不存在: {code}")
|
||
|
||
return form
|
||
|
||
# ============ 创建 ============
|
||
|
||
@staticmethod
|
||
async def create(
|
||
db: AsyncSession,
|
||
data: Dict[str, Any],
|
||
user_id: str = None
|
||
) -> FormMeta:
|
||
"""创建表单"""
|
||
code = data.get("code")
|
||
|
||
# 检查编码唯一性
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.code == code,
|
||
FormMeta.is_deleted == False
|
||
)
|
||
result = await db.execute(stmt)
|
||
if result.scalar_one_or_none():
|
||
raise FormServiceException(f"表单编码已存在: {code}")
|
||
|
||
sub_tables_data = data.pop("sub_tables", [])
|
||
|
||
# 从上下文获取用户信息
|
||
from utils.context import get_current_user_info_from_context
|
||
user_info = get_current_user_info_from_context()
|
||
creator_id = user_id or (user_info.get('user_id') if user_info else None)
|
||
dept_id = user_info.get('dept_id') if user_info else None
|
||
|
||
# 创建主表单
|
||
form = FormMeta(
|
||
application_id=data.get("application_id"),
|
||
name=data.get("name"),
|
||
code=code,
|
||
form_type=data.get("form_type", "normal"),
|
||
description=data.get("description", ""),
|
||
db_config=data.get("db_config"),
|
||
main_table=data.get("main_table"),
|
||
main_table_schema=data.get("main_table_schema", ""),
|
||
main_table_database=data.get("main_table_database", ""),
|
||
form_config=data.get("form_config", {}),
|
||
list_config=data.get("list_config", {}),
|
||
sort=data.get("sort", 0),
|
||
show_in_mobile=data.get("show_in_mobile", False),
|
||
globally_visible=data.get("globally_visible", False),
|
||
icon=data.get("icon", ""),
|
||
icon_bg_color=data.get("icon_bg_color", ""),
|
||
sys_creator_id=creator_id,
|
||
sys_modifier_id=creator_id,
|
||
sys_dept_id=dept_id,
|
||
)
|
||
db.add(form)
|
||
await db.flush()
|
||
|
||
# 创建子表关联
|
||
for idx, sub_data in enumerate(sub_tables_data):
|
||
sub_table = FormSubTable(
|
||
form_id=form.id,
|
||
table_name=sub_data.get("table_name"),
|
||
table_schema=sub_data.get("table_schema", ""),
|
||
table_database=sub_data.get("table_database", ""),
|
||
alias=sub_data.get("alias", ""),
|
||
foreign_key=sub_data.get("foreign_key"),
|
||
related_field=sub_data.get("related_field", "id"),
|
||
relation_type=sub_data.get("relation_type", "one-to-many"),
|
||
sort=sub_data.get("sort", idx),
|
||
sys_creator_id=user_id,
|
||
sys_modifier_id=user_id,
|
||
)
|
||
db.add(sub_table)
|
||
|
||
await db.commit()
|
||
await db.refresh(form)
|
||
|
||
logger.info(f"表单创建成功: {form.code}")
|
||
return form
|
||
|
||
# ============ 更新 ============
|
||
|
||
@staticmethod
|
||
async def update(
|
||
db: AsyncSession,
|
||
form_id: str,
|
||
data: Dict[str, Any],
|
||
user_id: str = None
|
||
) -> FormMeta:
|
||
"""更新表单"""
|
||
form = await FormService.get(db, form_id)
|
||
|
||
# 更新基本字段
|
||
if "name" in data and data["name"] is not None:
|
||
form.name = data["name"]
|
||
if "form_type" in data and data["form_type"] is not None:
|
||
form.form_type = data["form_type"]
|
||
if "description" in data and data["description"] is not None:
|
||
form.description = data["description"]
|
||
if "sort" in data and data["sort"] is not None:
|
||
form.sort = data["sort"]
|
||
if "show_in_mobile" in data and data["show_in_mobile"] is not None:
|
||
form.show_in_mobile = data["show_in_mobile"]
|
||
if "globally_visible" in data and data["globally_visible"] is not None:
|
||
form.globally_visible = data["globally_visible"]
|
||
if "icon" in data and data["icon"] is not None:
|
||
form.icon = data["icon"]
|
||
if "icon_bg_color" in data and data["icon_bg_color"] is not None:
|
||
form.icon_bg_color = data["icon_bg_color"]
|
||
if "form_config" in data and data["form_config"] is not None:
|
||
form.form_config = data["form_config"]
|
||
if "list_config" in data and data["list_config"] is not None:
|
||
form.list_config = data["list_config"]
|
||
|
||
# 更新数据库配置字段
|
||
if "db_config" in data and data["db_config"] is not None:
|
||
form.db_config = data["db_config"]
|
||
if "main_table" in data and data["main_table"] is not None:
|
||
form.main_table = data["main_table"]
|
||
if "main_table_schema" in data and data["main_table_schema"] is not None:
|
||
form.main_table_schema = data["main_table_schema"]
|
||
if "main_table_database" in data and data["main_table_database"] is not None:
|
||
form.main_table_database = data["main_table_database"]
|
||
|
||
form.sys_modifier_id = user_id
|
||
|
||
# 更新子表关联
|
||
if "sub_tables" in data and data["sub_tables"] is not None:
|
||
# 删除现有子表关联
|
||
delete_stmt = update(FormSubTable).where(
|
||
FormSubTable.form_id == form_id
|
||
).values(is_deleted=True)
|
||
await db.execute(delete_stmt)
|
||
|
||
# 创建新的子表关联
|
||
for idx, sub_data in enumerate(data["sub_tables"]):
|
||
sub_table = FormSubTable(
|
||
form_id=form_id,
|
||
table_name=sub_data.get("table_name"),
|
||
table_schema=sub_data.get("table_schema", ""),
|
||
table_database=sub_data.get("table_database", ""),
|
||
alias=sub_data.get("alias", ""),
|
||
foreign_key=sub_data.get("foreign_key"),
|
||
related_field=sub_data.get("related_field", "id"),
|
||
relation_type=sub_data.get("relation_type", "one-to-many"),
|
||
sort=sub_data.get("sort", idx),
|
||
sys_creator_id=user_id,
|
||
sys_modifier_id=user_id,
|
||
)
|
||
db.add(sub_table)
|
||
|
||
await db.commit()
|
||
await db.refresh(form)
|
||
|
||
logger.info(f"表单更新成功: {form.code}")
|
||
return form
|
||
|
||
# ============ 删除 ============
|
||
|
||
@staticmethod
|
||
async def _cleanup_form_publish_resources(db: AsyncSession, form: FormMeta) -> None:
|
||
"""清理表单发布产生的菜单、API/字段/数据权限及资源注册（取消发布、删除时共用）"""
|
||
from core.menu.model import Menu
|
||
from core.permission.model import Permission
|
||
from core.resource_scope.field_permission.model import ResourceFieldPermissionConfig
|
||
from core.resource_scope.scope_permission.model import ResourceDataScopeConfig
|
||
from app.resource_registry import ResourceRegistry
|
||
|
||
resource_type = f"form:{form.code}"
|
||
|
||
# 1. 物理删除对应菜单
|
||
delete_menu_stmt = delete(Menu).where(
|
||
Menu.path == f"/form-render/{form.code}"
|
||
)
|
||
menu_result = await db.execute(delete_menu_stmt)
|
||
if menu_result.rowcount > 0:
|
||
logger.info(f"物理删除表单菜单: {form.code}, 删除数量: {menu_result.rowcount}")
|
||
|
||
# 2. 物理删除 API 权限
|
||
delete_perm_stmt = delete(Permission).where(
|
||
Permission.code.like(f"form:{form.code}:%")
|
||
)
|
||
perm_result = await db.execute(delete_perm_stmt)
|
||
if perm_result.rowcount > 0:
|
||
logger.info(f"物理删除表单API权限: {form.code}, 删除数量: {perm_result.rowcount}")
|
||
|
||
# 3. 物理删除字段权限配置
|
||
delete_field_perm_stmt = delete(ResourceFieldPermissionConfig).where(
|
||
ResourceFieldPermissionConfig.resource_type == resource_type
|
||
)
|
||
field_perm_result = await db.execute(delete_field_perm_stmt)
|
||
if field_perm_result.rowcount > 0:
|
||
logger.info(f"物理删除表单字段权限: {form.code}, 删除数量: {field_perm_result.rowcount}")
|
||
|
||
# 4. 物理删除数据权限配置
|
||
delete_scope_stmt = delete(ResourceDataScopeConfig).where(
|
||
ResourceDataScopeConfig.resource_type == resource_type
|
||
)
|
||
scope_result = await db.execute(delete_scope_stmt)
|
||
if scope_result.rowcount > 0:
|
||
logger.info(f"物理删除表单数据权限: {form.code}, 删除数量: {scope_result.rowcount}")
|
||
|
||
# 5. 从资源注册表中移除
|
||
if ResourceRegistry.unregister(resource_type):
|
||
logger.info(f"从资源注册表移除: {resource_type}")
|
||
|
||
@staticmethod
|
||
async def delete(db: AsyncSession, form_id: str) -> bool:
|
||
"""删除表单（物理删除，并清理菜单与权限配置）"""
|
||
from core.menu.service import MenuService
|
||
|
||
form = await FormService.get(db, form_id)
|
||
|
||
await FormService._cleanup_form_publish_resources(db, form)
|
||
|
||
delete_sub_stmt = delete(FormSubTable).where(
|
||
FormSubTable.form_id == form_id
|
||
)
|
||
await db.execute(delete_sub_stmt)
|
||
|
||
await db.delete(form)
|
||
await db.commit()
|
||
|
||
await MenuService.invalidate_cache()
|
||
logger.info(f"表单删除成功: {form.code}")
|
||
return True
|
||
|
||
@staticmethod
|
||
async def batch_delete(db: AsyncSession, form_ids: List[str]) -> int:
|
||
"""批量删除表单（物理删除，并清理菜单与权限配置）"""
|
||
from core.menu.service import MenuService
|
||
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.id.in_(form_ids),
|
||
FormMeta.is_deleted == False,
|
||
)
|
||
result = await db.execute(stmt)
|
||
forms = list(result.scalars().all())
|
||
|
||
for form in forms:
|
||
await FormService._cleanup_form_publish_resources(db, form)
|
||
|
||
delete_sub_stmt = delete(FormSubTable).where(
|
||
FormSubTable.form_id.in_(form_ids)
|
||
)
|
||
await db.execute(delete_sub_stmt)
|
||
|
||
delete_stmt = delete(FormMeta).where(
|
||
FormMeta.id.in_(form_ids),
|
||
FormMeta.is_deleted == False,
|
||
)
|
||
result = await db.execute(delete_stmt)
|
||
await db.commit()
|
||
|
||
await MenuService.invalidate_cache()
|
||
count = result.rowcount
|
||
logger.info(f"批量删除表单成功: {count} 个")
|
||
return count
|
||
|
||
# ============ 发布/取消发布 ============
|
||
|
||
@staticmethod
|
||
async def publish(
|
||
db: AsyncSession,
|
||
form_id: str,
|
||
publish_config: Dict[str, Any] = None
|
||
) -> FormMeta:
|
||
"""发布表单并创建菜单和权限"""
|
||
from core.menu.model import Menu
|
||
from core.menu.service import MenuService
|
||
from core.permission.model import Permission
|
||
|
||
form = await FormService.get(db, form_id)
|
||
|
||
if form.status == "published":
|
||
raise FormServiceException("表单已发布")
|
||
|
||
sub_tables = await FormService.get_sub_tables(db, form_id)
|
||
table_validation = await FormService.validate_form_tables(
|
||
db,
|
||
{
|
||
"db_config": form.db_config,
|
||
"main_table": form.main_table,
|
||
"main_table_schema": form.main_table_schema or "",
|
||
"main_table_database": form.main_table_database or "",
|
||
"sub_tables": [
|
||
{
|
||
"table_name": s.table_name,
|
||
"table_schema": s.table_schema or "",
|
||
"table_database": s.table_database or "",
|
||
"foreign_key": s.foreign_key,
|
||
}
|
||
for s in sub_tables
|
||
],
|
||
},
|
||
)
|
||
if not table_validation.get("valid"):
|
||
if not table_validation.get("connection_ok"):
|
||
raise FormServiceException(
|
||
table_validation.get("connection_message")
|
||
or "数据库连接不可用，无法发布"
|
||
)
|
||
if not table_validation.get("main_table_exists"):
|
||
raise FormServiceException(
|
||
f"主表在目标库中不存在: {form.main_table}"
|
||
)
|
||
for check in table_validation.get("sub_table_checks") or []:
|
||
if not check.get("exists"):
|
||
raise FormServiceException(
|
||
f"子表在目标库中不存在: {check.get('table_name')}"
|
||
)
|
||
|
||
# 更新表单状态
|
||
form.status = "published"
|
||
form.version += 1
|
||
|
||
# 保存发布配置到 list_config
|
||
if publish_config:
|
||
list_config = form.list_config or {}
|
||
list_config["publish_config"] = {
|
||
"allow_add": publish_config.get("allow_add", True),
|
||
"allow_edit": publish_config.get("allow_edit", True),
|
||
"allow_delete": publish_config.get("allow_delete", True),
|
||
"allow_export": publish_config.get("allow_export", True),
|
||
"allow_import": publish_config.get("allow_import", False),
|
||
}
|
||
form.list_config = list_config
|
||
|
||
# 创建或更新菜单
|
||
menu_record = None
|
||
if publish_config:
|
||
menu_parent_id = publish_config.get("menu_parent_id")
|
||
|
||
# 检查是否已存在该表单的菜单
|
||
menu_stmt = select(Menu).where(
|
||
Menu.path == f"/form-render/{form.code}"
|
||
)
|
||
menu_result = await db.execute(menu_stmt)
|
||
existing_menu = menu_result.scalar_one_or_none()
|
||
|
||
if existing_menu:
|
||
# 更新现有菜单
|
||
existing_menu.name = publish_config.get("menu_name", form.name)
|
||
existing_menu.title = publish_config.get("menu_name", form.name)
|
||
existing_menu.parent_id = menu_parent_id
|
||
existing_menu.icon = publish_config.get("menu_icon", "lucide:file-text")
|
||
existing_menu.order = publish_config.get("menu_order", 0)
|
||
existing_menu.type = "online_form"
|
||
existing_menu.application_id = form.application_id
|
||
menu_record = existing_menu
|
||
logger.info(f"更新表单菜单: {form.code}")
|
||
else:
|
||
# 创建新菜单
|
||
new_menu = Menu(
|
||
application_id=form.application_id,
|
||
name=publish_config.get("menu_name", form.name),
|
||
title=publish_config.get("menu_name", form.name),
|
||
path=f"/form-render/{form.code}",
|
||
component="online-dev/form-render/index",
|
||
type="online_form",
|
||
parent_id=menu_parent_id,
|
||
icon=publish_config.get("menu_icon", "lucide:file-text"),
|
||
order=publish_config.get("menu_order", 0),
|
||
)
|
||
db.add(new_menu)
|
||
await db.flush()
|
||
menu_record = new_menu
|
||
logger.info(f"创建表单菜单: {form.code}")
|
||
|
||
# 创建表单操作权限
|
||
if menu_record:
|
||
await FormService._create_form_permissions(
|
||
db, form, menu_record.id, publish_config
|
||
)
|
||
|
||
await db.commit()
|
||
await db.refresh(form)
|
||
|
||
# 清空菜单缓存
|
||
await MenuService.invalidate_cache()
|
||
logger.info("已清空菜单缓存")
|
||
|
||
logger.info(f"表单发布成功: {form.code}, version={form.version}")
|
||
return form
|
||
|
||
@staticmethod
|
||
async def _create_form_permissions(
|
||
db: AsyncSession,
|
||
form: FormMeta,
|
||
menu_id: str,
|
||
publish_config: Dict[str, Any] = None
|
||
):
|
||
"""创建表单操作权限"""
|
||
from core.permission.model import Permission
|
||
from app.resource_registry import ResourceRegistry
|
||
|
||
# 注册表单资源类型到资源注册表（用于数据权限和字段权限配置）
|
||
resource_type = f"form:{form.code}"
|
||
# 生成字段元数据
|
||
field_metadata = FormService._generate_form_field_metadata(form)
|
||
ResourceRegistry.register(
|
||
resource_type=resource_type,
|
||
service_class=None, # 表单没有对应的 Service 类
|
||
display_name=form.name,
|
||
application_id=form.application_id,
|
||
field_metadata=field_metadata
|
||
)
|
||
logger.info(f"注册表单资源类型: {resource_type}, application_id={form.application_id}, fields={len(field_metadata)}")
|
||
|
||
# 定义标准操作权限
|
||
actions = [
|
||
("view", "查看", True, 0, "GET"),
|
||
("add", "新增", publish_config.get("allow_add", True) if publish_config else True, 1, "POST"),
|
||
("edit", "编辑", publish_config.get("allow_edit", True) if publish_config else True, 2, "PUT"),
|
||
("delete", "删除", publish_config.get("allow_delete", True) if publish_config else True, 3, "DELETE"),
|
||
("export", "导出", publish_config.get("allow_export", True) if publish_config else True, 1, "POST"),
|
||
("import", "导入", publish_config.get("allow_import", False) if publish_config else False, 1, "POST"),
|
||
]
|
||
|
||
# HTTP 方法映射
|
||
http_method_map = {"GET": 0, "POST": 1, "PUT": 2, "DELETE": 3, "PATCH": 4, "ALL": 5}
|
||
|
||
for action, name, enabled, http_method_int, http_method_str in actions:
|
||
perm_code = f"form:{form.code}:{action}"
|
||
|
||
# 检查权限是否已存在
|
||
existing_stmt = select(Permission).where(
|
||
Permission.menu_id == menu_id,
|
||
Permission.code == perm_code,
|
||
Permission.is_deleted == False
|
||
)
|
||
existing_result = await db.execute(existing_stmt)
|
||
existing_perm = existing_result.scalar_one_or_none()
|
||
|
||
if existing_perm:
|
||
# 更新现有权限的启用状态
|
||
existing_perm.is_active = enabled
|
||
existing_perm.name = f"{form.name}-{name}"
|
||
logger.info(f"更新表单权限: {perm_code}, enabled={enabled}")
|
||
else:
|
||
# 创建新权限
|
||
perm = Permission(
|
||
menu_id=menu_id,
|
||
name=f"{form.name}-{name}",
|
||
code=perm_code,
|
||
permission_type=1, # API权限
|
||
api_path=f"/api/core/form-data/{form.code}",
|
||
http_method=http_method_int,
|
||
is_active=enabled,
|
||
sort=actions.index((action, name, enabled, http_method_int, http_method_str))
|
||
)
|
||
db.add(perm)
|
||
logger.info(f"创建表单权限: {perm_code}, enabled={enabled}")
|
||
|
||
@staticmethod
|
||
async def unpublish(db: AsyncSession, form_id: str) -> FormMeta:
|
||
"""取消发布表单并删除菜单、权限等相关数据"""
|
||
from core.menu.service import MenuService
|
||
|
||
form = await FormService.get(db, form_id)
|
||
|
||
if form.status == "draft":
|
||
raise FormServiceException("表单未发布")
|
||
|
||
form.status = "draft"
|
||
await FormService._cleanup_form_publish_resources(db, form)
|
||
|
||
await db.commit()
|
||
await db.refresh(form)
|
||
|
||
await MenuService.invalidate_cache()
|
||
logger.info("已清空菜单缓存")
|
||
|
||
logger.info(f"表单取消发布完成: {form.code}")
|
||
return form
|
||
|
||
# ============ 复制 ============
|
||
|
||
@staticmethod
|
||
async def copy(
|
||
db: AsyncSession,
|
||
form_id: str,
|
||
new_code: str,
|
||
new_name: str = None,
|
||
user_id: str = None
|
||
) -> FormMeta:
|
||
"""复制表单"""
|
||
source = await FormService.get(db, form_id)
|
||
|
||
# 检查新编码唯一性
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.code == new_code,
|
||
FormMeta.is_deleted == False
|
||
)
|
||
result = await db.execute(stmt)
|
||
if result.scalar_one_or_none():
|
||
raise FormServiceException(f"表单编码已存在: {new_code}")
|
||
|
||
# 创建新表单
|
||
new_form = FormMeta(
|
||
application_id=source.application_id,
|
||
name=new_name or f"{source.name}_副本",
|
||
code=new_code,
|
||
form_type=source.form_type,
|
||
description=source.description,
|
||
status="draft",
|
||
version=1,
|
||
db_config=source.db_config,
|
||
main_table=source.main_table,
|
||
main_table_schema=source.main_table_schema,
|
||
main_table_database=source.main_table_database,
|
||
show_in_mobile=source.show_in_mobile,
|
||
globally_visible=False,
|
||
icon=source.icon,
|
||
icon_bg_color=source.icon_bg_color,
|
||
form_config=source.form_config,
|
||
list_config=source.list_config,
|
||
sort=source.sort,
|
||
sys_creator_id=user_id,
|
||
sys_modifier_id=user_id,
|
||
)
|
||
db.add(new_form)
|
||
await db.flush()
|
||
|
||
# 复制子表关联
|
||
sub_tables = await FormService.get_sub_tables(db, form_id)
|
||
for sub in sub_tables:
|
||
new_sub = FormSubTable(
|
||
form_id=new_form.id,
|
||
table_name=sub.table_name,
|
||
table_schema=sub.table_schema,
|
||
table_database=sub.table_database,
|
||
alias=sub.alias,
|
||
foreign_key=sub.foreign_key,
|
||
related_field=sub.related_field,
|
||
relation_type=sub.relation_type,
|
||
sort=sub.sort,
|
||
sys_creator_id=user_id,
|
||
sys_modifier_id=user_id,
|
||
)
|
||
db.add(new_sub)
|
||
|
||
await db.commit()
|
||
await db.refresh(new_form)
|
||
|
||
logger.info(f"表单复制成功: {source.code} -> {new_code}")
|
||
return new_form
|
||
|
||
# ============ 导入/导出 ============
|
||
|
||
@staticmethod
|
||
async def export_config(db: AsyncSession, form_id: str) -> Dict[str, Any]:
|
||
"""导出表单配置（含数据库表 DDL）"""
|
||
form = await FormService.get(db, form_id)
|
||
sub_tables = await FormService.get_sub_tables(db, form_id)
|
||
|
||
sub_tables_data = []
|
||
for sub in sub_tables:
|
||
sub_tables_data.append({
|
||
"table_name": sub.table_name,
|
||
"table_schema": sub.table_schema,
|
||
"table_database": sub.table_database,
|
||
"alias": sub.alias,
|
||
"foreign_key": sub.foreign_key,
|
||
"related_field": sub.related_field,
|
||
"relation_type": sub.relation_type,
|
||
"sort": sub.sort
|
||
})
|
||
|
||
table_ddl = {"main_table": "", "sub_tables": {}}
|
||
export_db_type = ""
|
||
db_service = None
|
||
try:
|
||
from core.database_manager.service import AsyncDatabaseManagerService
|
||
db_service = await AsyncDatabaseManagerService.create(form.db_config or "default")
|
||
export_db_type = getattr(db_service, "db_type", "") or ""
|
||
schema_name = form.main_table_schema or None
|
||
if form.main_table:
|
||
table_ddl["main_table"] = await db_service.get_table_ddl(
|
||
form.main_table, schema_name
|
||
)
|
||
for sub in sub_tables:
|
||
if sub.table_name:
|
||
sub_schema = sub.table_schema or schema_name
|
||
table_ddl["sub_tables"][sub.table_name] = await db_service.get_table_ddl(
|
||
sub.table_name, sub_schema
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f"导出表单 DDL 失败（不影响配置导出）: {e}")
|
||
|
||
return {
|
||
"name": form.name,
|
||
"code": form.code,
|
||
"form_type": form.form_type,
|
||
"description": form.description,
|
||
"show_in_mobile": form.show_in_mobile or False,
|
||
"globally_visible": form.globally_visible or False,
|
||
"export_db_type": export_db_type,
|
||
"db_config": form.db_config,
|
||
"main_table": form.main_table,
|
||
"main_table_schema": form.main_table_schema,
|
||
"main_table_database": form.main_table_database,
|
||
"form_config": form.form_config,
|
||
"list_config": form.list_config,
|
||
"sub_tables": sub_tables_data,
|
||
"table_ddl": table_ddl
|
||
}
|
||
|
||
@staticmethod
|
||
async def _check_table_exists(
|
||
db_config: str,
|
||
table_name: str,
|
||
schema_name: str = None,
|
||
database: str = None,
|
||
) -> bool:
|
||
"""检查数据库表是否存在"""
|
||
try:
|
||
from core.database_manager.service import AsyncDatabaseManagerService
|
||
db_service = await AsyncDatabaseManagerService.create(db_config or "default")
|
||
tables = await db_service.get_tables(
|
||
database=database,
|
||
schema_name=schema_name,
|
||
)
|
||
return any(t.get("table_name") == table_name for t in tables)
|
||
except Exception as e:
|
||
logger.warning(f"检查表是否存在失败: {table_name}, {e}")
|
||
return False
|
||
|
||
@staticmethod
|
||
async def validate_form_tables(db: AsyncSession, data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""校验表单主/子表在目标连接上是否存在"""
|
||
db_config = (data.get("db_config") or "default").strip() or "default"
|
||
main_table = data.get("main_table") or ""
|
||
main_schema = data.get("main_table_schema") or ""
|
||
main_database = data.get("main_table_database") or ""
|
||
sub_tables = data.get("sub_tables") or []
|
||
|
||
connection_ok = True
|
||
connection_message = ""
|
||
try:
|
||
from core.database_connection.resolver import ConnectionResolver
|
||
|
||
await ConnectionResolver.resolve(db_config, db)
|
||
except Exception as e:
|
||
connection_ok = False
|
||
connection_message = str(e)
|
||
|
||
main_exists = (
|
||
await FormService._check_table_exists(
|
||
db_config, main_table, main_schema or None, main_database or None
|
||
)
|
||
if main_table
|
||
else False
|
||
)
|
||
|
||
sub_checks = []
|
||
for sub in sub_tables:
|
||
if isinstance(sub, dict):
|
||
sub_name = sub.get("table_name", "")
|
||
sub_schema = sub.get("table_schema", "") or main_schema
|
||
sub_database = sub.get("table_database", "") or main_database
|
||
else:
|
||
sub_name = getattr(sub, "table_name", "")
|
||
sub_schema = getattr(sub, "table_schema", "") or main_schema
|
||
sub_database = getattr(sub, "table_database", "") or main_database
|
||
exists = (
|
||
await FormService._check_table_exists(
|
||
db_config, sub_name, sub_schema or None, sub_database or None
|
||
)
|
||
if sub_name
|
||
else False
|
||
)
|
||
sub_checks.append(
|
||
{
|
||
"table_name": sub_name,
|
||
"schema_name": sub_schema,
|
||
"exists": exists,
|
||
"has_ddl": False,
|
||
}
|
||
)
|
||
|
||
database_warnings: List[str] = []
|
||
if connection_ok and db_config != "default":
|
||
try:
|
||
from core.database_connection.resolver import ConnectionResolver
|
||
|
||
target_info = await ConnectionResolver.resolve(db_config, db)
|
||
if target_info.db_type == "mysql":
|
||
conn_db = (target_info.database or "").strip()
|
||
if main_database and conn_db and main_database.lower() != conn_db.lower():
|
||
database_warnings.append(
|
||
f"主表库名「{main_database}」与连接默认库「{conn_db}」不一致，"
|
||
"请确认 MySQL 账号具备跨库访问权限，或统一连接默认库与表单库名"
|
||
)
|
||
elif main_database and not conn_db:
|
||
database_warnings.append(
|
||
f"连接未配置默认库，将依赖 SQL 中的库名「{main_database}」访问表"
|
||
)
|
||
for sub in sub_tables:
|
||
if isinstance(sub, dict):
|
||
sub_name = sub.get("table_name", "")
|
||
sub_db = sub.get("table_database", "") or main_database
|
||
else:
|
||
sub_name = getattr(sub, "table_name", "")
|
||
sub_db = getattr(sub, "table_database", "") or main_database
|
||
if (
|
||
sub_name
|
||
and sub_db
|
||
and conn_db
|
||
and sub_db.lower() != conn_db.lower()
|
||
):
|
||
database_warnings.append(
|
||
f"子表「{sub_name}」库名「{sub_db}」与连接默认库「{conn_db}」不一致"
|
||
)
|
||
elif target_info.db_type == "postgresql":
|
||
conn_db = (target_info.database or "").strip()
|
||
if not conn_db and not main_database:
|
||
database_warnings.append(
|
||
"PostgreSQL 连接未配置默认库且表单未填写主表 database，"
|
||
"运行时将使用 postgres 系统库，可能导致找不到业务表"
|
||
)
|
||
elif not conn_db and main_database:
|
||
database_warnings.append(
|
||
f"连接未配置默认库，运行时将使用表单主表 database「{main_database}」"
|
||
)
|
||
elif target_info.db_type == "oracle":
|
||
conn_svc = (target_info.database or "").strip()
|
||
if main_database and conn_svc and main_database != conn_svc:
|
||
database_warnings.append(
|
||
f"表单主表 database「{main_database}」与连接 service「{conn_svc}」不一致，"
|
||
"Oracle 不按库名切换连接，请统一连接 service 与表单配置"
|
||
)
|
||
except Exception as e:
|
||
logger.warning("校验库名绑定失败: %s", e)
|
||
|
||
all_ok = connection_ok and main_exists and all(c["exists"] for c in sub_checks)
|
||
return {
|
||
"valid": all_ok,
|
||
"connection_ok": connection_ok,
|
||
"connection_message": connection_message,
|
||
"db_config": db_config,
|
||
"main_table_exists": main_exists,
|
||
"sub_table_checks": sub_checks,
|
||
"database_warnings": database_warnings,
|
||
}
|
||
|
||
@staticmethod
|
||
async def _get_available_schemas(db_config: str) -> List[str]:
|
||
"""获取可用的Schema列表"""
|
||
try:
|
||
from core.database_manager.service import AsyncDatabaseManagerService
|
||
db_service = await AsyncDatabaseManagerService.create(db_config or "default")
|
||
schemas = await db_service.get_schemas()
|
||
return [s.get("name", "") for s in schemas if s.get("name")]
|
||
except Exception as e:
|
||
logger.warning(f"获取Schema列表失败: {e}")
|
||
return ["public"]
|
||
|
||
@staticmethod
|
||
async def _resolve_table_schema(
|
||
db_config: str,
|
||
table_name: str,
|
||
preferred_schema: str = None,
|
||
) -> str:
|
||
"""解析表在目标库中实际所在的 schema（导入时 meta 可能与真实库不一致）"""
|
||
if not table_name:
|
||
return preferred_schema or "public"
|
||
|
||
schemas_to_try: List[str] = []
|
||
if preferred_schema:
|
||
schemas_to_try.append(preferred_schema)
|
||
for schema in await FormService._get_available_schemas(db_config):
|
||
if schema and schema not in schemas_to_try:
|
||
schemas_to_try.append(schema)
|
||
if "public" not in schemas_to_try:
|
||
schemas_to_try.append("public")
|
||
|
||
for schema in schemas_to_try:
|
||
if await FormService._check_table_exists(db_config, table_name, schema):
|
||
return schema
|
||
|
||
return preferred_schema or "public"
|
||
|
||
@staticmethod
|
||
def _generate_create_schema_sql(schema: str, db_type: str) -> str:
|
||
"""生成创建 Schema 的 SQL（PostgreSQL / SQL Server）"""
|
||
if not schema:
|
||
return ""
|
||
if db_type == "postgresql":
|
||
return f'CREATE SCHEMA IF NOT EXISTS "{schema}";'
|
||
if db_type == "sqlserver":
|
||
return f"""
|
||
IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '{schema}')
|
||
BEGIN
|
||
EXEC('CREATE SCHEMA [{schema}]')
|
||
END;
|
||
"""
|
||
return ""
|
||
|
||
@staticmethod
|
||
async def _ensure_schemas_exist(
|
||
db_config: str,
|
||
schemas: List[str],
|
||
database: str = None,
|
||
) -> None:
|
||
"""确保目标 Schema 存在（仅 PostgreSQL / SQL Server）"""
|
||
unique_schemas = sorted({s.strip() for s in schemas if s and s.strip()})
|
||
if not unique_schemas:
|
||
return
|
||
|
||
from core.database_manager.service import AsyncDatabaseManagerService
|
||
|
||
db_service = await AsyncDatabaseManagerService.create(db_config)
|
||
db_type = getattr(db_service, "db_type", None)
|
||
if db_type not in ("postgresql", "sqlserver"):
|
||
return
|
||
|
||
available = await FormService._get_available_schemas(db_config)
|
||
for schema in unique_schemas:
|
||
if schema in available:
|
||
continue
|
||
sql = FormService._generate_create_schema_sql(schema, db_type)
|
||
if not sql:
|
||
continue
|
||
result = await db_service.execute_ddl(sql, database=database)
|
||
if not result.get("success"):
|
||
raise FormServiceException(
|
||
f"创建 Schema [{schema}] 失败: {result.get('message')}"
|
||
)
|
||
logger.info(f"导入时自动创建 Schema: {schema}")
|
||
|
||
@staticmethod
|
||
def _collect_import_target_schemas(data: Dict[str, Any]) -> List[str]:
|
||
"""收集导入配置中涉及的目标 Schema"""
|
||
schemas: List[str] = []
|
||
main_schema = (data.get("main_table_schema") or "").strip()
|
||
if main_schema:
|
||
schemas.append(main_schema)
|
||
|
||
for sub in data.get("sub_tables", []) or []:
|
||
if isinstance(sub, dict):
|
||
sub_schema = (sub.get("table_schema") or "").strip()
|
||
else:
|
||
sub_schema = (getattr(sub, "table_schema", "") or "").strip()
|
||
if sub_schema:
|
||
schemas.append(sub_schema)
|
||
|
||
return schemas
|
||
|
||
@staticmethod
|
||
def _sync_form_config_table_meta(data: Dict[str, Any]) -> None:
|
||
"""将顶层库表绑定同步到 form_config.tableConfigs.meta"""
|
||
form_config = data.get("form_config") or {}
|
||
table_configs = form_config.get("tableConfigs") or []
|
||
if not table_configs:
|
||
return
|
||
|
||
db_config = data.get("db_config", "default")
|
||
main_schema = data.get("main_table_schema", "")
|
||
main_database = data.get("main_table_database", "")
|
||
sub_tables = data.get("sub_tables", []) or []
|
||
sub_map = {}
|
||
for sub in sub_tables:
|
||
if isinstance(sub, dict):
|
||
sub_map[sub.get("table_name", "")] = sub
|
||
else:
|
||
sub_map[getattr(sub, "table_name", "")] = sub
|
||
|
||
for tc in table_configs:
|
||
if not isinstance(tc, dict):
|
||
continue
|
||
meta = tc.setdefault("meta", {})
|
||
meta["dbName"] = db_config
|
||
if tc.get("type") == "main":
|
||
if main_database:
|
||
meta["database"] = main_database
|
||
if main_schema:
|
||
meta["schema"] = main_schema
|
||
else:
|
||
sub = sub_map.get(tc.get("tableName", ""))
|
||
if sub:
|
||
if isinstance(sub, dict):
|
||
if sub.get("table_database"):
|
||
meta["database"] = sub["table_database"]
|
||
if sub.get("table_schema"):
|
||
meta["schema"] = sub["table_schema"]
|
||
else:
|
||
if sub.table_database:
|
||
meta["database"] = sub.table_database
|
||
if sub.table_schema:
|
||
meta["schema"] = sub.table_schema
|
||
|
||
@staticmethod
|
||
async def check_import(db: AsyncSession, data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""导入预检查：检查编码冲突、表和schema是否存在"""
|
||
code = data.get("code", "")
|
||
db_config = data.get("db_config", "default")
|
||
main_table = data.get("main_table", "")
|
||
main_table_schema = data.get("main_table_schema", "") or "public"
|
||
main_table_database = data.get("main_table_database", "") or ""
|
||
sub_tables = data.get("sub_tables", [])
|
||
table_ddl = data.get("table_ddl") or {}
|
||
|
||
code_exists = False
|
||
if code:
|
||
stmt = select(FormMeta).where(FormMeta.code == code, FormMeta.is_deleted == False)
|
||
result = await db.execute(stmt)
|
||
code_exists = result.scalar_one_or_none() is not None
|
||
|
||
main_exists = (
|
||
await FormService._check_table_exists(
|
||
db_config, main_table, main_table_schema, main_table_database or None
|
||
)
|
||
if main_table
|
||
else False
|
||
)
|
||
main_has_ddl = bool(table_ddl.get("main_table"))
|
||
|
||
sub_table_checks = []
|
||
ddl_sub = table_ddl.get("sub_tables", {})
|
||
for sub in sub_tables:
|
||
sub_name = sub.get("table_name", "") if isinstance(sub, dict) else sub.table_name
|
||
sub_schema = (sub.get("table_schema", "") if isinstance(sub, dict) else sub.table_schema) or main_table_schema
|
||
sub_database = (
|
||
(sub.get("table_database", "") if isinstance(sub, dict) else getattr(sub, "table_database", ""))
|
||
or main_table_database
|
||
)
|
||
exists = (
|
||
await FormService._check_table_exists(
|
||
db_config, sub_name, sub_schema or None, sub_database or None
|
||
)
|
||
if sub_name
|
||
else False
|
||
)
|
||
sub_table_checks.append({
|
||
"table_name": sub_name,
|
||
"schema_name": sub_schema,
|
||
"exists": exists,
|
||
"has_ddl": bool(ddl_sub.get(sub_name))
|
||
})
|
||
|
||
all_tables_exist = main_exists and all(c["exists"] for c in sub_table_checks)
|
||
can_import = not code_exists and all_tables_exist
|
||
|
||
available_schemas = await FormService._get_available_schemas(db_config)
|
||
|
||
target_db_type = ""
|
||
try:
|
||
from core.database_connection.resolver import ConnectionResolver
|
||
|
||
target_info = await ConnectionResolver.resolve(db_config, db)
|
||
target_db_type = getattr(target_info, "db_type", "") or ""
|
||
except Exception as e:
|
||
logger.warning("导入预检查解析目标库类型失败: %s", e)
|
||
|
||
return {
|
||
"code_exists": code_exists,
|
||
"main_table_check": {
|
||
"table_name": main_table,
|
||
"schema_name": main_table_schema,
|
||
"exists": main_exists,
|
||
"has_ddl": main_has_ddl
|
||
},
|
||
"sub_table_checks": sub_table_checks,
|
||
"can_import": can_import,
|
||
"available_schemas": available_schemas,
|
||
"target_db_type": target_db_type,
|
||
}
|
||
|
||
@staticmethod
|
||
def _replace_table_name_in_ddl(ddl: str, old_name: str, new_name: str, new_schema: str = None) -> str:
|
||
"""替换DDL中的表名和schema"""
|
||
import re
|
||
escaped = re.escape(old_name)
|
||
# CREATE TABLE "schema"."table" or CREATE TABLE schema.table
|
||
pattern_with_schema = rf'(CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?)"?[\w]+"?\."?{escaped}"?'
|
||
# CREATE TABLE "table" or CREATE TABLE table
|
||
pattern_without_schema = rf'(CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?)"?{escaped}"?'
|
||
|
||
if new_schema:
|
||
target = f'\\1"{new_schema}"."{new_name}"'
|
||
else:
|
||
target = f'\\1"{new_name}"'
|
||
|
||
result = re.sub(pattern_with_schema, target, ddl, count=1, flags=re.IGNORECASE)
|
||
if result == ddl:
|
||
if new_schema:
|
||
target_no_schema = f'\\1"{new_schema}"."{new_name}"'
|
||
else:
|
||
target_no_schema = f'\\1"{new_name}"'
|
||
result = re.sub(pattern_without_schema, target_no_schema, ddl, count=1, flags=re.IGNORECASE)
|
||
return result
|
||
|
||
@staticmethod
|
||
async def import_config(
|
||
db: AsyncSession,
|
||
data: Dict[str, Any],
|
||
user_id: str = None
|
||
) -> FormMeta:
|
||
"""导入表单配置（支持自动建表、表名重映射）"""
|
||
required_fields = ["name", "code", "db_config", "main_table"]
|
||
for field in required_fields:
|
||
if not data.get(field):
|
||
raise FormServiceException(f"缺少必要字段: {field}")
|
||
|
||
auto_create = data.pop("auto_create_tables", False)
|
||
create_schema = data.pop("create_schema_if_not_exists", False)
|
||
table_ddl = data.pop("table_ddl", None) or {}
|
||
rename_mappings = data.pop("table_rename_mappings", [])
|
||
export_db_type = (data.pop("export_db_type", None) or "").strip().lower()
|
||
db_config = data.get("db_config", "default")
|
||
|
||
if auto_create and table_ddl and export_db_type:
|
||
from core.database_connection.resolver import ConnectionResolver
|
||
|
||
def _norm_db_type(t: str) -> str:
|
||
t = (t or "").lower()
|
||
if t in ("postgres", "psql"):
|
||
return "postgresql"
|
||
if t == "mssql":
|
||
return "sqlserver"
|
||
return t
|
||
|
||
target_info = await ConnectionResolver.resolve(db_config, db)
|
||
src_t = _norm_db_type(export_db_type)
|
||
tgt_t = _norm_db_type(target_info.db_type)
|
||
if src_t and tgt_t and src_t != tgt_t:
|
||
raise FormServiceException(
|
||
"CROSS_DIALECT_AUTO_CREATE:"
|
||
f"导出库类型为 {src_t}，目标连接类型为 {tgt_t}"
|
||
)
|
||
|
||
rename_map = {}
|
||
for m in rename_mappings:
|
||
orig = m.get("original_name", "") if isinstance(m, dict) else m.original_name
|
||
new_n = m.get("new_name", "") if isinstance(m, dict) else m.new_name
|
||
new_s = m.get("new_schema") if isinstance(m, dict) else m.new_schema
|
||
if orig and new_n:
|
||
rename_map[orig] = {"new_name": new_n, "new_schema": new_s}
|
||
|
||
original_main_table = data["main_table"]
|
||
if original_main_table in rename_map:
|
||
mapping = rename_map[original_main_table]
|
||
data["main_table"] = mapping["new_name"]
|
||
if mapping["new_schema"]:
|
||
data["main_table_schema"] = mapping["new_schema"]
|
||
|
||
sub_tables = data.get("sub_tables", [])
|
||
for sub in sub_tables:
|
||
sub_name = sub.get("table_name", "") if isinstance(sub, dict) else sub.table_name
|
||
if sub_name in rename_map:
|
||
mapping = rename_map[sub_name]
|
||
if isinstance(sub, dict):
|
||
sub["table_name"] = mapping["new_name"]
|
||
if mapping["new_schema"]:
|
||
sub["table_schema"] = mapping["new_schema"]
|
||
else:
|
||
sub.table_name = mapping["new_name"]
|
||
if mapping["new_schema"]:
|
||
sub.table_schema = mapping["new_schema"]
|
||
|
||
db_config = data.get("db_config", "default")
|
||
main_database = data.get("main_table_database", "") or None
|
||
|
||
if create_schema:
|
||
await FormService._ensure_schemas_exist(
|
||
db_config,
|
||
FormService._collect_import_target_schemas(data),
|
||
main_database,
|
||
)
|
||
|
||
if auto_create and table_ddl:
|
||
main_table = data.get("main_table", "")
|
||
main_schema = data.get("main_table_schema", "")
|
||
|
||
try:
|
||
from core.database_manager.service import AsyncDatabaseManagerService
|
||
db_service = await AsyncDatabaseManagerService.create(db_config)
|
||
|
||
main_ddl = table_ddl.get("main_table", "")
|
||
if main_ddl and main_table:
|
||
if not await FormService._check_table_exists(db_config, main_table, main_schema):
|
||
if original_main_table in rename_map:
|
||
main_ddl = FormService._replace_table_name_in_ddl(
|
||
main_ddl, original_main_table, main_table, main_schema
|
||
)
|
||
result = await db_service.execute_ddl(main_ddl, schema_name=main_schema or None)
|
||
if not result.get("success"):
|
||
raise FormServiceException(f"创建主表失败: {result.get('message')}")
|
||
logger.info(f"导入时自动创建主表: {main_schema}.{main_table}")
|
||
|
||
sub_ddls = table_ddl.get("sub_tables", {})
|
||
for sub in data.get("sub_tables", []):
|
||
sub_name = sub.get("table_name", "") if isinstance(sub, dict) else sub.table_name
|
||
sub_schema = sub.get("table_schema", "") if isinstance(sub, dict) else sub.table_schema
|
||
|
||
original_sub_name = None
|
||
for orig_name, mp in rename_map.items():
|
||
if mp["new_name"] == sub_name:
|
||
original_sub_name = orig_name
|
||
break
|
||
|
||
ddl_key = original_sub_name or sub_name
|
||
ddl = sub_ddls.get(ddl_key, "")
|
||
if ddl and sub_name:
|
||
if not await FormService._check_table_exists(db_config, sub_name, sub_schema or main_schema):
|
||
if original_sub_name:
|
||
ddl = FormService._replace_table_name_in_ddl(
|
||
ddl, original_sub_name, sub_name, sub_schema or main_schema
|
||
)
|
||
result = await db_service.execute_ddl(ddl, schema_name=sub_schema or main_schema or None)
|
||
if not result.get("success"):
|
||
raise FormServiceException(f"创建子表 {sub_name} 失败: {result.get('message')}")
|
||
logger.info(f"导入时自动创建子表: {sub_schema or main_schema}.{sub_name}")
|
||
except FormServiceException:
|
||
raise
|
||
except Exception as e:
|
||
raise FormServiceException(f"自动建表失败: {str(e)}")
|
||
|
||
# 导入时校正 schema：导出环境的 schema 可能与目标库不一致
|
||
main_table = data.get("main_table", "")
|
||
if main_table:
|
||
data["main_table_schema"] = await FormService._resolve_table_schema(
|
||
db_config,
|
||
main_table,
|
||
data.get("main_table_schema") or None,
|
||
)
|
||
|
||
for sub in data.get("sub_tables", []):
|
||
if isinstance(sub, dict):
|
||
sub_name = sub.get("table_name", "")
|
||
sub_schema = sub.get("table_schema", "") or data.get("main_table_schema", "")
|
||
else:
|
||
sub_name = sub.table_name
|
||
sub_schema = sub.table_schema or data.get("main_table_schema", "")
|
||
if sub_name:
|
||
resolved_sub_schema = await FormService._resolve_table_schema(
|
||
db_config, sub_name, sub_schema or None
|
||
)
|
||
if isinstance(sub, dict):
|
||
sub["table_schema"] = resolved_sub_schema
|
||
else:
|
||
sub.table_schema = resolved_sub_schema
|
||
|
||
FormService._sync_form_config_table_meta(data)
|
||
|
||
return await FormService.create(db, data, user_id)
|
||
|
||
# ============ 获取表单类型列表 ============
|
||
|
||
@staticmethod
|
||
def get_form_types() -> List[Dict[str, str]]:
|
||
"""获取所有表单类型"""
|
||
return [
|
||
{"value": "normal", "label": "普通表单"},
|
||
{"value": "workflow", "label": "流程表单"},
|
||
]
|
||
|
||
@staticmethod
|
||
def _generate_form_field_metadata(form: FormMeta) -> Dict[str, Dict[str, Any]]:
|
||
"""
|
||
根据表单配置生成字段元数据
|
||
用于字段权限配置
|
||
"""
|
||
field_metadata = {}
|
||
|
||
# 从表单配置中提取字段信息
|
||
form_config = form.form_config or {}
|
||
items = form_config.get('items', [])
|
||
|
||
def extract_fields(items_list):
|
||
"""递归提取字段信息"""
|
||
for item in items_list:
|
||
field_name = item.get('field')
|
||
item_type = item.get('type', '')
|
||
|
||
# 处理容器类型，递归提取子项
|
||
# collapse: 子项在 items[].children 中
|
||
if item_type == 'collapse':
|
||
collapse_items = item.get('items', [])
|
||
for collapse_item in collapse_items:
|
||
collapse_children = collapse_item.get('children', [])
|
||
if collapse_children:
|
||
extract_fields(collapse_children)
|
||
continue
|
||
|
||
# grid: 子项在 columns[].children 中
|
||
if item_type == 'grid':
|
||
columns = item.get('columns', [])
|
||
for column in columns:
|
||
column_children = column.get('children', [])
|
||
if column_children:
|
||
extract_fields(column_children)
|
||
continue
|
||
|
||
# tabs: 子项在 tabs[].children 中
|
||
if item_type == 'tabs':
|
||
tabs = item.get('tabs', [])
|
||
for tab in tabs:
|
||
tab_children = tab.get('children', [])
|
||
if tab_children:
|
||
extract_fields(tab_children)
|
||
continue
|
||
|
||
# 其他容器类型（card, row, col, 展示组件等）: 子项在 children 中
|
||
if item_type in ['card', 'row', 'col', 'divider', 'alert', 'timeline', 'text', 'html', 'spacer', 'title', 'steps']:
|
||
children = item.get('children', [])
|
||
if children:
|
||
extract_fields(children)
|
||
continue
|
||
|
||
# sub-table: 子表字段也需要提取
|
||
if item_type == 'sub-table':
|
||
# 子表本身作为一个字段
|
||
if field_name and not field_name.startswith('_'):
|
||
field_metadata[field_name] = {
|
||
'label': item.get('label', field_name),
|
||
'field_type': 'sub-table',
|
||
'required': item.get('props', {}).get('required', False),
|
||
'sensitive': False,
|
||
'maskable': False,
|
||
'default_permission': 'write'
|
||
}
|
||
# 子表内的字段也提取
|
||
children = item.get('children', [])
|
||
if children:
|
||
extract_fields(children)
|
||
continue
|
||
|
||
# 跳过没有字段名的项
|
||
if not field_name:
|
||
continue
|
||
|
||
# 跳过内部字段
|
||
if field_name.startswith('_'):
|
||
continue
|
||
|
||
field_metadata[field_name] = {
|
||
'label': item.get('label', field_name),
|
||
'field_type': item_type or 'string',
|
||
'required': item.get('props', {}).get('required', False),
|
||
'sensitive': False,
|
||
'maskable': False,
|
||
'default_permission': 'write'
|
||
}
|
||
|
||
extract_fields(items)
|
||
return field_metadata
|
||
|
||
@staticmethod
|
||
async def get_published_forms_simple(db: AsyncSession, application_id: str = None, all_apps: bool = False) -> List[Dict[str, Any]]:
|
||
"""
|
||
获取已发布表单的简单列表（用于下拉选择）
|
||
|
||
Args:
|
||
application_id: 过滤指定应用，为 None 且 all_apps=False 时只返回无应用的表单
|
||
all_apps: 为 True 时返回所有应用的已发布表单（移动端工作台使用）
|
||
Returns:
|
||
[{code, name, mainTable, application_id, application_name, fields: [{field, label, type}]}]
|
||
"""
|
||
from core.application.model import Application
|
||
|
||
conditions = [
|
||
FormMeta.status == "published",
|
||
FormMeta.is_deleted == False
|
||
]
|
||
if application_id:
|
||
conditions.append(
|
||
FormService.build_app_scope_condition(
|
||
application_id,
|
||
for_selection=not all_apps,
|
||
)
|
||
)
|
||
elif not all_apps:
|
||
conditions.append(
|
||
FormService.build_app_scope_condition(
|
||
None,
|
||
for_selection=True,
|
||
)
|
||
)
|
||
|
||
if all_apps:
|
||
conditions.append(FormMeta.show_in_mobile == True)
|
||
|
||
stmt = select(FormMeta, Application.name.label("application_name")).outerjoin(
|
||
Application, Application.id == FormMeta.application_id
|
||
).where(
|
||
*conditions
|
||
).order_by(FormMeta.name)
|
||
|
||
result = await db.execute(stmt)
|
||
rows = result.all()
|
||
|
||
simple_list = []
|
||
for row in rows:
|
||
form = row[0]
|
||
application_name = row[1]
|
||
# 提取表单字段信息
|
||
fields = []
|
||
form_config = form.form_config or {}
|
||
items = form_config.get("items", [])
|
||
|
||
def extract_fields(item_list: List[Dict], in_sub_table: bool = False):
|
||
"""递归提取字段"""
|
||
for item in item_list:
|
||
item_type = item.get("type", "")
|
||
field = item.get("field", "")
|
||
label = item.get("label", "")
|
||
|
||
# 跳过子表和布局组件
|
||
if item_type == "sub-table":
|
||
continue
|
||
|
||
# 布局组件，递归处理
|
||
if item_type in ("grid", "tabs", "collapse", "steps", "button"):
|
||
if item.get("columns"):
|
||
for col in item["columns"]:
|
||
extract_fields(col.get("children", []), in_sub_table)
|
||
if item.get("items"):
|
||
for sub_item in item["items"]:
|
||
extract_fields(sub_item.get("children", []), in_sub_table)
|
||
continue
|
||
|
||
# 普通字段（排除非数据字段）
|
||
if field and not in_sub_table and item_type not in ("divider", "alert", "timeline", "text", "html", "spacer", "title", "button"):
|
||
fields.append({
|
||
"field": field,
|
||
"label": label or field,
|
||
"type": item_type
|
||
})
|
||
|
||
extract_fields(items)
|
||
|
||
# 添加常用的系统字段到字段列表开头
|
||
system_fields = [
|
||
{"field": "id", "label": "ID", "type": "string"},
|
||
{"field": "sys_create_datetime", "label": "创建时间", "type": "datetime"},
|
||
{"field": "sys_update_datetime", "label": "更新时间", "type": "datetime"},
|
||
{"field": "sys_creator_id", "label": "创建人ID", "type": "string"},
|
||
{"field": "sys_modifier_id", "label": "修改人ID", "type": "string"},
|
||
{"field": "sys_dept_id", "label": "部门ID", "type": "string"},
|
||
{"field": "sort", "label": "排序", "type": "number"},
|
||
]
|
||
# 将系统字段添加到开头
|
||
fields = system_fields + fields
|
||
|
||
simple_list.append({
|
||
"code": form.code,
|
||
"name": form.name,
|
||
"mainTable": form.main_table,
|
||
"application_id": form.application_id,
|
||
"application_name": application_name,
|
||
"icon": form.icon or "",
|
||
"icon_bg_color": form.icon_bg_color or "",
|
||
"form_type": form.form_type or "normal",
|
||
"fields": fields
|
||
})
|
||
|
||
return simple_list
|
||
|
||
@staticmethod
|
||
async def register_published_forms_to_registry(db: AsyncSession):
|
||
"""
|
||
启动时加载已发布的表单并注册资源类型到 ResourceRegistry
|
||
用于数据权限和字段权限配置
|
||
"""
|
||
from app.resource_registry import ResourceRegistry
|
||
|
||
# 查询所有已发布的表单
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.status == "published",
|
||
FormMeta.is_deleted == False
|
||
)
|
||
result = await db.execute(stmt)
|
||
published_forms = result.scalars().all()
|
||
|
||
for form in published_forms:
|
||
resource_type = f"form:{form.code}"
|
||
# 生成字段元数据
|
||
field_metadata = FormService._generate_form_field_metadata(form)
|
||
|
||
ResourceRegistry.register(
|
||
resource_type=resource_type,
|
||
service_class=None,
|
||
display_name=form.name,
|
||
application_id=form.application_id,
|
||
field_metadata=field_metadata
|
||
)
|
||
logger.info(f"启动时注册表单资源类型: {resource_type}, application_id={form.application_id}, fields={len(field_metadata)}")
|