1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
5 import { dialogActions } from "store/dialog/dialog-actions";
6 import { withDialog } from "store/dialog/with-dialog";
9 SHARING_INVITATION_FORM_NAME,
10 SharingManagementFormData,
11 SharingInvitationFormData,
12 getSharingMangementFormData,
13 SharingPublicAccessFormData,
15 SHARING_PUBLIC_ACCESS_FORM_NAME,
16 } from './sharing-dialog-types';
17 import { Dispatch } from 'redux';
18 import { ServiceRepository } from "services/services";
19 import { FilterBuilder } from 'services/api/filter-builder';
20 import { initialize, getFormValues, reset } from 'redux-form';
21 import { SHARING_MANAGEMENT_FORM_NAME } from 'store/sharing-dialog/sharing-dialog-types';
22 import { RootState } from 'store/store';
23 import { getDialog } from 'store/dialog/dialog-reducer';
24 import { PermissionLevel, PermissionResource } from 'models/permission';
25 import { differenceWith } from "lodash";
26 import { withProgress } from "store/progress-indicator/with-progress";
27 import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
28 import { snackbarActions, SnackbarKind } from "../snackbar/snackbar-actions";
30 extractUuidObjectType,
32 } from "models/resource";
33 import { resourcesActions } from "store/resources/resources-actions";
34 import { getPublicGroupUuid } from "store/workflow-panel/workflow-panel-actions";
35 import { getSharingPublicAccessFormData } from './sharing-dialog-types';
37 export const openSharingDialog = (resourceUuid: string, refresh?: () => void) =>
38 (dispatch: Dispatch) => {
39 dispatch(dialogActions.OPEN_DIALOG({ id: SHARING_DIALOG_NAME, data: {resourceUuid, refresh} }));
40 dispatch<any>(loadSharingDialog);
43 export const closeSharingDialog = () =>
44 dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME });
46 export const connectSharingDialog = withDialog(SHARING_DIALOG_NAME);
47 export const connectSharingDialogProgress = withProgress(SHARING_DIALOG_NAME);
50 export const saveSharingDialogChanges = async (dispatch: Dispatch, getState: () => RootState) => {
51 dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
52 await dispatch<any>(savePublicPermissionChanges);
53 await dispatch<any>(saveManagementChanges);
54 await dispatch<any>(sendInvitations);
55 dispatch(reset(SHARING_INVITATION_FORM_NAME));
56 await dispatch<any>(loadSharingDialog);
57 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
59 const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
60 if (dialog && dialog.data.refresh) {
61 dialog.data.refresh();
65 export interface SharingDialogData {
70 export const createSharingToken = (expDate: Date | undefined) => async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
71 const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
73 const resourceUuid = dialog.data.resourceUuid;
74 if (extractUuidObjectType(resourceUuid) === ResourceObjectType.COLLECTION) {
75 dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
77 const sharingToken = await apiClientAuthorizationService.createCollectionSharingToken(resourceUuid, expDate);
78 dispatch(resourcesActions.SET_RESOURCES([sharingToken]));
79 dispatch(snackbarActions.OPEN_SNACKBAR({
80 message: 'Sharing URL created',
82 kind: SnackbarKind.SUCCESS,
85 dispatch(snackbarActions.OPEN_SNACKBAR({
86 message: 'Failed to create sharing URL',
88 kind: SnackbarKind.ERROR,
91 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
97 export const deleteSharingToken = (uuid: string) => async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
98 dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
100 await apiClientAuthorizationService.delete(uuid);
101 dispatch(resourcesActions.DELETE_RESOURCES([uuid]));
102 dispatch(snackbarActions.OPEN_SNACKBAR({
103 message: 'Sharing URL removed',
105 kind: SnackbarKind.SUCCESS,
108 dispatch(snackbarActions.OPEN_SNACKBAR({
109 message: 'Failed to remove sharing URL',
111 kind: SnackbarKind.ERROR,
114 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
118 const loadSharingDialog = async (dispatch: Dispatch, getState: () => RootState, { apiClientAuthorizationService }: ServiceRepository) => {
120 const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
122 dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
124 const resourceUuid = dialog.data.resourceUuid;
125 await dispatch<any>(initializeManagementForm);
126 // For collections, we need to load the public sharing tokens
127 if (extractUuidObjectType(resourceUuid) === ResourceObjectType.COLLECTION) {
128 const sharingTokens = await apiClientAuthorizationService.listCollectionSharingTokens(resourceUuid);
129 dispatch(resourcesActions.SET_RESOURCES([...sharingTokens.items]));
132 dispatch(snackbarActions.OPEN_SNACKBAR({
133 message: 'You do not have access to share this item',
135 kind: SnackbarKind.ERROR }));
136 dispatch(dialogActions.CLOSE_DIALOG({ id: SHARING_DIALOG_NAME }));
138 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
143 export const initializeManagementForm = async (dispatch: Dispatch, getState: () => RootState, { userService, groupsService, permissionService }: ServiceRepository) => {
145 const dialog = getDialog<SharingDialogData>(getState().dialog, SHARING_DIALOG_NAME);
149 dispatch(progressIndicatorActions.START_WORKING(SHARING_DIALOG_NAME));
150 const resourceUuid = dialog?.data.resourceUuid;
151 const { items: permissionLinks } = await permissionService.listResourcePermissions(resourceUuid);
152 dispatch<any>(initializePublicAccessForm(permissionLinks));
153 const filters = new FilterBuilder()
154 .addIn('uuid', permissionLinks.map(({ tailUuid }) => tailUuid))
157 const { items: users } = await userService.list({ filters, count: "none" });
158 const { items: groups } = await groupsService.list({ filters, count: "none" });
160 const getEmail = (tailUuid: string) => {
161 const user = users.find(({ uuid }) => uuid === tailUuid);
162 const group = groups.find(({ uuid }) => uuid === tailUuid);
170 const managementPermissions = permissionLinks
172 item.tailUuid !== getPublicGroupUuid(getState()))
173 .map(({ tailUuid, name, uuid }) => ({
174 email: getEmail(tailUuid),
175 permissions: name as PermissionLevel,
176 permissionUuid: uuid,
179 const managementFormData: SharingManagementFormData = {
180 permissions: managementPermissions,
181 initialPermissions: managementPermissions,
184 dispatch(initialize(SHARING_MANAGEMENT_FORM_NAME, managementFormData));
185 dispatch(progressIndicatorActions.STOP_WORKING(SHARING_DIALOG_NAME));
188 const initializePublicAccessForm = (permissionLinks: PermissionResource[]) =>
189 (dispatch: Dispatch, getState: () => RootState, ) => {
190 const [publicPermission] = permissionLinks
191 .filter(item => item.tailUuid === getPublicGroupUuid(getState()));
192 const publicAccessFormData: SharingPublicAccessFormData = publicPermission
194 visibility: VisibilityLevel.PUBLIC,
195 permissionUuid: publicPermission.uuid,
198 visibility: permissionLinks.length > 0
199 ? VisibilityLevel.SHARED
200 : VisibilityLevel.PRIVATE,
203 dispatch(initialize(SHARING_PUBLIC_ACCESS_FORM_NAME, publicAccessFormData));
206 const savePublicPermissionChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
207 const state = getState();
208 const { user } = state.auth;
209 const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
210 if (dialog && user) {
211 const { permissionUuid, visibility } = getSharingPublicAccessFormData(state);
212 if (permissionUuid) {
213 if (visibility === VisibilityLevel.PUBLIC) {
214 await permissionService.update(permissionUuid, {
215 name: PermissionLevel.CAN_READ
218 await permissionService.delete(permissionUuid);
220 } else if (visibility === VisibilityLevel.PUBLIC) {
221 await permissionService.create({
222 ownerUuid: user.uuid,
223 headUuid: dialog.data.resourceUuid,
224 tailUuid: getPublicGroupUuid(state),
225 name: PermissionLevel.CAN_READ,
231 const saveManagementChanges = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
232 const state = getState();
233 const { user } = state.auth;
234 const dialog = getDialog<string>(state.dialog, SHARING_DIALOG_NAME);
235 if (dialog && user) {
236 const { initialPermissions, permissions } = getSharingMangementFormData(state);
237 const { visibility } = getSharingPublicAccessFormData(state);
238 const cancelledPermissions = visibility === VisibilityLevel.PRIVATE
243 (a, b) => a.permissionUuid === b.permissionUuid
246 const deletions = cancelledPermissions.map(({ permissionUuid }) =>
247 permissionService.delete(permissionUuid));
248 const updates = permissions.map(update =>
249 permissionService.update(update.permissionUuid, { name: update.permissions }));
250 await Promise.all([...deletions, ...updates]);
254 const sendInvitations = async (_: Dispatch, getState: () => RootState, { permissionService }: ServiceRepository) => {
255 const state = getState();
256 const { user } = state.auth;
257 const dialog = getDialog<SharingDialogData>(state.dialog, SHARING_DIALOG_NAME);
258 if (dialog && user) {
259 const invitations = getFormValues(SHARING_INVITATION_FORM_NAME)(state) as SharingInvitationFormData;
260 const data = invitations.invitedPeople.map(invitee => ({
261 ownerUuid: user.uuid,
262 headUuid: dialog.data.resourceUuid,
263 tailUuid: invitee.uuid,
264 name: invitations.permissions
266 const changes = data.map( invitation => permissionService.create(invitation));
267 await Promise.all(changes);