cozy-sharing 30.3.0 → 31.0.0

package/dist/components/SharedDrive/useSharedDrive.spec.js

@@ -0,0 +1,252 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useSharedDrive } from './useSharedDrive';
+var mockShowAlert = jest.fn();
+var mockCreateSharedDrive = jest.fn();
+var mockCollection = jest.fn(function () {
+  return {
+    createSharedDrive: mockCreateSharedDrive
+  };
+});
+var mockT = jest.fn(function (key) {
+  return key;
+});
+jest.mock('cozy-client', function () {
+  return {
+    useClient: jest.fn(function () {
+      return {
+        collection: mockCollection
+      };
+    }),
+    models: {
+      contact: {
+        getPrimaryEmail: jest.fn(function (r) {
+          return Array.isArray(r.email) && r.email[0] ? r.email[0].address : '';
+        }),
+        getDisplayName: jest.fn(function (r) {
+          return r.displayName || r.name || '';
+        })
+      }
+    }
+  };
+});
+jest.mock('cozy-ui/transpiled/react/providers/Alert', function () {
+  return {
+    useAlert: jest.fn(function () {
+      return {
+        showAlert: mockShowAlert
+      };
+    })
+  };
+});
+jest.mock('twake-i18n', function () {
+  return {
+    useI18n: jest.fn(function () {
+      return {
+        t: mockT
+      };
+    })
+  };
+});
+jest.mock('../../models', function () {
+  return {
+    Contact: {
+      doctype: 'io.cozy.contacts'
+    }
+  };
+});
+describe('useSharedDrive', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('returns empty initial state', function () {
+    var _renderHook = renderHook(function () {
+      return useSharedDrive({
+        onSuccess: jest.fn()
+      });
+    }),
+        result = _renderHook.result;
+
+    expect(result.current.sharedDriveName).toBe('');
+    expect(result.current.recipients).toEqual([]);
+  });
+  it('handleSharedDriveNameChange updates the name', function () {
+    var _renderHook2 = renderHook(function () {
+      return useSharedDrive({
+        onSuccess: jest.fn()
+      });
+    }),
+        result = _renderHook2.result;
+
+    act(function () {
+      result.current.handleSharedDriveNameChange({
+        target: {
+          value: 'My Drive'
+        }
+      });
+    });
+    expect(result.current.sharedDriveName).toBe('My Drive');
+  });
+  it('onRevoke removes a recipient from both lists', function () {
+    var _renderHook3 = renderHook(function () {
+      return useSharedDrive({
+        onSuccess: jest.fn()
+      });
+    }),
+        result = _renderHook3.result;
+
+    act(function () {
+      result.current.onShare({
+        recipients: [{
+          _id: 'abc',
+          displayName: 'Alice',
+          email: []
+        }],
+        readOnlyRecipients: []
+      });
+    });
+    act(function () {
+      result.current.onRevoke("virtual-shared-drive-sharing-abc");
+    });
+    expect(result.current.recipients).toHaveLength(0);
+  });
+  it('onSetType moves a recipient to read-only', function () {
+    var _renderHook4 = renderHook(function () {
+      return useSharedDrive({
+        onSuccess: jest.fn()
+      });
+    }),
+        result = _renderHook4.result;
+
+    act(function () {
+      result.current.onShare({
+        recipients: [{
+          _id: 'abc',
+          displayName: 'Alice',
+          email: []
+        }],
+        readOnlyRecipients: []
+      });
+    });
+    act(function () {
+      result.current.onSetType("virtual-shared-drive-sharing-abc", 'one-way');
+    });
+    expect(result.current.recipients[0].type).toBe('one-way');
+  });
+  it('onSetType moves a recipient to read-write', function () {
+    var _renderHook5 = renderHook(function () {
+      return useSharedDrive({
+        onSuccess: jest.fn()
+      });
+    }),
+        result = _renderHook5.result;
+
+    act(function () {
+      result.current.onShare({
+        recipients: [],
+        readOnlyRecipients: [{
+          _id: 'xyz',
+          displayName: 'Bob',
+          email: []
+        }]
+      });
+    });
+    act(function () {
+      result.current.onSetType("virtual-shared-drive-sharing-xyz", 'two-way');
+    });
+    expect(result.current.recipients).toHaveLength(1);
+    expect(result.current.recipients[0].type).toBe('two-way');
+  });
+  it('onCreate calls createSharedDrive, showAlert with success, and onSuccess', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var onSuccess, _renderHook6, result;
+
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          onSuccess = jest.fn();
+          mockCreateSharedDrive.mockResolvedValue({});
+          _renderHook6 = renderHook(function () {
+            return useSharedDrive({
+              onSuccess: onSuccess
+            });
+          }), result = _renderHook6.result;
+          act(function () {
+            result.current.handleSharedDriveNameChange({
+              target: {
+                value: 'My Drive'
+              }
+            });
+          });
+          _context2.next = 6;
+          return act( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return result.current.onCreate();
+
+                case 2:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+
+        case 6:
+          expect(mockCreateSharedDrive).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'My Drive',
+            description: 'My Drive'
+          }));
+          expect(mockShowAlert).toHaveBeenCalledWith(expect.objectContaining({
+            severity: 'success'
+          }));
+          expect(onSuccess).toHaveBeenCalledTimes(1);
+
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('onCreate shows error alert and does not call onSuccess on failure', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var onSuccess, _renderHook7, result;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          onSuccess = jest.fn();
+          mockCreateSharedDrive.mockRejectedValue(new Error('network error'));
+          _renderHook7 = renderHook(function () {
+            return useSharedDrive({
+              onSuccess: onSuccess
+            });
+          }), result = _renderHook7.result;
+          _context4.next = 5;
+          return act( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 2;
+                  return result.current.onCreate();
+
+                case 2:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+
+        case 5:
+          expect(mockShowAlert).toHaveBeenCalledWith(expect.objectContaining({
+            severity: 'error'
+          }));
+          expect(onSuccess).not.toHaveBeenCalled();
+
+        case 7:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+});

