wren
1209 lines
34 KiB
TypeScript
1209 lines
34 KiB
TypeScript
import { API_BASE_URL } from '../../config/api-config';
|
||
import { postgrestPut, postgrestGet } from '../postgrest-client';
|
||
import axios from 'axios';
|
||
export { uploadDocumentToTask } from './cross-files-upload';
|
||
|
||
// 交叉评查任务状态枚举
|
||
export enum CrossCheckingTaskStatus {
|
||
PENDING = 'pending',
|
||
IN_PROGRESS = 'in_progress',
|
||
COMPLETED = 'completed'
|
||
}
|
||
|
||
// 交叉评查任务类型枚举
|
||
export enum CrossCheckingTaskType {
|
||
CITY = 'CITY',
|
||
DISTRICT = 'DISTRICT'
|
||
}
|
||
|
||
// 案卷类型枚举
|
||
export enum CrossCheckingDocType {
|
||
PENALTY = 'penalty', // 行政处罚
|
||
PERMIT = 'permit' // 行政许可
|
||
}
|
||
|
||
// 文档类型接口（用于交叉评查案卷类型选项）
|
||
export interface DocumentType {
|
||
id: number;
|
||
name: string;
|
||
code: string;
|
||
evaluation_point_groups_ids?: number[];
|
||
}
|
||
|
||
// 交叉评查任务接口
|
||
export interface CrossCheckingTask {
|
||
id: number;
|
||
sequence: number;
|
||
taskName: string;
|
||
startDate: string;
|
||
taskType: CrossCheckingTaskType;
|
||
docType: string; // 改为直接使用返回的 doc_type 字符串
|
||
evaluationRegion: string[];
|
||
progress: number;
|
||
status: string; // 改为直接使用返回的 task_status 字符串
|
||
score: number;
|
||
operation: string;
|
||
documents: UserTaskDocument[]; // 改为 documents 数组，包含完整的文档信息
|
||
totalDocuments?: number; // 新增：任务包含的文档总数
|
||
}
|
||
|
||
// 用户任务文档接口类型定义
|
||
export interface UserTaskDocument {
|
||
document_id: number;
|
||
document_name: string;
|
||
document_type_id: number;
|
||
document_type_name: string;
|
||
}
|
||
|
||
// 新的用户任务信息接口（根据新的API格式）
|
||
export interface UserTaskInfo {
|
||
task_id: number;
|
||
task_name?: string;
|
||
task_status: string;
|
||
doc_type?: string;
|
||
task_created_at?: string;
|
||
evaluation_region?: string[];
|
||
task_type?: string;
|
||
progress?: number;
|
||
total_documents?: number; // 新增：任务包含的文档总数
|
||
}
|
||
|
||
// 用户任务API响应格式（新格式）
|
||
export interface UserTaskApiResponse {
|
||
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;
|
||
score_summary: string ;
|
||
score_percent?: number | null;
|
||
pass_count: number;
|
||
warning_count: number;
|
||
fail_count: number;
|
||
manual_count: number;
|
||
}
|
||
|
||
// ==================== 新版接口类型定义（支持版本归纳）====================
|
||
|
||
/**
|
||
* 历史版本信息
|
||
* 每个历史版本都有独立的评查统计、消息列表、分数信息
|
||
*/
|
||
export interface CrossReviewHistoryVersion {
|
||
/** 历史版本的文档ID */
|
||
id: number;
|
||
/** 版本号（从1开始，数字越小越旧） */
|
||
version_number: number;
|
||
/** 创建时间（ISO 8601格式） */
|
||
created_at: string;
|
||
/** 文件大小（字节） */
|
||
file_size: number;
|
||
/** 文件存储路径 */
|
||
path: string;
|
||
/** 文档处理状态 */
|
||
status: "Waiting" | "Cutting" | "Extractioning" | "Evaluationing" | "Failed" | "Processed";
|
||
/** 文书号/文档编号（可为null） */
|
||
document_number: string | null;
|
||
/** 文档类型ID */
|
||
type_id: number;
|
||
/** 文档类型名称 */
|
||
type_name: string;
|
||
/** 上传时间（ISO 8601格式） */
|
||
upload_time: string;
|
||
/** 任务内评查完成状态：0=未评查, 1=已评查 */
|
||
audit_status: 0 | 1;
|
||
/** 总评查点数 */
|
||
total_evaluation_points: number;
|
||
/** 通过的评查点数量 */
|
||
pass_count: number;
|
||
/** 警告的评查点数量 */
|
||
warning_count: number;
|
||
/** 错误的评查点数量 */
|
||
error_count: number;
|
||
/** 需人工审核的评查点数量 */
|
||
manual_count: number;
|
||
/** 问题总数 */
|
||
issue_count: number;
|
||
/** 警告消息列表 */
|
||
warning_messages: string[];
|
||
/** 错误消息列表 */
|
||
error_messages: string[];
|
||
/** 问题消息列表（综合：警告+错误） */
|
||
issue_messages: string[];
|
||
/** 需人工确认的消息列表 */
|
||
manual_messages: string[];
|
||
/** 最终得分 */
|
||
final_score: number;
|
||
/** 满分 */
|
||
full_score: number;
|
||
/** 得分摘要（如 "85.5/100"） */
|
||
score_summary: string;
|
||
/** 得分百分比（0-100） */
|
||
score_percent: number;
|
||
}
|
||
|
||
/**
|
||
* 文档信息（含版本和评查统计）- 新版接口
|
||
*/
|
||
export interface CrossReviewDocumentWithVersion {
|
||
// ========== 基本信息 ==========
|
||
/** 当前版本的文档ID */
|
||
id: number;
|
||
/** 文档名称 */
|
||
name: string;
|
||
/** 文件存储路径 */
|
||
path: string;
|
||
/** 当前版本号（最大值，从1开始） */
|
||
version_number: number;
|
||
/** 创建时间（ISO 8601格式） */
|
||
created_at: string;
|
||
/** 文档处理状态 */
|
||
status: "Waiting" | "Cutting" | "Extractioning" | "Evaluationing" | "Failed" | "Processed";
|
||
/** 文件大小（字节） */
|
||
file_size: number;
|
||
/** 文书号/文档编号（可为null） */
|
||
document_number: string | null;
|
||
/** 文档类型ID */
|
||
type_id: number;
|
||
/** 文档类型名称 */
|
||
type_name: string;
|
||
/** 上传时间（ISO 8601格式） */
|
||
upload_time: string;
|
||
|
||
// ========== 任务内评查状态 ==========
|
||
/** 任务内评查完成状态：0=未评查, 1=已评查 */
|
||
audit_status: 0 | 1;
|
||
|
||
// ========== 评查统计 ==========
|
||
/** 总评查点数 */
|
||
total_evaluation_points: number;
|
||
/** 通过的评查点数量 */
|
||
pass_count: number;
|
||
/** 警告的评查点数量 */
|
||
warning_count: number;
|
||
/** 错误的评查点数量 */
|
||
error_count: number;
|
||
/** 需人工审核的评查点数量 */
|
||
manual_count: number;
|
||
/** 问题总数 */
|
||
issue_count: number;
|
||
|
||
// ========== 评查消息列表 ==========
|
||
/** 警告消息列表 */
|
||
warning_messages: string[];
|
||
/** 错误消息列表 */
|
||
error_messages: string[];
|
||
/** 问题消息列表（综合） */
|
||
issue_messages: string[];
|
||
/** 需人工确认的消息列表 */
|
||
manual_messages: string[];
|
||
|
||
// ========== 交叉评查特有：分数信息 ==========
|
||
/** 最终得分 */
|
||
final_score: number;
|
||
/** 满分 */
|
||
full_score: number;
|
||
/** 得分摘要（如 "85.5/100"） */
|
||
score_summary: string;
|
||
/** 得分百分比（0-100） */
|
||
score_percent: number;
|
||
|
||
// ========== 版本信息 ==========
|
||
/** 总版本数 */
|
||
total_versions: number;
|
||
/** 历史版本列表（按created_at降序，不包含当前版本） */
|
||
history_versions: CrossReviewHistoryVersion[];
|
||
|
||
// ========== 前端扩展字段 ==========
|
||
/** 是否已展开历史版本（前端状态） */
|
||
isExpanded?: boolean;
|
||
}
|
||
|
||
/**
|
||
* 交叉评查任务文档列表响应
|
||
*/
|
||
export interface CrossReviewDocumentListResponse {
|
||
/** 总文档数（按版本分组后的唯一文档数） */
|
||
total: number;
|
||
/** 当前页码 */
|
||
page: number;
|
||
/** 每页数量 */
|
||
page_size: number;
|
||
/** 总页数 */
|
||
total_pages: number;
|
||
/** 文档列表 */
|
||
documents: CrossReviewDocumentWithVersion[];
|
||
}
|
||
|
||
/**
|
||
* 获取任务文档列表请求参数（支持版本归纳）
|
||
*/
|
||
export interface GetTaskDocumentsWithVersionsParams {
|
||
/** 任务ID */
|
||
taskId: number;
|
||
/** 页码（从1开始） */
|
||
page?: number;
|
||
/** 每页数量（最大100） */
|
||
pageSize?: number;
|
||
/** 模糊搜索关键字（匹配文件名称或文档编号） */
|
||
keyword?: string;
|
||
/** JWT token */
|
||
jwtToken?: string;
|
||
}
|
||
|
||
// 任务文档API响应格式（新增）
|
||
export interface TaskDocumentApiResponse {
|
||
total: number;
|
||
page: number;
|
||
page_size: number;
|
||
items: TaskDocument[];
|
||
}
|
||
|
||
// API响应格式
|
||
export interface ApiResponse<T> {
|
||
success: boolean;
|
||
data?: T;
|
||
error?: string;
|
||
message?: string;
|
||
status?: number;
|
||
}
|
||
|
||
interface ResultEnvelope<T> {
|
||
code?: number;
|
||
msg?: string;
|
||
data?: T;
|
||
}
|
||
|
||
interface V3UserTaskItem {
|
||
taskId: number;
|
||
taskName: string;
|
||
taskType: string;
|
||
docTypeId?: number | null;
|
||
docTypeCode?: string | null;
|
||
status: string;
|
||
progress?: number;
|
||
totalDocuments?: number;
|
||
completedDocuments?: number;
|
||
createdAt?: string;
|
||
}
|
||
|
||
interface V3UserTaskPage {
|
||
total: number;
|
||
page: number;
|
||
pageSize: number;
|
||
items: V3UserTaskItem[];
|
||
}
|
||
|
||
interface V3TaskDocumentItem {
|
||
documentId: number;
|
||
name: string;
|
||
documentNumber?: string | null;
|
||
typeId?: number | null;
|
||
processingStatus?: string | null;
|
||
versionNo?: number;
|
||
isLatestVersion?: boolean;
|
||
auditStatus?: number;
|
||
createdAt?: string;
|
||
}
|
||
|
||
interface V3TaskDocumentPage {
|
||
taskId: number;
|
||
total: number;
|
||
page: number;
|
||
pageSize: number;
|
||
items: V3TaskDocumentItem[];
|
||
}
|
||
|
||
function unwrapResultEnvelope<T>(payload: unknown): T {
|
||
if (payload && typeof payload === 'object' && 'data' in (payload as ResultEnvelope<T>)) {
|
||
return ((payload as ResultEnvelope<T>).data ?? null) as T;
|
||
}
|
||
return payload as T;
|
||
}
|
||
|
||
function mapProcessingStatus(status?: string | null): CrossReviewDocumentWithVersion['status'] {
|
||
switch (status) {
|
||
case 'processed':
|
||
case 'Processed':
|
||
return 'Processed';
|
||
case 'failed':
|
||
case 'Failed':
|
||
return 'Failed';
|
||
case 'cutting':
|
||
case 'Cutting':
|
||
return 'Cutting';
|
||
case 'extracting':
|
||
case 'Extractioning':
|
||
return 'Extractioning';
|
||
case 'evaluating':
|
||
case 'Evaluationing':
|
||
return 'Evaluationing';
|
||
case 'waiting':
|
||
case 'Waiting':
|
||
default:
|
||
return 'Waiting';
|
||
}
|
||
}
|
||
|
||
function mapV3TaskToUserTaskInfo(item: V3UserTaskItem): UserTaskInfo {
|
||
return {
|
||
task_id: item.taskId,
|
||
task_name: item.taskName,
|
||
task_status: item.status,
|
||
doc_type: item.docTypeCode || undefined,
|
||
task_created_at: item.createdAt,
|
||
task_type: item.taskType,
|
||
progress: item.progress,
|
||
total_documents: item.totalDocuments
|
||
};
|
||
}
|
||
|
||
function mapV3DocumentToTaskDocument(item: V3TaskDocumentItem): TaskDocument {
|
||
return {
|
||
document_id: item.documentId,
|
||
file_name: item.name || '',
|
||
status: mapProcessingStatus(item.processingStatus),
|
||
path: '',
|
||
file_code: item.documentNumber || '',
|
||
file_type_name: item.typeId ? `类型${item.typeId}` : '',
|
||
file_type_id: item.typeId || 0,
|
||
file_size: 0,
|
||
upload_time: item.createdAt || '',
|
||
created_at: item.createdAt || '',
|
||
evaluations_status: 0,
|
||
audit_status: item.auditStatus || 0,
|
||
created_by_user_id: 0,
|
||
issues: [],
|
||
final_score: 0,
|
||
score_summary: '',
|
||
score_percent: null,
|
||
pass_count: 0,
|
||
warning_count: 0,
|
||
fail_count: 0,
|
||
manual_count: 0
|
||
};
|
||
}
|
||
|
||
function mapV3DocumentToVersionedDocument(item: V3TaskDocumentItem): CrossReviewDocumentWithVersion {
|
||
const typeName = item.typeId ? `类型${item.typeId}` : '未知类型';
|
||
return {
|
||
id: item.documentId,
|
||
name: item.name || '',
|
||
path: '',
|
||
version_number: item.versionNo || 1,
|
||
created_at: item.createdAt || '',
|
||
status: mapProcessingStatus(item.processingStatus),
|
||
file_size: 0,
|
||
document_number: item.documentNumber || null,
|
||
type_id: item.typeId || 0,
|
||
type_name: typeName,
|
||
upload_time: item.createdAt || '',
|
||
audit_status: (item.auditStatus || 0) as 0 | 1,
|
||
total_evaluation_points: 0,
|
||
pass_count: 0,
|
||
warning_count: 0,
|
||
error_count: 0,
|
||
manual_count: 0,
|
||
issue_count: 0,
|
||
warning_messages: [],
|
||
error_messages: [],
|
||
issue_messages: [],
|
||
manual_messages: [],
|
||
final_score: 0,
|
||
full_score: 100,
|
||
score_summary: '',
|
||
score_percent: 0,
|
||
total_versions: 1,
|
||
history_versions: []
|
||
};
|
||
}
|
||
|
||
// 任务列表查询参数
|
||
export interface TaskListParams {
|
||
page?: number;
|
||
pageSize?: number;
|
||
taskType?: string;
|
||
docType?: string;
|
||
status?: string;
|
||
keyword?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}
|
||
|
||
// 任务列表响应数据
|
||
export interface TaskListResponse {
|
||
tasks: CrossCheckingTask[];
|
||
totalCount: number;
|
||
currentPage: number;
|
||
pageSize: number;
|
||
totalPages: number;
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* 获取交叉评查任务列表
|
||
* @param params 查询参数
|
||
* @param userInfo 用户信息
|
||
* @param jwtToken JWT token
|
||
* @returns 任务列表响应
|
||
*/
|
||
export async function getCrossCheckingTasks(params: TaskListParams = {}, userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<TaskListResponse>> {
|
||
try {
|
||
const userTasksResponse = await getUserTaskDocuments(params, jwtToken);
|
||
|
||
// console.log('getUserTaskDocuments响应:', JSON.stringify(userTasksResponse,null,2));
|
||
|
||
if (!userTasksResponse.success || !userTasksResponse.data) {
|
||
console.error('获取用户任务失败:', userTasksResponse.error);
|
||
return {
|
||
success: false,
|
||
error: userTasksResponse.error || '获取用户任务失败'
|
||
};
|
||
}
|
||
|
||
// 将用户任务数据转换为CrossCheckingTask格式
|
||
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_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: userTask.task_type, // 保持默认任务类型
|
||
docType: userTask.doc_type || '未知类型', // 使用API返回的文档类型
|
||
evaluationRegion: userTask.evaluation_region || [],
|
||
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' ? '进行中' : '去评查',
|
||
documents: [], // 暂时为空数组，因为新API格式中任务列表不包含具体文档信息
|
||
totalDocuments: userTask.total_documents || 0 // 使用API返回的文档总数
|
||
};
|
||
return task;
|
||
});
|
||
|
||
const {
|
||
taskType,
|
||
docType,
|
||
status,
|
||
keyword,
|
||
dateFrom,
|
||
dateTo
|
||
} = params;
|
||
|
||
// 筛选数据
|
||
let filteredTasks = [...convertedTasks];
|
||
|
||
// 按任务类型筛选
|
||
if (taskType && taskType !== 'all') {
|
||
filteredTasks = filteredTasks.filter(task => task.taskType === taskType);
|
||
}
|
||
|
||
// 按案卷类型筛选
|
||
if (docType && docType !== 'all') {
|
||
filteredTasks = filteredTasks.filter(task => task.docType === docType);
|
||
}
|
||
|
||
// 按状态筛选
|
||
if (status && status !== 'all') {
|
||
filteredTasks = filteredTasks.filter(task => task.status === status);
|
||
}
|
||
|
||
// 按关键词搜索
|
||
if (keyword) {
|
||
const lowerKeyword = keyword.toLowerCase();
|
||
filteredTasks = filteredTasks.filter(task =>
|
||
task.taskName.toLowerCase().includes(lowerKeyword) ||
|
||
task.evaluationRegion.join(',').toLowerCase().includes(lowerKeyword)
|
||
);
|
||
}
|
||
|
||
// 按日期范围筛选
|
||
if (dateFrom || dateTo) {
|
||
filteredTasks = filteredTasks.filter(task => {
|
||
const taskDate = new Date(task.startDate);
|
||
if (dateFrom && new Date(dateFrom) > taskDate) return false;
|
||
if (dateTo && new Date(dateTo) < taskDate) return false;
|
||
return true;
|
||
});
|
||
}
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
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) {
|
||
console.error('获取交叉评查任务列表失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '获取任务列表失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 删除交叉评查任务
|
||
* @param taskId 任务ID
|
||
* @returns 删除结果
|
||
*/
|
||
export async function deleteCrossCheckingTask(taskId: number): Promise<ApiResponse<boolean>> {
|
||
try {
|
||
// 模拟API延迟
|
||
await new Promise(resolve => setTimeout(resolve, 500));
|
||
|
||
// 这里应该调用实际的API来删除任务
|
||
// 目前暂时返回成功，因为没有实际的删除API
|
||
console.log(`尝试删除任务ID: ${taskId}`);
|
||
|
||
return {
|
||
success: true,
|
||
data: true,
|
||
message: '删除任务成功'
|
||
};
|
||
} catch (error) {
|
||
console.error('删除交叉评查任务失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '删除任务失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取任务详情及相关文档
|
||
* @param taskId 任务ID
|
||
* @param page 页码，默认为1
|
||
* @param pageSize 每页大小，默认为10
|
||
* @param jwtToken JWT token
|
||
* @returns 任务详情和文档列表
|
||
*/
|
||
export async function getCrossCheckingTaskDetail(
|
||
taskId: number,
|
||
page: number = 1,
|
||
pageSize: number = 10,
|
||
jwtToken?: string
|
||
): Promise<ApiResponse<{
|
||
task: CrossCheckingTask | null;
|
||
files: TaskDocument[];
|
||
total: number;
|
||
currentPage: number;
|
||
pageSize: number;
|
||
}>> {
|
||
try {
|
||
// console.log('开始调用getCrossCheckingTaskDetail，参数:', { taskId, page, pageSize });
|
||
|
||
// 获取任务的文档列表
|
||
const taskDocumentsResponse = await getTaskDocuments(taskId, page, pageSize, jwtToken);
|
||
|
||
if (!taskDocumentsResponse.success || !taskDocumentsResponse.data) {
|
||
console.error('获取任务文档失败:', taskDocumentsResponse.error);
|
||
return {
|
||
success: false,
|
||
error: taskDocumentsResponse.error || '获取任务文档失败'
|
||
};
|
||
}
|
||
|
||
const documentsData = taskDocumentsResponse.data;
|
||
|
||
const result = {
|
||
success: true,
|
||
data: {
|
||
task: null, // 暂时不返回任务详情，因为新接口主要关注文档列表
|
||
files: documentsData.items,
|
||
total: documentsData.total,
|
||
currentPage: documentsData.page,
|
||
pageSize: documentsData.page_size
|
||
}
|
||
};
|
||
|
||
return result;
|
||
} catch (error) {
|
||
console.error('获取任务详情失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '获取任务详情失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取统计数据
|
||
* @param userInfo 用户信息
|
||
* @param jwtToken JWT token
|
||
* @returns 统计数据
|
||
*/
|
||
export async function getCrossCheckingStats(userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<{
|
||
totalTasks: number;
|
||
pendingTasks: number;
|
||
inProgressTasks: number;
|
||
completedTasks: number;
|
||
}>> {
|
||
try {
|
||
console.log('开始调用getCrossCheckingStats');
|
||
|
||
// 获取用户任务数据来计算统计（默认获取第一页数据进行统计）
|
||
const userTasksResponse = await getUserTaskDocuments({ page: 1, pageSize: 100 }, jwtToken);
|
||
|
||
if (!userTasksResponse.success || !userTasksResponse.data) {
|
||
console.error('获取用户任务失败:', userTasksResponse.error);
|
||
return {
|
||
success: false,
|
||
error: userTasksResponse.error || '获取用户任务失败'
|
||
};
|
||
}
|
||
|
||
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;
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
totalTasks,
|
||
pendingTasks,
|
||
inProgressTasks,
|
||
completedTasks
|
||
}
|
||
};
|
||
} catch (error) {
|
||
console.error('获取统计数据失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '获取统计数据失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
// ==================== 更新：用户任务文档相关接口 ====================
|
||
|
||
/**
|
||
* 获取用户参与的所有任务列表（更新为新的API格式）
|
||
* @param page 页码
|
||
* @param pageSize 每页大小
|
||
* @param jwtToken JWT token
|
||
* @returns 用户任务列表
|
||
*/
|
||
export async function getUserTaskDocuments(params: TaskListParams = {}, jwtToken?: string): Promise<ApiResponse<UserTaskApiResponse>> {
|
||
try {
|
||
const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
|
||
const url = `${base}/api/v3/cross-review/tasks/query`;
|
||
|
||
const page = params.page || 1;
|
||
const pageSize = params.pageSize || 10;
|
||
const requestBody: Record<string, unknown> = {
|
||
page,
|
||
pageSize
|
||
};
|
||
|
||
if (params.keyword?.trim()) {
|
||
requestBody.keyword = params.keyword.trim();
|
||
}
|
||
if (params.status && params.status !== 'all') {
|
||
requestBody.status = params.status;
|
||
}
|
||
if (params.taskType && params.taskType !== 'all') {
|
||
requestBody.taskType = params.taskType;
|
||
}
|
||
if (params.docType && params.docType !== 'all') {
|
||
requestBody.docTypeCode = params.docType;
|
||
}
|
||
|
||
const response = await axios.post<ResultEnvelope<V3UserTaskPage>>(url, requestBody, {
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'Authorization': `Bearer ${jwtToken || ''}`
|
||
}
|
||
});
|
||
|
||
const pageData = unwrapResultEnvelope<V3UserTaskPage>(response.data);
|
||
const items = Array.isArray(pageData?.items) ? pageData.items.map(mapV3TaskToUserTaskInfo) : [];
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
total: pageData?.total || 0,
|
||
page: pageData?.page || page,
|
||
page_size: pageData?.pageSize || pageSize,
|
||
items
|
||
}
|
||
};
|
||
} catch (error) {
|
||
if (axios.isAxiosError(error)) {
|
||
return {
|
||
success: false,
|
||
error: `HTTP ${error.response?.status}: ${error.response?.statusText || error.message}`
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
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}/api/v3/cross-review/tasks/${taskId}/documents`;
|
||
|
||
const response = await axios.get<ResultEnvelope<V3TaskDocumentPage>>(url, {
|
||
params: {
|
||
page,
|
||
pageSize
|
||
},
|
||
headers: {
|
||
'Authorization': `Bearer ${jwtToken || ''}`
|
||
}
|
||
});
|
||
|
||
const pageData = unwrapResultEnvelope<V3TaskDocumentPage>(response.data);
|
||
const items = Array.isArray(pageData?.items) ? pageData.items.map(mapV3DocumentToTaskDocument) : [];
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
total: pageData?.total || 0,
|
||
page: pageData?.page || page,
|
||
page_size: pageData?.pageSize || pageSize,
|
||
items
|
||
}
|
||
};
|
||
} catch (error) {
|
||
if (axios.isAxiosError(error)) {
|
||
return {
|
||
success: false,
|
||
error: `HTTP ${error.response?.status}: ${error.response?.statusText || error.message}`
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '获取任务文档列表失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取任务下文档列表（支持版本归纳）
|
||
*
|
||
* GET /api/v3/cross-review/tasks/{task_id}/documents
|
||
*
|
||
* 同一任务内同名且同类型的文档会被归纳为版本组，最新上传的为当前版本，其余为历史版本。
|
||
*
|
||
* @param params 请求参数
|
||
* @returns 文档列表响应（含版本信息）
|
||
*/
|
||
export async function getTaskDocumentsWithVersions(
|
||
params: GetTaskDocumentsWithVersionsParams
|
||
): Promise<ApiResponse<CrossReviewDocumentListResponse>> {
|
||
const { taskId, page = 1, pageSize = 10, keyword, jwtToken } = params;
|
||
|
||
try {
|
||
const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
|
||
const url = `${base}/api/v3/cross-review/tasks/${taskId}/documents`;
|
||
|
||
const queryParams: {
|
||
page: number;
|
||
pageSize: number;
|
||
keyword?: string;
|
||
} = {
|
||
page,
|
||
pageSize
|
||
};
|
||
|
||
// 只有当 keyword 有值时才添加
|
||
if (keyword && keyword.trim()) {
|
||
queryParams.keyword = keyword.trim();
|
||
}
|
||
|
||
const response = await axios.get<ResultEnvelope<V3TaskDocumentPage>>(url, {
|
||
params: queryParams,
|
||
headers: {
|
||
'Authorization': `Bearer ${jwtToken || ''}`
|
||
}
|
||
});
|
||
|
||
const pageData = unwrapResultEnvelope<V3TaskDocumentPage>(response.data);
|
||
const documents = Array.isArray(pageData?.items) ? pageData.items.map(mapV3DocumentToVersionedDocument) : [];
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
total: pageData?.total || 0,
|
||
page: pageData?.page || page,
|
||
page_size: pageData?.pageSize || pageSize,
|
||
total_pages: Math.ceil((pageData?.total || 0) / (pageData?.pageSize || pageSize || 1)),
|
||
documents
|
||
}
|
||
};
|
||
} catch (error) {
|
||
if (axios.isAxiosError(error)) {
|
||
// 处理特定错误码
|
||
if (error.response?.status === 403) {
|
||
return {
|
||
success: false,
|
||
error: '无权访问任务：您不是该任务的参与者',
|
||
status: 403
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: `HTTP ${error.response?.status}: ${error.response?.statusText || error.message}`,
|
||
status: error.response?.status
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '获取任务文档列表失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* 更新文件的审核状态
|
||
* @param id 文件ID
|
||
* @param auditStatus 审核状态
|
||
* @returns 更新结果
|
||
*/
|
||
export async function updateDocumentAuditStatus(id: string, auditStatus: number, frontendJWT?: string): Promise<{
|
||
success?: boolean;
|
||
error?: string;
|
||
status?: number;
|
||
}> {
|
||
try {
|
||
if (!id) {
|
||
return { error: '文件ID不能为空', status: 400 };
|
||
}
|
||
|
||
const response = await postgrestPut<TaskDocument, Partial<TaskDocument>>(
|
||
'/api/postgrest/proxy/documents',
|
||
{ audit_status: auditStatus },
|
||
{
|
||
id: parseInt(id)
|
||
},
|
||
frontendJWT
|
||
);
|
||
|
||
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
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取可用于交叉评查的文档类型列表
|
||
* 条件：evaluation_point_groups_ids 不为空
|
||
* @param jwtToken JWT token
|
||
* @returns 文档类型列表
|
||
*/
|
||
export async function getCrossCheckingDocumentTypes(jwtToken?: string): Promise<ApiResponse<DocumentType[]>> {
|
||
try {
|
||
const response = await axios.get<{ data?: Array<{
|
||
id: number;
|
||
name: string;
|
||
code: string;
|
||
isEnabled?: boolean;
|
||
ruleSetIds?: number[];
|
||
}> }>(`${API_BASE_URL}/api/document-types`, {
|
||
headers: jwtToken ? { Authorization: `Bearer ${jwtToken}` } : undefined,
|
||
});
|
||
const rawItems = Array.isArray(response.data?.data) ? response.data.data : [];
|
||
const filteredData = rawItems
|
||
.filter((item) => item && item.isEnabled !== false)
|
||
.map((item) => ({
|
||
id: item.id,
|
||
name: item.name,
|
||
code: item.code,
|
||
}))
|
||
.sort((a, b) => a.name.localeCompare(b.name, 'zh-CN'));
|
||
|
||
return {
|
||
success: true,
|
||
data: filteredData
|
||
};
|
||
} catch (error) {
|
||
console.error('[getCrossCheckingDocumentTypes] 获取交叉评查文档类型失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '获取文档类型失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
|
||
// ==================== 追加附件 API ====================
|
||
|
||
/**
|
||
* 追加附件响应接口
|
||
*/
|
||
export interface AppendAttachmentsResponse {
|
||
success: boolean;
|
||
result?: {
|
||
original_document_id: number;
|
||
new_document_id: number;
|
||
new_version_number: number;
|
||
task_id: number;
|
||
message: string;
|
||
background_processing: boolean;
|
||
};
|
||
error?: string;
|
||
}
|
||
|
||
/**
|
||
* 追加附件参数接口
|
||
*/
|
||
export interface AppendAttachmentsParams {
|
||
/** 任务ID */
|
||
taskId: number;
|
||
/** 原文档ID */
|
||
documentId: number;
|
||
/** 附件文件列表 */
|
||
files: File[];
|
||
/** 备注说明（可选） */
|
||
remark?: string;
|
||
/** Word附件是否使用Markdown处理（可选，默认false） */
|
||
useMarkdown?: boolean;
|
||
/** JWT Token */
|
||
jwtToken?: string;
|
||
}
|
||
|
||
/**
|
||
* 为交叉评查任务文档追加附件
|
||
*
|
||
* POST /api/v2/cross_review/tasks/{task_id}/documents/{document_id}/append_attachments
|
||
*
|
||
* 追加附件后创建新文档（新版本），原文档保留。
|
||
* 新文档自动关联到当前任务，audit_status = 0（需重新评查）
|
||
*
|
||
* @param params 追加附件参数
|
||
* @returns 追加结果
|
||
*/
|
||
export async function appendTaskDocumentAttachments(
|
||
params: AppendAttachmentsParams
|
||
): Promise<ApiResponse<AppendAttachmentsResponse>> {
|
||
const { taskId, documentId, files, remark, useMarkdown = false, jwtToken } = params;
|
||
|
||
try {
|
||
if (!taskId || taskId <= 0) {
|
||
return { success: false, error: '任务ID无效' };
|
||
}
|
||
if (!documentId || documentId <= 0) {
|
||
return { success: false, error: '文档ID无效' };
|
||
}
|
||
if (!files || files.length === 0) {
|
||
return { success: false, error: '请选择附件文件' };
|
||
}
|
||
|
||
// 构建 FormData
|
||
const formData = new FormData();
|
||
files.forEach(file => {
|
||
formData.append('files', file);
|
||
});
|
||
if (remark) {
|
||
formData.append('remark', remark);
|
||
}
|
||
formData.append('use_markdown', useMarkdown.toString());
|
||
|
||
// 构建请求 URL
|
||
const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
|
||
const url = `${base}/api/v2/cross_review/tasks/${taskId}/documents/${documentId}/append_attachments`;
|
||
|
||
const response = await axios.post<AppendAttachmentsResponse>(url, formData, {
|
||
headers: {
|
||
'Content-Type': 'multipart/form-data',
|
||
'Authorization': `Bearer ${jwtToken || ''}`
|
||
}
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
data: response.data
|
||
};
|
||
} catch (error) {
|
||
if (axios.isAxiosError(error)) {
|
||
if (error.response?.status === 403) {
|
||
return {
|
||
success: false,
|
||
error: '无权追加附件：您不是任务创建者或负责人',
|
||
status: 403
|
||
};
|
||
}
|
||
if (error.response?.status === 400) {
|
||
return {
|
||
success: false,
|
||
error: error.response.data?.error || '请求参数错误',
|
||
status: 400
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: `HTTP ${error.response?.status}: ${error.response?.statusText || error.message}`,
|
||
status: error.response?.status
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '追加附件失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
|
||
// ==================== 上传模板 API ====================
|
||
|
||
/**
|
||
* 上传模板响应接口（文档级别）
|
||
*/
|
||
export interface UploadDocumentTemplateResponse {
|
||
success: boolean;
|
||
result?: {
|
||
document_id: number;
|
||
comparison_id: number;
|
||
template_name: string;
|
||
template_path: string;
|
||
status: string;
|
||
message: string;
|
||
};
|
||
error?: string;
|
||
}
|
||
|
||
/**
|
||
* 上传模板参数接口（文档级别）
|
||
*/
|
||
export interface UploadDocumentTemplateParams {
|
||
/** 文档ID */
|
||
documentId: number;
|
||
/** 模板文件 */
|
||
file: File;
|
||
/** 对比记录ID（可选，用于更新已有模板） */
|
||
comparisonId?: number;
|
||
/** JWT Token */
|
||
jwtToken?: string;
|
||
}
|
||
|
||
/**
|
||
* 为交叉评查任务中的文档上传模板（文档级别）
|
||
*
|
||
* 复用现有的 /upload_contract_template 接口，与 files-upload.ts 中的 uploadContractTemplate 保持一致
|
||
*
|
||
* @param params 上传模板参数
|
||
* @returns 上传结果
|
||
*/
|
||
export async function uploadCrossReviewDocumentTemplate(
|
||
params: UploadDocumentTemplateParams
|
||
): Promise<ApiResponse<UploadDocumentTemplateResponse>> {
|
||
const { documentId, file, comparisonId, jwtToken } = params;
|
||
|
||
try {
|
||
if (!documentId || documentId <= 0) {
|
||
return { success: false, error: '文档ID无效' };
|
||
}
|
||
if (!file) {
|
||
return { success: false, error: '请选择模板文件' };
|
||
}
|
||
|
||
// 构建 FormData，与 files-upload.ts 中的 uploadContractTemplate 保持一致
|
||
const formData = new FormData();
|
||
formData.append('file', file);
|
||
|
||
// upload_info 作为 JSON 字符串
|
||
const uploadInfo: { document_id: number; comparison_id?: number } = {
|
||
document_id: documentId
|
||
};
|
||
if (comparisonId) {
|
||
uploadInfo.comparison_id = comparisonId;
|
||
}
|
||
formData.append('upload_info', JSON.stringify(uploadInfo));
|
||
|
||
// 使用与 files-upload.ts 相同的上传接口
|
||
const { UPLOAD_URL } = await import('~/config/api-config');
|
||
const url = `${UPLOAD_URL}/upload_contract_template`;
|
||
|
||
const response = await axios.post<UploadDocumentTemplateResponse>(url, formData, {
|
||
headers: {
|
||
'Accept': 'application/json',
|
||
'Authorization': `Bearer ${jwtToken || ''}`
|
||
}
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
data: response.data
|
||
};
|
||
} catch (error) {
|
||
if (axios.isAxiosError(error)) {
|
||
if (error.response?.status === 403) {
|
||
return {
|
||
success: false,
|
||
error: '无权上传模板',
|
||
status: 403
|
||
};
|
||
}
|
||
if (error.response?.status === 400) {
|
||
return {
|
||
success: false,
|
||
error: error.response.data?.error || '请求参数错误',
|
||
status: 400
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: `HTTP ${error.response?.status}: ${error.response?.statusText || error.message}`,
|
||
status: error.response?.status
|
||
};
|
||
}
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : '上传模板失败'
|
||
};
|
||
}
|
||
}
|