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             const filters = pipe(
 239                 (fb: FilterBuilder) => includeCollections
 240                     ? fb.addIsA('headUuid', [ResourceKind.PROJECT, ResourceKind.COLLECTION])
 241                     : fb.addIsA('headUuid', [ResourceKind.PROJECT]),
 242                 fb => fb.getFilters(),
 243             )(new FilterBuilder());
 244
 245             const { items } = await services.favoriteService.list(uuid, { filters });
 246
 247             dispatch<any>(receiveTreePickerData<GroupContentsResource>({
 248                 id: 'Favorites',
 249                 pickerId,
 250                 data: items,
 251                 extractNodeData: item => ({
 252                     id: item.uuid,
 253                     value: item,
 254                     status: item.kind === ResourceKind.PROJECT
 255                         ? TreeNodeStatus.INITIAL
 256                         : includeFiles
 257                             ? TreeNodeStatus.INITIAL
 258                             : TreeNodeStatus.LOADED
 259                 }),
 260             }));
 261         }
 262     };
 263
 264 export const loadPublicFavoritesProject = (params: LoadFavoritesProjectParams) =>
 265     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 266         const { pickerId, includeCollections = false, includeFiles = false } = params;
 267         const uuidPrefix = getState().config.uuidPrefix;
 268         const uuid = `${uuidPrefix}-j7d0g-fffffffffffffff`;
 269         if (uuid) {
 270
 271             const filters = pipe(
 272                 (fb: FilterBuilder) => includeCollections
 273                     ? fb.addIsA('headUuid', [ResourceKind.PROJECT, ResourceKind.COLLECTION])
 274                     : fb.addIsA('headUuid', [ResourceKind.PROJECT]),
 275                 fb => fb
 276                     .addEqual('linkClass', LinkClass.STAR)
 277                     .addEqual('ownerUuid', uuid)
 278                     .addLike('name', '')
 279                     .getFilters(),
 280             )(new FilterBuilder());
 281
 282             const { items } = await services.linkService.list({ filters });
 283
 284             dispatch<any>(receiveTreePickerData<LinkResource>({
 285                 id: 'Public Favorites',
 286                 pickerId,
 287                 data: items,
 288                 extractNodeData: item => ({
 289                     id: item.headUuid,
 290                     value: item,
 291                     status: item.headKind === ResourceKind.PROJECT
 292                         ? TreeNodeStatus.INITIAL
 293                         : includeFiles
 294                             ? TreeNodeStatus.INITIAL
 295                             : TreeNodeStatus.LOADED
 296                 }),
 297             }));
 298         }
 299     };
 300
 301 export const receiveTreePickerProjectsData = (id: string, projects: ProjectResource[], pickerId: string) =>
 302     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 303         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
 304             id,
 305             nodes: projects.map(project => initTreeNode({ id: project.uuid, value: project })),
 306             pickerId,
 307         }));
 308
 309         dispatch(treePickerActions.TOGGLE_TREE_PICKER_NODE_COLLAPSE({ id, pickerId }));
 310     };
 311
 312 export const loadProjectTreePickerProjects = (id: string) =>
 313     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 314         dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.PROJECTS }));
 315
 316
 317         const ownerUuid = id.length === 0 ? getUserUuid(getState()) || '' : id;
 318         const { items } = await services.projectService.list(buildParams(ownerUuid));
 319
 320         dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.PROJECTS));
 321     };
 322
 323 export const loadFavoriteTreePickerProjects = (id: string) =>
 324     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 325         const parentId = getUserUuid(getState()) || '';
 326
 327         if (id === '') {
 328             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.FAVORITES }));
 329             const { items } = await services.favoriteService.list(parentId);
 330             dispatch<any>(receiveTreePickerProjectsData(parentId, items as ProjectResource[], TreePickerId.FAVORITES));
 331         } else {
 332             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.FAVORITES }));
 333             const { items } = await services.projectService.list(buildParams(id));
 334             dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.FAVORITES));
 335         }
 336
 337     };
 338
 339 export const loadPublicFavoriteTreePickerProjects = (id: string) =>
 340     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 341         const parentId = getUserUuid(getState()) || '';
 342
 343         if (id === '') {
 344             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.PUBLIC_FAVORITES }));
 345             const { items } = await services.favoriteService.list(parentId);
 346             dispatch<any>(receiveTreePickerProjectsData(parentId, items as ProjectResource[], TreePickerId.PUBLIC_FAVORITES));
 347         } else {
 348             dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.PUBLIC_FAVORITES }));
 349             const { items } = await services.projectService.list(buildParams(id));
 350             dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.PUBLIC_FAVORITES));
 351         }
 352
 353     };
 354
 355 const buildParams = (ownerUuid: string) => {
 356     return {
 357         filters: new FilterBuilder()
 358             .addEqual('ownerUuid', ownerUuid)
 359             .getFilters(),
 360         order: new OrderBuilder<ProjectResource>()
 361             .addAsc('name')
 362             .getOrder()
 363     };
 364 };