19690: uuid column goodish

Arvados-DCO-1.1-Signed-off-by: Lisa Knox <lisa.knox@curii.com>

diff --git a/src/components/column-selector/column-selector.tsx b/src/components/column-selector/column-selector.tsx
index 441d8ec83da77a5ce688744776da168b3860ccf8..63934ddbff54681c4b344e202a00ffc5654cd58f 100644 (file)
--- a/src/components/column-selector/column-selector.tsx
+++ b/src/components/column-selector/column-selector.tsx
@@ -31,14 +31,16 @@ export type ColumnSelectorProps = ColumnSelectorDataProps & WithStyles<CssRules>
 
 export const ColumnSelector = withStyles(styles)(
     ({ columns, onColumnToggle, classes }: ColumnSelectorProps) =>
-    {console.log('COLUMN_SELECTOR',columns)
-    columns = [...columns, {
-        name:'bananas',
-        selected: false,
-        configurable: true, filters:{}, render: (uuid)=><ResourceName uuid='uuid'/>
-    }
-]
-    console.log('COLUMN_SELECTOR',columns)
+    {
+//         // console.log('COLUMN_SELECTOR',columns)
+//     columns = [...columns, {
+//         name:'bananas',
+//         selected: false,
+//         configurable: true, filters:{}, render: (uuid)=><ResourceName uuid='bananas'/>
+//     }
+// ]
+// //lisa
+//     // console.log('COLUMN_SELECTOR',columns)
        return <Popover triggerComponent={ColumnSelectorTrigger}>
             <Paper>
                 <List dense>

diff --git a/src/components/data-explorer/data-explorer.tsx b/src/components/data-explorer/data-explorer.tsx
index cf45e24fbb75bd271497652bf099595ca0f28327..67f9bfba99e79af6dc980df16740b536752d3770 100644 (file)
--- a/src/components/data-explorer/data-explorer.tsx
+++ b/src/components/data-explorer/data-explorer.tsx
@@ -140,8 +140,10 @@ export const DataExplorer = withStyles(styles)(
         }
 
         componentDidMount() {
-            // console.log('DATA_EXPLORER:',this.props)
             if (this.props.onSetColumns) {
+                //lisa
+                // console.log('DATA_EXPLORER_CDM:',this.props)
+                
                 this.props.onSetColumns(this.props.columns);
             }
             // Component just mounted, so we need to show the loading indicator.
@@ -161,7 +163,8 @@ export const DataExplorer = withStyles(styles)(
                 paperKey, fetchMode, currentItemUuid, title,
                 doHidePanel, doMaximizePanel, doUnMaximizePanel, panelName, panelMaximized, elementPath
             } = this.props;
-
+            //lisa
+// console.log('DATA_EXPLORER_TSX', this.props)
             return <Paper className={classes.root} {...paperProps} key={paperKey} data-cy={this.props["data-cy"]}>
                 <Grid container direction="column" wrap="nowrap" className={classes.container}>
                     <div>

diff --git a/src/components/data-table/data-table.tsx b/src/components/data-table/data-table.tsx
index 10446d1a306e4923883bfac2f966e23420e67354..cf83fa6fa158c2f234ae96219b02a64e759824ae 100644 (file)
--- a/src/components/data-table/data-table.tsx
+++ b/src/components/data-table/data-table.tsx
@@ -98,6 +98,7 @@ export const DataTable = withStyles(styles)(
                             </TableRow>
                         </TableHead>
                         <TableBody className={classes.tableBody}>
+                            {console.log('TABLEBODY>ITEMS',items, "THIS ?", this)}
                             { !working && items.map(this.renderBodyRow) }
                         </TableBody>
                     </Table>
@@ -168,11 +169,12 @@ export const DataTable = withStyles(styles)(
                 onContextMenu={this.handleRowContextMenu(item)}
                 onDoubleClick={event => onRowDoubleClick && onRowDoubleClick(event, item)}
                 selected={item === currentItemUuid}>
-                {this.mapVisibleColumns((column, index) => (
-                    <TableCell key={column.key || index} className={currentRoute === '/workflows' ? classes.tableCellWorkflows : classes.tableCell}>
+                {this.mapVisibleColumns((column, index) => {
+                    console.log('RENDERBODYROW', column.render(item))
+                    return <TableCell key={column.key || index} className={currentRoute === '/workflows' ? classes.tableCellWorkflows : classes.tableCell}>
                         {column.render(item)}
                     </TableCell>
-                ))}
+        })}
             </TableRow>;
         }
 

diff --git a/src/store/data-explorer/data-explorer-middleware-service.ts b/src/store/data-explorer/data-explorer-middleware-service.ts
index 71a6ee6a9577341a639e5df492fc78cf7441459e..c747d53340d6be2265fe3ce6c5962478735861d0 100644 (file)
--- a/src/store/data-explorer/data-explorer-middleware-service.ts
+++ b/src/store/data-explorer/data-explorer-middleware-service.ts
@@ -2,44 +2,59 @@
 //
 // SPDX-License-Identifier: AGPL-3.0
 
-import { Dispatch, MiddlewareAPI } from "redux";
-import { RootState } from "../store";
-import { DataColumns } from "components/data-table/data-table";
+import { Dispatch, MiddlewareAPI } from 'redux';
+import { RootState } from '../store';
+import { DataColumns } from 'components/data-table/data-table';
 import { DataExplorer } from './data-explorer-reducer';
 import { ListResults } from 'services/common-service/common-service';
-import { createTree } from "models/tree";
-import { DataTableFilters } from "components/data-table-filters/data-table-filters-tree";
+import { createTree } from 'models/tree';
+import { DataTableFilters } from 'components/data-table-filters/data-table-filters-tree';
 
 export abstract class DataExplorerMiddlewareService {
-    protected readonly id: string;
-
-    protected constructor(id: string) {
-        this.id = id;
-    }
-
-    public getId() {
-        return this.id;
-    }
-
-    public getColumnFilters<T>(columns: DataColumns<T>, columnName: string): DataTableFilters {
-        return getDataExplorerColumnFilters(columns, columnName);
-    }
-
-    abstract requestItems(api: MiddlewareAPI<Dispatch, RootState>, criteriaChanged?: boolean): Promise<void>;
+  protected readonly id: string;
+
+  protected constructor(id: string) {
+    this.id = id;
+  }
+
+  public getId() {
+    return this.id;
+  }
+
+  public getColumnFilters<T>(
+    columns: DataColumns<T>,
+    columnName: string
+  ): DataTableFilters {
+    return getDataExplorerColumnFilters(columns, columnName);
+  }
+
+  abstract requestItems(
+    api: MiddlewareAPI<Dispatch, RootState>,
+    criteriaChanged?: boolean
+  ): Promise<void>;
 }
 
-export const getDataExplorerColumnFilters = <T>(columns: DataColumns<T>, columnName: string): DataTableFilters => {
-    const column = columns.find(c => c.name === columnName);
-    return column ? column.filters : createTree();
+export const getDataExplorerColumnFilters = <T>(
+  columns: DataColumns<T>,
+  columnName: string
+): DataTableFilters => {
+  const column = columns.find((c) => c.name === columnName);
+  //lisa
+  //   console.log('DATA_EXPLORER_MIDD, GETDEXCOLUMNFILTERS', column);
+  return column ? column.filters : createTree();
 };
 
 export const dataExplorerToListParams = (dataExplorer: DataExplorer) => ({
-    limit: dataExplorer.rowsPerPage,
-    offset: dataExplorer.page * dataExplorer.rowsPerPage
+  limit: dataExplorer.rowsPerPage,
+  offset: dataExplorer.page * dataExplorer.rowsPerPage,
 });
 
-export const listResultsToDataExplorerItemsMeta = <R>({ itemsAvailable, offset, limit }: ListResults<R>) => ({
-    itemsAvailable,
-    page: Math.floor(offset / limit),
-    rowsPerPage: limit
+export const listResultsToDataExplorerItemsMeta = <R>({
+  itemsAvailable,
+  offset,
+  limit,
+}: ListResults<R>) => ({
+  itemsAvailable,
+  page: Math.floor(offset / limit),
+  rowsPerPage: limit,
 });

diff --git a/src/store/data-explorer/data-explorer-middleware.ts b/src/store/data-explorer/data-explorer-middleware.ts
index efe51fe3740e73c368e077ee2d0ca0db707b6433..b99af64a328bcc8df4cd040b3a9cf342c96109a5 100644 (file)
--- a/src/store/data-explorer/data-explorer-middleware.ts
+++ b/src/store/data-explorer/data-explorer-middleware.ts
@@ -1,4 +1,3 @@
-
 // Copyright (C) The Arvados Authors. All rights reserved.
 //
 // SPDX-License-Identifier: AGPL-3.0
@@ -6,74 +5,113 @@
 import { Dispatch } from 'redux';
 import { RootState } from 'store/store';
 import { ServiceRepository } from 'services/services';
-import { Middleware } from "redux";
-import { dataExplorerActions, bindDataExplorerActions, DataTableRequestState } from "./data-explorer-action";
-import { getDataExplorer } from "./data-explorer-reducer";
-import { DataExplorerMiddlewareService } from "./data-explorer-middleware-service";
+import { Middleware } from 'redux';
+import {
+  dataExplorerActions,
+  bindDataExplorerActions,
+  DataTableRequestState,
+} from './data-explorer-action';
+import { getDataExplorer } from './data-explorer-reducer';
+import { DataExplorerMiddlewareService } from './data-explorer-middleware-service';
 
-export const dataExplorerMiddleware = (service: DataExplorerMiddlewareService): Middleware => api => next => {
+export const dataExplorerMiddleware =
+  (service: DataExplorerMiddlewareService): Middleware =>
+  (api) =>
+  (next) => {
     const actions = bindDataExplorerActions(service.getId());
 
-    return action => {
-        const handleAction = <T extends { id: string }>(handler: (data: T) => void) =>
-            (data: T) => {
-                next(action);
-                if (data.id === service.getId()) {
-                    handler(data);
-                }
-            };
-        dataExplorerActions.match(action, {
-            SET_PAGE: handleAction(() => {
-                api.dispatch(actions.REQUEST_ITEMS(false));
-            }),
-            SET_ROWS_PER_PAGE: handleAction(() => {
-                api.dispatch(actions.REQUEST_ITEMS(true));
-            }),
-            SET_FILTERS: handleAction(() => {
-                api.dispatch(actions.RESET_PAGINATION());
-                api.dispatch(actions.REQUEST_ITEMS(true));
-            }),
-            TOGGLE_SORT: handleAction(() => {
-                api.dispatch(actions.REQUEST_ITEMS(true));
-            }),
-            SET_EXPLORER_SEARCH_VALUE: handleAction(() => {
-                api.dispatch(actions.RESET_PAGINATION());
-                api.dispatch(actions.REQUEST_ITEMS(true));
-            }),
-            REQUEST_ITEMS: handleAction(({ criteriaChanged }) => {
-                api.dispatch<any>(async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-                    while (true) {
-                        let de = getDataExplorer(getState().dataExplorer, service.getId());
-                        switch (de.requestState) {
-                            case DataTableRequestState.IDLE:
-                                // Start a new request.
-                                try {
-                                    dispatch(actions.SET_REQUEST_STATE({ requestState: DataTableRequestState.PENDING }));
-                                    await service.requestItems(api, criteriaChanged);
-                                } catch {
-                                    dispatch(actions.SET_REQUEST_STATE({ requestState: DataTableRequestState.NEED_REFRESH }));
-                                }
-                                // Now check if the state is still PENDING, if it moved to NEED_REFRESH
-                                // then we need to reissue requestItems
-                                de = getDataExplorer(getState().dataExplorer, service.getId());
-                                const complete = (de.requestState === DataTableRequestState.PENDING);
-                                dispatch(actions.SET_REQUEST_STATE({ requestState: DataTableRequestState.IDLE }));
-                                if (complete) {
-                                    return;
-                                }
-                                break;
-                            case DataTableRequestState.PENDING:
-                                // State is PENDING, move it to NEED_REFRESH so that when the current request finishes it starts a new one.
-                                dispatch(actions.SET_REQUEST_STATE({ requestState: DataTableRequestState.NEED_REFRESH }));
-                                return;
-                            case DataTableRequestState.NEED_REFRESH:
-                                // Nothing to do right now.
-                                return;
-                        }
+    return (action) => {
+      const handleAction =
+        <T extends { id: string }>(handler: (data: T) => void) =>
+        (data: T) => {
+          next(action);
+          if (data.id === service.getId()) {
+            handler(data);
+          }
+        };
+      dataExplorerActions.match(action, {
+        SET_PAGE: handleAction(() => {
+          api.dispatch(actions.REQUEST_ITEMS(false));
+        }),
+        SET_ROWS_PER_PAGE: handleAction(() => {
+          api.dispatch(actions.REQUEST_ITEMS(true));
+        }),
+        SET_FILTERS: handleAction(() => {
+          api.dispatch(actions.RESET_PAGINATION());
+          api.dispatch(actions.REQUEST_ITEMS(true));
+        }),
+        TOGGLE_SORT: handleAction(() => {
+          api.dispatch(actions.REQUEST_ITEMS(true));
+        }),
+        SET_EXPLORER_SEARCH_VALUE: handleAction(() => {
+          api.dispatch(actions.RESET_PAGINATION());
+          api.dispatch(actions.REQUEST_ITEMS(true));
+        }),
+        REQUEST_ITEMS: handleAction(({ criteriaChanged }) => {
+          api.dispatch<any>(
+            async (
+              dispatch: Dispatch,
+              getState: () => RootState,
+              services: ServiceRepository
+            ) => {
+              while (true) {
+                let de = getDataExplorer(
+                  getState().dataExplorer,
+                  service.getId()
+                );
+                switch (de.requestState) {
+                  case DataTableRequestState.IDLE:
+                    // Start a new request.
+                    try {
+                      dispatch(
+                        actions.SET_REQUEST_STATE({
+                          requestState: DataTableRequestState.PENDING,
+                        })
+                      );
+                      await service.requestItems(api, criteriaChanged);
+                    } catch {
+                      dispatch(
+                        actions.SET_REQUEST_STATE({
+                          requestState: DataTableRequestState.NEED_REFRESH,
+                        })
+                      );
                     }
-                });
-            }),
-            default: () => next(action)
-        });
+                    // Now check if the state is still PENDING, if it moved to NEED_REFRESH
+                    // then we need to reissue requestItems
+                    de = getDataExplorer(
+                      getState().dataExplorer,
+                      service.getId()
+                    );
+                    //lisa
+                    // console.log('DE_MIDDLEWARE', de);
+                    const complete =
+                      de.requestState === DataTableRequestState.PENDING;
+                    dispatch(
+                      actions.SET_REQUEST_STATE({
+                        requestState: DataTableRequestState.IDLE,
+                      })
+                    );
+                    if (complete) {
+                      return;
+                    }
+                    break;
+                  case DataTableRequestState.PENDING:
+                    // State is PENDING, move it to NEED_REFRESH so that when the current request finishes it starts a new one.
+                    dispatch(
+                      actions.SET_REQUEST_STATE({
+                        requestState: DataTableRequestState.NEED_REFRESH,
+                      })
+                    );
+                    return;
+                  case DataTableRequestState.NEED_REFRESH:
+                    // Nothing to do right now.
+                    return;
+                }
+              }
+            }
+          );
+        }),
+        default: () => next(action),
+      });
     };
-};
+  };

diff --git a/src/store/data-explorer/data-explorer-reducer.ts b/src/store/data-explorer/data-explorer-reducer.ts
index 4ae01adfc16d812bd43cec7a6dd944a6f6f13db1..e1f4ef2a7bb6068d1cc0462e0f7a2335408271c0 100644 (file)
--- a/src/store/data-explorer/data-explorer-reducer.ts
+++ b/src/store/data-explorer/data-explorer-reducer.ts
@@ -110,8 +110,12 @@ export const dataExplorerReducer = (
     default: () => state,
   });
 };
-export const getDataExplorer = (state: DataExplorerState, id: string) =>
-  state[id] || initialDataExplorer;
+export const getDataExplorer = (state: DataExplorerState, id: string) => {
+  const returnValue = state[id] || initialDataExplorer;
+  //lisa
+  //   console.log('GETDATAEXPLORER RETURN:', state[id]);
+  return returnValue;
+};
 
 export const getSortColumn = (dataExplorer: DataExplorer) =>
   dataExplorer.columns.find(

diff --git a/src/store/workbench/workbench-actions.ts b/src/store/workbench/workbench-actions.ts
index 0a3484310ee74a5d6e5182f3e47fb27290520ef3..e1fcae4b8db6ce930f6c2fbcff42e303f746010f 100644 (file)
--- a/src/store/workbench/workbench-actions.ts
+++ b/src/store/workbench/workbench-actions.ts
@@ -3,40 +3,46 @@
 // SPDX-License-Identifier: AGPL-3.0
 
 import { Dispatch } from 'redux';
-import { RootState } from "store/store";
-import { getUserUuid } from "common/getuser";
+import { RootState } from 'store/store';
+import { getUserUuid } from 'common/getuser';
 import { loadDetailsPanel } from 'store/details-panel/details-panel-action';
 import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
-import { favoritePanelActions, loadFavoritePanel } from 'store/favorite-panel/favorite-panel-action';
 import {
-    getProjectPanelCurrentUuid,
-    openProjectPanel,
-    projectPanelActions,
-    setIsProjectPanelTrashed
+  favoritePanelActions,
+  loadFavoritePanel,
+} from 'store/favorite-panel/favorite-panel-action';
+import {
+  getProjectPanelCurrentUuid,
+  openProjectPanel,
+  projectPanelActions,
+  setIsProjectPanelTrashed,
 } from 'store/project-panel/project-panel-action';
 import {
-    activateSidePanelTreeItem,
-    initSidePanelTree,
-    loadSidePanelTreeProjects,
-    SidePanelTreeCategory
+  activateSidePanelTreeItem,
+  initSidePanelTree,
+  loadSidePanelTreeProjects,
+  SidePanelTreeCategory,
 } from 'store/side-panel-tree/side-panel-tree-actions';
 import { updateResources } from 'store/resources/resources-actions';
 import { projectPanelColumns } from 'views/project-panel/project-panel';
 import { favoritePanelColumns } from 'views/favorite-panel/favorite-panel';
 import { matchRootRoute } from 'routes/routes';
 import {
-    setBreadcrumbs,
-    setGroupDetailsBreadcrumbs,
-    setGroupsBreadcrumbs,
-    setProcessBreadcrumbs,
-    setSharedWithMeBreadcrumbs,
-    setSidePanelBreadcrumbs,
-    setTrashBreadcrumbs,
-    setUsersBreadcrumbs,
-    setMyAccountBreadcrumbs,
-    setUserProfileBreadcrumbs,
+  setBreadcrumbs,
+  setGroupDetailsBreadcrumbs,
+  setGroupsBreadcrumbs,
+  setProcessBreadcrumbs,
+  setSharedWithMeBreadcrumbs,
+  setSidePanelBreadcrumbs,
+  setTrashBreadcrumbs,
+  setUsersBreadcrumbs,
+  setMyAccountBreadcrumbs,
+  setUserProfileBreadcrumbs,
 } from 'store/breadcrumbs/breadcrumbs-actions';
-import { navigateTo, navigateToRootProject } from 'store/navigation/navigation-action';
+import {
+  navigateTo,
+  navigateToRootProject,
+} from 'store/navigation/navigation-action';
 import { MoveToFormDialogData } from 'store/move-to-dialog/move-to-dialog';
 import { ServiceRepository } from 'services/services';
 import { getResource } from 'store/resources/resources';
@@ -50,17 +56,23 @@ import * as processesActions from 'store/processes/processes-actions';
 import * as processMoveActions from 'store/processes/process-move-actions';
 import * as processUpdateActions from 'store/processes/process-update-actions';
 import * as processCopyActions from 'store/processes/process-copy-actions';
-import { trashPanelColumns } from "views/trash-panel/trash-panel";
-import { loadTrashPanel, trashPanelActions } from "store/trash-panel/trash-panel-action";
+import { trashPanelColumns } from 'views/trash-panel/trash-panel';
+import {
+  loadTrashPanel,
+  trashPanelActions,
+} from 'store/trash-panel/trash-panel-action';
 import { loadProcessPanel } from 'store/process-panel/process-panel-actions';
 import {
-    loadSharedWithMePanel,
-    sharedWithMePanelActions
+  loadSharedWithMePanel,
+  sharedWithMePanelActions,
 } from 'store/shared-with-me-panel/shared-with-me-panel-actions';
 import { CopyFormDialogData } from 'store/copy-dialog/copy-dialog';
 import { workflowPanelActions } from 'store/workflow-panel/workflow-panel-actions';
 import { loadSshKeysPanel } from 'store/auth/auth-action-ssh';
-import { loadLinkAccountPanel, linkAccountPanelActions } from 'store/link-account-panel/link-account-panel-actions';
+import {
+  loadLinkAccountPanel,
+  linkAccountPanelActions,
+} from 'store/link-account-panel/link-account-panel-actions';
 import { loadSiteManagerPanel } from 'store/auth/auth-action-session';
 import { workflowPanelColumns } from 'views/workflow-panel/workflow-panel-view';
 import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
@@ -70,11 +82,14 @@ import { FilterBuilder } from 'services/api/filter-builder';
 import { GroupContentsResource } from 'services/groups-service/groups-service';
 import { MatchCases, ofType, unionize, UnionOf } from 'common/unionize';
 import { loadRunProcessPanel } from 'store/run-process-panel/run-process-panel-actions';
-import { collectionPanelActions, loadCollectionPanel } from "store/collection-panel/collection-panel-action";
-import { CollectionResource } from "models/collection";
 import {
-    loadSearchResultsPanel,
-    searchResultsPanelActions
+  collectionPanelActions,
+  loadCollectionPanel,
+} from 'store/collection-panel/collection-panel-action';
+import { CollectionResource } from 'models/collection';
+import {
+  loadSearchResultsPanel,
+  searchResultsPanelActions,
 } from 'store/search-results-panel/search-results-panel-actions';
 import { searchResultsPanelColumns } from 'views/search-results-panel/search-results-panel-view';
 import { loadVirtualMachinesPanel } from 'store/virtual-machines/virtual-machines-actions';
@@ -82,23 +97,41 @@ import { loadRepositoriesPanel } from 'store/repositories/repositories-actions';
 import { loadKeepServicesPanel } from 'store/keep-services/keep-services-actions';
 import { loadUsersPanel, userBindedActions } from 'store/users/users-actions';
 import * as userProfilePanelActions from 'store/user-profile/user-profile-actions';
-import { linkPanelActions, loadLinkPanel } from 'store/link-panel/link-panel-actions';
+import {
+  linkPanelActions,
+  loadLinkPanel,
+} from 'store/link-panel/link-panel-actions';
 import { linkPanelColumns } from 'views/link-panel/link-panel-root';
 import { userPanelColumns } from 'views/user-panel/user-panel';
-import { loadApiClientAuthorizationsPanel, apiClientAuthorizationsActions } from 'store/api-client-authorizations/api-client-authorizations-actions';
+import {
+  loadApiClientAuthorizationsPanel,
+  apiClientAuthorizationsActions,
+} from 'store/api-client-authorizations/api-client-authorizations-actions';
 import { apiClientAuthorizationPanelColumns } from 'views/api-client-authorization-panel/api-client-authorization-panel-root';
 import * as groupPanelActions from 'store/groups-panel/groups-panel-actions';
 import { groupsPanelColumns } from 'views/groups-panel/groups-panel';
 import * as groupDetailsPanelActions from 'store/group-details-panel/group-details-panel-actions';
-import { groupDetailsMembersPanelColumns, groupDetailsPermissionsPanelColumns } from 'views/group-details-panel/group-details-panel';
-import { DataTableFetchMode } from "components/data-table/data-table";
-import { loadPublicFavoritePanel, publicFavoritePanelActions } from 'store/public-favorites-panel/public-favorites-action';
+import {
+  groupDetailsMembersPanelColumns,
+  groupDetailsPermissionsPanelColumns,
+} from 'views/group-details-panel/group-details-panel';
+import { DataTableFetchMode } from 'components/data-table/data-table';
+import {
+  loadPublicFavoritePanel,
+  publicFavoritePanelActions,
+} from 'store/public-favorites-panel/public-favorites-action';
 import { publicFavoritePanelColumns } from 'views/public-favorites-panel/public-favorites-panel';
-import { loadCollectionsContentAddressPanel, collectionsContentAddressActions } from 'store/collections-content-address-panel/collections-content-address-panel-actions';
+import {
+  loadCollectionsContentAddressPanel,
+  collectionsContentAddressActions,
+} from 'store/collections-content-address-panel/collections-content-address-panel-actions';
 import { collectionContentAddressPanelColumns } from 'views/collection-content-address-panel/collection-content-address-panel';
 import { subprocessPanelActions } from 'store/subprocess-panel/subprocess-panel-actions';
 import { subprocessPanelColumns } from 'views/subprocess-panel/subprocess-panel-root';
-import { loadAllProcessesPanel, allProcessesPanelActions } from '../all-processes-panel/all-processes-panel-action';
+import {
+  loadAllProcessesPanel,
+  allProcessesPanelActions,
+} from '../all-processes-panel/all-processes-panel-action';
 import { allProcessesPanelColumns } from 'views/all-processes-panel/all-processes-panel';
 import { AdminMenuIcon } from 'components/icon/icon';
 import { userProfileGroupsColumns } from 'views/user-profile-panel/user-profile-panel-root';
@@ -106,497 +139,759 @@ import { userProfileGroupsColumns } from 'views/user-profile-panel/user-profile-
 export const WORKBENCH_LOADING_SCREEN = 'workbenchLoadingScreen';
 
 export const isWorkbenchLoading = (state: RootState) => {
-    const progress = getProgressIndicator(WORKBENCH_LOADING_SCREEN)(state.progressIndicator);
-    return progress ? progress.working : false;
+  const progress = getProgressIndicator(WORKBENCH_LOADING_SCREEN)(
+    state.progressIndicator
+  );
+  return progress ? progress.working : false;
 };
 
-export const handleFirstTimeLoad = (action: any) =>
-    async (dispatch: Dispatch<any>, getState: () => RootState) => {
-        try {
-            await dispatch(action);
-        } finally {
-            if (isWorkbenchLoading(getState())) {
-                dispatch(progressIndicatorActions.STOP_WORKING(WORKBENCH_LOADING_SCREEN));
-            }
-        }
-    };
-
-export const loadWorkbench = () =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        dispatch(progressIndicatorActions.START_WORKING(WORKBENCH_LOADING_SCREEN));
-        const { auth, router } = getState();
-        const { user } = auth;
-        if (user) {
-            dispatch(projectPanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
-            dispatch(favoritePanelActions.SET_COLUMNS({ columns: favoritePanelColumns }));
-            dispatch(allProcessesPanelActions.SET_COLUMNS({ columns: allProcessesPanelColumns }));
-            dispatch(publicFavoritePanelActions.SET_COLUMNS({ columns: publicFavoritePanelColumns }));
-            dispatch(trashPanelActions.SET_COLUMNS({ columns: trashPanelColumns }));
-            dispatch(sharedWithMePanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
-            dispatch(workflowPanelActions.SET_COLUMNS({ columns: workflowPanelColumns }));
-            dispatch(searchResultsPanelActions.SET_FETCH_MODE({ fetchMode: DataTableFetchMode.INFINITE }));
-            dispatch(searchResultsPanelActions.SET_COLUMNS({ columns: searchResultsPanelColumns }));
-            dispatch(userBindedActions.SET_COLUMNS({ columns: userPanelColumns }));
-            dispatch(groupPanelActions.GroupsPanelActions.SET_COLUMNS({ columns: groupsPanelColumns }));
-            dispatch(groupDetailsPanelActions.GroupMembersPanelActions.SET_COLUMNS({ columns: groupDetailsMembersPanelColumns }));
-            dispatch(groupDetailsPanelActions.GroupPermissionsPanelActions.SET_COLUMNS({ columns: groupDetailsPermissionsPanelColumns }));
-            dispatch(userProfilePanelActions.UserProfileGroupsActions.SET_COLUMNS({ columns: userProfileGroupsColumns }));
-            dispatch(linkPanelActions.SET_COLUMNS({ columns: linkPanelColumns }));
-            dispatch(apiClientAuthorizationsActions.SET_COLUMNS({ columns: apiClientAuthorizationPanelColumns }));
-            dispatch(collectionsContentAddressActions.SET_COLUMNS({ columns: collectionContentAddressPanelColumns }));
-            dispatch(subprocessPanelActions.SET_COLUMNS({ columns: subprocessPanelColumns }));
-
-            if (services.linkAccountService.getAccountToLink()) {
-                dispatch(linkAccountPanelActions.HAS_SESSION_DATA());
-            }
-
-            dispatch<any>(initSidePanelTree());
-            if (router.location) {
-                const match = matchRootRoute(router.location.pathname);
-                if (match) {
-                    dispatch<any>(navigateToRootProject);
-                }
-            }
-        } else {
-            dispatch(userIsNotAuthenticated);
+export const handleFirstTimeLoad =
+  (action: any) =>
+  async (dispatch: Dispatch<any>, getState: () => RootState) => {
+    try {
+      await dispatch(action);
+    } finally {
+      if (isWorkbenchLoading(getState())) {
+        dispatch(
+          progressIndicatorActions.STOP_WORKING(WORKBENCH_LOADING_SCREEN)
+        );
+      }
+    }
+  };
+
+export const loadWorkbench =
+  () =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    dispatch(progressIndicatorActions.START_WORKING(WORKBENCH_LOADING_SCREEN));
+    const { auth, router } = getState();
+    const { user } = auth;
+    if (user) {
+      //   console.log('PREJECTPANELCOLUMNS', projectPanelColumns);
+      dispatch(
+        projectPanelActions.SET_COLUMNS({ columns: projectPanelColumns })
+      );
+      dispatch(
+        favoritePanelActions.SET_COLUMNS({ columns: favoritePanelColumns })
+      );
+      dispatch(
+        allProcessesPanelActions.SET_COLUMNS({
+          columns: allProcessesPanelColumns,
+        })
+      );
+      dispatch(
+        publicFavoritePanelActions.SET_COLUMNS({
+          columns: publicFavoritePanelColumns,
+        })
+      );
+      dispatch(trashPanelActions.SET_COLUMNS({ columns: trashPanelColumns }));
+      dispatch(
+        sharedWithMePanelActions.SET_COLUMNS({ columns: projectPanelColumns })
+      );
+      dispatch(
+        workflowPanelActions.SET_COLUMNS({ columns: workflowPanelColumns })
+      );
+      dispatch(
+        searchResultsPanelActions.SET_FETCH_MODE({
+          fetchMode: DataTableFetchMode.INFINITE,
+        })
+      );
+      dispatch(
+        searchResultsPanelActions.SET_COLUMNS({
+          columns: searchResultsPanelColumns,
+        })
+      );
+      dispatch(userBindedActions.SET_COLUMNS({ columns: userPanelColumns }));
+      dispatch(
+        groupPanelActions.GroupsPanelActions.SET_COLUMNS({
+          columns: groupsPanelColumns,
+        })
+      );
+      dispatch(
+        groupDetailsPanelActions.GroupMembersPanelActions.SET_COLUMNS({
+          columns: groupDetailsMembersPanelColumns,
+        })
+      );
+      dispatch(
+        groupDetailsPanelActions.GroupPermissionsPanelActions.SET_COLUMNS({
+          columns: groupDetailsPermissionsPanelColumns,
+        })
+      );
+      dispatch(
+        userProfilePanelActions.UserProfileGroupsActions.SET_COLUMNS({
+          columns: userProfileGroupsColumns,
+        })
+      );
+      dispatch(linkPanelActions.SET_COLUMNS({ columns: linkPanelColumns }));
+      dispatch(
+        apiClientAuthorizationsActions.SET_COLUMNS({
+          columns: apiClientAuthorizationPanelColumns,
+        })
+      );
+      dispatch(
+        collectionsContentAddressActions.SET_COLUMNS({
+          columns: collectionContentAddressPanelColumns,
+        })
+      );
+      dispatch(
+        subprocessPanelActions.SET_COLUMNS({ columns: subprocessPanelColumns })
+      );
+
+      if (services.linkAccountService.getAccountToLink()) {
+        dispatch(linkAccountPanelActions.HAS_SESSION_DATA());
+      }
+
+      dispatch<any>(initSidePanelTree());
+      if (router.location) {
+        const match = matchRootRoute(router.location.pathname);
+        if (match) {
+          dispatch<any>(navigateToRootProject);
         }
-    };
+      }
+    } else {
+      dispatch(userIsNotAuthenticated);
+    }
+  };
 
 export const loadFavorites = () =>
-    handleFirstTimeLoad(
-        (dispatch: Dispatch) => {
-            dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.FAVORITES));
-            dispatch<any>(loadFavoritePanel());
-            dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.FAVORITES));
-        });
+  handleFirstTimeLoad((dispatch: Dispatch) => {
+    dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.FAVORITES));
+    dispatch<any>(loadFavoritePanel());
+    dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.FAVORITES));
+  });
 
 export const loadCollectionContentAddress = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadCollectionsContentAddressPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadCollectionsContentAddressPanel());
