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 } from 'redux-form';
   7 import { bindDataExplorerActions } from "~/store/data-explorer/data-explorer-action";
   8 import { dialogActions } from '~/store/dialog/dialog-actions';
   9 import { Person } from '~/views-components/sharing-dialog/people-select';
  10 import { RootState } from '~/store/store';
  11 import { ServiceRepository } from '~/services/services';
  12 import { getResource } from '~/store/resources/resources';
  13 import { GroupResource } 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, PermissionResource } from '~/models/permission';
  17 import { PermissionService } from '~/services/permission-service/permission-service';
  18
  19 export const GROUPS_PANEL_ID = "groupsPanel";
  20 export const CREATE_GROUP_DIALOG = "createGroupDialog";
  21 export const CREATE_GROUP_FORM = "createGroupForm";
  22 export const CREATE_GROUP_NAME_FIELD_NAME = 'name';
  23 export const CREATE_GROUP_USERS_FIELD_NAME = 'users';
  24 export const GROUP_ATTRIBUTES_DIALOG = 'groupAttributesDialog';
  25 export const GROUP_REMOVE_DIALOG = 'groupRemoveDialog';
  26 export const MEMBER_ATTRIBUTES_DIALOG = 'memberAttributesDialog';
  27 export const MEMBER_REMOVE_DIALOG = 'memberRemoveDialog';
  28
  29 export const GroupsPanelActions = bindDataExplorerActions(GROUPS_PANEL_ID);
  30
  31 export const loadGroupsPanel = () => GroupsPanelActions.REQUEST_ITEMS();
  32
  33 export const openCreateGroupDialog = () =>
  34     (dispatch: Dispatch) => {
  35         dispatch(dialogActions.OPEN_DIALOG({ id: CREATE_GROUP_DIALOG, data: {} }));
  36         dispatch(reset(CREATE_GROUP_FORM));
  37     };
  38
  39 export const openGroupAttributes = (uuid: string) =>
  40     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  41         const { resources } = getState();
  42         const data = getResource<GroupResource>(uuid)(resources);
  43         dispatch(dialogActions.OPEN_DIALOG({ id: GROUP_ATTRIBUTES_DIALOG, data }));
  44     };
  45
  46 export const openGroupMemberAttributes = (uuid: string) =>
  47     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  48         const { resources } = getState();
  49         const data = getResource<PermissionResource>(uuid)(resources);
  50         dispatch(dialogActions.OPEN_DIALOG({ id: MEMBER_ATTRIBUTES_DIALOG, data }));
  51     };
  52
  53 export const removeGroup = (uuid: string) =>
  54     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  55         dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Removing ...' }));
  56         await services.groupsService.delete(uuid);
  57         dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Removed.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
  58         dispatch<any>(loadGroupsPanel());
  59     };
  60
  61 export const openRemoveGroupDialog = (uuid: string) =>
  62     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  63         dispatch(dialogActions.OPEN_DIALOG({
  64             id: GROUP_REMOVE_DIALOG,
  65             data: {
  66                 title: 'Remove group',
  67                 text: 'Are you sure you want to remove this group?',
  68                 confirmButtonLabel: 'Remove',
  69                 uuid
  70             }
  71         }));
  72     };
  73
  74 export const removeGroupMember = (uuid: string) =>
  75     async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  76         dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Removing ...' }));
  77         await services.permissionService.delete(uuid);
  78         dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Removed.', hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
  79         dispatch<any>(loadGroupsPanel());
  80     };
  81
  82 export const openRemoveGroupMemberDialog = (uuid: string) =>
  83     (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
  84         dispatch(dialogActions.OPEN_DIALOG({
  85             id: MEMBER_REMOVE_DIALOG,
  86             data: {
  87                 title: 'Remove member',
  88                 text: 'Are you sure you want to remove this member from this group?',
  89                 confirmButtonLabel: 'Remove',
  90                 uuid
  91             }
  92         }));
  93     };
  94
  95 export interface CreateGroupFormData {
  96     [CREATE_GROUP_NAME_FIELD_NAME]: string;
  97     [CREATE_GROUP_USERS_FIELD_NAME]?: Person[];
  98 }
  99
 100 export const createGroup = ({ name, users = [] }: CreateGroupFormData) =>
 101     async (dispatch: Dispatch, _: {}, { groupsService, permissionService }: ServiceRepository) => {
 102
 103         dispatch(startSubmit(CREATE_GROUP_FORM));
 104
 105         try {
 106
 107             const newGroup = await groupsService.create({ name });
 108
 109             for (const user of users) {
 110
 111                 await addGroupMember({
 112                     user,
 113                     group: newGroup,
 114                     dispatch,
 115                     permissionService,
 116                 });
 117
 118             }
 119
 120             dispatch(dialogActions.CLOSE_DIALOG({ id: CREATE_GROUP_DIALOG }));
 121             dispatch(reset(CREATE_GROUP_FORM));
 122             dispatch(loadGroupsPanel());
 123             dispatch(snackbarActions.OPEN_SNACKBAR({
 124                 message: `${newGroup.name} group has been created`,
 125                 kind: SnackbarKind.SUCCESS
 126             }));
 127
 128             return newGroup;
 129
 130         } catch (e) {
 131
 132             const error = getCommonResourceServiceError(e);
 133             if (error === CommonResourceServiceError.UNIQUE_VIOLATION) {
 134                 dispatch(stopSubmit(CREATE_GROUP_FORM, { name: 'Group with the same name already exists.' } as FormErrors));
 135             }
 136
 137             return;
 138
 139         }
 140     };
 141
 142 interface AddGroupMemberArgs {
 143     user: { uuid: string, name: string };
 144     group: { uuid: string, name: string };
 145     dispatch: Dispatch;
 146     permissionService: PermissionService;
 147 }
 148
 149 export const addGroupMember = async ({ user, group, ...args }: AddGroupMemberArgs) => {
 150
 151
 152
 153     await createPermission({
 154         head: { ...group },
 155         tail: { ...user },
 156         permissionLevel: PermissionLevel.CAN_MANAGE,
 157         ...args,
 158     });
 159
 160     await createPermission({
 161         head: { ...user },
 162         tail: { ...group },
 163         permissionLevel: PermissionLevel.CAN_READ,
 164         ...args,
 165     });
 166
 167 };
 168
 169 interface CreatePermissionLinkArgs {
 170     head: { uuid: string, name: string };
 171     tail: { uuid: string, name: string };
 172     permissionLevel: PermissionLevel;
 173     dispatch: Dispatch;
 174     permissionService: PermissionService;
 175 }
 176
 177 const createPermission = async ({ head, tail, permissionLevel, dispatch, permissionService }: CreatePermissionLinkArgs) => {
 178
 179     try {
 180
 181         await permissionService.create({
 182             tailUuid: tail.uuid,
 183             headUuid: head.uuid,
 184             name: permissionLevel,
 185         });
 186
 187     } catch (e) {
 188
 189         dispatch(snackbarActions.OPEN_SNACKBAR({
 190             message: `Could not add ${tail.name} -> ${head.name} relation`,
 191             kind: SnackbarKind.ERROR,
 192         }));
 193
 194     }
 195
 196 };