src/store/side-panel-tree/side-panel-tree-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 { treePickerActions } from "~/store/tree-picker/tree-picker-actions";
   7 import { RootState } from '~/store/store';
   8 import { getUserUuid } from "~/common/getuser";
   9 import { ServiceRepository } from '~/services/services';
  10 import { FilterBuilder } from '~/services/api/filter-builder';
  11 import { resourcesActions } from '~/store/resources/resources-actions';
  12 import { getTreePicker, TreePicker } from '~/store/tree-picker/tree-picker';
  13 import { getNodeAncestors, getNodeAncestorsIds, getNode, TreeNode, initTreeNode, TreeNodeStatus } from '~/models/tree';
  14 import { ProjectResource } from '~/models/project';
  15 import { OrderBuilder } from '~/services/api/order-builder';
  16 import { ResourceKind } from '~/models/resource';
  17 import { GroupContentsResourcePrefix } from '~/services/groups-service/groups-service';
  18 import { GroupClass } from '~/models/group';
  19
  20 export enum SidePanelTreeCategory {
  21     PROJECTS = 'Projects',
  22     SHARED_WITH_ME = 'Shared with me',
  23     PUBLIC_FAVORITES = 'Public Favorites',
  24     WORKFLOWS = 'Workflows',
  25     FAVORITES = 'Favorites',
  26     TRASH = 'Trash'
  27 }
  28
  29 export const SIDE_PANEL_TREE = 'sidePanelTree';
  30
  31 export const getSidePanelTree = (treePicker: TreePicker) =>
  32     getTreePicker<ProjectResource | string>(SIDE_PANEL_TREE)(treePicker);
  33
  34 export const getSidePanelTreeBranch = (uuid: string) => (treePicker: TreePicker): Array<TreeNode<ProjectResource | string>> => {
  35     const tree = getSidePanelTree(treePicker);
  36     if (tree) {
  37         const ancestors = getNodeAncestors(uuid)(tree);
  38         const node = getNode(uuid)(tree);
  39         if (node) {
  40             return [...ancestors, node];
  41         }
  42     }
  43     return [];
  44 };
  45
  46 const SIDE_PANEL_CATEGORIES = [
  47     SidePanelTreeCategory.PUBLIC_FAVORITES,
  48     SidePanelTreeCategory.WORKFLOWS,
  49     SidePanelTreeCategory.FAVORITES,
  50     SidePanelTreeCategory.TRASH,
  51 ];
  52
  53 export const isSidePanelTreeCategory = (id: string) => SIDE_PANEL_CATEGORIES.some(category => category === id);
  54
  55 export const initSidePanelTree = () =>
  56     (dispatch: Dispatch, getState: () => RootState, { authService }: ServiceRepository) => {
  57         const rootProjectUuid = getUserUuid(getState());
  58         if (!rootProjectUuid) {
  59             return;
  60         }
  61         const nodes = SIDE_PANEL_CATEGORIES.map(id => initTreeNode({ id, value: id }));
  62         const projectsNode = initTreeNode({ id: rootProjectUuid, value: SidePanelTreeCategory.PROJECTS });
  63         const sharedNode = initTreeNode({ id: SidePanelTreeCategory.SHARED_WITH_ME, value: SidePanelTreeCategory.SHARED_WITH_ME });
  64         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
  65             id: '',
  66             pickerId: SIDE_PANEL_TREE,
  67             nodes: [projectsNode, sharedNode, ...nodes]
  68         }));
  69         SIDE_PANEL_CATEGORIES.forEach(category => {
  70             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
  71                 id: category,
  72                 pickerId: SIDE_PANEL_TREE,
  73                 nodes: []
  74             }));
  75         });
  76     };
  77
  78 export const loadSidePanelTreeProjects = (projectUuid: string) =>
  79     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  80         const treePicker = getTreePicker(SIDE_PANEL_TREE)(getState().treePicker);
  81         const node = treePicker ? getNode(projectUuid)(treePicker) : undefined;
  82         if (projectUuid === SidePanelTreeCategory.SHARED_WITH_ME) {
  83             await dispatch<any>(loadSharedRoot);
  84         } else if (node || projectUuid === '') {
  85             await dispatch<any>(loadProject(projectUuid));
  86         }
  87     };
  88
  89 const loadProject = (projectUuid: string) =>
  90     async (dispatch: Dispatch, _: () => RootState, services: ServiceRepository) => {
  91         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: projectUuid, pickerId: SIDE_PANEL_TREE }));
  92         const params = {
  93             filters: new FilterBuilder()
  94                 .addEqual('ownerUuid', projectUuid)
  95                 .getFilters(),
  96             order: new OrderBuilder<ProjectResource>()
  97                 .addAsc('name')
  98                 .getOrder()
  99         };
 100         const { items } = await services.projectService.list(params);
 101         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
 102             id: projectUuid,
 103             pickerId: SIDE_PANEL_TREE,
 104             nodes: items.map(item => initTreeNode({ id: item.uuid, value: item })),
 105         }));
 106         dispatch(resourcesActions.SET_RESOURCES(items));
 107     };
 108
 109 const loadSharedRoot = async (dispatch: Dispatch, _: () => RootState, services: ServiceRepository) => {
 110     dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: SidePanelTreeCategory.SHARED_WITH_ME, pickerId: SIDE_PANEL_TREE }));
 111
 112     const params = {
 113         filters: `[${new FilterBuilder()
 114             .addIsA('uuid', ResourceKind.PROJECT)
 115             .addEqual('groupClass', GroupClass.PROJECT)
 116             .getFilters()}]`,
 117         order: new OrderBuilder<ProjectResource>()
 118             .addAsc('name', GroupContentsResourcePrefix.PROJECT)
 119             .getOrder(),
 120         limit: 1000
 121     };
 122
 123     const { items } = await services.groupsService.shared(params);
 124
 125     dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
 126         id: SidePanelTreeCategory.SHARED_WITH_ME,
 127         pickerId: SIDE_PANEL_TREE,
 128         nodes: items.map(item => initTreeNode({ id: item.uuid, value: item })),
 129     }));
 130
 131     dispatch(resourcesActions.SET_RESOURCES(items));
 132 };
 133
 134 export const activateSidePanelTreeItem = (id: string) =>
 135     async (dispatch: Dispatch, getState: () => RootState) => {
 136         const node = getSidePanelTreeNode(id)(getState().treePicker);
 137         if (node && !node.active) {
 138             dispatch(treePickerActions.ACTIVATE_TREE_PICKER_NODE({ id, pickerId: SIDE_PANEL_TREE }));
 139         }
 140         if (!isSidePanelTreeCategory(id)) {
 141             await dispatch<any>(activateSidePanelTreeProject(id));
 142         }
 143     };
 144
 145 export const activateSidePanelTreeProject = (id: string) =>
 146     async (dispatch: Dispatch, getState: () => RootState) => {
 147         const { treePicker } = getState();
 148         const node = getSidePanelTreeNode(id)(treePicker);
 149         if (node && node.status !== TreeNodeStatus.LOADED) {
 150             await dispatch<any>(loadSidePanelTreeProjects(id));
 151         } else if (node === undefined) {
 152             await dispatch<any>(activateSidePanelTreeBranch(id));
 153         }
 154         dispatch(treePickerActions.EXPAND_TREE_PICKER_NODES({
 155             ids: getSidePanelTreeNodeAncestorsIds(id)(treePicker),
 156             pickerId: SIDE_PANEL_TREE
 157         }));
 158         dispatch<any>(expandSidePanelTreeItem(id));
 159     };
 160
 161 export const activateSidePanelTreeBranch = (id: string) =>
 162     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 163         const userUuid = getUserUuid(getState());
 164         if (!userUuid) {
 165             return;
 166         }
 167         const ancestors = await services.ancestorsService.ancestors(id, userUuid);
 168         const isShared = ancestors.every(({ uuid }) => uuid !== userUuid);
 169         if (isShared) {
 170             await dispatch<any>(loadSidePanelTreeProjects(SidePanelTreeCategory.SHARED_WITH_ME));
 171         }
 172         for (const ancestor of ancestors) {
 173             await dispatch<any>(loadSidePanelTreeProjects(ancestor.uuid));
 174         }
 175         dispatch(treePickerActions.EXPAND_TREE_PICKER_NODES({
 176             ids: [
 177                 ...(isShared ? [SidePanelTreeCategory.SHARED_WITH_ME] : []),
 178                 ...ancestors.map(ancestor => ancestor.uuid)
 179             ],
 180             pickerId: SIDE_PANEL_TREE
 181         }));
 182         dispatch(treePickerActions.ACTIVATE_TREE_PICKER_NODE({ id, pickerId: SIDE_PANEL_TREE }));
 183     };
 184
 185 export const toggleSidePanelTreeItemCollapse = (id: string) =>
 186     async (dispatch: Dispatch, getState: () => RootState) => {
 187         const node = getSidePanelTreeNode(id)(getState().treePicker);
 188         if (node && node.status === TreeNodeStatus.INITIAL) {
 189             await dispatch<any>(loadSidePanelTreeProjects(node.id));
 190         }
 191         dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId: SIDE_PANEL_TREE }));
 192     };
 193
 194 export const expandSidePanelTreeItem = (id: string) =>
 195     async (dispatch: Dispatch, getState: () => RootState) => {
 196         const node = getSidePanelTreeNode(id)(getState().treePicker);
 197         if (node && !node.expanded) {
 198             dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId: SIDE_PANEL_TREE }));
 199         }
 200     };
 201
 202 export const getSidePanelTreeNode = (id: string) => (treePicker: TreePicker) => {
 203     const sidePanelTree = getTreePicker(SIDE_PANEL_TREE)(treePicker);
 204     return sidePanelTree
 205         ? getNode(id)(sidePanelTree)
 206         : undefined;
 207 };
 208
 209 export const getSidePanelTreeNodeAncestorsIds = (id: string) => (treePicker: TreePicker) => {
 210     const sidePanelTree = getTreePicker(SIDE_PANEL_TREE)(treePicker);
 211     return sidePanelTree
 212         ? getNodeAncestorsIds(id)(sidePanelTree)
 213         : [];
 214 };