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 {
   8     SHARING_DIALOG_NAME,
   9     SHARING_INVITATION_FORM_NAME,
  10     SharingManagementFormData,
  11     SharingInvitationFormData,
  12     getSharingMangementFormData,
  13 } from './sharing-dialog-types';
  14 import { Dispatch } from 'redux';
  15 import { ServiceRepository } from "services/services";
  16 import { FilterBuilder } from 'services/api/filter-builder';
  17 import { initialize, getFormValues, reset } from 'redux-form';
  18 import { SHARING_MANAGEMENT_FORM_NAME } from 'store/sharing-dialog/sharing-dialog-types';
  19 import { RootState } from 'store/store';
  20 import { getDialog } from 'store/dialog/dialog-reducer';
  21 import { PermissionLevel } from 'models/permission';
  22 import { differenceWith } from "lodash";
  23 import { withProgress } from "store/progress-indicator/with-progress";
  24 import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
  25 import { snackbarActions, SnackbarKind } from "../snackbar/snackbar-actions";
  26 import {
  27     extractUuidObjectType,
  28     ResourceObjectType
  29 } from "models/resource";
  30 import { resourcesActions } from "store/resources/resources-actions";
  31
  32 export const openSharingDialog = (resourceUuid: string, refresh?: () => void) =>
  33     (dispatch: Dispatch) => {
  34         dispatch(dialogActions.OPEN_DIALOG({ id: SHARING_DIALOG_NAME, data: {resourceUuid, refresh} }));
  35         dispatch<any>(loadSharingDialog);
  36     };
  37
  38 export const closeSharingDialog = () =>
  39     dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME });
  40
  41 export const connectSharingDialog = withDialog(SHARING_DIALOG_NAME);
  42 export const connectSharingDialogProgress = withProgress(SHARING_DIALOG_NAME);
  43
  44
  45 export const saveSharingDialogChanges = async (dispatch: Dispatch, getState: () => RootState) => {
  46     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  47     await dispatch<any>(saveManagementChanges);
  48     await dispatch<any>(sendInvitations);
  49     dispatch(reset(SHARING_INVITATION_FORM_NAME));
  50     await dispatch<any>(loadSharingDialog);
  51     dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  52
  53     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  54     if (dialog && dialog.data.refresh) {
  55         dialog.data.refresh();
  56     }
  57 };
  58
  59 export interface SharingDialogData {
  60     resourceUuid: string;
  61     refresh: () => void;
  62 }
  63
  64 export const createSharingToken = async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
  65     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
  66     if (dialog) {
  67         const resourceUuid = dialog.data.resourceUuid;
  68         if (extractUuidObjectType(resourceUuid) === ResourceObjectType.COLLECTION) {
  69             dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  70             try {
  71                 const sharingToken = await apiClientAuthorizationService.createCollectionSharingToken(resourceUuid);
  72                 dispatch(resourcesActions.SET_RESOURCES([sharingToken]));
  73                 dispatch(snackbarActions.OPEN_SNACKBAR({
  74                     message: 'Sharing URL created',
  75                     hideDuration: 2000,
  76                     kind: SnackbarKind.SUCCESS,
  77                 }));
  78             } catch (e) {
  79                 dispatch(snackbarActions.OPEN_SNACKBAR({
  80                     message: 'Failed to create sharing URL',
  81                     hideDuration: 2000,
  82                     kind: SnackbarKind.ERROR,
  83                 }));
  84             } finally {
  85                 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  86             }
  87         }
  88     }
  89 };
  90
  91 export const deleteSharingToken = (uuid: string) => async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
  92     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  93     try {
  94         await apiClientAuthorizationService.delete(uuid);
  95         dispatch(resourcesActions.DELETE_RESOURCES([uuid]));
  96         dispatch(snackbarActions.OPEN_SNACKBAR({
  97             message: 'Sharing URL removed',
  98             hideDuration: 2000,
  99             kind: SnackbarKind.SUCCESS,
 100         }));
 101     } catch (e) {
 102         dispatch(snackbarActions.OPEN_SNACKBAR({
 103             message: 'Failed to remove sharing URL',
 104             hideDuration: 2000,
 105             kind: SnackbarKind.ERROR,
 106         }));
 107     } finally {
 108         dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
 109     }
 110 };
 111
 112 const loadSharingDialog = async (dispatch: Dispatch, getState: () => RootState, { permissionService, apiClientAuthorizationService }: ServiceRepository) => {
 113
 114     const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
 115     if (dialog) {
 116         dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
 117         try {
 118             const resourceUuid = dialog.data.resourceUuid;
 119             await dispatch<any>(initializeManagementForm);
 120             // For collections, we need to load the public sharing tokens
 121             if (extractUuidObjectType(resourceUuid) === ResourceObjectType.COLLECTION) {
 122                 const sharingTokens = await apiClientAuthorizationService.listCollectionSharingTokens(resourceUuid);
 123                 dispatch(resourcesActions.SET_RESOURCES([...sharingTokens.items]));
 124             }
 125         } catch (e) {
 126             dispatch(snackbarActions.OPEN_SNACKBAR({
 127                 message: 'You do not have access to share this item',
 128                 hideDuration: 2000,
 129                 kind: SnackbarKind.ERROR }));
 130             dispatch(dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME }));
 131         } finally {
 132             dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
 133         }
 134     }
 135 };
 136
 137 export const initializeManagementForm = async (dispatch: Dispatch, getState: () => RootState, { userService, groupsService, permissionService }: ServiceRepository) => {
 138
 139         const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
 140         if (!dialog) {
 141             return;
 142         }
 143         dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
 144         const resourceUuid = dialog?.data.resourceUuid;
 145         const { items: permissionLinks } = await permissionService.listResourcePermissions(resourceUuid);
 146         const filters = new FilterBuilder()
 147             .addIn('uuid', permissionLinks.map(({ tailUuid }) => tailUuid))
 148             .getFilters();
 149
 150         const { items: users } = await userService.list({ filters, count: "none" });
 151         const { items: groups } = await groupsService.list({ filters, count: "none" });
 152
 153         const getEmail = (tailUuid: string) => {
 154             const user = users.find(({ uuid }) => uuid === tailUuid);
 155             const group = groups.find(({ uuid }) => uuid === tailUuid);
 156             return user
 157                 ? user.email
 158                 : group
 159                     ? group.name
 160                     : tailUuid;
 161         };
 162
 163         const managementPermissions = permissionLinks
 164             .map(({ tailUuid, name, uuid }) => ({
 165                 email: getEmail(tailUuid),
 166                 permissions: name as PermissionLevel,
 167                 permissionUuid: uuid,
 168             }));
 169
 170         const managementFormData: SharingManagementFormData = {
 171             permissions: managementPermissions,
 172             initialPermissions: managementPermissions,
 173         };
 174
 175         dispatch(initialize(SHARING_MANAGEMENT_FORM_NAME, managementFormData));
 176         dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
 177     };
 178
 179 const saveManagementChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 180     const state = getState();
 181     const { user } = state.auth;
 182     const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
 183     if (dialog && user) {
 184         const { initialPermissions, permissions } = getSharingMangementFormData(state);
 185         const cancelledPermissions = differenceWith(
 186             initialPermissions,
 187             permissions,
 188             (a, b) => a.permissionUuid === b.permissionUuid
 189         );
 190
 191         const deletions = cancelledPermissions.map(({ permissionUuid }) =>
 192             permissionService.delete(permissionUuid));
 193         const updates = permissions.map(update =>
 194             permissionService.update(update.permissionUuid, { name: update.permissions }));
 195         await Promise.all([...deletions, ...updates]);
 196     }
 197 };
 198
 199 const sendInvitations = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 200     const state = getState();
 201     const { user } = state.auth;
 202     const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
 203     if (dialog && user) {
 204         const invitations = getFormValues(SHARING_INVITATION_FORM_NAME)(state) as SharingInvitationFormData;
 205         const data = invitations.invitedPeople.map(invitee => ({
 206             ownerUuid: user.uuid,
 207             headUuid: dialog.data.resourceUuid,
 208             tailUuid: invitee.uuid,
 209             name: invitations.permissions
 210         }));
 211         const changes = data.map( invitation => permissionService.create(invitation));
 212         await Promise.all(changes);
 213     }
 214 };