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, extractUuidObjectType, ResourceKind, ResourceObjectType } from "models/resource";
  23 import { ApiClientAuthorizationService } from "services/api-client-authorization-service/api-client-authorization-service";
  24 import { resourcesActions } from "store/resources/resources-actions";
  25
  26 export const openSharingDialog = (resourceUuid: string, refresh?: () => void) =>
  27     (dispatch: Dispatch) => {
  28         dispatch(dialogActions.OPEN_DIALOG({ id: SHARING_DIALOG_NAME, data: {resourceUuid, refresh} }));
  29         dispatch<any>(loadSharingDialog);
  30     };
  31
  32 export const closeSharingDialog = () =>
  33     dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME });
  34
  35 export const connectSharingDialog = withDialog(SHARING_DIALOG_NAME);
  36 export const connectSharingDialogProgress = withProgress(SHARING_DIALOG_NAME);
  37
  38
  39 export const saveSharingDialogChanges = async (dispatch: Dispatch, getState: () => RootState) => {
  40     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  41     await dispatch<any>(savePublicPermissionChanges);
  42     await dispatch<any>(saveManagementChanges);
  43     await dispatch<any>(sendInvitations);
  44     dispatch(reset(SHARING_INVITATION_FORM_NAME));
  45     await dispatch<any>(loadSharingDialog);
  46     dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  47
  48     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  49     if (dialog && dialog.data.refresh) {
  50         dialog.data.refresh();
  51     }
  52 };
  53
  54 export const sendSharingInvitations = async (dispatch: Dispatch, getState: () => RootState) => {
  55     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  56     await dispatch<any>(sendInvitations);
  57     dispatch(closeSharingDialog());
  58     dispatch(snackbarActions.OPEN_SNACKBAR({
  59         message: 'Resource has been shared',
  60         kind: SnackbarKind.SUCCESS,
  61     }));
  62     dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  63
  64     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  65     if (dialog && dialog.data.refresh) {
  66         dialog.data.refresh();
  67     }
  68 };
  69
  70 export interface SharingDialogData {
  71     resourceUuid: string;
  72     refresh: () => void;
  73 }
  74
  75 export const createSharingToken = async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
  76     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  77     if (dialog) {
  78         const resourceUuid = dialog.data.resourceUuid;
  79         if (extractUuidObjectType(resourceUuid) === ResourceObjectType.COLLECTION) {
  80             dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  81             try {
  82                 const sharingToken = await apiClientAuthorizationService.createCollectionSharingToken(resourceUuid);
  83                 dispatch(resourcesActions.SET_RESOURCES([sharingToken]));
  84                 dispatch(snackbarActions.OPEN_SNACKBAR({
  85                     message: 'Sharing URL created',
  86                     hideDuration: 2000,
  87                     kind: SnackbarKind.SUCCESS,
  88                 }));
  89             } catch (e) {
  90                 dispatch(snackbarActions.OPEN_SNACKBAR({
  91                     message: 'Failed to create sharing URL',
  92                     hideDuration: 2000,
  93                     kind: SnackbarKind.ERROR,
  94                 }));
  95             } finally {
  96                 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  97             }
  98         }
  99     }
 100 };
 101
 102 export const deleteSharingToken = (uuid: string) => async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
 103     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
 104     try {
 105         await apiClientAuthorizationService.delete(uuid);
 106         dispatch(resourcesActions.DELETE_RESOURCES([uuid]));
 107         dispatch(snackbarActions.OPEN_SNACKBAR({
 108             message: 'Sharing URL removed',
 109             hideDuration: 2000,
 110             kind: SnackbarKind.SUCCESS,
 111         }));
 112     } catch (e) {
 113         dispatch(snackbarActions.OPEN_SNACKBAR({
 114             message: 'Failed to remove sharing URL',
 115             hideDuration: 2000,
 116             kind: SnackbarKind.ERROR,
 117         }));
 118     } finally {
 119         dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
 120     }
 121 };
 122
 123 const loadSharingDialog = async (dispatch: Dispatch, getState: () => RootState, { permissionService, apiClientAuthorizationService }: ServiceRepository) => {
 124
 125     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
 126     if (dialog) {
 127         dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
 128         try {
 129             const resourceUuid = dialog.data.resourceUuid;
 130             const { items } = await permissionService.listResourcePermissions(resourceUuid);
 131             dispatch<any>(initializePublicAccessForm(items));
 132             await dispatch<any>(initializeManagementForm(items));
 133             // For collections, we need to load the public sharing tokens
 134             if (extractUuidObjectType(resourceUuid) === ResourceObjectType.COLLECTION) {
 135                 const sharingTokens = await apiClientAuthorizationService.listCollectionSharingTokens(resourceUuid);
 136                 dispatch(resourcesActions.SET_RESOURCES([...sharingTokens.items]));
 137             }
 138         } catch (e) {
 139             dispatch(snackbarActions.OPEN_SNACKBAR({
 140                 message: 'You do not have access to share this item',
 141                 hideDuration: 2000,
 142                 kind: SnackbarKind.ERROR }));
 143             dispatch(dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME }));
 144         } finally {
 145             dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
 146         }
 147     }
 148 };
 149
 150 const initializeManagementForm = (permissionLinks: PermissionResource[]) =>
 151     async (dispatch: Dispatch, getState: () => RootState, { userService, groupsService }: ServiceRepository) => {
 152
 153         const filters = new FilterBuilder()
 154             .addIn('uuid', permissionLinks.map(({ tailUuid }) => tailUuid))
 155             .getFilters();
 156
 157         const { items: users } = await userService.list({ filters, count: "none" });
 158         const { items: groups } = await groupsService.list({ filters, count: "none" });
 159
 160         const getEmail = (tailUuid: string) => {
 161             const user = users.find(({ uuid }) => uuid === tailUuid);
 162             const group = groups.find(({ uuid }) => uuid === tailUuid);
 163             return user
 164                 ? user.email
 165                 : group
 166                     ? group.name
 167                     : tailUuid;
 168         };
 169
 170         const managementPermissions = permissionLinks
 171             .filter(item =>
 172                 item.tailUuid !== getPublicGroupUuid(getState()))
 173             .map(({ tailUuid, name, uuid }) => ({
 174                 email: getEmail(tailUuid),
 175                 permissions: name as PermissionLevel,
 176                 permissionUuid: uuid,
 177             }));
 178
 179         const managementFormData: SharingManagementFormData = {
 180             permissions: managementPermissions,
 181             initialPermissions: managementPermissions,
 182         };
 183
 184         dispatch(initialize(SHARING_MANAGEMENT_FORM_NAME, managementFormData));
 185     };
 186
 187 const initializePublicAccessForm = (permissionLinks: PermissionResource[]) =>
 188     (dispatch: Dispatch, getState: () => RootState, ) => {
 189
 190         const [publicPermission] = permissionLinks
 191             .filter(item => item.tailUuid === getPublicGroupUuid(getState()));
 192
 193         const publicAccessFormData: SharingPublicAccessFormData = publicPermission
 194             ? {
 195                 visibility: VisibilityLevel.PUBLIC,
 196                 permissionUuid: publicPermission.uuid,
 197             }
 198             : {
 199                 visibility: permissionLinks.length > 0
 200                     ? VisibilityLevel.SHARED
 201                     : VisibilityLevel.PRIVATE,
 202                 permissionUuid: '',
 203             };
 204
 205         dispatch(initialize(SHARING_PUBLIC_ACCESS_FORM_NAME, publicAccessFormData));
 206     };
 207
 208 const savePublicPermissionChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 209     const state = getState();
 210     const { user } = state.auth;
 211     const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
 212     if (dialog && user) {
 213         const { permissionUuid, visibility } = getSharingPublicAccessFormData(state);
 214
 215         if (permissionUuid) {
 216             if (visibility === VisibilityLevel.PUBLIC) {
 217                 await permissionService.update(permissionUuid, {
 218                     name: PermissionLevel.CAN_READ
 219                 });
 220             } else {
 221                 await permissionService.delete(permissionUuid);
 222             }
 223
 224         } else if (visibility === VisibilityLevel.PUBLIC) {
 225
 226             await permissionService.create({
 227                 ownerUuid: user.uuid,
 228                 headUuid: dialog.data.resourceUuid,
 229                 tailUuid: getPublicGroupUuid(state),
 230                 name: PermissionLevel.CAN_READ,
 231             });
 232         }
 233     }
 234 };
 235
 236 const saveManagementChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 237     const state = getState();
 238     const { user } = state.auth;
 239     const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
 240     if (dialog && user) {
 241         const { initialPermissions, permissions } = getSharingMangementFormData(state);
 242         const { visibility } = getSharingPublicAccessFormData(state);
 243
 244         if (visibility === VisibilityLevel.PRIVATE) {
 245             for (const permission of initialPermissions) {
 246                 await permissionService.delete(permission.permissionUuid);
 247             }
 248         } else {
 249             const cancelledPermissions = differenceWith(
 250                 initialPermissions,
 251                 permissions,
 252                 (a, b) => a.permissionUuid === b.permissionUuid
 253             );
 254
 255             for (const { permissionUuid } of cancelledPermissions) {
 256                 await permissionService.delete(permissionUuid);
 257             }
 258
 259             for (const permission of permissions) {
 260                 await permissionService.update(permission.permissionUuid, { name: permission.permissions });
 261             }
 262         }
 263     }
 264 };
 265
 266 const sendInvitations = async (_: Dispatch, getState: () => RootState, { permissionService, userService }: ServiceRepository) => {
 267     const state = getState();
 268     const { user } = state.auth;
 269     const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
 270     if (dialog && user) {
 271         const invitations = getFormValues(SHARING_INVITATION_FORM_NAME)(state) as SharingInvitationFormData;
 272
 273         const getGroupsFromForm = invitations.invitedPeople.filter((invitation) => extractUuidKind(invitation.uuid) === ResourceKind.GROUP);
 274         const getUsersFromForm = invitations.invitedPeople.filter((invitation) => extractUuidKind(invitation.uuid) === ResourceKind.USER);
 275
 276         const invitationDataUsers = getUsersFromForm
 277             .map(person => ({
 278                 ownerUuid: user.uuid,
 279                 headUuid: dialog.data.resourceUuid,
 280                 tailUuid: person.uuid,
 281                 name: invitations.permissions
 282             }));
 283
 284         const invitationsDataGroups = getGroupsFromForm.map(
 285             group => ({
 286                 ownerUuid: user.uuid,
 287                 headUuid: dialog.data.resourceUuid,
 288                 tailUuid: group.uuid,
 289                 name: invitations.permissions
 290             })
 291         );
 292
 293         const data = invitationDataUsers.concat(invitationsDataGroups);
 294
 295         for (const invitation of data) {
 296             await permissionService.create(invitation);
 297         }
 298     }
 299 };