feat: 1. 本地化思源黑体的字体包并优先使用。

2. 添加权限映射表和全局查看权限的hook,便于路由控制不同权限按钮显示/隐藏。
3. 删除评查点分组的部分旧api方法。
4. 对接评查点分组接口,文档类型接口, 提示词管理接口, 入口模块管理的接口。
5. 优化角色权限管理的接口,完善不用地区的访问权限认证。
6. 优化主页交叉评查和设置的入口样式和布局。
7. 优化评查点分组,评查规则的功能权限校验。
This commit is contained in:
2025-11-29 10:37:35 +08:00
parent 61facf5d71
commit 30e100ef3e
29 changed files with 2527 additions and 2126 deletions
+105 -3
View File
@@ -14,6 +14,7 @@ export interface BackendRouteInfo {
is_hidden: boolean;
is_cache: boolean;
meta: string;
permissions?: string[]; // ✅ 新增:该路由下用户拥有的权限列表
children?: BackendRouteInfo[];
}
@@ -60,6 +61,7 @@ export interface MenuItem {
order: number;
hideBreadcrumb?: boolean;
requiredRole?: string;
permissions?: string[]; // ✅ 新增:该菜单项的权限列表
children?: MenuItem[];
}
@@ -484,6 +486,88 @@ const FALLBACK_MENU_DATA: Record<string, MenuItem[]> = {
]
};
/**
* 权限映射表类型
* key: 路由路径 (如 '/prompts', '/documents')
* value: 该路由下的权限列表
*/
export type PermissionMap = Map<string, string[]>;
/**
* 从路由树中提取权限映射表
* @param routes 路由树
* @param aggregateChildren 是否聚合子路由权限到父路由(默认true)
* @returns 权限映射表 (路径 -> 权限列表)
*/
export function buildPermissionMap(routes: BackendRouteInfo[], aggregateChildren: boolean = true): PermissionMap {
const permissionMap = new Map<string, string[]>();
/**
* 递归收集路由及其所有子路由的权限
*/
function collectAllPermissions(route: BackendRouteInfo): string[] {
const allPermissions = new Set<string>();
// 添加当前路由的权限
if (route.permissions && route.permissions.length > 0) {
route.permissions.forEach(p => allPermissions.add(p));
}
// 递归收集子路由的权限
if (aggregateChildren && route.children && route.children.length > 0) {
route.children.forEach(child => {
const childPermissions = collectAllPermissions(child);
childPermissions.forEach(p => allPermissions.add(p));
});
}
return Array.from(allPermissions);
}
function traverse(routeList: BackendRouteInfo[]) {
for (const route of routeList) {
// 存储当前路由的权限(聚合或不聚合)
const permissions = aggregateChildren
? collectAllPermissions(route)
: (route.permissions || []);
if (permissions.length > 0) {
permissionMap.set(route.route_path, permissions);
}
// 递归处理子路由
if (route.children && route.children.length > 0) {
traverse(route.children);
}
}
}
traverse(routes);
return permissionMap;
}
/**
* 将权限映射表转换为普通对象(用于JSON序列化)
*/
export function permissionMapToObject(map: PermissionMap): Record<string, string[]> {
const obj: Record<string, string[]> = {};
map.forEach((value, key) => {
obj[key] = value;
});
return obj;
}
/**
* 从对象恢复权限映射表
*/
export function objectToPermissionMap(obj: Record<string, string[]>): PermissionMap {
const map = new Map<string, string[]>();
Object.entries(obj).forEach(([key, value]) => {
map.set(key, value);
});
return map;
}
/**
* 根据角色获取用户可访问的路由(调用后端统一接口)
* @param roleKey 角色标识 (如: 'admin', 'common', 'deptLeader', 'groupLeader') - 暂时不使用,后端通过JWT自动识别
@@ -491,7 +575,17 @@ const FALLBACK_MENU_DATA: Record<string, MenuItem[]> = {
* @param includeHidden 是否包含隐藏路由(默认 false)。true: 用于权限校验,false: 用于菜单渲染
* @returns 用户可访问的路由列表
*/
export async function getUserRoutesByRole(roleKey: string, jwt?: string, includeHidden: boolean = false): Promise<{ success: boolean; data?: MenuItem[]; error?: string; shouldRedirectToHome?: boolean }> {
export async function getUserRoutesByRole(
roleKey: string,
jwt?: string,
includeHidden: boolean = false
): Promise<{
success: boolean;
data?: MenuItem[];
permissionMap?: Record<string, string[]>; // ✅ 新增:返回权限映射表
error?: string;
shouldRedirectToHome?: boolean
}> {
try {
// console.log(`🔍 [User Routes] 获取用户路由,角色: ${roleKey}, JWT前20字符: ${jwt?.substring(0, 20)}`);
@@ -598,6 +692,9 @@ export async function getUserRoutesByRole(roleKey: string, jwt?: string, include
// console.log('🔍 [User Routes] 后端返回的原始路由数据:', JSON.stringify(routes, null, 2));
// console.log('🔍 [User Routes] 检查第一个路由是否有children:', routes[0]?.children);
// ✅ 构建权限映射表
const permissionMapObj = permissionMapToObject(buildPermissionMap(routes));
// 将后端路由格式转换为前端 MenuItem 格式
const menuItems = convertBackendRoutesToMenuItems(routes, includeHidden);
@@ -605,7 +702,11 @@ export async function getUserRoutesByRole(roleKey: string, jwt?: string, include
// console.log('🔍 [User Routes] 转换后的菜单数据:', JSON.stringify(menuItems, null, 2));
// console.log('🔍 [User Routes] 检查第一个菜单项是否有children:', menuItems[0]?.children);
return { success: true, data: menuItems };
return {
success: true,
data: menuItems,
permissionMap: permissionMapObj // ✅ 返回权限映射表
};
} catch (error) {
console.error("❌ [User Routes] 获取用户路由时发生错误:", error);
@@ -801,7 +902,8 @@ function convertBackendRoutesToMenuItems(backendRoutes: BackendRouteInfo[], incl
path: route.route_path,
icon: convertIcon(route.icon),
order: route.sort_order,
hideBreadcrumb: route.is_hidden
hideBreadcrumb: route.is_hidden,
permissions: route.permissions // ✅ 传递权限列表
};
// 递归处理子路由,传递 includeHidden 参数
File diff suppressed because it is too large Load Diff
+19 -678
View File
@@ -1,4 +1,4 @@
import { postgrestGet, postgrestPost, postgrestPut, postgrestDelete, type PostgrestParams } from '../postgrest-client';
import { postgrestGet, postgrestPut, type PostgrestParams } from '../postgrest-client';
import { apiRequest } from '../axios-client';
import { formatDate } from '../../utils';
@@ -238,680 +238,9 @@ export async function getChildGroups(parentId: string, token?: string): Promise<
}
}
/**
* 获取所有评查点分组(包括一级和二级)
* @deprecated 使用 getAllEvaluationPointGroups 代替(FastAPI v3
* @param token JWT token (可选)
* @returns 完整的评查点分组列表
*/
export async function getAllRuleGroups_legacy(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
};
}
}
/**
* 获取单个评查点分组详情(包含评查点数量统计)
* @deprecated 使用 getEvaluationPointGroup 代替(FastAPI v3
* @param id 分组ID
* @param token JWT token (可选)
* @returns 分组详情
*/
export async function getRuleGroup_legacy(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
};
}
}
/**
* 创建评查点分组(增强版 - 包含完整验证)
* @deprecated 使用 createEvaluationPointGroup 代替(FastAPI v3
* @param groupData 分组数据
* @param token JWT token (可选)
* @returns 创建的分组
*/
export async function createRuleGroup_legacy(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)
* @deprecated 使用 updateEvaluationPointGroup 代替(FastAPI v3
* @param id 分组ID
* @param data 更新的分组数据
* @param token JWT token (可选)
* @returns 更新后的分组
*/
export async function updateRuleGroup_legacy(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
};
}
}
/**
* 删除评查点分组(增强版 - 安全的阻止删除策略)
* @deprecated 使用 deleteEvaluationPointGroup 代替(FastAPI v3
*
* 删除策略:
* - 如果分组下有子分组,拒绝删除,提示用户先删除子分组
* - 如果分组下有评查点,拒绝删除,提示用户先删除或移动评查点
* - 只有空分组才能被删除
*
* @param id 分组ID
* @param token JWT token (可选)
* @returns 删除结果
*/
export async function deleteRuleGroup_legacy(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 : '删除评查点失败'
};
}
}
// ==================== 批量操作接口 ====================
@@ -1184,14 +513,12 @@ export async function getEvaluationPointGroups(
if (code) queryParams.append('code', code);
if (is_enabled !== undefined) queryParams.append('is_enabled', String(is_enabled));
// 🔑 添加 pid 参数过滤
// pid=null 或 pid='0' 表示只查询一级分组,后端需要识别字符串 "null"
// pid=null 或 pid='0' 表示只查询一级分组pid=0
// 如果 pid 未定义,则不传该参数(默认查询所有分组)
if (pid !== undefined) {
if (pid === null || pid === '0') {
// 方案1:传递字符串 "null",后端需要识别并转换为 None/NULL
queryParams.append('pid', 'null');
// 方案2:不传参数,后端默认查询一级分组(需要后端支持)
// 不添加 pid 参数
// FastAPI v3 后端期望 pid=0(数字),不接受字符串 "null"
queryParams.append('pid', '0');
} else {
queryParams.append('pid', String(pid));
}
@@ -1262,11 +589,25 @@ export async function getAllEvaluationPointGroups(
return { error: response.error, status: response.status };
}
if (response.data) {
// ✅ 后端直接返回数组(不包裹在 { data: [...] } 中)
if (response.data && Array.isArray(response.data)) {
const ruleGroups = response.data.map(convertApiGroupToRuleGroup);
return { data: ruleGroups };
}
// ✅ 后端返回 { data: [...] } 格式(向后兼容)
if (response.data && response.data.data && Array.isArray(response.data.data)) {
const ruleGroups = response.data.data.map(convertApiGroupToRuleGroup);
return { data: ruleGroups };
}
// 返回错误(数据格式不正确)
// console.error('❌ 获取分组数据格式错误:', {
// responseData: response.data,
// isArray: Array.isArray(response.data),
// hasDataField: !!(response.data && 'data' in response.data)
// });
return { error: '获取分组树形结构失败:返回数据格式不正确', status: 500 };
} catch (error) {
console.error('❌ 获取分组树形结构出错:', error);
+352 -232
View File
@@ -1,21 +1,22 @@
import { postgrestGet, postgrestPut, postgrestPost, postgrestDelete, type PostgrestParams } from '../postgrest-client';
import { apiRequest } from '../axios-client';
import { formatDate } from '../../utils';
// 提示词模板接口
// 提示词模板接口(数据库格式)
export interface PromptTemplate {
id: number;
template_name: string;
template_code: string | null;
template_type: string;
description: string | null;
template_content: string;
variables: Record<string, string>; // 变量定义
template_abbreviation: string | null;
variables: Record<string, string> | null;
status: number;
version: string;
created_by: number;
created_by: number | null;
created_at: string;
updated_at: string;
template_code?: string; // 模板代码(VLM_Extraction 类型时使用)
template_abbreviation?: string; // 模板简称(VLM_Extraction 类型时使用)
is_active?: boolean;
}
// 提示词模板前端接口
@@ -32,8 +33,8 @@ export interface PromptTemplateUI {
created_by_username?: string; // 创建者用户名
created_at: string;
updated_at: string;
template_code?: string; // 模板代码VLM_Extraction 类型时使用)
template_abbreviation?: string; // 模板简称VLM_Extraction 类型时使用)
template_code?: string; // 模板代码
template_abbreviation?: string; // 模板简称
}
// 搜索参数接口
@@ -45,25 +46,65 @@ export interface PromptSearchParams {
pageSize?: number;
}
// API 响应格式
interface ApiResponse<T> {
code: number;
message: string;
data: T;
}
// 列表响应格式
interface ListResponse {
total: number;
page: number;
page_size: number;
items: PromptTemplate[];
}
// 类型选项
interface TypeOption {
value: string;
label: string;
count: number;
}
// 默认的模板类型列表(当没有指定类型时使用)
const DEFAULT_TEMPLATE_TYPES = [
'LLM_Extraction',
'VLM_Extraction',
'Evaluation',
'Summary',
'Common'
];
/**
* 从不同格式的 API 响应中提取数据
* @param responseData API 响应数据
* @returns 提取后的数据或 null
* 构建请求选项(包括 JWT token)
* @param method HTTP 方法
* @param data 请求数据(可选)
* @param jwt JWT token(可选)
* @returns 请求选项
*/
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;
function buildRequestOptions(method: 'GET' | 'POST' | 'PUT' | 'DELETE', data?: unknown, jwt?: string) {
const options: {
method: string;
data?: unknown;
headers?: Record<string, string>;
} = {
method,
};
if (data !== undefined) {
options.data = data;
}
// 格式2: 直接是数据对象
return responseData as T;
// 如果提供了 JWT token(服务端调用时),添加到 headers
if (jwt) {
options.headers = {
'Authorization': `Bearer ${jwt}`,
};
}
return options;
}
/**
@@ -96,32 +137,31 @@ function mapStatusToAPI(status: string): number {
/**
* 将数据库模板转换为UI模板
* @param template 数据库模板(可能包含关联的用户信息)
* @param template 数据库模板
* @returns UI模板
*/
export function convertToUITemplate(template: PromptTemplate & { sso_users?: { username: string } }): PromptTemplateUI {
export function convertToUITemplate(template: PromptTemplate): PromptTemplateUI {
return {
id: template.id ? template.id.toString() : '',
template_name: template.template_name,
template_type: template.template_type as "LLM_Extraction" | "VLM_Extraction" | "Evaluation" | "Summary" | "Common",
description: template.description || '',
template_content: template.template_content,
variables: template.variables || {}, // 如果variables为null,则使用空对象
variables: template.variables || {},
status: mapStatusToUI(template.status),
version: template.version,
created_by: template.created_by,
created_by_username: template.sso_users?.username, // 从关联的用户信息中提取用户名
created_by: template.created_by || 0,
created_at: formatDate(template.created_at),
updated_at: formatDate(template.updated_at),
template_code: template.template_code,
template_abbreviation: template.template_abbreviation
template_code: template.template_code || undefined,
template_abbreviation: template.template_abbreviation || undefined
};
}
/**
* 获取提示词模板列表
* @param searchParams 搜索参数
* @param frontendJWT JWT token (可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 提示词模板列表和总数
*/
export async function getPromptTemplates(searchParams: PromptSearchParams = {}, frontendJWT?: string): Promise<{
@@ -130,89 +170,71 @@ export async function getPromptTemplates(searchParams: PromptSearchParams = {},
status?: number;
}> {
try {
// console.log('获取提示词模板列表,参数:', searchParams);
const TYPE = 'Common,LLM_Extraction,VLM_Extraction,Evaluation,Summary';
const page = searchParams.page || 1;
const pageSize = searchParams.pageSize || 10;
// 构建查询参数,包含对 sso_users 表的左连接
const params: PostgrestParams = {
select: `id,template_name,template_type,description,template_content,variables,status,version,created_by,created_at,updated_at,template_code,template_abbreviation,sso_users!created_by(username)`,
order: 'updated_at.desc',
headers: {
'Prefer': 'count=exact'
},
limit: pageSize,
offset: (page - 1) * pageSize,
filter: {} as Record<string, string>,
token: frontendJWT
// 构建查询参数
const params: Record<string, string | number | boolean | undefined> = {
page,
page_size: pageSize,
};
// 添加筛选条件
const filter: Record<string, string> = {};
filter['status'] = `gte.0`;
if (searchParams.name) {
filter['template_name'] = `ilike.%${searchParams.name}%`;
params.search = searchParams.name;
}
// 模板类型:如果指定了类型则使用指定的,否则使用默认的 5 个类型
if (searchParams.type) {
filter['template_type'] = `eq.${searchParams.type}`;
}else{
filter['template_type'] = `in.(${TYPE})`;
params.template_type = searchParams.type;
} else {
// 没有指定类型时,默认只查询这 5 个类型
params.template_type = DEFAULT_TEMPLATE_TYPES.join(',');
}
if (searchParams.status) {
let statusValue: number;
switch (searchParams.status) {
case 'active': statusValue = 1; break;
case 'inactive': statusValue = 0; break;
case 'system': statusValue = 2; break;
default: statusValue = -1;
}
if (statusValue >= 0) {
filter['status'] = `eq.${statusValue}`;
}
params.status = mapStatusToAPI(searchParams.status);
}
params.filter = filter;
// 发送API请求
// console.log('API请求参数:', params);
const response = await postgrestGet<PromptTemplate[]>('prompt_templates', params);
const response = await apiRequest<ApiResponse<ListResponse>>(
'/api/v3/prompt-templates',
buildRequestOptions('GET', undefined, frontendJWT),
params
);
if (response.error) {
console.error('API返回错误:', response.error);
return { error: response.error, status: response.status };
}
// 提取API返回的数据
const extractedData = extractApiData<PromptTemplate[]>(response.data);
if (!extractedData) {
console.error('提取数据失败,原始响应:', response.data);
// 检查响应数据
if (!response.data) {
console.error('响应数据为空');
return { error: '获取提示词模板数据失败', status: 500 };
}
// console.log(`成功获取${extractedData.length}条提示词模板数据`);
// 从响应头中获取总数
let totalCount = 0;
const responseWithHeaders = response as { data: PromptTemplate[]; headers: Record<string, string> };
if(responseWithHeaders.headers){
const rangeHeader = responseWithHeaders.headers['content-range'];
if(rangeHeader){
const total = rangeHeader.split('/')[1];
if(total !== '*'){
totalCount = parseInt(total, 10);
}
}
// 解析响应数据
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
console.error('API返回非成功状态码:', apiResponse.code, apiResponse.message);
return { error: apiResponse.message || '获取提示词模板失败', status: response.status };
}
const listData = apiResponse.data;
if (!listData || !listData.items) {
console.error('列表数据格式错误:', listData);
return { error: '获取提示词模板数据失败', status: 500 };
}
// 返回转换后的数据
return {
data: {
templates: extractedData.map(convertToUITemplate),
total: totalCount
templates: listData.items.map(convertToUITemplate),
total: listData.total || 0
}
};
} catch (error) {
@@ -227,7 +249,7 @@ export async function getPromptTemplates(searchParams: PromptSearchParams = {},
/**
* 获取提示词模板详情
* @param id 模板ID
* @param frontendJWT JWT token (可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 提示词模板详情
*/
export async function getPromptTemplate(id: string, frontendJWT?: string): Promise<{
@@ -239,28 +261,32 @@ export async function getPromptTemplate(id: string, frontendJWT?: string): Promi
if (!id) {
return { error: '模板ID不能为空', status: 400 };
}
const params: PostgrestParams = {
select: `id,template_name,template_type,description,template_content,variables,status,version,created_by,created_at,updated_at,template_code,template_abbreviation,sso_users!created_by(username)`,
filter: {
'id': `eq.${id}`
},
token: frontendJWT
};
const response = await postgrestGet<PromptTemplate[]>('prompt_templates', params);
const response = await apiRequest<ApiResponse<PromptTemplate>>(
`/api/v3/prompt-templates/${id}`,
buildRequestOptions('GET', undefined, frontendJWT)
);
if (response.error) {
return { error: response.error, status: response.status };
}
const extractedData = extractApiData<PromptTemplate[]>(response.data);
if (!extractedData || extractedData.length === 0) {
if (!response.data) {
return { error: '获取提示词模板详情失败', status: 500 };
}
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '获取提示词模板详情失败', status: response.status };
}
if (!apiResponse.data) {
return { error: '未找到指定模板', status: 404 };
}
return { data: convertToUITemplate(extractedData[0]) };
return { data: convertToUITemplate(apiResponse.data) };
} catch (error) {
console.error('获取提示词模板详情失败:', error);
return {
@@ -274,7 +300,7 @@ export async function getPromptTemplate(id: string, frontendJWT?: string): Promi
* 创建提示词模板
* @param template 提示词模板数据
* @param userId 当前用户ID
* @param frontendJWT JWT token (可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 创建的提示词模板
*/
export async function createPromptTemplate(template: Partial<PromptTemplateUI>, userId: number, frontendJWT?: string): Promise<{
@@ -288,59 +314,47 @@ export async function createPromptTemplate(template: Partial<PromptTemplateUI>,
return { error: '模板名称、类型和内容不能为空', status: 400 };
}
// 验证用户ID
if (!userId) {
return { error: '用户ID不能为空', status: 400 };
}
// 准备变量数据
let variablesData: Record<string, string> = {};
if (typeof template.variables === 'string') {
try {
variablesData = JSON.parse(template.variables);
} catch (e) {
console.error('解析变量JSON失败:', e);
}
} else if (template.variables) {
variablesData = template.variables;
}
// 准备API数据
const apiTemplate: Partial<PromptTemplate> = {
const apiTemplate = {
template_name: template.template_name,
template_code: template.template_code || `custom_${Date.now()}`, // 如果没有提供 code,自动生成
template_type: template.template_type,
description: template.description || null,
template_content: template.template_content,
variables: variablesData,
template_abbreviation: template.template_abbreviation || null,
variables: template.variables || {},
status: mapStatusToAPI(template.status || 'active'),
version: template.version || 'v1.0',
created_by: userId, // 使用当前登录用户ID
template_code: template.template_code,
template_abbreviation: template.template_abbreviation
};
if(apiTemplate){
// console.log('apiTemplate', apiTemplate);
// throw new Error('测试错误');
}
const response = await postgrestPost<PromptTemplate, Partial<PromptTemplate>>(
'prompt_templates',
apiTemplate,
frontendJWT
const response = await apiRequest<ApiResponse<PromptTemplate>>(
'/api/v3/prompt-templates',
buildRequestOptions('POST', apiTemplate, frontendJWT)
);
if (response.error) {
return { error: response.error, status: response.status };
}
const extractedData = extractApiData<PromptTemplate>(response.data);
if (!extractedData) {
if (!response.data) {
return { error: '创建提示词模板失败', status: 500 };
}
return { data: convertToUITemplate(extractedData) };
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '创建提示词模板失败', status: response.status };
}
if (!apiResponse.data) {
return { error: '创建提示词模板失败', status: 500 };
}
return { data: convertToUITemplate(apiResponse.data) };
} catch (error) {
console.error('创建提示词模板失败:', error);
return {
@@ -354,7 +368,7 @@ export async function createPromptTemplate(template: Partial<PromptTemplateUI>,
* 更新提示词模板
* @param id 模板ID
* @param template 提示词模板数据
* @param frontendJWT JWT token (可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 更新后的提示词模板
*/
export async function updatePromptTemplate(id: string, template: Partial<PromptTemplateUI>, frontendJWT?: string): Promise<{
@@ -366,81 +380,67 @@ export async function updatePromptTemplate(id: string, template: Partial<PromptT
if (!id) {
return { error: '模板ID不能为空', status: 400 };
}
// 准备变量数据
let variablesData: Record<string, string> = {};
if (typeof template.variables === 'string') {
try {
variablesData = JSON.parse(template.variables);
} catch (e) {
console.error('解析变量JSON失败:', e);
}
} else if (template.variables) {
variablesData = template.variables;
}
// 准备API数据
const apiTemplate: Partial<PromptTemplate> = {};
// 准备API数据(只传需要更新的字段)
const apiTemplate: Record<string, unknown> = {};
if (template.template_name !== undefined) {
apiTemplate.template_name = template.template_name;
}
if (template.template_type !== undefined) {
apiTemplate.template_type = template.template_type;
}
if (template.description !== undefined) {
apiTemplate.description = template.description;
}
if (template.template_content !== undefined) {
apiTemplate.template_content = template.template_content;
}
if (template.variables !== undefined) {
apiTemplate.variables = variablesData;
}
if (template.status !== undefined) {
apiTemplate.status = mapStatusToAPI(template.status);
}
if (template.version !== undefined) {
apiTemplate.version = template.version;
}
if (template.template_code !== undefined) {
apiTemplate.template_code = template.template_code;
}
if (template.template_type !== undefined) {
apiTemplate.template_type = template.template_type;
}
if (template.description !== undefined) {
apiTemplate.description = template.description;
}
if (template.template_content !== undefined) {
apiTemplate.template_content = template.template_content;
}
if (template.template_abbreviation !== undefined) {
apiTemplate.template_abbreviation = template.template_abbreviation;
}
// if(apiTemplate){
// console.log('apiTemplate', apiTemplate);
// throw new Error('测试错误');
// }
if (template.variables !== undefined) {
apiTemplate.variables = template.variables;
}
const response = await postgrestPut<PromptTemplate, Partial<PromptTemplate>>(
'prompt_templates',
apiTemplate,
{ id },
frontendJWT
if (template.status !== undefined) {
apiTemplate.status = mapStatusToAPI(template.status);
}
const response = await apiRequest<ApiResponse<PromptTemplate>>(
`/api/v3/prompt-templates/${id}`,
buildRequestOptions('PUT', apiTemplate, frontendJWT)
);
if (response.error) {
return { error: response.error, status: response.status };
}
const extractedData = extractApiData<PromptTemplate>(response.data);
if (!extractedData) {
if (!response.data) {
return { error: '更新提示词模板失败', status: 500 };
}
return { data: convertToUITemplate(extractedData) };
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '更新提示词模板失败', status: response.status };
}
if (!apiResponse.data) {
return { error: '更新提示词模板失败', status: 500 };
}
return { data: convertToUITemplate(apiResponse.data) };
} catch (error) {
console.error('更新提示词模板失败:', error);
return {
@@ -453,7 +453,7 @@ export async function updatePromptTemplate(id: string, template: Partial<PromptT
/**
* 删除提示词模板
* @param id 模板ID
* @param frontendJWT JWT token (可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 成功或失败信息
*/
export async function deletePromptTemplate(id: string, frontendJWT?: string): Promise<{
@@ -466,21 +466,26 @@ export async function deletePromptTemplate(id: string, frontendJWT?: string): Pr
return { error: '模板ID不能为空', status: 400 };
}
// 使用真实删除替代状态更新
const response = await postgrestDelete<PromptTemplate>(
'prompt_templates',
{
filter: {
'id': `eq.${id}`
},
token: frontendJWT
}
const response = await apiRequest<ApiResponse<{ message: string }>>(
`/api/v3/prompt-templates/${id}`,
buildRequestOptions('DELETE', undefined, frontendJWT)
);
if (response.error) {
return { error: response.error, status: response.status };
}
if (!response.data) {
return { error: '删除提示词模板失败', status: 500 };
}
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '删除提示词模板失败', status: response.status };
}
return { success: true };
} catch (error) {
console.error('删除提示词模板失败:', error);
@@ -494,7 +499,7 @@ export async function deletePromptTemplate(id: string, frontendJWT?: string): Pr
/**
* 获取指定类型的提示词模板选项
* @param templateType 模板类型(如 'VLM_Extraction', 'LLM_Extraction' 等)
* @param frontendJWT JWT token (可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 模板选项列表 { value: template_code, label: template_abbreviation }
*/
export async function getPromptTemplateOptions(templateType: string, frontendJWT?: string): Promise<{
@@ -507,35 +512,49 @@ export async function getPromptTemplateOptions(templateType: string, frontendJWT
return { error: '模板类型不能为空', status: 400 };
}
const params: PostgrestParams = {
select: 'template_code,template_abbreviation',
filter: {
'template_type': `eq.${templateType}`,
'status': 'gte.0' // 只查询有效状态的模板
},
order: 'template_abbreviation.asc', // 按标签排序
token: frontendJWT
// 使用列表接口,筛选指定类型并只获取需要的字段
const params = {
template_type: templateType,
page: 1,
page_size: 500, // 获取足够多的选项
};
const response = await postgrestGet<Array<{ template_code: string; template_abbreviation: string }>>('prompt_templates', params);
const response = await apiRequest<ApiResponse<ListResponse>>(
'/api/v3/prompt-templates',
buildRequestOptions('GET', undefined, frontendJWT),
params
);
if (response.error) {
console.error('获取提示词模板选项失败:', response.error);
return { error: response.error, status: response.status };
}
const extractedData = extractApiData<Array<{ template_code: string; template_abbreviation: string }>>(response.data);
if (!extractedData) {
if (!response.data) {
console.error('提取提示词模板选项数据失败');
return { error: '获取提示词模板选项失败', status: 500 };
}
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '获取提示词模板选项失败', status: response.status };
}
const listData = apiResponse.data;
if (!listData || !listData.items) {
return { error: '获取提示词模板选项失败', status: 500 };
}
// 转换为选项格式
const options = extractedData.map(item => ({
value: item.template_code,
label: item.template_abbreviation
}));
const options = listData.items
.filter(item => item.template_code && item.template_abbreviation) // 只保留有 code 和 abbreviation 的
.map(item => ({
value: item.template_code!,
label: item.template_abbreviation!
}));
return { data: options };
} catch (error) {
@@ -545,4 +564,105 @@ export async function getPromptTemplateOptions(templateType: string, frontendJWT
status: 500
};
}
}
}
/**
* 获取提示词模板类型列表
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 类型选项列表
*/
export async function getPromptTemplateTypes(frontendJWT?: string): Promise<{
data?: TypeOption[];
error?: string;
status?: number;
}> {
try {
const response = await apiRequest<ApiResponse<{ items: TypeOption[] }>>(
'/api/v3/prompt-templates/types',
buildRequestOptions('GET', undefined, frontendJWT)
);
if (response.error) {
console.error('获取提示词模板类型失败:', response.error);
return { error: response.error, status: response.status };
}
if (!response.data) {
console.error('提取提示词模板类型数据失败');
return { error: '获取提示词模板类型失败', status: 500 };
}
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '获取提示词模板类型失败', status: response.status };
}
if (!apiResponse.data || !apiResponse.data.items) {
return { error: '获取提示词模板类型失败', status: 500 };
}
return { data: apiResponse.data.items };
} catch (error) {
console.error('获取提示词模板类型出错:', error);
return {
error: error instanceof Error ? error.message : '获取提示词模板类型失败',
status: 500
};
}
}
/**
* 复制提示词模板
* @param id 原模板ID
* @param newCode 新模板代码(可选)
* @param frontendJWT JWT token (可选,已由 axios-client 自动处理)
* @returns 复制后的新模板
*/
export async function duplicatePromptTemplate(id: string, newCode?: string, frontendJWT?: string): Promise<{
data?: PromptTemplateUI;
error?: string;
status?: number;
}> {
try {
if (!id) {
return { error: '模板ID不能为空', status: 400 };
}
const params = newCode ? { new_code: newCode } : undefined;
const response = await apiRequest<ApiResponse<PromptTemplate>>(
`/api/v3/prompt-templates/${id}/duplicate`,
buildRequestOptions('POST', undefined, frontendJWT),
params
);
if (response.error) {
return { error: response.error, status: response.status };
}
if (!response.data) {
return { error: '复制提示词模板失败', status: 500 };
}
const apiResponse = response.data;
// 支持 code=0 (成功) 和 code=200 (成功) 两种格式
if (apiResponse.code !== 0 && apiResponse.code !== 200) {
return { error: apiResponse.message || '复制提示词模板失败', status: response.status };
}
if (!apiResponse.data) {
return { error: '复制提示词模板失败', status: 500 };
}
return { data: convertToUITemplate(apiResponse.data) };
} catch (error) {
console.error('复制提示词模板出错:', error);
return {
error: error instanceof Error ? error.message : '复制提示词模板失败',
status: 500
};
}
}
+42 -10
View File
@@ -100,7 +100,8 @@ export interface UserInfo {
nick_name: string;
phone_number?: string;
email?: string;
ou_name: string;
area: string; // v3.3: 地区字段,用于权限隔离(省/市级别)
ou_name: string; // 部门名称,用于组织显示(部门级别)
status: number;
is_leader: boolean;
}
@@ -277,6 +278,8 @@ export async function getRoutes(): Promise<RouteInfo[]> {
children: route.children ? route.children.map(mapRouteData) : undefined
});
console.log('获取当前用户的路由', routes.map(mapRouteData) )
return routes.map(mapRouteData);
} catch (error) {
console.error('❌ [getRoutes] 获取路由数据失败:', error);
@@ -316,6 +319,8 @@ export async function getRoleRoutePermissions(roleId: number): Promise<RoleRoute
created_at: new Date().toISOString()
}));
console.log("路由权限数据", permissions)
return permissions;
} catch (error) {
console.error('❌ [getRoleRoutePermissions] 获取角色路由权限失败:', error);
@@ -352,7 +357,7 @@ export async function getRoleRoutesWithPermissions(roleId: number): Promise<{
}
// 递归转换路由数据格式
const mapRouteData = (route: any): RouteInfo => ({
const mapRouteData = (route: any): any => ({
id: route.id,
route_path: route.route_path,
route_name: route.route_name,
@@ -364,6 +369,8 @@ export async function getRoleRoutesWithPermissions(roleId: number): Promise<{
status: route.status || 1,
parent_id: route.parent_id || null,
component: route.component,
// v3.2: 添加 enabled 字段
enabled: route.enabled !== undefined ? route.enabled : true,
// v3.0: 转换permissions数组
permissions: Array.isArray(route.permissions) ? route.permissions.map((p: any) => ({
id: p.id,
@@ -377,11 +384,14 @@ export async function getRoleRoutesWithPermissions(roleId: number): Promise<{
const mappedRoutes = routes.map(mapRouteData);
// 收集所有已选中的路由ID
const collectRouteIds = (routes: RouteInfo[]): number[] => {
// v3.2: 收集已启用的路由IDenabled=true
const collectRouteIds = (routes: any[]): number[] => {
let ids: number[] = [];
routes.forEach(route => {
ids.push(route.id);
// v3.2: 只收集 enabled=true 的路由
if (route.enabled) {
ids.push(route.id);
}
if (route.children) {
ids = ids.concat(collectRouteIds(route.children));
}
@@ -468,14 +478,14 @@ export async function saveRoleApiPermissions(
}
/**
* 更新角色的路由权限
* 更新角色的路由权限 - v3.2更新
* @param roleId 角色ID
* @param routeIds 路由ID数组
*/
export async function updateRoleRoutePermissions(
roleId: number,
routeIds: number[]
): Promise<{ success: boolean; message: string }> {
): Promise<{ success: boolean; message: string; code?: number }> {
try {
// 导入 axios-client 的 put 函数
const { put } = await import('~/api/axios-client');
@@ -491,13 +501,33 @@ export async function updateRoleRoutePermissions(
throw new Error(response.error);
}
// 后端响应格式: { code: 200, msg: "success", data: { role_id, assigned_count, removed_count, route_ids } }
// v3.3: 处理权限不足错误
if (response.data && response.data.code === 4003) {
return {
success: false,
message: response.data.msg || '权限不足:仅省级管理员可以修改角色路由权限',
code: 4003
};
}
// v3.2: 新响应格式: { code: 200, msg: "success", data: { role_id, enabled_count, disabled_count, inserted_count, route_ids } }
let message = '角色权限更新成功';
if (response.data && response.data.msg) {
message = response.data.msg;
} else if (response.data && response.data.data) {
const { assigned_count, removed_count } = response.data.data;
message = `成功分配 ${assigned_count} 个路由,移除了 ${removed_count} 个旧路由`;
const { enabled_count, disabled_count, inserted_count } = response.data.data;
if (enabled_count !== undefined && disabled_count !== undefined) {
message = `成功启用 ${enabled_count} 个路由,禁用 ${disabled_count} 个路由`;
if (inserted_count && inserted_count > 0) {
message += `,新增 ${inserted_count} 个路由关联`;
}
} else {
// 兼容旧版本响应格式
const { assigned_count, removed_count } = response.data.data;
if (assigned_count !== undefined && removed_count !== undefined) {
message = `成功分配 ${assigned_count} 个路由,移除了 ${removed_count} 个旧路由`;
}
}
}
return { success: true, message };
@@ -558,6 +588,7 @@ export async function getRoleUsers(
nick_name: user.nick_name,
phone_number: user.phone_number || '',
email: user.email || '',
area: user.area || '', // v3.3: 地区字段,用于权限隔离
ou_name: user.ou_name,
status: user.status || 1,
is_leader: user.is_leader || false
@@ -619,6 +650,7 @@ export async function getAllUsers(params?: {
nick_name: user.nick_name,
phone_number: user.phone_number || '',
email: user.email || '',
area: user.area || '', // v3.3: 地区字段,用于权限隔离
ou_name: user.ou_name,
status: user.status || 1,
is_leader: user.is_leader || false