+  }
+);
 
 export const loadTrash = () =>
-    handleFirstTimeLoad(
-        (dispatch: Dispatch) => {
-            dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
-            dispatch<any>(loadTrashPanel());
-            dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.TRASH));
-        });
+  handleFirstTimeLoad((dispatch: Dispatch) => {
+    dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
+    dispatch<any>(loadTrashPanel());
+    dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.TRASH));
+  });
 
 export const loadAllProcesses = () =>
-    handleFirstTimeLoad(
-        (dispatch: Dispatch) => {
-            dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.ALL_PROCESSES));
-            dispatch<any>(loadAllProcessesPanel());
-            dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.ALL_PROCESSES));
-        }
+  handleFirstTimeLoad((dispatch: Dispatch) => {
+    dispatch<any>(
+      activateSidePanelTreeItem(SidePanelTreeCategory.ALL_PROCESSES)
     );
+    dispatch<any>(loadAllProcessesPanel());
+    dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.ALL_PROCESSES));
+  });
 
 export const loadProject = (uuid: string) =>
-    handleFirstTimeLoad(
-        async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
-            const userUuid = getUserUuid(getState());
-            dispatch(setIsProjectPanelTrashed(false));
-            if (!userUuid) {
-                return;
-            }
-            if (extractUuidKind(uuid) === ResourceKind.USER && userUuid !== uuid) {
-                // Load another users home projects
-                dispatch(finishLoadingProject(uuid));
-            } else if (userUuid !== uuid) {
-                await dispatch(finishLoadingProject(uuid));
-                const match = await loadGroupContentsResource({ uuid, userUuid, services });
-                match({
-                    OWNED: async () => {
-                        await dispatch(activateSidePanelTreeItem(uuid));
-                        dispatch<any>(setSidePanelBreadcrumbs(uuid));
-                    },
-                    SHARED: async () => {
-                        await dispatch(activateSidePanelTreeItem(uuid));
-                        dispatch<any>(setSharedWithMeBreadcrumbs(uuid));
-                    },
-                    TRASHED: async () => {
-                        await dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
-                        dispatch<any>(setTrashBreadcrumbs(uuid));
-                        dispatch(setIsProjectPanelTrashed(true));
-                    }
-                });
-            } else {
-                await dispatch(finishLoadingProject(userUuid));
-                await dispatch(activateSidePanelTreeItem(userUuid));
-                dispatch<any>(setSidePanelBreadcrumbs(userUuid));
-            }
+  handleFirstTimeLoad(
+    async (
+      dispatch: Dispatch<any>,
+      getState: () => RootState,
+      services: ServiceRepository
+    ) => {
+      const userUuid = getUserUuid(getState());
+      dispatch(setIsProjectPanelTrashed(false));
+      if (!userUuid) {
+        return;
+      }
+      if (extractUuidKind(uuid) === ResourceKind.USER && userUuid !== uuid) {
+        // Load another users home projects
+        dispatch(finishLoadingProject(uuid));
+      } else if (userUuid !== uuid) {
+        await dispatch(finishLoadingProject(uuid));
+        const match = await loadGroupContentsResource({
+          uuid,
+          userUuid,
+          services,
+        });
+        match({
+          OWNED: async () => {
+            await dispatch(activateSidePanelTreeItem(uuid));
+            dispatch<any>(setSidePanelBreadcrumbs(uuid));
+          },
+          SHARED: async () => {
+            await dispatch(activateSidePanelTreeItem(uuid));
+            dispatch<any>(setSharedWithMeBreadcrumbs(uuid));
+          },
+          TRASHED: async () => {
+            await dispatch(
+              activateSidePanelTreeItem(SidePanelTreeCategory.TRASH)
+            );
+            dispatch<any>(setTrashBreadcrumbs(uuid));
+            dispatch(setIsProjectPanelTrashed(true));
+          },
         });
+      } else {
+        await dispatch(finishLoadingProject(userUuid));
+        await dispatch(activateSidePanelTreeItem(userUuid));
+        dispatch<any>(setSidePanelBreadcrumbs(userUuid));
+      }
+    }
+  );
 
-export const createProject = (data: projectCreateActions.ProjectCreateFormDialogData) =>
-    async (dispatch: Dispatch) => {
-        const newProject = await dispatch<any>(projectCreateActions.createProject(data));
-        if (newProject) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({
-                message: "Project has been successfully created.",
-                hideDuration: 2000,
-                kind: SnackbarKind.SUCCESS
-            }));
-            await dispatch<any>(loadSidePanelTreeProjects(newProject.ownerUuid));
-            dispatch<any>(navigateTo(newProject.uuid));
-        }
-    };
-
-export const moveProject = (data: MoveToFormDialogData) =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        try {
-            const oldProject = getResource(data.uuid)(getState().resources);
-            const oldOwnerUuid = oldProject ? oldProject.ownerUuid : '';
-            const movedProject = await dispatch<any>(projectMoveActions.moveProject(data));
-            if (movedProject) {
-                dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Project has been moved', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
-                if (oldProject) {
-                    await dispatch<any>(loadSidePanelTreeProjects(oldProject.ownerUuid));
-                }
-                dispatch<any>(reloadProjectMatchingUuid([oldOwnerUuid, movedProject.ownerUuid, movedProject.uuid]));
-            }
-        } catch (e) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
-        }
-    };
-
-export const updateProject = (data: projectUpdateActions.ProjectUpdateFormDialogData) =>
-    async (dispatch: Dispatch) => {
-        const updatedProject = await dispatch<any>(projectUpdateActions.updateProject(data));
-        if (updatedProject) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({
-                message: "Project has been successfully updated.",
-                hideDuration: 2000,
-                kind: SnackbarKind.SUCCESS
-            }));
-            await dispatch<any>(loadSidePanelTreeProjects(updatedProject.ownerUuid));
-            dispatch<any>(reloadProjectMatchingUuid([updatedProject.ownerUuid, updatedProject.uuid]));
-        }
-    };
-
-export const updateGroup = (data: projectUpdateActions.ProjectUpdateFormDialogData) =>
-    async (dispatch: Dispatch) => {
-        const updatedGroup = await dispatch<any>(groupPanelActions.updateGroup(data));
-        if (updatedGroup) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({
-                message: "Group has been successfully updated.",
-                hideDuration: 2000,
-                kind: SnackbarKind.SUCCESS
-            }));
-            await dispatch<any>(loadSidePanelTreeProjects(updatedGroup.ownerUuid));
-            dispatch<any>(reloadProjectMatchingUuid([updatedGroup.ownerUuid, updatedGroup.uuid]));
+export const createProject =
+  (data: projectCreateActions.ProjectCreateFormDialogData) =>
+  async (dispatch: Dispatch) => {
+    const newProject = await dispatch<any>(
+      projectCreateActions.createProject(data)
+    );
+    if (newProject) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Project has been successfully created.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+      await dispatch<any>(loadSidePanelTreeProjects(newProject.ownerUuid));
+      dispatch<any>(navigateTo(newProject.uuid));
+    }
+  };
+
+export const moveProject =
+  (data: MoveToFormDialogData) =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    try {
+      const oldProject = getResource(data.uuid)(getState().resources);
+      const oldOwnerUuid = oldProject ? oldProject.ownerUuid : '';
+      const movedProject = await dispatch<any>(
+        projectMoveActions.moveProject(data)
+      );
+      if (movedProject) {
+        dispatch(
+          snackbarActions.OPEN_SNACKBAR({
+            message: 'Project has been moved',
+            hideDuration: 2000,
+            kind: SnackbarKind.SUCCESS,
+          })
+        );
+        if (oldProject) {
+          await dispatch<any>(loadSidePanelTreeProjects(oldProject.ownerUuid));
         }
-    };
+        dispatch<any>(
+          reloadProjectMatchingUuid([
+            oldOwnerUuid,
+            movedProject.ownerUuid,
+            movedProject.uuid,
+          ])
+        );
+      }
+    } catch (e) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: e.message,
+          hideDuration: 2000,
+          kind: SnackbarKind.ERROR,
+        })
+      );
+    }
+  };
+
+export const updateProject =
+  (data: projectUpdateActions.ProjectUpdateFormDialogData) =>
+  async (dispatch: Dispatch) => {
+    const updatedProject = await dispatch<any>(
+      projectUpdateActions.updateProject(data)
+    );
+    if (updatedProject) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Project has been successfully updated.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+      await dispatch<any>(loadSidePanelTreeProjects(updatedProject.ownerUuid));
+      dispatch<any>(
+        reloadProjectMatchingUuid([
+          updatedProject.ownerUuid,
+          updatedProject.uuid,
+        ])
+      );
+    }
+  };
+
+export const updateGroup =
+  (data: projectUpdateActions.ProjectUpdateFormDialogData) =>
+  async (dispatch: Dispatch) => {
+    const updatedGroup = await dispatch<any>(
+      groupPanelActions.updateGroup(data)
+    );
+    if (updatedGroup) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Group has been successfully updated.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+      await dispatch<any>(loadSidePanelTreeProjects(updatedGroup.ownerUuid));
+      dispatch<any>(
+        reloadProjectMatchingUuid([updatedGroup.ownerUuid, updatedGroup.uuid])
+      );
+    }
+  };
 
 export const loadCollection = (uuid: string) =>
