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