restore backwards compatibility for old publish task in API v10 and older

app/controllers/WKRemoteDataStoreController.scala

@@ -84,6 +84,8 @@ class WKRemoteDataStoreController @Inject()(
           layersToLinkWithDirectoryName <- Fox.serialCombined(uploadInfo.layersToLink.getOrElse(List.empty))(l =>
             validateLayerToLink(l, user)) ?~> "dataset.upload.invalidLinkedLayers"
           newDatasetId = ObjectId.generate
+          _ <- Fox.runIf(request.body.requireUniqueName.getOrElse(false))(
+            datasetService.assertNewDatasetNameUnique(request.body.name, organization._id))
           dataset <- datasetService.createPreliminaryDataset(newDatasetId,
                                                              uploadInfo.name,
                                                              datasetService.generateDirectoryName(uploadInfo.name,

app/models/dataset/DatasetService.scala

@@ -66,6 +66,12 @@ class DatasetService @Inject()(organizationDAO: OrganizationDAO,
       _ <- Fox.fromBool(!name.startsWith(".")) ?~> "dataset.layer.name.invalid.startsWithDot"
     } yield ()
 
+  def assertNewDatasetNameUnique(name: String, organizationId: String): Fox[Unit] =
+    for {
+      exists <- datasetDAO.doesDatasetNameExistInOrganization(name, organizationId)
+      _ <- Fox.fromBool(!exists) ?~> "dataset.name.taken"
+    } yield ()
+
   def checkNameAvailable(organizationId: String, datasetName: String): Fox[Unit] =
     for {
       isDatasetNameAlreadyTaken <- datasetDAO.doesDatasetNameExistInOrganization(datasetName, organizationId)

webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/LegacyController.scala

@@ -12,18 +12,31 @@ import com.scalableminds.webknossos.datastore.models.{
 }
 import com.scalableminds.webknossos.datastore.models.datasource.{DataSourceId, UnusableDataSource, UsableDataSource}
 import com.scalableminds.webknossos.datastore.services.mesh.FullMeshRequest
+import com.scalableminds.webknossos.datastore.services.uploading.ReserveUploadInformation
 import com.scalableminds.webknossos.datastore.services.{
   DSRemoteWebknossosClient,
   DataSourceService,
   DataStoreAccessTokenService,
   DatasetCache,
   UserAccessRequest
 }
-import play.api.libs.json.Json
+import play.api.libs.json.{Json, OFormat}
 import play.api.mvc.{Action, AnyContent, PlayBodyParsers, RawBuffer, Result}
 
 import scala.concurrent.ExecutionContext
 
+case class LegacyReserveManualUploadInformation(
+    datasetName: String,
+    organization: String,
+    initialTeamIds: List[ObjectId],
+    folderId: Option[ObjectId],
+    requireUniqueName: Boolean = false,
+)
+object LegacyReserveManualUploadInformation {
+  implicit val jsonFormat: OFormat[LegacyReserveManualUploadInformation] =
+    Json.format[LegacyReserveManualUploadInformation]
+}
+
 class LegacyController @Inject()(
     accessTokenService: DataStoreAccessTokenService,
     remoteWebknossosClient: DSRemoteWebknossosClient,
@@ -32,6 +45,7 @@ class LegacyController @Inject()(
     meshController: DSMeshController,
     dataSourceController: DataSourceController,
     dataSourceService: DataSourceService,
+    dsRemoteWebknossosClient: DSRemoteWebknossosClient,
     datasetCache: DatasetCache
 )(implicit ec: ExecutionContext, bodyParsers: PlayBodyParsers)
     extends Controller
@@ -40,10 +54,32 @@ class LegacyController @Inject()(
 
   override def allowRemoteOrigin: Boolean = true
 
-  def reserveManualUploadV10: Action[AnyContent] =
-    Action.async { implicit request =>
-      Fox.failure(
-        "Reserving manual uploads via datastore route /datasets/reserveManualUpload is no longer available in this WEBKNOSSOS server version. This is an exception to the listed API compatibility. Please use a client version that supports API version 11 or newer.")
+  // To be called by people with disk access but not DatasetManager role. This way, they can upload a dataset manually on disk,
+  // and it can be put in a webknossos folder where they have access
+  def reserveManualUploadV10(): Action[LegacyReserveManualUploadInformation] =
+    Action.async(validateJson[LegacyReserveManualUploadInformation]) { implicit request =>
+      accessTokenService.validateAccessFromTokenContext(
+        UserAccessRequest.administrateDataSources(request.body.organization)) {
+        for {
+          reservedDatasetInfo <- dsRemoteWebknossosClient.reserveDataSourceUpload(
+            ReserveUploadInformation(
+              "aManualUpload",
+              request.body.datasetName,
+              request.body.organization,
+              0,
+              Some(List.empty),
+              None,
+              None,
+              request.body.initialTeamIds,
+              request.body.folderId,
+              Some(request.body.requireUniqueName)
+            )
+          ) ?~> "dataset.upload.validation.failed"
+        } yield
+          Ok(
+            Json.obj("newDatasetId" -> reservedDatasetInfo.newDatasetId,
+                     "directoryName" -> reservedDatasetInfo.directoryName))
+      }
     }
 
   def requestViaWebknossosV9(

webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/uploading/UploadService.scala

@@ -35,7 +35,8 @@ case class ReserveUploadInformation(
     totalFileSizeInBytes: Option[Long],
     layersToLink: Option[List[LegacyLinkedLayerIdentifier]],
     initialTeams: List[ObjectId], // team ids
-    folderId: Option[ObjectId])
+    folderId: Option[ObjectId],
+    requireUniqueName: Option[Boolean])
 object ReserveUploadInformation {
   implicit val reserveUploadInformation: OFormat[ReserveUploadInformation] = Json.format[ReserveUploadInformation]
 }