1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
5 import { Dispatch } from 'redux';
6 import { RootState } from "~/store/store";
7 import { getUserUuid } from "~/common/getuser";
8 import { loadDetailsPanel } from '~/store/details-panel/details-panel-action';
9 import { snackbarActions, SnackbarKind } from '~/store/snackbar/snackbar-actions';
10 import { favoritePanelActions, loadFavoritePanel } from '~/store/favorite-panel/favorite-panel-action';
12 getProjectPanelCurrentUuid,
15 setIsProjectPanelTrashed
16 } from '~/store/project-panel/project-panel-action';
18 activateSidePanelTreeItem,
20 loadSidePanelTreeProjects,
22 } from '~/store/side-panel-tree/side-panel-tree-actions';
23 import { updateResources } from '~/store/resources/resources-actions';
24 import { projectPanelColumns } from '~/views/project-panel/project-panel';
25 import { favoritePanelColumns } from '~/views/favorite-panel/favorite-panel';
26 import { matchRootRoute } from '~/routes/routes';
29 setGroupDetailsBreadcrumbs,
31 setProcessBreadcrumbs,
32 setSharedWithMeBreadcrumbs,
33 setSidePanelBreadcrumbs,
35 } from '~/store/breadcrumbs/breadcrumbs-actions';
36 import { navigateTo } from '~/store/navigation/navigation-action';
37 import { MoveToFormDialogData } from '~/store/move-to-dialog/move-to-dialog';
38 import { ServiceRepository } from '~/services/services';
39 import { getResource } from '~/store/resources/resources';
40 import * as projectCreateActions from '~/store/projects/project-create-actions';
41 import * as projectMoveActions from '~/store/projects/project-move-actions';
42 import * as projectUpdateActions from '~/store/projects/project-update-actions';
43 import * as collectionCreateActions from '~/store/collections/collection-create-actions';
44 import * as collectionCopyActions from '~/store/collections/collection-copy-actions';
45 import * as collectionUpdateActions from '~/store/collections/collection-update-actions';
46 import * as collectionMoveActions from '~/store/collections/collection-move-actions';
47 import * as processesActions from '~/store/processes/processes-actions';
48 import * as processMoveActions from '~/store/processes/process-move-actions';
49 import * as processUpdateActions from '~/store/processes/process-update-actions';
50 import * as processCopyActions from '~/store/processes/process-copy-actions';
51 import { trashPanelColumns } from "~/views/trash-panel/trash-panel";
52 import { loadTrashPanel, trashPanelActions } from "~/store/trash-panel/trash-panel-action";
53 import { initProcessLogsPanel } from '~/store/process-logs-panel/process-logs-panel-actions';
54 import { loadProcessPanel } from '~/store/process-panel/process-panel-actions';
56 loadSharedWithMePanel,
57 sharedWithMePanelActions
58 } from '~/store/shared-with-me-panel/shared-with-me-panel-actions';
59 import { CopyFormDialogData } from '~/store/copy-dialog/copy-dialog';
60 import { loadWorkflowPanel, workflowPanelActions } from '~/store/workflow-panel/workflow-panel-actions';
61 import { loadSshKeysPanel } from '~/store/auth/auth-action-ssh';
62 import { loadMyAccountPanel } from '~/store/my-account/my-account-panel-actions';
63 import { loadLinkAccountPanel, linkAccountPanelActions } from '~/store/link-account-panel/link-account-panel-actions';
64 import { loadSiteManagerPanel } from '~/store/auth/auth-action-session';
65 import { workflowPanelColumns } from '~/views/workflow-panel/workflow-panel-view';
66 import { progressIndicatorActions } from '~/store/progress-indicator/progress-indicator-actions';
67 import { getProgressIndicator } from '~/store/progress-indicator/progress-indicator-reducer';
68 import { extractUuidKind, ResourceKind } from '~/models/resource';
69 import { FilterBuilder } from '~/services/api/filter-builder';
70 import { GroupContentsResource } from '~/services/groups-service/groups-service';
71 import { MatchCases, ofType, unionize, UnionOf } from '~/common/unionize';
72 import { loadRunProcessPanel } from '~/store/run-process-panel/run-process-panel-actions';
73 import { collectionPanelActions, loadCollectionPanel } from "~/store/collection-panel/collection-panel-action";
74 import { CollectionResource } from "~/models/collection";
76 loadSearchResultsPanel,
77 searchResultsPanelActions
78 } from '~/store/search-results-panel/search-results-panel-actions';
79 import { searchResultsPanelColumns } from '~/views/search-results-panel/search-results-panel-view';
80 import { loadVirtualMachinesPanel } from '~/store/virtual-machines/virtual-machines-actions';
81 import { loadRepositoriesPanel } from '~/store/repositories/repositories-actions';
82 import { loadKeepServicesPanel } from '~/store/keep-services/keep-services-actions';
83 import { loadUsersPanel, userBindedActions } from '~/store/users/users-actions';
84 import { linkPanelActions, loadLinkPanel } from '~/store/link-panel/link-panel-actions';
85 import { computeNodesActions, loadComputeNodesPanel } from '~/store/compute-nodes/compute-nodes-actions';
86 import { linkPanelColumns } from '~/views/link-panel/link-panel-root';
87 import { userPanelColumns } from '~/views/user-panel/user-panel';
88 import { computeNodePanelColumns } from '~/views/compute-node-panel/compute-node-panel-root';
89 import { loadApiClientAuthorizationsPanel, apiClientAuthorizationsActions } from '~/store/api-client-authorizations/api-client-authorizations-actions';
90 import { apiClientAuthorizationPanelColumns } from '~/views/api-client-authorization-panel/api-client-authorization-panel-root';
91 import * as groupPanelActions from '~/store/groups-panel/groups-panel-actions';
92 import { groupsPanelColumns } from '~/views/groups-panel/groups-panel';
93 import * as groupDetailsPanelActions from '~/store/group-details-panel/group-details-panel-actions';
94 import { groupDetailsPanelColumns } from '~/views/group-details-panel/group-details-panel';
95 import { DataTableFetchMode } from "~/components/data-table/data-table";
96 import { loadPublicFavoritePanel, publicFavoritePanelActions } from '~/store/public-favorites-panel/public-favorites-action';
97 import { publicFavoritePanelColumns } from '~/views/public-favorites-panel/public-favorites-panel';
98 import { loadCollectionsContentAddressPanel, collectionsContentAddressActions } from '~/store/collections-content-address-panel/collections-content-address-panel-actions';
99 import { collectionContentAddressPanelColumns } from '~/views/collection-content-address-panel/collection-content-address-panel';
101 export const WORKBENCH_LOADING_SCREEN = 'workbenchLoadingScreen';
103 export const isWorkbenchLoading = (state: RootState) => {
104 const progress = getProgressIndicator(WORKBENCH_LOADING_SCREEN)(state.progressIndicator);
105 return progress ? progress.working : false;
108 const handleFirstTimeLoad = (action: any) =>
109 async (dispatch: Dispatch<any>, getState: () => RootState) => {
111 await dispatch(action);
113 if (isWorkbenchLoading(getState())) {
114 dispatch(progressIndicatorActions.STOP_WORKING(WORKBENCH_LOADING_SCREEN));
119 export const loadWorkbench = () =>
120 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
121 dispatch(progressIndicatorActions.START_WORKING(WORKBENCH_LOADING_SCREEN));
122 const { auth, router } = getState();
123 const { user } = auth;
125 dispatch(projectPanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
126 dispatch(favoritePanelActions.SET_COLUMNS({ columns: favoritePanelColumns }));
127 dispatch(publicFavoritePanelActions.SET_COLUMNS({ columns: publicFavoritePanelColumns }));
128 dispatch(trashPanelActions.SET_COLUMNS({ columns: trashPanelColumns }));
129 dispatch(sharedWithMePanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
130 dispatch(workflowPanelActions.SET_COLUMNS({ columns: workflowPanelColumns }));
131 dispatch(searchResultsPanelActions.SET_FETCH_MODE({ fetchMode: DataTableFetchMode.INFINITE }));
132 dispatch(searchResultsPanelActions.SET_COLUMNS({ columns: searchResultsPanelColumns }));
133 dispatch(userBindedActions.SET_COLUMNS({ columns: userPanelColumns }));
134 dispatch(groupPanelActions.GroupsPanelActions.SET_COLUMNS({ columns: groupsPanelColumns }));
135 dispatch(groupDetailsPanelActions.GroupDetailsPanelActions.SET_COLUMNS({ columns: groupDetailsPanelColumns }));
136 dispatch(linkPanelActions.SET_COLUMNS({ columns: linkPanelColumns }));
137 dispatch(computeNodesActions.SET_COLUMNS({ columns: computeNodePanelColumns }));
138 dispatch(apiClientAuthorizationsActions.SET_COLUMNS({ columns: apiClientAuthorizationPanelColumns }));
139 dispatch(collectionsContentAddressActions.SET_COLUMNS({ columns: collectionContentAddressPanelColumns }));
141 if (services.linkAccountService.getAccountToLink()) {
142 dispatch(linkAccountPanelActions.HAS_SESSION_DATA());
145 dispatch<any>(initSidePanelTree());
146 if (router.location) {
147 const match = matchRootRoute(router.location.pathname);
149 dispatch<any>(navigateTo(user.uuid));
153 dispatch(userIsNotAuthenticated);
157 export const loadFavorites = () =>
159 (dispatch: Dispatch) => {
160 dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.FAVORITES));
161 dispatch<any>(loadFavoritePanel());
162 dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.FAVORITES));
165 export const loadCollectionContentAddress = handleFirstTimeLoad(
166 async (dispatch: Dispatch<any>) => {
167 await dispatch(loadCollectionsContentAddressPanel());
170 export const loadTrash = () =>
172 (dispatch: Dispatch) => {
173 dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
174 dispatch<any>(loadTrashPanel());
175 dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.TRASH));
178 export const loadProject = (uuid: string) =>
180 async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
181 const userUuid = getUserUuid(getState());
182 dispatch(setIsProjectPanelTrashed(false));
184 if (extractUuidKind(uuid) === ResourceKind.USER && userUuid !== uuid) {
185 // Load another users home projects
186 dispatch(finishLoadingProject(uuid));
187 } else if (userUuid !== uuid) {
188 const match = await loadGroupContentsResource({ uuid, userUuid, services });
190 OWNED: async project => {
191 await dispatch(activateSidePanelTreeItem(uuid));
192 dispatch<any>(setSidePanelBreadcrumbs(uuid));
193 dispatch(finishLoadingProject(project));
196 dispatch<any>(setSharedWithMeBreadcrumbs(uuid));
197 dispatch(activateSidePanelTreeItem(uuid));
198 dispatch(finishLoadingProject(project));
200 TRASHED: project => {
201 dispatch<any>(setTrashBreadcrumbs(uuid));
202 dispatch(setIsProjectPanelTrashed(true));
203 dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
204 dispatch(finishLoadingProject(project));
208 await dispatch(activateSidePanelTreeItem(userUuid));
209 dispatch<any>(setSidePanelBreadcrumbs(userUuid));
210 dispatch(finishLoadingProject(userUuid));
215 export const createProject = (data: projectCreateActions.ProjectCreateFormDialogData) =>
216 async (dispatch: Dispatch) => {
217 const newProject = await dispatch<any>(projectCreateActions.createProject(data));
219 dispatch(snackbarActions.OPEN_SNACKBAR({
220 message: "Project has been successfully created.",
222 kind: SnackbarKind.SUCCESS
224 await dispatch<any>(loadSidePanelTreeProjects(newProject.ownerUuid));
225 dispatch<any>(reloadProjectMatchingUuid([newProject.ownerUuid]));
229 export const moveProject = (data: MoveToFormDialogData) =>
230 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
232 const oldProject = getResource(data.uuid)(getState().resources);
233 const oldOwnerUuid = oldProject ? oldProject.ownerUuid : '';
234 const movedProject = await dispatch<any>(projectMoveActions.moveProject(data));
236 dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Project has been moved', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
238 await dispatch<any>(loadSidePanelTreeProjects(oldProject.ownerUuid));
240 dispatch<any>(reloadProjectMatchingUuid([oldOwnerUuid, movedProject.ownerUuid, movedProject.uuid]));
243 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
247 export const updateProject = (data: projectUpdateActions.ProjectUpdateFormDialogData) =>
248 async (dispatch: Dispatch) => {
249 const updatedProject = await dispatch<any>(projectUpdateActions.updateProject(data));
250 if (updatedProject) {
251 dispatch(snackbarActions.OPEN_SNACKBAR({
252 message: "Project has been successfully updated.",
254 kind: SnackbarKind.SUCCESS
256 await dispatch<any>(loadSidePanelTreeProjects(updatedProject.ownerUuid));
257 dispatch<any>(reloadProjectMatchingUuid([updatedProject.ownerUuid, updatedProject.uuid]));
261 export const loadCollection = (uuid: string) =>
263 async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
264 const userUuid = getUserUuid(getState());
266 const match = await loadGroupContentsResource({ uuid, userUuid, services });
268 OWNED: async collection => {
269 dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
270 dispatch(updateResources([collection]));
271 await dispatch(activateSidePanelTreeItem(collection.ownerUuid));
272 dispatch(setSidePanelBreadcrumbs(collection.ownerUuid));
273 dispatch(loadCollectionPanel(collection.uuid));
275 SHARED: collection => {
276 dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
277 dispatch(updateResources([collection]));
278 dispatch<any>(setSharedWithMeBreadcrumbs(collection.ownerUuid));
279 dispatch(activateSidePanelTreeItem(collection.ownerUuid));
280 dispatch(loadCollectionPanel(collection.uuid));
282 TRASHED: collection => {
283 dispatch(collectionPanelActions.SET_COLLECTION(collection as CollectionResource));
284 dispatch(updateResources([collection]));
285 dispatch(setTrashBreadcrumbs(''));
286 dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.TRASH));
287 dispatch(loadCollectionPanel(collection.uuid));
294 export const createCollection = (data: collectionCreateActions.CollectionCreateFormDialogData) =>
295 async (dispatch: Dispatch) => {
296 const collection = await dispatch<any>(collectionCreateActions.createCollection(data));
298 dispatch(snackbarActions.OPEN_SNACKBAR({
299 message: "Collection has been successfully created.",
301 kind: SnackbarKind.SUCCESS
303 dispatch<any>(updateResources([collection]));
304 dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
308 export const updateCollection = (data: collectionUpdateActions.CollectionUpdateFormDialogData) =>
309 async (dispatch: Dispatch) => {
311 const collection = await dispatch<any>(collectionUpdateActions.updateCollection(data));
313 dispatch(snackbarActions.OPEN_SNACKBAR({
314 message: "Collection has been successfully updated.",
316 kind: SnackbarKind.SUCCESS
318 dispatch<any>(updateResources([collection]));
319 dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
322 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.errors.join(''), hideDuration: 2000, kind: SnackbarKind.ERROR }));
326 export const copyCollection = (data: CopyFormDialogData) =>
327 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
329 const copyToProject = getResource(data.ownerUuid)(getState().resources);
330 const collection = await dispatch<any>(collectionCopyActions.copyCollection(data));
331 if (copyToProject && collection) {
332 dispatch<any>(reloadProjectMatchingUuid([copyToProject.uuid]));
333 dispatch(snackbarActions.OPEN_SNACKBAR({
334 message: 'Collection has been copied.',
336 kind: SnackbarKind.SUCCESS,
337 link: collection.ownerUuid
341 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
345 export const moveCollection = (data: MoveToFormDialogData) =>
346 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
348 const collection = await dispatch<any>(collectionMoveActions.moveCollection(data));
349 dispatch<any>(updateResources([collection]));
350 dispatch<any>(reloadProjectMatchingUuid([collection.ownerUuid]));
351 dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Collection has been moved.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
353 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
357 export const loadProcess = (uuid: string) =>
359 async (dispatch: Dispatch, getState: () => RootState) => {
360 dispatch<any>(loadProcessPanel(uuid));
361 const process = await dispatch<any>(processesActions.loadProcess(uuid));
362 await dispatch<any>(activateSidePanelTreeItem(process.containerRequest.ownerUuid));
363 dispatch<any>(setProcessBreadcrumbs(uuid));
364 dispatch(loadDetailsPanel(uuid));
367 export const updateProcess = (data: processUpdateActions.ProcessUpdateFormDialogData) =>
368 async (dispatch: Dispatch) => {
370 const process = await dispatch<any>(processUpdateActions.updateProcess(data));
372 dispatch(snackbarActions.OPEN_SNACKBAR({
373 message: "Process has been successfully updated.",
375 kind: SnackbarKind.SUCCESS
377 dispatch<any>(updateResources([process]));
378 dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
381 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
385 export const moveProcess = (data: MoveToFormDialogData) =>
386 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
388 const process = await dispatch<any>(processMoveActions.moveProcess(data));
389 dispatch<any>(updateResources([process]));
390 dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
391 dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Process has been moved.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
393 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
397 export const copyProcess = (data: CopyFormDialogData) =>
398 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
400 const process = await dispatch<any>(processCopyActions.copyProcess(data));
401 dispatch<any>(updateResources([process]));
402 dispatch<any>(reloadProjectMatchingUuid([process.ownerUuid]));
403 dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Process has been copied.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
405 dispatch(snackbarActions.OPEN_SNACKBAR({ message: e.message, hideDuration: 2000, kind: SnackbarKind.ERROR }));
409 export const loadProcessLog = (uuid: string) =>
411 async (dispatch: Dispatch) => {
412 const process = await dispatch<any>(processesActions.loadProcess(uuid));
413 dispatch<any>(setProcessBreadcrumbs(uuid));
414 dispatch<any>(initProcessLogsPanel(uuid));
415 await dispatch<any>(activateSidePanelTreeItem(process.containerRequest.ownerUuid));
418 export const resourceIsNotLoaded = (uuid: string) =>
419 snackbarActions.OPEN_SNACKBAR({
420 message: `Resource identified by ${uuid} is not loaded.`,
421 kind: SnackbarKind.ERROR
424 export const userIsNotAuthenticated = snackbarActions.OPEN_SNACKBAR({
425 message: 'User is not authenticated',
426 kind: SnackbarKind.ERROR
429 export const couldNotLoadUser = snackbarActions.OPEN_SNACKBAR({
430 message: 'Could not load user',
431 kind: SnackbarKind.ERROR
434 export const reloadProjectMatchingUuid = (matchingUuids: string[]) =>
435 async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
436 const currentProjectPanelUuid = getProjectPanelCurrentUuid(getState());
437 if (currentProjectPanelUuid && matchingUuids.some(uuid => uuid === currentProjectPanelUuid)) {
438 dispatch<any>(loadProject(currentProjectPanelUuid));
442 export const loadSharedWithMe = handleFirstTimeLoad(async (dispatch: Dispatch) => {
443 dispatch<any>(loadSharedWithMePanel());
444 await dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.SHARED_WITH_ME));
445 await dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.SHARED_WITH_ME));
448 export const loadRunProcess = handleFirstTimeLoad(
449 async (dispatch: Dispatch) => {
450 await dispatch<any>(loadRunProcessPanel());
454 export const loadWorkflow = handleFirstTimeLoad(async (dispatch: Dispatch<any>) => {
455 dispatch(activateSidePanelTreeItem(SidePanelTreeCategory.WORKFLOWS));
456 await dispatch(loadWorkflowPanel());
457 dispatch(setSidePanelBreadcrumbs(SidePanelTreeCategory.WORKFLOWS));
460 export const loadPublicFavorites = () =>
462 (dispatch: Dispatch) => {
463 dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.PUBLIC_FAVORITES));
464 dispatch<any>(loadPublicFavoritePanel());
465 dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.PUBLIC_FAVORITES));
468 export const loadSearchResults = handleFirstTimeLoad(
469 async (dispatch: Dispatch<any>) => {
470 await dispatch(loadSearchResultsPanel());
473 export const loadLinks = handleFirstTimeLoad(
474 async (dispatch: Dispatch<any>) => {
475 await dispatch(loadLinkPanel());
478 export const loadVirtualMachines = handleFirstTimeLoad(
479 async (dispatch: Dispatch<any>) => {
480 await dispatch(loadVirtualMachinesPanel());
481 dispatch(setBreadcrumbs([{ label: 'Virtual Machines' }]));
484 export const loadRepositories = handleFirstTimeLoad(
485 async (dispatch: Dispatch<any>) => {
486 await dispatch(loadRepositoriesPanel());
487 dispatch(setBreadcrumbs([{ label: 'Repositories' }]));
490 export const loadSshKeys = handleFirstTimeLoad(
491 async (dispatch: Dispatch<any>) => {
492 await dispatch(loadSshKeysPanel());
495 export const loadSiteManager = handleFirstTimeLoad(
496 async (dispatch: Dispatch<any>) => {
497 await dispatch(loadSiteManagerPanel());
500 export const loadMyAccount = handleFirstTimeLoad(
501 (dispatch: Dispatch<any>) => {
502 dispatch(loadMyAccountPanel());
505 export const loadLinkAccount = handleFirstTimeLoad(
506 (dispatch: Dispatch<any>) => {
507 dispatch(loadLinkAccountPanel());
510 export const loadKeepServices = handleFirstTimeLoad(
511 async (dispatch: Dispatch<any>) => {
512 await dispatch(loadKeepServicesPanel());
515 export const loadUsers = handleFirstTimeLoad(
516 async (dispatch: Dispatch<any>) => {
517 await dispatch(loadUsersPanel());
518 dispatch(setBreadcrumbs([{ label: 'Users' }]));
521 export const loadComputeNodes = handleFirstTimeLoad(
522 async (dispatch: Dispatch<any>) => {
523 await dispatch(loadComputeNodesPanel());
526 export const loadApiClientAuthorizations = handleFirstTimeLoad(
527 async (dispatch: Dispatch<any>) => {
528 await dispatch(loadApiClientAuthorizationsPanel());
531 export const loadGroupsPanel = handleFirstTimeLoad(
532 (dispatch: Dispatch<any>) => {
533 dispatch(setGroupsBreadcrumbs());
534 dispatch(groupPanelActions.loadGroupsPanel());
538 export const loadGroupDetailsPanel = (groupUuid: string) =>
540 (dispatch: Dispatch<any>) => {
541 dispatch(setGroupDetailsBreadcrumbs(groupUuid));
542 dispatch(groupDetailsPanelActions.loadGroupDetailsPanel(groupUuid));
545 const finishLoadingProject = (project: GroupContentsResource | string) =>
546 async (dispatch: Dispatch<any>) => {
547 const uuid = typeof project === 'string' ? project : project.uuid;
548 dispatch(openProjectPanel(uuid));
549 dispatch(loadDetailsPanel(uuid));
550 if (typeof project !== 'string') {
551 dispatch(updateResources([project]));
555 const loadGroupContentsResource = async (params: {
558 services: ServiceRepository
560 const filters = new FilterBuilder()
561 .addEqual('uuid', params.uuid)
563 const { items } = await params.services.groupsService.contents(params.userUuid, {
568 const resource = items.shift();
569 let handler: GroupContentsHandler;
571 handler = (resource.kind === ResourceKind.COLLECTION || resource.kind === ResourceKind.PROJECT) && resource.isTrashed
572 ? groupContentsHandlers.TRASHED(resource)
573 : groupContentsHandlers.OWNED(resource);
575 const kind = extractUuidKind(params.uuid);
576 let resource: GroupContentsResource;
577 if (kind === ResourceKind.COLLECTION) {
578 resource = await params.services.collectionService.get(params.uuid);
579 } else if (kind === ResourceKind.PROJECT) {
580 resource = await params.services.projectService.get(params.uuid);
582 resource = await params.services.containerRequestService.get(params.uuid);
584 handler = groupContentsHandlers.SHARED(resource);
586 return (cases: MatchCases<typeof groupContentsHandlersRecord, GroupContentsHandler, void>) =>
587 groupContentsHandlers.match(handler, cases);
591 const groupContentsHandlersRecord = {
592 TRASHED: ofType<GroupContentsResource>(),
593 SHARED: ofType<GroupContentsResource>(),
594 OWNED: ofType<GroupContentsResource>(),
597 const groupContentsHandlers = unionize(groupContentsHandlersRecord);
599 type GroupContentsHandler = UnionOf<typeof groupContentsHandlers>;