Fix nml upload with only ds name set by using user's orga as fallback

scalableminds · Dec 13, 2024 · 648c5e3 · 648c5e3
1 parent 8c842c3
commit 648c5e3
Show file tree

Hide file tree

Showing 4 changed files with 27 additions and 20 deletions.
diff --git a/app/controllers/AnnotationIOController.scala b/app/controllers/AnnotationIOController.scala
@@ -105,10 +105,12 @@ class AnnotationIOController @Inject()(
           request.body.dataParts("createGroupForEachFile").headOption.contains("true")
         val overwritingDatasetId: Option[String] =
           request.body.dataParts.get("datasetId").flatMap(_.headOption)
+        val userOrganizationId = request.identity._organization
         val attachedFiles = request.body.files.map(f => (f.ref.path.toFile, f.filename))
         for {
-          parsedFiles <- annotationUploadService
-            .extractFromFiles(attachedFiles, SharedParsingParameters(useZipName = true, overwritingDatasetId))
+          parsedFiles <- annotationUploadService.extractFromFiles(
+            attachedFiles,
+            SharedParsingParameters(useZipName = true, overwritingDatasetId, userOrganizationId))
           parsedFilesWrapped = annotationUploadService.wrapOrPrefixGroups(parsedFiles.parseResults,
                                                                           shouldCreateGroupForEachFile)
           parseResultsFiltered: List[NmlParseResult] = parsedFilesWrapped.filter(_.succeeded)

diff --git a/app/controllers/TaskController.scala b/app/controllers/TaskController.scala
@@ -82,14 +82,16 @@ class TaskController @Inject()(taskCreationService: TaskCreationService,
       _ <- bool2Fox(inputFiles.nonEmpty) ?~> "nml.file.notFound"
       jsonString <- body.dataParts.get("formJSON").flatMap(_.headOption) ?~> "format.json.missing"
       params <- JsonHelper.parseAndValidateJson[NmlTaskParameters](jsonString) ?~> "task.create.failed"
+      userOrganizationId = request.identity._organization
       _ <- taskCreationService.assertBatchLimit(inputFiles.length, List(params.taskTypeId))
       taskTypeIdValidated <- ObjectId.fromString(params.taskTypeId) ?~> "taskType.id.invalid"
       taskType <- taskTypeDAO.findOne(taskTypeIdValidated) ?~> "taskType.notFound" ~> NOT_FOUND
       project <- projectDAO
         .findOneByNameAndOrganization(params.projectName, request.identity._organization) ?~> "project.notFound" ~> NOT_FOUND
       _ <- Fox.assertTrue(userService.isTeamManagerOrAdminOf(request.identity, project._team))
-      extractedFiles <- nmlService.extractFromFiles(inputFiles.map(f => (f.ref.path.toFile, f.filename)),
-                                                    SharedParsingParameters(useZipName = false, isTaskUpload = true))
+      extractedFiles <- nmlService.extractFromFiles(
+        inputFiles.map(f => (f.ref.path.toFile, f.filename)),
+        SharedParsingParameters(useZipName = false, isTaskUpload = true, userOrganizationId = userOrganizationId))
       extractedTracingBoxesRaw: List[TracingBoxContainer] = extractedFiles.toBoxes
       extractedTracingBoxes: List[TracingBoxContainer] <- taskCreationService.addVolumeFallbackBoundingBoxes(
         extractedTracingBoxesRaw)

diff --git a/app/models/annotation/AnnotationUploadService.scala b/app/models/annotation/AnnotationUploadService.scala
@@ -27,6 +27,7 @@ case class UploadedVolumeLayer(tracing: VolumeTracing, dataZipLocation: String,
 
 case class SharedParsingParameters(useZipName: Boolean,
                                    overwritingDatasetId: Option[String] = None,
+                                   userOrganizationId: String,
                                    isTaskUpload: Boolean = false)
 
 class AnnotationUploadService @Inject()(tempFileService: TempFileService, nmlParser: NmlParser) extends LazyLogging {
@@ -53,8 +54,7 @@ class AnnotationUploadService @Inject()(tempFileService: TempFileService, nmlPar
       nmlParser.parse(
         name,
         inputStream,
-        sharedParsingParameters.overwritingDatasetId,
-        sharedParsingParameters.isTaskUpload,
+        sharedParsingParameters,
         basePath
       )
     parserOutput.futureBox.map {

diff --git a/app/models/annotation/nml/NmlParser.scala b/app/models/annotation/nml/NmlParser.scala
@@ -24,7 +24,7 @@ import com.scalableminds.webknossos.tracingstore.tracings.ColorGenerator
 import com.scalableminds.webknossos.tracingstore.tracings.skeleton.updating.TreeType
 import com.scalableminds.webknossos.tracingstore.tracings.skeleton.{MultiComponentTreeSplitter, TreeValidator}
 import com.typesafe.scalalogging.LazyLogging
-import models.annotation.UploadedVolumeLayer
+import models.annotation.{SharedParsingParameters, UploadedVolumeLayer}
 import models.dataset.DatasetDAO
 import net.liftweb.common.Box._
 import net.liftweb.common.{Box, Empty, Failure, Full}
@@ -48,13 +48,12 @@ class NmlParser @Inject()(datasetDAO: DatasetDAO) extends LazyLogging with Proto
 
   def parse(name: String,
             nmlInputStream: InputStream,
-            overwritingDatasetId: Option[String],
-            isTaskUpload: Boolean,
+            sharedParsingParameters: SharedParsingParameters,
             basePath: Option[String] = None)(implicit m: MessagesProvider,
                                              ec: ExecutionContext,
                                              ctx: DBAccessContext): Fox[NmlParseSuccessWithoutFile] =
     for {
-      nmlParsedParameters <- getParametersFromNML(nmlInputStream, name, overwritingDatasetId, isTaskUpload).toFox
+      nmlParsedParameters <- getParametersFromNML(nmlInputStream, name, sharedParsingParameters).toFox
       parsedResult <- nmlParametersToResult(nmlParsedParameters, basePath)
     } yield parsedResult
 
@@ -121,10 +120,10 @@ class NmlParser @Inject()(datasetDAO: DatasetDAO) extends LazyLogging with Proto
     } yield
       NmlParseSuccessWithoutFile(skeletonTracingOpt, volumeLayers, dataset._id, nmlParams.description, nmlParams.wkUrl)
 
-  private def getParametersFromNML(nmlInputStream: InputStream,
-                                   name: String,
-                                   overwritingDatasetId: Option[String],
-                                   isTaskUpload: Boolean)(implicit m: MessagesProvider): Box[NmlParsedParameters] =
+  private def getParametersFromNML(
+      nmlInputStream: InputStream,
+      name: String,
+      sharedParsingParameters: SharedParsingParameters)(implicit m: MessagesProvider): Box[NmlParsedParameters] =
     try {
       val nmlData = XML.load(nmlInputStream)
       for {
@@ -143,21 +142,23 @@ class NmlParser @Inject()(datasetDAO: DatasetDAO) extends LazyLogging with Proto
         _ <- TreeValidator.validateTrees(treesSplit, treeGroupsAfterSplit, branchPoints, comments)
         additionalAxisProtos <- parseAdditionalAxes(parameters \ "additionalAxes")
         datasetName = parseDatasetName(parameters \ "experiment")
-        datasetIdOpt = if (overwritingDatasetId.isDefined) overwritingDatasetId
+        datasetIdOpt = if (sharedParsingParameters.overwritingDatasetId.isDefined)
+          sharedParsingParameters.overwritingDatasetId
         else parseDatasetId(parameters \ "experiment")
-        organizationId = parseOrganizationId(parameters \ "experiment")
+        organizationId = parseOrganizationId(parameters \ "experiment", sharedParsingParameters.userOrganizationId)
         description = parseDescription(parameters \ "experiment")
         wkUrl = parseWkUrl(parameters \ "experiment")
         activeNodeId = parseActiveNode(parameters \ "activeNode")
         (editPosition, editPositionAdditionalCoordinates) = parseEditPosition(parameters \ "editPosition")
           .getOrElse((SkeletonTracingDefaults.editPosition, Seq()))
         editRotation = parseEditRotation(parameters \ "editRotation").getOrElse(SkeletonTracingDefaults.editRotation)
         zoomLevel = parseZoomLevel(parameters \ "zoomLevel").getOrElse(SkeletonTracingDefaults.zoomLevel)
-        taskBoundingBox: Option[BoundingBox] = if (isTaskUpload) parseTaskBoundingBox(parameters \ "taskBoundingBox")
+        taskBoundingBox: Option[BoundingBox] = if (sharedParsingParameters.isTaskUpload)
+          parseTaskBoundingBox(parameters \ "taskBoundingBox")
         else None
         userBoundingBoxes = parseBoundingBoxes(parameters \ "userBoundingBox")
       } yield {
-        if (!isTaskUpload) {
+        if (!sharedParsingParameters.isTaskUpload) {
           parseTaskBoundingBoxAsUserBoundingBox(parameters \ "taskBoundingBox", userBoundingBoxes)
             .map(asUserBoundingBox => userBoundingBoxes :+ asUserBoundingBox)
         }
@@ -379,8 +380,10 @@ class NmlParser @Inject()(datasetDAO: DatasetDAO) extends LazyLogging with Proto
   private def parseWkUrl(nodes: NodeSeq): Option[String] =
     nodes.headOption.map(node => getSingleAttribute(node, "wkUrl"))
 
-  private def parseOrganizationId(nodes: NodeSeq): String =
-    nodes.headOption.map(node => getSingleAttribute(node, "organization")).getOrElse("")
+  private def parseOrganizationId(nodes: NodeSeq, fallbackOrganization: String): String =
+    nodes.headOption
+      .map(node => getSingleAttributeOpt(node, "organization").getOrElse(fallbackOrganization))
+      .getOrElse(fallbackOrganization)
 
   private def parseActiveNode(nodes: NodeSeq): Option[Int] =
     nodes.headOption.flatMap(node => getSingleAttribute(node, "id").toIntOpt)