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