Remove collections in endpoints

cvat-core/package.json

@@ -25,6 +25,7 @@
     "ts-jest": "26"
   },
   "dependencies": {
+    "@types/lodash": "^4.14.191",
     "axios": "^0.27.2",
     "browser-or-node": "^2.0.0",
     "cvat-data": "link:./../cvat-data",
@@ -34,6 +35,7 @@
     "jest-config": "^29.0.3",
     "js-cookie": "^3.0.1",
     "json-logic-js": "^2.0.1",
+    "lodash": "^4.17.21",
     "platform": "^1.3.5",
     "quickhull": "^1.0.3",
     "store": "^2.0.12",

cvat-core/src/annotation-formats.ts

@@ -5,9 +5,9 @@
 
 import { DimensionType } from 'enums';
 import {
-    AnnotationExporterResponseBody,
-    AnnotationFormatsResponseBody,
-    AnnotationImporterResponseBody,
+    SerializedAnnotationExporter,
+    SerializedAnnotationFormats,
+    SerializedAnnotationImporter,
 } from 'server-response-types';
 
 export class Loader {
@@ -17,7 +17,7 @@ export class Loader {
     public enabled: boolean;
     public dimension: DimensionType;
 
-    constructor(initialData: AnnotationImporterResponseBody) {
+    constructor(initialData: SerializedAnnotationImporter) {
         const data = {
             name: initialData.name,
             format: initialData.ext,
@@ -53,7 +53,7 @@ export class Dumper {
     public enabled: boolean;
     public dimension: DimensionType;
 
-    constructor(initialData: AnnotationExporterResponseBody) {
+    constructor(initialData: SerializedAnnotationExporter) {
         const data = {
             name: initialData.name,
             format: initialData.ext,
@@ -86,7 +86,7 @@ export class AnnotationFormats {
     public loaders: Loader[];
     public dumpers: Dumper[];
 
-    constructor(initialData: AnnotationFormatsResponseBody) {
+    constructor(initialData: SerializedAnnotationFormats) {
         const data = {
             exporters: initialData.exporters.map((el) => new Dumper(el)),
             importers: initialData.importers.map((el) => new Loader(el)),

cvat-core/src/annotations-history.ts

@@ -1,4 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
+// Copyright (C) 2023 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 

cvat-core/src/api-implementation.ts

@@ -172,27 +172,25 @@ export default function implementAPI(cvat) {
             filter: isString,
             sort: isString,
             search: isString,
-            taskID: isInteger,
             jobID: isInteger,
         });
 
-        checkExclusiveFields(query, ['jobID', 'taskID', 'filter', 'search'], ['page', 'sort']);
+        checkExclusiveFields(query, ['jobID', 'filter', 'search'], ['page', 'sort']);
         if ('jobID' in query) {
-            const job = await serverProxy.jobs.get({ id: query.jobID });
+            const { results } = await serverProxy.jobs.get({ id: query.jobID });
+            const [job] = results;
             if (job) {
-                return [new Job(job)];
+                // When request job by ID we also need to add labels to work with them
+                const labels = await serverProxy.labels.get({ job_id: job.id });
+                return [new Job({ ...job, labels: labels.results })];
             }
 
             return [];
         }
 
-        if ('taskID' in query) {
-            query.filter = JSON.stringify({ and: [{ '==': [{ var: 'task_id' }, query.taskID] }] });
-        }
-
         const searchParams = {};
         for (const key of Object.keys(query)) {
-            if (['page', 'sort', 'search', 'filter'].includes(key)) {
+            if (['page', 'sort', 'search', 'filter', 'task_id'].includes(key)) {
                 searchParams[key] = query[key];
             }
         }
@@ -214,7 +212,7 @@ export default function implementAPI(cvat) {
             ordering: isString,
         });
 
-        checkExclusiveFields(filter, ['id', 'projectId'], ['page']);
+        checkExclusiveFields(filter, ['id'], ['page']);
         const searchParams = {};
         for (const key of Object.keys(filter)) {
             if (['page', 'id', 'sort', 'search', 'filter', 'ordering'].includes(key)) {
@@ -233,15 +231,19 @@ export default function implementAPI(cvat) {
 
         const tasksData = await serverProxy.tasks.get(searchParams);
         const tasks = await Promise.all(tasksData.map(async (taskItem) => {
-            // Temporary workaround for UI
-            // Fixme: too much requests on tasks page
-            let jobs = { results: [] };
             if ('id' in filter) {
-                jobs = await serverProxy.jobs.get({
-                    filter: JSON.stringify({ and: [{ '==': [{ var: 'task_id' }, taskItem.id] }] }),
-                }, true);
+                // When request task by ID we also need to add labels and jobs to work with them
+                const labels = await serverProxy.labels.get({ task_id: taskItem.id });
+                const jobs = await serverProxy.jobs.get({ task_id: taskItem.id }, true);
+                return new Task({
+                    ...taskItem, progress: taskItem.jobs, jobs: jobs.results, labels: labels.results,
+                });
             }
-            return new Task({ ...taskItem, jobs: jobs.results });
+
+            return new Task({
+                ...taskItem,
+                progress: taskItem.jobs,
+            });
         }));
 
         tasks.count = tasksData.count;
@@ -260,15 +262,25 @@ export default function implementAPI(cvat) {
         checkExclusiveFields(filter, ['id'], ['page']);
         const searchParams = {};
         for (const key of Object.keys(filter)) {
-            if (['id', 'page', 'search', 'sort', 'page', 'filter'].includes(key)) {
+            if (['page', 'id', 'sort', 'search', 'filter'].includes(key)) {
                 searchParams[key] = filter[key];
             }
         }
 
         const projectsData = await serverProxy.projects.get(searchParams);
-        const projects = projectsData.map((project) => new Project(project));
-        projects.count = projectsData.count;
+        const projects = await Promise.all(projectsData.map(async (projectItem) => {
+            if ('id' in filter) {
+                // When request a project by ID we also need to add labels to work with them
+                const labels = await serverProxy.labels.get({ project_id: projectItem.id });
+                return new Project({ ...projectItem, labels: labels.results });
+            }
 
+            return new Project({
+                ...projectItem,
+            });
+        }));
+
+        projects.count = projectsData.count;
         return projects;
     };
 

cvat-core/src/common.ts

@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022 CVAT.ai Corporation
+// Copyright (C) 2022-2023s CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -92,33 +92,22 @@ export function checkObjectType(name, value, type, instance?): boolean {
 }
 
 export class FieldUpdateTrigger {
-    constructor() {
-        let updatedFlags = {};
-
-        Object.defineProperties(
-            this,
-            Object.freeze({
-                reset: {
-                    value: () => {
-                        updatedFlags = {};
-                    },
-                },
-                update: {
-                    value: (name) => {
-                        updatedFlags[name] = true;
-                    },
-                },
-                getUpdated: {
-                    value: (data, propMap = {}) => {
-                        const result = {};
-                        for (const updatedField of Object.keys(updatedFlags)) {
-                            result[propMap[updatedField] || updatedField] = data[updatedField];
-                        }
-                        return result;
-                    },
-                },
-            }),
-        );
+    #updatedFlags: Record<string, boolean> = {};
+
+    reset(): void {
+        this.#updatedFlags = {};
+    }
+
+    update(name: string): void {
+        this.#updatedFlags[name] = true;
+    }
+
+    getUpdated(data: object, propMap: Record<string, string> = {}): Record<string, unknown> {
+        const result = {};
+        for (const updatedField of Object.keys(this.#updatedFlags)) {
+            result[propMap[updatedField] || updatedField] = data[updatedField];
+        }
+        return result;
     }
 }
 

cvat-core/src/config.ts

@@ -5,7 +5,6 @@
 
 const config = {
     backendAPI: '/api',
-    proxy: false,
     organizationID: null,
     origin: '',
     uploadChunkSize: 100,

cvat-core/src/enums.ts

@@ -8,12 +8,19 @@ export enum ShareFileType {
     REG = 'REG',
 }
 
+export enum ChunkType {
+    IMAGESET = 'imageset',
+    VIDEO = 'video',
+}
+
 export enum TaskStatus {
     ANNOTATION = 'annotation',
     VALIDATION = 'validation',
     COMPLETED = 'completed',
 }
 
+export type ProjectStatus = TaskStatus;
+
 export enum JobStage {
     ANNOTATION = 'annotation',
     VALIDATION = 'validation',

cvat-core/src/labels.ts

@@ -1,21 +1,14 @@
 // Copyright (C) 2019-2022 Intel Corporation
+// Copyright (C) 2023 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
+import {
+    AttrInputType, LabelType, SerializedAttribute, SerializedLabel,
+} from 'server-response-types';
 import { ShapeType, AttributeType } from './enums';
 import { ArgumentError } from './exceptions';
 
-type AttrInputType = 'select' | 'radio' | 'checkbox' | 'number' | 'text';
-
-export interface RawAttribute {
-    name: string;
-    mutable: boolean;
-    input_type: AttrInputType;
-    default_value: string;
-    values: string[];
-    id?: number;
-}
-
 export class Attribute {
     public id?: number;
     public defaultValue: string;
@@ -24,7 +17,7 @@ export class Attribute {
     public name: string;
     public values: string[];
 
-    constructor(initialData: RawAttribute) {
+    constructor(initialData: SerializedAttribute) {
         const data = {
             id: undefined,
             default_value: undefined,
@@ -75,8 +68,8 @@ export class Attribute {
         );
     }
 
-    toJSON(): RawAttribute {
-        const object: RawAttribute = {
+    toJSON(): SerializedAttribute {
+        const object: SerializedAttribute = {
             name: this.name,
             mutable: this.mutable,
             input_type: this.inputType,
@@ -92,19 +85,6 @@ export class Attribute {
     }
 }
 
-type LabelType = 'rectangle' | 'polygon' | 'polyline' | 'points' | 'ellipse' | 'cuboid' | 'skeleton' | 'mask' | 'tag' | 'any';
-export interface RawLabel {
-    id?: number;
-    name: string;
-    color?: string;
-    type: LabelType;
-    svg?: string;
-    sublabels?: RawLabel[];
-    has_parent?: boolean;
-    deleted?: boolean;
-    attributes: RawAttribute[];
-}
-
 export class Label {
     public name: string;
     public readonly id?: number;
@@ -116,9 +96,10 @@ export class Label {
         svg: string;
     } | null;
     public deleted: boolean;
+    public patched: boolean;
     public readonly hasParent?: boolean;
 
-    constructor(initialData: RawLabel) {
+    constructor(initialData: SerializedLabel) {
         const data = {
             id: undefined,
             name: undefined,
@@ -127,6 +108,7 @@ export class Label {
             structure: undefined,
             has_parent: false,
             deleted: false,
+            patched: false,
             svg: undefined,
             elements: undefined,
             sublabels: undefined,
@@ -167,13 +149,19 @@ export class Label {
                             throw new ArgumentError(`Name must be a string, but ${typeof name} was given`);
                         }
                         data.name = name;
+                        if (Number.isInteger(data.id)) {
+                            data.patched = true;
+                        }
                     },
                 },
                 color: {
                     get: () => data.color,
                     set: (color) => {
                         if (typeof color === 'string' && color.match(/^#[0-9a-f]{6}$|^$/)) {
                             data.color = color;
+                            if (Number.isInteger(data.id)) {
+                                data.patched = true;
+                            }
                         } else {
                             throw new ArgumentError('Trying to set wrong color format');
                         }
@@ -203,15 +191,21 @@ export class Label {
                         data.deleted = value;
                     },
                 },
+                patched: {
+                    get: () => data.patched,
+                    set: (value) => {
+                        data.patched = value;
+                    },
+                },
                 hasParent: {
                     get: () => data.has_parent,
                 },
             }),
         );
     }
 
-    toJSON(): RawLabel {
-        const object: RawLabel = {
+    toJSON(): SerializedLabel {
+        const object: SerializedLabel = {
             name: this.name,
             attributes: [...this.attributes.map((el) => el.toJSON())],
             type: this.type,
@@ -225,10 +219,6 @@ export class Label {
             object.id = this.id;
         }
 
-        if (this.deleted) {
-            object.deleted = this.deleted;
-        }
-
         if (this.type) {
             object.type = this.type;
         }