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                 .map(nodeToTreeItem);
  39             // prevTree = getNodeChildrenIds('')(state.collectionPanelFiles)
  40             //     .map(collectionItemToTreeItem(state.collectionPanelFiles));
  41         }
  42         return {
  43             items: prevTree,
  44             currentItemUuid: state.detailsPanel.resourceUuid
  45         };
  46     };
  47 };
  48
  49 const mapDispatchToProps = (dispatch: Dispatch): Pick<CollectionPanelFilesProps, 'onFileClick' | 'onUploadDataClick' | 'onCollapseToggle' | 'onSelectionToggle' | 'onItemMenuOpen' | 'onOptionsMenuOpen'> => ({
  50     onUploadDataClick: () => {
  51         dispatch<any>(openUploadCollectionFilesDialog());
  52     },
  53     onCollapseToggle: (id) => {
  54         dispatch(collectionPanelFilesAction.TOGGLE_COLLECTION_FILE_COLLAPSE({ id }));
  55     },
  56     onSelectionToggle: (event, item) => {
  57         dispatch(collectionPanelFilesAction.TOGGLE_COLLECTION_FILE_SELECTION({ id: item.id }));
  58     },
  59     onItemMenuOpen: (event, item, isWritable) => {
  60         dispatch<any>(openContextMenu(
  61             event,
  62             {
  63                 menuKind: isWritable
  64                     ? ContextMenuKind.COLLECTION_FILES_ITEM
  65                     : ContextMenuKind.READONLY_COLLECTION_FILES_ITEM,
  66                 kind: ResourceKind.COLLECTION,
  67                 name: item.data.name,
  68                 uuid: item.id,
  69                 ownerUuid: ''
  70             }
  71         ));
  72     },
  73     onOptionsMenuOpen: (event, isWritable) => {
  74         dispatch<any>(openCollectionFilesContextMenu(event, isWritable));
  75     },
  76     onFileClick: (id) => {
  77         dispatch(openDetailsPanel(id));
  78     },
  79 });
  80
  81
  82 export const CollectionPanelFiles = connect(memoizedMapStateToProps(), mapDispatchToProps)(Component);
  83
  84 export const collectionItemToList = (level: number) => (tree: Tree<CollectionPanelDirectory | CollectionPanelFile>) =>
  85     (id: string): TreeItem<FileTreeData>[] => {
  86         const node: TreeNode<CollectionPanelDirectory | CollectionPanelFile> = getNode(id)(tree) || initTreeNode({
  87             id: '',
  88             parent: '',
  89             value: {
  90                 ...createCollectionDirectory({ name: 'Invalid file' }),
  91                 selected: false,
  92                 collapsed: true
  93             }
  94         });
  95         const childs = [].concat.apply([], node.children.map(collectionItemToList(level+1)(tree)));
  96         return [
  97             {...node, level},
  98             ...childs,
  99         ];
 100     };
 101
 102 const collectionItemToTreeItem = (tree: Tree<CollectionPanelDirectory | CollectionPanelFile>) =>
 103     (id: string): TreeItem<FileTreeData> => {
 104         const node: TreeNode<CollectionPanelDirectory | CollectionPanelFile> = getNode(id)(tree) || initTreeNode({
 105             id: '',
 106             parent: '',
 107             value: {
 108                 ...createCollectionDirectory({ name: 'Invalid file' }),
 109                 selected: false,
 110                 collapsed: true
 111             }
 112         });
 113         return {
 114             active: false,
 115             data: {
 116                 name: node.value.name,
 117                 size: node.value.type === CollectionFileType.FILE ? node.value.size : undefined,
 118                 type: node.value.type,
 119                 url: node.value.url,
 120             },
 121             id: node.id,
 122             items: getNodeChildrenIds(node.id)(tree)
 123                 .map(collectionItemToTreeItem(tree)),
 124             open: node.value.type === CollectionFileType.DIRECTORY ? !node.value.collapsed : false,
 125             selected: node.value.selected,
 126             status: TreeItemStatus.LOADED
 127         };
 128     };
 129
 130 const nodeToTreeItem = (node: TreeNode<CollectionPanelDirectory | CollectionPanelFile>): TreeItem<FileTreeData> => {
 131     return ({
 132         active: false,
 133         data: {
 134             name: node.value.name,
 135             size: node.value.type === CollectionFileType.FILE ? node.value.size : undefined,
 136             type: node.value.type,
 137             url: node.value.url,
 138         },
 139         id: node.id,
 140         items: [],
 141         open: node.value.type === CollectionFileType.DIRECTORY ? !node.value.collapsed : false,
 142         selected: node.value.selected,
 143         status: TreeItemStatus.LOADED,
 144         level: node.level,
 145     });
 146 };