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 import { getProjectPanelCurrentUuid } from '~/store/project-panel/project-panel-action';
  24 import { matchProjectRoute } from '~/routes/routes';
  25 import { RouterState } from "react-router-redux";
  26
  27 export const contextMenuActions = unionize({
  28     OPEN_CONTEXT_MENU: ofType<{ position: ContextMenuPosition, resource: ContextMenuResource }>(),
  29     CLOSE_CONTEXT_MENU: ofType<{}>()
  30 });
  31
  32 export type ContextMenuAction = UnionOf<typeof contextMenuActions>;
  33
  34 export type ContextMenuResource = {
  35     name: string;
  36     uuid: string;
  37     ownerUuid: string;
  38     description?: string;
  39     kind: ResourceKind,
  40     menuKind: ContextMenuKind;
  41     isTrashed?: boolean;
  42     isEditable?: boolean;
  43     outputUuid?: string;
  44     workflowUuid?: string;
  45 };
  46
  47 export const isKeyboardClick = (event: React.MouseEvent<HTMLElement>) => event.nativeEvent.detail === 0;
  48
  49 export const openContextMenu = (event: React.MouseEvent<HTMLElement>, resource: ContextMenuResource) =>
  50     (dispatch: Dispatch) => {
  51         event.preventDefault();
  52         const { left, top } = event.currentTarget.getBoundingClientRect();
  53         dispatch(
  54             contextMenuActions.OPEN_CONTEXT_MENU({
  55                 position: {
  56                     x: event.clientX || left,
  57                     y: event.clientY || top,
  58                 },
  59                 resource
  60             })
  61         );
  62     };
  63
  64 export const openCollectionFilesContextMenu = (event: React.MouseEvent<HTMLElement>, isWritable: boolean) =>
  65     (dispatch: Dispatch, getState: () => RootState) => {
  66         const isCollectionFileSelected = JSON.stringify(getState().collectionPanelFiles).includes('"selected":true');
  67         dispatch<any>(openContextMenu(event, {
  68             name: '',
  69             uuid: '',
  70             ownerUuid: '',
  71             kind: ResourceKind.COLLECTION,
  72             menuKind: isCollectionFileSelected
  73                 ? isWritable
  74                     ? ContextMenuKind.COLLECTION_FILES
  75                     : ContextMenuKind.READONLY_COLLECTION_FILES
  76                 : ContextMenuKind.COLLECTION_FILES_NOT_SELECTED
  77         }));
  78     };
  79
  80 export const openRepositoryContextMenu = (event: React.MouseEvent<HTMLElement>, repository: RepositoryResource) =>
  81     (dispatch: Dispatch, getState: () => RootState) => {
  82         dispatch<any>(openContextMenu(event, {
  83             name: '',
  84             uuid: repository.uuid,
  85             ownerUuid: repository.ownerUuid,
  86             kind: ResourceKind.REPOSITORY,
  87             menuKind: ContextMenuKind.REPOSITORY
  88         }));
  89     };
  90
  91 export const openVirtualMachinesContextMenu = (event: React.MouseEvent<HTMLElement>, repository: VirtualMachinesResource) =>
  92     (dispatch: Dispatch, getState: () => RootState) => {
  93         dispatch<any>(openContextMenu(event, {
  94             name: '',
  95             uuid: repository.uuid,
  96             ownerUuid: repository.ownerUuid,
  97             kind: ResourceKind.VIRTUAL_MACHINE,
  98             menuKind: ContextMenuKind.VIRTUAL_MACHINE
  99         }));
 100     };
 101
 102 export const openSshKeyContextMenu = (event: React.MouseEvent<HTMLElement>, sshKey: SshKeyResource) =>
 103     (dispatch: Dispatch) => {
 104         dispatch<any>(openContextMenu(event, {
 105             name: '',
 106             uuid: sshKey.uuid,
 107             ownerUuid: sshKey.ownerUuid,
 108             kind: ResourceKind.SSH_KEY,
 109             menuKind: ContextMenuKind.SSH_KEY
 110         }));
 111     };
 112
 113 export const openKeepServiceContextMenu = (event: React.MouseEvent<HTMLElement>, keepService: KeepServiceResource) =>
 114     (dispatch: Dispatch) => {
 115         dispatch<any>(openContextMenu(event, {
 116             name: '',
 117             uuid: keepService.uuid,
 118             ownerUuid: keepService.ownerUuid,
 119             kind: ResourceKind.KEEP_SERVICE,
 120             menuKind: ContextMenuKind.KEEP_SERVICE
 121         }));
 122     };
 123
 124 export const openComputeNodeContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 125     (dispatch: Dispatch) => {
 126         dispatch<any>(openContextMenu(event, {
 127             name: '',
 128             uuid: resourceUuid,
 129             ownerUuid: '',
 130             kind: ResourceKind.NODE,
 131             menuKind: ContextMenuKind.NODE
 132         }));
 133     };
 134
 135 export const openApiClientAuthorizationContextMenu =
 136     (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 137         (dispatch: Dispatch) => {
 138             dispatch<any>(openContextMenu(event, {
 139                 name: '',
 140                 uuid: resourceUuid,
 141                 ownerUuid: '',
 142                 kind: ResourceKind.API_CLIENT_AUTHORIZATION,
 143                 menuKind: ContextMenuKind.API_CLIENT_AUTHORIZATION
 144             }));
 145         };
 146
 147 export const openRootProjectContextMenu = (event: React.MouseEvent<HTMLElement>, projectUuid: string) =>
 148     (dispatch: Dispatch, getState: () => RootState) => {
 149         const res = getResource<UserResource>(projectUuid)(getState().resources);
 150         if (res) {
 151             dispatch<any>(openContextMenu(event, {
 152                 name: '',
 153                 uuid: res.uuid,
 154                 ownerUuid: res.uuid,
 155                 kind: res.kind,
 156                 menuKind: ContextMenuKind.ROOT_PROJECT,
 157                 isTrashed: false
 158             }));
 159         }
 160     };
 161
 162 export const openProjectContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 163     (dispatch: Dispatch, getState: () => RootState) => {
 164         const res = getResource<GroupContentsResource>(resourceUuid)(getState().resources);
 165         const menuKind = dispatch<any>(resourceUuidToContextMenuKind(resourceUuid));
 166         if (res && menuKind) {
 167             dispatch<any>(openContextMenu(event, {
 168                 name: res.name,
 169                 uuid: res.uuid,
 170                 kind: res.kind,
 171                 menuKind,
 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 isProjectRoute = (router: RouterState) => {
 208     if (router === undefined) {
 209       return false;
 210     }
 211     const pathname = router.location ? router.location.pathname : '';
 212     const matchProject = matchProjectRoute(pathname);
 213     return Boolean(matchProject);
 214 };
 215
 216 export const resourceUuidToContextMenuKind = (uuid: string) =>
 217     (dispatch: Dispatch, getState: () => RootState) => {
 218         const { isAdmin: isAdminUser, uuid: userUuid } = getState().auth.user!;
 219         const kind = extractUuidKind(uuid);
 220         const resource = getResourceWithEditableStatus<GroupResource & EditableResource>(uuid, userUuid)(getState().resources);
 221
 222         // When viewing the contents of a filter group, all contents should be treated as read only.
 223         let inFilterGroup = false;
 224         const { router } = getState();
 225         if (isProjectRoute(router)) {
 226           const projectUuid = getProjectPanelCurrentUuid(getState());
 227           if (projectUuid !== undefined) {
 228             const project = getResource<GroupResource>(projectUuid)(getState().resources);
 229             if (project) {
 230               if (project.groupClass === GroupClass.FILTER) {
 231                 inFilterGroup = true;
 232               }
 233             }
 234           }
 235         }
 236
 237         const isEditable = (isAdminUser || (resource || {} as EditableResource).isEditable) && !inFilterGroup;
 238         switch (kind) {
 239             case ResourceKind.PROJECT:
 240                 return (isAdminUser && !inFilterGroup)
 241                     ? (resource && resource.groupClass === GroupClass.PROJECT)
 242                         ? ContextMenuKind.PROJECT_ADMIN
 243                         : ContextMenuKind.READONLY_PROJECT
 244                     : isEditable
 245                         ? ContextMenuKind.PROJECT
 246                         : ContextMenuKind.READONLY_PROJECT;
 247             case ResourceKind.COLLECTION:
 248                 const c = getResource<CollectionResource>(uuid)(getState().resources);
 249                 if (c === undefined) { return; }
 250                 const isOldVersion = c.uuid !== c.currentVersionUuid;
 251                 const isTrashed = c.isTrashed;
 252                 return isOldVersion
 253                     ? ContextMenuKind.OLD_VERSION_COLLECTION
 254                     : (isTrashed && isEditable)
 255                         ? ContextMenuKind.TRASHED_COLLECTION
 256                         : (isAdminUser && !inFilterGroup)
 257                             ? ContextMenuKind.COLLECTION_ADMIN
 258                             : isEditable
 259                                 ? ContextMenuKind.COLLECTION
 260                                 : ContextMenuKind.READONLY_COLLECTION;
 261             case ResourceKind.PROCESS:
 262                 return (isAdminUser && !inFilterGroup)
 263                     ? ContextMenuKind.PROCESS_ADMIN
 264                     : inFilterGroup
 265                         ? ContextMenuKind.READONLY_PROCESS_RESOURCE
 266                         : ContextMenuKind.PROCESS_RESOURCE;
 267             case ResourceKind.USER:
 268                 return ContextMenuKind.ROOT_PROJECT;
 269             case ResourceKind.LINK:
 270                 return ContextMenuKind.LINK;
 271             default:
 272                 return;
 273         }
 274     };