fixed

app/api/client.ts

@@ -14,9 +14,9 @@ export type ApiResponse<T> = {
 export type QueryParams = Record<string, string | number | boolean | undefined>;
 
 // 获取 API 基础 URL
-// const API_BASE_URL = '172.18.0.100:3000';
-// const API_BASE_URL = '172.16.0.119:9000/admin';
-export const API_BASE_URL = 'http://nas.7bm.co:3000';
+const API_BASE_URL = 'http://172.18.0.100:3000';
+// const API_BASE_URL = 'http://172.16.0.119:9000/admin';
+// export const API_BASE_URL = 'http://nas.7bm.co:3000';
 
 // 是否使用模拟数据（开发环境使用）
 const USE_MOCK_DATA = false; // 设置为true使用模拟数据，避免API连接问题

app/api/evaluation_points/reviews.ts

@@ -0,0 +1,237 @@
+import { postgrestGet, type PostgrestParams } from "../postgrest-client";
+import dayjs from 'dayjs';
+
+/**
+ * 格式化日期
+ * @param dateString 日期字符串
+ * @returns 格式化后的日期字符串
+ */
+function formatDate(dateString: string): string {
+    if (!dateString) return '';
+    try {
+      return dayjs(dateString).format('YYYY-MM-DD HH:mm:ss');
+    } catch (error) {
+      console.error('日期格式化失败:', error);
+      return dateString;
+    }
+  }
+  
+/**
+ * 从不同格式的 API 响应中提取数据
+ * @param responseData API 响应数据
+ * @returns 提取后的数据或 null
+ */
+function extractApiData<T>(responseData: unknown): T | null {
+if (!responseData) return null;
+
+// 格式1: { code: number, msg: string, data: T }
+if (typeof responseData === 'object' && responseData !== null && 
+    'code' in responseData && 
+    'data' in responseData && 
+    (responseData as { data: unknown }).data) {
+    return (responseData as { data: T }).data;
+}
+
+// 格式2: 直接是数据对象
+return responseData as T;
+}
+
+// 定义评查结果类型
+interface EvaluationResult {
+  id: string | number;
+  document_id: string | number;
+  evaluation_point_id: string | number;
+  evaluated_results?: {
+    result?: boolean;
+    message?: string;
+    data?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+// 定义评查点类型
+interface EvaluationPoint {
+  id: string | number;
+  evaluation_point_groups_id: string | number;
+  suggestion_message_type?: string;
+  suggestion_message?: string;
+  score?: number;
+  [key: string]: unknown;
+}
+
+// 定义评查点组类型
+interface EvaluationPointGroup {
+  id: string | number;
+  name?: string;
+  [key: string]: unknown;
+}
+
+// 定义前端使用的评查点结果类型
+interface ReviewPointResult {
+  id: string | number;
+  title: string;
+  groupName: string;
+  status: string;
+  content: string;
+  suggestion: string;
+  result?: boolean;
+  score: number;
+}
+
+// 定义统计数据类型
+interface StatsData {
+  total: number;
+  success: number;
+  warning: number;
+  error: number;
+  score: number;
+}
+
+/**
+ * 获取当前评查文件的所有评查点结果
+ * @param fileId 评查文件ID
+ * @returns 评查点结果列表和统计数据
+ */
+export async function getReviewPoints(fileId: string) {
+    // 步骤1：根据fileId查询evaluation_results表
+    const evaluationResultsParams: PostgrestParams = {
+        select: '*',
+        filter: {
+            'document_id': `eq.${fileId}`
+        }
+    };
+    const evaluationResultsResponse = await postgrestGet('evaluation_results', evaluationResultsParams);
+
+    if (evaluationResultsResponse.error) {
+        return { error: evaluationResultsResponse.error, status: evaluationResultsResponse.status };
+    }
+
+    const evaluationResultsData = extractApiData<EvaluationResult[]>(evaluationResultsResponse.data);
+    
+    if (!evaluationResultsData || !Array.isArray(evaluationResultsData)) {
+        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
+    }
+
+    // 收集所有评查点ID，用于查询评查点详情
+    const evaluationPointIds = evaluationResultsData.map(item => item.evaluation_point_id).filter(Boolean);
+    
+    if (evaluationPointIds.length === 0) {
+        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
+    }
+
+    // 步骤2：根据evaluation_point_id查询evaluation_points表
+    const evaluationPointsParams: PostgrestParams = {
+        select: '*',
+        filter: {
+            'id': `in.(${evaluationPointIds.join(',')})`
+        }
+    };
+    const evaluationPointsResponse = await postgrestGet('evaluation_points', evaluationPointsParams);
+
+    if (evaluationPointsResponse.error) {
+        return { error: evaluationPointsResponse.error, status: evaluationPointsResponse.status };
+    }
+
+    const evaluationPointsData = extractApiData<EvaluationPoint[]>(evaluationPointsResponse.data);
+    
+    if (!evaluationPointsData || !Array.isArray(evaluationPointsData)) {
+        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
+    }
+
+    // 收集所有评查点组ID，用于查询评查点组详情
+    const groupIds = evaluationPointsData.map(item => item.evaluation_point_groups_id).filter(Boolean);
+
+    if (groupIds.length === 0) {
+        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
+    }
+
+    // 查询评查点组
+    const groupsParams: PostgrestParams = {
+        select: '*',
+        filter: {
+            'id': `in.(${groupIds.join(',')})`
+        }
+    };
+    const groupsResponse = await postgrestGet('evaluation_point_groups', groupsParams);
+
+    if (groupsResponse.error) {
+        return { error: groupsResponse.error, status: groupsResponse.status };
+    }
+
+    const groupsData = extractApiData<EvaluationPointGroup[]>(groupsResponse.data);
+    
+    if (!groupsData || !Array.isArray(groupsData)) {
+        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
+    }
+
+    // 创建映射关系以便快速查找
+    const pointsMap = new Map<string | number, EvaluationPoint>();
+    evaluationPointsData.forEach(point => {
+        pointsMap.set(point.id, point);
+    });
+
+    // console.log('pointsMap-------', pointsMap);
+
+    const groupsMap = new Map<string | number, EvaluationPointGroup>();
+    groupsData.forEach(group => {
+        groupsMap.set(group.id, group);
+    });
+
+    // console.log('groupsMap-------', groupsMap);
+
+    // 构建前端所需的数据格式
+    const resultData: ReviewPointResult[] = evaluationResultsData.map(result => {
+        const point = pointsMap.get(result.evaluation_point_id) || {} as EvaluationPoint;
+        const group = groupsMap.get(point.evaluation_point_groups_id || 0) || {} as EvaluationPointGroup;
+        
+        // 从 evaluated_results 中提取数据
+        let message = '';
+        let data = '';
+        
+        if (result.evaluated_results && typeof result.evaluated_results === 'object') {
+            message = result.evaluated_results.message || '';
+            data = result.evaluated_results.data || '';
+        }
+
+        return {
+            id: result.id,
+            title: message,
+            groupName: group.name || '',
+            status: point.suggestion_message_type || '',
+            content: data,
+            suggestion: point.suggestion_message || '',
+            result: result.evaluated_results?.result, // 记录评查结果，用于统计
+            score: point.score || 0
+        };
+    });
+
+    // 统计数据
+    const stats: StatsData = {
+        total: evaluationResultsData.length,
+        success: 0,
+        warning: 0,
+        error: 0,
+        score: 0
+    };
+
+    // 计算统计数据
+    resultData.forEach(item => {
+        // 成功数量统计
+        if (item.result === true) {
+            stats.success += 1;
+        } else if (item.result === false) {
+            // 警告和错误数量统计
+            if (item.status === 'warning') {
+                stats.warning += 1;
+            } else if (item.status === 'error') {
+                stats.error += 1;
+            }
+        }
+        
+        // 分数统计
+        stats.score += item.score || 0;
+    });
+
+    return { data: resultData, stats };
+}

app/api/evaluation_points/rules-files.ts

@@ -0,0 +1,371 @@
+import { postgrestGet, postgrestPut, type PostgrestParams } from '../postgrest-client';
+import dayjs from 'dayjs';
+import { getDocumentTypes } from '../document-types/document-types';
+import type { DocumentTypeUI } from '../document-types/document-types';
+import weekday from 'dayjs/plugin/weekday';
+import updateLocale from 'dayjs/plugin/updateLocale';
+
+// 配置 dayjs
+dayjs.extend(weekday);
+dayjs.extend(updateLocale);
+// 设置一周的第一天为周一
+dayjs.updateLocale('en', {
+  weekStart: 1
+});
+
+// 文档数据库表接口
+export interface Document {
+  id: number;
+  user_id: number | null;
+  type_id: number;
+  name: string;
+  document_number: string;
+  path: string;
+  storage_type: string;
+  file_size: number;
+  upload_time: string;
+  is_test_document: boolean;
+  evaluation_level: string;
+  status: string;
+  ocr_result: Record<string, unknown>;
+  extracted_results: Record<string, unknown> | null;
+  sumary: string | null;
+  remark: string;
+  created_at: string;
+  updated_at: string;
+  evaluations_status: number | null;
+  audit_status: number | null;
+}
+
+// 文档类型接口
+export interface DocumentType {
+  id: number;
+  name: string;
+  description: string | null;
+  status: number;
+  created_at: string;
+  updated_at: string;
+}
+
+// 评查文件UI接口
+export interface ReviewFileUI {
+  id: string;
+  fileName: string;
+  fileCode: string;
+  fileType: string;
+  fileTypeId: number;
+  fileSize: number;
+  uploadTime: string;
+  reviewStatus: string;
+  reviewStatusCode: number;
+  issueCount: number;
+  issues: Array<{
+    severity: 'info' | 'warning' | 'error' | 'critical';
+    message: string;
+  }>;
+  createdBy: string;
+}
+
+// 文件列表搜索参数
+export interface DocumentSearchParams {
+  fileType?: string; // 文件类型ID
+  reviewStatus?: string; // 评查状态
+  dateRange?: string; // 日期范围
+  keyword?: string; // 搜索关键字
+  sortOrder?: string; // 排序方式
+  page?: number; // 当前页码
+  pageSize?: number; // 每页条数
+}
+
+/**
+ * 格式化日期
+ * @param dateString 日期字符串
+ * @returns 格式化后的日期字符串
+ */
+function formatDate(dateString: string): string {
+  if (!dateString) return '';
+  try {
+    return dayjs(dateString).format('YYYY-MM-DD HH:mm:ss');
+  } catch (error) {
+    console.error('日期格式化失败:', error);
+    return dateString;
+  }
+}
+
+/**
+ * 从不同格式的 API 响应中提取数据
+ * @param responseData API 响应数据
+ * @returns 提取后的数据或 null
+ */
+function extractApiData<T>(responseData: unknown): T | null {
+  if (!responseData) return null;
+  
+  // 格式1: { code: number, msg: string, data: T }
+  if (typeof responseData === 'object' && responseData !== null && 
+      'code' in responseData && 
+      'data' in responseData && 
+      (responseData as { data: unknown }).data) {
+    return (responseData as { data: T }).data;
+  }
+  
+  // 格式2: 直接是数据对象
+  return responseData as T;
+}
+
+/**
+ * 将评查状态代码映射到UI状态
+ * @param status 评查状态代码
+ * @returns UI状态
+ */
+export function mapReviewStatusToUI(status: number | null): string {
+  switch(status) {
+    case 1: return 'pass';
+    case 2: return 'warning';
+    case -1: return 'fail';
+    case 0: return 'pending';
+    default: return 'pending';
+  }
+}
+
+/**
+ * 将UI状态映射到评查状态代码
+ * @param status UI状态
+ * @returns 评查状态代码
+ */
+export function mapUIToReviewStatus(status: string): number {
+  switch(status) {
+    case 'pass': return 1;
+    case 'warning': return 2;
+    case 'fail': return -1;
+    case 'pending': return 0;
+    default: return 0;
+  }
+}
+
+/**
+ * 获取文件扩展名
+ * @param fileName 文件名
+ * @returns 文件扩展名
+ */
+export function getFileExtension(fileName: string): string {
+  return fileName.split('.').pop()?.toLowerCase() || '';
+}
+
+/**
+ * 将数据库文档转换为UI文件对象
+ * @param document 数据库文档
+ * @param documentTypeName 文档类型名称
+ * @returns UI文件对象
+ */
+export function convertToReviewFileUI(document: Document, documentTypeName: string): ReviewFileUI {
+  const reviewStatus = mapReviewStatusToUI(document.evaluations_status);
+  
+  const reviewFileUI: ReviewFileUI = {
+    id: document.id.toString(),
+    fileName: document.name,
+    fileCode: document.document_number,
+    fileType: documentTypeName,
+    fileTypeId: document.type_id,
+    fileSize: document.file_size,
+    uploadTime: formatDate(document.created_at),
+    reviewStatus: reviewStatus,
+    reviewStatusCode: document.evaluations_status || 0,
+    issueCount: 0,
+    issues: [],
+    createdBy: document.user_id?.toString() || '系统'
+  };
+
+//   console.log('reviewFileUI-----',reviewFileUI);
+
+  return reviewFileUI;
+}
+
+/**
+ * 获取评查文件列表
+ * @param searchParams 搜索参数
+ * @returns 评查文件列表和总数
+ */
+export async function getReviewFiles(searchParams: DocumentSearchParams = {}): Promise<{
+  data?: { files: ReviewFileUI[], total: number };
+  error?: string;
+  status?: number;
+}> {
+  try {
+    const page = searchParams.page || 1;
+    const pageSize = searchParams.pageSize || 10;
+    
+    // 构建查询参数
+    const params: PostgrestParams = {
+      select: '*',
+      order: 'created_at.desc',
+      headers: {
+        'Prefer': 'count=exact'
+      },
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+      filter: {} as Record<string, string>
+    };
+    
+    // 根据排序方式设置排序
+    if (searchParams.sortOrder) {
+      switch (searchParams.sortOrder) {
+        case 'upload_time_desc':
+          params.order = 'created_at.desc';
+          break;
+        case 'upload_time_asc':
+          params.order = 'created_at.asc';
+          break;
+        // 其他排序方式可以在这里添加
+      }
+    }
+    
+    // 添加筛选条件
+    const filter: Record<string, string> = {};
+    
+    if (searchParams.fileType) {
+      filter['type_id'] = `eq.${searchParams.fileType}`;
+    }
+    
+    if (searchParams.reviewStatus) {
+      const statusValue = mapUIToReviewStatus(searchParams.reviewStatus);
+      filter['evaluations_status'] = `eq.${statusValue}`;
+    }
+    
+    if (searchParams.keyword) {
+      filter['or'] = `(name.ilike.%${searchParams.keyword}%,document_number.ilike.%${searchParams.keyword}%)`;
+    }
+    
+    // 处理日期范围筛选
+    if (searchParams.dateRange) {
+      const now = dayjs();
+      const today = now.startOf('day').format('YYYY-MM-DD HH:mm:ss');
+      switch (searchParams.dateRange) {
+        case 'today':
+          filter['created_at'] = `gte.${today}`;
+          break;
+        case 'week': {
+          const weekStart = now.startOf('week').format('YYYY-MM-DD HH:mm:ss');
+          filter['created_at'] = `gte.${weekStart}`;
+          break;
+        }
+        case 'month': {
+          const monthStart = now.startOf('month').format('YYYY-MM-DD HH:mm:ss');
+          filter['created_at'] = `gte.${monthStart}`;
+          break;
+        }
+      }
+    }
+    
+    // console.log('filter-----',filter);
+    params.filter = filter;
+    
+    // 发送API请求获取文档列表
+    const response = await postgrestGet<Document[]>('documents', params);
+    
+    if (response.error) {
+      return { error: response.error, status: response.status };
+    }
+    
+    // 提取API返回的数据
+    const extractedDocuments = extractApiData<Document[]>(response.data);
+    
+    if (!extractedDocuments) {
+      return { error: '获取评查文件数据失败', status: 500 };
+    }
+    
+    // 从响应头中获取总数
+    let totalCount = 0;
+    const responseWithHeaders = response as { data: Document[]; headers: Record<string, string> };
+    if(responseWithHeaders.headers){
+      const rangeHeader = responseWithHeaders.headers['content-range'];
+      if(rangeHeader){
+        const total = rangeHeader.split('/')[1];
+        if(total !== '*'){
+          totalCount = parseInt(total, 10);
+        }
+      }
+    }
+    
+    // 获取文档类型数据，用于查找文档类型名称
+    const documentTypesResponse = await getDocumentTypes({pageSize: 500});
+    const documentTypes = documentTypesResponse.data?.types || [];
+    
+    // 创建文档类型ID到名称的映射
+    const typeNameMap: Record<number, string> = {};
+    documentTypes.forEach((type: DocumentTypeUI) => {
+      typeNameMap[type.id] = type.name;
+    });
+    
+    // 将文档数据转换为UI文件对象
+    const reviewFiles = extractedDocuments.map(doc => {
+      const typeName = typeNameMap[doc.type_id] || '未知类型';
+      return convertToReviewFileUI(doc, typeName);
+    });
+    
+    return {
+      data: {
+        files: reviewFiles,
+        total: totalCount
+      }
+    };
+  } catch (error) {
+    console.error('获取评查文件列表失败:', error);
+    return {
+      error: error instanceof Error ? error.message : '获取评查文件列表失败',
+      status: 500
+    };
+  }
+}
+
+/**
+ * 更新文件的评查状态
+ * @param id 文件ID
+ * @param status 评查状态
+ * @returns 更新后的文件信息
+ */
+export async function updateReviewStatus(id: string, status: string): Promise<{
+  data?: ReviewFileUI;
+  error?: string;
+  status?: number;
+}> {
+  try {
+    if (!id) {
+      return { error: '文件ID不能为空', status: 400 };
+    }
+    
+    const statusValue = mapUIToReviewStatus(status);
+    
+    const response = await postgrestPut<Document, Partial<Document>>(
+      'documents',
+      { evaluations_status: statusValue },
+      { id: parseInt(id) }
+    );
+    
+    if (response.error) {
+      return { error: response.error, status: response.status };
+    }
+    
+    const extractedData = extractApiData<Document>(response.data);
+    
+    if (!extractedData) {
+      return { error: '更新评查状态失败', status: 500 };
+    }
+    
+    // 获取文档类型，用于查找文档类型名称
+    const documentTypesResponse = await getDocumentTypes({pageSize: 500});
+    const documentTypes = documentTypesResponse.data?.types || [];
+    
+    // 查找文档类型名称
+    const docType = documentTypes.find((type: DocumentTypeUI) => type.id === extractedData.type_id);
+    const typeName = docType ? docType.name : '未知类型';
+    
+    return { data: convertToReviewFileUI(extractedData, typeName) };
+  } catch (error) {
+    console.error('更新评查状态失败:', error);
+    return {
+      error: error instanceof Error ? error.message : '更新评查状态失败',
+      status: 500
+    };
+  }
+}
+

app/api/files/documents.ts

@@ -71,10 +71,14 @@ export interface Document {
   status: 'pass' | 'warning' | 'waiting' | 'processing' | 'fail';
   file_status: 'Waiting' | 'Cutting' | 'Extractioning' | 'Evaluationing' | 'Processed';
   audit_status: number; // -1: 不通过, 0: 待审核, 1: 通过, 2: 警告, 3: 审核中
-  ocr_result: unknown;
-  extracted_results: unknown;
-  summary: unknown;
-  remark: string;
+  ocr_result?: {
+    __meta?: {
+      page_count?: number;
+    }
+  };
+  extracted_results?: unknown;
+  summary?: unknown;
+  remark?: string;
   created_at: string;
   updated_at: string;
 }
@@ -96,6 +100,8 @@ export interface DocumentUI {
   fileType: string;
   path: string;
   isTest: boolean;
+  updatedAt?: string;
+  pageCount?: number;
 }
 
 /**
@@ -124,13 +130,15 @@ async function convertToUIDocument(doc: Document): Promise<DocumentUI> {
     type: doc.type_id.toString(),
     typeName: docType?.name || '未知类型',
     size: doc.file_size,
-    auditStatus: doc.audit_status,
+    auditStatus: doc.audit_status || 0,
     fileStatus: doc.status || '', // 默认为''
     issues: 0, // 固定为0
     uploadTime: formatDate(doc.updated_at),
     fileType: getFileExtension(doc.name),
     path: doc.path,
-    isTest: doc.is_test_document
+    isTest: doc.is_test_document,
+    updatedAt: formatDate(doc.updated_at),
+    pageCount: doc.ocr_result?.__meta?.page_count || 0
   };
 }
 
@@ -204,7 +212,7 @@ export async function getDocuments(searchParams: DocumentSearchParams = {}): Pro
       }
     }
     
-    console.log('filter-----', filter);
+    // console.log('filter-----', filter);
     params.filter = filter;
     
     // 发送请求