package/dist/index.js

@@ -16,6 +16,7 @@ export { default as OwnerRecipientDefaultLite } from './components/Recipient/Own
 export { SharedRecipientsList } from './SharedRecipientsList';
 export { ShareButton } from './ShareButton';
 export { SharedDriveModal } from './components/SharedDrive/SharedDriveModal';
+export { SharedDriveForm } from './components/SharedDrive/SharedDriveForm';
 export { FederatedFolderModal } from './components/FederatedFolder/FederatedFolderModal';
 export { ShareModal } from './components/ShareModal/ShareModal';
 export { RefreshableSharings } from './RefreshableSharings';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "30.3.0",
+  "version": "31.0.0",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -54,7 +54,7 @@
     "babel-jest": "30.3.0",
     "babel-plugin-css-modules-transform": "1.6.2",
     "babel-plugin-inline-react-svg": "1.1.2",
-    "cozy-client": "^60.22.0",
+    "cozy-client": "^60.24.0",
     "cozy-device-helper": "^3.7.1",
     "cozy-intent": "^2.31.1",
     "cozy-minilog": "^3.10.1",
@@ -69,7 +69,7 @@
     "twake-i18n": "^0.4.1"
   },
   "peerDependencies": {
-    "cozy-client": ">=60.22.0",
+    "cozy-client": ">=60.24.0",
     "cozy-device-helper": ">=3.7.1",
     "cozy-flags": ">=4.8.1",
     "cozy-intent": ">=2.29.1",
@@ -84,5 +84,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "8b1c0aece9584d82862592b6ab6e5579fa30be19"
+  "gitHead": "435fe26df7f273dda07330473eb1f638f0f1277a"
 }

package/src/components/ShareModal/EditableSharingModal.jsx

