TanWenyan
89b1d2e5f5
## 主要改进 ### 1. 删除策略优化（从级联删除改为阻止删除） - ✅ **安全优先**：采用阻止删除策略而非级联删除 - ✅ 删除前检查子分组，如有则拒绝删除 - ✅ 删除前检查关联评查点，如有则拒绝删除 - ✅ 只有空分组才能被删除 ### 2. 详细的删除检查 - ✅ ID有效性验证 - ✅ 分组存在性验证 - ✅ 子分组检查（仅一级分组） - ✅ 评查点关联检查（所有分组） - ✅ 返回详细的检查结果（childCount, pointCount） ### 3. 友好的错误提示 - ✅ 明确提示存在多少个子分组 - ✅ 明确提示存在多少个评查点 - ✅ 建议用户先清理关联数据 - ✅ 区分不同类型的删除失败原因 ### 4. 标记废弃函数 - ✅ deleteChildGroup 标记为 @deprecated - ✅ deleteEvaluationPointsByGroupId 标记为 @deprecated - ✅ 保留代码以备将来批量删除功能使用 ## 删除策略对比 ### 旧策略（级联删除）- 高风险 ❌ 删除一级分组时自动删除所有子分组 ❌ 自动删除所有关联的评查点 ❌ 用户可能误删大量数据 ❌ 无法恢复 ### 新策略（阻止删除）- 安全 ✅ 拒绝删除有子分组的一级分组 ✅ 拒绝删除有评查点的分组 ✅ 用户必须手动清理关联数据 ✅ 防止误删除 ✅ 提供清晰的错误提示 ## 返回值增强 ```typescript { success: boolean; error?: string; details?: { hasChildren: boolean; // 是否有子分组 hasPoints: boolean; // 是否有评查点 childCount?: number; // 子分组数量 pointCount?: number; // 评查点数量 } } ``` ## 相关文件 - app/api/evaluation_points/rule-groups.ts ## 验收清单 - [x] TypeScript 类型检查通过 - [x] 删除前完整的关联检查 - [x] 阻止删除有依赖的分组 - [x] 详细的错误提示 - [x] 返回详细的检查结果 Co-Authored-By: Claude <noreply@anthropic.com>
945 lines
28 KiB
TypeScript
945 lines
28 KiB
TypeScript
import { postgrestGet, postgrestPost, postgrestPut, postgrestDelete, type PostgrestParams } from '../postgrest-client';
|
|
import { formatDate } from '../../utils';
|
|
|
|
/**
|
|
* 评查点分组接口
|
|
*/
|
|
export interface RuleGroup {
|
|
id: string;
|
|
pid: string;
|
|
name: string;
|
|
code?: string; // 添加分组编码字段
|
|
is_enabled: boolean;
|
|
ruleCount?: number; // 评查点数量
|
|
children?: RuleGroup[]; // 子分组
|
|
createdAt?: string; // 添加创建时间字段
|
|
description?: string; // 描述
|
|
}
|
|
|
|
// API请求模型
|
|
export interface ApiRuleGroup {
|
|
id?: number;
|
|
pid: number | null; // 允许 null，表示一级分组
|
|
name: string;
|
|
code?: string;
|
|
description?: string;
|
|
is_enabled: boolean;
|
|
created_at?: string;
|
|
updated_at?: string;
|
|
}
|
|
|
|
// 创建或更新分组请求参数
|
|
export interface RuleGroupCreateUpdateDto {
|
|
name: string;
|
|
code: string;
|
|
pid: string | null; // 父分组ID，如果是一级分组则为null或'0'
|
|
description?: string;
|
|
is_enabled: boolean;
|
|
}
|
|
|
|
// 用于替换代码中的 any 类型
|
|
interface ApiResponse<T> {
|
|
code: number;
|
|
msg: string;
|
|
data: T;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 从不同格式的 API 响应中提取数据
|
|
* @param responseData API 响应数据
|
|
* @returns 提取后的数据或 null
|
|
*/
|
|
function extractApiData<T>(responseData: unknown): T | null {
|
|
if (!responseData) return null;
|
|
|
|
// 格式1: { code: number, msg: string, data: T }
|
|
if (typeof responseData === 'object' && responseData !== null &&
|
|
'code' in responseData &&
|
|
'data' in responseData &&
|
|
(responseData as { data: unknown }).data) {
|
|
return (responseData as { data: T }).data;
|
|
}
|
|
|
|
// 格式2: 直接是数据对象
|
|
return responseData as T;
|
|
}
|
|
|
|
/**
|
|
* 评查点分组查询参数
|
|
*/
|
|
export interface RuleGroupQueryParams {
|
|
// 分页参数
|
|
page?: number;
|
|
pageSize?: number;
|
|
|
|
// 筛选参数
|
|
name?: string; // 名称模糊搜索
|
|
code?: string; // 编码模糊搜索
|
|
is_enabled?: boolean; // 启用状态
|
|
pid?: string | null; // 父级ID (null表示一级分组, 具体ID表示查询该父级的子分组)
|
|
|
|
// 排序参数
|
|
orderBy?: 'created_at' | 'updated_at' | 'name' | 'code';
|
|
order?: 'asc' | 'desc';
|
|
|
|
token?: string;
|
|
}
|
|
|
|
/**
|
|
* 获取评查点分组列表（支持分页、筛选、排序）
|
|
* @param params 查询参数
|
|
* @returns 评查点分组列表和总数
|
|
*/
|
|
export async function getRuleGroups(
|
|
params?: RuleGroupQueryParams
|
|
): Promise<{data: RuleGroup[]; totalCount?: number; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
const {
|
|
page = 1,
|
|
pageSize = 50,
|
|
name,
|
|
code,
|
|
is_enabled,
|
|
pid = '0', // 默认获取一级分组
|
|
orderBy = 'created_at',
|
|
order = 'desc',
|
|
token
|
|
} = params || {};
|
|
|
|
// 构建筛选条件
|
|
const filter: Record<string, string> = {};
|
|
|
|
// 父级ID筛选 (pid=null或'0'表示一级分组)
|
|
if (pid === null || pid === '0') {
|
|
filter['pid'] = 'eq.0';
|
|
} else if (pid) {
|
|
filter['pid'] = `eq.${pid}`;
|
|
}
|
|
|
|
// 名称模糊搜索
|
|
if (name) {
|
|
filter['name'] = `ilike.*${name}*`;
|
|
}
|
|
|
|
// 编码模糊搜索
|
|
if (code) {
|
|
filter['code'] = `ilike.*${code}*`;
|
|
}
|
|
|
|
// 状态筛选
|
|
if (is_enabled !== undefined) {
|
|
filter['is_enabled'] = `eq.${is_enabled}`;
|
|
}
|
|
|
|
const postgrestParams: PostgrestParams = {
|
|
select: `
|
|
id,
|
|
pid,
|
|
name,
|
|
code,
|
|
description,
|
|
is_enabled,
|
|
created_at
|
|
`,
|
|
filter,
|
|
order: `${orderBy}.${order}`, // PostgREST order format: field.direction
|
|
limit: pageSize,
|
|
offset: (page - 1) * pageSize,
|
|
token
|
|
};
|
|
|
|
const response = await postgrestGet<{code: number; msg: string; data: Array<{
|
|
id: number;
|
|
pid: number;
|
|
name: string;
|
|
code?: string;
|
|
description?: string;
|
|
is_enabled: boolean;
|
|
created_at?: string;
|
|
}>}>('evaluation_point_groups', postgrestParams);
|
|
|
|
if (response.error) {
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
// 处理响应数据
|
|
let groups: RuleGroup[] = [];
|
|
if (response.data && 'code' in response.data && response.data.data) {
|
|
groups = response.data.data.map(group => ({
|
|
id: group.id.toString(),
|
|
pid: group.pid.toString(),
|
|
name: group.name,
|
|
code: group.code,
|
|
description: group.description,
|
|
is_enabled: group.is_enabled,
|
|
createdAt: group.created_at ? formatDate(group.created_at) : undefined
|
|
}));
|
|
} else if (Array.isArray(response.data)) {
|
|
groups = response.data.map(group => ({
|
|
id: group.id.toString(),
|
|
pid: group.pid.toString(),
|
|
name: group.name,
|
|
code: group.code,
|
|
description: group.description,
|
|
is_enabled: group.is_enabled,
|
|
createdAt: group.created_at ? formatDate(group.created_at) : undefined
|
|
}));
|
|
}
|
|
|
|
// 注意：由于当前 PostgREST 客户端不支持 count 参数，totalCount 返回当前页的记录数
|
|
// 后续可优化为单独查询获取准确的总数
|
|
return {
|
|
data: groups,
|
|
totalCount: groups.length
|
|
};
|
|
} catch (error) {
|
|
console.error('获取评查点分组列表失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取评查点分组列表失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取指定分组的子分组（包含评查点数量统计）
|
|
* @param parentId 父分组ID
|
|
* @param token JWT token (可选)
|
|
* @returns 子分组列表
|
|
*/
|
|
export async function getChildGroups(parentId: string, token?: string): Promise<{data: RuleGroup[]; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// 使用改进后的 getRuleGroups 函数获取子分组
|
|
const response = await getRuleGroups({
|
|
pid: parentId,
|
|
pageSize: 1000, // 设置较大的页面大小以获取所有子分组
|
|
token
|
|
});
|
|
|
|
if (response.error) {
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
const childGroups = response.data || [];
|
|
|
|
// 为每个子分组添加评查点数量统计
|
|
const groupsWithCount = await Promise.all(
|
|
childGroups.map(async (group) => {
|
|
// 获取该分组的评查点数量
|
|
const ruleCountParams: PostgrestParams = {
|
|
select: 'id',
|
|
filter: {
|
|
'evaluation_point_groups_id': `eq.${group.id}`
|
|
},
|
|
token
|
|
};
|
|
|
|
const ruleCountResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>(
|
|
'evaluation_points',
|
|
ruleCountParams
|
|
);
|
|
|
|
let ruleCount = 0;
|
|
if (ruleCountResponse.error) {
|
|
// 查询失败，使用默认值 0
|
|
ruleCount = 0;
|
|
} else if (ruleCountResponse.data) {
|
|
// 处理包装格式的响应
|
|
if ('code' in ruleCountResponse.data && 'data' in ruleCountResponse.data) {
|
|
const wrappedData = ruleCountResponse.data as {code: number; data: Array<{id: number}>};
|
|
ruleCount = Array.isArray(wrappedData.data) ? wrappedData.data.length : 0;
|
|
}
|
|
// 处理直接数组格式的响应
|
|
else if (Array.isArray(ruleCountResponse.data)) {
|
|
ruleCount = (ruleCountResponse.data as Array<{id: number}>).length;
|
|
}
|
|
}
|
|
|
|
return {
|
|
...group,
|
|
ruleCount
|
|
};
|
|
})
|
|
);
|
|
|
|
return { data: groupsWithCount };
|
|
} catch (error) {
|
|
console.error('获取子分组列表出错:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取子分组列表失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取所有评查点分组（包括一级和二级）
|
|
* @param token JWT token (可选)
|
|
* @returns 完整的评查点分组列表
|
|
*/
|
|
export async function getAllRuleGroups(token?: string): Promise<{data: RuleGroup[]; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// 1. 获取所有分组
|
|
const allGroupsParams: PostgrestParams = {
|
|
select: `
|
|
id,
|
|
pid,
|
|
name,
|
|
is_enabled
|
|
`,
|
|
token
|
|
};
|
|
|
|
const allGroupsResponse = await postgrestGet<{code: number; msg: string; data: Array<{
|
|
id: number;
|
|
pid: number;
|
|
name: string;
|
|
is_enabled: boolean;
|
|
}>}>('evaluation_point_groups', allGroupsParams);
|
|
|
|
if (allGroupsResponse.error) {
|
|
return { error: allGroupsResponse.error, status: allGroupsResponse.status };
|
|
}
|
|
|
|
// 2. 处理响应数据
|
|
let allGroups: RuleGroup[] = [];
|
|
if (allGroupsResponse.data && 'code' in allGroupsResponse.data && allGroupsResponse.data.data) {
|
|
allGroups = allGroupsResponse.data.data.map(group => ({
|
|
id: group.id.toString(),
|
|
pid: group.pid.toString(),
|
|
name: group.name,
|
|
is_enabled: group.is_enabled,
|
|
children: []
|
|
}));
|
|
} else if (Array.isArray(allGroupsResponse.data)) {
|
|
allGroups = allGroupsResponse.data.map(group => ({
|
|
id: group.id.toString(),
|
|
pid: group.pid.toString(),
|
|
name: group.name,
|
|
is_enabled: group.is_enabled,
|
|
children: []
|
|
}));
|
|
}
|
|
|
|
// 3. 构建树形结构（pid为NULL表示顶级分组）
|
|
const parentGroups = allGroups.filter(group => !group.pid || group.pid === '0' || group.pid === null);
|
|
|
|
// 4. 为每个父分组添加子分组
|
|
for (const parent of parentGroups) {
|
|
parent.children = allGroups.filter(group => group.pid === parent.id);
|
|
|
|
// 5. 获取每个子分组的评查点数量
|
|
for (const child of parent.children) {
|
|
const ruleCountParams: PostgrestParams = {
|
|
select: 'id',
|
|
filter: {
|
|
'evaluation_point_groups_id': `eq.${child.id}`
|
|
},
|
|
token
|
|
};
|
|
|
|
const ruleCountResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>('evaluation_points', ruleCountParams);
|
|
|
|
child.ruleCount = ruleCountResponse.data && 'code' in ruleCountResponse.data
|
|
? (ruleCountResponse.data.data && Array.isArray(ruleCountResponse.data.data) ? ruleCountResponse.data.data.length : 0)
|
|
: (Array.isArray(ruleCountResponse.data) ? (ruleCountResponse.data as unknown[]).length : 0)
|
|
}
|
|
}
|
|
|
|
return { data: parentGroups };
|
|
} catch (error) {
|
|
console.error('获取所有评查点分组出错:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取所有评查点分组失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取单个评查点分组详情（包含评查点数量统计）
|
|
* @param id 分组ID
|
|
* @param token JWT token (可选)
|
|
* @returns 分组详情
|
|
*/
|
|
export async function getRuleGroup(id: string, token?: string): Promise<{data: RuleGroup; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
if (!id) {
|
|
return { error: '分组ID不能为空', status: 400 };
|
|
}
|
|
|
|
const params: PostgrestParams = {
|
|
select: `
|
|
id,
|
|
pid,
|
|
name,
|
|
code,
|
|
description,
|
|
is_enabled,
|
|
created_at
|
|
`,
|
|
filter: {
|
|
'id': `eq.${id}`
|
|
},
|
|
token
|
|
};
|
|
|
|
const response = await postgrestGet<{code: number; msg: string; data: Array<{
|
|
id: number;
|
|
pid: number;
|
|
name: string;
|
|
code?: string;
|
|
description?: string;
|
|
is_enabled: boolean;
|
|
created_at?: string;
|
|
}>}>('evaluation_point_groups', params);
|
|
|
|
if (response.error) {
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
let group: RuleGroup | null = null;
|
|
|
|
if (response.data && 'code' in response.data && response.data.data && response.data.data.length > 0) {
|
|
const apiGroup = response.data.data[0];
|
|
group = {
|
|
id: apiGroup.id.toString(),
|
|
pid: apiGroup.pid.toString(),
|
|
name: apiGroup.name,
|
|
code: apiGroup.code,
|
|
description: apiGroup.description,
|
|
is_enabled: apiGroup.is_enabled,
|
|
createdAt: apiGroup.created_at ? formatDate(apiGroup.created_at) : undefined
|
|
};
|
|
} else if (Array.isArray(response.data) && response.data.length > 0) {
|
|
const apiGroup = response.data[0];
|
|
group = {
|
|
id: apiGroup.id.toString(),
|
|
pid: apiGroup.pid.toString(),
|
|
name: apiGroup.name,
|
|
code: apiGroup.code,
|
|
description: apiGroup.description,
|
|
is_enabled: apiGroup.is_enabled,
|
|
createdAt: apiGroup.created_at ? formatDate(apiGroup.created_at) : undefined
|
|
};
|
|
}
|
|
|
|
if (!group) {
|
|
return { error: '未找到指定分组', status: 404 };
|
|
}
|
|
|
|
// 获取该分组下的评查点数量（一级分组和二级分组都统计）
|
|
const ruleCountParams: PostgrestParams = {
|
|
select: 'id',
|
|
filter: {
|
|
'evaluation_point_groups_id': `eq.${group.id}`
|
|
},
|
|
token
|
|
};
|
|
|
|
const ruleCountResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>(
|
|
'evaluation_points',
|
|
ruleCountParams
|
|
);
|
|
|
|
// 计算评查点数量
|
|
let ruleCount = 0;
|
|
if (ruleCountResponse.error) {
|
|
// 查询失败，使用默认值 0
|
|
ruleCount = 0;
|
|
} else if (ruleCountResponse.data) {
|
|
// 处理包装格式的响应
|
|
if ('code' in ruleCountResponse.data && 'data' in ruleCountResponse.data) {
|
|
const wrappedData = ruleCountResponse.data as {code: number; data: Array<{id: number}>};
|
|
ruleCount = Array.isArray(wrappedData.data) ? wrappedData.data.length : 0;
|
|
}
|
|
// 处理直接数组格式的响应
|
|
else if (Array.isArray(ruleCountResponse.data)) {
|
|
ruleCount = (ruleCountResponse.data as Array<{id: number}>).length;
|
|
}
|
|
}
|
|
|
|
group.ruleCount = ruleCount;
|
|
|
|
return { data: group };
|
|
} catch (error) {
|
|
console.error('获取评查点分组详情失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取评查点分组详情失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 创建评查点分组（增强版 - 包含完整验证）
|
|
* @param groupData 分组数据
|
|
* @param token JWT token (可选)
|
|
* @returns 创建的分组
|
|
*/
|
|
export async function createRuleGroup(groupData: RuleGroupCreateUpdateDto, token?: string): Promise<{data: RuleGroup; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// ========== 1. 基本字段验证 ==========
|
|
|
|
// 验证必填字段
|
|
if (!groupData.name || !groupData.code) {
|
|
return { error: '分组名称和编码不能为空', status: 400 };
|
|
}
|
|
|
|
// 验证名称长度
|
|
const trimmedName = groupData.name.trim();
|
|
if (trimmedName.length === 0) {
|
|
return { error: '分组名称不能为空', status: 400 };
|
|
}
|
|
if (trimmedName.length > 100) {
|
|
return { error: '分组名称不能超过100个字符', status: 400 };
|
|
}
|
|
|
|
// 验证编码格式（只允许字母、数字、连字符、下划线）
|
|
const trimmedCode = groupData.code.trim();
|
|
if (trimmedCode.length === 0) {
|
|
return { error: '分组编码不能为空', status: 400 };
|
|
}
|
|
if (!/^[a-zA-Z0-9-_]+$/.test(trimmedCode)) {
|
|
return { error: '分组编码只能包含字母、数字、连字符和下划线', status: 400 };
|
|
}
|
|
if (trimmedCode.length > 50) {
|
|
return { error: '分组编码不能超过50个字符', status: 400 };
|
|
}
|
|
|
|
// ========== 2. 编码唯一性验证 ==========
|
|
|
|
const existingGroupsResponse = await getRuleGroups({
|
|
code: trimmedCode,
|
|
pageSize: 1,
|
|
token
|
|
});
|
|
|
|
if (existingGroupsResponse.error) {
|
|
return {
|
|
error: `编码唯一性检查失败: ${existingGroupsResponse.error}`,
|
|
status: existingGroupsResponse.status || 500
|
|
};
|
|
}
|
|
|
|
if (existingGroupsResponse.data && existingGroupsResponse.data.length > 0) {
|
|
return { error: '分组编码已存在，请使用其他编码', status: 409 };
|
|
}
|
|
|
|
// ========== 3. 父级ID验证 ==========
|
|
|
|
let pidValue: number | null;
|
|
if (!groupData.pid || groupData.pid === '0') {
|
|
// 一级分组（顶级分组）
|
|
pidValue = null;
|
|
} else {
|
|
// 二级分组 - 验证父级ID
|
|
pidValue = Number(groupData.pid);
|
|
if (isNaN(pidValue)) {
|
|
return { error: '父分组ID必须是有效的数字', status: 400 };
|
|
}
|
|
|
|
// 验证父级分组是否存在
|
|
const parentGroupResponse = await getRuleGroup(groupData.pid, token);
|
|
if (parentGroupResponse.error || !parentGroupResponse.data) {
|
|
return { error: '父分组不存在或无法访问', status: 404 };
|
|
}
|
|
|
|
// 验证父级分组本身不是二级分组（不允许三级分组）
|
|
const parentGroup = parentGroupResponse.data;
|
|
if (parentGroup.pid && parentGroup.pid !== '0') {
|
|
return { error: '不允许创建三级分组，父级分组必须是一级分组', status: 400 };
|
|
}
|
|
}
|
|
|
|
// ========== 4. 构建并发送请求 ==========
|
|
|
|
const apiGroup: ApiRuleGroup = {
|
|
pid: pidValue,
|
|
name: trimmedName,
|
|
code: trimmedCode,
|
|
description: groupData.description?.trim() || '',
|
|
is_enabled: groupData.is_enabled !== undefined ? groupData.is_enabled : true
|
|
};
|
|
|
|
const response = await postgrestPost<ApiResponse<ApiRuleGroup> | ApiRuleGroup, ApiRuleGroup>(
|
|
'evaluation_point_groups',
|
|
apiGroup,
|
|
token
|
|
);
|
|
|
|
if (response.error) {
|
|
// 处理数据库约束错误
|
|
if (response.error.includes('evaluation_point_groups_code_key')) {
|
|
return { error: '分组编码已存在（数据库约束）', status: 409 };
|
|
}
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
// ========== 5. 处理响应数据 ==========
|
|
|
|
const apiResponse = extractApiData<ApiRuleGroup>(response.data);
|
|
|
|
if (!apiResponse || !apiResponse.id) {
|
|
return { error: '创建成功但未返回分组ID', status: 500 };
|
|
}
|
|
|
|
// 构建返回对象
|
|
const createdGroup: RuleGroup = {
|
|
id: apiResponse.id.toString(),
|
|
pid: apiResponse.pid !== null ? apiResponse.pid.toString() : '0',
|
|
name: apiResponse.name,
|
|
code: apiResponse.code || trimmedCode,
|
|
description: apiResponse.description,
|
|
is_enabled: apiResponse.is_enabled,
|
|
createdAt: apiResponse.created_at ? formatDate(apiResponse.created_at) : undefined
|
|
};
|
|
|
|
return { data: createdGroup };
|
|
} catch (error) {
|
|
console.error('创建评查点分组失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '创建评查点分组失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 更新评查点分组（增强版 - 包含完整验证，不允许修改 pid）
|
|
* @param id 分组ID
|
|
* @param data 更新的分组数据
|
|
* @param token JWT token (可选)
|
|
* @returns 更新后的分组
|
|
*/
|
|
export async function updateRuleGroup(id: string, data: RuleGroupCreateUpdateDto, token?: string): Promise<{data: RuleGroup; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// ========== 1. ID有效性验证 ==========
|
|
|
|
if (!id) {
|
|
return { error: '分组ID不能为空', status: 400 };
|
|
}
|
|
|
|
// 验证分组是否存在
|
|
const existingGroupResponse = await getRuleGroup(id, token);
|
|
if (existingGroupResponse.error || !existingGroupResponse.data) {
|
|
return { error: '分组不存在或无法访问', status: 404 };
|
|
}
|
|
|
|
const existingGroup = existingGroupResponse.data;
|
|
|
|
// ========== 2. 基本字段验证 ==========
|
|
|
|
// 验证必填字段
|
|
if (!data.name || !data.code) {
|
|
return { error: '分组名称和编码不能为空', status: 400 };
|
|
}
|
|
|
|
// 验证名称长度
|
|
const trimmedName = data.name.trim();
|
|
if (trimmedName.length === 0) {
|
|
return { error: '分组名称不能为空', status: 400 };
|
|
}
|
|
if (trimmedName.length > 100) {
|
|
return { error: '分组名称不能超过100个字符', status: 400 };
|
|
}
|
|
|
|
// 验证编码格式（只允许字母、数字、连字符、下划线）
|
|
const trimmedCode = data.code.trim();
|
|
if (trimmedCode.length === 0) {
|
|
return { error: '分组编码不能为空', status: 400 };
|
|
}
|
|
if (!/^[a-zA-Z0-9-_]+$/.test(trimmedCode)) {
|
|
return { error: '分组编码只能包含字母、数字、连字符和下划线', status: 400 };
|
|
}
|
|
if (trimmedCode.length > 50) {
|
|
return { error: '分组编码不能超过50个字符', status: 400 };
|
|
}
|
|
|
|
// ========== 3. 编码唯一性验证（排除自身） ==========
|
|
|
|
const duplicateCheckResponse = await getRuleGroups({
|
|
code: trimmedCode,
|
|
pageSize: 10,
|
|
token
|
|
});
|
|
|
|
if (duplicateCheckResponse.error) {
|
|
return {
|
|
error: `编码唯一性检查失败: ${duplicateCheckResponse.error}`,
|
|
status: duplicateCheckResponse.status || 500
|
|
};
|
|
}
|
|
|
|
// 检查是否有其他分组使用了相同的编码
|
|
if (duplicateCheckResponse.data && duplicateCheckResponse.data.length > 0) {
|
|
const isDuplicate = duplicateCheckResponse.data.some(group => group.id !== id);
|
|
if (isDuplicate) {
|
|
return { error: '分组编码已被其他分组使用，请使用其他编码', status: 409 };
|
|
}
|
|
}
|
|
|
|
// ========== 4. 不允许修改 pid（防止分组层级混乱） ==========
|
|
|
|
if (data.pid !== undefined) {
|
|
const existingPid = existingGroup.pid === '0' || !existingGroup.pid ? null : existingGroup.pid;
|
|
const newPid = !data.pid || data.pid === '0' ? null : data.pid;
|
|
|
|
if (existingPid !== newPid) {
|
|
return {
|
|
error: '不允许修改分组的父级ID，这会导致分组层级混乱。如需调整层级，请删除后重新创建。',
|
|
status: 400
|
|
};
|
|
}
|
|
}
|
|
|
|
// ========== 5. 构建并发送请求 ==========
|
|
|
|
const apiGroup: Partial<ApiRuleGroup> = {
|
|
name: trimmedName,
|
|
code: trimmedCode,
|
|
description: data.description?.trim() || '',
|
|
is_enabled: data.is_enabled !== undefined ? data.is_enabled : true
|
|
};
|
|
|
|
// 注意：不包含 pid 字段，防止误修改
|
|
|
|
const response = await postgrestPut<ApiResponse<RuleGroup> | RuleGroup, Partial<ApiRuleGroup>>(
|
|
'evaluation_point_groups',
|
|
apiGroup,
|
|
{ id },
|
|
token
|
|
);
|
|
|
|
if (response.error) {
|
|
// 处理数据库约束错误
|
|
if (response.error.includes('evaluation_point_groups_code_key')) {
|
|
return { error: '分组编码已存在（数据库约束）', status: 409 };
|
|
}
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
// ========== 6. 处理响应数据 ==========
|
|
|
|
const extractedData = extractApiData<RuleGroup>(response.data);
|
|
|
|
if (!extractedData) {
|
|
return { error: '更新成功但未返回数据', status: 500 };
|
|
}
|
|
|
|
return { data: extractedData };
|
|
} catch (error) {
|
|
console.error('更新评查点分组失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '更新评查点分组失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除评查点分组（增强版 - 安全的阻止删除策略）
|
|
*
|
|
* 删除策略：
|
|
* - 如果分组下有子分组，拒绝删除，提示用户先删除子分组
|
|
* - 如果分组下有评查点，拒绝删除，提示用户先删除或移动评查点
|
|
* - 只有空分组才能被删除
|
|
*
|
|
* @param id 分组ID
|
|
* @param token JWT token (可选)
|
|
* @returns 删除结果
|
|
*/
|
|
export async function deleteRuleGroup(id: string, token?: string): Promise<{success: boolean; error?: string; details?: { hasChildren: boolean; hasPoints: boolean; childCount?: number; pointCount?: number }}> {
|
|
try {
|
|
// ========== 1. ID验证 ==========
|
|
|
|
if (!id) {
|
|
return { success: false, error: '分组ID不能为空' };
|
|
}
|
|
|
|
// 验证分组是否存在
|
|
const groupResponse = await getRuleGroup(id, token);
|
|
if (groupResponse.error || !groupResponse.data) {
|
|
return { success: false, error: '分组不存在或无法访问' };
|
|
}
|
|
|
|
const group = groupResponse.data;
|
|
|
|
// ========== 2. 检查是否有子分组（一级分组专用） ==========
|
|
|
|
let hasChildren = false;
|
|
let childCount = 0;
|
|
|
|
// 如果是一级分组，检查是否有子分组
|
|
if (!group.pid || group.pid === '0') {
|
|
const childGroupsResponse = await getChildGroups(id, token);
|
|
|
|
if (childGroupsResponse.error) {
|
|
return {
|
|
success: false,
|
|
error: `检查子分组时出错: ${childGroupsResponse.error}`
|
|
};
|
|
}
|
|
|
|
const childGroups = childGroupsResponse.data || [];
|
|
childCount = childGroups.length;
|
|
hasChildren = childCount > 0;
|
|
|
|
if (hasChildren) {
|
|
return {
|
|
success: false,
|
|
error: `该分组下存在 ${childCount} 个子分组，请先删除所有子分组后再删除此分组。`,
|
|
details: {
|
|
hasChildren: true,
|
|
hasPoints: false,
|
|
childCount
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
// ========== 3. 检查是否有关联的评查点 ==========
|
|
|
|
const pointsParams: PostgrestParams = {
|
|
select: 'id',
|
|
filter: {
|
|
'evaluation_point_groups_id': `eq.${id}`
|
|
},
|
|
limit: 1, // 只需要知道是否存在，不需要获取所有数据
|
|
token
|
|
};
|
|
|
|
const pointsResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>(
|
|
'evaluation_points',
|
|
pointsParams
|
|
);
|
|
|
|
let hasPoints = false;
|
|
let pointCount = group.ruleCount || 0;
|
|
|
|
if (pointsResponse.error) {
|
|
return {
|
|
success: false,
|
|
error: `检查关联评查点时出错: ${pointsResponse.error}`
|
|
};
|
|
}
|
|
|
|
if (pointsResponse.data) {
|
|
if ('code' in pointsResponse.data && pointsResponse.data.data) {
|
|
hasPoints = Array.isArray(pointsResponse.data.data) && pointsResponse.data.data.length > 0;
|
|
} else if (Array.isArray(pointsResponse.data)) {
|
|
hasPoints = pointsResponse.data.length > 0;
|
|
}
|
|
}
|
|
|
|
if (hasPoints) {
|
|
return {
|
|
success: false,
|
|
error: `该分组下存在 ${pointCount} 个评查点，请先删除或移动所有评查点后再删除此分组。`,
|
|
details: {
|
|
hasChildren: false,
|
|
hasPoints: true,
|
|
pointCount
|
|
}
|
|
};
|
|
}
|
|
|
|
// ========== 4. 执行删除操作 ==========
|
|
|
|
const response = await postgrestDelete<ApiResponse<{id: number}>>('evaluation_point_groups', {
|
|
filter: {
|
|
'id': `eq.${id}`
|
|
},
|
|
token
|
|
});
|
|
|
|
if (response.error) {
|
|
return { success: false, error: `删除失败: ${response.error}` };
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
details: {
|
|
hasChildren: false,
|
|
hasPoints: false
|
|
}
|
|
};
|
|
} catch (error) {
|
|
console.error('删除评查点分组失败:', error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '删除评查点分组失败'
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除子分组及其相关数据（级联删除）
|
|
*
|
|
* @deprecated 当前采用阻止删除策略，此函数暂不使用
|
|
* @param id 子分组ID
|
|
* @param token JWT token (可选)
|
|
* @returns 删除结果
|
|
*/
|
|
async function deleteChildGroup(id: string, token?: string): Promise<{success: boolean; error?: string}> {
|
|
try {
|
|
// 1. 删除子分组下的所有评查点
|
|
const deletePointsResult = await deleteEvaluationPointsByGroupId(id, token);
|
|
if (!deletePointsResult.success) {
|
|
return deletePointsResult;
|
|
}
|
|
|
|
// 2. 删除子分组本身
|
|
const response = await postgrestDelete<ApiResponse<{id: number}>>('evaluation_point_groups', {
|
|
filter: {
|
|
'id': `eq.${id}`
|
|
},
|
|
token
|
|
});
|
|
|
|
if (response.error) {
|
|
return { success: false, error: response.error };
|
|
}
|
|
|
|
return { success: true };
|
|
} catch (error) {
|
|
console.error('删除子分组失败:', error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '删除子分组失败'
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除指定分组下的所有评查点（级联删除）
|
|
*
|
|
* @deprecated 当前采用阻止删除策略，此函数暂不使用
|
|
* @param groupId 分组ID
|
|
* @param token JWT token (可选)
|
|
* @returns 删除结果
|
|
*/
|
|
async function deleteEvaluationPointsByGroupId(groupId: string, token?: string): Promise<{success: boolean; error?: string}> {
|
|
try {
|
|
const response = await postgrestDelete<ApiResponse<{id: number}>>('evaluation_points', {
|
|
filter: {
|
|
'evaluation_point_groups_id': `eq.${groupId}`
|
|
},
|
|
token
|
|
});
|
|
|
|
if (response.error) {
|
|
return { success: false, error: response.error };
|
|
}
|
|
|
|
return { success: true };
|
|
} catch (error) {
|
|
console.error('删除评查点失败:', error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '删除评查点失败'
|
|
};
|
|
}
|
|
}
|