1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
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, Resource } 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 { LinkResource } from "models/link";
24 import { resourceIsFrozen } from "common/frozen-resources";
25 import { ProjectResource } from "models/project";
27 export const contextMenuActions = unionize({
28 OPEN_CONTEXT_MENU: ofType<{ position: ContextMenuPosition; resource: ContextMenuResource }>(),
29 CLOSE_CONTEXT_MENU: ofType<{}>(),
32 export type ContextMenuAction = UnionOf<typeof contextMenuActions>;
34 export type ContextMenuResource = {
40 menuKind: ContextMenuKind | string;
44 workflowUuid?: string;
47 storageClassesDesired?: string[];
48 properties?: { [key: string]: string | string[] };
53 export const isKeyboardClick = (event: React.MouseEvent<HTMLElement>) => event.nativeEvent.detail === 0;
55 export const openContextMenu = (event: React.MouseEvent<HTMLElement>, resource: ContextMenuResource) => (dispatch: Dispatch) => {
56 event.preventDefault();
57 const { left, top } = event.currentTarget.getBoundingClientRect();
59 contextMenuActions.OPEN_CONTEXT_MENU({
61 x: event.clientX || left,
62 y: event.clientY || top,
69 export const openCollectionFilesContextMenu =
70 (event: React.MouseEvent<HTMLElement>, isWritable: boolean) => (dispatch: Dispatch, getState: () => RootState) => {
71 const isCollectionFileSelected = JSON.stringify(getState().collectionPanelFiles).includes('"selected":true');
73 openContextMenu(event, {
78 kind: ResourceKind.COLLECTION,
79 menuKind: isCollectionFileSelected
81 ? ContextMenuKind.COLLECTION_FILES
82 : ContextMenuKind.READONLY_COLLECTION_FILES
83 : ContextMenuKind.COLLECTION_FILES_NOT_SELECTED,
88 export const openRepositoryContextMenu =
89 (event: React.MouseEvent<HTMLElement>, repository: RepositoryResource) => (dispatch: Dispatch, getState: () => RootState) => {
91 openContextMenu(event, {
93 uuid: repository.uuid,
94 ownerUuid: repository.ownerUuid,
95 kind: ResourceKind.REPOSITORY,
96 menuKind: ContextMenuKind.REPOSITORY,
101 export const openVirtualMachinesContextMenu =
102 (event: React.MouseEvent<HTMLElement>, repository: VirtualMachinesResource) => (dispatch: Dispatch, getState: () => RootState) => {
104 openContextMenu(event, {
106 uuid: repository.uuid,
107 ownerUuid: repository.ownerUuid,
108 kind: ResourceKind.VIRTUAL_MACHINE,
109 menuKind: ContextMenuKind.VIRTUAL_MACHINE,
114 export const openSshKeyContextMenu = (event: React.MouseEvent<HTMLElement>, sshKey: SshKeyResource) => (dispatch: Dispatch) => {
116 openContextMenu(event, {
119 ownerUuid: sshKey.ownerUuid,
120 kind: ResourceKind.SSH_KEY,
121 menuKind: ContextMenuKind.SSH_KEY,
126 export const openKeepServiceContextMenu = (event: React.MouseEvent<HTMLElement>, keepService: KeepServiceResource) => (dispatch: Dispatch) => {
128 openContextMenu(event, {
130 uuid: keepService.uuid,
131 ownerUuid: keepService.ownerUuid,
132 kind: ResourceKind.KEEP_SERVICE,
133 menuKind: ContextMenuKind.KEEP_SERVICE,
138 export const openApiClientAuthorizationContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) => (dispatch: Dispatch) => {
140 openContextMenu(event, {
144 kind: ResourceKind.API_CLIENT_AUTHORIZATION,
145 menuKind: ContextMenuKind.API_CLIENT_AUTHORIZATION,
150 export const openRootProjectContextMenu =
151 (event: React.MouseEvent<HTMLElement>, projectUuid: string) => (dispatch: Dispatch, getState: () => RootState) => {
152 const res = getResource<UserResource>(projectUuid)(getState().resources);
155 openContextMenu(event, {
160 menuKind: ContextMenuKind.ROOT_PROJECT,
167 export const openProjectContextMenu =
168 (event: React.MouseEvent<HTMLElement>, resourceUuid: string) => (dispatch: Dispatch, getState: () => RootState) => {
169 const res = getResource<GroupContentsResource>(resourceUuid)(getState().resources);
170 const menuKind = dispatch<any>(resourceUuidToContextMenuKind(resourceUuid));
171 if (res && menuKind) {
173 openContextMenu(event, {
178 description: res.description,
179 ownerUuid: res.ownerUuid,
180 isTrashed: "isTrashed" in res ? res.isTrashed : false,
181 isFrozen: !!(res as ProjectResource).frozenByUuid,
187 export const openSidePanelContextMenu = (event: React.MouseEvent<HTMLElement>, id: string) => (dispatch: Dispatch, getState: () => RootState) => {
188 if (!isSidePanelTreeCategory(id)) {
189 const kind = extractUuidKind(id);
190 if (kind === ResourceKind.USER) {
191 dispatch<any>(openRootProjectContextMenu(event, id));
192 } else if (kind === ResourceKind.PROJECT) {
193 dispatch<any>(openProjectContextMenu(event, id));
198 export const openProcessContextMenu = (event: React.MouseEvent<HTMLElement>, process: Process) => (dispatch: Dispatch, getState: () => RootState) => {
199 const res = getResource<ProcessResource>(process.containerRequest.uuid)(getState().resources);
202 openContextMenu(event, {
204 ownerUuid: res.ownerUuid,
205 kind: ResourceKind.PROCESS,
207 description: res.description,
208 outputUuid: res.outputUuid || "",
209 workflowUuid: res.properties.template_uuid || "",
210 menuKind: ContextMenuKind.PROCESS_RESOURCE,
216 export const openPermissionEditContextMenu =
217 (event: React.MouseEvent<HTMLElement>, link: LinkResource) => (dispatch: Dispatch, getState: () => RootState) => {
220 openContextMenu(event, {
224 menuKind: ContextMenuKind.PERMISSION_EDIT,
225 ownerUuid: link.ownerUuid,
231 export const openUserContextMenu = (event: React.MouseEvent<HTMLElement>, user: UserResource) => (dispatch: Dispatch, getState: () => RootState) => {
233 openContextMenu(event, {
236 ownerUuid: user.ownerUuid,
238 menuKind: ContextMenuKind.USER,
243 export const resourceUuidToContextMenuKind =
244 (uuid: string, readonly = false) =>
245 (dispatch: Dispatch, getState: () => RootState) => {
246 const { isAdmin: isAdminUser, uuid: userUuid } = getState().auth.user!;
247 const kind = extractUuidKind(uuid);
248 const resource = getResourceWithEditableStatus<GroupResource & EditableResource>(uuid, userUuid)(getState().resources);
249 const isFrozen = resourceIsFrozen(resource, getState().resources);
250 const isEditable = (isAdminUser || (resource || ({} as EditableResource)).isEditable) && !readonly && !isFrozen;
253 case ResourceKind.PROJECT:
255 return isAdminUser ? ContextMenuKind.FROZEN_PROJECT_ADMIN : ContextMenuKind.FROZEN_PROJECT;
258 return isAdminUser && !readonly
259 ? resource && resource.groupClass !== GroupClass.FILTER
260 ? ContextMenuKind.PROJECT_ADMIN
261 : ContextMenuKind.FILTER_GROUP_ADMIN
263 ? resource && resource.groupClass !== GroupClass.FILTER
264 ? ContextMenuKind.PROJECT
265 : ContextMenuKind.FILTER_GROUP
266 : ContextMenuKind.READONLY_PROJECT;
267 case ResourceKind.COLLECTION:
268 const c = getResource<CollectionResource>(uuid)(getState().resources);
269 if (c === undefined) {
272 const isOldVersion = c.uuid !== c.currentVersionUuid;
273 const isTrashed = c.isTrashed;
275 ? ContextMenuKind.OLD_VERSION_COLLECTION
276 : isTrashed && isEditable
277 ? ContextMenuKind.TRASHED_COLLECTION
278 : isAdminUser && isEditable
279 ? ContextMenuKind.COLLECTION_ADMIN
281 ? ContextMenuKind.COLLECTION
282 : ContextMenuKind.READONLY_COLLECTION;
283 case ResourceKind.PROCESS:
284 return isAdminUser && isEditable
285 ? ContextMenuKind.PROCESS_ADMIN
287 ? ContextMenuKind.READONLY_PROCESS_RESOURCE
288 : ContextMenuKind.PROCESS_RESOURCE;
289 case ResourceKind.USER:
290 return ContextMenuKind.ROOT_PROJECT;
291 case ResourceKind.LINK:
292 return ContextMenuKind.LINK;
293 case ResourceKind.WORKFLOW:
294 return isEditable ? ContextMenuKind.WORKFLOW : ContextMenuKind.READONLY_WORKFLOW;
300 export const openSearchResultsContextMenu =
301 (event: React.MouseEvent<HTMLElement>, uuid: string) => (dispatch: Dispatch, getState: () => RootState) => {
302 const res = getResource<Resource>(uuid)(getState().resources);
305 openContextMenu(event, {
310 menuKind: ContextMenuKind.SEARCH_RESULTS,