-    handleFirstTimeLoad(
-        async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
-            const userUuid = getUserUuid(getState());
-            if (userUuid) {
-                const match = await loadGroupContentsResource({ uuid, userUuid, services });
-                match({
-                    OWNED: collection => {
-                        dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
-                        dispatch(updateResources([collection]));
-                        dispatch(activateSidePanelTreeItem(collection.ownerUuid));
-                        dispatch(setSidePanelBreadcrumbs(collection.ownerUuid));
-                        dispatch(loadCollectionPanel(collection.uuid));
-                    },
-                    SHARED: collection => {
-                        dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
-                        dispatch(updateResources([collection]));
-                        dispatch<any>(setSharedWithMeBreadcrumbs(collection.ownerUuid));
-                        dispatch(activateSidePanelTreeItem(collection.ownerUuid));
-                        dispatch(loadCollectionPanel(collection.uuid));
-                    },
-                    TRASHED: collection => {
-                        dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
-                        dispatch(updateResources([collection]));
-                        dispatch(setTrashBreadcrumbs(''));
-                        dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
-                        dispatch(loadCollectionPanel(collection.uuid));
-                    },
-                });
-            }
+  handleFirstTimeLoad(
+    async (
+      dispatch: Dispatch<any>,
+      getState: () => RootState,
+      services: ServiceRepository
+    ) => {
+      const userUuid = getUserUuid(getState());
+      if (userUuid) {
+        const match = await loadGroupContentsResource({
+          uuid,
+          userUuid,
+          services,
         });
+        match({
+          OWNED: (collection) => {
+            dispatch(
+              collectionPanelActions.SET_COLLECTION(
+                collection as CollectionResource
+              )
+            );
+            dispatch(updateResources([collection]));
+            dispatch(activateSidePanelTreeItem(collection.ownerUuid));
+            dispatch(setSidePanelBreadcrumbs(collection.ownerUuid));
+            dispatch(loadCollectionPanel(collection.uuid));
+          },
+          SHARED: (collection) => {
+            dispatch(
+              collectionPanelActions.SET_COLLECTION(
+                collection as CollectionResource
+              )
+            );
+            dispatch(updateResources([collection]));
+            dispatch<any>(setSharedWithMeBreadcrumbs(collection.ownerUuid));
+            dispatch(activateSidePanelTreeItem(collection.ownerUuid));
+            dispatch(loadCollectionPanel(collection.uuid));
+          },
+          TRASHED: (collection) => {
+            dispatch(
+              collectionPanelActions.SET_COLLECTION(
+                collection as CollectionResource
+              )
+            );
+            dispatch(updateResources([collection]));
+            dispatch(setTrashBreadcrumbs(''));
+            dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
+            dispatch(loadCollectionPanel(collection.uuid));
+          },
+        });
+      }
+    }
+  );
 
-export const createCollection = (data: collectionCreateActions.CollectionCreateFormDialogData) =>
-    async (dispatch: Dispatch) => {
-        const collection = await dispatch<any>(collectionCreateActions.createCollection(data));
-        if (collection) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({
-                message: "Collection has been successfully created.",
-                hideDuration: 2000,
-                kind: SnackbarKind.SUCCESS
-            }));
-            dispatch<any>(updateResources([collection]));
-            dispatch<any>(navigateTo(collection.uuid));
-        }
-    };
-
-export const copyCollection = (data: CopyFormDialogData) =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        try {
-            const copyToProject = getResource(data.ownerUuid)(getState().resources);
-            const collection = await dispatch<any>(collectionCopyActions.copyCollection(data));
-            if (copyToProject && collection) {
-                dispatch<any>(reloadProjectMatchingUuid([copyToProject.uuid]));
-                dispatch(snackbarActions.OPEN_SNACKBAR({
-                    message: 'Collection has been copied.',
-                    hideDuration: 3000,
-                    kind: SnackbarKind.SUCCESS,
-                    link: collection.ownerUuid
-                }));
-            }
-        } catch (e) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
-        }
-    };
-
-export const moveCollection = (data: MoveToFormDialogData) =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        try {
-            const collection = await dispatch<any>(collectionMoveActions.moveCollection(data));
-            dispatch<any>(updateResources([collection]));
-            dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Collection has been moved.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
-        } catch (e) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
-        }
-    };
+export const createCollection =
+  (data: collectionCreateActions.CollectionCreateFormDialogData) =>
+  async (dispatch: Dispatch) => {
+    const collection = await dispatch<any>(
+      collectionCreateActions.createCollection(data)
+    );
+    if (collection) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Collection has been successfully created.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+      dispatch<any>(updateResources([collection]));
+      dispatch<any>(navigateTo(collection.uuid));
+    }
+  };
+
+export const copyCollection =
+  (data: CopyFormDialogData) =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    try {
+      const copyToProject = getResource(data.ownerUuid)(getState().resources);
+      const collection = await dispatch<any>(
+        collectionCopyActions.copyCollection(data)
+      );
+      if (copyToProject && collection) {
+        dispatch<any>(reloadProjectMatchingUuid([copyToProject.uuid]));
+        dispatch(
+          snackbarActions.OPEN_SNACKBAR({
+            message: 'Collection has been copied.',
+            hideDuration: 3000,
+            kind: SnackbarKind.SUCCESS,
+            link: collection.ownerUuid,
+          })
+        );
+      }
+    } catch (e) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: e.message,
+          hideDuration: 2000,
+          kind: SnackbarKind.ERROR,
+        })
+      );
+    }
+  };
+
+export const moveCollection =
+  (data: MoveToFormDialogData) =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    try {
+      const collection = await dispatch<any>(
+        collectionMoveActions.moveCollection(data)
+      );
+      dispatch<any>(updateResources([collection]));
+      dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Collection has been moved.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+    } catch (e) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: e.message,
+          hideDuration: 2000,
+          kind: SnackbarKind.ERROR,
+        })
+      );
+    }
+  };
 
 export const loadProcess = (uuid: string) =>
