src/store/tree-picker/tree-picker-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { unionize, ofType, UnionOf } from "~/common/unionize";
   6 import { TreeNode, initTreeNode, getNodeDescendants, TreeNodeStatus, getNode, TreePickerId, Tree } from '~/models/tree';
   7 import { Dispatch } from 'redux';
   8 import { RootState } from '~/store/store';
   9 import { getUserUuid } from "~/common/getuser";
  10 import { ServiceRepository } from '~/services/services';
  11 import { FilterBuilder } from '~/services/api/filter-builder';
  12 import { pipe, values } from 'lodash/fp';
  13 import { ResourceKind } from '~/models/resource';
  14 import { GroupContentsResource } from '~/services/groups-service/groups-service';
  15 import { getTreePicker, TreePicker } from './tree-picker';
  16 import { ProjectsTreePickerItem } from '~/views-components/projects-tree-picker/generic-projects-tree-picker';
  17 import { OrderBuilder } from '~/services/api/order-builder';
  18 import { ProjectResource } from '~/models/project';
  19 import { mapTree } from '../../models/tree';
  20 import { LinkResource, LinkClass } from "~/models/link";
  21
  22 export const treePickerActions = unionize({
  23     LOAD_TREE_PICKER_NODE: ofType<{ id: string, pickerId: string }>(),
  24     LOAD_TREE_PICKER_NODE_SUCCESS: ofType<{ id: string, nodes: Array<TreeNode<any>>, pickerId: string }>(),
  25     APPEND_TREE_PICKER_NODE_SUBTREE: ofType<{ id: string, subtree: Tree<any>, pickerId: string }>(),
  26     TOGGLE_TREE_PICKER_NODE_COLLAPSE: ofType<{ id: string, pickerId: string }>(),
  27     ACTIVATE_TREE_PICKER_NODE: ofType<{ id: string, pickerId: string, relatedTreePickers?: string[] }>(),
  28     DEACTIVATE_TREE_PICKER_NODE: ofType<{ pickerId: string }>(),
  29     TOGGLE_TREE_PICKER_NODE_SELECTION: ofType<{ id: string, pickerId: string }>(),
  30     SELECT_TREE_PICKER_NODE: ofType<{ id: string | string[], pickerId: string }>(),
  31     DESELECT_TREE_PICKER_NODE: ofType<{ id: string | string[], pickerId: string }>(),
  32     EXPAND_TREE_PICKER_NODES: ofType<{ ids: string[], pickerId: string }>(),
  33     RESET_TREE_PICKER: ofType<{ pickerId: string }>()
  34 });
  35
  36 export type TreePickerAction = UnionOf<typeof treePickerActions>;
  37
  38 export const getProjectsTreePickerIds = (pickerId: string) => ({
  39     home: `${pickerId}_home`,
  40     shared: `${pickerId}_shared`,
  41     favorites: `${pickerId}_favorites`,
  42     publicFavorites: `${pickerId}_publicFavorites`
  43 });
  44
  45 export const getAllNodes = <Value>(pickerId: string, filter = (node: TreeNode<Value>) => true) => (state: TreePicker) =>
  46     pipe(
  47         () => values(getProjectsTreePickerIds(pickerId)),
  48
  49         ids => ids
  50             .map(id => getTreePicker<Value>(id)(state)),
  51
  52         trees => trees
  53             .map(getNodeDescendants(''))
  54             .reduce((allNodes, nodes) => allNodes.concat(nodes), []),
  55
  56         allNodes => allNodes
  57             .reduce((map, node) =>
  58                 filter(node)
  59                     ? map.set(node.id, node)
  60                     : map, new Map<string, TreeNode<Value>>())
  61             .values(),
  62
  63         uniqueNodes => Array.from(uniqueNodes),
  64     )();
  65 export const getSelectedNodes = <Value>(pickerId: string) => (state: TreePicker) =>
  66     getAllNodes<Value>(pickerId, node => node.selected)(state);
  67
  68 export const initProjectsTreePicker = (pickerId: string) =>
  69     async (dispatch: Dispatch, _: () => RootState, services: ServiceRepository) => {
  70         const { home, shared, favorites, publicFavorites } = getProjectsTreePickerIds(pickerId);
  71         dispatch<any>(initUserProject(home));
  72         dispatch<any>(initSharedProject(shared));
  73         dispatch<any>(initFavoritesProject(favorites));
  74         dispatch<any>(initPublicFavoritesProject(publicFavorites));
  75     };
  76
  77 interface ReceiveTreePickerDataParams<T> {
  78     data: T[];
  79     extractNodeData: (value: T) => { id: string, value: T, status?: TreeNodeStatus };
  80     id: string;
  81     pickerId: string;
  82 }
  83
  84 export const receiveTreePickerData = <T>(params: ReceiveTreePickerDataParams<T>) =>
  85     (dispatch: Dispatch) => {
  86         const { data, extractNodeData, id, pickerId, } = params;
  87         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
  88             id,
  89             nodes: data.map(item => initTreeNode(extractNodeData(item))),
  90             pickerId,
  91         }));
  92         dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId }));
  93     };
  94
  95 interface LoadProjectParams {
  96     id: string;
  97     pickerId: string;
  98     includeCollections?: boolean;
  99     includeFiles?: boolean;
 100     loadShared?: boolean;
 101 }
 102 export const loadProject = (params: LoadProjectParams) =>
 103     async (dispatch: Dispatch, _: () => RootState, services: ServiceRepository) => {
 104         const { id, pickerId, includeCollections = false, includeFiles = false, loadShared = false } = params;
 105
 106         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId }));
 107
 108         const filters = pipe(
 109             (fb: FilterBuilder) => includeCollections
 110                 ? fb.addIsA('uuid', [ResourceKind.PROJECT, ResourceKind.COLLECTION])
 111                 : fb.addIsA('uuid', [ResourceKind.PROJECT]),
 112             fb => fb.getFilters(),
 113         )(new FilterBuilder());
 114
 115         const { items } = await services.groupsService.contents(loadShared ? '' : id, { filters, excludeHomeProject: loadShared || undefined });
 116
 117         dispatch<any>(receiveTreePickerData<GroupContentsResource>({
 118             id,
 119             pickerId,
 120             data: items,
 121             extractNodeData: item => ({
 122                 id: item.uuid,
 123                 value: item,
 124                 status: item.kind === ResourceKind.PROJECT
 125                     ? TreeNodeStatus.INITIAL
 126                     : includeFiles
 127                         ? TreeNodeStatus.INITIAL
 128                         : TreeNodeStatus.LOADED
 129             }),
 130         }));
 131     };
 132
 133 export const loadCollection = (id: string, pickerId: string) =>
 134     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 135         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId }));
 136
 137         const picker = getTreePicker<ProjectsTreePickerItem>(pickerId)(getState().treePicker);
 138         if (picker) {
 139
 140             const node = getNode(id)(picker);
 141             if (node && 'kind' in node.value && node.value.kind === ResourceKind.COLLECTION) {
 142
 143                 const filesTree = await services.collectionService.files(node.value.portableDataHash);
 144
 145                 dispatch(
 146                     treePickerActions.APPEND_TREE_PICKER_NODE_SUBTREE({
 147                         id,
 148                         pickerId,
 149                         subtree: mapTree(node => ({ ...node, status: TreeNodeStatus.LOADED }))(filesTree)
 150                     }));
 151
 152                 dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId }));
 153             }
 154         }
 155     };
 156
 157
 158 export const initUserProject = (pickerId: string) =>
 159     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 160         const uuid = getUserUuid(getState());
 161         if (uuid) {
 162             dispatch(receiveTreePickerData({
 163                 id: '',
 164                 pickerId,
 165                 data: [{ uuid, name: 'Projects' }],
 166                 extractNodeData: value => ({
 167                     id: value.uuid,
 168                     status: TreeNodeStatus.INITIAL,
 169                     value,
 170                 }),
 171             }));
 172         }
 173     };
 174 export const loadUserProject = (pickerId: string, includeCollections = false, includeFiles = false) =>
 175     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 176         const uuid = getUserUuid(getState());
 177         if (uuid) {
 178             dispatch(loadProject({ id: uuid, pickerId, includeCollections, includeFiles }));
 179         }
 180     };
 181
 182 export const SHARED_PROJECT_ID = 'Shared with me';
 183 export const initSharedProject = (pickerId: string) =>
 184     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 185         dispatch(receiveTreePickerData({
 186             id: '',
 187             pickerId,
 188             data: [{ uuid: SHARED_PROJECT_ID, name: SHARED_PROJECT_ID }],
 189             extractNodeData: value => ({
 190                 id: value.uuid,
 191                 status: TreeNodeStatus.INITIAL,
 192                 value,
 193             }),
 194         }));
 195     };
 196
 197 export const FAVORITES_PROJECT_ID = 'Favorites';
 198 export const initFavoritesProject = (pickerId: string) =>
 199     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 200         dispatch(receiveTreePickerData({
 201             id: '',
 202             pickerId,
 203             data: [{ uuid: FAVORITES_PROJECT_ID, name: FAVORITES_PROJECT_ID }],
 204             extractNodeData: value => ({
 205                 id: value.uuid,
 206                 status: TreeNodeStatus.INITIAL,
 207                 value,
 208             }),
 209         }));
 210     };
 211
 212 export const PUBLIC_FAVORITES_PROJECT_ID = 'Public Favorites';
 213 export const initPublicFavoritesProject = (pickerId: string) =>
 214     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 215         dispatch(receiveTreePickerData({
 216             id: '',
 217             pickerId,
 218             data: [{ uuid: PUBLIC_FAVORITES_PROJECT_ID, name: PUBLIC_FAVORITES_PROJECT_ID }],
 219             extractNodeData: value => ({
 220                 id: value.uuid,
 221                 status: TreeNodeStatus.INITIAL,
 222                 value,
 223             }),
 224         }));
 225     };
 226
 227 interface LoadFavoritesProjectParams {
 228     pickerId: string;
 229     includeCollections?: boolean;
 230     includeFiles?: boolean;
 231 }
 232
 233 export const loadFavoritesProject = (params: LoadFavoritesProjectParams) =>
 234     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 235         const { pickerId, includeCollections = false, includeFiles = false } = params;
 236         const uuid = getUserUuid(getState());
 237         if (uuid) {
 238
 239             const filters = pipe(
 240                 (fb: FilterBuilder) => includeCollections
 241                     ? fb.addIsA('headUuid', [ResourceKind.PROJECT, ResourceKind.COLLECTION])
 242                     : fb.addIsA('headUuid', [ResourceKind.PROJECT]),
 243                 fb => fb.getFilters(),
 244             )(new FilterBuilder());
 245
 246             const { items } = await services.favoriteService.list(uuid, { filters });
 247
 248             dispatch<any>(receiveTreePickerData<GroupContentsResource>({
 249                 id: 'Favorites',
 250                 pickerId,
 251                 data: items,
 252                 extractNodeData: item => ({
 253                     id: item.uuid,
 254                     value: item,
 255                     status: item.kind === ResourceKind.PROJECT
 256                         ? TreeNodeStatus.INITIAL
 257                         : includeFiles
 258                             ? TreeNodeStatus.INITIAL
 259                             : TreeNodeStatus.LOADED
 260                 }),
 261             }));
 262         }
 263     };
 264
 265 export const loadPublicFavoritesProject = (params: LoadFavoritesProjectParams) =>
 266     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 267         const { pickerId, includeCollections = false, includeFiles = false } = params;
 268         const uuidPrefix = getState().config.uuidPrefix;
 269         const uuid = `${uuidPrefix}-j7d0g-fffffffffffffff`;
 270         if (uuid) {
 271
 272             const filters = pipe(
 273                 (fb: FilterBuilder) => includeCollections
 274                     ? fb.addIsA('headUuid', [ResourceKind.PROJECT, ResourceKind.COLLECTION])
 275                     : fb.addIsA('headUuid', [ResourceKind.PROJECT]),
 276                 fb => fb
 277                     .addEqual('linkClass', LinkClass.STAR)
 278                     .addEqual('ownerUuid', uuid)
 279                     .addLike('name', '')
 280                     .getFilters(),
 281             )(new FilterBuilder());
 282
 283             const { items } = await services.linkService.list({ filters });
 284
 285             dispatch<any>(receiveTreePickerData<LinkResource>({
 286                 id: 'Public Favorites',
 287                 pickerId,
 288                 data: items,
 289                 extractNodeData: item => ({
 290                     id: item.headUuid,
 291                     value: item,
 292                     status: item.headKind === ResourceKind.PROJECT
 293                         ? TreeNodeStatus.INITIAL
 294                         : includeFiles
 295                             ? TreeNodeStatus.INITIAL
 296                             : TreeNodeStatus.LOADED
 297                 }),
 298             }));
 299         }
 300     };
 301
 302 export const receiveTreePickerProjectsData = (id: string, projects: ProjectResource[], pickerId: string) =>
 303     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 304         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
 305             id,
 306             nodes: projects.map(project => initTreeNode({ id: project.uuid, value: project })),
 307             pickerId,
 308         }));
 309
 310         dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId }));
 311     };
 312
 313 export const loadProjectTreePickerProjects = (id: string) =>
 314     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 315         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.PROJECTS }));
 316
 317
 318         const ownerUuid = id.length === 0 ? getUserUuid(getState()) || '' : id;
 319         const { items } = await services.projectService.list(buildParams(ownerUuid));
 320
 321         dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.PROJECTS));
 322     };
 323
 324 export const loadFavoriteTreePickerProjects = (id: string) =>
 325     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 326         const parentId = getUserUuid(getState()) || '';
 327
 328         if (id === '') {
 329             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.FAVORITES }));
 330             const { items } = await services.favoriteService.list(parentId);
 331             dispatch<any>(receiveTreePickerProjectsData(parentId, items as ProjectResource[], TreePickerId.FAVORITES));
 332         } else {
 333             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.FAVORITES }));
 334             const { items } = await services.projectService.list(buildParams(id));
 335             dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.FAVORITES));
 336         }
 337
 338     };
 339
 340 export const loadPublicFavoriteTreePickerProjects = (id: string) =>
 341     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 342         const parentId = getUserUuid(getState()) || '';
 343
 344         if (id === '') {
 345             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.PUBLIC_FAVORITES }));
 346             const { items } = await services.favoriteService.list(parentId);
 347             dispatch<any>(receiveTreePickerProjectsData(parentId, items as ProjectResource[], TreePickerId.PUBLIC_FAVORITES));
 348         } else {
 349             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.PUBLIC_FAVORITES }));
 350             const { items } = await services.projectService.list(buildParams(id));
 351             dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.PUBLIC_FAVORITES));
 352         }
 353
 354     };
 355
 356 const buildParams = (ownerUuid: string) => {
 357     return {
 358         filters: new FilterBuilder()
 359             .addEqual('ownerUuid', ownerUuid)
 360             .getFilters(),
 361         order: new OrderBuilder<ProjectResource>()
 362             .addAsc('name')
 363             .getOrder()
 364     };
 365 };