X-Git-Url: https://git.arvados.org/arvados-workbench2.git/blobdiff_plain/1e32e6134cd53c30cd8a9410572a443b37f76f2e..fd24fbe43ef6f898f31804aff16ea6911a014ff8:/src/store/navigation/navigation-action.ts

diff --git a/src/store/navigation/navigation-action.ts b/src/store/navigation/navigation-action.ts
index b5dc5e9d..146530ca 100644
--- a/src/store/navigation/navigation-action.ts
+++ b/src/store/navigation/navigation-action.ts
@@ -2,122 +2,157 @@
 //
 // SPDX-License-Identifier: AGPL-3.0
 
-import { Dispatch, compose } from 'redux';
+import { Dispatch, compose, AnyAction } from 'redux';
 import { push } from "react-router-redux";
-import { RootState } from "../store";
-import { ResourceKind, Resource, extractUuidKind } from '~/models/resource';
-import { getCollectionUrl } from "~/models/collection";
-import { getProjectUrl } from "~/models/project";
-import { getResource } from '~/store/resources/resources';
-import { loadDetailsPanel } from '~/store/details-panel/details-panel-action';
-import { loadCollectionPanel } from '~/store/collection-panel/collection-panel-action';
-import { snackbarActions } from '../snackbar/snackbar-actions';
-import { resourceLabel } from "~/common/labels";
-import { loadFavoritePanel } from '../favorite-panel/favorite-panel-action';
-import { openProjectPanel, projectPanelActions } from '~/store/project-panel/project-panel-action';
-import { activateSidePanelTreeItem, initSidePanelTree, SidePanelTreeCategory } from '../side-panel-tree/side-panel-tree-actions';
-import { Routes } from '~/routes/routes';
-import { loadResource } from '../resources/resources-actions';
-import { ServiceRepository } from '~/services/services';
-import { favoritePanelActions } from '~/store/favorite-panel/favorite-panel-action';
-import { projectPanelColumns } from '~/views/project-panel/project-panel';
-import { favoritePanelColumns } from '~/views/favorite-panel/favorite-panel';
-import { matchRootRoute } from '~/routes/routes';
-import { setCollectionBreadcrumbs, setProjectBreadcrumbs, setSidePanelBreadcrumbs } from '../breadcrumbs/breadcrumbs-actions';
+import { ResourceKind, extractUuidKind } from 'models/resource';
+import { SidePanelTreeCategory } from '../side-panel-tree/side-panel-tree-actions';
+import { Routes, getGroupUrl, getNavUrl, getUserProfileUrl } from 'routes/routes';
+import { RootState } from 'store/store';
+import { openDetailsPanel } from 'store/details-panel/details-panel-action';
+import { ServiceRepository } from 'services/services';
+import { pluginConfig } from 'plugins';
+import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
+import { USERS_PANEL_LABEL, MY_ACCOUNT_PANEL_LABEL } from 'store/breadcrumbs/breadcrumbs-actions';
+
+export const navigationNotAvailable = (id: string) =>
+    snackbarActions.OPEN_SNACKBAR({
+        message: `${id} not available`,
+        hideDuration: 3000,
+        kind: SnackbarKind.ERROR
+    });
 
 export const navigateTo = (uuid: string) =>
     async (dispatch: Dispatch, getState: () => RootState) => {
+
+        for (const navToFn of pluginConfig.navigateToHandlers) {
+            if (navToFn(dispatch, getState, uuid)) {
+                return;
+            }
+        }
+
         const kind = extractUuidKind(uuid);
-        if (kind === ResourceKind.PROJECT || kind === ResourceKind.USER) {
-            dispatch<any>(navigateToProject(uuid));
-        } else if (kind === ResourceKind.COLLECTION) {
-            dispatch<any>(navigateToCollection(uuid));
+        switch (kind) {
+            case ResourceKind.PROJECT:
+            case ResourceKind.USER:
+            case ResourceKind.COLLECTION:
+            case ResourceKind.CONTAINER_REQUEST:
+                dispatch<any>(pushOrGoto(getNavUrl(uuid, getState().auth)));
+                return;
+            case ResourceKind.VIRTUAL_MACHINE:
+                dispatch<any>(navigateToAdminVirtualMachines);
+                return;
+            case ResourceKind.WORKFLOW:
+                dispatch<any>(openDetailsPanel(uuid));
+                return;
         }
-        if (uuid === SidePanelTreeCategory.FAVORITES) {
-            dispatch<any>(navigateToFavorites);
+
+        switch (uuid) {
+            case SidePanelTreeCategory.PROJECTS:
+                const usr = getState().auth.user;
+                if (usr) {
+                    dispatch<any>(pushOrGoto(getNavUrl(usr.uuid, getState().auth)));
+                }
+                return;
+            case SidePanelTreeCategory.FAVORITES:
+                dispatch<any>(navigateToFavorites);
+                return;
+            case SidePanelTreeCategory.PUBLIC_FAVORITES:
+                dispatch(navigateToPublicFavorites);
+                return;
+            case SidePanelTreeCategory.SHARED_WITH_ME:
+                dispatch(navigateToSharedWithMe);
+                return;
+            case SidePanelTreeCategory.TRASH:
+                dispatch(navigateToTrash);
+                return;
+            case SidePanelTreeCategory.GROUPS:
+                dispatch(navigateToGroups);
+                return;
+            case SidePanelTreeCategory.ALL_PROCESSES:
+                dispatch(navigateToAllProcesses);
+                return;
+            case USERS_PANEL_LABEL:
+                dispatch(navigateToUsers);
+                return;
+            case MY_ACCOUNT_PANEL_LABEL:
+                dispatch(navigateToMyAccount);
+                return;
         }
+
+        dispatch(navigationNotAvailable(uuid));
     };
 
-const getResourceNavigationAction = (resource: Resource) => {
-    switch (resource.kind) {
-        case ResourceKind.COLLECTION:
-            return navigateToCollection(resource.uuid);
-        case ResourceKind.PROJECT:
-        case ResourceKind.USER:
-            return navigateToProject(resource.uuid);
-        default:
-            return cannotNavigateToResource(resource);
+
+export const navigateToNotFound = push(Routes.NO_MATCH);
+
+export const navigateToRoot = push(Routes.ROOT);
+
+export const navigateToFavorites = push(Routes.FAVORITES);
+
+export const navigateToTrash = push(Routes.TRASH);
+
+export const navigateToPublicFavorites = push(Routes.PUBLIC_FAVORITES);
+
+export const navigateToWorkflows = push(Routes.WORKFLOWS);
+
+export const pushOrGoto = (url: string): AnyAction => {
+    if (url === "") {
+        return { type: "noop" };
+    } else if (url[0] === '/') {
+        return push(url);
+    } else {
+        window.location.href = url;
+        return { type: "noop" };
     }
 };
 
-export const loadWorkbench = () =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        const { auth, router } = getState();
-        const { user } = auth;
-        if (user) {
-            const userResource = await dispatch<any>(loadResource(user.uuid));
-            if (userResource) {
-                dispatch(projectPanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
-                dispatch(favoritePanelActions.SET_COLUMNS({ columns: favoritePanelColumns }));
-                dispatch<any>(initSidePanelTree());
-                if (router.location) {
-                    const match = matchRootRoute(router.location.pathname);
-                    if (match) {
-                        dispatch(navigateToProject(userResource.uuid));
-                    }
-                }
-            } else {
-                dispatch(userIsNotAuthenticated);
-            }
-        } else {
-            dispatch(userIsNotAuthenticated);
-        }
-    };
 
-export const navigateToFavorites = push(Routes.FAVORITES);
+export const navigateToRootProject = (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+    navigateTo(SidePanelTreeCategory.PROJECTS)(dispatch, getState);
+};
 
-export const loadFavorites = () =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.FAVORITES));
-        dispatch<any>(loadFavoritePanel());
-        dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.FAVORITES));
-    };
+export const navigateToSharedWithMe = push(Routes.SHARED_WITH_ME);
 
