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