TanWenyan/leaudit-platform-frontend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加jwt验证，添加交叉评查首页加载对接接口，评查任务文档列表对接接口，意见列表对接接口

Browse Source
This commit is contained in:
yorn
2025-07-22 14:37:37 +08:00
parent de953283e3
commit 47664fc0e8
19 changed files with 1988 additions and 557 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/api/cross-checking/cross-file-result.ts
+64 -6
View File
@@ -65,15 +65,29 @@ export interface ApiResponse<T> {
status?: number;
}
/**
* 安全获取JWT token
* @param jwtToken JWT token字符串
* @returns JWT token字符串
*/
async function safeGetJWT(jwtToken?: string): Promise<string> {
return jwtToken || '';
}
/**
* 提交交叉评查意见
* @param opinionData 意见数据
* @param jwtToken JWT token
* @returns 提交结果
*/
export async function submitCrossCheckingOpinion(
opinionData: SubmitOpinionRequest
opinionData: SubmitOpinionRequest,
jwtToken?: string
): Promise<ApiResponse<SubmitOpinionResponse>> {
try {
// 获取JWT token
const token = await safeGetJWT(jwtToken);
const requestData = {
proposer_user_id: 1,
evaluation_result_id: opinionData.reviewPointResultId,
@@ -87,7 +101,8 @@ export async function submitCrossCheckingOpinion(
const response = await fetch(`${API_BASE_URL}/admin/cross_review/proposals`, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
body: JSON.stringify(requestData)
});
@@ -119,6 +134,8 @@ export async function submitCrossCheckingOpinion(
* @param documentId 文档ID
* @param page 页码
* @param pageSize 每页大小
* @param userId 用户ID，可选，便于后端接口对接
* @param jwtToken JWT token
* @returns 意见列表和总数
*/
import { API_BASE_URL } from '../../config/api-config';
@@ -127,9 +144,13 @@ export async function getCrossCheckingOpinions(
documentId: string | number,
page: number = 1,
pageSize: number = 10,
userId?: number // 可选，便于后端接口对接
userId?: number, // 可选，便于后端接口对接
jwtToken?: string // 改为jwtToken参数
): Promise<ApiResponse<{ opinions: CrossCheckingOpinion[], total: number }>> {
try {
// 获取JWT token
const token = await safeGetJWT(jwtToken);
// 如果没传userId，默认用1
const realUserId = userId ?? 1;
// 实际后端API调用，拼接API_BASE_URL
@@ -137,6 +158,7 @@ export async function getCrossCheckingOpinions(
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
body: JSON.stringify({
user_id: realUserId,
@@ -226,6 +248,13 @@ export async function getCrossCheckingOpinions(
*/
export type OpinionActionType = 'agree' | 'disagree' | 'withdraw_vote' | 'withdraw_opinion';
/**
* 投票请求参数接口
*/
export interface OpinionVoteCreate {
vote_type: 'agree' | 'disagree';
}
/**
* 意见操作请求参数
*/
@@ -237,33 +266,62 @@ export interface OpinionActionRequest {
/**
* 执行意见操作（赞同、反对、撤销投票、撤销意见）
* @param actionData 操作数据
* @param jwtToken JWT token
* @returns 操作结果
*/
export async function performOpinionAction(
actionData: OpinionActionRequest
actionData: OpinionActionRequest,
jwtToken?: string
): Promise<ApiResponse<{ success: boolean; message: string }>> {
try {
// 模拟API调用延迟
await new Promise(resolve => setTimeout(resolve, 500));
const token = await safeGetJWT(jwtToken);
let message = '';
let endpoint = '';
let requestBody: Record<string, unknown> = {};
switch (actionData.action) {
case 'agree':
message = '已赞同该意见';
endpoint = `${API_BASE_URL}/admin/cross_review/proposals/${actionData.opinionId}/votes`;
requestBody = { vote_type: 'agree' };
break;
case 'disagree':
message = '已反对该意见';
endpoint = `${API_BASE_URL}/admin/cross_review/proposals/${actionData.opinionId}/votes`;
requestBody = { vote_type: 'disagree' };
break;
case 'withdraw_vote':
message = '已撤销投票';
// 撤销投票的接口，根据实际API调整
endpoint = `${API_BASE_URL}/admin/cross_review/proposals/${actionData.opinionId}/votes/withdraw`;
requestBody = {};
break;
case 'withdraw_opinion':
message = '已撤销意见';
// 撤销意见的接口，根据实际API调整
endpoint = `${API_BASE_URL}/admin/cross_review/proposals/${actionData.opinionId}/withdraw`;
requestBody = {};
break;
default:
throw new Error('无效的操作类型');
}
const response = await fetch(endpoint, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
body: JSON.stringify(requestBody)
});
const data = await response.json();
if (!response.ok) {
throw new Error(data.message || data.error || '操作失败');
}
return {
data: {
success: true,
app/api/cross-checking/cross-files.ts
+214 -255
View File
@@ -1,4 +1,5 @@
import { API_BASE_URL } from '../../config/api-config';
import { postgrestPut } from '../postgrest-client';
// 交叉评查任务状态枚举
export enum CrossCheckingTaskStatus {
@@ -26,13 +27,14 @@ export interface CrossCheckingTask {
taskName: string;
startDate: string;
taskType: CrossCheckingTaskType;
docType: CrossCheckingDocType; // 案卷类型
docType: string; // 改为直接使用返回的 doc_type 字符串
evaluationRegion: string;
progress: number;
status: CrossCheckingTaskStatus;
status: string; // 改为直接使用返回的 task_status 字符串
score: number;
operation: string;
documentIds: number[];
documents: UserTaskDocument[]; // 改为 documents 数组，包含完整的文档信息
totalDocuments?: number; // 新增：任务包含的文档总数
}
// 用户任务文档接口类型定义
@@ -43,22 +45,57 @@ export interface UserTaskDocument {
document_type_name: string;
}
// 用户任务信息接口
// 新的用户任务信息接口（根据新的API格式）
export interface UserTaskInfo {
task_id: number;
task_name?: string;
task_status: string;
documents: UserTaskDocument[];
doc_type?: string;
task_created_at?: string;
progress?: number;
total_documents?: number; // 新增：任务包含的文档总数
}
// 用户任务API响应格式
// 用户任务API响应格式（新格式）
export interface UserTaskApiResponse {
data: UserTaskInfo[];
pagination: {
page: number;
page_size: number;
total: number;
total_pages: number;
};
total: number;
page: number;
page_size: number;
items: UserTaskInfo[];
}
// 任务文档接口类型定义（新增）
export interface TaskDocument {
document_id: number;
file_name: string;
status: string;
path: string;
file_code: string;
file_type_name: string;
file_type_id: number;
file_size: number;
upload_time: string;
created_at: string;
evaluations_status: number;
audit_status: number;
created_by_user_id: number;
issues: Array<{
severity: string;
message: string;
}>;
final_score: number;
pass_count: number;
warning_count: number;
fail_count: number;
manual_count: number;
}
// 任务文档API响应格式（新增）
export interface TaskDocumentApiResponse {
total: number;
page: number;
page_size: number;
items: TaskDocument[];
}
// API响应格式
@@ -91,95 +128,23 @@ export interface TaskListResponse {
totalPages: number;
}
/**
* 模拟数据 - 临时使用
*/
const mockTasks: CrossCheckingTask[] = [
{
id: 1,
sequence: 1,
taskName: '2024年度交叉评查',
startDate: '2024-12-23',
taskType: CrossCheckingTaskType.CITY,
docType: CrossCheckingDocType.PENALTY,
evaluationRegion: '梅州市、揭阳市、潮州市、云浮市',
progress: 0,
status: CrossCheckingTaskStatus.PENDING,
score: 0,
operation: '去评查',
documentIds: [1, 2, 3, 4, 5]
},
{
id: 2,
sequence: 2,
taskName: '2024年第4季度交叉评查',
startDate: '2024-12-05',
taskType: CrossCheckingTaskType.COUNTY,
docType: CrossCheckingDocType.PERMIT,
evaluationRegion: '梅江区、梅县区、平远县、蕉岭县、大埔县、丰顺县、五华县',
progress: 72,
status: CrossCheckingTaskStatus.IN_PROGRESS,
score: 0,
operation: '进行中',
documentIds: [1, 2, 3, 4, 5]
},
{
id: 3,
sequence: 3,
taskName: '2024年第3季度交叉评查',
startDate: '2024-9-23',
taskType: CrossCheckingTaskType.COUNTY,
docType: CrossCheckingDocType.PERMIT,
evaluationRegion: '梅江区、梅县区、平远县、蕉岭县、大埔县、丰顺县、五华县',
progress: 100,
status: CrossCheckingTaskStatus.COMPLETED,
score: 95,
operation: '查看结果',
documentIds: [1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370,1371,1372,1373,1374]
},
{
id: 4,
sequence: 4,
taskName: '2024年中交叉评查',
startDate: '2024-6-23',
taskType: CrossCheckingTaskType.CITY,
docType: CrossCheckingDocType.PENALTY,
evaluationRegion: '梅州市、揭阳市、潮州市、云浮市',
progress: 100,
status: CrossCheckingTaskStatus.COMPLETED,
score: 85,
operation: '查看结果',
documentIds: [1, 2, 3, 4, 5]
},
{
id: 5,
sequence: 5,
taskName: '2024年第2季度交叉评查',
startDate: '2024-3-23',
taskType: CrossCheckingTaskType.COUNTY,
docType: CrossCheckingDocType.PENALTY,
evaluationRegion: '梅江区、梅县区、平远县、蕉岭县、大埔县、丰顺县、五华县',
progress: 100,
status: CrossCheckingTaskStatus.COMPLETED,
score: 92,
operation: '查看结果',
documentIds: [1, 2, 3, 4, 5]
}
];
/**
* 获取交叉评查任务列表
* @param params 查询参数
* @param userInfo 用户信息
* @param jwtToken JWT token
* @returns 任务列表响应
*/
export async function getCrossCheckingTasks(params: TaskListParams = {}): Promise<ApiResponse<TaskListResponse>> {
export async function getCrossCheckingTasks(params: TaskListParams = {}, userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<TaskListResponse>> {
try {
console.log('开始调用getCrossCheckingTasks，参数:', params);
// 调用用户任务API，获取当前用户参与的任务
const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
const userTasksResponse = await getUserTaskDocuments(params.page || 1, params.pageSize || 10, jwtToken);
console.log('getUserTaskDocuments响应:', userTasksResponse);
// console.log('getUserTaskDocuments响应:', JSON.stringify(userTasksResponse,null,2));
if (!userTasksResponse.success || !userTasksResponse.data) {
console.error('获取用户任务失败:', userTasksResponse.error);
@@ -190,33 +155,29 @@ export async function getCrossCheckingTasks(params: TaskListParams = {}): Promis
}
// 将用户任务数据转换为CrossCheckingTask格式
const userTasks = userTasksResponse.data;
const userTasks = userTasksResponse.data.items;
const convertedTasks: CrossCheckingTask[] = userTasks.map((userTask: UserTaskInfo, index: number) => {
// 从用户任务中提取任务信息，如果没有对应信息则使用默认值
// 从用户任务中提取任务信息，使用API返回的实际数据
const task: CrossCheckingTask = {
id: userTask.task_id,
sequence: index + 1,
taskName: `任务 ${userTask.task_id}`, // 用户任务API中没有任务名称，使用默认值
startDate: new Date().toISOString().split('T')[0], // 使用当前日期作为默认值
taskType: CrossCheckingTaskType.CITY, // 默认任务类型
docType: CrossCheckingDocType.PENALTY, // 默认案卷类型
evaluationRegion: '待定', // 默认评查地区
progress: userTask.task_status === 'completed' ? 100 :
userTask.task_status === 'in_progress' ? 50 : 0,
status: userTask.task_status === 'completed' ? CrossCheckingTaskStatus.COMPLETED :
userTask.task_status === 'in_progress' ? CrossCheckingTaskStatus.IN_PROGRESS :
CrossCheckingTaskStatus.PENDING,
taskName: userTask.task_name || `任务 ${userTask.task_id}`, // 使用API返回的任务名称
startDate: userTask.task_created_at ? new Date(userTask.task_created_at).toISOString().split('T')[0] : new Date().toISOString().split('T')[0],
taskType: CrossCheckingTaskType.CITY, // 保持默认任务类型
docType: userTask.doc_type || '未知类型', // 使用API返回的文档类型
evaluationRegion: '待定', // 保持默认评查地区
progress: userTask.progress || 0, // 使用API返回的进度
status: userTask.task_status || 'pending', // 使用API返回的任务状态
score: userTask.task_status === 'completed' ? 85 : 0, // 默认分数
operation: userTask.task_status === 'completed' ? '查看结果' :
userTask.task_status === 'in_progress' ? '进行中' : '去评查',
documentIds: userTask.documents.map((doc: UserTaskDocument) => doc.document_id)
documents: [], // 暂时为空数组，因为新API格式中任务列表不包含具体文档信息
totalDocuments: userTask.total_documents || 0 // 使用API返回的文档总数
};
return task;
});
const {
page = 1,
pageSize = 10,
taskType,
docType,
status,
@@ -262,21 +223,14 @@ export async function getCrossCheckingTasks(params: TaskListParams = {}): Promis
});
}
// 分页处理
const totalCount = filteredTasks.length;
const totalPages = Math.ceil(totalCount / pageSize);
const startIndex = (page - 1) * pageSize;
const endIndex = startIndex + pageSize;
const paginatedTasks = filteredTasks.slice(startIndex, endIndex);
return {
success: true,
data: {
tasks: paginatedTasks,
totalCount,
currentPage: page,
pageSize,
totalPages
tasks: filteredTasks,
totalCount: userTasksResponse.data.total,
currentPage: userTasksResponse.data.page,
pageSize: userTasksResponse.data.page_size,
totalPages: Math.ceil(userTasksResponse.data.total / userTasksResponse.data.page_size)
}
};
} catch (error) {
@@ -288,41 +242,6 @@ export async function getCrossCheckingTasks(params: TaskListParams = {}): Promis
}
}
/**
* 创建新的交叉评查任务
* @param taskData 任务数据
* @returns 创建结果
*/
export async function createCrossCheckingTask(taskData: Omit<CrossCheckingTask, 'id' | 'sequence' | 'progress' | 'score'>): Promise<ApiResponse<CrossCheckingTask>> {
try {
// 模拟API延迟
await new Promise(resolve => setTimeout(resolve, 800));
const newTask: CrossCheckingTask = {
...taskData,
id: Math.max(...mockTasks.map(t => t.id)) + 1,
sequence: mockTasks.length + 1,
progress: 0,
score: 0
};
// 添加到模拟数据
mockTasks.unshift(newTask);
return {
success: true,
data: newTask,
message: '创建任务成功'
};
} catch (error) {
console.error('创建交叉评查任务失败:', error);
return {
success: false,
error: error instanceof Error ? error.message : '创建任务失败'
};
}
}
/**
* 删除交叉评查任务
* @param taskId 任务ID
@@ -333,16 +252,9 @@ export async function deleteCrossCheckingTask(taskId: number): Promise<ApiRespon
// 模拟API延迟
await new Promise(resolve => setTimeout(resolve, 500));
const taskIndex = mockTasks.findIndex(task => task.id === taskId);
if (taskIndex === -1) {
return {
success: false,
error: '任务不存在'
};
}
// 从模拟数据中删除
mockTasks.splice(taskIndex, 1);
// 这里应该调用实际的API来删除任务
// 目前暂时返回成功，因为没有实际的删除API
console.log(`尝试删除任务ID: ${taskId}`);
return {
success: true,
@@ -361,96 +273,51 @@ export async function deleteCrossCheckingTask(taskId: number): Promise<ApiRespon
/**
* 获取任务详情及相关文档
* @param taskId 任务ID
* @param documentIds 指定的文档ID数组，用于筛选任务包含的文档
* @param page 页码，默认为1
* @param pageSize 每页大小，默认为10
* @param jwtToken JWT token
* @returns 任务详情和文档列表
*/
export async function getCrossCheckingTaskDetail(
taskId: number,
documentIds: number[],
page: number = 1,
pageSize: number = 10
pageSize: number = 10,
jwtToken?: string
): Promise<ApiResponse<{
task: CrossCheckingTask;
files: import('../evaluation_points/rules-files').ReviewFileUI[];
task: CrossCheckingTask | null;
files: TaskDocument[];
total: number;
currentPage: number;
pageSize: number;
}>> {
try {
// 从用户任务API中获取任务信息
const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
console.log('开始调用getCrossCheckingTaskDetail，参数:', { taskId, page, pageSize });
if (!userTasksResponse.success || !userTasksResponse.data) {
console.error('获取用户任务失败:', userTasksResponse.error);
// 获取任务的文档列表
const taskDocumentsResponse = await getTaskDocuments(taskId, page, pageSize, jwtToken);
if (!taskDocumentsResponse.success || !taskDocumentsResponse.data) {
console.error('获取任务文档失败:', taskDocumentsResponse.error);
return {
success: false,
error: userTasksResponse.error || '获取用户任务失败'
error: taskDocumentsResponse.error || '获取任务文档失败'
};
}
// 查找指定的任务
const userTask = userTasksResponse.data.find(t => t.task_id === taskId);
if (!userTask) {
return {
success: false,
error: '任务不存在'
};
}
const documentsData = taskDocumentsResponse.data;
// 将用户任务转换为CrossCheckingTask格式
const task: CrossCheckingTask = {
id: userTask.task_id,
sequence: 1, // 暂时使用默认值
taskName: `任务 ${userTask.task_id}`, // 用户任务API中没有任务名称，使用默认值
startDate: new Date().toISOString().split('T')[0], // 使用当前日期作为默认值
taskType: CrossCheckingTaskType.CITY, // 默认任务类型
docType: CrossCheckingDocType.PENALTY, // 默认案卷类型
evaluationRegion: '待定', // 默认评查地区
progress: userTask.task_status === 'completed' ? 100 :
userTask.task_status === 'in_progress' ? 50 : 0,
status: userTask.task_status === 'completed' ? CrossCheckingTaskStatus.COMPLETED :
userTask.task_status === 'in_progress' ? CrossCheckingTaskStatus.IN_PROGRESS :
CrossCheckingTaskStatus.PENDING,
score: userTask.task_status === 'completed' ? 85 : 0, // 默认分数
operation: userTask.task_status === 'completed' ? '查看结果' :
userTask.task_status === 'in_progress' ? '进行中' : '去评查',
documentIds: userTask.documents.map(doc => doc.document_id)
};
let files: import('../evaluation_points/rules-files').ReviewFileUI[] = [];
let total = 0;
// 如果提供了documentIds，则调用getReviewFiles获取相关文档
if (documentIds && documentIds.length > 0) {
const { getReviewFiles } = await import('../evaluation_points/rules-files');
const reviewFilesResponse = await getReviewFiles({
page: page,
pageSize: pageSize,
sortOrder: 'upload_time_desc'
}, documentIds);
if (reviewFilesResponse.error) {
return {
success: false,
error: reviewFilesResponse.error
};
}
files = reviewFilesResponse.data?.files || [];
total = reviewFilesResponse.data?.total || 0;
}
console.log('files', files);
return {
const result = {
success: true,
data: {
task,
files,
total
task: null, // 暂时不返回任务详情，因为新接口主要关注文档列表
files: documentsData.items,
total: documentsData.total,
currentPage: documentsData.page,
pageSize: documentsData.page_size
}
};
return result;
} catch (error) {
console.error('获取任务详情失败:', error);
return {
@@ -462,9 +329,11 @@ export async function getCrossCheckingTaskDetail(
/**
* 获取统计数据
* @param userInfo 用户信息
* @param jwtToken JWT token
* @returns 统计数据
*/
export async function getCrossCheckingStats(): Promise<ApiResponse<{
export async function getCrossCheckingStats(userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<{
totalTasks: number;
pendingTasks: number;
inProgressTasks: number;
@@ -473,8 +342,8 @@ export async function getCrossCheckingStats(): Promise<ApiResponse<{
try {
console.log('开始调用getCrossCheckingStats');
// 获取用户任务数据来计算统计
const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
// 获取用户任务数据来计算统计（默认获取第一页数据进行统计）
const userTasksResponse = await getUserTaskDocuments(1, 100, jwtToken); // 获取前100个任务用于统计
if (!userTasksResponse.success || !userTasksResponse.data) {
console.error('获取用户任务失败:', userTasksResponse.error);
@@ -484,8 +353,8 @@ export async function getCrossCheckingStats(): Promise<ApiResponse<{
};
}
const userTasks = userTasksResponse.data;
const totalTasks = userTasks.length;
const userTasks = userTasksResponse.data.items;
const totalTasks = userTasksResponse.data.total;
const pendingTasks = userTasks.filter(t => t.task_status === 'pending').length;
const inProgressTasks = userTasks.filter(t => t.task_status === 'in_progress').length;
const completedTasks = userTasks.filter(t => t.task_status === 'completed').length;
@@ -508,47 +377,137 @@ export async function getCrossCheckingStats(): Promise<ApiResponse<{
}
}
// ==================== 新增：用户任务文档相关接口 ====================
// ==================== 更新：用户任务文档相关接口 ====================
/**
* 获取用户参与的所有任务及文档
* @param userId 用户ID
* @returns 用户任务及文档列表
* 获取用户参与的所有任务列表（更新为新的API格式）
* @param page 页码
* @param pageSize 每页大小
* @param jwtToken JWT token
* @returns 用户任务列表
*/
export async function getUserTaskDocuments(userId: number): Promise<ApiResponse<UserTaskInfo[]>> {
export async function getUserTaskDocuments(page: number = 1, pageSize: number = 10, jwtToken?: string): Promise<ApiResponse<UserTaskApiResponse>> {
try {
// 拼接绝对路径，去除多余斜杠
const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
const url = `${base}/admin/cross_review/tasks/user_documents?user_id=${userId}`;
console.log('最终请求URL:', url);
const url = `${base}/admin/cross_review/tasks/user_tasks`;
const response = await fetch(url, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ user_id: userId })
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${jwtToken || ''}`
},
body: JSON.stringify({
page: page,
page_size: pageSize
})
});
if (!response.ok) {
return {
success: false,
error: `HTTP ${response.status}: ${response.statusText}`
};
}
const result = await response.json();
let userTasks: UserTaskInfo[] = [];
if (Array.isArray(result.data)) {
userTasks = result.data;
} else if (Array.isArray(result)) {
userTasks = result;
} else {
userTasks = [];
}
return {
success: true,
data: userTasks
data: result
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : '获取用户任务及文档失败'
error: error instanceof Error ? error.message : '获取用户任务列表失败'
};
}
}
/**
* 获取指定任务的文档列表（新增接口）
* @param taskId 任务ID
* @param page 页码
* @param pageSize 每页大小
* @param jwtToken JWT token
* @returns 任务文档列表
*/
export async function getTaskDocuments(taskId: number, page: number = 1, pageSize: number = 10, jwtToken?: string): Promise<ApiResponse<TaskDocumentApiResponse>> {
try {
// 拼接绝对路径，去除多余斜杠
const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
const url = `${base}/admin/cross_review/tasks/${taskId}/documents`;
// console.log('最终请求URL:', url);
const response = await fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${jwtToken || ''}`
},
body: JSON.stringify({
page: page,
page_size: pageSize
})
});
if (!response.ok) {
return {
success: false,
error: `HTTP ${response.status}: ${response.statusText}`
};
}
const result = await response.json();
return {
success: true,
data: result
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : '获取任务文档列表失败'
};
}
}
/**
* 更新文件的审核状态
* @param id 文件ID
* @param auditStatus 审核状态
* @returns 更新结果
*/
export async function updateDocumentAuditStatus(id: string, auditStatus: number): Promise<{
success?: boolean;
error?: string;
status?: number;
}> {
try {
if (!id) {
return { error: '文件ID不能为空', status: 400 };
}
const response = await postgrestPut<TaskDocument, Partial<TaskDocument>>(
'documents',
{ audit_status: auditStatus },
{
id: parseInt(id)
}
);
if (response.error) {
return { error: response.error, status: response.status };
}
return { success: true };
} catch (error) {
console.error('更新文件审核状态失败:', error);
return {
error: error instanceof Error ? error.message : '更新文件审核状态失败',
status: 500
};
}
}