Online 0713

apps/frontend/src/api/mutations/datasource.ts

@@ -0,0 +1,51 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+
+import { createDataSource, deleteDataSource, importS3Samples, updateDataSource } from '@/api/services/datasource';
+import { datasourceKey } from '@/api/queryKeyFactories/datasource';
+import { sampleKey } from '@/api/queryKeyFactories/sample';
+
+import type { CreateDataSourceCommand, ImportS3SamplesCommand, UpdateDataSourceCommand } from '../types';
+
+export function useCreateDataSourceMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: CreateDataSourceCommand) => createDataSource(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: datasourceKey.lists() });
+    },
+  });
+}
+
+export function useUpdateDataSourceMutation(dsId: number) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: UpdateDataSourceCommand) => updateDataSource(dsId, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: datasourceKey.lists() });
+    },
+  });
+}
+
+export function useDeleteDataSourceMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (dsId: number) => deleteDataSource(dsId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: datasourceKey.lists() });
+    },
+  });
+}
+
+export function useImportS3SamplesMutation(taskId: number) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: ImportS3SamplesCommand) => importS3Samples(taskId, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sampleKey.lists() });
+    },
+  });
+}

apps/frontend/src/api/queryKeyFactories/datasource.ts

@@ -0,0 +1,11 @@
+import type { ListDataSourcesParams, ListS3ObjectsParams } from '../types';
+
+export const datasourceKey = {
+  all: ['datasourceKey'] as const,
+  lists: () => [...datasourceKey.all, 'list'] as const,
+  list: (filter: ListDataSourcesParams) => [...datasourceKey.lists(), filter] as const,
+  details: () => [...datasourceKey.all, 'details'] as const,
+  detail: (id: number) => [...datasourceKey.details(), id] as const,
+  objects: () => [...datasourceKey.all, 'objects'] as const,
+  objectList: (filter: ListS3ObjectsParams) => [...datasourceKey.objects(), filter] as const,
+};

apps/frontend/src/api/queryKeyFactories/index.ts

@@ -1,2 +1,3 @@
 export * from './sample';
 export * from './task';
+export * from './datasource';

apps/frontend/src/api/request.tsx

@@ -6,12 +6,25 @@ import axios from 'axios';
 import commonController from '@/utils/common';
 import { goAuth } from '@/utils/sso';
 
+/**
+ * 滑动续期：后端在响应头 `X-New-Token` 中返回新签发的 token 时，更新本地存储，
+ * 使活跃用户的登录态自动延续，不会到点被强制登出。
+ * @param response
+ */
+function applyRefreshedToken(response: AxiosResponse<any>) {
+  const newToken = response?.headers?.['x-new-token'];
+  if (newToken) {
+    localStorage.token = newToken;
+  }
+}
+
 /**
  * 后端返回的结构由 { data, meta_data } 包裹
  * @param response
  * @returns
  */
 export function successHandler(response: AxiosResponse<any>) {
+  applyRefreshedToken(response);
   return response.data;
 }
 
@@ -45,11 +58,24 @@ async function errorHandler(error: AxiosError) {
   return Promise.reject(error);
 }
 
