src/store/breadcrumbs/breadcrumbs-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { Dispatch } from 'redux';
   6 import { RootState } from 'store/store';
   7 import { getUserUuid } from "common/getuser";
   8 import { getResource } from 'store/resources/resources';
   9 import { TreePicker } from '../tree-picker/tree-picker';
  10 import { getSidePanelTreeBranch, getSidePanelTreeNodeAncestorsIds } from '../side-panel-tree/side-panel-tree-actions';
  11 import { propertiesActions } from '../properties/properties-actions';
  12 import { getProcess } from 'store/processes/process';
  13 import { ServiceRepository } from 'services/services';
  14 import { SidePanelTreeCategory, activateSidePanelTreeItem } from 'store/side-panel-tree/side-panel-tree-actions';
  15 import { updateResources } from '../resources/resources-actions';
  16 import { ResourceKind } from 'models/resource';
  17 import { GroupResource } from 'models/group';
  18 import { extractUuidKind } from 'models/resource';
  19 import { UserResource } from 'models/user';
  20 import { containerRequestFieldsNoMounts } from 'store/all-processes-panel/all-processes-panel-middleware-service';
  21 import { FilterBuilder } from 'services/api/filter-builder';
  22 import { ProcessResource } from 'models/process';
  23 import { OrderBuilder } from 'services/api/order-builder';
  24 import { Breadcrumb } from 'components/breadcrumbs/breadcrumbs';
  25 import { ContainerRequestResource } from 'models/container-request';
  26 import { CollectionIcon, IconType, ProcessBreadcrumbIcon, ProjectIcon } from 'components/icon/icon';
  27 import { CollectionResource } from 'models/collection';
  28
  29 export const BREADCRUMBS = 'breadcrumbs';
  30
  31 export const setBreadcrumbs = (breadcrumbs: any, currentItem?: CollectionResource | ContainerRequestResource | GroupResource) => {
  32     if (currentItem) {
  33         breadcrumbs.push(resourceToBreadcrumb(currentItem));
  34     }
  35     return propertiesActions.SET_PROPERTY({ key: BREADCRUMBS, value: breadcrumbs });
  36 };
  37
  38 const resourceToBreadcrumbIcon = (resource: CollectionResource | ContainerRequestResource | GroupResource): IconType | undefined => {
  39     switch (resource.kind) {
  40         case ResourceKind.PROJECT:
  41             return ProjectIcon;
  42             break;
  43
  44         case ResourceKind.PROCESS:
  45             return ProcessBreadcrumbIcon;
  46             break;
  47
  48         case ResourceKind.COLLECTION:
  49             return CollectionIcon;
  50             break;
  51
  52         default:
  53             return undefined;
  54             break;
  55     }
  56 }
  57
  58 const resourceToBreadcrumb = (resource: CollectionResource | ContainerRequestResource | GroupResource) => ({
  59     label: resource.name,
  60     uuid: resource.uuid,
  61     icon: resourceToBreadcrumbIcon(resource),
  62 })
  63
  64 const getSidePanelTreeBreadcrumbs = (uuid: string) => (treePicker: TreePicker): Breadcrumb[] => {
  65     const nodes = getSidePanelTreeBranch(uuid)(treePicker);
  66     return nodes.map(node =>
  67         typeof node.value === 'string'
  68             ? { label: node.value, uuid: node.id }
  69             : resourceToBreadcrumb(node.value));
  70 };
  71
  72 export const setSidePanelBreadcrumbs = (uuid: string) =>
  73     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  74         const { treePicker, collectionPanel: { item } } = getState();
  75         const breadcrumbs = getSidePanelTreeBreadcrumbs(uuid)(treePicker);
  76         const path = getState().router.location!.pathname;
  77         const currentUuid = path.split('/')[2];
  78         const uuidKind = extractUuidKind(currentUuid);
  79
  80         if (uuidKind === ResourceKind.COLLECTION) {
  81             const collectionItem = item ? item : await services.collectionService.get(currentUuid);
  82             const parentProcessItem = await getCollectionParent(collectionItem)(services);
  83             if (parentProcessItem) {
  84                 breadcrumbs.push(resourceToBreadcrumb(parentProcessItem));
  85             }
  86             dispatch(setBreadcrumbs(breadcrumbs, collectionItem));
  87         } else if (uuidKind === ResourceKind.PROCESS) {
  88             const processItem = await services.containerRequestService.get(currentUuid);
  89             const parentProcessItem = await getProcessParent(processItem)(services);
  90             if (parentProcessItem) {
  91                 breadcrumbs.push(resourceToBreadcrumb(parentProcessItem));
  92             }
  93             dispatch(setBreadcrumbs(breadcrumbs, processItem));
  94         }
  95         dispatch(setBreadcrumbs(breadcrumbs));
  96     };
  97
  98 export const setSharedWithMeBreadcrumbs = (uuid: string) =>
  99     setCategoryBreadcrumbs(uuid, SidePanelTreeCategory.SHARED_WITH_ME);
 100
 101 export const setTrashBreadcrumbs = (uuid: string) =>
 102     setCategoryBreadcrumbs(uuid, SidePanelTreeCategory.TRASH);
 103
 104 export const setCategoryBreadcrumbs = (uuid: string, category: string) =>
 105     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 106         const ancestors = await services.ancestorsService.ancestors(uuid, '');
 107         dispatch(updateResources(ancestors));
 108         const initialBreadcrumbs: Breadcrumb[] = [
 109             { label: category, uuid: category }
 110         ];
 111         const { collectionPanel: { item } } = getState();
 112         const path = getState().router.location!.pathname;
 113         const currentUuid = path.split('/')[2];
 114         const uuidKind = extractUuidKind(currentUuid);
 115         let breadcrumbs = ancestors.reduce((breadcrumbs, ancestor) =>
 116             ancestor.kind === ResourceKind.GROUP
 117                 ? [...breadcrumbs, resourceToBreadcrumb(ancestor)]
 118                 : breadcrumbs,
 119             initialBreadcrumbs);
 120         if (uuidKind === ResourceKind.COLLECTION) {
 121             const collectionItem = item ? item : await services.collectionService.get(currentUuid);
 122             const parentProcessItem = await getCollectionParent(collectionItem)(services);
 123             if (parentProcessItem) {
 124                 breadcrumbs.push(resourceToBreadcrumb(parentProcessItem));
 125             }
 126             dispatch(setBreadcrumbs(breadcrumbs, collectionItem));
 127         } else if (uuidKind === ResourceKind.PROCESS) {
 128             const processItem = await services.containerRequestService.get(currentUuid);
 129             const parentProcessItem = await getProcessParent(processItem)(services);
 130             if (parentProcessItem) {
 131                 breadcrumbs.push(resourceToBreadcrumb(parentProcessItem));
 132             }
 133             dispatch(setBreadcrumbs(breadcrumbs, processItem));
 134         }
 135         dispatch(setBreadcrumbs(breadcrumbs));
 136     };
 137
 138 const getProcessParent = (childProcess: ContainerRequestResource) =>
 139     async (services: ServiceRepository): Promise<ContainerRequestResource | undefined> => {
 140         if (childProcess.requestingContainerUuid) {
 141             const parentProcesses = await services.containerRequestService.list({
 142                 order: new OrderBuilder<ProcessResource>().addAsc('createdAt').getOrder(),
 143                 filters: new FilterBuilder().addEqual('container_uuid', childProcess.requestingContainerUuid).getFilters(),
 144                 select: containerRequestFieldsNoMounts,
 145             });
 146             if (parentProcesses.items.length > 0) {
 147                 return parentProcesses.items[0];
 148             } else {
 149                 return undefined;
 150             }
 151         } else {
 152             return undefined;
 153         }
 154     }
 155
 156 const getCollectionParent = (collection: CollectionResource) =>
 157     async (services: ServiceRepository): Promise<ContainerRequestResource | undefined> => {
 158         const parentProcesses = await services.containerRequestService.list({
 159             order: new OrderBuilder<ProcessResource>().addAsc('createdAt').getOrder(),
 160             filters: new FilterBuilder().addEqual('output_uuid', collection.uuid).getFilters(),
 161             select: containerRequestFieldsNoMounts,
 162         });
 163         if (parentProcesses.items.length > 0) {
 164             return parentProcesses.items[0];
 165         } else {
 166             return undefined;
 167         }
 168     }
 169
 170
 171 export const setProjectBreadcrumbs = (uuid: string) =>
 172     (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 173         const ancestors = getSidePanelTreeNodeAncestorsIds(uuid)(getState().treePicker);
 174         const rootUuid = getUserUuid(getState());
 175         if (uuid === rootUuid || ancestors.find(uuid => uuid === rootUuid)) {
 176             dispatch(setSidePanelBreadcrumbs(uuid));
 177         } else {
 178             dispatch(setSharedWithMeBreadcrumbs(uuid));
 179             dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME));
 180         }
 181     };
 182
 183 export const setProcessBreadcrumbs = (processUuid: string) =>
 184     (dispatch: Dispatch, getState: () => RootState) => {
 185         const { resources } = getState();
 186         const process = getProcess(processUuid)(resources);
 187         if (process) {
 188             dispatch<any>(setProjectBreadcrumbs(process.containerRequest.ownerUuid));
 189         }
 190     };
 191
 192 export const setGroupsBreadcrumbs = () =>
 193     setBreadcrumbs([{ label: SidePanelTreeCategory.GROUPS }]);
 194
 195 export const setGroupDetailsBreadcrumbs = (groupUuid: string) =>
 196     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 197
 198         const group = getResource<GroupResource>(groupUuid)(getState().resources);
 199
 200         const breadcrumbs: Breadcrumb[] = [
 201             { label: SidePanelTreeCategory.GROUPS, uuid: SidePanelTreeCategory.GROUPS },
 202             { label: group ? group.name : (await services.groupsService.get(groupUuid)).name, uuid: groupUuid },
 203         ];
 204
 205         dispatch(setBreadcrumbs(breadcrumbs));
 206
 207     };
 208
 209 export const USERS_PANEL_LABEL = 'Users';
 210
 211 export const setUsersBreadcrumbs = () =>
 212     setBreadcrumbs([{ label: USERS_PANEL_LABEL, uuid: USERS_PANEL_LABEL }]);
 213
 214 export const setUserProfileBreadcrumbs = (userUuid: string) =>
 215     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 216         try {
 217             const user = getResource<UserResource>(userUuid)(getState().resources)
 218                         || await services.userService.get(userUuid, false);
 219             const breadcrumbs: Breadcrumb[] = [
 220                 { label: USERS_PANEL_LABEL, uuid: USERS_PANEL_LABEL },
 221                 { label: user ? user.username : userUuid, uuid: userUuid },
 222             ];
 223             dispatch(setBreadcrumbs(breadcrumbs));
 224         } catch (e) {
 225             const breadcrumbs: Breadcrumb[] = [
 226                 { label: USERS_PANEL_LABEL, uuid: USERS_PANEL_LABEL },
 227                 { label: userUuid, uuid: userUuid },
 228             ];
 229             dispatch(setBreadcrumbs(breadcrumbs));
 230         }
 231     };
 232
 233 export const MY_ACCOUNT_PANEL_LABEL = 'My Account';
 234
 235 export const setMyAccountBreadcrumbs = () =>
 236     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 237         dispatch(setBreadcrumbs([
 238             { label: MY_ACCOUNT_PANEL_LABEL, uuid: MY_ACCOUNT_PANEL_LABEL },
 239         ]));
 240     };