-    handleFirstTimeLoad(
-        async (dispatch: Dispatch, getState: () => RootState) => {
-            dispatch<any>(loadProcessPanel(uuid));
-            const process = await dispatch<any>(processesActions.loadProcess(uuid));
-            await dispatch<any>(activateSidePanelTreeItem(process.containerRequest.ownerUuid));
-            dispatch<any>(setProcessBreadcrumbs(uuid));
-            dispatch<any>(loadDetailsPanel(uuid));
-        });
+  handleFirstTimeLoad(async (dispatch: Dispatch, getState: () => RootState) => {
+    dispatch<any>(loadProcessPanel(uuid));
+    const process = await dispatch<any>(processesActions.loadProcess(uuid));
+    await dispatch<any>(
+      activateSidePanelTreeItem(process.containerRequest.ownerUuid)
+    );
+    dispatch<any>(setProcessBreadcrumbs(uuid));
+    dispatch<any>(loadDetailsPanel(uuid));
+  });
+
+export const updateProcess =
+  (data: processUpdateActions.ProcessUpdateFormDialogData) =>
+  async (dispatch: Dispatch) => {
+    try {
+      const process = await dispatch<any>(
+        processUpdateActions.updateProcess(data)
+      );
+      if (process) {
+        dispatch(
+          snackbarActions.OPEN_SNACKBAR({
+            message: 'Process has been successfully updated.',
+            hideDuration: 2000,
+            kind: SnackbarKind.SUCCESS,
+          })
+        );
+        dispatch<any>(updateResources([process]));
+        dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
+      }
+    } catch (e) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: e.message,
+          hideDuration: 2000,
+          kind: SnackbarKind.ERROR,
+        })
+      );
+    }
+  };
 
