[feature]: Offline Execute workflow

packages/shared/lib/api/sqle/service/common.d.ts

@@ -2192,12 +2192,6 @@ export interface IReportPushConfigList {
   type?: string;
 }
 
-export interface IRetryExecWorkflowReqV1 {
-  task_ids?: number[];
-
-  workflow_id?: string;
-}
-
 export interface IRewriteRule {
   message?: string;
 
@@ -3401,7 +3395,13 @@ export interface IBatchCancelWorkflowsReqV2 {
 }
 
 export interface IBatchCompleteWorkflowsReqV2 {
-  workflow_id_list?: string[];
+  workflow_list?: ICompleteWorkflowReq[];
+}
+
+export interface ICompleteWorkflowReq {
+  desc?: string;
+
+  workflow_id?: string;
 }
 
 export interface ICreateWorkflowReqV2 {

packages/sqle/src/page/SqlExecWorkflow/Detail/__tests__/index.test.tsx

@@ -373,7 +373,7 @@ describe('sqle/ExecWorkflow/Detail', () => {
 
     expect(batchCompleteWorkflowsSpy).toHaveBeenCalledTimes(1);
     expect(batchCompleteWorkflowsSpy).toHaveBeenCalledWith({
-      workflow_id_list: [workflowsDetailData.workflow_id],
+      workflow_list: [{ workflow_id: workflowsDetailData.workflow_id }],
       project_name: mockProjectInfo.projectName
     });
     await act(async () => jest.advanceTimersByTime(3000));

packages/sqle/src/page/SqlExecWorkflow/Detail/hooks/useGenerateWorkflowStepsProps.ts

@@ -140,7 +140,7 @@ const useGenerateWorkflowStepsProps = ({
   const completeAction = useCallback(async () => {
     return workflow
       .batchCompleteWorkflowsV2({
-        workflow_id_list: [workflowId],
+        workflow_list: [{ workflow_id: workflowId }],
         project_name: projectName
       })
       .then((res) => {

packages/sqle/src/page/VersionManagement/Detail/Modal/AssociateWorkflowModal/WorkflowTableField/index.tsx

@@ -3,39 +3,40 @@
 import { useTranslation } from 'react-i18next';
 import WorkflowStatus from '../../../../../SqlExecWorkflow/List/components/WorkflowStatus';
 import { WorkflowDetailResV1StatusEnum } from '@actiontech/shared/lib/api/sqle/service/common.enum';
+import { IBasicTable } from '@actiontech/shared/lib/components/BasicTable';
 
 const WorkflowTableField: React.FC<{
   value?: React.Key[];
   onChange?: (value: React.Key[]) => void;
   workflowList?: IAssociateWorkflows[];
   loading: boolean;
 }> = ({ loading, workflowList, onChange, value }) => {
   const { t } = useTranslation();
 
   const onSelectChange = (keys: React.Key[]) => {
     onChange?.(keys);
   };
 
-  const columns = [
+  const columns: IBasicTable<IAssociateWorkflows>['columns'] = [
     {
       dataIndex: 'workflow_name',
       title: t('versionManagement.associateWorkflow.workflowName')
     },
-    {
-      dataIndex: 'desc',
-      title: t('versionManagement.associateWorkflow.workflowDesc'),
-      render: (desc: string) => desc || '-'
-    },
     {
       dataIndex: 'status',
       title: t('versionManagement.associateWorkflow.workflowStatus'),
       render: (status: string) => (
         <WorkflowStatus
           status={status as unknown as WorkflowDetailResV1StatusEnum}
         />
       )
+    },
+    {
+      dataIndex: 'desc',
+      title: t('versionManagement.associateWorkflow.workflowDesc'),
+      render: (desc: string) => desc || '-'
     }
   ];
 
   return (
     <BasicTable

packages/sqle/src/page/VersionManagement/Detail/Modal/OfflineExecModal/index.tsx

@@ -17,46 +17,50 @@
 import { FormItemLabel } from '@actiontech/shared/lib/components/FormCom';
 import workflow from '@actiontech/shared/lib/api/sqle/service/workflow';
 
 const OfflineExecModal = () => {
   const { t } = useTranslation();
 
   const dispatch = useDispatch();
 
   const [messageApi, messageContextHolder] = message.useMessage();
 
   const [submitting, { setTrue: startSubmit, setFalse: submitFinish }] =
     useBoolean();
 
   const [form] = Form.useForm<{ remarks: string }>();
 
   const { projectName } = useCurrentProject();
 
   const { workflowId, visible } = useSelector((state: IReduxState) => ({
     workflowId: state.versionManagement.workflowId,
     visible:
       !!state.versionManagement.modalStatus[
         ModalName.Version_Management_Offline_Execute_Modal
       ]
   }));
 
   const onClose = () => {
     form.resetFields();
     dispatch(
       updateVersionManagementModalStatus({
         modalName: ModalName.Version_Management_Offline_Execute_Modal,
         status: false
       })
     );
     dispatch(updateSelectVersionStageId({ stageId: null }));
   };
 
-  const onSubmit = () => {
-    form.validateFields();
-    // todo 待后端补充备注字段
+  const onSubmit = async () => {
+    const values = await form.validateFields();
     startSubmit();
     workflow
       .batchCompleteWorkflowsV2({
-        workflow_id_list: [workflowId ?? ''],
+        workflow_list: [
+          {
+            workflow_id: workflowId ?? '',
+            desc: values.remarks
+          }
+        ],
         project_name: projectName
       })
       .then((res) => {

packages/sqle/src/page/VersionManagement/Detail/Modal/ReleaseModal/hooks/useTestConnection.tsx

@@ -11,85 +11,91 @@
 import { EmptyBox, ReminderInformation } from '@actiontech/shared';
 import { useTranslation } from 'react-i18next';
 
 const useTestConnection = (releaseWorkflows: TargetReleaseWorkflowType[]) => {
   const { projectName } = useCurrentProject();
 
   const { t } = useTranslation();
 
   const instanceNames = useMemo(() => {
     return releaseWorkflows?.reduce(
       (prev: Array<{ name: string }>, next: TargetReleaseWorkflowType) => {
         return prev.concat(
           next.target_release_instances
             ?.filter((i: TargetReleaseInstanceType) => !!i.target_instance_name)
             ?.map((i) => ({
               name: i.target_instance_name!
             })) ?? []
         );
       },
       []
     );
   }, [releaseWorkflows]);
 
   const {
     data: connectionInfo,
     loading: getConnectionInfoLoading,
-    run: getConnectionInfo
+    run: getConnectionInfo,
+    mutate: setConnectionInfo
   } = useRequest(
     () => {
       const params: IBatchCheckInstanceIsConnectableByNameParams = {
         instances: instanceNames,
         project_name: projectName
       };
 
       return instance
         .batchCheckInstanceIsConnectableByName(params)
         .then((res) => {
           if (res.data.code === ResponseCode.SUCCESS) {
             return res.data.data;
           }
         });
     },
     { manual: true }
   );
 
   const renderTestDatabasesConnectInfo = useCallback(
     (name?: string) => {
       const result = connectionInfo?.find((v) => v.instance_name === name);
       if (!result) {
         return null;
       }
 
       return (
         <>
           <EmptyBox if={!!result.is_instance_connectable}>
             <ReminderInformation
               status="success"
               message={t('common.testDatabaseConnectButton.testSuccess')}
             />
           </EmptyBox>
           <EmptyBox
             if={
               !result.is_instance_connectable && !!result.connect_error_message
             }
           >
             <ReminderInformation
               status="error"
               message={result.connect_error_message ?? t('common.unknownError')}
             />
           </EmptyBox>
         </>
       );
     },
     [t, connectionInfo]
   );
 
+  const clearConnectionInfo = useCallback(() => {
+    setConnectionInfo(undefined);
+  }, [setConnectionInfo]);
+
   return {
     renderTestDatabasesConnectInfo,
     getConnectionInfoLoading,
     getConnectionInfo,
-    testConnectionAble: !!instanceNames?.length
+    testConnectionAble: !!instanceNames?.length,
+    clearConnectionInfo
   };
 };
 
 export default useTestConnection;

packages/sqle/src/page/VersionManagement/Detail/Modal/ReleaseModal/index.tsx

@@ -32,88 +32,90 @@
 import EmitterKey from '../../../../../data/EmitterKey';
 import EventEmitter from '../../../../../utils/EventEmitter';
 
 const ReleaseModal: React.FC = () => {
   const { t } = useTranslation();
 
   const dispatch = useDispatch();
 
   const { versionId } = useParams<{ versionId: string }>();
 
   const { projectName, projectID } = useCurrentProject();
 
   const [messageApi, messageContextHolder] = message.useMessage();
 
   const [form] = Form.useForm<ReleaseWorkflowFormType>();
 
   const [submitting, { setTrue: startSubmit, setFalse: submitFinish }] =
     useBoolean();
 
   const releaseWorkflows = Form.useWatch('release_workflows', form);
 
   const {
     renderTestDatabasesConnectInfo,
     getConnectionInfoLoading,
     getConnectionInfo,
-    testConnectionAble
+    testConnectionAble,
+    clearConnectionInfo
   } = useTestConnection(releaseWorkflows);
 
   const { stageId, currentStageWorkflowList, visible } = useSelector(
     (state: IReduxState) => ({
       stageId: state.versionManagement.stageId,
       currentStageWorkflowList:
         state.versionManagement.currentStageWorkflowList,
       visible:
         !!state.versionManagement.modalStatus[
           ModalName.Version_Management_Release_Modal
         ]
     })
   );
 
   const { data: nextStageInstances, loading: getNextStageInstanceLoading } =
     useRequest(
       () => {
         return sqlVersion
           .getDependenciesBetweenStageInstanceV1({
             project_name: projectName,
             sql_version_stage_id: `${stageId}`,
             sql_version_id: versionId ?? ''
           })
           .then((res) => {
             if (res.data.code === ResponseCode.SUCCESS) {
               return res.data.data;
             }
           });
       },
       {
         ready: !!stageId && visible,
         onSuccess: (res) => {
           const initValues = currentStageWorkflowList?.map((workflow) => {
             return {
               workflow_id: workflow.workflow_id,
               target_release_instances: workflow.workflow_instances?.map(
                 (instance) => {
                   const nextInstances = res?.filter(
                     (i) => i.stage_instance_id === instance.instances_id
                   );
                   return {
                     instance_id: instance.instances_id,
                     instance_schema: instance.instance_schema,
                     target_instance_id:
                       nextInstances?.length === 1
                         ? nextInstances?.[0].next_stage_instance_id
                         : undefined
                   };
                 }
               )
             };
           });
           form.setFieldValue('release_workflows', initValues);
         }
       }
     );
 
   const onClose = () => {
     form.resetFields();
+    clearConnectionInfo();
     dispatch(
       updateVersionManagementModalStatus({
         modalName: ModalName.Version_Management_Release_Modal,