Add switch orga to legacy routes

app/controllers/AuthenticationController.scala

@@ -234,39 +234,61 @@ class AuthenticationController @Inject()(
    */
 
   def accessibleBySwitching(datasetId: Option[String],
+                            datasetDirectoryName: Option[String],
+                            organizationId: Option[String],
                             annotationId: Option[String],
                             workflowHash: Option[String]): Action[AnyContent] = sil.SecuredAction.async {
     implicit request =>
       for {
         datasetIdValidated <- Fox.runOptional(datasetId)(ObjectId.fromString(_))
+        _ <- Fox
+          .runIf(datasetDirectoryName.isDefined)(bool2Fox(organizationId.isDefined)) ?~> "Organization id must be defined if dataset directory name is defined."
+        _ <- Fox
+          .runIf(organizationId.isDefined)(bool2Fox(datasetDirectoryName.isDefined)) ?~> "Directory name must be defined if dataset organization id is defined."
         isSuperUser <- multiUserDAO.findOne(request.identity._multiUser).map(_.isSuperUser)
         selectedOrganization <- if (isSuperUser)
-          accessibleBySwitchingForSuperUser(datasetIdValidated, annotationId, workflowHash)
+          accessibleBySwitchingForSuperUser(datasetIdValidated,
+                                            datasetDirectoryName,
+                                            organizationId,
+                                            annotationId,
+                                            workflowHash)
         else
-          accessibleBySwitchingForMultiUser(request.identity._multiUser, datasetIdValidated, annotationId, workflowHash)
+          accessibleBySwitchingForMultiUser(request.identity._multiUser,
+                                            datasetIdValidated,
+                                            datasetDirectoryName,
+                                            organizationId,
+                                            annotationId,
+                                            workflowHash)
         _ <- bool2Fox(selectedOrganization._id != request.identity._organization) // User is already in correct orga, but still could not see dataset. Assume this had a reason.
         selectedOrganizationJs <- organizationService.publicWrites(selectedOrganization)
       } yield Ok(selectedOrganizationJs)
   }
 
   private def accessibleBySwitchingForSuperUser(datasetIdOpt: Option[ObjectId],
+                                                datasetDirectoryNameOpt: Option[String],
+                                                organizationIdOpt: Option[String],
                                                 annotationIdOpt: Option[String],
                                                 workflowHashOpt: Option[String]): Fox[Organization] = {
     implicit val ctx: DBAccessContext = GlobalAccessContext
-    (datasetIdOpt, annotationIdOpt, workflowHashOpt) match {
-      case (Some(datasetId), None, None) =>
+    (datasetIdOpt, datasetDirectoryNameOpt, organizationIdOpt, annotationIdOpt, workflowHashOpt) match {
+      case (Some(datasetId), None, None, None, None) =>
         for {
           dataset <- datasetDAO.findOne(datasetId)
           organization <- organizationDAO.findOne(dataset._organization)
         } yield organization
-      case (None, Some(annotationId), None) =>
+      case (None, Some(datasetDirectoryName), Some(organizationId), None, None) =>
+        for {
+          dataset <- datasetDAO.findOneByDirectoryNameAndOrganization(datasetDirectoryName, organizationId)
+          organization <- organizationDAO.findOne(dataset._organization)
+        } yield organization
+      case (None, None, None, Some(annotationId), None) =>
         for {
           annotationObjectId <- ObjectId.fromString(annotationId)
           annotation <- annotationDAO.findOne(annotationObjectId) // Note: this does not work for compound annotations.
           user <- userDAO.findOne(annotation._user)
           organization <- organizationDAO.findOne(user._organization)
         } yield organization
-      case (None, None, Some(workflowHash)) =>
+      case (None, None, None, None, Some(workflowHash)) =>
         for {
           workflow <- voxelyticsDAO.findWorkflowByHash(workflowHash)
           organization <- organizationDAO.findOne(workflow._organization)
@@ -277,26 +299,38 @@ class AuthenticationController @Inject()(
 
   private def accessibleBySwitchingForMultiUser(multiUserId: ObjectId,
                                                 datasetIdOpt: Option[ObjectId],
+                                                datasetDirectoryNameOpt: Option[String],
+                                                organizationIdOpt: Option[String],
                                                 annotationIdOpt: Option[String],
                                                 workflowHashOpt: Option[String]): Fox[Organization] =
     for {
       identities <- userDAO.findAllByMultiUser(multiUserId)
-      selectedIdentity <- Fox.find(identities)(identity =>
-        canAccessDatasetOrAnnotationOrWorkflow(identity, datasetIdOpt, annotationIdOpt, workflowHashOpt))
+      selectedIdentity <- Fox.find(identities)(
+        identity =>
+          canAccessDatasetOrAnnotationOrWorkflow(identity,
+                                                 datasetIdOpt,
+                                                 datasetDirectoryNameOpt,
+                                                 organizationIdOpt,
+                                                 annotationIdOpt,
+                                                 workflowHashOpt))
       selectedOrganization <- organizationDAO.findOne(selectedIdentity._organization)(GlobalAccessContext)
     } yield selectedOrganization
 
   private def canAccessDatasetOrAnnotationOrWorkflow(user: User,
                                                      datasetIdOpt: Option[ObjectId],
+                                                     datasetDirectoryNameOpt: Option[String],
+                                                     organizationIdOpt: Option[String],
                                                      annotationIdOpt: Option[String],
                                                      workflowHashOpt: Option[String]): Fox[Boolean] = {
     val ctx = AuthorizedAccessContext(user)
-    (datasetIdOpt, annotationIdOpt, workflowHashOpt) match {
-      case (Some(datasetId), None, None) =>
+    (datasetIdOpt, datasetDirectoryNameOpt, organizationIdOpt, annotationIdOpt, workflowHashOpt) match {
+      case (Some(datasetId), None, None, None, None) =>
         canAccessDataset(ctx, datasetId)
-      case (None, Some(annotationId), None) =>
+      case (None, Some(datasetDirectoryName), Some(organizationId), None, None) =>
+        canAccessDatasetByDirectoryNameAndOrganization(ctx, datasetDirectoryName, organizationId)
+      case (None, None, None, Some(annotationId), None) =>
         canAccessAnnotation(user, ctx, annotationId)
-      case (None, None, Some(workflowHash)) =>
+      case (None, None, None, None, Some(workflowHash)) =>
         canAccessWorkflow(user, workflowHash)
       case _ => Fox.failure("Can either test access for dataset or annotation or workflow, not a combination")
     }
@@ -307,6 +341,13 @@ class AuthenticationController @Inject()(
     foundFox.futureBox.map(_.isDefined)
   }
 
+  private def canAccessDatasetByDirectoryNameAndOrganization(ctx: DBAccessContext,
+                                                             datasetDirectoryName: String,
+                                                             organizationId: String): Fox[Boolean] = {
+    val foundFox = datasetDAO.findOneByDirectoryNameAndOrganization(datasetDirectoryName, organizationId)(ctx)
+    foundFox.futureBox.map(_.isDefined)
+  }
+
   private def canAccessAnnotation(user: User, ctx: DBAccessContext, annotationId: String): Fox[Boolean] = {
     val foundFox = for {
       annotationIdParsed <- ObjectId.fromString(annotationId)

app/models/dataset/Dataset.scala

@@ -434,16 +434,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

conf/webknossos.latest.routes

@@ -27,7 +27,7 @@ GET           /auth/token
 DELETE        /auth/token                                                                       controllers.AuthenticationController.deleteToken()
 GET           /auth/switch                                                                      controllers.AuthenticationController.switchMultiUser(to: String)
 POST          /auth/switchOrganization/:organizationId                                          controllers.AuthenticationController.switchOrganization(organizationId: String)
-GET           /auth/accessibleBySwitching                                                       controllers.AuthenticationController.accessibleBySwitching(datasetId: Option[String], annotationId: Option[String], workflowHash: Option[String])
+GET           /auth/accessibleBySwitching                                                       controllers.AuthenticationController.accessibleBySwitching(datasetId: Option[String], datasetDirectoryName: Option[String], organizationId: Option[String], annotationId: Option[String], workflowHash: Option[String])
 POST          /auth/sendInvites                                                                 controllers.AuthenticationController.sendInvites()
 POST          /auth/startResetPassword                                                          controllers.AuthenticationController.handleStartResetPassword()
 POST          /auth/changePassword                                                              controllers.AuthenticationController.changePassword()

frontend/javascripts/admin/admin_rest_api.ts

@@ -1778,7 +1778,7 @@ export async function updateOrganization(
 }
 
 export async function isDatasetAccessibleBySwitching(
-  commandType: TraceOrViewCommand,
+  commandType: TraceOrViewCommand | { directoryName: string; organizationId: string; type: "VIEW" },
 ): Promise<APIOrganization | null | undefined> {
   if (commandType.type === ControlModeEnum.TRACE) {
     return Request.receiveJSON(
@@ -1787,13 +1787,20 @@ export async function isDatasetAccessibleBySwitching(
         showErrorToast: false,
       },
     );
-  } else {
+  } else if ("datasetId" in commandType) {
     return Request.receiveJSON(
       `/api/auth/accessibleBySwitching?datasetId=${commandType.datasetId}`,
       {
         showErrorToast: false,
       },
     );
+  } else {
+    return Request.receiveJSON(
+      `/api/auth/accessibleBySwitching?datasetDirectoryName=${commandType.directoryName}&organizationId=${commandType.organizationId}`,
+      {
+        showErrorToast: false,
+      },
+    );
   }
 }
 

frontend/javascripts/components/redirect.tsx

@@ -1,46 +1,53 @@
 import type { RouteComponentProps } from "react-router-dom";
 import { withRouter } from "react-router-dom";
-import React from "react";
+import type React from "react";
+import { useState } from "react";
+import { useEffectOnlyOnce } from "libs/react_hooks";
 
 type Props = {
   redirectTo: () => Promise<string>;
   history: RouteComponentProps["history"];
   pushToHistory?: boolean;
+  errorComponent?: React.ReactNode;
 };
 
-class AsyncRedirect extends React.PureComponent<Props> {
-  static defaultProps = {
-    pushToHistory: true,
-  };
-
-  componentDidMount() {
-    this.redirect();
-  }
-
-  async redirect() {
-    const newPath = await this.props.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 (this.props.pushToHistory) {
-        location.assign(newPath);
-      } else {
-        location.replace(newPath);
+const AsyncRedirect: React.FC<Props> = ({
+  redirectTo,
+  history,
+  pushToHistory = true,
+  errorComponent,
+}: Props) => {
+  const [hasError, setHasError] = useState(false);
+  useEffectOnlyOnce(() => {
+    const performRedirect = async () => {
+      try {
+        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 (pushToHistory) {
+          history.push(newPath);
+        } else {
+          history.replace(newPath);
+        }
+      } catch (e) {
+        setHasError(true);
+        throw e;
       }
-      return;
-    }
+    };
+    performRedirect();
+  });
 
-    if (this.props.pushToHistory) {
-      this.props.history.push(newPath);
-    } else {
-      this.props.history.replace(newPath);
-    }
-  }
-
-  render() {
-    return null;
-  }
-}
+  return hasError && errorComponent ? errorComponent : null;
+};
 
 export default withRouter<RouteComponentProps & Props, any>(AsyncRedirect);

frontend/javascripts/router.tsx

@@ -1,4 +1,9 @@
-import { createExplorational, getAnnotationInformation, getShortLink } from "admin/admin_rest_api";
+import {
+  createExplorational,
+  getAnnotationInformation,
+  getShortLink,
+  isDatasetAccessibleBySwitching,
+} from "admin/admin_rest_api";
 import AcceptInviteView from "admin/auth/accept_invite_view";
 import AuthTokenView from "admin/auth/auth_token_view";
 import ChangePasswordView from "admin/auth/change_password_view";
@@ -44,7 +49,7 @@ import type { OxalisState } from "oxalis/store";
 import HelpButton from "oxalis/view/help_modal";
 import TracingLayoutView from "oxalis/view/layouting/tracing_layout_view";
 import React from "react";
-import { connect } from "react-redux";
+import { connect, useSelector } from "react-redux";
 // @ts-expect-error ts-migrate(2305) FIXME: Module '"react-router-dom"' has no exported member... Remove this comment to see the full error message
 import { type ContextRouter, Link, type RouteProps } from "react-router-dom";
 import { Redirect, Route, Router, Switch } from "react-router-dom";
@@ -69,6 +74,9 @@ import {
   getOrganizationForDataset,
 } from "admin/api/disambiguate_legacy_routes";
 import { getDatasetIdOrNameFromReadableURLPart } from "oxalis/model/accessors/dataset_accessor";
+import { useFetch } from "libs/react_helpers";
+import { BrainSpinnerWithError, CoverWithLogin } from "components/brain_spinner";
+import Toast from "libs/toast";
 
 const { Content } = Layout;
 
@@ -128,6 +136,37 @@ const SecuredRouteWithErrorBoundary: React.FC<GetComponentProps<typeof SecuredRo
   );
 };
 
+const LegacyLinkDisambiguateErrorView: React.FC<{
+  directoryName: string;
+  organizationId: string;
+}> = ({ directoryName, organizationId }) => {
+  const user = useSelector((state: OxalisState) => state.activeUser);
+  const organizationToSwitchTo = useFetch(
+    async () => {
+      return user
+        ? isDatasetAccessibleBySwitching({ directoryName, organizationId, type: "VIEW" })
+        : null;
+    },
+    null,
+    [directoryName, organizationId, user],
+  );
+  return user ? (
+    <BrainSpinnerWithError
+      gotUnhandledError={false}
+      organizationToSwitchTo={organizationToSwitchTo}
+    />
+  ) : (
+    <CoverWithLogin
+      onLoggedIn={() => {
+        // Close existing error toasts for "Not Found" errors before trying again.
+        // If they get relevant again, they will be recreated anyway.
+        Toast.close("404");
+        location.reload();
+      }}
+    />
+  );
+};
+
 class ReactRouter extends React.Component<Props> {
   tracingView = ({ match }: ContextRouter) => {
     const initialMaybeCompoundType =
@@ -198,16 +237,24 @@ class ReactRouter extends React.Component<Props> {
     );
   };
 
-  tracingViewModeLegacy = ({ match, location }: ContextRouter) => (
-    <AsyncRedirect
-      redirectTo={async () => {
-        const datasetName = match.params.datasetName || "";
-        const organizationId = match.params.organizationId || "";
-        const datasetId = await getDatasetIdFromNameAndOrganization(datasetName, organizationId);
-        return `/datasets/${datasetName}-${datasetId}/view${location.search}${location.hash}`;
-      }}
-    />
-  );
+  tracingViewModeLegacy = ({ match, location }: ContextRouter) => {
+    const datasetName = match.params.datasetName || "";
+    const organizationId = match.params.organizationId || "";
+    return (
+      <AsyncRedirect
+        redirectTo={async () => {
+          const datasetId = await getDatasetIdFromNameAndOrganization(datasetName, organizationId);
+          return `/datasets/${datasetName}-${datasetId}/view${location.search}${location.hash}`;
+        }}
+        errorComponent={
+          <LegacyLinkDisambiguateErrorView
+            directoryName={datasetName}
+            organizationId={organizationId}
+          />
+        }
+      />
+    );
+  };
 
   tracingViewMode = ({ match }: ContextRouter) => {
     const { datasetId, datasetName } = getDatasetIdOrNameFromReadableURLPart(