555 lines
16 KiB
TypeScript
555 lines
16 KiB
TypeScript
import { API_BASE_URL } from '../../config/api-config';
|
|
|
|
// 交叉评查任务状态枚举
|
|
export enum CrossCheckingTaskStatus {
|
|
PENDING = 'pending',
|
|
IN_PROGRESS = 'in_progress',
|
|
COMPLETED = 'completed'
|
|
}
|
|
|
|
// 交叉评查任务类型枚举
|
|
export enum CrossCheckingTaskType {
|
|
CITY = 'city',
|
|
COUNTY = 'county'
|
|
}
|
|
|
|
// 案卷类型枚举
|
|
export enum CrossCheckingDocType {
|
|
PENALTY = 'penalty', // 行政处罚
|
|
PERMIT = 'permit' // 行政许可
|
|
}
|
|
|
|
// 交叉评查任务接口
|
|
export interface CrossCheckingTask {
|
|
id: number;
|
|
sequence: number;
|
|
taskName: string;
|
|
startDate: string;
|
|
taskType: CrossCheckingTaskType;
|
|
docType: CrossCheckingDocType; // 案卷类型
|
|
evaluationRegion: string;
|
|
progress: number;
|
|
status: CrossCheckingTaskStatus;
|
|
score: number;
|
|
operation: string;
|
|
documentIds: number[];
|
|
}
|
|
|
|
// 用户任务文档接口类型定义
|
|
export interface UserTaskDocument {
|
|
document_id: number;
|
|
document_name: string;
|
|
document_type_id: number;
|
|
document_type_name: string;
|
|
}
|
|
|
|
// 用户任务信息接口
|
|
export interface UserTaskInfo {
|
|
task_id: number;
|
|
task_status: string;
|
|
documents: UserTaskDocument[];
|
|
}
|
|
|
|
// 用户任务API响应格式
|
|
export interface UserTaskApiResponse {
|
|
data: UserTaskInfo[];
|
|
pagination: {
|
|
page: number;
|
|
page_size: number;
|
|
total: number;
|
|
total_pages: number;
|
|
};
|
|
}
|
|
|
|
// API响应格式
|
|
export interface ApiResponse<T> {
|
|
success: boolean;
|
|
data?: T;
|
|
error?: string;
|
|
message?: string;
|
|
status?: number;
|
|
}
|
|
|
|
// 任务列表查询参数
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* 模拟数据 - 临时使用
|
|
*/
|
|
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 查询参数
|
|
* @returns 任务列表响应
|
|
*/
|
|
export async function getCrossCheckingTasks(params: TaskListParams = {}): Promise<ApiResponse<TaskListResponse>> {
|
|
try {
|
|
console.log('开始调用getCrossCheckingTasks，参数:', params);
|
|
|
|
// 调用用户任务API，获取当前用户参与的任务
|
|
const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
|
|
|
|
console.log('getUserTaskDocuments响应:', userTasksResponse);
|
|
|
|
if (!userTasksResponse.success || !userTasksResponse.data) {
|
|
console.error('获取用户任务失败:', userTasksResponse.error);
|
|
return {
|
|
success: false,
|
|
error: userTasksResponse.error || '获取用户任务失败'
|
|
};
|
|
}
|
|
|
|
// 将用户任务数据转换为CrossCheckingTask格式
|
|
const userTasks = userTasksResponse.data;
|
|
const convertedTasks: CrossCheckingTask[] = userTasks.map((userTask: UserTaskInfo, index: number) => {
|
|
// 从用户任务中提取任务信息，如果没有对应信息则使用默认值
|
|
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,
|
|
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)
|
|
};
|
|
return task;
|
|
});
|
|
|
|
const {
|
|
page = 1,
|
|
pageSize = 10,
|
|
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.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;
|
|
});
|
|
}
|
|
|
|
// 分页处理
|
|
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
|
|
}
|
|
};
|
|
} catch (error) {
|
|
console.error('获取交叉评查任务列表失败:', error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '获取任务列表失败'
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 创建新的交叉评查任务
|
|
* @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
|
|
* @returns 删除结果
|
|
*/
|
|
export async function deleteCrossCheckingTask(taskId: number): Promise<ApiResponse<boolean>> {
|
|
try {
|
|
// 模拟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);
|
|
|
|
return {
|
|
success: true,
|
|
data: true,
|
|
message: '删除任务成功'
|
|
};
|
|
} catch (error) {
|
|
console.error('删除交叉评查任务失败:', error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '删除任务失败'
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取任务详情及相关文档
|
|
* @param taskId 任务ID
|
|
* @param documentIds 指定的文档ID数组，用于筛选任务包含的文档
|
|
* @param page 页码，默认为1
|
|
* @param pageSize 每页大小，默认为10
|
|
* @returns 任务详情和文档列表
|
|
*/
|
|
export async function getCrossCheckingTaskDetail(
|
|
taskId: number,
|
|
documentIds: number[],
|
|
page: number = 1,
|
|
pageSize: number = 10
|
|
): Promise<ApiResponse<{
|
|
task: CrossCheckingTask;
|
|
files: import('../evaluation_points/rules-files').ReviewFileUI[];
|
|
total: number;
|
|
}>> {
|
|
try {
|
|
// 从用户任务API中获取任务信息
|
|
const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
|
|
|
|
if (!userTasksResponse.success || !userTasksResponse.data) {
|
|
console.error('获取用户任务失败:', userTasksResponse.error);
|
|
return {
|
|
success: false,
|
|
error: userTasksResponse.error || '获取用户任务失败'
|
|
};
|
|
}
|
|
|
|
// 查找指定的任务
|
|
const userTask = userTasksResponse.data.find(t => t.task_id === taskId);
|
|
if (!userTask) {
|
|
return {
|
|
success: false,
|
|
error: '任务不存在'
|
|
};
|
|
}
|
|
|
|
// 将用户任务转换为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 {
|
|
success: true,
|
|
data: {
|
|
task,
|
|
files,
|
|
total
|
|
}
|
|
};
|
|
} catch (error) {
|
|
console.error('获取任务详情失败:', error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '获取任务详情失败'
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取统计数据
|
|
* @returns 统计数据
|
|
*/
|
|
export async function getCrossCheckingStats(): Promise<ApiResponse<{
|
|
totalTasks: number;
|
|
pendingTasks: number;
|
|
inProgressTasks: number;
|
|
completedTasks: number;
|
|
}>> {
|
|
try {
|
|
console.log('开始调用getCrossCheckingStats');
|
|
|
|
// 获取用户任务数据来计算统计
|
|
const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
|
|
|
|
if (!userTasksResponse.success || !userTasksResponse.data) {
|
|
console.error('获取用户任务失败:', userTasksResponse.error);
|
|
return {
|
|
success: false,
|
|
error: userTasksResponse.error || '获取用户任务失败'
|
|
};
|
|
}
|
|
|
|
const userTasks = userTasksResponse.data;
|
|
const totalTasks = userTasks.length;
|
|
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 : '获取统计数据失败'
|
|
};
|
|
}
|
|
}
|
|
|
|
// ==================== 新增：用户任务文档相关接口 ====================
|
|
|
|
/**
|
|
* 获取用户参与的所有任务及文档
|
|
* @param userId 用户ID
|
|
* @returns 用户任务及文档列表
|
|
*/
|
|
export async function getUserTaskDocuments(userId: number): Promise<ApiResponse<UserTaskInfo[]>> {
|
|
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 response = await fetch(url, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ user_id: userId })
|
|
});
|
|
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
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : '获取用户任务及文档失败'
|
|
};
|
|
}
|
|
}
|