Fix duplicating compound volume annotations (#8743)

The tracingstore needs to be able to get the datasource for an
annotation in order to duplicate it. This is for fallback layer handling
and has been introduced in its current form in #8405

The wk side answers this with either postgres (stored annotations) or a
special temporary store (for temporary annotations). This PR includes
compound annotations in this handling for temporary annotations.

### URL of deployed dev instance (used for testing):
- https://fixduplicatecompound.webknossos.xyz

### Steps to test:
- Create volume task type, project, tasks
- Trace some
- View compound annotation
- hit duplicate
- Should result in a usable explorative annotation.

### Issues:
- fixes #8736

------
- [x] Added changelog entry (create a `$PR_NUMBER.md` file in
`unreleased_changes` or use `./tools/create-changelog-entry.py`)
- [x] Considered [common edge
cases](../blob/master/.github/common_edge_cases.md)
- [x] Needs datastore update after deployment

Author: fm3

app/models/annotation/AnnotationDataSourceTemporaryStore.scala

@@ -11,6 +11,7 @@ import scala.concurrent.duration.DurationInt
 /**
   * Used to store a mapping from annotation id to datasource. This makes it possible for WK to answer a
   * /tracingstores/:name/dataSource request before an annotation is created. This happens when uploading an annotation.
+  * It also provides a mapping from temporary/compound annotation id (e.g. taskTypeId, projectId) to datasource
   */
 class AnnotationDataSourceTemporaryStore @Inject()(temporaryStore: TemporaryStore[ObjectId, DataSourceLike]) {
 

app/models/annotation/handler/AnnotationInformationHandler.scala

@@ -1,12 +1,14 @@
 package models.annotation.handler
 
-import com.scalableminds.util.accesscontext.DBAccessContext
+import com.scalableminds.util.accesscontext.{DBAccessContext, GlobalAccessContext}
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
+
 import javax.inject.Inject
 import models.annotation.AnnotationType.AnnotationType
 import models.annotation._
 import models.user.User
 import com.scalableminds.util.objectid.ObjectId
+import models.dataset.{DatasetDAO, DatasetService}
 
 import scala.annotation.{nowarn, tailrec}
 import scala.concurrent.ExecutionContext
@@ -24,6 +26,10 @@ class AnnotationInformationHandlerSelector @Inject()(projectInformationHandler:
 
 trait AnnotationInformationHandler extends FoxImplicits {
 
+  def datasetDAO: DatasetDAO
+  def datasetService: DatasetService
+  def annotationDataSourceTemporaryStore: AnnotationDataSourceTemporaryStore
+
   implicit val ec: ExecutionContext
 
   def cache: Boolean = true
@@ -43,6 +49,7 @@ trait AnnotationInformationHandler extends FoxImplicits {
         case List()       => true
         case head :: tail => head._dataset == datasetId && allOnSameDatasetIter(tail, datasetId)
       }
+
     annotations match {
       case List() => Fox.successful(true)
       case head :: _ =>
@@ -56,4 +63,11 @@ trait AnnotationInformationHandler extends FoxImplicits {
   def assertNonEmpty[T](seq: List[T]): Fox[Unit] =
     if (seq.isEmpty) Fox.failure("no annotations")
     else Fox.successful(())
+
+  protected def registerDataSourceInTemporaryStore(temporaryAnnotationId: ObjectId, datasetId: ObjectId): Fox[Unit] =
+    for {
+      dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> "dataset.notFoundForAnnotation"
+      dataSource <- datasetService.dataSourceFor(dataset).flatMap(_.toUsable.toFox) ?~> "dataset.dataSource.notUsable"
+      _ = annotationDataSourceTemporaryStore.store(temporaryAnnotationId, dataSource)
+    } yield ()
 }

app/models/annotation/handler/ProjectInformationHandler.scala

@@ -8,15 +8,20 @@ import models.annotation._
 import models.project.ProjectDAO
 import models.user.{User, UserService}
 import com.scalableminds.util.objectid.ObjectId
+import models.dataset.{DatasetDAO, DatasetService}
 import models.task.TaskDAO
 
 import scala.concurrent.ExecutionContext
 
-class ProjectInformationHandler @Inject()(annotationDAO: AnnotationDAO,
-                                          projectDAO: ProjectDAO,
-                                          taskDAO: TaskDAO,
-                                          userService: UserService,
-                                          annotationMerger: AnnotationMerger)(implicit val ec: ExecutionContext)
+class ProjectInformationHandler @Inject()(
+    annotationDAO: AnnotationDAO,
+    projectDAO: ProjectDAO,
+    userService: UserService,
+    annotationMerger: AnnotationMerger,
+    taskDAO: TaskDAO,
+    val datasetService: DatasetService,
+    val datasetDAO: DatasetDAO,
+    val annotationDataSourceTemporaryStore: AnnotationDataSourceTemporaryStore)(implicit val ec: ExecutionContext)
     extends AnnotationInformationHandler
     with FoxImplicits {
 
@@ -30,6 +35,7 @@ class ProjectInformationHandler @Inject()(annotationDAO: AnnotationDAO,
       _ <- assertAllOnSameDataset(annotations)
       _ <- assertNonEmpty(annotations) ?~> "project.noAnnotations"
       datasetId <- annotations.headOption.map(_._dataset).toFox
+      _ <- registerDataSourceInTemporaryStore(projectId, datasetId)
       taskBoundingBoxes <- taskDAO.findTaskBoundingBoxesByAnnotationIds(annotations.map(_._id))
       mergedAnnotation <- annotationMerger.mergeN(projectId,
                                                   toTemporaryStore = true,

app/models/annotation/handler/SavedTracingInformationHandler.scala

@@ -7,16 +7,19 @@ import com.scalableminds.util.tools.{Fox, FoxImplicits}
 
 import javax.inject.Inject
 import models.annotation._
-import models.dataset.DatasetDAO
+import models.dataset.{DatasetDAO, DatasetService}
 import models.user.{User, UserService}
 import com.scalableminds.util.objectid.ObjectId
 
 import scala.concurrent.ExecutionContext
 
-class SavedTracingInformationHandler @Inject()(annotationDAO: AnnotationDAO,
-                                               datasetDAO: DatasetDAO,
-                                               annotationRestrictionDefults: AnnotationRestrictionDefaults,
-                                               userService: UserService)(implicit val ec: ExecutionContext)
+class SavedTracingInformationHandler @Inject()(
+    annotationDAO: AnnotationDAO,
+    annotationRestrictionDefults: AnnotationRestrictionDefaults,
+    userService: UserService,
+    val datasetService: DatasetService,
+    val datasetDAO: DatasetDAO,
+    val annotationDataSourceTemporaryStore: AnnotationDataSourceTemporaryStore)(implicit val ec: ExecutionContext)
     extends AnnotationInformationHandler
     with Formatter
     with FoxImplicits {

app/models/annotation/handler/TaskInformationHandler.scala

@@ -2,21 +2,27 @@ package models.annotation.handler
 
 import com.scalableminds.util.accesscontext.DBAccessContext
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
+
 import javax.inject.Inject
 import models.annotation._
 import models.task.TaskDAO
 import models.user.{User, UserService}
 import models.annotation.AnnotationState._
 import models.project.ProjectDAO
 import com.scalableminds.util.objectid.ObjectId
+import models.dataset.{DatasetDAO, DatasetService}
 
 import scala.concurrent.ExecutionContext
 
-class TaskInformationHandler @Inject()(taskDAO: TaskDAO,
-                                       annotationDAO: AnnotationDAO,
-                                       userService: UserService,
-                                       annotationMerger: AnnotationMerger,
-                                       projectDAO: ProjectDAO)(implicit val ec: ExecutionContext)
+class TaskInformationHandler @Inject()(
+    taskDAO: TaskDAO,
+    annotationDAO: AnnotationDAO,
+    userService: UserService,
+    annotationMerger: AnnotationMerger,
+    projectDAO: ProjectDAO,
+    val datasetService: DatasetService,
+    val datasetDAO: DatasetDAO,
+    val annotationDataSourceTemporaryStore: AnnotationDataSourceTemporaryStore)(implicit val ec: ExecutionContext)
     extends AnnotationInformationHandler
     with FoxImplicits {
 
@@ -31,6 +37,7 @@ class TaskInformationHandler @Inject()(taskDAO: TaskDAO,
       user <- userOpt.toFox ?~> "user.notAuthorised"
       project <- projectDAO.findOne(task._project)
       datasetId <- finishedAnnotations.headOption.map(_._dataset).toFox
+      _ <- registerDataSourceInTemporaryStore(taskId, datasetId)
       taskBoundingBoxes <- taskDAO.findTaskBoundingBoxesByAnnotationIds(annotations.map(_._id))
       mergedAnnotation <- annotationMerger.mergeN(task._id,
                                                   toTemporaryStore = true,

app/models/annotation/handler/TaskTypeInformationHandler.scala

@@ -2,20 +2,26 @@ package models.annotation.handler
 
 import com.scalableminds.util.accesscontext.DBAccessContext
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
+
 import javax.inject.Inject
 import models.annotation._
 import models.task.{TaskDAO, TaskTypeDAO}
 import models.user.{User, UserService}
 import models.annotation.AnnotationState._
 import com.scalableminds.util.objectid.ObjectId
+import models.dataset.{DatasetDAO, DatasetService}
 
 import scala.concurrent.ExecutionContext
 
-class TaskTypeInformationHandler @Inject()(taskTypeDAO: TaskTypeDAO,
-                                           taskDAO: TaskDAO,
-                                           userService: UserService,
-                                           annotationDAO: AnnotationDAO,
-                                           annotationMerger: AnnotationMerger)(implicit val ec: ExecutionContext)
+class TaskTypeInformationHandler @Inject()(
+    taskTypeDAO: TaskTypeDAO,
+    taskDAO: TaskDAO,
+    userService: UserService,
+    annotationDAO: AnnotationDAO,
+    annotationMerger: AnnotationMerger,
+    val datasetService: DatasetService,
+    val datasetDAO: DatasetDAO,
+    val annotationDataSourceTemporaryStore: AnnotationDataSourceTemporaryStore)(implicit val ec: ExecutionContext)
     extends AnnotationInformationHandler
     with FoxImplicits {
 
@@ -32,6 +38,7 @@ class TaskTypeInformationHandler @Inject()(taskTypeDAO: TaskTypeDAO,
       _ <- assertNonEmpty(finishedAnnotations) ?~> "taskType.noAnnotations"
       user <- userOpt.toFox ?~> "user.notAuthorised"
       datasetId <- finishedAnnotations.headOption.map(_._dataset).toFox
+      _ <- registerDataSourceInTemporaryStore(taskTypeId, datasetId)
       taskBoundingBoxes <- taskDAO.findTaskBoundingBoxesByAnnotationIds(annotations.map(_._id))
       mergedAnnotation <- annotationMerger.mergeN(taskTypeId,
                                                   toTemporaryStore = true,

conf/messages

@@ -67,7 +67,7 @@ user.configuration.dataset.invalid=Dataset configuration is invalid
 user.configuration.dataset.updated=Dataset configuration updated
 user.email.invalid=At least one Email is invalid
 user.notAuthorised=You are not authorized to view this resource. Please log in.
-user.id.notFound=We could not find a user id in the request.
+user.id.notFound=Could not find a user id in the request.
 user.id.invalid=The provided user id is invalid.
 user.creation.failed=Failed to create user
 user.team.memberships.failed=Failed to retrieve team memberships for user
@@ -177,7 +177,7 @@ project.remove.success=Project was removed successfully
 project.remove.failure=Project could not be removed
 project.notFound=Project could not be found
 project.update.failed=Project update failed
-project.noAnnotations=We could not find annotations for this project
+project.noAnnotations=Could not find annotations for this project
 project.increaseTaskInstances.negative=Cannot increment task counts by negative number
 project.list.failed=Failed to retrieve list of projects.
 project.creation.failed=Failed to create project.
@@ -283,7 +283,7 @@ task.notFound=Task could not be found
 task.removed=Task was removed
 task.remove.failed=Task removal failed
 task.editSuccess=Task successfully edited
-task.noAnnotations=We could not find finished annotations for this task
+task.noAnnotations=Could not find finished annotations for this task
 task.annotation.failed=Failed to retrieve annotations for this task
 task.id.invalid=The provided task id is invalid.
 
@@ -293,7 +293,7 @@ taskType.editSuccess=Task type successfully edited
 taskType.notFound=Selected task type does not exist
 taskType.deleteSuccess=Task type “{0}” successfully deleted
 taskType.deleteFailure=Task type “{0}” deletion failed
-taskType.noAnnotations=We could not find finished annotations for this task type
+taskType.noAnnotations=Could not find finished annotations for this task type
 taskType.id.invalid=The provided task type id is invalid.
 taskType.tracingTypeImmutable=Annotation types of task types are immutable. Consider creating a new task type.
 taskType.magRestrictionsImmutable=Mag restrictions of task types are immutable. Consider creating a new task type.

unreleased_changes/8743.md

@@ -0,0 +1,2 @@
+### Fixed
+- Fixed a bug where duplicating a compound annotation would fail if it has volume annotation layers.