-export const updateProcess = (data: processUpdateActions.ProcessUpdateFormDialogData) =>
-    async (dispatch: Dispatch) => {
-        try {
-            const process = await dispatch<any>(processUpdateActions.updateProcess(data));
-            if (process) {
-                dispatch(snackbarActions.OPEN_SNACKBAR({
-                    message: "Process has been successfully updated.",
-                    hideDuration: 2000,
-                    kind: SnackbarKind.SUCCESS
-                }));
-                dispatch<any>(updateResources([process]));
-                dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
-            }
-        } catch (e) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
-        }
-    };
-
-export const moveProcess = (data: MoveToFormDialogData) =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        try {
-            const process = await dispatch<any>(processMoveActions.moveProcess(data));
-            dispatch<any>(updateResources([process]));
-            dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Process has been moved.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
-        } catch (e) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
-        }
-    };
-
-export const copyProcess = (data: CopyFormDialogData) =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        try {
-            const process = await dispatch<any>(processCopyActions.copyProcess(data));
-            dispatch<any>(updateResources([process]));
-            dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Process has been copied.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
-        } catch (e) {
-            dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
-        }
-    };
+export const moveProcess =
+  (data: MoveToFormDialogData) =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    try {
+      const process = await dispatch<any>(processMoveActions.moveProcess(data));
+      dispatch<any>(updateResources([process]));
+      dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Process has been moved.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+    } catch (e) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: e.message,
+          hideDuration: 2000,
+          kind: SnackbarKind.ERROR,
+        })
+      );
+    }
+  };
+
+export const copyProcess =
+  (data: CopyFormDialogData) =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    try {
+      const process = await dispatch<any>(processCopyActions.copyProcess(data));
+      dispatch<any>(updateResources([process]));
+      dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: 'Process has been copied.',
+          hideDuration: 2000,
+          kind: SnackbarKind.SUCCESS,
+        })
+      );
+    } catch (e) {
+      dispatch(
+        snackbarActions.OPEN_SNACKBAR({
+          message: e.message,
+          hideDuration: 2000,
+          kind: SnackbarKind.ERROR,
+        })
+      );
+    }
+  };
 
 export const resourceIsNotLoaded = (uuid: string) =>
