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 = 'My Favorites',
  26     TRASH = 'Trash',
  27     ALL_PROCESSES = 'All Processes'
  28 }
  29
  30 export const SIDE_PANEL_TREE = 'sidePanelTree';
  31
  32 export const getSidePanelTree = (treePicker: TreePicker) =>
  33     getTreePicker<ProjectResource | string>(SIDE_PANEL_TREE)(treePicker);
  34
  35 export const getSidePanelTreeBranch = (uuid: string) => (treePicker: TreePicker): Array<TreeNode<ProjectResource | string>> => {
  36     const tree = getSidePanelTree(treePicker);
  37     if (tree) {
  38         const ancestors = getNodeAncestors(uuid)(tree);
  39         const node = getNode(uuid)(tree);
  40         if (node) {
  41             return [...ancestors, node];
  42         }
  43     }
  44     return [];
  45 };
  46
  47 const SIDE_PANEL_CATEGORIES = [
  48     SidePanelTreeCategory.PUBLIC_FAVORITES,
  49     SidePanelTreeCategory.FAVORITES,
  50     SidePanelTreeCategory.WORKFLOWS,
  51     SidePanelTreeCategory.ALL_PROCESSES,
  52     SidePanelTreeCategory.TRASH,
  53 ];
  54
  55 export const isSidePanelTreeCategory = (id: string) => SIDE_PANEL_CATEGORIES.some(category => category === id);
  56
  57 export const initSidePanelTree = () =>
  58     (dispatch: Dispatch, getState: () => RootState, { authService }: ServiceRepository) => {
  59         const rootProjectUuid = getUserUuid(getState());
  60         if (!rootProjectUuid) { return; }
  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('owner_uuid', 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('group_class', 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) { return; }
 165         const ancestors = await services.ancestorsService.ancestors(id, userUuid);
 166         const isShared = ancestors.every(({ uuid }) => uuid !== userUuid);
 167         if (isShared) {
 168             await dispatch<any>(loadSidePanelTreeProjects(SidePanelTreeCategory.SHARED_WITH_ME));
 169         }
 170         for (const ancestor of ancestors) {
 171             await dispatch<any>(loadSidePanelTreeProjects(ancestor.uuid));
 172         }
 173         dispatch(treePickerActions.EXPAND_TREE_PICKER_NODES({
 174             ids: [
 175                 ...(isShared ? [SidePanelTreeCategory.SHARED_WITH_ME] : []),
 176                 ...ancestors.map(ancestor => ancestor.uuid)
 177             ],
 178             pickerId: SIDE_PANEL_TREE
 179         }));
 180         dispatch(treePickerActions.ACTIVATE_TREE_PICKER_NODE({ id, pickerId: SIDE_PANEL_TREE }));
 181     };
 182
 183 export const toggleSidePanelTreeItemCollapse = (id: string) =>
 184     async (dispatch: Dispatch, getState: () => RootState) => {
 185         const node = getSidePanelTreeNode(id)(getState().treePicker);
 186         if (node && node.status === TreeNodeStatus.INITIAL) {
 187             await dispatch<any>(loadSidePanelTreeProjects(node.id));
 188         }
 189         dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId: SIDE_PANEL_TREE }));
 190     };
 191
 192 export const expandSidePanelTreeItem = (id: string) =>
 193     async (dispatch: Dispatch, getState: () => RootState) => {
 194         const node = getSidePanelTreeNode(id)(getState().treePicker);
 195         if (node && !node.expanded) {
 196             dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId: SIDE_PANEL_TREE }));
 197         }
 198     };
 199
 200 export const getSidePanelTreeNode = (id: string) => (treePicker: TreePicker) => {
 201     const sidePanelTree = getTreePicker(SIDE_PANEL_TREE)(treePicker);
 202     return sidePanelTree
 203         ? getNode(id)(sidePanelTree)
 204         : undefined;
 205 };
 206
 207 export const getSidePanelTreeNodeAncestorsIds = (id: string) => (treePicker: TreePicker) => {
 208     const sidePanelTree = getTreePicker(SIDE_PANEL_TREE)(treePicker);
 209     return sidePanelTree
 210         ? getNodeAncestorsIds(id)(sidePanelTree)
 211         : [];
 212 };