580 lines
19 KiB
TypeScript
580 lines
19 KiB
TypeScript
import { postgrestGet, type PostgrestParams } from '../postgrest-client';
|
|
import dayjs from 'dayjs';
|
|
import { UPLOAD_URL } from '../../config/api-config';
|
|
// import { API_BASE_URL } from '../client';
|
|
|
|
/**
|
|
* 从不同格式的 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;
|
|
}
|
|
|
|
// 文档状态枚举
|
|
export enum DocumentStatus {
|
|
waiting = 'waiting',
|
|
WAITING = "Waiting",
|
|
CUTTING = "Cutting",
|
|
EXTRACTIONING = "Extractioning",
|
|
EVALUATIONING = "Evaluationing",
|
|
FAILED = "Failed",
|
|
PROCESSED = "Processed"
|
|
}
|
|
|
|
// 文档类型接口
|
|
export interface DocumentType {
|
|
id: number;
|
|
name: string;
|
|
}
|
|
|
|
// 提取结果接口
|
|
interface ExtractedResult {
|
|
[key: string]: unknown;
|
|
}
|
|
|
|
// 摘要接口
|
|
interface Summary {
|
|
[key: string]: unknown;
|
|
}
|
|
|
|
// 文档接口
|
|
export interface Document {
|
|
id: number;
|
|
name: string;
|
|
type_id: number;
|
|
file_size: number;
|
|
status: DocumentStatus;
|
|
created_at: string;
|
|
document_number?: string;
|
|
path?: string;
|
|
storage_type?: string;
|
|
is_test_document?: boolean;
|
|
evaluation_level?: string;
|
|
ocr_result?: Record<string, string>;
|
|
extracted_results?: ExtractedResult;
|
|
sumary?: Summary;
|
|
remark?: string;
|
|
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;
|
|
result?: {
|
|
id: number;
|
|
file_name: string;
|
|
file_size: number;
|
|
file_url: string;
|
|
type_id: number;
|
|
type_description: string;
|
|
document_number: string | null;
|
|
storage_type: string;
|
|
is_test_document: boolean;
|
|
remark: string | null;
|
|
background_processing: boolean;
|
|
evaluation_level: string;
|
|
};
|
|
error: string | null;
|
|
}
|
|
|
|
/**
|
|
* 将文件转换为二进制数据
|
|
*/
|
|
export async function uploadFileToBinary(file: File): Promise<ArrayBuffer> {
|
|
return new Promise((resolve, reject) => {
|
|
const reader = new FileReader();
|
|
reader.onload = () => {
|
|
if (reader.result instanceof ArrayBuffer) {
|
|
resolve(reader.result);
|
|
} else {
|
|
reject(new Error('文件读取失败'));
|
|
}
|
|
};
|
|
reader.onerror = () => reject(new Error('文件读取失败'));
|
|
reader.readAsArrayBuffer(file);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 上传文件到文档审核系统
|
|
* @param binaryData 文件的二进制数据
|
|
* @param fileName 文件名
|
|
* @param fileType 文件类型
|
|
* @param typeId 文档类型ID
|
|
* @param priority 优先级
|
|
* @param documentNumber 文档编号（可选）
|
|
* @param remark 备注信息（可选）
|
|
* @param isTestDocument 是否为测试文档
|
|
* @param documentId 关联的文档ID（用于合同附件上传）
|
|
* @param isReupload 是否为重新上传
|
|
* @param jwtToken JWT token
|
|
* @returns 上传结果
|
|
*/
|
|
export async function uploadDocumentToServer(
|
|
binaryData: ArrayBuffer,
|
|
fileName: string,
|
|
fileType: string,
|
|
typeId: string | number,
|
|
priority: string,
|
|
documentNumber?: string | null,
|
|
remark?: string | null,
|
|
isTestDocument: boolean = false,
|
|
documentId?: number | null,
|
|
isReupload: boolean = false,
|
|
jwtToken?: string
|
|
): Promise<{data: FileUploadResponse; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// console.log('【调试】开始上传文档:', { fileName, fileSize: binaryData.byteLength });
|
|
|
|
// 创建FormData对象
|
|
const formData = new FormData();
|
|
|
|
// 将二进制数据转换为Blob并添加到FormData
|
|
const blob = new Blob([binaryData], { type: fileType });
|
|
formData.append('file', blob, fileName);
|
|
// console.log('【调试】Blob已创建，文件大小:', blob.size);
|
|
|
|
// 将信息添加到一个JSON对象中
|
|
const uploadInfo = {
|
|
type_id: Number(typeId),
|
|
evaluation_level: priority,
|
|
document_number: documentNumber || null,
|
|
remark: remark || null,
|
|
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));
|
|
|
|
// 根据是否有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(uploadUrl, {
|
|
method: 'POST',
|
|
headers: {
|
|
'X-File-Name': encodeURIComponent(fileName),
|
|
'Authorization': `Bearer ${jwtToken || ''}`
|
|
},
|
|
body: formData
|
|
});
|
|
|
|
// console.log('【调试】收到服务器响应:', { status: response.status, statusText: response.statusText });
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
console.error(`【调试】上传失败 (${response.status}): ${errorText}`);
|
|
return {
|
|
error: `上传失败: ${response.status} ${response.statusText} - ${errorText}`,
|
|
status: response.status
|
|
};
|
|
}
|
|
|
|
// console.log('【调试】开始解析JSON响应');
|
|
let responseData;
|
|
try {
|
|
responseData = await response.json();
|
|
// console.log('【调试】JSON响应解析成功:', responseData);
|
|
} catch (jsonError) {
|
|
console.error('【调试】JSON解析失败:', jsonError);
|
|
return {
|
|
error: `解析响应JSON失败: ${jsonError instanceof Error ? jsonError.message : '未知错误'}`,
|
|
status: 500
|
|
};
|
|
}
|
|
|
|
const extractedData = extractApiData<FileUploadResponse>(responseData);
|
|
// console.log('【调试】提取的数据:', extractedData);
|
|
|
|
if (!extractedData) {
|
|
console.error('【调试】无法提取数据');
|
|
return { error: '处理上传响应失败', status: 500 };
|
|
}
|
|
|
|
// console.log('【调试】上传成功，返回数据');
|
|
return { data: extractedData };
|
|
} catch (fetchError) {
|
|
console.error('【调试】fetch请求失败:', fetchError);
|
|
return {
|
|
error: `fetch请求错误: ${fetchError instanceof Error ? fetchError.message : '未知错误'}`,
|
|
status: 500
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.error('【调试】上传过程中发生错误:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '上传失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取当天的文档列表
|
|
* @param userInfo 用户信息（必需）
|
|
* @param reviewType 审核类型（可选）
|
|
* @returns 文档列表
|
|
*/
|
|
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);
|
|
|
|
// 如果是合同类型，需要合并查询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',
|
|
'user_id': `eq.${userInfo.user_id}`
|
|
}
|
|
};
|
|
|
|
|
|
// 查询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,
|
|
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}`,
|
|
'user_id': `eq.${userInfo.user_id}`
|
|
}
|
|
};
|
|
|
|
// 根据reviewType添加过滤条件
|
|
if (reviewType === 'record') {
|
|
// 如果是卷宗类型，只显示type_id=2或type_id=3的文档
|
|
if (params.filter) {
|
|
params.filter['type_id'] = 'in.(2,3)';
|
|
} else {
|
|
params.filter = { 'type_id': 'in.(2,3)' };
|
|
}
|
|
}
|
|
|
|
// console.log('发送请求参数:', params);
|
|
const response = await postgrestGet<Document[]>('documents', params);
|
|
// console.log('API 响应:', response);
|
|
|
|
if (response.error) {
|
|
console.error('API 返回错误:', response.error);
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
const extractedData = extractApiData<Document[]>(response.data);
|
|
// console.log('提取后的数据:', extractedData);
|
|
|
|
if (!extractedData) {
|
|
console.error('数据提取失败');
|
|
return { error: '获取数据失败', status: 500 };
|
|
}
|
|
|
|
return { data: extractedData };
|
|
} catch (error) {
|
|
console.error('获取当天文档列表失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取当天文档列表失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取文档类型列表
|
|
* @param reviewType 审核类型（可选）
|
|
* @returns 文档类型列表
|
|
*/
|
|
export async function getDocumentTypes(reviewType?: string): Promise<{data: DocumentType[]; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
const params: PostgrestParams = {
|
|
select: 'id, name',
|
|
filter: {} // 初始化为空对象
|
|
};
|
|
|
|
// 根据reviewType添加过滤条件
|
|
if (reviewType === 'contract') {
|
|
// 如果是合同类型，只显示id=1的文档类型
|
|
if (params.filter) {
|
|
params.filter['id'] = 'eq.1';
|
|
} else {
|
|
params.filter = { 'id': 'eq.1' };
|
|
}
|
|
} else if (reviewType === 'record') {
|
|
// 如果是卷宗类型，只显示id=2或id=3的文档类型
|
|
if (params.filter) {
|
|
params.filter['id'] = 'in.(2,3)';
|
|
} else {
|
|
params.filter = { 'id': 'in.(2,3)' };
|
|
}
|
|
}
|
|
|
|
const response = await postgrestGet<DocumentType[]>('document_types', params);
|
|
|
|
if (response.error) {
|
|
return { error: response.error, status: response.status };
|
|
}
|
|
|
|
const extractedData = extractApiData<DocumentType[]>(response.data);
|
|
if (!extractedData) {
|
|
return { error: '获取数据失败', status: 500 };
|
|
}
|
|
|
|
return { data: extractedData };
|
|
} catch (error) {
|
|
console.error('获取文档类型列表失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取文档类型列表失败',
|
|
status: 500
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取指定文档的状态
|
|
* @param documentIds 文档ID列表
|
|
* @param attachmentIds 合同附件ID列表（可选）
|
|
* @returns 文档状态列表
|
|
*/
|
|
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) && (!attachmentIds || attachmentIds.length === 0)) {
|
|
return { data: [] };
|
|
}
|
|
|
|
// 查询主文档状态
|
|
// 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];
|
|
}
|
|
}
|
|
|
|
// 处理合同附件数据
|
|
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: allData };
|
|
} catch (error) {
|
|
console.error('获取文档状态失败:', error);
|
|
return {
|
|
error: error instanceof Error ? error.message : '获取文档状态失败',
|
|
status: 500
|
|
};
|
|
}
|
|
} |