-    snackbarActions.OPEN_SNACKBAR({
-        message: `Resource identified by ${uuid} is not loaded.`,
-        kind: SnackbarKind.ERROR
-    });
+  snackbarActions.OPEN_SNACKBAR({
+    message: `Resource identified by ${uuid} is not loaded.`,
+    kind: SnackbarKind.ERROR,
+  });
 
 export const userIsNotAuthenticated = snackbarActions.OPEN_SNACKBAR({
-    message: 'User is not authenticated',
-    kind: SnackbarKind.ERROR
+  message: 'User is not authenticated',
+  kind: SnackbarKind.ERROR,
 });
 
 export const couldNotLoadUser = snackbarActions.OPEN_SNACKBAR({
-    message: 'Could not load user',
-    kind: SnackbarKind.ERROR
+  message: 'Could not load user',
+  kind: SnackbarKind.ERROR,
 });
 
-export const reloadProjectMatchingUuid = (matchingUuids: string[]) =>
-    async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
-        const currentProjectPanelUuid = getProjectPanelCurrentUuid(getState());
-        if (currentProjectPanelUuid && matchingUuids.some(uuid => uuid === currentProjectPanelUuid)) {
-            dispatch<any>(loadProject(currentProjectPanelUuid));
-        }
-    };
+export const reloadProjectMatchingUuid =
+  (matchingUuids: string[]) =>
+  async (
+    dispatch: Dispatch,
+    getState: () => RootState,
+    services: ServiceRepository
+  ) => {
+    const currentProjectPanelUuid = getProjectPanelCurrentUuid(getState());
+    if (
+      currentProjectPanelUuid &&
+      matchingUuids.some((uuid) => uuid === currentProjectPanelUuid)
+    ) {
+      dispatch<any>(loadProject(currentProjectPanelUuid));
+    }
+  };
 
