src/views-components/collection-panel-files/collection-panel-files.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { connect } from "react-redux";
   6 import {
   7     CollectionPanelFiles as Component,
   8     CollectionPanelFilesProps
   9 } from "~/components/collection-panel-files/collection-panel-files";
  10 import { RootState } from "~/store/store";
  11 import { TreeItem, TreeItemStatus } from "~/components/tree/tree";
  12 import {
  13     CollectionPanelDirectory,
  14     CollectionPanelFile,
  15     CollectionPanelFilesState
  16 } from "~/store/collection-panel/collection-panel-files/collection-panel-files-state";
  17 import { FileTreeData } from "~/components/file-tree/file-tree-data";
  18 import { Dispatch } from "redux";
  19 import { collectionPanelFilesAction } from "~/store/collection-panel/collection-panel-files/collection-panel-files-actions";
  20 import { ContextMenuKind } from "../context-menu/context-menu";
  21 import { getNode, getNodeChildrenIds, Tree, TreeNode, initTreeNode } from "~/models/tree";
  22 import { CollectionFileType, createCollectionDirectory } from "~/models/collection-file";
  23 import { openContextMenu, openCollectionFilesContextMenu } from '~/store/context-menu/context-menu-actions';
  24 import { openUploadCollectionFilesDialog } from '~/store/collections/collection-upload-actions';
  25 import { ResourceKind } from "~/models/resource";
  26 import { openDetailsPanel } from '~/store/details-panel/details-panel-action';
  27
  28 const memoizedMapStateToProps = () => {
  29     let prevState: CollectionPanelFilesState;
  30     let prevTree: Array<TreeItem<FileTreeData>>;
  31
  32     return (state: RootState): Pick<CollectionPanelFilesProps, "items" | "currentItemUuid"> => {
  33         if (prevState !== state.collectionPanelFiles) {
  34             prevState = state.collectionPanelFiles;
  35             prevTree = [].concat.apply(
  36                 [], getNodeChildrenIds('')(state.collectionPanelFiles)
  37                     .map(collectionItemToList(0)(state.collectionPanelFiles)));
  38         }
  39         return {
  40             items: prevTree,
  41             currentItemUuid: state.detailsPanel.resourceUuid
  42         };
  43     };
  44 };
  45
  46 const mapDispatchToProps = (dispatch: Dispatch): Pick<CollectionPanelFilesProps, 'onFileClick' | 'onUploadDataClick' | 'onCollapseToggle' | 'onSelectionToggle' | 'onItemMenuOpen' | 'onOptionsMenuOpen'> => ({
  47     onUploadDataClick: () => {
  48         dispatch<any>(openUploadCollectionFilesDialog());
  49     },
  50     onCollapseToggle: (id) => {
  51         dispatch(collectionPanelFilesAction.TOGGLE_COLLECTION_FILE_COLLAPSE({ id }));
  52     },
  53     onSelectionToggle: (event, item) => {
  54         dispatch(collectionPanelFilesAction.TOGGLE_COLLECTION_FILE_SELECTION({ id: item.id }));
  55     },
  56     onItemMenuOpen: (event, item, isWritable) => {
  57         dispatch<any>(openContextMenu(
  58             event,
  59             {
  60                 menuKind: isWritable
  61                     ? ContextMenuKind.COLLECTION_FILES_ITEM
  62                     : ContextMenuKind.READONLY_COLLECTION_FILES_ITEM,
  63                 kind: ResourceKind.COLLECTION,
  64                 name: item.data.name,
  65                 uuid: item.id,
  66                 ownerUuid: ''
  67             }
  68         ));
  69     },
  70     onOptionsMenuOpen: (event, isWritable) => {
  71         dispatch<any>(openCollectionFilesContextMenu(event, isWritable));
  72     },
  73     onFileClick: (id) => {
  74         dispatch(openDetailsPanel(id));
  75     },
  76 });
  77
  78
  79 export const CollectionPanelFiles = connect(memoizedMapStateToProps(), mapDispatchToProps)(Component);
  80
  81 export const collectionItemToList = (level: number) => (tree: Tree<CollectionPanelDirectory | CollectionPanelFile>) =>
  82     (id: string): TreeItem<FileTreeData>[] => {
  83         const node: TreeNode<CollectionPanelDirectory | CollectionPanelFile> = getNode(id)(tree) || initTreeNode({
  84             id: '',
  85             parent: '',
  86             value: {
  87                 ...createCollectionDirectory({ name: 'Invalid file' }),
  88                 selected: false,
  89                 collapsed: true
  90             }
  91         });
  92
  93         const treeItem = {
  94             active: false,
  95             data: {
  96                 name: node.value.name,
  97                 size: node.value.type === CollectionFileType.FILE ? node.value.size : undefined,
  98                 type: node.value.type,
  99                 url: node.value.url,
 100             },
 101             id: node.id,
 102             items: [], // Not used in this case as we're converting a tree to a list.
 103             itemCount: node.children.length,
 104             open: node.value.type === CollectionFileType.DIRECTORY ? !node.value.collapsed : false,
 105             selected: node.value.selected,
 106             status: TreeItemStatus.LOADED,
 107             level,
 108         };
 109
 110         const treeItemChilds = [].concat.apply([], node.children.map(collectionItemToList(level+1)(tree)));
 111
 112         return [
 113             treeItem,
 114             ...treeItemChilds,
 115         ];
 116     };
 117
 118 const collectionItemToTreeItem = (tree: Tree<CollectionPanelDirectory | CollectionPanelFile>) =>
 119     (id: string): TreeItem<FileTreeData> => {
 120         const node: TreeNode<CollectionPanelDirectory | CollectionPanelFile> = getNode(id)(tree) || initTreeNode({
 121             id: '',
 122             parent: '',
 123             value: {
 124                 ...createCollectionDirectory({ name: 'Invalid file' }),
 125                 selected: false,
 126                 collapsed: true
 127             }
 128         });
 129         return {
 130             active: false,
 131             data: {
 132                 name: node.value.name,
 133                 size: node.value.type === CollectionFileType.FILE ? node.value.size : undefined,
 134                 type: node.value.type,
 135                 url: node.value.url,
 136             },
 137             id: node.id,
 138             items: getNodeChildrenIds(node.id)(tree)
 139                 .map(collectionItemToTreeItem(tree)),
 140             open: node.value.type === CollectionFileType.DIRECTORY ? !node.value.collapsed : false,
 141             selected: node.value.selected,
 142             status: TreeItemStatus.LOADED
 143         };
 144     };