src/store/sharing-dialog/sharing-dialog-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { dialogActions } from "store/dialog/dialog-actions";
   6 import { withDialog } from "store/dialog/with-dialog";
   7 import { SHARING_DIALOG_NAME, SharingPublicAccessFormData, SHARING_PUBLIC_ACCESS_FORM_NAME, SHARING_INVITATION_FORM_NAME, SharingManagementFormData, SharingInvitationFormData, VisibilityLevel, getSharingMangementFormData, getSharingPublicAccessFormData } from './sharing-dialog-types';
   8 import { Dispatch } from 'redux';
   9 import { ServiceRepository } from "services/services";
  10 import { FilterBuilder } from 'services/api/filter-builder';
  11 import { initialize, getFormValues, reset } from 'redux-form';
  12 import { SHARING_MANAGEMENT_FORM_NAME } from 'store/sharing-dialog/sharing-dialog-types';
  13 import { RootState } from 'store/store';
  14 import { getDialog } from 'store/dialog/dialog-reducer';
  15 import { PermissionLevel } from 'models/permission';
  16 import { getPublicGroupUuid } from "store/workflow-panel/workflow-panel-actions";
  17 import { PermissionResource } from 'models/permission';
  18 import { differenceWith } from "lodash";
  19 import { withProgress } from "store/progress-indicator/with-progress";
  20 import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
  21 import { snackbarActions, SnackbarKind } from "../snackbar/snackbar-actions";
  22 import { extractUuidKind, ResourceKind } from "models/resource";
  23
  24 export const openSharingDialog = (resourceUuid: string, refresh?: () => void) =>
  25     (dispatch: Dispatch) => {
  26         dispatch(dialogActions.OPEN_DIALOG({ id: SHARING_DIALOG_NAME, data: {resourceUuid, refresh} }));
  27         dispatch<any>(loadSharingDialog);
  28     };
  29
  30 export const closeSharingDialog = () =>
  31     dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME });
  32
  33 export const connectSharingDialog = withDialog(SHARING_DIALOG_NAME);
  34 export const connectSharingDialogProgress = withProgress(SHARING_DIALOG_NAME);
  35
  36
  37 export const saveSharingDialogChanges = async (dispatch: Dispatch, getState: () => RootState) => {
  38     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  39     await dispatch<any>(savePublicPermissionChanges);
  40     await dispatch<any>(saveManagementChanges);
  41     await dispatch<any>(sendInvitations);
  42     dispatch(reset(SHARING_INVITATION_FORM_NAME));
  43     await dispatch<any>(loadSharingDialog);
  44
  45     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  46     if (dialog && dialog.data.refresh) {
  47         dialog.data.refresh();
  48     }
  49 };
  50
  51 export const sendSharingInvitations = async (dispatch: Dispatch, getState: () => RootState) => {
  52     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  53     await dispatch<any>(sendInvitations);
  54     dispatch(closeSharingDialog());
  55     dispatch(snackbarActions.OPEN_SNACKBAR({
  56         message: 'Resource has been shared',
  57         kind: SnackbarKind.SUCCESS,
  58     }));
  59     dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  60
  61     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  62     if (dialog && dialog.data.refresh) {
  63         dialog.data.refresh();
  64     }
  65 };
  66
  67 interface SharingDialogData {
  68     resourceUuid: string;
  69     refresh: () => void;
  70 }
  71
  72 const loadSharingDialog = async (dispatch: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
  73
  74     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  75     if (dialog) {
  76         dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  77         try {
  78             const { items } = await permissionService.listResourcePermissions(dialog.data.resourceUuid);
  79             dispatch<any>(initializePublicAccessForm(items));
  80             await dispatch<any>(initializeManagementForm(items));
  81             dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  82         } catch (e) {
  83             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'You do not have access to share this item', hideDuration: 2000, kind: SnackbarKind.ERROR }));
  84             dispatch(dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME }));
  85             dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  86         }
  87     }
  88 };
  89
  90 const initializeManagementForm = (permissionLinks: PermissionResource[]) =>
  91     async (dispatch: Dispatch, getState: () => RootState, { userService, groupsService }: ServiceRepository) => {
  92
  93         const filters = new FilterBuilder()
  94             .addIn('uuid', permissionLinks.map(({ tailUuid }) => tailUuid))
  95             .getFilters();
  96
  97         const { items: users } = await userService.list({ filters, count: "none" });
  98         const { items: groups } = await groupsService.list({ filters, count: "none" });
  99
 100         const getEmail = (tailUuid: string) => {
 101             const user = users.find(({ uuid }) => uuid === tailUuid);
 102             const group = groups.find(({ uuid }) => uuid === tailUuid);
 103             return user
 104                 ? user.email
 105                 : group
 106                     ? group.name
 107                     : tailUuid;
 108         };
 109
 110         const managementPermissions = permissionLinks
 111             .filter(item =>
 112                 item.tailUuid !== getPublicGroupUuid(getState()))
 113             .map(({ tailUuid, name, uuid }) => ({
 114                 email: getEmail(tailUuid),
 115                 permissions: name as PermissionLevel,
 116                 permissionUuid: uuid,
 117             }));
 118
 119         const managementFormData: SharingManagementFormData = {
 120             permissions: managementPermissions,
 121             initialPermissions: managementPermissions,
 122         };
 123
 124         dispatch(initialize(SHARING_MANAGEMENT_FORM_NAME, managementFormData));
 125     };
 126
 127 const initializePublicAccessForm = (permissionLinks: PermissionResource[]) =>
 128     (dispatch: Dispatch, getState: () => RootState, ) => {
 129
 130         const [publicPermission] = permissionLinks
 131             .filter(item => item.tailUuid === getPublicGroupUuid(getState()));
 132
 133         const publicAccessFormData: SharingPublicAccessFormData = publicPermission
 134             ? {
 135                 visibility: VisibilityLevel.PUBLIC,
 136                 permissionUuid: publicPermission.uuid,
 137             }
 138             : {
 139                 visibility: permissionLinks.length > 0
 140                     ? VisibilityLevel.SHARED
 141                     : VisibilityLevel.PRIVATE,
 142                 permissionUuid: '',
 143             };
 144
 145         dispatch(initialize(SHARING_PUBLIC_ACCESS_FORM_NAME, publicAccessFormData));
 146     };
 147
 148 const savePublicPermissionChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 149     const state = getState();
 150     const { user } = state.auth;
 151     const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
 152     if (dialog && user) {
 153         const { permissionUuid, visibility } = getSharingPublicAccessFormData(state);
 154
 155         if (permissionUuid) {
 156             if (visibility === VisibilityLevel.PUBLIC) {
 157                 await permissionService.update(permissionUuid, {
 158                     name: PermissionLevel.CAN_READ
 159                 });
 160             } else {
 161                 await permissionService.delete(permissionUuid);
 162             }
 163
 164         } else if (visibility === VisibilityLevel.PUBLIC) {
 165
 166             await permissionService.create({
 167                 ownerUuid: user.uuid,
 168                 headUuid: dialog.data.resourceUuid,
 169                 tailUuid: getPublicGroupUuid(state),
 170                 name: PermissionLevel.CAN_READ,
 171             });
 172         }
 173     }
 174 };
 175
 176 const saveManagementChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 177     const state = getState();
 178     const { user } = state.auth;
 179     const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
 180     if (dialog && user) {
 181
 182         const { initialPermissions, permissions } = getSharingMangementFormData(state);
 183         const { visibility } = getSharingPublicAccessFormData(state);
 184
 185
 186         if (visibility === VisibilityLevel.PRIVATE) {
 187
 188             for (const permission of initialPermissions) {
 189                 await permissionService.delete(permission.permissionUuid);
 190             }
 191
 192         } else {
 193
 194             const cancelledPermissions = differenceWith(
 195                 initialPermissions,
 196                 permissions,
 197                 (a, b) => a.permissionUuid === b.permissionUuid
 198             );
 199
 200             for (const { permissionUuid } of cancelledPermissions) {
 201                 await permissionService.delete(permissionUuid);
 202             }
 203
 204             for (const permission of permissions) {
 205                 await permissionService.update(permission.permissionUuid, { name: permission.permissions });
 206             }
 207
 208         }
 209     }
 210 };
 211
 212 const sendInvitations = async (_: Dispatch, getState: () => RootState, { permissionService, userService }: ServiceRepository) => {
 213     const state = getState();
 214     const { user } = state.auth;
 215     const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
 216     if (dialog && user) {
 217         const invitations = getFormValues(SHARING_INVITATION_FORM_NAME)(state) as SharingInvitationFormData;
 218
 219         const getGroupsFromForm = invitations.invitedPeople.filter((invitation) => extractUuidKind(invitation.uuid) === ResourceKind.GROUP);
 220         const getUsersFromForm = invitations.invitedPeople.filter((invitation) => extractUuidKind(invitation.uuid) === ResourceKind.USER);
 221
 222         const invitationDataUsers = getUsersFromForm
 223             .map(person => ({
 224                 ownerUuid: user.uuid,
 225                 headUuid: dialog.data.resourceUuid,
 226                 tailUuid: person.uuid,
 227                 name: invitations.permissions
 228             }));
 229
 230         const invitationsDataGroups = getGroupsFromForm.map(
 231             group => ({
 232                 ownerUuid: user.uuid,
 233                 headUuid: dialog.data.resourceUuid,
 234                 tailUuid: group.uuid,
 235                 name: invitations.permissions
 236             })
 237         );
 238
 239         const data = invitationDataUsers.concat(invitationsDataGroups);
 240
 241         for (const invitation of data) {
 242             await permissionService.create(invitation);
 243         }
 244     }
 245 };