Add switch orga to legacy routes

CHANGELOG.unreleased.md

@@ -21,6 +21,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 
 ### Fixed
 - Fixed that listing datasets with the `api/datasets` route without compression failed due to missing permissions regarding public datasets. [#8249](https://github.com/scalableminds/webknossos/pull/8249)
+- Fixed the organization switching feature for datasets opened via old links. [#8257](https://github.com/scalableminds/webknossos/pull/8257)
 - Fixed that the frontend did not ensure a minium length for annotation layer names. Moreover, names starting with a `.` are also disallowed now. [#8244](https://github.com/scalableminds/webknossos/pull/8244)
 - Fixed a bug where in the add remote dataset view the dataset name setting was not in sync with the datasource setting of the advanced tab making the form not submittable. [#8245](https://github.com/scalableminds/webknossos/pull/8245)
 - Fix read and update dataset route for versions 8 and lower. [#8263](https://github.com/scalableminds/webknossos/pull/8263)

app/controllers/DatasetController.scala

@@ -20,7 +20,7 @@ import models.folder.FolderService
 import models.organization.OrganizationDAO
 import models.team.{TeamDAO, TeamService}
 import models.user.{User, UserDAO, UserService}
-import net.liftweb.common.{Failure, Full}
+import net.liftweb.common.{Failure, Full, Empty}
 import play.api.i18n.{Messages, MessagesProvider}
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
@@ -85,6 +85,7 @@ class DatasetController @Inject()(userService: UserService,
                                   thumbnailService: ThumbnailService,
                                   thumbnailCachingService: ThumbnailCachingService,
                                   conf: WkConf,
+                                  authenticationController: AuthenticationController,
                                   analyticsService: AnalyticsService,
                                   mailchimpClient: MailchimpClient,
                                   wkExploreRemoteLayerService: WKExploreRemoteLayerService,
@@ -406,13 +407,35 @@ class DatasetController @Inject()(userService: UserService,
   def getDatasetIdFromNameAndOrganization(datasetName: String, organizationId: String): Action[AnyContent] =
     sil.UserAwareAction.async { implicit request =>
       for {
-        dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organizationId) ?~> notFoundMessage(datasetName) ~> NOT_FOUND
-      } yield
-        Ok(
-          Json.obj("id" -> dataset._id,
-                   "name" -> dataset.name,
-                   "organization" -> dataset._organization,
-                   "directoryName" -> dataset.directoryName))
+        datasetBox <- datasetDAO.findOneByNameAndOrganization(datasetName, organizationId).futureBox
+        result <- (datasetBox match {
+          case Full(dataset) =>
+            Fox.successful(
+              Ok(
+                Json.obj("id" -> dataset._id,
+                         "name" -> dataset.name,
+                         "organization" -> dataset._organization,
+                         "directoryName" -> dataset.directoryName)))
+          case Empty =>
+            for {
+              dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organizationId)(GlobalAccessContext)
+              isAccessibleResult <- authenticationController.accessibleBySwitching(Some(dataset._id.toString),
+                                                                                   None,
+                                                                                   None)(request)
+              result <- isAccessibleResult.header.status match {
+                case 200 =>
+                  Fox.successful(
+                    Ok(
+                      Json.obj("id" -> dataset._id,
+                               "name" -> dataset.name,
+                               "organization" -> dataset._organization,
+                               "directoryName" -> dataset.directoryName)))
+                case _ => Fox.failure(notFoundMessage(datasetName))
+              }
+            } yield result
+          case _ => Fox.failure(notFoundMessage(datasetName))
+        }) ?~> notFoundMessage(datasetName) ~> NOT_FOUND
+      } yield result
     }
 
   private def notFoundMessage(datasetName: String)(implicit ctx: DBAccessContext, m: MessagesProvider): String =

app/models/dataset/Dataset.scala

@@ -430,16 +430,15 @@ class DatasetDAO @Inject()(sqlClient: SqlClient, datasetLayerDAO: DatasetLayerDA
       exists <- r.headOption
     } yield exists
 
-  // Datasets are looked up by name and directoryName, as datasets from before dataset renaming was possible
-  // should have their directory name equal to their name during the time the link was created. This heuristic should
-  // have the best expected outcome as it expect to find the dataset by directoryName and it to be the oldest. In case
-  // someone renamed a dataset and created the link with a tool that uses the outdated dataset identification, the dataset should still be found.
+  // Legacy links to Datasets used their name and organizationId as identifier. In #8075 name was changed to directoryName.
+  // Thus, interpreting the name as the directory name should work, as changing the directory name is not possible.
+  // This way of looking up datasets should only be used for backwards compatibility.
   def findOneByNameAndOrganization(name: String, organizationId: String)(implicit ctx: DBAccessContext): Fox[Dataset] =
     for {
       accessQuery <- readAccessQuery
       r <- run(q"""SELECT $columns
                    FROM $existingCollectionName
-                   WHERE (directoryName = $name OR name = $name)
+                   WHERE (directoryName = $name)
                    AND _organization = $organizationId
                    AND $accessQuery
                    ORDER BY created ASC

frontend/javascripts/components/redirect.tsx

@@ -1,46 +1,41 @@
 import type { RouteComponentProps } from "react-router-dom";
 import { withRouter } from "react-router-dom";
-import React from "react";
+import type React from "react";
+import { useEffectOnlyOnce } from "libs/react_hooks";
 
 type Props = {
   redirectTo: () => Promise<string>;
   history: RouteComponentProps["history"];
   pushToHistory?: boolean;
 };
 
-class AsyncRedirect extends React.PureComponent<Props> {
-  static defaultProps = {
-    pushToHistory: true,
-  };
-
-  componentDidMount() {
-    this.redirect();
-  }
-
-  async redirect() {
-    const newPath = await this.props.redirectTo();
+const AsyncRedirect: React.FC<Props> = ({ redirectTo, history, pushToHistory = true }) => {
+  useEffectOnlyOnce(() => {
+    const redirect = async () => {
+      const newPath = await redirectTo();
+
+      if (newPath.startsWith(location.origin)) {
+        // The link is absolute which react-router does not support
+        // apparently. See https://stackoverflow.com/questions/42914666/react-router-external-link
+        if (pushToHistory) {
+          location.assign(newPath);
+        } else {
+          location.replace(newPath);
+        }
+        return;
+      }
 
-    if (newPath.startsWith(location.origin)) {
-      // The link is absolute which react-router does not support
-      // apparently. See https://stackoverflow.com/questions/42914666/react-router-external-link
-      if (this.props.pushToHistory) {
-        location.assign(newPath);
+      if (pushToHistory) {
+        history.push(newPath);
       } else {
-        location.replace(newPath);
+        history.replace(newPath);
       }
-      return;
-    }
+    };
 
-    if (this.props.pushToHistory) {
-      this.props.history.push(newPath);
-    } else {
-      this.props.history.replace(newPath);
-    }
-  }
+    redirect();
+  });
 
-  render() {
-    return null;
-  }
-}
+  return null;
+};
 
 export default withRouter<RouteComponentProps & Props, any>(AsyncRedirect);