-export const loadSharedWithMe = handleFirstTimeLoad(async (dispatch: Dispatch) => {
+export const loadSharedWithMe = handleFirstTimeLoad(
+  async (dispatch: Dispatch) => {
     dispatch<any>(loadSharedWithMePanel());
-    await dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME));
-    await dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.SHARED_WITH_ME));
-});
+    await dispatch<any>(
+      activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME)
+    );
+    await dispatch<any>(
+      setSidePanelBreadcrumbs(SidePanelTreeCategory.SHARED_WITH_ME)
+    );
+  }
+);
 
 export const loadRunProcess = handleFirstTimeLoad(
-    async (dispatch: Dispatch) => {
-        await dispatch<any>(loadRunProcessPanel());
-    }
+  async (dispatch: Dispatch) => {
+    await dispatch<any>(loadRunProcessPanel());
+  }
 );
 
 export const loadPublicFavorites = () =>
-    handleFirstTimeLoad(
-        (dispatch: Dispatch) => {
-            dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.PUBLIC_FAVORITES));
-            dispatch<any>(loadPublicFavoritePanel());
-            dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.PUBLIC_FAVORITES));
-        });
+  handleFirstTimeLoad((dispatch: Dispatch) => {
+    dispatch<any>(
+      activateSidePanelTreeItem(SidePanelTreeCategory.PUBLIC_FAVORITES)
+    );
+    dispatch<any>(loadPublicFavoritePanel());
+    dispatch<any>(
+      setSidePanelBreadcrumbs(SidePanelTreeCategory.PUBLIC_FAVORITES)
+    );
+  });
 
 export const loadSearchResults = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadSearchResultsPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadSearchResultsPanel());
+  }
+);
 
 export const loadLinks = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadLinkPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadLinkPanel());
+  }
+);
 
 export const loadVirtualMachines = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadVirtualMachinesPanel());
-        dispatch(setBreadcrumbs([{ label: 'Virtual Machines' }]));
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadVirtualMachinesPanel());
+    dispatch(setBreadcrumbs([{ label: 'Virtual Machines' }]));
+  }
+);
 
 export const loadVirtualMachinesAdmin = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadVirtualMachinesPanel());
-        dispatch(setBreadcrumbs([{ label: 'Virtual Machines Admin', icon: AdminMenuIcon }]));
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadVirtualMachinesPanel());
+    dispatch(
+      setBreadcrumbs([{ label: 'Virtual Machines Admin', icon: AdminMenuIcon }])
+    );
+  }
+);
 
 export const loadRepositories = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadRepositoriesPanel());
-        dispatch(setBreadcrumbs([{ label: 'Repositories' }]));
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadRepositoriesPanel());
+    dispatch(setBreadcrumbs([{ label: 'Repositories' }]));
+  }
+);
 
 export const loadSshKeys = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadSshKeysPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadSshKeysPanel());
+  }
+);
 
 export const loadSiteManager = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadSiteManagerPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadSiteManagerPanel());
+  }
+);
 
 export const loadUserProfile = (userUuid?: string) =>
-    handleFirstTimeLoad(
-        (dispatch: Dispatch<any>) => {
-            if (userUuid) {
-                dispatch(setUserProfileBreadcrumbs(userUuid));
-                dispatch(userProfilePanelActions.loadUserProfilePanel(userUuid));
-            } else {
-                dispatch(setMyAccountBreadcrumbs());
-                dispatch(userProfilePanelActions.loadUserProfilePanel());
-            }
-        }
-    );
+  handleFirstTimeLoad((dispatch: Dispatch<any>) => {
+    if (userUuid) {
+      dispatch(setUserProfileBreadcrumbs(userUuid));
+      dispatch(userProfilePanelActions.loadUserProfilePanel(userUuid));
+    } else {
+      dispatch(setMyAccountBreadcrumbs());
+      dispatch(userProfilePanelActions.loadUserProfilePanel());
+    }
+  });
 
 export const loadLinkAccount = handleFirstTimeLoad(
-    (dispatch: Dispatch<any>) => {
-        dispatch(loadLinkAccountPanel());
-    });
+  (dispatch: Dispatch<any>) => {
+    dispatch(loadLinkAccountPanel());
+  }
+);
 
 export const loadKeepServices = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadKeepServicesPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadKeepServicesPanel());
