updated ui

Author: klakhov

cvat-core/src/api-implementation.ts

@@ -32,22 +32,21 @@ import Webhook from './webhook';
 import { ArgumentError } from './exceptions';
 import {
     AnalyticsReportFilter, QualityConflictsFilter, QualityReportsFilter,
-    QualitySettingsFilter, SerializedAsset,
-    ConsensusSettingsFilter,
+    QualitySettingsFilter, SerializedAsset, ConsensusSettingsFilter,
 } from './server-response-types';
 import QualityReport from './quality-report';
 import QualityConflict, { ConflictSeverity } from './quality-conflict';
 import QualitySettings from './quality-settings';
 import { getFramesMeta } from './frames';
 import AnalyticsReport from './analytics-report';
+import ConsensusSettings from './consensus-settings';
 import {
     callAction, listActions, registerAction, runAction,
 } from './annotations-actions/annotations-actions';
 import { convertDescriptions, getServerAPISchema } from './server-schema';
 import { JobType } from './enums';
 import { PaginatedResource } from './core-types';
 import CVATCore from '.';
-import ConsensusSettings from './consensus-settings';
 
 function implementationMixin(func: Function, implementation: Function): void {
     Object.assign(func, { implementation });

cvat-ui/src/actions/common.ts

@@ -0,0 +1,24 @@
+// Copyright (C) CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+import { getCore, ProjectOrTaskOrJob } from 'cvat-core-wrapper';
+import { RequestInstanceType } from './requests-actions';
+
+const core = getCore();
+
+export function getInstanceType(instance: ProjectOrTaskOrJob | RequestInstanceType): 'project' | 'task' | 'job' {
+    if (instance instanceof core.classes.Project) {
+        return 'project';
+    }
+
+    if (instance instanceof core.classes.Task) {
+        return 'task';
+    }
+
+    if (instance instanceof core.classes.Job) {
+        return 'job';
+    }
+
+    return instance.type;
+}

cvat-ui/src/actions/consensus-actions.ts

@@ -1,66 +1,40 @@
-// Copyright (C) 2024 CVAT.ai Corporation
+// Copyright (C) CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
 import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
-import { Job, Task } from 'cvat-core-wrapper';
+import { Project, ProjectOrTaskOrJob } from 'cvat-core-wrapper';
 
 export enum ConsensusActionTypes {
     MERGE_CONSENSUS_JOBS = 'MERGE_CONSENSUS_JOBS',
     MERGE_CONSENSUS_JOBS_SUCCESS = 'MERGE_CONSENSUS_JOBS_SUCCESS',
     MERGE_CONSENSUS_JOBS_FAILED = 'MERGE_CONSENSUS_JOBS_FAILED',
-    MERGE_SPECIFIC_CONSENSUS_JOBS = 'MERGE_SPECIFIC_CONSENSUS_JOBS',
-    MERGE_SPECIFIC_CONSENSUS_JOBS_SUCCESS = 'MERGE_SPECIFIC_CONSENSUS_JOBS_SUCCESS',
-    MERGE_SPECIFIC_CONSENSUS_JOBS_FAILED = 'MERGE_SPECIFIC_CONSENSUS_JOBS_FAILED',
 }
 
 export const consensusActions = {
-    mergeTaskConsensusJobs: (taskID: number) => (
-        createAction(ConsensusActionTypes.MERGE_CONSENSUS_JOBS, { taskID })
+    mergeConsensusJobs: (instance: Exclude<ProjectOrTaskOrJob, Project>) => (
+        createAction(ConsensusActionTypes.MERGE_CONSENSUS_JOBS, { instance })
     ),
-    mergeTaskConsensusJobsSuccess: (taskID: number) => (
-        createAction(ConsensusActionTypes.MERGE_CONSENSUS_JOBS_SUCCESS, { taskID })
+    mergeConsensusJobsSuccess: (instance: Exclude<ProjectOrTaskOrJob, Project>) => (
+        createAction(ConsensusActionTypes.MERGE_CONSENSUS_JOBS_SUCCESS, { instance })
     ),
-    mergeTaskConsensusJobsFailed: (taskID: number, error: any) => (
-        createAction(ConsensusActionTypes.MERGE_CONSENSUS_JOBS_FAILED, { taskID, error })
+    mergeConsensusJobsFailed: (instance: Exclude<ProjectOrTaskOrJob, Project>, error: any) => (
+        createAction(ConsensusActionTypes.MERGE_CONSENSUS_JOBS_FAILED, { instance, error })
     ),
-    mergeSpecificTaskConsensusJobs: (jobID: number) => (
-        createAction(ConsensusActionTypes.MERGE_SPECIFIC_CONSENSUS_JOBS, { jobID })
-    ),
-    mergeSpecificTaskConsensusJobsSuccess: (jobID: number, taskID: number) => (
-        createAction(ConsensusActionTypes.MERGE_SPECIFIC_CONSENSUS_JOBS_SUCCESS, { jobID, taskID })
-    ),
-    mergeSpecificTaskConsensusJobsFailed: (jobID: number, taskID: number, error: any) => (
-        createAction(ConsensusActionTypes.MERGE_SPECIFIC_CONSENSUS_JOBS_FAILED, { jobID, taskID, error })
-    ),
-};
-
-export const mergeTaskConsensusJobsAsync = (
-    taskInstance: Task,
-): ThunkAction => async (dispatch) => {
-    try {
-        dispatch(consensusActions.mergeTaskConsensusJobs(taskInstance.id));
-        await taskInstance.mergeConsensusJobs();
-    } catch (error) {
-        dispatch(consensusActions.mergeTaskConsensusJobsFailed(taskInstance.id, error));
-        return;
-    }
-
-    dispatch(consensusActions.mergeTaskConsensusJobsSuccess(taskInstance.id));
 };
 
-export const mergeTaskSpecificConsensusJobsAsync = (
-    jobInstance: Job,
+export const mergeConsensusJobsAsync = (
+    instance: Exclude<ProjectOrTaskOrJob, Project>,
 ): ThunkAction => async (dispatch) => {
     try {
-        dispatch(consensusActions.mergeSpecificTaskConsensusJobs(jobInstance.id));
-        await jobInstance.mergeConsensusJobs();
+        dispatch(consensusActions.mergeConsensusJobs(instance));
+        await instance.mergeConsensusJobs();
     } catch (error) {
-        dispatch(consensusActions.mergeSpecificTaskConsensusJobsFailed(jobInstance.id, jobInstance.taskId, error));
+        dispatch(consensusActions.mergeConsensusJobsFailed(instance, error));
         return;
     }
 
-    dispatch(consensusActions.mergeSpecificTaskConsensusJobsSuccess(jobInstance.id, jobInstance.taskId));
+    dispatch(consensusActions.mergeConsensusJobsSuccess(instance));
 };
 
 export type ConsensusActions = ActionUnion<typeof consensusActions>;

cvat-ui/src/actions/export-actions.ts

@@ -8,9 +8,10 @@ import {
     Storage, ProjectOrTaskOrJob, Job, getCore, StorageLocation,
 } from 'cvat-core-wrapper';
 import {
-    getInstanceType, RequestInstanceType, listen,
+    RequestInstanceType, listen,
     RequestsActions, updateRequestProgress,
 } from './requests-actions';
+import { getInstanceType } from './common';
 
 export enum ExportActionTypes {
     OPEN_EXPORT_DATASET_MODAL = 'OPEN_EXPORT_DATASET_MODAL',

cvat-ui/src/actions/import-actions.ts

@@ -10,9 +10,10 @@ import {
 import { getProjectsAsync } from './projects-actions';
 import { AnnotationActionTypes, fetchAnnotationsAsync } from './annotation-actions';
 import {
-    getInstanceType, listen, RequestInstanceType,
+    listen, RequestInstanceType,
     RequestsActions, updateRequestProgress,
 } from './requests-actions';
+import { getInstanceType } from './common';
 
 const core = getCore();
 

cvat-ui/src/actions/requests-actions.ts

@@ -4,7 +4,7 @@
 
 import { ActionUnion, createAction } from 'utils/redux';
 import { CombinedState, RequestsQuery } from 'reducers';
-import { Request, ProjectOrTaskOrJob, getCore } from 'cvat-core-wrapper';
+import { Request, getCore } from 'cvat-core-wrapper';
 import { Store } from 'redux';
 import { getCVATStore } from 'cvat-store';
 
@@ -64,22 +64,6 @@ export interface RequestInstanceType {
     type: 'project' | 'task' | 'job';
 }
 
-export function getInstanceType(instance: ProjectOrTaskOrJob | RequestInstanceType): 'project' | 'task' | 'job' {
-    if (instance instanceof core.classes.Project) {
-        return 'project';
-    }
-
-    if (instance instanceof core.classes.Task) {
-        return 'task';
-    }
-
-    if (instance instanceof core.classes.Job) {
-        return 'job';
-    }
-
-    return instance.type;
-}
-
 export function updateRequestProgress(request: Request, dispatch: (action: RequestsActions) => void): void {
     dispatch(
         requestsActions.getRequestStatusSuccess(request),

cvat-ui/src/base.scss

@@ -63,3 +63,22 @@ $monospaced-fonts-stack: Consolas, Monaco, Lucida Console, Liberation Mono, Deja
         align-items: center;
     }
 }
+
+.cvat-scrollbar {
+    overflow-y: auto;
+
+    &::-webkit-scrollbar {
+        background-color: #fff;
+        width: $grid-unit-size * 2;
+    }
+
+    &::-webkit-scrollbar-track {
+        background-color: #fff;
+    }
+
+    &::-webkit-scrollbar-thumb {
+        background-color: #babac0;
+        border-radius: $border-radius-base * 2;
+        border: 6px solid #fff;
+    }
+}

cvat-ui/src/components/actions-menu/actions-menu.tsx

@@ -54,7 +54,7 @@ function ActionsMenuComponent(props: Props): JSX.Element {
 
     const plugins = usePlugins((state: CombinedState) => state.plugins.components.taskActions.items, props);
 
-    const mergingConsensus = useSelector((state: CombinedState) => state.consensus.mergingConsensus);
+    const mergingConsensus = useSelector((state: CombinedState) => state.consensus.actions.merging);
     const isTaskInMergingConsensus = mergingConsensus[`task_${taskID}`];
 
     const onClickMenuWrapper = useCallback(

cvat-ui/src/components/consensus-management-page/consensus-management-page.tsx

@@ -20,6 +20,7 @@ import Result from 'antd/lib/result';
 
 import CVATLoadingSpinner from 'components/common/loading-spinner';
 import { ActionUnion, createAction } from 'utils/redux';
+import { fetchTask } from 'utils/fetch';
 import ConsensusSettingsTab from './consensus-settings-tab';
 
 const core = getCore();
@@ -125,12 +126,7 @@ function ConsensusManagementPage(): JSX.Element {
 
     const initializeData = async (id: number): Promise<void> => {
         try {
-            let taskInstance = null;
-            try {
-                [taskInstance] = await core.tasks.get({ id });
-            } catch (error: unknown) {
-                throw new Error('The task was not found on the server');
-            }
+            const taskInstance = await fetchTask(id);
 
             setInstance(taskInstance);
             try {

cvat-ui/src/components/consensus-management-page/styles.scss

@@ -4,25 +4,6 @@
 
 @import 'base';
 
-.cvat-consensus-scrollbar {
-    overflow-y: auto;
-
-    &::-webkit-scrollbar {
-        background-color: #fff;
-        width: $grid-unit-size * 2;
-    }
-
-    &::-webkit-scrollbar-track {
-        background-color: #fff;
-    }
-
-    &::-webkit-scrollbar-thumb {
-        background-color: #babac0;
-        border-radius: $border-radius-base * 2;
-        border: 6px solid #fff;
-    }
-}
-
 .cvat-consensus-management-inner {
     background: $background-color-1;
     padding: $grid-unit-size * 4;
@@ -66,7 +47,7 @@
 
 .cvat-task-control-tabs {
     .ant-tabs-tabpane {
-        @extend .cvat-consensus-scrollbar;
+        @extend .cvat-scrollbar;
 
         height: calc(100vh - $grid-unit-size * 33);
     }