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

app/api/cross-checking/cross-file-result.ts

@@ -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

@@ -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
+    };
+  }
+}

app/api/evaluation_points/reviews.ts

@@ -1,6 +1,7 @@
 import { postgrestGet, type PostgrestParams, postgrestPut, postgrestPost } from "../postgrest-client";
-import {getDocument} from "~/api/files/documents";
+import {getDocumentWithNoUserId} from "~/api/files/documents";
 import dayjs from "dayjs";
+import { getUserSession } from "~/api/login/auth.server";
 // import { formatDate } from "~/utils";
   
 /**
@@ -125,11 +126,22 @@ interface ScoringProposal {
 /**
  * 获取当前评查文件的所有评查点结果
  * @param fileId 评查文件ID
+ * @param request Remix请求对象，用于获取用户会话
  * @returns 评查点结果列表和统计数据
  */ 
-export async function getReviewPoints(fileId: string, userId: string) {
+export async function getReviewPoints(fileId: string, request: Request) {
+    // 获取用户会话信息
+    const { userInfo } = await getUserSession(request);
+    
+    if (!userInfo?.user_id) {
+        console.error("用户身份验证失败");
+        return { error: '用户身份验证失败', status: 401 };
+    }
+    
+    // const userId = userInfo.user_id.toString();
+    
     // 首先先获取这个文档的数据
-    const documentData = await getDocument(fileId);
+    const documentData = await getDocumentWithNoUserId(fileId);
     if (documentData.error) {
       console.error("获取文档数据错误:", documentData.error);
       return Response.json({ error: documentData.error }, { status: documentData.status || 500 });
@@ -722,14 +734,31 @@ export async function getReviewPoints(fileId: string, userId: string) {
  * @param editAuditStatusId 审核状态ID
  * @param result 评查结果 (true/false)
  * @param message 评查意见
+ * @param request Remix请求对象，用于获取用户会话
  * @returns 更新后的评查结果
  */
-export async function updateReviewResult(resultId: string, editAuditStatusId: string | number, result: string, message: string): Promise<{
+export async function updateReviewResult(
+  resultId: string, 
+  editAuditStatusId: string | number, 
+  result: string, 
+  message: string,
+  request: Request
+): Promise<{
   data?: unknown;
   error?: string;
   status?: number;
 }> {
   try {
+    // 获取用户会话信息
+    const { userInfo } = await getUserSession(request);
+    
+    if (!userInfo?.user_id) {
+      console.error("用户身份验证失败");
+      return { error: '用户身份验证失败', status: 401 };
+    }
+    
+    const userId = userInfo.user_id;
+    
     if (!resultId) {
       return { error: '评查结果ID不能为空', status: 400 };
     }
@@ -794,7 +823,10 @@ export async function updateReviewResult(resultId: string, editAuditStatusId: st
           // 重新审核时不更新message
           ...(isReview ? {} : { message })
         },
-        { id: editAuditStatusId }
+        { 
+          id: editAuditStatusId,
+          user_id: userId // 添加用户ID条件，确保只能更新自己的记录
+        }
       );
       
       if (auditStatusResponse.error) {
@@ -812,7 +844,8 @@ export async function updateReviewResult(resultId: string, editAuditStatusId: st
         evaluation_point_id: evaluationPointId,
         evaluation_result_id: resultId,
         edit_audit_status: editAuditStatusValue,
-        message: isReview ? '' : message
+        message: isReview ? '' : message,
+        user_id: userId // 添加用户ID
       };
       
       // 使用postgrestPost创建新记录
@@ -842,14 +875,25 @@ export async function updateReviewResult(resultId: string, editAuditStatusId: st
 /**
  * 确认评查结果并更新文档审核状态 只更新文档的审核状态为通过
  * @param documentId 文档ID
+ * @param request Remix请求对象，用于获取用户会话
  * @returns 更新结果
  */
-export async function confirmReviewResults(documentId: string): Promise<{
+export async function confirmReviewResults(documentId: string, request: Request): Promise<{
   data?: { auditStatus: number; };
   error?: string;
   status?: number;
 }> {
   try {
+    // 获取用户会话信息
+    const { userInfo } = await getUserSession(request);
+    
+    if (!userInfo?.user_id) {
+      console.error("用户身份验证失败");
+      return { error: '用户身份验证失败', status: 401 };
+    }
+    
+    const userId = userInfo.user_id;
+    
     if (!documentId) {
       return { error: '文档ID不能为空', status: 400 };
     }
@@ -881,7 +925,10 @@ export async function confirmReviewResults(documentId: string): Promise<{
     const response = await postgrestPut<{ id: string }, typeof updateDocumentParams>(
       'documents',
       updateDocumentParams,
-      { id: documentId }
+      { 
+        id: documentId,
+        user_id: userId // 添加用户ID条件，确保只能更新自己的文档
+      }
     );
     
     if (response.error) {

app/api/files/documents.ts

@@ -396,6 +396,56 @@ export async function getDocument(id: string, userId: string): Promise<{
   }
 }
 
+
+/**
+ * 获取单个文档详情
+ * @param id 文档ID
+ * @returns 文档详情
+ */
+export async function getDocumentWithNoUserId(id: string): Promise<{
+  data?: DocumentUI;
+  error?: string;
+  status?: number;
+}> {
+  try {
+    if (!id) {
+      return { error: '文档ID不能为空', status: 400 };
+    }
+    
+    const response = await postgrestGet<Document[]>(
+      'documents',
+      {
+        filter: {
+          'id': `eq.${id}`,
+        },
+        limit: 1
+      }
+    );
+    
+    if (response.error) {
+      return { error: response.error, status: response.status };
+    }
+    
+    const extractedData = extractApiData<Document[]>(response.data);
+    if (!extractedData || extractedData.length === 0) {
+      return { error: '文档不存在', status: 404 };
+    }
+    
+    // console.log('extractedData', extractedData);
+    const documentUI = await convertToUIDocument(extractedData[0]);
+    
+    return { data: documentUI };
+  } catch (error) {
+    console.error('获取文档详情失败:', error);
+    return {
+      error: error instanceof Error ? error.message : '获取文档详情失败',
+      status: 500
+    };
+  }
+}
+
+
+
 /**
  * 获取文件下载链接
  * @param filePath 文件路径

app/api/files/files-upload.ts

@@ -133,6 +133,7 @@ export async function uploadFileToBinary(file: File): Promise<ArrayBuffer> {
  * @param isTestDocument 是否为测试文档
  * @param documentId 关联的文档ID（用于合同附件上传）
  * @param isReupload 是否为重新上传
+ * @param jwtToken JWT token
  * @returns 上传结果
  */
 export async function uploadDocumentToServer(
@@ -145,7 +146,8 @@ export async function uploadDocumentToServer(
   remark?: string | null,
   isTestDocument: boolean = false,
   documentId?: number | null,
-  isReupload: boolean = false
+  isReupload: boolean = false,
+  jwtToken?: string
 ): Promise<{data: FileUploadResponse; error?: never} | {data?: never; error: string; status?: number}> {
   try {
     // console.log('【调试】开始上传文档:', { fileName, fileSize: binaryData.byteLength });
@@ -185,7 +187,8 @@ export async function uploadDocumentToServer(
       const response = await fetch(uploadUrl, {
         method: 'POST',
         headers: {
-          'X-File-Name': encodeURIComponent(fileName)
+          'X-File-Name': encodeURIComponent(fileName),
+          'Authorization': `Bearer ${jwtToken || ''}`
         },
         body: formData
       });
@@ -242,11 +245,20 @@ export async function uploadDocumentToServer(
 
 /**
  * 获取当天的文档列表
+ * @param userInfo 用户信息（必需）
  * @param reviewType 审核类型（可选）
  * @returns 文档列表
  */
-export async function getTodayDocuments(reviewType?: string): Promise<{data: Document[]; error?: never} | {data?: never; error: string; status?: number}> {
+export async function getTodayDocuments(userInfo?: { user_id?: number; [key: string]: unknown }, reviewType?: string): Promise<{data: Document[]; error?: never} | {data?: never; error: string; status?: number}> {
   try {
+    // 检查用户信息是否存在
+    if (!userInfo?.user_id) {
+      return {
+        error: '没有找到用户信息，请刷新重试',
+        status: 401
+      };
+    }
+
     const today = dayjs().startOf('day').format('YYYY-MM-DD');
     // console.log('查询当天文档，日期范围:', today);
     
@@ -276,10 +288,12 @@ export async function getTodayDocuments(reviewType?: string): Promise<{data: Doc
           order: 'created_at.desc',
           filter: {
             'created_at': `gte.${today}`,
-            'type_id': 'eq.1'
+            'type_id': 'eq.1',
+            'user_id': `eq.${userInfo.user_id}`
           }
         };
 
+
         // 查询contract_structure_comparison表中的数据
         // const comparisonParams: PostgrestParams = {
         //   select: `
@@ -391,7 +405,8 @@ export async function getTodayDocuments(reviewType?: string): Promise<{data: Doc
       `,
       order: 'created_at.desc',
       filter: {
-        'created_at': `gte.${today}`
+        'created_at': `gte.${today}`,
+        'user_id': `eq.${userInfo.user_id}`
       }
     };
 

app/api/login/auth.server.ts

@@ -20,6 +20,7 @@
 import { createCookieSessionStorage } from "@remix-run/node";
 import { tokenManager } from "./token-manager.server";
 import { postgrestGet, postgrestPost, postgrestPut } from "../postgrest-client";
+import { JWTUtils, type UserInfoForJWT } from "~/utils/jwt";
 
 /**
  * 用户角色类型定义
@@ -132,6 +133,56 @@ export async function getSession(request: Request) {
  *   - isTokenExpired: Token 是否已过期
  *   - refreshedSession: 如果刷新了 Token，返回更新后的会话对象
  */
+/**
+ * 生成前端JWT
+ * @param userInfo 用户信息
+ * @param expiresIn OAuth token过期时间（秒）
+ * @returns JWT字符串
+ */
+async function generateFrontendJWT(userInfo: UserInfo, savedUserData: SsoUser, userRole: UserRole, expiresIn: number): Promise<string> {
+  const jwtUserInfo: UserInfoForJWT = {
+    sub: userInfo.sub,
+    user_id: savedUserData.id!,
+    username: savedUserData.username,
+    nick_name: savedUserData.nick_name,
+    email: savedUserData.email,
+    phone_number: savedUserData.phone_number,
+    ou_id: savedUserData.ou_id,
+    ou_name: savedUserData.ou_name,
+    is_leader: savedUserData.is_leader,
+    user_role: userRole
+  };
+
+  return JWTUtils.generateJWT(jwtUserInfo, expiresIn);
+}
+
+/**
+ * 创建包含JWT的用户信息对象
+ * @param userInfo OAuth用户信息
+ * @param savedUserData 数据库中保存的用户数据
+ * @param userRole 用户角色
+ * @param frontendJWT 前端JWT
+ * @returns 完整的用户信息对象
+ */
+function createUserInfoWithJWT(userInfo: UserInfo, savedUserData: SsoUser, userRole: UserRole, frontendJWT: string) {
+  return {
+    // 保持与callback.tsx中enhancedUserInfo相同的数据结构
+    sub: userInfo.sub,
+    username: savedUserData.username,
+    nick_name: savedUserData.nick_name,
+    phone_number: savedUserData.phone_number,
+    email: savedUserData.email,
+    ou_id: savedUserData.ou_id,
+    ou_name: savedUserData.ou_name,
+    status: savedUserData.status,
+    is_leader: savedUserData.is_leader,
+    // 增强字段，与OAuth登录保持一致
+    user_id: savedUserData.id,
+    user_role: userRole,
+    frontend_jwt: frontendJWT
+  };
+}
+
 export async function getUserSession(request: Request) {
   const session = await getSession(request);
   const isAuthenticated = session.get("isAuthenticated") === true;
@@ -141,9 +192,11 @@ export async function getUserSession(request: Request) {
   let tokenIssuedAt = session.get("tokenIssuedAt");
   let tokenExpiresIn = session.get("tokenExpiresIn");
   const userInfo = session.get("userInfo");
+  let frontendJWT = session.get("frontendJWT");
   
   let isTokenExpired = false;
   let refreshedSession = null;
+  let shouldRegenerateJWT = false;
   
   // 如果有token信息，检查是否需要刷新
   if (accessToken && refreshToken && tokenIssuedAt && tokenExpiresIn) {
@@ -175,6 +228,9 @@ export async function getUserSession(request: Request) {
           tokenIssuedAt = newToken.tokenIssuedAt;
           tokenExpiresIn = newToken.tokenExpiresIn;
           
+          // 标记需要重新生成JWT
+          shouldRegenerateJWT = true;
+          
           refreshedSession = session;
         }
         
@@ -189,6 +245,77 @@ export async function getUserSession(request: Request) {
     }
   }
   
+  // 检查前端JWT状态
+  if (isAuthenticated && !isTokenExpired && userInfo) {
+    let needsJWTRefresh = false;
+    
+    // 检查是否有前端JWT
+    if (!frontendJWT) {
+      needsJWTRefresh = true;
+      console.log("缺少前端JWT，需要生成");
+    } else {
+      // 检查JWT是否即将过期
+      if (JWTUtils.isJWTExpiringSoon(frontendJWT)) {
+        needsJWTRefresh = true;
+        console.log("前端JWT即将过期，需要重新生成");
+      }
+    }
+    
+    // 如果OAuth token被刷新了，也需要重新生成JWT
+    if (shouldRegenerateJWT) {
+      needsJWTRefresh = true;
+      console.log("OAuth token已刷新，需要重新生成JWT");
+    }
+    
+    // 重新生成JWT
+    if (needsJWTRefresh && tokenExpiresIn) {
+      try {
+        // 从userInfo中获取用户数据
+        if (userInfo.user_id && userInfo.sub) {
+          const mockSavedUserData: SsoUser = {
+            id: userInfo.user_id,
+            sub: userInfo.sub,
+            username: userInfo.username || userInfo.sub,
+            nick_name: userInfo.nick_name || "未知用户",
+            phone_number: userInfo.phone_number,
+            email: userInfo.email,
+            ou_id: userInfo.ou_id || "default",
+            ou_name: userInfo.ou_name || "未知部门",
+            status: 0,
+            is_leader: userInfo.is_leader || false
+          };
+          
+          const newJWT = await generateFrontendJWT(userInfo, mockSavedUserData, userRole, tokenExpiresIn);
+          
+          // 打印JWT重新生成信息
+          console.log("=== Token刷新时重新生成JWT ===");
+          console.log("原始userInfo:", userInfo);
+          console.log("重构的用户数据:", mockSavedUserData);
+          console.log("用户角色:", userRole);
+          console.log("新生成的JWT:", newJWT);
+          console.log("JWT过期时间:", JWTUtils.getJWTExpiration(newJWT));
+          
+          // 更新session中的JWT
+          if (!refreshedSession) {
+            refreshedSession = session;
+          }
+          refreshedSession.set("frontendJWT", newJWT);
+          
+          // 更新userInfo以包含新的JWT
+          const updatedUserInfo = createUserInfoWithJWT(userInfo, mockSavedUserData, userRole, newJWT);
+          refreshedSession.set("userInfo", updatedUserInfo);
+          
+          console.log("更新后的userInfo:", updatedUserInfo);
+          console.log("=== JWT重新生成完成 ===");
+          
+          frontendJWT = newJWT;
+        }
+      } catch (error) {
+        console.error("生成前端JWT失败:", error);
+      }
+    }
+  }
+  
   return {
     isAuthenticated: isAuthenticated && !isTokenExpired,
     userRole,
@@ -196,7 +323,8 @@ export async function getUserSession(request: Request) {
     refreshToken,
     userInfo,
     isTokenExpired,
-    refreshedSession // 如果刷新了token，返回更新后的session
+    refreshedSession, // 如果刷新了token，返回更新后的session
+    frontendJWT // 返回前端JWT
   };
 }