@@ -21,7 +21,6 @@ export const EditableSharingModal = ({ document, ...rest }) => {
     hasSharedChild,
     hasSharedParent,
     isOwner,
-    isSharedDrive,
     revoke,
     revokeSelf,
     share
@@ -35,7 +34,6 @@ export const EditableSharingModal = ({ document, ...rest }) => {
       hasSharedChild={documentPath && hasSharedChild(documentPath)}
       hasSharedParent={documentPath && hasSharedParent(documentPath)}
       isOwner={isOwner(document._id)}
-      isSharedDrive={isSharedDrive(document._id)}
       link={getSharingLink(document._id)}
       onRevoke={revoke}
       onRevokeSelf={revokeSelf}

package/src/components/ShareModal.jsx

@@ -5,7 +5,6 @@ import flag from 'cozy-flags'
 
 import ShareDialogCozyToCozy from './ShareDialogCozyToCozy'
 import ShareDialogOnlyByLink from './ShareDialogOnlyByLink'
-import { SharedDriveEditModal } from './SharedDrive/SharedDriveEditModal'
 
 export const ShareModal = ({
   autoOpenShareRestriction,
@@ -15,7 +14,6 @@ export const ShareModal = ({
   hasSharedChild,
   hasSharedParent,
   isOwner,
-  isSharedDrive,
   link,
   onClose,
   onRevoke,
@@ -28,21 +26,6 @@ export const ShareModal = ({
   showGenerateLinkButton,
   twoStepsConfirmationMethods
 }) => {
-  if (isSharedDrive && !flag('drive.federated-shared-folder.enabled')) {
-    return (
-      <SharedDriveEditModal
-        document={document}
-        sharing={sharing}
-        recipients={recipients}
-        onShare={onShare}
-        onRevoke={onRevoke}
-        onClose={onClose}
-        autoOpenShareRestriction={autoOpenShareRestriction}
-        showGenerateLinkButton={showGenerateLinkButton}
-      />
-    )
-  }
-
   const shareDialogOnlyByLink =
     flag('cozy.hide-sharing-cozy-to-cozy') || documentType === 'Albums'
 

package/src/components/SharedDrive/SharedDriveForm.jsx

@@ -0,0 +1,81 @@
+import PropTypes from 'prop-types'
+import React from 'react'
+
+import Button from 'cozy-ui/transpiled/react/Buttons'
+import TextField from 'cozy-ui/transpiled/react/TextField'
+import Typography from 'cozy-ui/transpiled/react/Typography'
+import { useI18n } from 'twake-i18n'
+
+import withLocales from '../../hoc/withLocales'
+import { default as DumbShareByEmail } from '../ShareByEmail'
+import WhoHasAccess from '../WhoHasAccess'
+import { useSharedDrive } from './useSharedDrive'
+
+export const SharedDriveForm = withLocales(({ onSuccess, onCancel }) => {
+  const { t } = useI18n()
+  const {
+    sharedDriveName,
+    recipients,
+    handleSharedDriveNameChange,
+    onShare,
+    onCreate,
+    onSetType,
+    onRevoke,
+    createContact
+  } = useSharedDrive({ onSuccess })
+
+  return (
+    <div>
+      <div className="u-ph-2">
+        <TextField
+          required
+          label={t('SharedDrive.sharedDriveModal.nameLabel')}
+          variant="outlined"
+          size="small"
+          className="u-w-100 u-mt-1-half"
+          value={sharedDriveName}
+          onChange={handleSharedDriveNameChange}
+        />
+        <Typography variant="h6" className="u-mt-1-half u-mb-half">
+          {t('SharedDrive.sharedDriveModal.addPeople')}
+        </Typography>
+        <DumbShareByEmail
+          createContact={createContact}
+          currentRecipients={recipients}
+          documentType="Files"
+          sharedDrive
+          onShare={onShare}
+          submitLabel={t('SharedDrive.sharedDriveModal.add')}
+          showNotifications={false}
+          sharingDesc=""
+        />
+      </div>
+      <WhoHasAccess
+        isOwner
+        isSharedDrive
+        recipients={recipients}
+        documentType="Files"
+        className="u-w-100"
+        onRevoke={onRevoke}
+        onSetType={onSetType}
+      />
+      <div className="u-flex u-flex-justify-end u-ph-2 u-pv-1 u-column-gap-half">
+        <Button
+          variant="secondary"
+          label={t('SharedDrive.sharedDriveModal.cancel')}
+          onClick={onCancel}
+        />
+        <Button
+          variant="primary"
+          label={t('SharedDrive.sharedDriveModal.create')}
+          onClick={onCreate}
+        />
+      </div>
+    </div>
+  )
+})
+
+SharedDriveForm.propTypes = {
+  onSuccess: PropTypes.func.isRequired,
+  onCancel: PropTypes.func.isRequired
+}

package/src/components/SharedDrive/SharedDriveModal.jsx

@@ -1,141 +1,25 @@
 import PropTypes from 'prop-types'
-import React, { useState } from 'react'
+import React from 'react'
 
-import { useClient } from 'cozy-client'
-import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert'
+import { FixedDialog } from 'cozy-ui/transpiled/react/CozyDialogs'
 import { useI18n } from 'twake-i18n'
 
-import { DumbSharedDriveModal } from './DumbSharedDriveModal'
-import {
-  mergeAndDeduplicateRecipients,
-  formatRecipients,
-  RECIPIENT_INDEX_PREFIX
-} from './helpers'
 import withLocales from '../../hoc/withLocales'
-import { useSharingContext } from '../../hooks/useSharingContext'
-import { Contact } from '../../models'
+import { SharedDriveForm } from './SharedDriveForm'
 
 export const SharedDriveModal = withLocales(({ onClose }) => {
-  const client = useClient()
   const { t } = useI18n()
-  const { share } = useSharingContext()
-  const { showAlert } = useAlert()
-
-  const [sharedDriveRecipients, setSharedDriveRecipients] = useState({
-    recipients: [],
-    readOnlyRecipients: []
-  })
-  const [sharedDriveName, setSharedDriveName] = useState('')
-
-  const onShare = params => {
-    setSharedDriveRecipients({
-      recipients: mergeAndDeduplicateRecipients([
-        sharedDriveRecipients.recipients,
-        params.recipients
-      ]),
-      readOnlyRecipients: mergeAndDeduplicateRecipients([
-        sharedDriveRecipients.readOnlyRecipients,
-        params.readOnlyRecipients
-      ])
-    })
-  }
-
-  const handleSharedDriveNameChange = event => {
-    setSharedDriveName(event.target.value)
-  }
-
-  const onCreate = async () => {
-    try {
-      await client
-        .collection('io.cozy.files')
-        .getOrCreateSharedDrivesDirectory()
-      const { data: sharedDriveFolder } = await client.create('io.cozy.files', {
-        name: sharedDriveName,
-        dirId: 'io.cozy.files.shared-drives-dir',
-        type: 'directory'
-      })
-
-      await share({
-        description: sharedDriveName,
-        document: sharedDriveFolder,
-        recipients: sharedDriveRecipients.recipients,
-        readOnlyRecipients: sharedDriveRecipients.readOnlyRecipients,
-        sharedDrive: true,
-        openSharing: false
-      })
-
-      showAlert({
-        message: t('SharedDrive.sharedDriveModal.successNotification'),
-        severity: 'success',
-        variant: 'filled'
-      })
-
-      onClose()
-    } catch (_err) {
-      showAlert({
-        message: t('SharedDrive.sharedDriveModal.errorNotification'),
-        severity: 'error',
-        variant: 'filled'
-      })
-    }
-  }
-
-  const onSetType = (index, newType) => {
-    const _id = index.split(RECIPIENT_INDEX_PREFIX)[1]
-
-    if (newType === 'two-way') {
-      setSharedDriveRecipients(prev => {
-        const recipientToMove = prev.readOnlyRecipients.find(r => r._id === _id)
-
-        return {
-          recipients: [...prev.recipients, recipientToMove],
-          readOnlyRecipients: prev.readOnlyRecipients.filter(r => r._id !== _id)
-        }
-      })
-    } else {
-      setSharedDriveRecipients(prev => {
-        const recipientToMove = prev.recipients.find(r => r._id === _id)
-
-        return {
-          recipients: prev.recipients.filter(r => r._id !== _id),
-          readOnlyRecipients: [...prev.readOnlyRecipients, recipientToMove]
-        }
-      })
-    }
-  }
-
-  const onRevoke = index => {
-    const _id = index.split(RECIPIENT_INDEX_PREFIX)[1]
-
-    setSharedDriveRecipients(prev => {
-      return {
-        recipients: prev.recipients.filter(r => r._id !== _id),
-        readOnlyRecipients: prev.readOnlyRecipients.filter(r => r._id !== _id)
-      }
-    })
-  }
-
-  const createContact = contact => client.create(Contact.doctype, contact)
-
-  const recipients = formatRecipients(sharedDriveRecipients)
-
   return (
-    <DumbSharedDriveModal
-      title={t('SharedDrive.sharedDriveModal.title')}
-      sharedDriveName={sharedDriveName}
-      handleSharedDriveNameChange={handleSharedDriveNameChange}
-      createContact={createContact}
-      recipients={recipients}
-      currentRecipients={[]}
-      onRevoke={onRevoke}
-      onSetType={onSetType}
-      onCreate={onCreate}
-      onSend={undefined}
+    <FixedDialog
+      open
+      disableGutters
       onClose={onClose}
-      onShare={onShare}
-      showNameField={true}
-      sharingLink={undefined}
-      document={undefined}
+      title={t('SharedDrive.sharedDriveModal.title')}
+      classes={{ paper: 'u-ov-visible' }}
+      componentsProps={{
+        dialogContent: { className: 'u-ov-visible' }
+      }}
+      content={<SharedDriveForm onSuccess={onClose} onCancel={onClose} />}
     />
   )
 })

package/src/components/SharedDrive/helpers.js

@@ -73,7 +73,7 @@ export const formatRecipients = sharedDriveRecipients => {
     recipients.push({
       index: `${RECIPIENT_INDEX_PREFIX}${r._id}`,
       email: ContactModel.getPrimaryEmail(r),
-      public_name: r.displayName || r.name,
+      public_name: ContactModel.getDisplayName(r),
       memberIndex: r._id,
       type: 'two-way',
       members: r.members
@@ -84,7 +84,7 @@ export const formatRecipients = sharedDriveRecipients => {
     recipients.push({
       index: `${RECIPIENT_INDEX_PREFIX}${r._id}`,
       email: ContactModel.getPrimaryEmail(r),
-      public_name: r.displayName || r.name,
+      public_name: ContactModel.getDisplayName(r),
       memberIndex: r._id,
       type: 'one-way',
       members: r.members

package/src/components/SharedDrive/helpers.spec.js

@@ -138,6 +138,22 @@ describe('formatRecipients', () => {
     })
   })
 
+  it('should flatten an object-shaped contact name into a string public_name', () => {
+    const input = {
+      recipients: [
+        {
+          _id: '3',
+          name: { givenName: 'Arya', familyName: 'Stark' },
+          email: [{ address: 'arya@example.com', primary: true }]
+        }
+      ],
+      readOnlyRecipients: []
+    }
+    const result = formatRecipients(input)
+    expect(typeof result[0].public_name).toBe('string')
+    expect(result[0].public_name).toBe('Arya Stark')
+  })
+
   it('should sort recipients by public_name', () => {
     const input = {
       recipients: [