ai-contract-platform/frontend/src/services/knowledge-base.ts

import { http } from "@/services/http";
import type {
  ApiResponse,
  KnowledgeBaseCreatePayload,
  KnowledgeBaseDocumentItem,
  KnowledgeBaseItem,
  KnowledgeBaseRollbackPayload,
  KnowledgeBaseVersionItem,
  PageResponse,
} from "@/types/api";

function getKnowledgeBaseSortTimestamp(item: KnowledgeBaseItem) {
  return new Date(item.updated_at || item.created_at || 0).getTime() || 0;
}

export async function listKnowledgeBases(page = 1, pageSize = 100) {
  const response = await http.get<ApiResponse<PageResponse<KnowledgeBaseItem>>>("/knowledge-bases", {
    params: {
      page,
      page_size: pageSize,
    },
  });
  if (response.data.code === 0 && response.data.data?.items) {
    return {
      ...response.data,
      data: {
        ...response.data.data,
        items: [...response.data.data.items].sort((left, right) => getKnowledgeBaseSortTimestamp(right) - getKnowledgeBaseSortTimestamp(left)),
      },
    };
  }
  return response.data;
}

export async function createKnowledgeBase(payload: KnowledgeBaseCreatePayload) {
  const formData = new FormData();
  formData.append("name", payload.name);
  if (payload.description) {
    formData.append("description", payload.description);
  }

  const response = await http.post<ApiResponse<KnowledgeBaseItem>>("/knowledge-bases", formData);
  return response.data;
}

export async function listKnowledgeBaseVersions(knowledgeBaseId: string) {
  const response = await http.get<ApiResponse<KnowledgeBaseVersionItem[]>>(`/knowledge-bases/${knowledgeBaseId}/versions`);
  return response.data;
}

export async function publishKnowledgeBase(knowledgeBaseId: string) {
  const response = await http.post<ApiResponse<KnowledgeBaseItem>>(`/knowledge-bases/${knowledgeBaseId}/publish`);
  return response.data;
}

export async function unpublishKnowledgeBase(knowledgeBaseId: string) {
  const response = await http.post<ApiResponse<KnowledgeBaseItem>>(`/knowledge-bases/${knowledgeBaseId}/unpublish`);
  return response.data;
}

export async function rollbackKnowledgeBase(knowledgeBaseId: string, payload: KnowledgeBaseRollbackPayload) {
  const formData = new FormData();
  formData.append("target_version_label", payload.target_version_label);
  if (payload.change_summary) {
    formData.append("change_summary", payload.change_summary);
  }
  const response = await http.post<ApiResponse<KnowledgeBaseItem>>(`/knowledge-bases/${knowledgeBaseId}/rollback`, formData);
  return response.data;
}

export async function listKnowledgeBaseDocuments(knowledgeBaseId: string, page = 1, pageSize = 20) {
  const response = await http.get<ApiResponse<PageResponse<KnowledgeBaseDocumentItem>>>(`/knowledge-bases/${knowledgeBaseId}/documents`, {
    params: {
      page,
      page_size: pageSize,
    },
  });
  return response.data;
}

export type KnowledgeDocumentMetadataPayload = {
  source_type?: string;
  authority?: string;
  effective_date?: string;
  region?: string;
  tags?: string[];
};

function appendMetadata(formData: FormData, metadata?: KnowledgeDocumentMetadataPayload) {
  if (!metadata) {
    return;
  }
  if (metadata.source_type) {
    formData.append("source_type", metadata.source_type);
  }
  if (metadata.authority) {
    formData.append("authority", metadata.authority);
  }
  if (metadata.effective_date) {
    formData.append("effective_date", metadata.effective_date);
  }
  if (metadata.region) {
    formData.append("region", metadata.region);
  }
  if (metadata.tags && metadata.tags.length > 0) {
    formData.append("tags_json", JSON.stringify(metadata.tags));
  }
}

export async function uploadKnowledgeBaseDocument(
  knowledgeBaseId: string,
  file: File,
  note?: string,
  metadata?: KnowledgeDocumentMetadataPayload,
) {
  const formData = new FormData();
  formData.append("file", file);
  if (note) {
    formData.append("note", note);
  }
  appendMetadata(formData, metadata);

  const response = await http.post<ApiResponse<KnowledgeBaseDocumentItem>>(`/knowledge-bases/${knowledgeBaseId}/documents`, formData);
  return response.data;
}

export async function retryKnowledgeBaseDocument(
  knowledgeBaseId: string,
  documentId: string,
  file?: File,
  note?: string,
  metadata?: KnowledgeDocumentMetadataPayload,
) {
  const formData = new FormData();
  if (file) {
    formData.append("file", file);
  }
  if (note) {
    formData.append("note", note);
  }
  appendMetadata(formData, metadata);

  const response = await http.post<ApiResponse<KnowledgeBaseDocumentItem>>(
    `/knowledge-bases/${knowledgeBaseId}/documents/${documentId}/retry`,
    formData,
  );
  return response.data;
}