src/store/context-menu/context-menu-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { unionize, ofType, UnionOf } from 'common/unionize';
   6 import { ContextMenuPosition } from "./context-menu-reducer";
   7 import { ContextMenuKind } from 'views-components/context-menu/context-menu';
   8 import { Dispatch } from 'redux';
   9 import { RootState } from 'store/store';
  10 import { getResource, getResourceWithEditableStatus } from '../resources/resources';
  11 import { UserResource } from 'models/user';
  12 import { isSidePanelTreeCategory } from 'store/side-panel-tree/side-panel-tree-actions';
  13 import { extractUuidKind, ResourceKind, EditableResource } from 'models/resource';
  14 import { Process } from 'store/processes/process';
  15 import { RepositoryResource } from 'models/repositories';
  16 import { SshKeyResource } from 'models/ssh-key';
  17 import { VirtualMachinesResource } from 'models/virtual-machines';
  18 import { KeepServiceResource } from 'models/keep-services';
  19 import { ProcessResource } from 'models/process';
  20 import { CollectionResource } from 'models/collection';
  21 import { GroupClass, GroupResource } from 'models/group';
  22 import { GroupContentsResource } from 'services/groups-service/groups-service';
  23
  24 export const contextMenuActions = unionize({
  25     OPEN_CONTEXT_MENU: ofType<{ position: ContextMenuPosition, resource: ContextMenuResource }>(),
  26     CLOSE_CONTEXT_MENU: ofType<{}>()
  27 });
  28
  29 export type ContextMenuAction = UnionOf<typeof contextMenuActions>;
  30
  31 export type ContextMenuResource = {
  32     name: string;
  33     uuid: string;
  34     ownerUuid: string;
  35     description?: string;
  36     kind: ResourceKind,
  37     menuKind: ContextMenuKind | string;
  38     isTrashed?: boolean;
  39     isEditable?: boolean;
  40     outputUuid?: string;
  41     workflowUuid?: string;
  42     storageClassesDesired?: string[];
  43 };
  44
  45 export const isKeyboardClick = (event: React.MouseEvent<HTMLElement>) => event.nativeEvent.detail === 0;
  46
  47 export const openContextMenu = (event: React.MouseEvent<HTMLElement>, resource: ContextMenuResource) =>
  48     (dispatch: Dispatch) => {
  49         event.preventDefault();
  50         const { left, top } = event.currentTarget.getBoundingClientRect();
  51         dispatch(
  52             contextMenuActions.OPEN_CONTEXT_MENU({
  53                 position: {
  54                     x: event.clientX || left,
  55                     y: event.clientY || top,
  56                 },
  57                 resource
  58             })
  59         );
  60     };
  61
  62 export const openCollectionFilesContextMenu = (event: React.MouseEvent<HTMLElement>, isWritable: boolean) =>
  63     (dispatch: Dispatch, getState: () => RootState) => {
  64         const isCollectionFileSelected = JSON.stringify(getState().collectionPanelFiles).includes('"selected":true');
  65         dispatch<any>(openContextMenu(event, {
  66             name: '',
  67             uuid: '',
  68             ownerUuid: '',
  69             description: '',
  70             kind: ResourceKind.COLLECTION,
  71             menuKind: isCollectionFileSelected
  72                 ? isWritable
  73                     ? ContextMenuKind.COLLECTION_FILES
  74                     : ContextMenuKind.READONLY_COLLECTION_FILES
  75                 : ContextMenuKind.COLLECTION_FILES_NOT_SELECTED
  76         }));
  77     };
  78
  79 export const openRepositoryContextMenu = (event: React.MouseEvent<HTMLElement>, repository: RepositoryResource) =>
  80     (dispatch: Dispatch, getState: () => RootState) => {
  81         dispatch<any>(openContextMenu(event, {
  82             name: '',
  83             uuid: repository.uuid,
  84             ownerUuid: repository.ownerUuid,
  85             kind: ResourceKind.REPOSITORY,
  86             menuKind: ContextMenuKind.REPOSITORY
  87         }));
  88     };
  89
  90 export const openVirtualMachinesContextMenu = (event: React.MouseEvent<HTMLElement>, repository: VirtualMachinesResource) =>
  91     (dispatch: Dispatch, getState: () => RootState) => {
  92         dispatch<any>(openContextMenu(event, {
  93             name: '',
  94             uuid: repository.uuid,
  95             ownerUuid: repository.ownerUuid,
  96             kind: ResourceKind.VIRTUAL_MACHINE,
  97             menuKind: ContextMenuKind.VIRTUAL_MACHINE
  98         }));
  99     };
 100
 101 export const openSshKeyContextMenu = (event: React.MouseEvent<HTMLElement>, sshKey: SshKeyResource) =>
 102     (dispatch: Dispatch) => {
 103         dispatch<any>(openContextMenu(event, {
 104             name: '',
 105             uuid: sshKey.uuid,
 106             ownerUuid: sshKey.ownerUuid,
 107             kind: ResourceKind.SSH_KEY,
 108             menuKind: ContextMenuKind.SSH_KEY
 109         }));
 110     };
 111
 112 export const openKeepServiceContextMenu = (event: React.MouseEvent<HTMLElement>, keepService: KeepServiceResource) =>
 113     (dispatch: Dispatch) => {
 114         dispatch<any>(openContextMenu(event, {
 115             name: '',
 116             uuid: keepService.uuid,
 117             ownerUuid: keepService.ownerUuid,
 118             kind: ResourceKind.KEEP_SERVICE,
 119             menuKind: ContextMenuKind.KEEP_SERVICE
 120         }));
 121     };
 122
 123 export const openComputeNodeContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 124     (dispatch: Dispatch) => {
 125         dispatch<any>(openContextMenu(event, {
 126             name: '',
 127             uuid: resourceUuid,
 128             ownerUuid: '',
 129             kind: ResourceKind.NODE,
 130             menuKind: ContextMenuKind.NODE
 131         }));
 132     };
 133
 134 export const openApiClientAuthorizationContextMenu =
 135     (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 136         (dispatch: Dispatch) => {
 137             dispatch<any>(openContextMenu(event, {
 138                 name: '',
 139                 uuid: resourceUuid,
 140                 ownerUuid: '',
 141                 kind: ResourceKind.API_CLIENT_AUTHORIZATION,
 142                 menuKind: ContextMenuKind.API_CLIENT_AUTHORIZATION
 143             }));
 144         };
 145
 146 export const openRootProjectContextMenu = (event: React.MouseEvent<HTMLElement>, projectUuid: string) =>
 147     (dispatch: Dispatch, getState: () => RootState) => {
 148         const res = getResource<UserResource>(projectUuid)(getState().resources);
 149         if (res) {
 150             dispatch<any>(openContextMenu(event, {
 151                 name: '',
 152                 uuid: res.uuid,
 153                 ownerUuid: res.uuid,
 154                 kind: res.kind,
 155                 menuKind: ContextMenuKind.ROOT_PROJECT,
 156                 isTrashed: false
 157             }));
 158         }
 159     };
 160
 161 export const openProjectContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 162     (dispatch: Dispatch, getState: () => RootState) => {
 163         const res = getResource<GroupContentsResource>(resourceUuid)(getState().resources);
 164         const menuKind = dispatch<any>(resourceUuidToContextMenuKind(resourceUuid));
 165         if (res && menuKind) {
 166             dispatch<any>(openContextMenu(event, {
 167                 name: res.name,
 168                 uuid: res.uuid,
 169                 kind: res.kind,
 170                 menuKind,
 171                 description: res.description,
 172                 ownerUuid: res.ownerUuid,
 173                 isTrashed: ('isTrashed' in res) ? res.isTrashed : false,
 174             }));
 175         }
 176     };
 177
 178 export const openSidePanelContextMenu = (event: React.MouseEvent<HTMLElement>, id: string) =>
 179     (dispatch: Dispatch, getState: () => RootState) => {
 180         if (!isSidePanelTreeCategory(id)) {
 181             const kind = extractUuidKind(id);
 182             if (kind === ResourceKind.USER) {
 183                 dispatch<any>(openRootProjectContextMenu(event, id));
 184             } else if (kind === ResourceKind.PROJECT) {
 185                 dispatch<any>(openProjectContextMenu(event, id));
 186             }
 187         }
 188     };
 189
 190 export const openProcessContextMenu = (event: React.MouseEvent<HTMLElement>, process: Process) =>
 191     (dispatch: Dispatch, getState: () => RootState) => {
 192         const res = getResource<ProcessResource>(process.containerRequest.uuid)(getState().resources);
 193         if (res) {
 194             dispatch<any>(openContextMenu(event, {
 195                 uuid: res.uuid,
 196                 ownerUuid: res.ownerUuid,
 197                 kind: ResourceKind.PROCESS,
 198                 name: res.name,
 199                 description: res.description,
 200                 outputUuid: res.outputUuid || '',
 201                 workflowUuid: res.properties.workflowUuid || '',
 202                 menuKind: ContextMenuKind.PROCESS
 203             }));
 204         }
 205     };
 206
 207 export const resourceUuidToContextMenuKind = (uuid: string, readonly = false) =>
 208     (dispatch: Dispatch, getState: () => RootState) => {
 209         const { isAdmin: isAdminUser, uuid: userUuid } = getState().auth.user!;
 210         const kind = extractUuidKind(uuid);
 211         const resource = getResourceWithEditableStatus<GroupResource & EditableResource>(uuid, userUuid)(getState().resources);
 212
 213         const isEditable = (isAdminUser || (resource || {} as EditableResource).isEditable) && !readonly;
 214         switch (kind) {
 215             case ResourceKind.PROJECT:
 216                 return (isAdminUser && !readonly)
 217                     ? (resource && resource.groupClass !== GroupClass.FILTER)
 218                         ? ContextMenuKind.PROJECT_ADMIN
 219                         : ContextMenuKind.FILTER_GROUP_ADMIN
 220                     : isEditable
 221                         ? (resource && resource.groupClass !== GroupClass.FILTER)
 222                             ? ContextMenuKind.PROJECT
 223                             : ContextMenuKind.FILTER_GROUP
 224                         : ContextMenuKind.READONLY_PROJECT;
 225             case ResourceKind.COLLECTION:
 226                 const c = getResource<CollectionResource>(uuid)(getState().resources);
 227                 if (c === undefined) { return; }
 228                 const isOldVersion = c.uuid !== c.currentVersionUuid;
 229                 const isTrashed = c.isTrashed;
 230                 return isOldVersion
 231                     ? ContextMenuKind.OLD_VERSION_COLLECTION
 232                     : (isTrashed && isEditable)
 233                         ? ContextMenuKind.TRASHED_COLLECTION
 234                         : (isAdminUser && !readonly)
 235                             ? ContextMenuKind.COLLECTION_ADMIN
 236                             : isEditable
 237                                 ? ContextMenuKind.COLLECTION
 238                                 : ContextMenuKind.READONLY_COLLECTION;
 239             case ResourceKind.PROCESS:
 240                 return (isAdminUser && !readonly)
 241                     ? ContextMenuKind.PROCESS_ADMIN
 242                     : readonly
 243                         ? ContextMenuKind.READONLY_PROCESS_RESOURCE
 244                         : ContextMenuKind.PROCESS_RESOURCE;
 245             case ResourceKind.USER:
 246                 return ContextMenuKind.ROOT_PROJECT;
 247             case ResourceKind.LINK:
 248                 return ContextMenuKind.LINK;
 249             default:
 250                 return;
 251         }
 252     };