+export const navigateToRunProcess = push(Routes.RUN_PROCESS);
 
-export const navigateToProject = compose(push, getProjectUrl);
+export const navigateToSearchResults = (searchValue: string) => {
+    if (searchValue !== "") {
+        return push({ pathname: Routes.SEARCH_RESULTS, search: '?q=' + encodeURIComponent(searchValue) });
+    } else {
+        return push({ pathname: Routes.SEARCH_RESULTS });
+    }
+};
 
-export const loadProject = (uuid: string) =>
-    async (dispatch: Dispatch) => {
-        await dispatch<any>(activateSidePanelTreeItem(uuid));
-        dispatch<any>(setProjectBreadcrumbs(uuid));
-        dispatch<any>(openProjectPanel(uuid));
-        dispatch(loadDetailsPanel(uuid));
-    };
+export const navigateToUserVirtualMachines = push(Routes.VIRTUAL_MACHINES_USER);
 
-export const navigateToCollection = compose(push, getCollectionUrl);
+export const navigateToAdminVirtualMachines = push(Routes.VIRTUAL_MACHINES_ADMIN);
 
-export const loadCollection = (uuid: string) =>
-    async (dispatch: Dispatch) => {
-        const collection = await dispatch<any>(loadCollectionPanel(uuid));
-        await dispatch<any>(activateSidePanelTreeItem(collection.ownerUuid));
-        dispatch<any>(setCollectionBreadcrumbs(collection.uuid));
-        dispatch(loadDetailsPanel(uuid));
-    };
+export const navigateToRepositories = push(Routes.REPOSITORIES);
 
-export const cannotNavigateToResource = ({ kind, uuid }: Resource) =>
-    snackbarActions.OPEN_SNACKBAR({
-        message: `${resourceLabel(kind)} identified by ${uuid} cannot be opened.`
-    });
+export const navigateToSshKeysAdmin = push(Routes.SSH_KEYS_ADMIN);
 
-export const resourceIsNotLoaded = (uuid: string) =>
-    snackbarActions.OPEN_SNACKBAR({
-        message: `Resource identified by ${uuid} is not loaded.`
-    });
+export const navigateToSshKeysUser = push(Routes.SSH_KEYS_USER);
+
+export const navigateToSiteManager = push(Routes.SITE_MANAGER);
+
+export const navigateToMyAccount = push(Routes.MY_ACCOUNT);
+
+export const navigateToLinkAccount = push(Routes.LINK_ACCOUNT);
+
+export const navigateToKeepServices = push(Routes.KEEP_SERVICES);
+
+export const navigateToUsers = push(Routes.USERS);
+
+export const navigateToUserProfile = compose(push, getUserProfileUrl);
+
+export const navigateToApiClientAuthorizations = push(Routes.API_CLIENT_AUTHORIZATIONS);
+
+export const navigateToGroups = push(Routes.GROUPS);
+
+export const navigateToGroupDetails = compose(push, getGroupUrl);
+
+export const navigateToLinks = push(Routes.LINKS);
 
-export const userIsNotAuthenticated = snackbarActions.OPEN_SNACKBAR({
-    message: 'User is not authenticated'
-});
+export const navigateToCollectionsContentAddress = push(Routes.COLLECTIONS_CONTENT_ADDRESS);
 
-export const couldNotLoadUser = snackbarActions.OPEN_SNACKBAR({
-    message: 'Could not load user'
-});
\ No newline at end of file
+export const navigateToAllProcesses = push(Routes.ALL_PROCESSES);