src/store/workbench/workbench-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { Dispatch } from 'redux';
   6 import { RootState } from "../store";
   7 import { loadDetailsPanel } from '~/store/details-panel/details-panel-action';
   8 import { snackbarActions } from '../snackbar/snackbar-actions';
   9 import { loadFavoritePanel } from '../favorite-panel/favorite-panel-action';
  10 import { openProjectPanel, projectPanelActions } from '~/store/project-panel/project-panel-action';
  11 import { activateSidePanelTreeItem, initSidePanelTree, SidePanelTreeCategory, loadSidePanelTreeProjects } from '../side-panel-tree/side-panel-tree-actions';
  12 import { loadResource, updateResources } from '../resources/resources-actions';
  13 import { favoritePanelActions } from '~/store/favorite-panel/favorite-panel-action';
  14 import { projectPanelColumns } from '~/views/project-panel/project-panel';
  15 import { favoritePanelColumns } from '~/views/favorite-panel/favorite-panel';
  16 import { matchRootRoute } from '~/routes/routes';
  17 import { setSidePanelBreadcrumbs, setProcessBreadcrumbs, setSharedWithMeBreadcrumbs, setTrashBreadcrumbs } from '../breadcrumbs/breadcrumbs-actions';
  18 import { navigateToProject } from '../navigation/navigation-action';
  19 import { MoveToFormDialogData } from '~/store/move-to-dialog/move-to-dialog';
  20 import { ServiceRepository } from '~/services/services';
  21 import { getResource } from '../resources/resources';
  22 import { getProjectPanelCurrentUuid } from '../project-panel/project-panel-action';
  23 import * as projectCreateActions from '~/store/projects/project-create-actions';
  24 import * as projectMoveActions from '~/store/projects/project-move-actions';
  25 import * as projectUpdateActions from '~/store/projects/project-update-actions';
  26 import * as collectionCreateActions from '~/store/collections/collection-create-actions';
  27 import * as collectionCopyActions from '~/store/collections/collection-copy-actions';
  28 import * as collectionUpdateActions from '~/store/collections/collection-update-actions';
  29 import * as collectionMoveActions from '~/store/collections/collection-move-actions';
  30 import * as processesActions from '../processes/processes-actions';
  31 import * as processMoveActions from '~/store/processes/process-move-actions';
  32 import * as processUpdateActions from '~/store/processes/process-update-actions';
  33 import * as processCopyActions from '~/store/processes/process-copy-actions';
  34 import { trashPanelColumns } from "~/views/trash-panel/trash-panel";
  35 import { loadTrashPanel, trashPanelActions } from "~/store/trash-panel/trash-panel-action";
  36 import { initProcessLogsPanel } from '../process-logs-panel/process-logs-panel-actions';
  37 import { loadProcessPanel } from '~/store/process-panel/process-panel-actions';
  38 import { sharedWithMePanelActions } from '~/store/shared-with-me-panel/shared-with-me-panel-actions';
  39 import { loadSharedWithMePanel } from '../shared-with-me-panel/shared-with-me-panel-actions';
  40 import { CopyFormDialogData } from '~/store/copy-dialog/copy-dialog';
  41 import { loadWorkflowPanel, workflowPanelActions } from '~/store/workflow-panel/workflow-panel-actions';
  42 import { workflowPanelColumns } from '~/views/workflow-panel/workflow-panel-view';
  43 import { progressIndicatorActions } from '~/store/progress-indicator/progress-indicator-actions';
  44 import { getProgressIndicator } from '../progress-indicator/progress-indicator-reducer';
  45 import { ResourceKind, extractUuidKind } from '~/models/resource';
  46 import { FilterBuilder } from '~/services/api/filter-builder';
  47 import { GroupContentsResource } from '~/services/groups-service/groups-service';
  48 import { unionize, ofType, UnionOf, MatchCases } from '~/common/unionize';
  49 import { loadRunProcessPanel } from '~/store/run-process-panel/run-process-panel-actions';
  50 import { loadCollectionFiles } from '~/store/collection-panel/collection-panel-files/collection-panel-files-actions';
  51 import { SnackbarKind } from '~/store/snackbar/snackbar-actions';
  52 import { collectionPanelActions } from "~/store/collection-panel/collection-panel-action";
  53 import { CollectionResource } from "~/models/collection";
  54 import { searchResultsPanelActions, loadSearchResultsPanel } from '~/store/search-results-panel/search-results-panel-actions';
  55 import { searchResultsPanelColumns } from '~/views/search-results-panel/search-results-panel-view';
  56
  57 export const WORKBENCH_LOADING_SCREEN = 'workbenchLoadingScreen';
  58
  59 export const isWorkbenchLoading = (state: RootState) => {
  60     const progress = getProgressIndicator(WORKBENCH_LOADING_SCREEN)(state.progressIndicator);
  61     return progress ? progress.working : false;
  62 };
  63
  64 const handleFirstTimeLoad = (action: any) =>
  65     async (dispatch: Dispatch<any>, getState: () => RootState) => {
  66         try {
  67             await dispatch(action);
  68         } finally {
  69             if (isWorkbenchLoading(getState())) {
  70                 dispatch(progressIndicatorActions.STOP_WORKING(WORKBENCH_LOADING_SCREEN));
  71             }
  72         }
  73     };
  74
  75
  76 export const loadWorkbench = () =>
  77     async (dispatch: Dispatch, getState: () => RootState) => {
  78         dispatch(progressIndicatorActions.START_WORKING(WORKBENCH_LOADING_SCREEN));
  79         const { auth, router } = getState();
  80         const { user } = auth;
  81         if (user) {
  82             const userResource = await dispatch<any>(loadResource(user.uuid));
  83             if (userResource) {
  84                 dispatch(projectPanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
  85                 dispatch(favoritePanelActions.SET_COLUMNS({ columns: favoritePanelColumns }));
  86                 dispatch(trashPanelActions.SET_COLUMNS({ columns: trashPanelColumns }));
  87                 dispatch(sharedWithMePanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
  88                 dispatch(workflowPanelActions.SET_COLUMNS({ columns: workflowPanelColumns }));
  89                 dispatch(searchResultsPanelActions.SET_COLUMNS({ columns: searchResultsPanelColumns }));
  90                 dispatch<any>(initSidePanelTree());
  91                 if (router.location) {
  92                     const match = matchRootRoute(router.location.pathname);
  93                     if (match) {
  94                         dispatch(navigateToProject(userResource.uuid));
  95                     }
  96                 }
  97             } else {
  98                 dispatch(userIsNotAuthenticated);
  99             }
 100         } else {
 101             dispatch(userIsNotAuthenticated);
 102         }
 103     };
 104
 105 export const loadFavorites = () =>
 106     handleFirstTimeLoad(
 107         (dispatch: Dispatch) => {
 108             dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.FAVORITES));
 109             dispatch<any>(loadFavoritePanel());
 110             dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.FAVORITES));
 111         });
 112
 113 export const loadTrash = () =>
 114     handleFirstTimeLoad(
 115         (dispatch: Dispatch) => {
 116             dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
 117             dispatch<any>(loadTrashPanel());
 118             dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.TRASH));
 119         });
 120
 121 export const loadProject = (uuid: string) =>
 122     handleFirstTimeLoad(
 123         async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 124             const userUuid = services.authService.getUuid();
 125             if (userUuid) {
 126                 if (userUuid !== uuid) {
 127                     const match = await loadGroupContentsResource({ uuid, userUuid, services });
 128                     match({
 129                         OWNED: async project => {
 130                             await dispatch(activateSidePanelTreeItem(uuid));
 131                             dispatch<any>(setSidePanelBreadcrumbs(uuid));
 132                             dispatch(finishLoadingProject(project));
 133                         },
 134                         SHARED: project => {
 135                             dispatch<any>(setSharedWithMeBreadcrumbs(uuid));
 136                             dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME));
 137                             dispatch(finishLoadingProject(project));
 138                         },
 139                         TRASHED: project => {
 140                             dispatch<any>(setTrashBreadcrumbs(uuid));
 141                             dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
 142                             dispatch(finishLoadingProject(project));
 143                         }
 144                     });
 145                 } else {
 146                     await dispatch(activateSidePanelTreeItem(userUuid));
 147                     dispatch<any>(setSidePanelBreadcrumbs(userUuid));
 148                     dispatch(finishLoadingProject(userUuid));
 149                 }
 150             }
 151         });
 152
 153 export const createProject = (data: projectCreateActions.ProjectCreateFormDialogData) =>
 154     async (dispatch: Dispatch) => {
 155         const newProject = await dispatch<any>(projectCreateActions.createProject(data));
 156         if (newProject) {
 157             dispatch(snackbarActions.OPEN_SNACKBAR({
 158                 message: "Project has been successfully created.",
 159                 hideDuration: 2000
 160             }));
 161             await dispatch<any>(loadSidePanelTreeProjects(newProject.ownerUuid));
 162             dispatch<any>(reloadProjectMatchingUuid([newProject.ownerUuid]));
 163         }
 164     };
 165
 166 export const moveProject = (data: MoveToFormDialogData) =>
 167     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 168         try {
 169             const oldProject = getResource(data.uuid)(getState().resources);
 170             const oldOwnerUuid = oldProject ? oldProject.ownerUuid : '';
 171             const movedProject = await dispatch<any>(projectMoveActions.moveProject(data));
 172             if (movedProject) {
 173                 dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Project has been moved', hideDuration: 2000 }));
 174                 if (oldProject) {
 175                     await dispatch<any>(loadSidePanelTreeProjects(oldProject.ownerUuid));
 176                 }
 177                 dispatch<any>(reloadProjectMatchingUuid([oldOwnerUuid, movedProject.ownerUuid, movedProject.uuid]));
 178             }
 179         } catch (e) {
 180             dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000 }));
 181         }
 182     };
 183
 184 export const updateProject = (data: projectUpdateActions.ProjectUpdateFormDialogData) =>
 185     async (dispatch: Dispatch) => {
 186         const updatedProject = await dispatch<any>(projectUpdateActions.updateProject(data));
 187         if (updatedProject) {
 188             dispatch(snackbarActions.OPEN_SNACKBAR({
 189                 message: "Project has been successfully updated.",
 190                 hideDuration: 2000
 191             }));
 192             await dispatch<any>(loadSidePanelTreeProjects(updatedProject.ownerUuid));
 193             dispatch<any>(reloadProjectMatchingUuid([updatedProject.ownerUuid, updatedProject.uuid]));
 194         }
 195     };
 196
 197 export const loadCollection = (uuid: string) =>
 198     handleFirstTimeLoad(
 199         async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 200             const userUuid = services.authService.getUuid();
 201             if (userUuid) {
 202                 const match = await loadGroupContentsResource({ uuid, userUuid, services });
 203                 match({
 204                     OWNED: async collection => {
 205                         dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
 206                         dispatch(updateResources([collection]));
 207                         await dispatch(activateSidePanelTreeItem(collection.ownerUuid));
 208                         dispatch(setSidePanelBreadcrumbs(collection.ownerUuid));
 209                         dispatch(loadCollectionFiles(collection.uuid));
 210                     },
 211                     SHARED: collection => {
 212                         dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
 213                         dispatch(updateResources([collection]));
 214                         dispatch<any>(setSharedWithMeBreadcrumbs(collection.ownerUuid));
 215                         dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME));
 216                         dispatch(loadCollectionFiles(collection.uuid));
 217                     },
 218                     TRASHED: collection => {
 219                         dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
 220                         dispatch(updateResources([collection]));
 221                         dispatch(setTrashBreadcrumbs(''));
 222                         dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
 223                         dispatch(loadCollectionFiles(collection.uuid));
 224                     },
 225
 226                 });
 227             }
 228         });
 229
 230 export const createCollection = (data: collectionCreateActions.CollectionCreateFormDialogData) =>
 231     async (dispatch: Dispatch) => {
 232         const collection = await dispatch<any>(collectionCreateActions.createCollection(data));
 233         if (collection) {
 234             dispatch(snackbarActions.OPEN_SNACKBAR({
 235                 message: "Collection has been successfully created.",
 236                 hideDuration: 2000
 237             }));
 238             dispatch<any>(updateResources([collection]));
 239             dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
 240         }
 241     };
 242
 243 export const updateCollection = (data: collectionUpdateActions.CollectionUpdateFormDialogData) =>
 244     async (dispatch: Dispatch) => {
 245         const collection = await dispatch<any>(collectionUpdateActions.updateCollection(data));
 246         if (collection) {
 247             dispatch(snackbarActions.OPEN_SNACKBAR({
 248                 message: "Collection has been successfully updated.",
 249                 hideDuration: 2000
 250             }));
 251             dispatch<any>(updateResources([collection]));
 252             dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
 253         }
 254     };
 255
 256 export const copyCollection = (data: CopyFormDialogData) =>
 257     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 258         try {
 259             const collection = await dispatch<any>(collectionCopyActions.copyCollection(data));
 260             dispatch<any>(updateResources([collection]));
 261             dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
 262             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Collection has been copied.', hideDuration: 2000 }));
 263         } catch (e) {
 264             dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000 }));
 265         }
 266     };
 267
 268 export const moveCollection = (data: MoveToFormDialogData) =>
 269     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 270         try {
 271             const collection = await dispatch<any>(collectionMoveActions.moveCollection(data));
 272             dispatch<any>(updateResources([collection]));
 273             dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
 274             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Collection has been moved.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
 275         } catch (e) {
 276             dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000 }));
 277         }
 278     };
 279
 280 export const loadProcess = (uuid: string) =>
 281     handleFirstTimeLoad(
 282         async (dispatch: Dispatch, getState: () => RootState) => {
 283             dispatch<any>(loadProcessPanel(uuid));
 284             const process = await dispatch<any>(processesActions.loadProcess(uuid));
 285             await dispatch<any>(activateSidePanelTreeItem(process.containerRequest.ownerUuid));
 286             dispatch<any>(setProcessBreadcrumbs(uuid));
 287             dispatch(loadDetailsPanel(uuid));
 288         });
 289
 290 export const updateProcess = (data: processUpdateActions.ProcessUpdateFormDialogData) =>
 291     async (dispatch: Dispatch) => {
 292         try {
 293             const process = await dispatch<any>(processUpdateActions.updateProcess(data));
 294             if (process) {
 295                 dispatch(snackbarActions.OPEN_SNACKBAR({
 296                     message: "Process has been successfully updated.",
 297                     hideDuration: 2000
 298                 }));
 299                 dispatch<any>(updateResources([process]));
 300                 dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
 301             }
 302         } catch (e) {
 303             dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000 }));
 304         }
 305     };
 306
 307 export const moveProcess = (data: MoveToFormDialogData) =>
 308     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 309         try {
 310             const process = await dispatch<any>(processMoveActions.moveProcess(data));
 311             dispatch<any>(updateResources([process]));
 312             dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
 313             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Process has been moved.', hideDuration: 2000 }));
 314         } catch (e) {
 315             dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000 }));
 316         }
 317     };
 318
 319 export const copyProcess = (data: CopyFormDialogData) =>
 320     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 321         try {
 322             const process = await dispatch<any>(processCopyActions.copyProcess(data));
 323             dispatch<any>(updateResources([process]));
 324             dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
 325             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Process has been copied.', hideDuration: 2000 }));
 326         } catch (e) {
 327             dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000 }));
 328         }
 329     };
 330
 331 export const loadProcessLog = (uuid: string) =>
 332     handleFirstTimeLoad(
 333         async (dispatch: Dispatch) => {
 334             const process = await dispatch<any>(processesActions.loadProcess(uuid));
 335             dispatch<any>(setProcessBreadcrumbs(uuid));
 336             dispatch<any>(initProcessLogsPanel(uuid));
 337             await dispatch<any>(activateSidePanelTreeItem(process.containerRequest.ownerUuid));
 338         });
 339
 340 export const resourceIsNotLoaded = (uuid: string) =>
 341     snackbarActions.OPEN_SNACKBAR({
 342         message: `Resource identified by ${uuid} is not loaded.`
 343     });
 344
 345 export const userIsNotAuthenticated = snackbarActions.OPEN_SNACKBAR({
 346     message: 'User is not authenticated'
 347 });
 348
 349 export const couldNotLoadUser = snackbarActions.OPEN_SNACKBAR({
 350     message: 'Could not load user'
 351 });
 352
 353 export const reloadProjectMatchingUuid = (matchingUuids: string[]) =>
 354     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
 355         const currentProjectPanelUuid = getProjectPanelCurrentUuid(getState());
 356         if (currentProjectPanelUuid && matchingUuids.some(uuid => uuid === currentProjectPanelUuid)) {
 357             dispatch<any>(loadProject(currentProjectPanelUuid));
 358         }
 359     };
 360
 361 export const loadSharedWithMe = handleFirstTimeLoad(async (dispatch: Dispatch) => {
 362     dispatch<any>(loadSharedWithMePanel());
 363     await dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME));
 364     await dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.SHARED_WITH_ME));
 365 });
 366
 367 export const loadRunProcess = handleFirstTimeLoad(
 368     async (dispatch: Dispatch) => {
 369         await dispatch<any>(loadRunProcessPanel());
 370     }
 371 );
 372
 373 export const loadWorkflow = handleFirstTimeLoad(async (dispatch: Dispatch<any>) => {
 374     dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.WORKFLOWS));
 375     await dispatch(loadWorkflowPanel());
 376     dispatch(setSidePanelBreadcrumbs(SidePanelTreeCategory.WORKFLOWS));
 377 });
 378
 379 export const loadSearchResults = handleFirstTimeLoad(
 380     async (dispatch: Dispatch<any>) => {
 381         await dispatch(loadSearchResultsPanel());
 382     });
 383
 384 const finishLoadingProject = (project: GroupContentsResource | string) =>
 385     async (dispatch: Dispatch<any>) => {
 386         const uuid = typeof project === 'string' ? project : project.uuid;
 387         dispatch(openProjectPanel(uuid));
 388         dispatch(loadDetailsPanel(uuid));
 389         if (typeof project !== 'string') {
 390             dispatch(updateResources([project]));
 391         }
 392     };
 393
 394 const loadGroupContentsResource = async (params: {
 395     uuid: string,
 396     userUuid: string,
 397     services: ServiceRepository
 398 }) => {
 399     const filters = new FilterBuilder()
 400         .addEqual('uuid', params.uuid)
 401         .getFilters();
 402     const { items } = await params.services.groupsService.contents(params.userUuid, {
 403         filters,
 404         recursive: true,
 405         includeTrash: true,
 406     });
 407     const resource = items.shift();
 408     let handler: GroupContentsHandler;
 409     if (resource) {
 410         handler = (resource.kind === ResourceKind.COLLECTION || resource.kind === ResourceKind.PROJECT) && resource.isTrashed
 411             ? groupContentsHandlers.TRASHED(resource)
 412             : groupContentsHandlers.OWNED(resource);
 413     } else {
 414         const kind = extractUuidKind(params.uuid);
 415         let resource: GroupContentsResource;
 416         if (kind === ResourceKind.COLLECTION) {
 417             resource = await params.services.collectionService.get(params.uuid);
 418         } else if (kind === ResourceKind.PROJECT) {
 419             resource = await params.services.projectService.get(params.uuid);
 420         } else {
 421             resource = await params.services.containerRequestService.get(params.uuid);
 422         }
 423         handler = groupContentsHandlers.SHARED(resource);
 424     }
 425     return (cases: MatchCases<typeof groupContentsHandlersRecord, GroupContentsHandler, void>) =>
 426         groupContentsHandlers.match(handler, cases);
 427
 428 };
 429
 430 const groupContentsHandlersRecord = {
 431     TRASHED: ofType<GroupContentsResource>(),
 432     SHARED: ofType<GroupContentsResource>(),
 433     OWNED: ofType<GroupContentsResource>(),
 434 };
 435
 436 const groupContentsHandlers = unionize(groupContentsHandlersRecord);
 437
 438 type GroupContentsHandler = UnionOf<typeof groupContentsHandlers>;