+  }
+);
 
 export const loadUsers = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadUsersPanel());
-        dispatch(setUsersBreadcrumbs());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadUsersPanel());
+    dispatch(setUsersBreadcrumbs());
+  }
+);
 
 export const loadApiClientAuthorizations = handleFirstTimeLoad(
-    async (dispatch: Dispatch<any>) => {
-        await dispatch(loadApiClientAuthorizationsPanel());
-    });
+  async (dispatch: Dispatch<any>) => {
+    await dispatch(loadApiClientAuthorizationsPanel());
+  }
+);
 
 export const loadGroupsPanel = handleFirstTimeLoad(
-    (dispatch: Dispatch<any>) => {
-        dispatch(setGroupsBreadcrumbs());
-        dispatch(groupPanelActions.loadGroupsPanel());
-    });
-
+  (dispatch: Dispatch<any>) => {
+    dispatch(setGroupsBreadcrumbs());
+    dispatch(groupPanelActions.loadGroupsPanel());
+  }
+);
 
 export const loadGroupDetailsPanel = (groupUuid: string) =>
-    handleFirstTimeLoad(
-        (dispatch: Dispatch<any>) => {
-            dispatch(setGroupDetailsBreadcrumbs(groupUuid));
-            dispatch(groupDetailsPanelActions.loadGroupDetailsPanel(groupUuid));
-        });
-
-const finishLoadingProject = (project: GroupContentsResource | string) =>
-    async (dispatch: Dispatch<any>) => {
-        const uuid = typeof project === 'string' ? project : project.uuid;
-        dispatch(openProjectPanel(uuid));
-        dispatch(loadDetailsPanel(uuid));
-        if (typeof project !== 'string') {
-            dispatch(updateResources([project]));
-        }
-    };
+  handleFirstTimeLoad((dispatch: Dispatch<any>) => {
+    dispatch(setGroupDetailsBreadcrumbs(groupUuid));
+    dispatch(groupDetailsPanelActions.loadGroupDetailsPanel(groupUuid));
+  });
+
+const finishLoadingProject =
+  (project: GroupContentsResource | string) =>
+  async (dispatch: Dispatch<any>) => {
+    const uuid = typeof project === 'string' ? project : project.uuid;
+    dispatch(openProjectPanel(uuid));
+    dispatch(loadDetailsPanel(uuid));
+    if (typeof project !== 'string') {
+      dispatch(updateResources([project]));
+    }
+  };
 
 const loadGroupContentsResource = async (params: {
-    uuid: string,
-    userUuid: string,
-    services: ServiceRepository
+  uuid: string;
+  userUuid: string;
+  services: ServiceRepository;
 }) => {
-    const filters = new FilterBuilder()
-        .addEqual('uuid', params.uuid)
-        .getFilters();
-    const { items } = await params.services.groupsService.contents(params.userUuid, {
-        filters,
-        recursive: true,
-        includeTrash: true,
-    });
-    const resource = items.shift();
-    let handler: GroupContentsHandler;
-    if (resource) {
-        handler = (resource.kind === ResourceKind.COLLECTION || resource.kind === ResourceKind.PROJECT) && resource.isTrashed
-            ? groupContentsHandlers.TRASHED(resource)
-            : groupContentsHandlers.OWNED(resource);
+  const filters = new FilterBuilder()
+    .addEqual('uuid', params.uuid)
+    .getFilters();
+  const { items } = await params.services.groupsService.contents(
+    params.userUuid,
+    {
+      filters,
+      recursive: true,
+      includeTrash: true,
+    }
+  );
+  const resource = items.shift();
+  let handler: GroupContentsHandler;
+  if (resource) {
+    handler =
+      (resource.kind === ResourceKind.COLLECTION ||
+        resource.kind === ResourceKind.PROJECT) &&
+      resource.isTrashed
+        ? groupContentsHandlers.TRASHED(resource)
+        : groupContentsHandlers.OWNED(resource);
+  } else {
+    const kind = extractUuidKind(params.uuid);
+    let resource: GroupContentsResource;
+    if (kind === ResourceKind.COLLECTION) {
+      resource = await params.services.collectionService.get(params.uuid);
+    } else if (kind === ResourceKind.PROJECT) {
+      resource = await params.services.projectService.get(params.uuid);
     } else {
-        const kind = extractUuidKind(params.uuid);
-        let resource: GroupContentsResource;
-        if (kind === ResourceKind.COLLECTION) {
-            resource = await params.services.collectionService.get(params.uuid);
-        } else if (kind === ResourceKind.PROJECT) {
-            resource = await params.services.projectService.get(params.uuid);
-        } else {
-            resource = await params.services.containerRequestService.get(params.uuid);
-        }
-        handler = groupContentsHandlers.SHARED(resource);
+      resource = await params.services.containerRequestService.get(params.uuid);
     }
-    return (cases: MatchCases<typeof groupContentsHandlersRecord, GroupContentsHandler, void>) =>
-        groupContentsHandlers.match(handler, cases);
-
+    handler = groupContentsHandlers.SHARED(resource);
+  }
+  return (
+    cases: MatchCases<
+      typeof groupContentsHandlersRecord,
+      GroupContentsHandler,
+      void
+    >
+  ) => groupContentsHandlers.match(handler, cases);
 };
 
 const groupContentsHandlersRecord = {
-    TRASHED: ofType<GroupContentsResource>(),
-    SHARED: ofType<GroupContentsResource>(),
-    OWNED: ofType<GroupContentsResource>(),
+  TRASHED: ofType<GroupContentsResource>(),
+  SHARED: ofType<GroupContentsResource>(),
+  OWNED: ofType<GroupContentsResource>(),
 };
 
 const groupContentsHandlers = unionize(groupContentsHandlersRecord);

diff --git a/src/views-components/data-explorer/data-explorer.tsx b/src/views-components/data-explorer/data-explorer.tsx
index 4d5523391fb7aebdd47d5abb6231f814c221e84e..79f530a062979ec64ee02c609afa5202a974cbaf 100644 (file)
--- a/src/views-components/data-explorer/data-explorer.tsx
+++ b/src/views-components/data-explorer/data-explorer.tsx
@@ -23,6 +23,7 @@ interface Props {
 
 const mapStateToProps = (state: RootState, { id }: Props) => {
     // console.log('DATA_EXPLORER, MSTP GLOBAL STATE:', state)
+    const test = 'foo'
     const progress = state.progressIndicator.find(p => p.id === id);
     const dataExplorerState = getDataExplorer(state.dataExplorer, id);
     const currentRoute = state.router.location ? state.router.location.pathname : '';
@@ -30,6 +31,7 @@ const mapStateToProps = (state: RootState, { id }: Props) => {
     const currentItemUuid = currentRoute === '/workflows' ? state.properties.workflowPanelDetailsUuid : state.detailsPanel.resourceUuid;
 // console.log('DATA_EXPLORER, MSTP FILTERED:', {...dataExplorerState})
     return {
+        foo: test,
         ...dataExplorerState,
         working: !!progress?.working,
         currentRefresh: currentRefresh,

diff --git a/src/views/project-panel/project-panel.tsx b/src/views/project-panel/project-panel.tsx
index d9d14ae31c14252330be10990f8fb1eb7ad04e08..032b73e15c2eedcb533686afe7645aedf6e56607 100644 (file)
--- a/src/views/project-panel/project-panel.tsx
+++ b/src/views/project-panel/project-panel.tsx
@@ -64,7 +64,8 @@ export enum ProjectPanelColumnNames {
     TYPE = "Type",
     OWNER = "Owner",
     FILE_SIZE = "File size",
-    LAST_MODIFIED = "Last modified"
+    LAST_MODIFIED = "Last modified",
+    UUID = "UUID"
 }
 
 export interface ProjectPanelFilter extends DataTableFilterItem {
@@ -116,6 +117,14 @@ export const projectPanelColumns: DataColumns<string> = [
         sortDirection: SortDirection.DESC,
         filters: createTree(),
         render: uuid => <ResourceLastModifiedDate uuid={uuid} />
+    },
+    {
+        name: ProjectPanelColumnNames.UUID,
+        selected: true,
+        configurable: true,
+        sortDirection: SortDirection.DESC,
+        filters: createTree(),
+        render: uuid =><>{uuid}</>
     }
 ];