src/store/groups-panel/groups-panel-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { Dispatch } from 'redux';
   6 import { reset, startSubmit, stopSubmit, FormErrors, initialize } from 'redux-form';
   7 import { bindDataExplorerActions } from "store/data-explorer/data-explorer-action";
   8 import { dialogActions } from 'store/dialog/dialog-actions';
   9 import { Participant } from 'views-components/sharing-dialog/participant-select';
  10 import { RootState } from 'store/store';
  11 import { ServiceRepository } from 'services/services';
  12 import { getResource } from 'store/resources/resources';
  13 import { GroupResource, GroupClass } from 'models/group';
  14 import { getCommonResourceServiceError, CommonResourceServiceError } from 'services/common-service/common-resource-service';
  15 import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
  16 import { PermissionLevel } from 'models/permission';
  17 import { PermissionService } from 'services/permission-service/permission-service';
  18 import { FilterBuilder } from 'services/api/filter-builder';
  19 import { ProjectUpdateFormDialogData, PROJECT_UPDATE_FORM_NAME } from 'store/projects/project-update-actions';
  20
  21 export const GROUPS_PANEL_ID = "groupsPanel";
  22
  23 export const GROUP_ATTRIBUTES_DIALOG = 'groupAttributesDialog';
  24 export const GROUP_REMOVE_DIALOG = 'groupRemoveDialog';
  25
  26 export const GroupsPanelActions = bindDataExplorerActions(GROUPS_PANEL_ID);
  27
  28 export const loadGroupsPanel = () => GroupsPanelActions.REQUEST_ITEMS();
  29
  30 export const openCreateGroupDialog = () =>
  31     (dispatch: Dispatch, getState: () => RootState) => {
  32         dispatch(initialize(PROJECT_UPDATE_FORM_NAME, {}));
  33         dispatch(dialogActions.OPEN_DIALOG({ id: PROJECT_UPDATE_FORM_NAME, data: {sourcePanel: GroupClass.ROLE, showUsersField: true} }));
  34     };
  35
  36 export const openGroupAttributes = (uuid: string) =>
  37     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  38         const { resources } = getState();
  39         const data = getResource<GroupResource>(uuid)(resources);
  40         dispatch(dialogActions.OPEN_DIALOG({ id: GROUP_ATTRIBUTES_DIALOG, data }));
  41     };
  42
  43 export const removeGroup = (uuid: string) =>
  44     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  45         dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Removing ...', kind: SnackbarKind.INFO }));
  46         await services.groupsService.delete(uuid);
  47         dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Removed.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
  48         dispatch<any>(loadGroupsPanel());
  49     };
  50
  51 export const openRemoveGroupDialog = (uuid: string) =>
  52     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  53         dispatch(dialogActions.OPEN_DIALOG({
  54             id: GROUP_REMOVE_DIALOG,
  55             data: {
  56                 title: 'Remove group',
  57                 text: 'Are you sure you want to remove this group?',
  58                 confirmButtonLabel: 'Remove',
  59                 uuid
  60             }
  61         }));
  62     };
  63
  64 // Group edit dialog uses project update dialog with sourcePanel set to reload the appropriate parts
  65 export const openGroupUpdateDialog = (resource: ProjectUpdateFormDialogData) =>
  66     (dispatch: Dispatch, getState: () => RootState) => {
  67         dispatch(initialize(PROJECT_UPDATE_FORM_NAME, resource));
  68         dispatch(dialogActions.OPEN_DIALOG({ id: PROJECT_UPDATE_FORM_NAME, data: {sourcePanel: GroupClass.ROLE} }));
  69     };
  70
  71 export const updateGroup = (project: ProjectUpdateFormDialogData) =>
  72     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  73         const uuid = project.uuid || '';
  74         dispatch(startSubmit(PROJECT_UPDATE_FORM_NAME));
  75         try {
  76             const updatedGroup = await services.groupsService.update(uuid, { name: project.name, description: project.description });
  77             dispatch(GroupsPanelActions.REQUEST_ITEMS());
  78             dispatch(reset(PROJECT_UPDATE_FORM_NAME));
  79             dispatch(dialogActions.CLOSE_DIALOG({ id: PROJECT_UPDATE_FORM_NAME }));
  80             return updatedGroup;
  81         } catch (e) {
  82             dispatch(stopSubmit(PROJECT_UPDATE_FORM_NAME));
  83             const error = getCommonResourceServiceError(e);
  84             if (error === CommonResourceServiceError.UNIQUE_NAME_VIOLATION) {
  85                 dispatch(stopSubmit(PROJECT_UPDATE_FORM_NAME, { name: 'Group with the same name already exists.' } as FormErrors));
  86             }
  87             return ;
  88         }
  89     };
  90
  91 export const createGroup = ({ name, users = [], description }: ProjectUpdateFormDialogData) =>
  92     async (dispatch: Dispatch, _: {}, { groupsService, permissionService }: ServiceRepository) => {
  93         dispatch(startSubmit(PROJECT_UPDATE_FORM_NAME));
  94         try {
  95             const newGroup = await groupsService.create({ name, description, groupClass: GroupClass.ROLE });
  96             for (const user of users) {
  97                 await addGroupMember({
  98                     user,
  99                     group: newGroup,
 100                     dispatch,
 101                     permissionService,
 102                 });
 103             }
 104             dispatch(dialogActions.CLOSE_DIALOG({ id: PROJECT_UPDATE_FORM_NAME }));
 105             dispatch(reset(PROJECT_UPDATE_FORM_NAME));
 106             dispatch(loadGroupsPanel());
 107             dispatch(snackbarActions.OPEN_SNACKBAR({
 108                 message: `${newGroup.name} group has been created`,
 109                 kind: SnackbarKind.SUCCESS
 110             }));
 111             return newGroup;
 112         } catch (e) {
 113             const error = getCommonResourceServiceError(e);
 114             if (error === CommonResourceServiceError.UNIQUE_NAME_VIOLATION) {
 115                 dispatch(stopSubmit(PROJECT_UPDATE_FORM_NAME, { name: 'Group with the same name already exists.' } as FormErrors));
 116             }
 117             return;
 118         }
 119     };
 120
 121 interface AddGroupMemberArgs {
 122     user: { uuid: string, name: string };
 123     group: { uuid: string, name: string };
 124     dispatch: Dispatch;
 125     permissionService: PermissionService;
 126 }
 127
 128 /**
 129  * Group membership is determined by whether the group has can_read permission on an object.
 130  * If a group G can_read an object A, then we say A is a member of G.
 131  *
 132  * [Permission model docs](https://doc.arvados.org/api/permission-model.html)
 133  */
 134 export const addGroupMember = async ({ user, group, ...args }: AddGroupMemberArgs) => {
 135     await createPermission({
 136         head: { ...group },
 137         tail: { ...user },
 138         permissionLevel: PermissionLevel.CAN_READ,
 139         ...args,
 140     });
 141 };
 142
 143 interface CreatePermissionLinkArgs {
 144     head: { uuid: string, name: string };
 145     tail: { uuid: string, name: string };
 146     permissionLevel: PermissionLevel;
 147     dispatch: Dispatch;
 148     permissionService: PermissionService;
 149 }
 150
 151 const createPermission = async ({ head, tail, permissionLevel, dispatch, permissionService }: CreatePermissionLinkArgs) => {
 152     try {
 153         await permissionService.create({
 154             tailUuid: tail.uuid,
 155             headUuid: head.uuid,
 156             name: permissionLevel,
 157         });
 158     } catch (e) {
 159         dispatch(snackbarActions.OPEN_SNACKBAR({
 160             message: `Could not add ${tail.name} -> ${head.name} relation`,
 161             kind: SnackbarKind.ERROR,
 162         }));
 163     }
 164 };
 165
 166 interface DeleteGroupMemberArgs {
 167     link: { uuid: string };
 168     dispatch: Dispatch;
 169     permissionService: PermissionService;
 170 }
 171
 172 export const deleteGroupMember = async ({ link, ...args }: DeleteGroupMemberArgs) => {
 173     await deletePermission({
 174         uuid: link.uuid,
 175         ...args,
 176     });
 177 };
 178
 179 interface DeletePermissionLinkArgs {
 180     uuid: string;
 181     dispatch: Dispatch;
 182     permissionService: PermissionService;
 183 }
 184
 185 export const deletePermission = async ({ uuid, dispatch, permissionService }: DeletePermissionLinkArgs) => {
 186     try {
 187         const permissionsResponse = await permissionService.list({
 188             filters: new FilterBuilder()
 189                 .addEqual('uuid', uuid)
 190                 .getFilters()
 191         });
 192         const [permission] = permissionsResponse.items;
 193         if (permission) {
 194             await permissionService.delete(permission.uuid);
 195         } else {
 196             throw new Error('Permission not found');
 197         }
 198     } catch (e) {
 199         dispatch(snackbarActions.OPEN_SNACKBAR({
 200             message: `Could not delete ${uuid} permission`,
 201             kind: SnackbarKind.ERROR,
 202         }));
 203     }
 204 };