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.ts';
  21
  22 export const openSharingDialog = (resourceUuid: string) =>
  23     (dispatch: Dispatch) => {
  24         dispatch(dialogActions.OPEN_DIALOG({ id: SHARING_DIALOG_NAME, data: resourceUuid }));
  25         dispatch<any>(loadSharingDialog);
  26     };
  27
  28 export const closeSharingDialog = () =>
  29     dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME });
  30
  31 export const connectSharingDialog = withDialog(SHARING_DIALOG_NAME);
  32 export const connectSharingDialogProgress = withProgress(SHARING_DIALOG_NAME);
  33
  34
  35 export const saveSharingDialogChanges = async (dispatch: Dispatch) => {
  36     dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  37     await dispatch<any>(savePublicPermissionChanges);
  38     await dispatch<any>(saveManagementChanges);
  39     await dispatch<any>(sendInvitations);
  40     dispatch(reset(SHARING_INVITATION_FORM_NAME));
  41     await dispatch<any>(loadSharingDialog);
  42 };
  43
  44 const loadSharingDialog = async (dispatch: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
  45
  46     const dialog = getDialog<string>(getState().dialog, SHARING_DIALOG_NAME);
  47
  48     if (dialog) {
  49         dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
  50         const { items } = await permissionService.listResourcePermissions(dialog.data);
  51         dispatch<any>(initializePublicAccessForm(items));
  52         await dispatch<any>(initializeManagementForm(items));
  53         dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
  54     }
  55 };
  56
  57 const initializeManagementForm = (permissionLinks: PermissionResource[]) =>
  58     async (dispatch: Dispatch, getState: () => RootState, { userService }: ServiceRepository) => {
  59
  60         const filters = new FilterBuilder()
  61             .addIn('uuid', permissionLinks.map(({ tailUuid }) => tailUuid))
  62             .getFilters();
  63
  64         const { items: users } = await userService.list({ filters });
  65
  66         const getEmail = (tailUuid: string) => {
  67             const user = users.find(({ uuid }) => uuid === tailUuid);
  68             return user
  69                 ? user.email
  70                 : tailUuid;
  71         };
  72
  73         const managementPermissions = permissionLinks
  74             .filter(item =>
  75                 item.tailUuid !== getPublicGroupUuid(getState()))
  76             .map(({ tailUuid, name, uuid }) => ({
  77                 email: getEmail(tailUuid),
  78                 permissions: name as PermissionLevel,
  79                 permissionUuid: uuid,
  80             }));
  81
  82         const managementFormData: SharingManagementFormData = {
  83             permissions: managementPermissions,
  84             initialPermissions: managementPermissions,
  85         };
  86
  87         dispatch(initialize(SHARING_MANAGEMENT_FORM_NAME, managementFormData));
  88     };
  89
  90 const initializePublicAccessForm = (permissionLinks: PermissionResource[]) =>
  91     (dispatch: Dispatch, getState: () => RootState, ) => {
  92
  93         const [publicPermission] = permissionLinks
  94             .filter(item => item.tailUuid === getPublicGroupUuid(getState()));
  95
  96         const publicAccessFormData: SharingPublicAccessFormData = publicPermission
  97             ? {
  98                 visibility: VisibilityLevel.PUBLIC,
  99                 permissionUuid: publicPermission.uuid,
 100             }
 101             : {
 102                 visibility: permissionLinks.length > 0
 103                     ? VisibilityLevel.SHARED
 104                     : VisibilityLevel.PRIVATE,
 105                 permissionUuid: '',
 106             };
 107
 108         dispatch(initialize(SHARING_PUBLIC_ACCESS_FORM_NAME, publicAccessFormData));
 109     };
 110
 111 const savePublicPermissionChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 112     const state = getState();
 113     const { user } = state.auth;
 114     const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
 115     if (dialog && user) {
 116         const { permissionUuid, visibility } = getSharingPublicAccessFormData(state);
 117
 118         if (permissionUuid) {
 119             if (visibility === VisibilityLevel.PUBLIC) {
 120                 await permissionService.update(permissionUuid, {
 121                     name: PermissionLevel.CAN_READ
 122                 });
 123             } else {
 124                 await permissionService.delete(permissionUuid);
 125             }
 126
 127         } else if (visibility === VisibilityLevel.PUBLIC) {
 128
 129             await permissionService.create({
 130                 ownerUuid: user.uuid,
 131                 headUuid: dialog.data,
 132                 tailUuid: getPublicGroupUuid(state),
 133                 name: PermissionLevel.CAN_READ,
 134             });
 135         }
 136     }
 137 };
 138
 139 const saveManagementChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 140     const state = getState();
 141     const { user } = state.auth;
 142     const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
 143     if (dialog && user) {
 144
 145         const { initialPermissions, permissions } = getSharingMangementFormData(state);
 146         const { visibility } = getSharingPublicAccessFormData(state);
 147
 148
 149         if (visibility === VisibilityLevel.PRIVATE) {
 150
 151             for (const permission of initialPermissions) {
 152                 await permissionService.delete(permission.permissionUuid);
 153             }
 154
 155         } else {
 156
 157             const cancelledPermissions = differenceWith(
 158                 initialPermissions,
 159                 permissions,
 160                 (a, b) => a.permissionUuid === b.permissionUuid
 161             );
 162
 163             for (const { permissionUuid } of cancelledPermissions) {
 164                 await permissionService.delete(permissionUuid);
 165             }
 166
 167             for (const permission of permissions) {
 168                 await permissionService.update(permission.permissionUuid, { name: permission.permissions });
 169             }
 170
 171         }
 172     }
 173 };
 174
 175 const sendInvitations = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
 176     const state = getState();
 177     const { user } = state.auth;
 178     const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
 179     if (dialog && user) {
 180
 181         const invitations = getFormValues(SHARING_INVITATION_FORM_NAME)(state) as SharingInvitationFormData;
 182
 183         const invitationData = invitations.invitedPeople
 184             .map(person => ({
 185                 ownerUuid: user.uuid,
 186                 headUuid: dialog.data,
 187                 tailUuid: person.uuid,
 188                 name: invitations.permissions
 189             }));
 190
 191         for (const invitation of invitationData) {
 192             await permissionService.create(invitation);
 193         }
 194
 195     }
 196 };