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 } from '../resources/resources';
  11 import { ProjectResource } from '~/models/project';
  12 import { UserResource } from '~/models/user';
  13 import { isSidePanelTreeCategory } from '~/store/side-panel-tree/side-panel-tree-actions';
  14 import { extractUuidKind, ResourceKind } from '~/models/resource';
  15 import { Process } from '~/store/processes/process';
  16 import { RepositoryResource } from '~/models/repositories';
  17 import { SshKeyResource } from '~/models/ssh-key';
  18 import { VirtualMachinesResource } from '~/models/virtual-machines';
  19 import { KeepServiceResource } from '~/models/keep-services';
  20 import { ApiClientAuthorization } from '~/models/api-client-authorization';
  21
  22 export const contextMenuActions = unionize({
  23     OPEN_CONTEXT_MENU: ofType<{ position: ContextMenuPosition, resource: ContextMenuResource }>(),
  24     CLOSE_CONTEXT_MENU: ofType<{}>()
  25 });
  26
  27 export type ContextMenuAction = UnionOf<typeof contextMenuActions>;
  28
  29 export type ContextMenuResource = {
  30     name: string;
  31     uuid: string;
  32     ownerUuid: string;
  33     description?: string;
  34     kind: ResourceKind,
  35     menuKind: ContextMenuKind;
  36     isTrashed?: boolean;
  37     index?: number
  38 };
  39
  40 export const isKeyboardClick = (event: React.MouseEvent<HTMLElement>) => event.nativeEvent.detail === 0;
  41
  42 export const openContextMenu = (event: React.MouseEvent<HTMLElement>, resource: ContextMenuResource) =>
  43     (dispatch: Dispatch) => {
  44         event.preventDefault();
  45         const { left, top } = event.currentTarget.getBoundingClientRect();
  46         dispatch(
  47             contextMenuActions.OPEN_CONTEXT_MENU({
  48                 position: {
  49                     x: event.clientX || left,
  50                     y: event.clientY || top,
  51                 },
  52                 resource
  53             })
  54         );
  55     };
  56
  57 export const openCollectionFilesContextMenu = (event: React.MouseEvent<HTMLElement>) =>
  58     (dispatch: Dispatch, getState: () => RootState) => {
  59         const isCollectionFileSelected = JSON.stringify(getState().collectionPanelFiles).includes('"selected":true');
  60         dispatch<any>(openContextMenu(event, {
  61             name: '',
  62             uuid: '',
  63             ownerUuid: '',
  64             kind: ResourceKind.COLLECTION,
  65             menuKind: isCollectionFileSelected ? ContextMenuKind.COLLECTION_FILES : ContextMenuKind.COLLECTION_FILES_NOT_SELECTED
  66         }));
  67     };
  68
  69 export const openRepositoryContextMenu = (event: React.MouseEvent<HTMLElement>, repository: RepositoryResource) =>
  70     (dispatch: Dispatch, getState: () => RootState) => {
  71         dispatch<any>(openContextMenu(event, {
  72             name: '',
  73             uuid: repository.uuid,
  74             ownerUuid: repository.ownerUuid,
  75             kind: ResourceKind.REPOSITORY,
  76             menuKind: ContextMenuKind.REPOSITORY
  77         }));
  78     };
  79
  80 export const openVirtualMachinesContextMenu = (event: React.MouseEvent<HTMLElement>, repository: VirtualMachinesResource) =>
  81     (dispatch: Dispatch, getState: () => RootState) => {
  82         dispatch<any>(openContextMenu(event, {
  83             name: '',
  84             uuid: repository.uuid,
  85             ownerUuid: repository.ownerUuid,
  86             kind: ResourceKind.VIRTUAL_MACHINE,
  87             menuKind: ContextMenuKind.VIRTUAL_MACHINE
  88         }));
  89     };
  90
  91 export const openSshKeyContextMenu = (event: React.MouseEvent<HTMLElement>, sshKey: SshKeyResource) =>
  92     (dispatch: Dispatch) => {
  93         dispatch<any>(openContextMenu(event, {
  94             name: '',
  95             uuid: sshKey.uuid,
  96             ownerUuid: sshKey.ownerUuid,
  97             kind: ResourceKind.SSH_KEY,
  98             menuKind: ContextMenuKind.SSH_KEY
  99         }));
 100     };
 101
 102 export const openKeepServiceContextMenu = (event: React.MouseEvent<HTMLElement>, keepService: KeepServiceResource) =>
 103     (dispatch: Dispatch) => {
 104         dispatch<any>(openContextMenu(event, {
 105             name: '',
 106             uuid: keepService.uuid,
 107             ownerUuid: keepService.ownerUuid,
 108             kind: ResourceKind.KEEP_SERVICE,
 109             menuKind: ContextMenuKind.KEEP_SERVICE
 110         }));
 111     };
 112
 113 export const openComputeNodeContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) =>
 114     (dispatch: Dispatch) => {
 115         dispatch<any>(openContextMenu(event, {
 116             name: '',
 117             uuid: resourceUuid,
 118             ownerUuid: '',
 119             kind: ResourceKind.NODE,
 120             menuKind: ContextMenuKind.NODE
 121         }));
 122     };
 123
 124 export const openApiClientAuthorizationContextMenu =
 125     (event: React.MouseEvent<HTMLElement>, apiClientAuthorization: ApiClientAuthorization) =>
 126         (dispatch: Dispatch) => {
 127             dispatch<any>(openContextMenu(event, {
 128                 name: '',
 129                 uuid: apiClientAuthorization.uuid,
 130                 ownerUuid: apiClientAuthorization.ownerUuid,
 131                 kind: ResourceKind.API_CLIENT_AUTHORIZATION,
 132                 menuKind: ContextMenuKind.API_CLIENT_AUTHORIZATION
 133             }));
 134         };
 135
 136 export const openRootProjectContextMenu = (event: React.MouseEvent<HTMLElement>, projectUuid: string) =>
 137     (dispatch: Dispatch, getState: () => RootState) => {
 138         const res = getResource<UserResource>(projectUuid)(getState().resources);
 139         if (res) {
 140             dispatch<any>(openContextMenu(event, {
 141                 name: '',
 142                 uuid: res.uuid,
 143                 ownerUuid: res.uuid,
 144                 kind: res.kind,
 145                 menuKind: ContextMenuKind.ROOT_PROJECT,
 146                 isTrashed: false
 147             }));
 148         }
 149     };
 150
 151 export const openProjectContextMenu = (event: React.MouseEvent<HTMLElement>, projectUuid: string) =>
 152     (dispatch: Dispatch, getState: () => RootState) => {
 153         const res = getResource<ProjectResource>(projectUuid)(getState().resources);
 154         if (res) {
 155             dispatch<any>(openContextMenu(event, {
 156                 name: res.name,
 157                 uuid: res.uuid,
 158                 kind: res.kind,
 159                 menuKind: ContextMenuKind.PROJECT,
 160                 ownerUuid: res.ownerUuid,
 161                 isTrashed: res.isTrashed
 162             }));
 163         }
 164     };
 165
 166 export const openSidePanelContextMenu = (event: React.MouseEvent<HTMLElement>, id: string) =>
 167     (dispatch: Dispatch, getState: () => RootState) => {
 168         if (!isSidePanelTreeCategory(id)) {
 169             const kind = extractUuidKind(id);
 170             if (kind === ResourceKind.USER) {
 171                 dispatch<any>(openRootProjectContextMenu(event, id));
 172             } else if (kind === ResourceKind.PROJECT) {
 173                 dispatch<any>(openProjectContextMenu(event, id));
 174             }
 175         }
 176     };
 177
 178 export const openProcessContextMenu = (event: React.MouseEvent<HTMLElement>, process: Process) =>
 179     (dispatch: Dispatch, getState: () => RootState) => {
 180         const resource = {
 181             uuid: process.containerRequest.uuid,
 182             ownerUuid: process.containerRequest.ownerUuid,
 183             kind: ResourceKind.PROCESS,
 184             name: process.containerRequest.name,
 185             description: process.containerRequest.description,
 186             menuKind: ContextMenuKind.PROCESS
 187         };
 188         dispatch<any>(openContextMenu(event, resource));
 189     };
 190
 191 export const resourceKindToContextMenuKind = (uuid: string) => {
 192     const kind = extractUuidKind(uuid);
 193     switch (kind) {
 194         case ResourceKind.PROJECT:
 195             return ContextMenuKind.PROJECT;
 196         case ResourceKind.COLLECTION:
 197             return ContextMenuKind.COLLECTION_RESOURCE;
 198         case ResourceKind.PROCESS:
 199             return ContextMenuKind.PROCESS_RESOURCE;
 200         case ResourceKind.USER:
 201             return ContextMenuKind.ROOT_PROJECT;
 202         case ResourceKind.LINK:
 203             return ContextMenuKind.LINK;
 204         default:
 205             return;
 206     }
 207 };