[WIP] Live Collab M3 - Proofreading (without segments list)

app/controllers/AnnotationController.scala

@@ -451,4 +451,12 @@ class AnnotationController @Inject()(
       }
     }
 
+  def releaseMutex(id: ObjectId): Action[AnyContent] = sil.SecuredAction.async { implicit request =>
+    logTime(slackNotificationService.noticeSlowRequest, durationThreshold = 1 second) {
+      for {
+        _ <- annotationMutexService.release(id, request.identity._id) ?~> "annotation.mutex.failed"
+      } yield Ok
+    }
+  }
+
 }

app/models/annotation/AnnotationMutexService.scala

@@ -68,6 +68,17 @@ class AnnotationMutexService @Inject()(val lifecycle: ApplicationLifecycle,
       _ <- annotationMutexDAO.upsertOne(mutex.copy(expiry = Instant.in(defaultExpiryTime)))
     } yield MutexResult(canEdit = true, None)
 
+  def release(annotationId: ObjectId, userId: ObjectId): Fox[Unit] =
+    for {
+      mutex <- annotationMutexDAO.findOne(annotationId).shiftBox
+      _ <- mutex match {
+        case Full(mutex) if mutex.userId == userId =>
+          annotationMutexDAO.deleteOne(annotationId).map(_ => ())
+        case _ =>
+          Fox.successful(())
+      }
+    } yield ()
+
   def publicWrites(mutexResult: MutexResult): Fox[JsObject] =
     for {
       userOpt <- Fox.runOptional(mutexResult.blockedByUser)(user => userDAO.findOne(user)(GlobalAccessContext))
@@ -114,4 +125,6 @@ class AnnotationMutexDAO @Inject()(sqlClient: SqlClient)(implicit ec: ExecutionC
   def deleteExpired(): Fox[Int] =
     run(q"DELETE FROM webknossos.annotation_mutexes WHERE expiry < NOW()".asUpdate)
 
+  def deleteOne(annotationId: ObjectId): Fox[Int] =
+    run(q"DELETE FROM webknossos.annotation_mutexes WHERE _annotation = $annotationId".asUpdate)
 }

conf/webknossos.latest.routes

@@ -155,6 +155,7 @@ DELETE        /annotations/:id
 POST          /annotations/:id/merge/:mergedTyp/:mergedId                                       controllers.AnnotationController.mergeWithoutType(id: ObjectId, mergedTyp: String, mergedId: ObjectId)
 GET           /annotations/:id/download                                                         controllers.AnnotationIOController.downloadWithoutType(id: ObjectId, version: Option[Long], skipVolumeData: Option[Boolean], volumeDataZipFormat: Option[String])
 POST          /annotations/:id/acquireMutex                                                     controllers.AnnotationController.tryAcquiringAnnotationMutex(id: ObjectId)
+DELETE        /annotations/:id/mutex                                                            controllers.AnnotationController.releaseMutex(id: ObjectId)
 
 GET           /annotations/:typ/:id/info                                                        controllers.AnnotationController.info(typ: String, id: ObjectId, timestamp: Option[Long])
 DELETE        /annotations/:typ/:id                                                             controllers.AnnotationController.cancel(typ: String, id: ObjectId)

frontend/javascripts/admin/rest_api.ts

@@ -719,6 +719,12 @@ export async function acquireAnnotationMutex(
   return { canEdit, blockedByUser };
 }
 
+export async function releaseAnnotationMutex(annotationId: string): Promise<void> {
+  await Request.receiveJSON(`/api/annotations/${annotationId}/mutex`, {
+    method: "DELETE",
+  });
+}
+
 export async function getTracingForAnnotationType(
   annotation: APIAnnotation,
   annotationLayerDescriptor: AnnotationLayerDescriptor,
@@ -767,8 +773,9 @@ export function getUpdateActionLog(
   annotationId: string,
   oldestVersion?: number,
   newestVersion?: number,
+  sortAscending: boolean = false,
 ): Promise<Array<APIUpdateActionBatch>> {
-  return doWithToken((token) => {
+  return doWithToken(async (token) => {
     const params = new URLSearchParams();
     params.set("token", token);
     if (oldestVersion != null) {
@@ -777,9 +784,14 @@ export function getUpdateActionLog(
     if (newestVersion != null) {
       params.set("newestVersion", newestVersion.toString());
     }
-    return Request.receiveJSON(
+    const log: APIUpdateActionBatch[] = await Request.receiveJSON(
       `${tracingStoreUrl}/tracings/annotation/${annotationId}/updateActionLog?${params}`,
     );
+
+    if (sortAscending) {
+      log.reverse();
+    }
+    return log;
   });
 }
 
@@ -1969,6 +1981,9 @@ export async function getAgglomeratesForSegmentsFromDatastore<T extends number |
   mappingId: string,
   segmentIds: Array<T>,
 ): Promise<Mapping> {
+  if (segmentIds.length === 0) {
+    return new Map();
+  }
   const segmentIdBuffer = serializeProtoListOfLong<T>(segmentIds);
   const listArrayBuffer: ArrayBuffer = await doWithToken((token) => {
     const params = new URLSearchParams({ token });
@@ -1999,6 +2014,9 @@ export async function getAgglomeratesForSegmentsFromTracingstore<T extends numbe
   annotationId: string,
   version?: number | null | undefined,
 ): Promise<Mapping> {
+  if (segmentIds.length === 0) {
+    return new Map();
+  }
   const params = new URLSearchParams({ annotationId });
   if (version != null) {
     params.set("version", version.toString());
@@ -2181,7 +2199,7 @@ export function getSynapseTypes(
   );
 }
 
-type MinCutTargetEdge = {
+export type MinCutTargetEdge = {
   position1: Vector3;
   position2: Vector3;
   segmentId1: number;

frontend/javascripts/libs/utils.ts

@@ -1,18 +1,12 @@
+import { Chalk } from "chalk";
 import dayjs from "dayjs";
 import naturalSort from "javascript-natural-sort";
 import window, { document, location } from "libs/window";
 import _ from "lodash";
 import type { APIDataset, APIUser, MapEntries } from "types/api_types";
+import type { BoundingBoxMinMaxType } from "types/bounding_box";
 import type { ArbitraryObject, Comparator } from "types/globals";
-import type {
-  BoundingBoxType,
-  ColorObject,
-  Point3,
-  TypedArray,
-  Vector3,
-  Vector4,
-  Vector6,
-} from "viewer/constants";
+import type { ColorObject, Point3, TypedArray, Vector3, Vector4, Vector6 } from "viewer/constants";
 import type { TreeGroup } from "viewer/model/types/tree_types";
 import type { BoundingBoxObject, NumberLike, SegmentGroup } from "viewer/store";
 
@@ -276,19 +270,23 @@ export function getRandomColor(): Vector3 {
   return randomColor as any as Vector3;
 }
 
-export function computeBoundingBoxFromArray(bb: Vector6): BoundingBoxType {
+export function computeBoundingBoxFromArray(bb: Vector6): BoundingBoxMinMaxType {
   const [x, y, z, width, height, depth] = bb;
   return {
     min: [x, y, z],
     max: [x + width, y + height, z + depth],
   };
 }
 
-export function computeBoundingBoxFromBoundingBoxObject(bb: BoundingBoxObject): BoundingBoxType {
+export function computeBoundingBoxFromBoundingBoxObject(
+  bb: BoundingBoxObject,
+): BoundingBoxMinMaxType {
   return computeBoundingBoxFromArray([...bb.topLeft, bb.width, bb.height, bb.depth]);
 }
 
-export function computeBoundingBoxObjectFromBoundingBox(bb: BoundingBoxType): BoundingBoxObject {
+export function computeBoundingBoxObjectFromBoundingBox(
+  bb: BoundingBoxMinMaxType,
+): BoundingBoxObject {
   const boundingBoxArray = computeArrayFromBoundingBox(bb);
   return {
     topLeft: [boundingBoxArray[0], boundingBoxArray[1], boundingBoxArray[2]],
@@ -298,7 +296,7 @@ export function computeBoundingBoxObjectFromBoundingBox(bb: BoundingBoxType): Bo
   };
 }
 
-export function computeArrayFromBoundingBox(bb: BoundingBoxType): Vector6 {
+export function computeArrayFromBoundingBox(bb: BoundingBoxMinMaxType): Vector6 {
   return [
     bb.min[0],
     bb.min[1],
@@ -309,11 +307,13 @@ export function computeArrayFromBoundingBox(bb: BoundingBoxType): Vector6 {
   ];
 }
 
-export function computeShapeFromBoundingBox(bb: BoundingBoxType): Vector3 {
+export function computeShapeFromBoundingBox(bb: BoundingBoxMinMaxType): Vector3 {
   return [bb.max[0] - bb.min[0], bb.max[1] - bb.min[1], bb.max[2] - bb.min[2]];
 }
 
-export function aggregateBoundingBox(boundingBoxes: Array<BoundingBoxObject>): BoundingBoxType {
+export function aggregateBoundingBox(
+  boundingBoxes: Array<BoundingBoxObject>,
+): BoundingBoxMinMaxType {
   if (boundingBoxes.length === 0) {
     return {
       min: [0, 0, 0],
@@ -344,8 +344,8 @@ export function aggregateBoundingBox(boundingBoxes: Array<BoundingBoxObject>): B
 }
 
 export function areBoundingBoxesOverlappingOrTouching(
-  firstBB: BoundingBoxType,
-  secondBB: BoundingBoxType,
+  firstBB: BoundingBoxMinMaxType,
+  secondBB: BoundingBoxMinMaxType,
 ) {
   let areOverlapping = true;
 
@@ -425,10 +425,6 @@ export function stringToNumberArray(s: string): Array<number> {
   return result;
 }
 
-export function concatVector3(a: Vector3, b: Vector3): Vector6 {
-  return [a[0], a[1], a[2], b[0], b[1], b[2]];
-}
-
 export function numberArrayToVector3(array: Array<number>): Vector3 {
   const output: Vector3 = [0, 0, 0];
 
@@ -1262,7 +1258,11 @@ export function notEmpty<TValue>(value: TValue | null | undefined): value is TVa
 
 export function isNumberMap(x: Map<NumberLike, NumberLike>): x is Map<number, number> {
   const { value } = x.entries().next();
-  return Boolean(value && typeof value[0] === "number");
+  if (value === undefined) {
+    // Let's assume a number map when the map is empty.
+    return true;
+  }
+  return Boolean(typeof value[0] === "number");
 }
 
 export function isBigInt(x: NumberLike): x is bigint {
@@ -1368,3 +1368,26 @@ export function areSetsEqual<T>(setA: Set<T>, setB: Set<T>) {
   }
   return true;
 }
+
+// ColoredLogger can be used to make certain log outputs easier to find (especially useful
+// when automatic logging of redux actions is enabled which makes the overall logging
+// very verbose).
+const chalk = new Chalk({ level: 3 });
+export const ColoredLogger = {
+  log: (...args: unknown[]) => {
+    // Simple wrapper to allow easy switching from colored to non-colored logs
+    console.log(...args);
+  },
+  logRed: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgRed(str), ...args);
+  },
+  logGreen: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgGreen(str), ...args);
+  },
+  logYellow: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgYellow(str), ...args);
+  },
+  logBlue: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgBlue(str), ...args);
+  },
+};

frontend/javascripts/libs/vector_input.tsx

@@ -2,7 +2,7 @@ import type { InputProps } from "antd";
 import * as Utils from "libs/utils";
 import _ from "lodash";
 import * as React from "react";
-import type { ServerBoundingBoxTypeTuple } from "types/api_types";
+import type { ServerBoundingBoxMinMaxTypeTuple } from "types/api_types";
 import type { Vector3, Vector6 } from "viewer/constants";
 import InputComponent from "viewer/view/components/input_component";
 
@@ -206,11 +206,11 @@ export class ArbitraryVectorInput extends BaseVector<number[]> {
 }
 
 type BoundingBoxInputProps = Omit<InputProps, "value"> & {
-  value: ServerBoundingBoxTypeTuple;
-  onChange: (arg0: ServerBoundingBoxTypeTuple) => void;
+  value: ServerBoundingBoxMinMaxTypeTuple;
+  onChange: (arg0: ServerBoundingBoxMinMaxTypeTuple) => void;
 };
 
-function boundingBoxToVector6(value: ServerBoundingBoxTypeTuple): Vector6 {
+function boundingBoxToVector6(value: ServerBoundingBoxMinMaxTypeTuple): Vector6 {
   const { topLeft, width, height, depth } = value;
   const [x, y, z] = topLeft;
   return [x, y, z, width, height, depth];

frontend/javascripts/test/backend-snapshot-tests/annotations.e2e.ts

@@ -11,14 +11,14 @@ import { createTreeMapFromTreeArray } from "viewer/model/reducers/skeletontracin
 import { diffTrees } from "viewer/model/sagas/skeletontracing_saga";
 import { getNullableSkeletonTracing } from "viewer/model/accessors/skeletontracing_accessor";
 import { getServerVolumeTracings } from "viewer/model/accessors/volumetracing_accessor";
-import { addVersionNumbers } from "viewer/model/sagas/save_saga";
-import * as UpdateActions from "viewer/model/sagas/update_actions";
+import * as UpdateActions from "viewer/model/sagas/volume/update_actions";
 import * as api from "admin/rest_api";
 import generateDummyTrees from "viewer/model/helpers/generate_dummy_trees";
 import { describe, it, beforeAll, expect } from "vitest";
 import { createSaveQueueFromUpdateActions } from "../helpers/saveHelpers";
 import type { SaveQueueEntry } from "viewer/store";
 import DiffableMap from "libs/diffable_map";
+import { addVersionNumbers } from "viewer/model/sagas/saving/save_queue_draining";
 
 const datasetId = "59e9cfbdba632ac2ab8b23b3";