cozy-sharing 32.1.2 → 32.3.1

package/dist/components/ShareRecipientsInput.js

@@ -18,6 +18,10 @@ import { buildReachableContactsQuery, buildContactGroupsQuery, buildUnreachableC
  * In order to display the total number of members in each group, we also retrieve the contacts that are not reachable.
  */
 
+var isCurrentUser = function isCurrentUser(contact) {
+  return contact.me === true;
+};
+
 var ShareRecipientsInput = function ShareRecipientsInput(_ref) {
   var currentRecipients = _ref.currentRecipients,
       recipients = _ref.recipients,
@@ -35,6 +39,12 @@ var ShareRecipientsInput = function ShareRecipientsInput(_ref) {
   var contactGroupsQuery = buildContactGroupsQuery();
   var contactGroupsResult = useQueryAll(contactGroupsQuery.definition, contactGroupsQuery.options);
   var isLoading = isQueryLoading(reachableContactsResult) || reachableContactsResult.hasMore || isQueryLoading(contactGroupsResult) || contactGroupsResult.hasMore || flag('sharing.show-recipient-groups') && (isQueryLoading(unreachableContactsWithGroupsResult) || unreachableContactsWithGroupsResult.hasMore);
+  var reachableContacts = (reachableContactsResult.data || []).filter(function (contact) {
+    return !isCurrentUser(contact);
+  });
+  var unreachableContactsWithGroups = (unreachableContactsWithGroupsResult.data || []).filter(function (contact) {
+    return !isCurrentUser(contact);
+  });
   var currentRecipientGroups = currentRecipients.map(function (_ref2) {
     var id = _ref2.id;
     return id;
@@ -43,7 +53,7 @@ var ShareRecipientsInput = function ShareRecipientsInput(_ref) {
     var _id = _ref3._id;
     return !flag('sharing.show-recipient-groups') || !currentRecipientGroups.includes(_id);
   }).map(function (contactGroup) {
-    var reachableMembers = getContactsFromGroupId(reachableContactsResult.data, contactGroup.id).map(function (contact) {
+    var reachableMembers = getContactsFromGroupId(reachableContacts, contactGroup.id).map(function (contact) {
       return _objectSpread(_objectSpread({}, contact), {}, {
         isReachable: true
       });
@@ -55,7 +65,7 @@ var ShareRecipientsInput = function ShareRecipientsInput(_ref) {
       });
     }
 
-    var unreachableMembers = getContactsFromGroupId(unreachableContactsWithGroupsResult.data, contactGroup.id).map(function (contact) {
+    var unreachableMembers = getContactsFromGroupId(unreachableContactsWithGroups, contactGroup.id).map(function (contact) {
       return _objectSpread(_objectSpread({}, contact), {}, {
         isReachable: false
       });
@@ -64,7 +74,7 @@ var ShareRecipientsInput = function ShareRecipientsInput(_ref) {
       members: [].concat(_toConsumableArray(reachableMembers), _toConsumableArray(unreachableMembers))
     });
   });
-  var contactsAndGroups = [].concat(_toConsumableArray(reachableContactsResult.data || []), _toConsumableArray(contactGroups));
+  var contactsAndGroups = [].concat(_toConsumableArray(reachableContacts), _toConsumableArray(contactGroups));
   return /*#__PURE__*/React.createElement(ShareAutosuggest, {
     loading: isLoading,
     disabled: disabled,

package/dist/components/ShareRecipientsInput.spec.js

@@ -113,10 +113,69 @@ describe('ShareRecipientsInput component', function () {
       }
     }, _callee);
   })));
-  it('should include unreachable members when flag sharing.show-recipient-groups is activated', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-    var contacts, contactGroups, unreachableContact;
+  it('should exclude current user from suggestions when me is true', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var contacts, contactGroups;
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          contacts = [{
+            id: 'df563cc4-6440',
+            _id: 'df563cc4-6440',
+            _type: 'io.cozy.contacts',
+            me: true,
+            name: {
+              givenName: 'My',
+              familyName: 'Self'
+            },
+            relationships: {
+              groups: {
+                data: [{
+                  _id: 'group-id',
+                  _type: 'io.cozy.contacts.groups'
+                }]
+              }
+            }
+          }, {
+            id: '5a3b4ccf-c257',
+            _id: '5a3b4ccf-c257',
+            _type: 'io.cozy.contacts',
+            name: {
+              givenName: 'Teagan',
+              familyName: 'Wolf'
+            },
+            relationships: {
+              groups: {
+                data: [{
+                  _id: 'group-id',
+                  _type: 'io.cozy.contacts.groups'
+                }]
+              }
+            }
+          }];
+          contactGroups = [{
+            id: 'group-id',
+            name: 'Friends',
+            _id: 'group-id',
+            _type: 'io.cozy.contacts.groups'
+          }];
+          setup({
+            contacts: contacts,
+            contactGroups: contactGroups
+          });
+          expect(screen.queryByText('My Self')).not.toBeInTheDocument();
+          expect(screen.getByText('Teagan Wolf')).toBeInTheDocument();
+          expect(screen.getByText('Friends - 1 members')).toBeInTheDocument();
+
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('should include unreachable members when flag sharing.show-recipient-groups is activated', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var contacts, contactGroups, unreachableContact;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
         case 0:
           flag.mockReturnValue(true);
           contacts = [{
@@ -181,8 +240,8 @@ describe('ShareRecipientsInput component', function () {
 
         case 8:
         case "end":
-          return _context2.stop();
+          return _context3.stop();
       }
-    }, _callee2);
+    }, _callee3);
   })));
 });

package/dist/components/SharedDrive/DumbSharedDriveModal.js

@@ -0,0 +1,78 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { useI18n } from 'twake-i18n';
+import withLocales from '../../hoc/withLocales';
+import { DumbBatchSharedFolderModal } from '../SharedFolder/DumbBatchSharedFolderModal';
+export var DumbSharedDriveModal = withLocales(function (_ref) {
+  var title = _ref.title,
+      document = _ref.document,
+      sharedDriveName = _ref.sharedDriveName,
+      handleSharedDriveNameChange = _ref.handleSharedDriveNameChange,
+      createContact = _ref.createContact,
+      recipients = _ref.recipients,
+      currentRecipients = _ref.currentRecipients,
+      onRevoke = _ref.onRevoke,
+      onSetType = _ref.onSetType,
+      onCreate = _ref.onCreate,
+      onSend = _ref.onSend,
+      onClose = _ref.onClose,
+      onShare = _ref.onShare,
+      onRename = _ref.onRename,
+      _ref$showNameField = _ref.showNameField,
+      showNameField = _ref$showNameField === void 0 ? true : _ref$showNameField,
+      sharingLink = _ref.sharingLink,
+      autoOpenShareRestriction = _ref.autoOpenShareRestriction,
+      showGenerateLinkButton = _ref.showGenerateLinkButton;
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  return /*#__PURE__*/React.createElement(DumbBatchSharedFolderModal, {
+    title: title,
+    document: document,
+    folderName: sharedDriveName,
+    handleFolderNameChange: handleSharedDriveNameChange,
+    createContact: createContact,
+    recipients: recipients,
+    currentRecipients: currentRecipients,
+    onRevoke: onRevoke,
+    onSetType: onSetType,
+    onCreate: onCreate,
+    onSend: onSend,
+    onClose: onClose,
+    onShare: onShare,
+    onRename: onRename,
+    showNameField: showNameField,
+    sharingLink: sharingLink,
+    nameLabel: t('SharedDrive.sharedDriveModal.nameLabel'),
+    addPeopleLabel: t('SharedDrive.sharedDriveModal.addPeople'),
+    addButtonLabel: t('SharedDrive.sharedDriveModal.add'),
+    cancelLabel: t('SharedDrive.sharedDriveModal.cancel'),
+    createLabel: t('SharedDrive.sharedDriveModal.create'),
+    shareLabel: t('FederatedFolder.share'),
+    saveLabel: t('SharedDrive.sharedDriveModal.save'),
+    autoOpenShareRestriction: autoOpenShareRestriction,
+    showGenerateLinkButton: showGenerateLinkButton
+  });
+});
+DumbSharedDriveModal.propTypes = {
+  title: PropTypes.string,
+  document: PropTypes.object,
+  sharedDriveName: PropTypes.string,
+  handleSharedDriveNameChange: PropTypes.func,
+  createContact: PropTypes.func.isRequired,
+  recipients: PropTypes.array,
+  currentRecipients: PropTypes.array,
+  onRevoke: PropTypes.func.isRequired,
+  onSetType: PropTypes.func.isRequired,
+  onCreate: PropTypes.func,
+  onSend: PropTypes.func,
+  onClose: PropTypes.func.isRequired,
+  onShare: PropTypes.func.isRequired,
+  onRename: PropTypes.func,
+  showNameField: PropTypes.bool,
+  sharingLink: PropTypes.string,
+  autoOpenShareRestriction: PropTypes.bool,
+  showGenerateLinkButton: PropTypes.bool
+};
+export default DumbSharedDriveModal;

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

@@ -0,0 +1,126 @@
+import _extends from "@babel/runtime/helpers/extends";
+import { render } from '@testing-library/react';
+import React from 'react';
+import { DumbSharedDriveModal } from './DumbSharedDriveModal';
+var mockDumbBatchSharedFolderModal = jest.fn();
+jest.mock('../SharedFolder/DumbBatchSharedFolderModal', function () {
+  return {
+    __esModule: true,
+    default: function _default(props) {
+      mockDumbBatchSharedFolderModal(props);
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "dumb-batch-shared-folder-modal"
+      }, "DumbBatchSharedFolderModal");
+    }
+  };
+});
+jest.mock('../../hoc/withLocales', function () {
+  return {
+    __esModule: true,
+    default: function _default(Component) {
+      return Component;
+    }
+  };
+});
+jest.mock('twake-i18n', function () {
+  return {
+    useI18n: jest.fn().mockReturnValue({
+      t: jest.fn(function (key) {
+        return key;
+      })
+    })
+  };
+});
+describe('DumbSharedDriveModal', function () {
+  var defaultProps = {
+    title: 'Test Shared Drive',
+    document: {
+      _id: 'doc-123',
+      name: 'Test'
+    },
+    sharedDriveName: 'My Drive',
+    handleSharedDriveNameChange: jest.fn(),
+    createContact: jest.fn(),
+    recipients: [{
+      _id: 'r1',
+      email: 'test@test.com'
+    }],
+    currentRecipients: [],
+    onRevoke: jest.fn(),
+    onSetType: jest.fn(),
+    onCreate: jest.fn(),
+    onSend: jest.fn(),
+    onClose: jest.fn(),
+    onShare: jest.fn(),
+    onRename: jest.fn(),
+    showNameField: true,
+    sharingLink: 'https://share.link/123',
+    hasRecipientsInitially: false
+  };
+
+  var setup = function setup() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    mockDumbBatchSharedFolderModal.mockClear();
+    return render( /*#__PURE__*/React.createElement(DumbSharedDriveModal, _extends({}, defaultProps, props)));
+  };
+
+  it('should render DumbBatchSharedFolderModal with correct props', function () {
+    setup();
+    expect(mockDumbBatchSharedFolderModal).toHaveBeenCalledWith(expect.objectContaining({
+      title: 'Test Shared Drive',
+      document: defaultProps.document,
+      folderName: 'My Drive',
+      handleFolderNameChange: defaultProps.handleSharedDriveNameChange,
+      createContact: defaultProps.createContact,
+      recipients: defaultProps.recipients,
+      currentRecipients: defaultProps.currentRecipients,
+      onRevoke: defaultProps.onRevoke,
+      onSetType: defaultProps.onSetType,
+      onCreate: defaultProps.onCreate,
+      onSend: defaultProps.onSend,
+      onClose: defaultProps.onClose,
+      onShare: defaultProps.onShare,
+      onRename: defaultProps.onRename,
+      showNameField: true,
+      sharingLink: 'https://share.link/123',
+      hasRecipientsInitially: false
+    }));
+  });
+  it('should pass correct i18n labels to DumbBatchSharedFolderModal', function () {
+    setup();
+    var passedProps = mockDumbBatchSharedFolderModal.mock.calls[0][0];
+    expect(passedProps.nameLabel).toBe('SharedDrive.sharedDriveModal.nameLabel');
+    expect(passedProps.addPeopleLabel).toBe('SharedDrive.sharedDriveModal.addPeople');
+    expect(passedProps.addButtonLabel).toBe('SharedDrive.sharedDriveModal.add');
+    expect(passedProps.cancelLabel).toBe('SharedDrive.sharedDriveModal.cancel');
+    expect(passedProps.createLabel).toBe('SharedDrive.sharedDriveModal.create');
+    expect(passedProps.shareLabel).toBe('SharedDrive.sharedDriveModal.share');
+    expect(passedProps.saveLabel).toBe('SharedDrive.sharedDriveModal.save');
+  });
+  it('should default showNameField to true', function () {
+    var _setup = setup({
+      showNameField: undefined
+    }),
+        rerender = _setup.rerender; // Re-render without showNameField
+
+
+    rerender( /*#__PURE__*/React.createElement(DumbSharedDriveModal, _extends({}, defaultProps, {
+      showNameField: undefined
+    })));
+    var passedProps = mockDumbBatchSharedFolderModal.mock.calls[mockDumbBatchSharedFolderModal.mock.calls.length - 1][0];
+    expect(passedProps.showNameField).toBe(true);
+  });
+  it('should handle hasRecipientsInitially correctly', function () {
+    setup({
+      hasRecipientsInitially: true
+    });
+    var passedProps = mockDumbBatchSharedFolderModal.mock.calls[0][0];
+    expect(passedProps.hasRecipientsInitially).toBe(true);
+  });
+  it('should render the mocked component', function () {
+    var _setup2 = setup(),
+        getByTestId = _setup2.getByTestId;
+
+    expect(getByTestId('dumb-batch-shared-folder-modal')).toBeInTheDocument();
+  });
+});

