Integration of VISIAN into DV

apps/editor/src/app/root-store.ts

@@ -1,10 +1,11 @@
 import { i18n, LocalForageBackend } from "@visian/ui-shared";
-import { isFromWHO, readFileFromURL } from "@visian/utils";
+import { isFromDV, isFromWHO, readFileFromURL } from "@visian/utils";
 import React from "react";
 
 import { storePersistInterval } from "../constants";
 import { RootStore } from "../models";
 import { WHOReviewStrategy } from "../models/review-strategy";
+import { DVReviewStrategy } from "../models/review-strategy/dv-review-strategy";
 
 export const storageBackend = new LocalForageBackend(
   storePersistInterval,
@@ -59,6 +60,11 @@ export const setupRootStore = async () => {
       store.setReviewStrategy(new WHOReviewStrategy({ store }));
       store.reviewStrategy?.loadTask();
     }
+
+    if (isFromDV()) {
+      store.setReviewStrategy(new DVReviewStrategy({ store }));
+      store.reviewStrategy?.loadTask();
+    }
   })();
 
   window.addEventListener("beforeunload", (event) => {

apps/editor/src/models/editor/document.ts

@@ -439,6 +439,11 @@ export class Document
     }
   };
 
+  public removeAnnotationGroup = (group: AnnotationGroup): void => {
+    const index = this.layerIds.indexOf(group.id);
+    this.layerIds.splice(index, 1);
+  };
+
   public getFirstUnusedColor = (
     defaultColor = defaultAnnotationColor,
   ): string => {

apps/editor/src/models/review-strategy/dv-review-strategy.ts

@@ -0,0 +1,75 @@
+import { getDVTask } from "@visian/utils";
+
+import { RootStore } from "../root";
+import { DVReviewTask } from "./dv-review-task";
+import { ReviewStrategy } from "./review-strategy";
+import { ReviewStrategySnapshot } from "./review-strategy-snapshot";
+
+export class DVReviewStrategy extends ReviewStrategy {
+  public static fromSnapshot(
+    store: RootStore,
+    snapshot?: ReviewStrategySnapshot,
+  ) {
+    if (!snapshot) return undefined;
+    if (snapshot.backend === "dv") {
+      return new DVReviewStrategy({
+        store,
+        currentReviewTask: snapshot.currentReviewTask
+          ? DVReviewTask.fromSnapshot(snapshot.currentReviewTask)
+          : undefined,
+      });
+    }
+    return undefined;
+  }
+
+  constructor({
+    store,
+    currentReviewTask,
+  }: {
+    store: RootStore;
+    currentReviewTask?: DVReviewTask;
+  }) {
+    super({ store });
+    if (currentReviewTask) this.setCurrentTask(currentReviewTask);
+  }
+
+  public async nextTask(): Promise<void> {
+    throw new Error("Next task is not implemented in the DV strategy!");
+  }
+
+  public async previousTask() {
+    throw new Error("Previous task is not implemented in the DV strategy!");
+  }
+
+  public async saveTask(): Promise<void> {
+    this.currentTask?.save(this.getDocument());
+  }
+
+  protected async buildTask() {
+    // TODO: receiving the task id from the url is not implemented yet
+    const dvTask = await getDVTask("dv-task-id");
+
+    if (!dvTask) throw new Error("DV Task not found.");
+    this.setCurrentTask(new DVReviewTask(dvTask));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  protected async importAnnotations(): Promise<void> {}
+
+  public loadTaskPostProcessing(): void {
+    const document = this.getDocument();
+    const reviewTask = this.currentTask as DVReviewTask;
+    reviewTask.addGroupsAndLayers(document);
+
+    document.requestSave();
+  }
+
+  public toJSON(): ReviewStrategySnapshot {
+    return {
+      backend: "dv",
+      currentReviewTask: this.currentTask
+        ? (this.currentTask as DVReviewTask).toJSON()
+        : undefined,
+    };
+  }
+}