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

添加登录内容，尚未完善，先创建分支

Browse Source
This commit is contained in:
yorn
2025-07-14 12:31:43 +08:00
parent e3109423d4
commit fff474f46b
25 changed files with 2693 additions and 1102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/api/axios-client.ts
+1 -1
View File
@@ -301,7 +301,7 @@ export async function apiRequest<T>(
// 检查API返回的状态码
const data = response.data;
if (data && 'code' in data && data.code !== 0) {
if (data && typeof data === 'object' && 'code' in data && data.code !== 0) {
console.error(`API请求失败: ${data.message || data.msg || '未知错误'} - ${url}`);
return {
error: data.message || data.msg || '请求失败',
app/api/evaluation_points/reviews.ts
+51 -1
View File
@@ -103,6 +103,12 @@ interface OcrData {
[key: string]: unknown;
}
interface ContractStructureComparison {
id: string | number;
document_id: string | number;
[key: string]: unknown;
}
/**
* 获取当前评查文件的所有评查点结果
* @param fileId 评查文件ID
@@ -116,6 +122,49 @@ export async function getReviewPoints(fileId: string) {
return Response.json({ error: documentData.error }, { status: documentData.status || 500 });
}
// 其次需要查询这个文档关联的文档附件，查询contract_structure_comparison表
const contractStructureComparisonParams: PostgrestParams = {
select: '*',
filter: {
'document_id': `eq.${fileId}`
},
order: 'id.desc',
limit: 1
};
const contractStructureComparisonResponse = await postgrestGet('contract_structure_comparison', contractStructureComparisonParams);
if (contractStructureComparisonResponse.error) {
console.error("获取文档附件数据错误:", contractStructureComparisonResponse.error);
return Response.json({ error: contractStructureComparisonResponse.error }, { status: contractStructureComparisonResponse.status || 500 });
}
const contractStructureComparisonData = extractApiData<ContractStructureComparison[]>(contractStructureComparisonResponse.data);
// console.log('文档附件的数据', JSON.stringify(contractStructureComparisonData, null, 2));
// 解析比对结果
let comparisonDocument = null;
if (contractStructureComparisonData && contractStructureComparisonData.length > 0) {
comparisonDocument = contractStructureComparisonData[0];
// 测试：将合同封面中的status改为abnormal
// (comparisonDocument.comparison_results as Record<string, Array<{ status: string; [key: string]: unknown }>>)['合同封面'][0]['status'] = 'abnormal';
// 如果 comparison_results 是字符串，尝试解析为 JSON
if (comparisonDocument.comparison_results && typeof comparisonDocument.comparison_results === 'string') {
try {
comparisonDocument.comparison_results = JSON.parse(comparisonDocument.comparison_results);
} catch (e) {
console.error('解析比对结果失败:', e);
comparisonDocument.comparison_results = null;
}
}
}else{
comparisonDocument = {
template_contract_path: '',
}
}
// console.log('documentData-------', documentData);
// 步骤1：根据fileId查询evaluation_results表
const evaluationResultsParams: PostgrestParams = {
select: '*',
@@ -125,6 +174,7 @@ export async function getReviewPoints(fileId: string) {
};
const evaluationResultsResponse = await postgrestGet('evaluation_results', evaluationResultsParams);
// console.log('evaluationResultsResponse-------', evaluationResultsResponse,);
if (evaluationResultsResponse.error) {
return { error: evaluationResultsResponse.error, status: evaluationResultsResponse.status };
}
@@ -622,7 +672,7 @@ export async function getReviewPoints(fileId: string) {
};
// console.log("reviewInfo-------",JSON.stringify(reviewInfo,null,2));
// data->reviewPoints stats->statistics reviewInfo->reviewInfo document->document
return { data: resultData, stats, reviewInfo, document: documentData.data };
return { data: resultData, stats, reviewInfo, document: documentData.data, comparison_document: comparisonDocument };
}
/**
app/api/evaluation_points/rules-files.ts
+142 -407
View File
@@ -1,19 +1,11 @@
import { postgrestGet, postgrestPut, type PostgrestParams } from '../postgrest-client';
import { postgrestPut, postgrestPost } from '../postgrest-client';
// import dayjs from 'dayjs';
import { getDocumentTypes } from '../document-types/document-types';
import type { DocumentTypeUI } from '../document-types/document-types';
// 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';
import { formatDate } from '../../utils';
// // 配置 dayjs
// dayjs.extend(weekday);
// dayjs.extend(updateLocale);
// // 设置一周的第一天为周一
// dayjs.updateLocale('en', {
// weekStart: 1
// });
// 文档数据库表接口
export interface Document {
id: number;
@@ -75,6 +67,33 @@ export interface ReviewFileUI {
manualCount: number;
}
// 数据库函数返回的评查文件结构
interface ReviewFileFromSQL {
id: number;
status: string;
path: string;
file_name: 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 | null;
created_by_user_id: number | null;
issue_count: number;
total_score: number;
pass_count: number;
warning_count: number;
fail_count: number;
manual_count: number;
issues: Array<{
severity: 'info' | 'warning' | 'error' | 'critical';
message: string;
}> | null;
}
// 文件列表搜索参数
export interface DocumentSearchParams {
fileType?: string; // 文件类型ID
@@ -90,56 +109,56 @@ export interface DocumentSearchParams {
// 添加评查结果和评查点类型定义
// 评查结果类型
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 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;
post_action?: string;
score?: number;
[key: string]: unknown;
}
// interface EvaluationPoint {
// id: string | number;
// post_action?: string;
// score?: number;
// [key: string]: unknown;
// }
// 文档评查状态结果
interface DocumentReviewResult {
status: number;
issueCount: number;
passCount: number;
warningCount: number;
failCount: number;
manualCount: number;
}
// interface DocumentReviewResult {
// status: number;
// issueCount: number;
// passCount: number;
// warningCount: number;
// failCount: number;
// manualCount: number;
// }
/**
* 从不同格式的 API 响应中提取数据
* @param responseData API 响应数据
* @returns 提取后的数据或 null
*/
function extractApiData<T>(responseData: unknown): T | null {
if (!responseData) return null;
// /**
// * 从不同格式的 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;
}
// // 格式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;
}
// // 格式2: 直接是数据对象
// return responseData as T;
// }
/**
* 将评查状态代码映射到UI状态
@@ -180,44 +199,6 @@ 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 {
// 将评查状态转换为UI状态（这个评查状态后续可能不需要，这里先预留）
const reviewStatus = mapReviewStatusToUI(document.evaluations_status);
const reviewFileUI: ReviewFileUI = {
id: document.id.toString(),
status: document.status,
path: document.path,
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,
score: 0,
auditStatus: document.audit_status,
issues: [],
createdBy: document.user_id?.toString() || '系统',
passCount: 0,
warningCount: 0,
failCount: 0,
manualCount: 0
};
// console.log('reviewFileUI-----',reviewFileUI);
return reviewFileUI;
}
/**
* 获取评查文件列表
* @param searchParams 搜索参数
@@ -229,334 +210,88 @@ export async function getReviewFiles(searchParams: DocumentSearchParams = {}): P
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;
// case 'issue_count_desc':
// params.order = 'issue_count.desc';
// break;
// case 'issue_count_asc':
// params.order = 'issue_count.asc';
// break;
}
}
// 添加筛选条件
const filter: Record<string, string> = {};
// 处理文件类型筛选
if (searchParams.fileType) {
// console.log('API处理文件类型筛选:', searchParams.fileType);
// 特殊处理 'record' 类型，表示 type_id 为 2 或 3
if (searchParams.fileType === 'record') {
filter['type_id'] = 'in.(2,3)';
const {
page = 1,
pageSize = 10,
keyword,
fileType, // sessionStorage.getItem('reviewType')
reviewStatus,
dateFrom,
dateTo,
sortOrder = 'upload_time_desc'
} = searchParams;
let p_typeid: number[] | null = null;
if (fileType) {
if (fileType === 'record') {
p_typeid = [2, 3];
} else if (fileType === 'contract') {
p_typeid = [1];
} else {
filter['type_id'] = `eq.${Number(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.dateFrom){
filter['created_at'] = `gte.${searchParams.dateFrom+ ' 00:00:00'}`;
}
if(searchParams.dateTo){
const dateToKey = searchParams.dateFrom ? 'and' : 'created_at';
if(dateToKey === 'and'){
delete filter['created_at'];
filter[dateToKey] = `(created_at.gte.${searchParams.dateFrom+' 00:00:00'},created_at.lte.${searchParams.dateTo+' 23:59:59'})`;
}else{
filter['created_at'] = `lte.${searchParams.dateTo+' 23:59:59'}`;
}
}
// 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;
// }
// }
// }
params.filter = filter;
// console.log('API请求参数:', params);
// 发送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 typeId = parseInt(fileType, 10);
if (!isNaN(typeId)) {
p_typeid = [typeId];
}
}
}
// 获取文档类型数据，用于查找文档类型名称
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;
});
// 获取评查文件的评查结果
// 第一步：收集所有文档ID
const documentIds = extractedDocuments.map(doc => doc.id);
// 第二步：查询所有文档的评查结果数据
const evaluationResultParams: PostgrestParams = {
select: '*',
filter: {
'document_id': `in.(${documentIds.join(',')})`
}
const rpcParams = {
p_keyword: keyword || null,
p_typeid: p_typeid,
p_evaluations_status: reviewStatus ? mapUIToReviewStatus(reviewStatus) : null,
p_date_from: dateFrom || null,
p_date_to: dateTo || null,
};
const evaluationResultsResponse = await postgrestGet('evaluation_results', evaluationResultParams);
let evaluationResults: EvaluationResult[] = [];
const listParams = {
...rpcParams,
p_page: page,
p_page_size: pageSize,
p_sort_order: sortOrder
};
// 并行执行获取数据和获取总数的请求
const [filesResponse, countResponse] = await Promise.all([
postgrestPost<ReviewFileFromSQL[]>('rpc/get_review_files_with_details', listParams),
postgrestPost<number>('rpc/count_review_files', rpcParams)
]);
if (!evaluationResultsResponse.error) {
evaluationResults = extractApiData<EvaluationResult[]>(evaluationResultsResponse.data) || [];
// 处理获取文档列表的错误
if (filesResponse.error || !filesResponse.data) {
return { error: filesResponse.error || '获取文档数据失败', status: filesResponse.status || 500 };
}
// 第三步：收集所有评查点ID
const evaluationPointIds = evaluationResults
.map(result => result.evaluation_point_id)
.filter(Boolean);
// 第四步：获取评查点数据
let evaluationPoints: EvaluationPoint[] = [];
if (evaluationPointIds.length > 0) {
const evaluationPointsParams: PostgrestParams = {
select: '*',
filter: {
'id': `in.(${evaluationPointIds.join(',')})`
}
};
const evaluationPointsResponse = await postgrestGet('evaluation_points', evaluationPointsParams);
if (!evaluationPointsResponse.error) {
evaluationPoints = extractApiData<EvaluationPoint[]>(evaluationPointsResponse.data) || [];
}
// 处理获取总数的错误
if (countResponse.error || typeof countResponse.data !== 'number') {
console.error('获取文档总数失败:', countResponse.error);
}
// 创建评查点ID到评查点数据的映射
const pointsMap = new Map<string | number, EvaluationPoint>();
evaluationPoints.forEach(point => {
pointsMap.set(point.id, point);
});
const totalCount = typeof countResponse.data === 'number' ? countResponse.data : 0;
// 创建文档ID到评查结果列表的映射
const documentResultsMap = new Map<string | number, EvaluationResult[]>();
evaluationResults.forEach(result => {
const docId = result.document_id;
if (!documentResultsMap.has(docId)) {
documentResultsMap.set(docId, []);
}
documentResultsMap.get(docId)!.push(result);
});
// 将SQL返回的数据转换为UI格式
const reviewFiles: ReviewFileUI[] = filesResponse.data.map((file: ReviewFileFromSQL) => ({
id: file.id.toString(),
status: file.status,
path: file.path,
fileName: file.file_name,
fileCode: file.file_code,
fileType: file.file_type_name,
fileTypeId: file.file_type_id,
fileSize: file.file_size,
uploadTime: formatDate(file.created_at),
reviewStatus: mapReviewStatusToUI(file.evaluations_status),
reviewStatusCode: file.evaluations_status,
issueCount: file.issue_count,
score: file.total_score,
auditStatus: file.audit_status,
issues: file.issues || [],
createdBy: file.created_by_user_id?.toString() || '系统',
passCount: file.pass_count,
warningCount: file.warning_count,
failCount: file.fail_count,
manualCount: file.manual_count,
}));
// 计算每个文档的评查状态和问题列表
const documentStatusMap = new Map<string | number, DocumentReviewResult>();
// 存储每个文档的问题消息
const documentIssuesMap = new Map<string | number, Array<{severity: 'info' | 'warning' | 'error' | 'critical', message: string}>>();
// 存储每个文档的分数
const documentScoreMap = new Map<string | number, number>();
documentIds.forEach(docId => {
const results = documentResultsMap.get(docId) || [];
// 1. 首先检查是否有需要人工审核的评查点
let hasManualReviewPoint = false;
let hasFailResult = false;
let totalScore = 0;
let totalPoints = 0;
let totalPassPoints = 0;
let totalWarningPoints = 0;
let totalFailPoints = 0;
let totalManualPoints = 0;
// 存储该文档的问题消息
const issuesList: Array<{severity: 'info' | 'warning' | 'error' | 'critical', message: string}> = [];
for (const result of results) {
const evaluatedResults = result.evaluated_results || {};
const resultValue = evaluatedResults.result;
const pointId = result.evaluation_point_id;
const point = pointsMap.get(pointId);
// 统计需要人工审核的评查点
if (point && point.post_action === 'manual') {
hasManualReviewPoint = true;
totalManualPoints++;
}
// 检查是否有不通过的结果
if (!resultValue) {
hasFailResult = true;
// 收集问题消息
if (evaluatedResults.message) {
issuesList.push({
severity: 'error',
message: evaluatedResults.message as string
});
}
// 统计不通过而且评查点是警告的评查点
if (point && (point.suggestion_message_type === 'warning' || point.suggestion_message_type === 'info')) {
totalWarningPoints++;
}else if (point && point.suggestion_message_type === 'error') {
totalFailPoints++;
}
}else{
totalPassPoints++;
}
// 计算总分
if (point) {
totalScore += point.score || 0;
totalPoints++;
}
}
// 保存文档的问题列表
documentIssuesMap.set(docId, issuesList);
// 计算并保存文档的分数
const calculatedScore = totalScore || 100;
documentScoreMap.set(docId, calculatedScore);
// 根据优先级确定评查状态
let status = 1; // 默认为通过
// 待人工确认优先级最高
if (hasManualReviewPoint) {
status = 0; // 待人工确认
}
// 警告次之
else if (hasFailResult) {
status = -2; // 警告
}
// 最后判断分数
else {
// 如果没有评查点，默认为通过
if (totalPoints > 0) {
// 通过分数线为80分
// status = totalScore >= 80 ? 1 : -1; // 通过或不通过
// 通过率为80%
status = parseFloat((totalPassPoints/totalPoints).toFixed(1)) >= 0.8 ? 1 : -1; // 通过或不通过
}
}
documentStatusMap.set(docId, {
status,
passCount: totalPassPoints,
warningCount: totalWarningPoints,
failCount: totalFailPoints,
manualCount: totalManualPoints,
issueCount: results.filter(r => r.evaluated_results?.result === false).length
});
});
// console.log("documentStatusMap-----",documentStatusMap);
// 将文档数据转换为UI文件对象，同时应用评查状态
const reviewFiles = extractedDocuments.map(doc => {
const typeName = typeNameMap[doc.type_id] || '未知类型';
const reviewResult = documentStatusMap.get(doc.id) || { status: doc.evaluations_status || 0, issueCount: 0, passCount: 0, warningCount: 0, failCount: 0, manualCount: 0 };
const issues = documentIssuesMap.get(doc.id) || [];
const score = documentScoreMap.get(doc.id) || 100; // 获取计算后的分数，默认为100
// 如果文档的评查状态与计算结果不同，更新文档的评查状态
if (doc.evaluations_status !== reviewResult.status) {
// 异步更新文档评查状态
postgrestPut('documents',
{ evaluations_status: reviewResult.status },
{ id: doc.id }
).catch(err => console.error(`更新文档${doc.id}评查状态失败:`, err));
}
const reviewFile = convertToReviewFileUI(doc, typeName);
// 覆盖文档的评查状态和问题计数
reviewFile.reviewStatusCode = reviewResult.status;
reviewFile.reviewStatus = mapReviewStatusToUI(reviewResult.status);
reviewFile.issueCount = reviewResult.issueCount;
reviewFile.passCount = reviewResult.passCount;
reviewFile.warningCount = reviewResult.warningCount;
reviewFile.failCount = reviewResult.failCount;
reviewFile.manualCount = reviewResult.manualCount;
reviewFile.score = score; // 添加分数
// 添加问题列表
reviewFile.issues = issues;
return reviewFile;
});
// console.log('reviewFiles-----',reviewFiles);
return {
data: {
files: reviewFiles,
@@ -620,7 +355,7 @@ export async function getReviewFiles(searchParams: DocumentSearchParams = {}): P
// return {
// error: error instanceof Error ? error.message : '更新评查状态失败',
// status: 500
// };
// }
// }
// }
app/api/files/documents.ts
+96 -112
View File
@@ -1,4 +1,4 @@
import { postgrestGet, postgrestDelete, postgrestPut, type PostgrestParams } from '../postgrest-client';
import { postgrestGet, postgrestDelete, postgrestPut, postgrestPost } from '../postgrest-client';
import { getDocumentTypes } from '../document-types/document-types';
import { formatDate } from '../../utils';
@@ -169,6 +169,29 @@ async function convertToUIDocument(doc: Document): Promise<DocumentUI> {
};
}
/**
* 后端SQL函数返回的文档结构
*/
interface DocumentFromSQL {
id: number;
name: string;
document_number: string;
type_id: number;
type_name: string;
file_size: number;
audit_status: number;
status: string;
false_count: number;
updated_at: string;
path: string;
is_test_document: boolean;
ocr_result: {
__meta?: {
page_count?: number;
}
};
}
/**
* 获取文档列表
* @param searchParams 搜索参数
@@ -180,124 +203,85 @@ export async function getDocuments(searchParams: DocumentSearchParams = {}): Pro
status?: number;
}> {
try {
const page = searchParams.page || 1;
const pageSize = searchParams.pageSize || 10;
// 构建查询参数
const params: PostgrestParams = {
select: '*',
order: 'updated_at.desc',
headers: {
'Prefer': 'count=exact'
},
limit: pageSize,
offset: (page - 1) * pageSize,
filter: {} as Record<string, string>
};
// 添加筛选条件
const filter: Record<string, string> = {};
if (searchParams.name) {
filter['name'] = `ilike.%${searchParams.name}%`;
}
if (searchParams.documentNumber) {
filter['document_number'] = `ilike.%${searchParams.documentNumber}%`;
}
if (searchParams.documentType) {
filter['type_id'] = `eq.${searchParams.documentType}`;
}
if (searchParams.auditStatus) {
// 处理"待审核"状态 - 特殊处理 audit_status = 0 的情况，同时包含 null 值
if (searchParams.auditStatus === '0') {
filter['or'] = `(audit_status.eq.0,audit_status.is.null)`;
} else {
filter['audit_status'] = `eq.${searchParams.auditStatus}`;
}
}
if (searchParams.fileStatus) {
filter['status'] = `eq.${searchParams.fileStatus}`;
}
// 处理日期范围
if (searchParams.dateFrom) {
// 添加当天开始时间 00:00:00
filter['updated_at'] = `gte.${searchParams.dateFrom + ' 00:00:00'}`;
}
if (searchParams.dateTo) {
// 如果有开始日期，使用and条件；否则直接设置结束日期
const dateToKey = searchParams.dateFrom ? 'and' : 'updated_at';
// 添加当天结束时间 23:59:59
if (dateToKey === 'and') {
delete filter['updated_at'];
// 使用OR操作符连接两个条件
filter[dateToKey] = `(updated_at.gte.${searchParams.dateFrom+' 00:00:00'},updated_at.lte.${searchParams.dateTo+' 23:59:59'})`;
} else {
filter['updated_at'] = `lte.${searchParams.dateTo+' 23:59:59'}`;
}
}
// 根据 reviewType 添加过滤条件
if (searchParams.reviewType) {
// 如果已经有文档类型过滤，则不再添加 reviewType 的过滤
if (!searchParams.documentType) {
if (searchParams.reviewType === 'contract') {
// 如果是合同类型，只显示 type_id=1 的文档
filter['type_id'] = 'eq.1';
} else if (searchParams.reviewType === 'record') {
// 如果是卷宗类型，只显示 type_id=2 或 type_id=3 的文档
filter['type_id'] = 'in.(2,3)';
}
}
}
// console.log('filter-----', filter);
params.filter = filter;
// 发送请求
const response = await postgrestGet<Document[]>('documents', params);
if (response.error) {
return { error: response.error, status: response.status };
}
// 提取数据
const extractedData = extractApiData<Document[]>(response.data);
if (!extractedData) {
return { error: '获取文档数据失败', status: 500 };
}
// console.log('extractedData---1--',extractedData[0]);
// 准备RPC调用参数
const {
page = 1,
pageSize = 10,
name,
documentNumber,
documentType,
auditStatus,
fileStatus,
dateFrom,
dateTo,
reviewType
} = searchParams;
// 转换为UI格式
const documents = await Promise.all(extractedData.map(convertToUIDocument));
// console.log('documentsItem',documents)
// 获取总数
let totalCount = 0;
const responseWithHeaders = response as {
data: unknown;
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);
}
let documentTypes: number[] | undefined;
if (documentType) {
documentTypes = [parseInt(documentType, 10)];
} else if (reviewType) {
if (reviewType === 'contract') {
documentTypes = [1];
} else if (reviewType === 'record') {
documentTypes = [2, 3];
}
}
const rpcParams = {
search_name: name,
search_document_number: documentNumber,
search_document_types: documentTypes,
search_audit_status: auditStatus !== undefined ? parseInt(auditStatus, 10) : undefined,
search_file_status: fileStatus,
search_date_from: dateFrom,
search_date_to: dateTo,
};
// 并行执行获取数据和获取总数的请求
const [documentsResponse, countResponse] = await Promise.all([
postgrestPost<DocumentFromSQL[], unknown>('rpc/get_documents_with_filters', { ...rpcParams, page, page_size: pageSize }),
postgrestPost<number, unknown>('rpc/count_documents_with_filters', rpcParams)
]);
// 处理获取文档列表的错误
if (documentsResponse.error || !documentsResponse.data) {
return { error: documentsResponse.error || '获取文档数据失败', status: documentsResponse.status || 500 };
}
// 处理获取总数的错误
if (countResponse.error || typeof countResponse.data !== 'number') {
// 如果计数失败，可以继续返回数据，但总数可能不准
console.error('获取文档总数失败:', countResponse.error);
}
// console.log('countResponse.data', countResponse.data);
const totalCount = typeof countResponse.data === 'number' ? countResponse.data : 0;
// 将SQL返回的数据转换为UI格式
const documents: DocumentUI[] = documentsResponse.data.map((doc: DocumentFromSQL) => ({
id: doc.id,
name: doc.name,
documentNumber: doc.document_number,
type: doc.type_id.toString(),
typeName: doc.type_name || '未知类型',
size: doc.file_size,
auditStatus: doc.audit_status ?? 0,
fileStatus: doc.status || '',
issues: doc.false_count ?? null,
uploadTime: formatDate(doc.updated_at),
fileType: getFileExtension(doc.name),
path: doc.path,
isTest: doc.is_test_document,
updatedAt: formatDate(doc.updated_at),
pageCount: doc.ocr_result?.__meta?.page_count || 0,
ocrResult: doc.ocr_result
}));
return {
data: {
documents,
total: totalCount || documents.length
total: totalCount
}
};
} catch (error) {
app/api/files/files-upload.ts
+205 -30
View File
@@ -70,6 +70,19 @@ export interface Document {
audit_status?: number;
}
// 合同结构比较表接口
export interface ContractStructureComparison {
id: number;
template_contract_name: string;
file_size: number;
status: DocumentStatus;
created_at: string;
document_id?: number;
template_contract_path?: string;
ocr_results?: Record<string, unknown>;
comparison_results?: Record<string, unknown>;
}
// 文件上传响应接口
export interface FileUploadResponse {
success: boolean;
@@ -118,6 +131,7 @@ export async function uploadFileToBinary(file: File): Promise<ArrayBuffer> {
* @param documentNumber 文档编号（可选）
* @param remark 备注信息（可选）
* @param isTestDocument 是否为测试文档
* @param documentId 关联的文档ID（用于合同附件上传）
* @returns 上传结果
*/
export async function uploadDocumentToServer(
@@ -128,7 +142,9 @@ export async function uploadDocumentToServer(
priority: string,
documentNumber?: string | null,
remark?: string | null,
isTestDocument: boolean = false
isTestDocument: boolean = false,
documentId?: number | null,
isReupload: boolean = false
): Promise<{data: FileUploadResponse; error?: never} | {data?: never; error: string; status?: number}> {
try {
// console.log('【调试】开始上传文档:', { fileName, fileSize: binaryData.byteLength });
@@ -147,22 +163,25 @@ export async function uploadDocumentToServer(
evaluation_level: priority,
document_number: documentNumber || null,
remark: remark || null,
is_test_document: isTestDocument
is_test_document: isTestDocument,
document_id: documentId || null,
is_reupload: isReupload
};
// 添加JSON字符串到FormData
formData.append('upload_info', JSON.stringify(uploadInfo));
// console.log('【调试】FormData准备完成:', JSON.stringify(uploadInfo));
// console.log('【调试】准备发送请求到服务器:', UPLOAD_URL);
// 根据是否有documentId决定使用哪个接口
const uploadEndpoint = documentId ? '/upload_contract_template' : '/upload';
const uploadUrl = UPLOAD_URL + uploadEndpoint;
// console.log('【调试】准备发送请求到服务器:', uploadUrl);
// 发送请求
// const response = await fetch(`${API_BASE_URL}/admin/documents/upload`, {
try {
// console.log('【调试】开始fetch请求...');
const response = await fetch(UPLOAD_URL, {
// const response = await fetch('http://172.16.0.55:8000/admin/documents/upload', {
// const response = await fetch('http://172.16.0.119:8000/admin/documents/upload', {
const response = await fetch(uploadUrl, {
method: 'POST',
headers: {
'X-File-Name': encodeURIComponent(fileName)
@@ -230,6 +249,126 @@ export async function getTodayDocuments(reviewType?: string): Promise<{data: Doc
const today = dayjs().startOf('day').format('YYYY-MM-DD');
// console.log('查询当天文档，日期范围:', today);
// 如果是合同类型，需要合并查询documents表和contract_structure_comparison表
if (reviewType === 'contract') {
try {
// 查询documents表中的合同数据
const documentsParams: PostgrestParams = {
select: `
id,
name,
type_id,
file_size,
status,
created_at,
document_number,
path,
storage_type,
is_test_document,
evaluation_level,
ocr_result,
extracted_results,
sumary,
remark,
audit_status
`,
order: 'created_at.desc',
filter: {
'created_at': `gte.${today}`,
'type_id': 'eq.1'
}
};
// 查询contract_structure_comparison表中的数据
// const comparisonParams: PostgrestParams = {
// select: `
// id,
// template_contract_name,
// file_size,
// status,
// created_at,
// document_id,
// template_contract_path,
// ocr_results,
// comparison_results
// `,
// order: 'created_at.desc',
// filter: {
// 'created_at': `gte.${today}`
// }
// };
// 并行查询两个表
// const [documentsResponse, comparisonResponse] = await Promise.all([
// postgrestGet<Document[]>('documents', documentsParams),
// postgrestGet<ContractStructureComparison[]>('contract_structure_comparison', comparisonParams)
// ]);
const documentsResponse = await postgrestGet<Document[]>('documents', documentsParams);
// console.log('documents表响应:', documentsResponse);
// console.log('contract_structure_comparison表响应:', comparisonResponse);
// if (documentsResponse.error && comparisonResponse.error) {
// console.error('两个表查询都失败:', documentsResponse.error, comparisonResponse.error);
// return { error: documentsResponse.error || comparisonResponse.error, status: documentsResponse.status || comparisonResponse.status };
// }
if (documentsResponse.error) {
console.error('documents表查询失败:', documentsResponse.error);
return { error: documentsResponse.error, status: documentsResponse.status };
}
// 提取documents表数据
let documentsData: Document[] = [];
if (!documentsResponse.error && documentsResponse.data) {
const extractedDocuments = extractApiData<Document[]>(documentsResponse.data);
if (extractedDocuments) {
documentsData = extractedDocuments;
}
}
// 提取contract_structure_comparison表数据并转换为Document格式
// let comparisonData: Document[] = [];
// if (!comparisonResponse.error && comparisonResponse.data) {
// const extractedComparison = extractApiData<ContractStructureComparison[]>(comparisonResponse.data);
// if (extractedComparison) {
// // 将ContractStructureComparison转换为Document格式
// console.log('extractedComparison:', extractedComparison);
// comparisonData = extractedComparison.map(item => ({
// id: item.id,
// name: item.template_contract_name || `合同结构比较记录_${item.id}`,
// type_id: 1, // 合同结构比较默认为合同类型
// file_size: item.file_size || 0,
// status: item.status,
// created_at: item.created_at,
// document_id: item.document_id,
// template_contract_path: item.template_contract_path,
// ocr_results: item.ocr_results,
// comparison_results: item.comparison_results
// }));
// }
// }
// 合并两个数据源
// const allData = [...documentsData, ...comparisonData];
const allData = [...documentsData];
// 按created_at降序排序
allData.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
// console.log('合并后的数据:', allData);
return { data: allData };
} catch (contractError) {
console.error('合同类型查询失败:', contractError);
return {
error: contractError instanceof Error ? contractError.message : '合同类型查询失败',
status: 500
};
}
}
// 非合同类型的原有逻辑
const params: PostgrestParams = {
select: `
id,
@@ -256,14 +395,7 @@ export async function getTodayDocuments(reviewType?: string): Promise<{data: Doc
};
// 根据reviewType添加过滤条件
if (reviewType === 'contract') {
// 如果是合同类型，只显示type_id=1的文档
if (params.filter) {
params.filter['type_id'] = 'eq.1';
} else {
params.filter = { 'type_id': 'eq.1' };
}
} else if (reviewType === 'record') {
if (reviewType === 'record') {
// 如果是卷宗类型，只显示type_id=2或type_id=3的文档
if (params.filter) {
params.filter['type_id'] = 'in.(2,3)';
@@ -352,33 +484,76 @@ export async function getDocumentTypes(reviewType?: string): Promise<{data: Docu
/**
* 获取指定文档的状态
* @param documentIds 文档ID列表
* @param attachmentIds 合同附件ID列表（可选）
* @returns 文档状态列表
*/
export async function getDocumentsStatus(documentIds: number[]): Promise<{data: Document[]; error?: never} | {data?: never; error: string; status?: number}> {
export async function getDocumentsStatus(
documentIds: number[],
attachmentIds?: number[]
): Promise<{data: Document[]; error?: never} | {data?: never; error: string; status?: number}> {
try {
if (!documentIds || documentIds.length === 0) {
if ((!documentIds || documentIds.length === 0) && (!attachmentIds || attachmentIds.length === 0)) {
return { data: [] };
}
const params: PostgrestParams = {
select: 'id, status',
filter: {
'id': `in.(${documentIds.join(',')})`
// 查询主文档状态
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let documentsResponse: any = { data: [], error: undefined, status: undefined };
if (documentIds && documentIds.length > 0) {
const documentsParams: PostgrestParams = {
select: 'id, status',
filter: {
'id': `in.(${documentIds.join(',')})`
}
};
documentsResponse = await postgrestGet<Document[]>('documents', documentsParams);
}
// 查询合同附件状态
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let attachmentResponse: any = { data: [], error: undefined, status: undefined };
if (attachmentIds && attachmentIds.length > 0) {
const attachmentParams: PostgrestParams = {
select: 'id, status',
filter: {
'id': `in.(${attachmentIds.join(',')})`
}
};
attachmentResponse = await postgrestGet<ContractStructureComparison[]>('contract_structure_comparison', attachmentParams);
}
if (documentsResponse.error && attachmentResponse.error) {
return { error: documentsResponse.error || attachmentResponse.error, status: documentsResponse.status || attachmentResponse.status };
}
let allData: Document[] = [];
// 处理主文档数据
if (!documentsResponse.error && documentsResponse.data) {
const extractedDocuments = extractApiData<Document[]>(documentsResponse.data);
if (extractedDocuments) {
allData = [...allData, ...extractedDocuments];
}
};
const response = await postgrestGet<Document[]>('documents', params);
if (response.error) {
return { error: response.error, status: response.status };
}
const extractedData = extractApiData<Document[]>(response.data);
if (!extractedData) {
return { error: '获取数据失败', status: 500 };
// 处理合同附件数据
if (!attachmentResponse.error && attachmentResponse.data) {
const extractedAttachments = extractApiData<ContractStructureComparison[]>(attachmentResponse.data);
if (extractedAttachments) {
// 将ContractStructureComparison转换为Document格式
const convertedAttachments: Document[] = extractedAttachments.map(item => ({
id: item.id,
name: item.template_contract_name || `合同结构比较记录_${item.id}`,
type_id: 1,
file_size: item.file_size || 0,
status: item.status,
created_at: item.created_at
}));
allData = [...allData, ...convertedAttachments];
}
}
return { data: extractedData };
return { data: allData };
} catch (error) {
console.error('获取文档状态失败:', error);
return {