package/dist/components/SharedDrive/SharedDriveEditModal.js

@@ -0,0 +1,110 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { useClient } from 'cozy-client';
+import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert';
+import { useI18n } from 'twake-i18n';
+import { DumbSharedDriveModal } from './DumbSharedDriveModal';
+import withLocales from '../../hoc/withLocales';
+import { useSharingContext } from '../../hooks/useSharingContext';
+import { Contact } from '../../models';
+export var SharedDriveEditModal = withLocales(function (_ref) {
+  var document = _ref.document,
+      sharing = _ref.sharing,
+      recipients = _ref.recipients,
+      onShare = _ref.onShare,
+      onRevoke = _ref.onRevoke,
+      onClose = _ref.onClose,
+      autoOpenShareRestriction = _ref.autoOpenShareRestriction,
+      showGenerateLinkButton = _ref.showGenerateLinkButton;
+  var client = useClient();
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  var _useAlert = useAlert(),
+      showAlert = _useAlert.showAlert;
+
+  var _useSharingContext = useSharingContext(),
+      renameSharedDrive = _useSharingContext.renameSharedDrive;
+
+  var createContact = function createContact(contact) {
+    return client.create(Contact.doctype, contact);
+  };
+
+  var _useState = useState(sharing === null || sharing === void 0 ? void 0 : sharing.description),
+      _useState2 = _slicedToArray(_useState, 2),
+      name = _useState2[0],
+      setName = _useState2[1];
+
+  var handleNameChange = function handleNameChange(event) {
+    setName(event.target.value);
+  };
+
+  var onRename = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(value) {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return renameSharedDrive(document, value);
+
+          case 3:
+            showAlert({
+              message: t('SharedDrive.sharedDriveModal.successNotificationUpdate'),
+              severity: 'success'
+            });
+            onClose();
+            _context.next = 10;
+            break;
+
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](0);
+            showAlert({
+              message: t('SharedDrive.sharedDriveModal.errorNotificationUpdate'),
+              severity: 'error'
+            });
+
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 7]]);
+    }));
+
+    return function onRename(_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  return /*#__PURE__*/React.createElement(DumbSharedDriveModal, {
+    title: t('Files.share.title', {
+      name: sharing === null || sharing === void 0 ? void 0 : sharing.description
+    }),
+    document: document,
+    createContact: createContact,
+    recipients: recipients,
+    onRevoke: onRevoke,
+    onClose: onClose,
+    onShare: onShare,
+    sharedDriveName: name,
+    handleSharedDriveNameChange: handleNameChange,
+    onRename: onRename,
+    autoOpenShareRestriction: autoOpenShareRestriction,
+    showGenerateLinkButton: showGenerateLinkButton
+  });
+});
+SharedDriveEditModal.propTypes = {
+  document: PropTypes.object,
+  sharing: PropTypes.object,
+  recipients: PropTypes.array,
+  onShare: PropTypes.func.isRequired,
+  onRevoke: PropTypes.func.isRequired,
+  onClose: PropTypes.func.isRequired,
+  autoOpenShareRestriction: PropTypes.bool,
+  showGenerateLinkButton: PropTypes.bool
+};