+const authorizationBearerSuccess = (config: any) => {
+  const token = localStorage.token;
+  if (token) {
+    config.headers.Authorization = localStorage.token;
+  }
+  return config;
+};
+
 const authorizationBearerFailed = (error: any) => {
   // 401一秒后跳转到登录页
   if (error?.response?.status === 401) {
+    localStorage.removeItem('token');
     setTimeout(() => {
-      goAuth();
+      if (window.IS_ONLINE) {
+        goAuth();
+      } else if (window.location.pathname !== '/login') {
+        window.location.href = '/login';
+      }
     }, 1000);
   }
 
@@ -65,11 +91,14 @@ const request = axios.create(requestConfig);
 
 export const requestWithHeaders = axios.create(requestConfig);
 
-requestWithHeaders.interceptors.request.use(undefined, authorizationBearerFailed);
-requestWithHeaders.interceptors.response.use(undefined, authorizationBearerFailed);
+requestWithHeaders.interceptors.request.use(authorizationBearerSuccess, authorizationBearerFailed);
+requestWithHeaders.interceptors.response.use((response) => {
+  applyRefreshedToken(response);
+  return response;
+}, authorizationBearerFailed);
 requestWithHeaders.interceptors.response.use(undefined, errorHandler);
 
-request.interceptors.request.use(undefined, authorizationBearerFailed);
+request.interceptors.request.use(authorizationBearerSuccess, authorizationBearerFailed);
 request.interceptors.response.use(successHandler, errorHandler);
 request.interceptors.response.use(undefined, authorizationBearerFailed);
 

apps/frontend/src/api/services/datasource.ts

@@ -0,0 +1,58 @@
+import request from '../request';
+import type {
+  CreateDataSourceCommand,
+  UpdateDataSourceCommand,
+  ListDataSourcesParams,
+  DataSourceListResponse,
+  DataSourceResponse,
+  ListS3ObjectsParams,
+  S3ObjectListResponse,
+  ImportS3SamplesCommand,
+  OkResponse,
+  OkRespCommonDataResp,
+  OkRespCreateSampleResponse,
+} from '../types';
+
+export async function getDataSources({ page, ...params }: ListDataSourcesParams): Promise<DataSourceListResponse> {
+  return await request.get('/v1/datasources', {
+    params: {
+      ...params,
+      page: typeof page === 'undefined' ? 0 : page - 1,
+    },
+  });
+}
+
+export async function getDataSource(dsId: number): Promise<OkResponse<DataSourceResponse>> {
+  return await request.get(`/v1/datasources/${dsId}`);
+}
+
+export async function createDataSource(data: CreateDataSourceCommand): Promise<OkResponse<DataSourceResponse>> {
+  return await request.post('/v1/datasources', data);
+}
+
+export async function updateDataSource(
+  dsId: number,
+  data: UpdateDataSourceCommand,
+): Promise<OkResponse<DataSourceResponse>> {
+  return await request.patch(`/v1/datasources/${dsId}`, data);
+}
+
+export async function deleteDataSource(dsId: number): Promise<OkRespCommonDataResp> {
+  return await request.delete(`/v1/datasources/${dsId}`);
+}
+
+export async function listS3Objects({
+  ds_id,
+  ...params
+}: ListS3ObjectsParams): Promise<OkResponse<S3ObjectListResponse>> {
+  return await request.get(`/v1/datasources/${ds_id}/objects`, {
+    params,
+  });
+}
+
+export async function importS3Samples(
+  taskId: number,
+  data: ImportS3SamplesCommand,
+): Promise<OkRespCreateSampleResponse> {
+  return await request.post(`/v1/tasks/${taskId}/samples/import_s3`, data);
+}

apps/frontend/src/api/services/samples.ts

@@ -3,6 +3,9 @@ import commonController from '@/utils/common';
 import request from '../request';
 import { getTask } from './task';
 import {
+  type AutoLabelCommand,
+  type BatchAutoLabelCommand,
+  type AutoLabelJobResponse,
   ExportType,
   type DeleteApiV1TasksTaskIdDeleteParams,
   type DeleteSampleCommand,
@@ -11,6 +14,7 @@ import {
   type ListByApiV1TasksTaskIdSamplesGetParams,
   type OkRespCommonDataResp,
   type OkRespCreateSampleResponse,
+  type OkRespAutoLabelResponse,
   type OkRespSampleResponse,
   type PatchSampleCommand,
   type SampleData,
@@ -80,61 +84,80 @@ export async function updateSampleAnnotationResult(
   );
 }
 
-export async function outputSample(taskId: number, sampleIds: number[], activeTxt: ExportType) {
-  const headers = {} as any;
-
-  if (
-    [
-      ExportType.MASK,
-      ExportType.LABEL_ME,
-      ExportType.YOLO,
-      ExportType.CSV,
-      ExportType.XML,
-      ExportType.TF_RECORD,
-      ExportType.PASCAL_VOC,
-    ].includes(activeTxt)
-  ) {
-    headers.responseType = 'blob';
-  }
+export async function autoLabelSample(
+  taskId: number,
+  sampleId: number,
+  body: AutoLabelCommand = {},
+): Promise<OkRespAutoLabelResponse> {
+  return await request.post(`/v1/tasks/${taskId}/samples/${sampleId}/auto_label`, body, {
+    timeout: 5 * 60 * 1000,
+    params: {
+      sample_id: sampleId,
+    },
+  });
+}
 
-  const data = await request.post(
+export async function createAutoLabelJob(
+  taskId: number,
+  body: BatchAutoLabelCommand = {},
+): Promise<{ data: AutoLabelJobResponse }> {
+  return await request.post(`/v1/tasks/${taskId}/auto_label_job`, body);
+}
+
+export async function getAutoLabelJobStatus(taskId: number, jobId: number): Promise<{ data: AutoLabelJobResponse }> {
+  return await request.get(`/v1/tasks/${taskId}/auto_label_job/${jobId}`);
+}
+
+export async function outputSample(taskId: number, sampleIds: number[], activeTxt: ExportType) {
+  // 1. Create export job
+  const jobRes = await request.post(
     `/v1/tasks/${taskId}/samples/export`,
-    {
-      sample_ids: sampleIds,
-    },
-    {
-      params: {
-        task_id: taskId,
-        export_type: activeTxt,
-      },
-      ...headers,
-    },
+    { sample_ids: sampleIds },
+    { params: { export_type: activeTxt } },
   );
-  const taskRes = await getTask(taskId);
 
-  const blobData = new Blob([JSON.stringify(data)]);
-  let url = window.URL.createObjectURL(blobData);
-  const a = document.createElement('a');
-  let filename = taskRes.data.name;
+  const jobId = jobRes.data.id;
+
+  // 2. Poll until completed
+  let job = jobRes.data;
+  while (job.status !== 'COMPLETED' && job.status !== 'FAILED') {
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    const statusRes = await request.get(`/v1/tasks/${taskId}/samples/export/${jobId}`);
+    job = statusRes.data;
+  }
+
+  if (job.status === 'FAILED') {
+    commonController.notificationErrorMessage({ message: job.error_message || 'Export failed' }, 3);
+    return;
+  }
+
+  // 3. Download the exported file
+  const blob = await request.get(`/v1/tasks/${taskId}/samples/export/${jobId}/download`, {
+    responseType: 'blob',
+  });
+
+  const taskRes = await getTask(taskId);
+  let filename = taskRes.data.name || 'export';
 
   switch (activeTxt) {
     case ExportType.JSON:
     case ExportType.COCO:
-      filename = filename + '.json';
+      filename += '.json';
       break;
-    case ExportType.MASK:
-    case ExportType.CSV:
     case ExportType.XML:
-    case ExportType.LABEL_ME:
-    case ExportType.YOLO:
-    case ExportType.TF_RECORD:
-    case ExportType.PASCAL_VOC:
-      url = window.URL.createObjectURL(data as any);
+      filename += '.xml';
+      break;
+    default:
+      filename += '.zip';
       break;
   }
-  a.download = filename!;
+
+  const url = window.URL.createObjectURL(blob as Blob);
+  const a = document.createElement('a');
   a.href = url;
+  a.download = filename;
   a.click();
+  window.URL.revokeObjectURL(url);
 }
 
 export async function outputSamples(taskId: number, activeTxt: ExportType) {
@@ -147,7 +170,7 @@ export async function outputSamples(taskId: number, activeTxt: ExportType) {
   }
 
   if (sampleIds.length === 0) {
-    commonController.notificationErrorMessage({ message: '后端返回数据出现问题' }, 1);
+    commonController.notificationErrorMessage({ message: 'No samples to export' }, 1);
     return;
   }