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/components/editor/review-bar/review-bar.tsx

@@ -424,12 +424,14 @@ export const MiaReviewBar = observer(
                   onPointerDown={previousTask}
                 />
               )}
-              <ActionButtons
-                icon="arrowForward"
-                tooltipTx="next-task-tooltip"
-                tooltipPosition="top"
-                onPointerDown={nextTask}
-              />
+              {store?.reviewStrategy?.supportsNextTask && (
+                <ActionButtons
+                  icon="arrowForward"
+                  tooltipTx="next-task-tooltip"
+                  tooltipPosition="top"
+                  onPointerDown={nextTask}
+                />
+              )}
             </ReviewToolsContainer>
           </ReviewContainer>
         </ReviewBarSheet>

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,85 @@
+import { getDvAnnotationTask, getTaskIdFromUrl } 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<DVReviewTask> {
+  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 supportsPreviousTask(): boolean {
+    return false;
+  }
+
+  public supportsNextTask(): boolean {
+    return false;
+  }
+
+  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() {
+    const taskId = getTaskIdFromUrl();
+    if (!taskId) throw new Error("No DV task specified in URL.");
+
+    const dvAnnotationTask = await getDvAnnotationTask(taskId);
+
+    if (!dvAnnotationTask) throw new Error("DV Task not found.");
+    this.setCurrentTask(new DVReviewTask(dvAnnotationTask));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  protected async importAnnotations(): Promise<void> {}
+
+  public postProcessLoadedTask(): void {
+    const document = this.getDocument();
+    if (this.currentTask) {
+      this.currentTask.addGroupsAndLayers(document);
+    }
+    document.requestSave();
+  }
+
+  public toJSON(): ReviewStrategySnapshot {
+    return {
+      backend: "dv",
+      currentReviewTask: this.currentTask
+        ? this.currentTask.toJSON()
+        : undefined,
+    };
+  }
+}