cozy-sharing 40.1.6 → 40.1.7

package/dist/components/SharedDrive/EditSharedDriveModal.js

@@ -17,9 +17,9 @@ import Typography from 'cozy-ui/transpiled/react/Typography';
 import { useSubmitWithLoader } from 'cozy-ui/transpiled/react/hooks/useSubmitWithLoader';
 import { useI18n } from 'twake-i18n';
 import SharedDriveHeader from './SharedDriveHeader';
-import { getOrCreateFromArray } from '../../helpers/contacts';
 import withLocales from '../../hoc/withLocales';
 import { usePendingRecipients } from '../../hooks/usePendingRecipients';
+import { useResolveRecipients } from '../../hooks/useResolveRecipients';
 import { useSharingContext } from '../../hooks/useSharingContext';
 var styles = {
   "share-modal-content": "share__share-modal-content___1iqEq",
@@ -40,7 +40,7 @@ var styles = {
   "aligned-dropdown-button": "share__aligned-dropdown-button___3crgG"
 };
 import { default as DumbShareByEmail } from '../ShareByEmail';
-import WhoHasAccess from '../WhoHasAccess';
+import WhoHasAccessWrapper from '../WhoHasAccessWrapper';
 export var EditSharedDriveModal = withLocales(function (_ref) {
   var onClose = _ref.onClose,
       document = _ref.document;
@@ -64,6 +64,8 @@ export var EditSharedDriveModal = withLocales(function (_ref) {
       onSubmit = _useSubmitWithLoader.onSubmit,
       isLoading = _useSubmitWithLoader.isLoading;
 
+  var resolveRecipients = useResolveRecipients();
+
   var _useState = useState(document.name),
       _useState2 = _slicedToArray(_useState, 2),
       driveName = _useState2[0],
@@ -71,19 +73,18 @@ export var EditSharedDriveModal = withLocales(function (_ref) {
 
   var onSave = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var contacts, readWriteRecipients, readOnlyRecipients;
+      var _yield$resolveRecipie, readWriteRecipients, readOnlyRecipients;
+
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _context.next = 2;
-            return getOrCreateFromArray(client, pendingRecipients, function (contact) {
-              return client.create('io.cozy.contacts', contact);
-            });
+            return resolveRecipients(pendingRecipients, selectedOption);
 
           case 2:
-            contacts = _context.sent;
-            readWriteRecipients = selectedOption === 'readOnly' ? [] : contacts;
-            readOnlyRecipients = selectedOption === 'readOnly' ? contacts : [];
+            _yield$resolveRecipie = _context.sent;
+            readWriteRecipients = _yield$resolveRecipie.recipients;
+            readOnlyRecipients = _yield$resolveRecipie.readOnlyRecipients;
             _context.next = 7;
             return share({
               document: document,
@@ -156,7 +157,7 @@ export var EditSharedDriveModal = withLocales(function (_ref) {
       onPendingRecipientsChange: setPendingRecipients,
       selectedOption: selectedOption,
       onSelectedOptionChange: setSelectedOption
-    })), /*#__PURE__*/React.createElement(WhoHasAccess, {
+    })), /*#__PURE__*/React.createElement(WhoHasAccessWrapper, {
       isOwner: true,
       isSharedDrive: true,
       showOwner: false,

package/dist/components/SharedDrive/useSharedDrive.js

@@ -3,11 +3,11 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { useState } from 'react';
 import { useClient } from 'cozy-client';
-import { getOrCreateFromArray } from '../../helpers/contacts';
 import { usePendingRecipients } from '../../hooks/usePendingRecipients';
-import { DOCTYPE_CONTACTS } from '../../models';
+import { useResolveRecipients } from '../../hooks/useResolveRecipients';
 export var useSharedDrive = function useSharedDrive() {
   var client = useClient();
+  var resolveRecipients = useResolveRecipients();
 
   var _useState = useState(''),
       _useState2 = _slicedToArray(_useState, 2),
@@ -24,23 +24,20 @@ export var useSharedDrive = function useSharedDrive() {
     setSharedDriveName(event.target.value);
   };
 
-  var createContact = function createContact(contact) {
-    return client.create(DOCTYPE_CONTACTS, contact);
-  };
-
   var onCreate = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var contacts, readWriteRecipients, readOnlyRecipients;
+      var _yield$resolveRecipie, readWriteRecipients, readOnlyRecipients;
+
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _context.next = 2;
-            return getOrCreateFromArray(client, pendingRecipients, createContact);
+            return resolveRecipients(pendingRecipients, selectedOption);
 
           case 2:
-            contacts = _context.sent;
-            readWriteRecipients = selectedOption === 'readOnly' ? [] : contacts;
-            readOnlyRecipients = selectedOption === 'readOnly' ? contacts : [];
+            _yield$resolveRecipie = _context.sent;
+            readWriteRecipients = _yield$resolveRecipie.recipients;
+            readOnlyRecipients = _yield$resolveRecipie.readOnlyRecipients;
             _context.next = 7;
             return client.collection('io.cozy.sharings').createSharedDrive({
               name: sharedDriveName,

package/dist/components/SharingContent.js

@@ -5,7 +5,7 @@ import useBreakpoints from 'cozy-ui/transpiled/react/providers/Breakpoints';
 import { useI18n } from 'twake-i18n';
 import AntivirusAlert from './AntivirusAlert';
 import { default as DumbShareByEmail } from './ShareByEmail';
-import WhoHasAccess from './WhoHasAccess';
+import WhoHasAccessWrapper from './WhoHasAccessWrapper';
 var styles = {
   "share-modal-content": "share__share-modal-content___1iqEq",
   "coz-form": "share__coz-form___1ICST",
@@ -40,7 +40,6 @@ var SharingContent = function SharingContent(_ref) {
       recipientsToBeConfirmed = _ref.recipientsToBeConfirmed,
       verifyRecipient = _ref.verifyRecipient,
       link = _ref.link,
-      permissions = _ref.permissions,
       pendingRecipients = _ref.pendingRecipients,
       onPendingRecipientsChange = _ref.onPendingRecipientsChange,
       selectedOption = _ref.selectedOption,
@@ -75,7 +74,7 @@ var SharingContent = function SharingContent(_ref) {
     selectedOption: selectedOption,
     onSelectedOptionChange: onSelectedOptionChange,
     enableCreateContact: true
-  })), showWhoHasAccess && /*#__PURE__*/React.createElement(WhoHasAccess, {
+  })), showWhoHasAccess && /*#__PURE__*/React.createElement(WhoHasAccessWrapper, {
     document: document,
     documentType: documentType,
     isOwner: isOwner,
@@ -84,8 +83,7 @@ var SharingContent = function SharingContent(_ref) {
     recipients: recipients,
     recipientsToBeConfirmed: recipientsToBeConfirmed,
     verifyRecipient: verifyRecipient,
-    link: link,
-    permissions: permissions
+    link: link
   }));
 };
 

package/dist/components/WhoHasAccess.js

@@ -6,7 +6,6 @@ import LinkRecipient from './Recipient/LinkRecipient';
 import OwnerRecipient from './Recipient/OwnerRecipient';
 import { RecipientList } from './Recipient/RecipientList';
 import { usePrevious } from '../helpers/hooks';
-import { useSharingContext } from '../hooks/useSharingContext';
 /**
  * Displays a warning if some contacts are waiting for confirmation of their sharing
  *
@@ -43,6 +42,10 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
       canManageLink = _ref2$canManageLink === void 0 ? canManageMembers : _ref2$canManageLink,
       _ref2$showOwner = _ref2.showOwner,
       showOwner = _ref2$showOwner === void 0 ? true : _ref2$showOwner,
+      owner = _ref2.owner,
+      _ref2$isInsideSharedP = _ref2.isInsideSharedParent,
+      isInsideSharedParent = _ref2$isInsideSharedP === void 0 ? false : _ref2$isInsideSharedP,
+      sharedParentName = _ref2.sharedParentName,
       recipients = _ref2.recipients,
       _ref2$recipientsToBeC = _ref2.recipientsToBeConfirmed,
       recipientsToBeConfirmed = _ref2$recipientsToBeC === void 0 ? [] : _ref2$recipientsToBeC,
@@ -51,17 +54,16 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
       className = _ref2.className,
       onRevoke = _ref2.onRevoke,
       onRevokeSelf = _ref2.onRevokeSelf,
-      onSetType = _ref2.onSetType,
+      onRevokeGroup = _ref2.onRevokeGroup,
+      onLeaveGroup = _ref2.onLeaveGroup,
+      onSetMemberType = _ref2.onSetMemberType,
+      onUpdateLinkPermissions = _ref2.onUpdateLinkPermissions,
+      onRevokeLink = _ref2.onRevokeLink,
       verifyRecipient = _ref2.verifyRecipient,
       link = _ref2.link,
       permissions = _ref2.permissions;
   var previousLink = usePrevious(link);
   var linkHasBeenJustCreated = link && previousLink === null;
-
-  var _useSharingContext = useSharingContext(),
-      isOrgSharedDrive = _useSharingContext.isOrgSharedDrive;
-
-  var isOrgDrive = isOrgSharedDrive(document === null || document === void 0 ? void 0 : document._id);
   return /*#__PURE__*/React.createElement("div", {
     className: className
   }, /*#__PURE__*/React.createElement(RecipientWaitingForConfirmationAlert, {
@@ -73,10 +75,11 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
     onRevoke: onRevoke,
     onRevokeSelf: onRevokeSelf,
     permissions: permissions,
+    onUpdateLinkPermissions: onUpdateLinkPermissions,
+    onRevokeLink: onRevokeLink,
     fadeIn: linkHasBeenJustCreated
   }), showOwner && /*#__PURE__*/React.createElement(OwnerRecipient, {
-    recipients: recipients,
-    isOrgSharedDrive: isOrgDrive
+    owner: owner
   }), /*#__PURE__*/React.createElement(RecipientList, {
     recipients: recipients,
     recipientsToBeConfirmed: recipientsToBeConfirmed,
@@ -86,9 +89,13 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
     isSharedDrive: isSharedDrive,
     document: document,
     documentType: documentType,
+    isInsideSharedParent: isInsideSharedParent,
+    sharedParentName: sharedParentName,
     onRevoke: onRevoke,
     onRevokeSelf: onRevokeSelf,
-    onSetType: onSetType,
+    onRevokeGroup: onRevokeGroup,
+    onLeaveGroup: onLeaveGroup,
+    onSetMemberType: onSetMemberType,
     verifyRecipient: verifyRecipient
   })));
 };
@@ -99,6 +106,9 @@ WhoHasAccess.propTypes = {
   canManageMembers: PropTypes.bool,
   canManageLink: PropTypes.bool,
   showOwner: PropTypes.bool,
+  owner: PropTypes.object,
+  isInsideSharedParent: PropTypes.bool,
+  sharedParentName: PropTypes.string,
   recipients: PropTypes.array.isRequired,
   recipientsToBeConfirmed: PropTypes.arrayOf(PropTypes.shape({
     email: PropTypes.string.isRequired
@@ -107,6 +117,12 @@ WhoHasAccess.propTypes = {
   documentType: PropTypes.string.isRequired,
   onRevoke: PropTypes.func.isRequired,
   onRevokeSelf: PropTypes.func,
-  verifyRecipient: PropTypes.func
+  onRevokeGroup: PropTypes.func.isRequired,
+  onLeaveGroup: PropTypes.func.isRequired,
+  onSetMemberType: PropTypes.func.isRequired,
+  onUpdateLinkPermissions: PropTypes.func.isRequired,
+  onRevokeLink: PropTypes.func.isRequired,
+  verifyRecipient: PropTypes.func,
+  permissions: PropTypes.arrayOf(PropTypes.object)
 };
 export default WhoHasAccess;

package/dist/components/WhoHasAccessWrapper.js

@@ -0,0 +1,122 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import React from 'react';
+import { useClient, useQuery, hasQueryBeenLoaded } from 'cozy-client';
+import WhoHasAccess from './WhoHasAccess';
+import { hasMemberActions, markCurrentUser } from '../helpers/recipients';
+import { useMemberPermissionType } from '../hooks/useMemberPermissionType';
+import { useSharingContext } from '../hooks/useSharingContext';
+import { buildInstanceSettingsQuery } from '../queries/queries'; // When the owner is not part of a sharing's members (eg. the folder only has
+// a link), there is no per-sharing avatar to reference. The instance's public
+// avatar still holds the owner's picture. fallback=initials makes the stack
+// serve a generated initials avatar (instead of the app icon) when no picture
+// has been uploaded, matching how avatars are rendered everywhere else.
+
+var OWNER_PUBLIC_AVATAR_PATH = '/public/avatar?fallback=initials';
+
+var WhoHasAccessWrapper = function WhoHasAccessWrapper(_ref) {
+  var _instanceSettingsResu;
+
+  var _ref$isOwner = _ref.isOwner,
+      isOwner = _ref$isOwner === void 0 ? false : _ref$isOwner,
+      _ref$canManageSharing = _ref.canManageSharing,
+      canManageSharing = _ref$canManageSharing === void 0 ? isOwner : _ref$canManageSharing,
+      isSharedDrive = _ref.isSharedDrive,
+      isReadOnly = _ref.isReadOnly,
+      _ref$canManageMembers = _ref.canManageMembers,
+      canManageMembers = _ref$canManageMembers === void 0 ? !isReadOnly : _ref$canManageMembers,
+      canManageLink = _ref.canManageLink,
+      _ref$showOwner = _ref.showOwner,
+      showOwner = _ref$showOwner === void 0 ? true : _ref$showOwner,
+      recipients = _ref.recipients,
+      _ref$recipientsToBeCo = _ref.recipientsToBeConfirmed,
+      recipientsToBeConfirmed = _ref$recipientsToBeCo === void 0 ? [] : _ref$recipientsToBeCo,
+      document = _ref.document,
+      documentType = _ref.documentType,
+      className = _ref.className,
+      onRevoke = _ref.onRevoke,
+      onRevokeSelf = _ref.onRevokeSelf,
+      verifyRecipient = _ref.verifyRecipient,
+      link = _ref.link;
+  var client = useClient();
+
+  var _useSharingContext = useSharingContext(),
+      isOrgSharedDrive = _useSharingContext.isOrgSharedDrive,
+      getDocumentPermissions = _useSharingContext.getDocumentPermissions,
+      updateDocumentPermissions = _useSharingContext.updateDocumentPermissions,
+      revokeSharingLink = _useSharingContext.revokeSharingLink,
+      revokeGroup = _useSharingContext.revokeGroup,
+      revokeSelf = _useSharingContext.revokeSelf;
+
+  var instanceUri = client.options.uri;
+  var markedRecipients = markCurrentUser(recipients, instanceUri);
+  var hasMemberMenus = markedRecipients.some(function (recipient) {
+    return !recipient.members && !recipientsToBeConfirmed.some(function (user) {
+      return user.email === recipient.email;
+    }) && hasMemberActions({
+      status: recipient.status,
+      isCurrentUser: recipient.isCurrentUser,
+      isOwner: isOwner,
+      canManageSharing: canManageSharing,
+      canManageMembers: canManageMembers
+    });
+  });
+
+  var _useMemberPermissionT = useMemberPermissionType(document, {
+    shouldFetchPath: hasMemberMenus
+  }),
+      isInsideSharedParent = _useMemberPermissionT.isInsideSharedParent,
+      sharedParentName = _useMemberPermissionT.sharedParentName,
+      setMemberType = _useMemberPermissionT.setMemberType;
+
+  var ownerRecipient = markedRecipients.find(function (recipient) {
+    return recipient.status === 'owner';
+  });
+  var instanceSettingsQuery = buildInstanceSettingsQuery();
+  var instanceSettingsResult = useQuery(instanceSettingsQuery.definition, _objectSpread(_objectSpread({}, instanceSettingsQuery.options), {}, {
+    enabled: showOwner && !ownerRecipient
+  }));
+  var defaultOwner = hasQueryBeenLoaded(instanceSettingsResult) ? {
+    isOwner: true,
+    status: 'owner',
+    instance: instanceUri,
+    avatarPath: OWNER_PUBLIC_AVATAR_PATH,
+    public_name: (_instanceSettingsResu = instanceSettingsResult.data) === null || _instanceSettingsResu === void 0 || (_instanceSettingsResu = _instanceSettingsResu.attributes) === null || _instanceSettingsResu === void 0 ? void 0 : _instanceSettingsResu.public_name
+  } : null;
+  var owner = ownerRecipient ? _objectSpread(_objectSpread({}, ownerRecipient), {}, {
+    isOrgSharedDrive: isOrgSharedDrive(document === null || document === void 0 ? void 0 : document._id)
+  }) : defaultOwner;
+  return /*#__PURE__*/React.createElement(WhoHasAccess, {
+    isOwner: isOwner,
+    canManageSharing: canManageSharing,
+    isSharedDrive: isSharedDrive,
+    isReadOnly: isReadOnly,
+    canManageMembers: canManageMembers,
+    canManageLink: canManageLink,
+    showOwner: showOwner,
+    owner: owner,
+    isInsideSharedParent: isInsideSharedParent,
+    sharedParentName: sharedParentName,
+    recipients: markedRecipients,
+    recipientsToBeConfirmed: recipientsToBeConfirmed,
+    document: document,
+    documentType: documentType,
+    className: className,
+    onRevoke: onRevoke,
+    onRevokeSelf: onRevokeSelf,
+    onRevokeGroup: revokeGroup,
+    onLeaveGroup: revokeSelf,
+    onSetMemberType: setMemberType,
+    onUpdateLinkPermissions: updateDocumentPermissions,
+    onRevokeLink: revokeSharingLink,
+    verifyRecipient: verifyRecipient,
+    link: link,
+    permissions: getDocumentPermissions(document === null || document === void 0 ? void 0 : document._id)
+  });
+};
+
+export default WhoHasAccessWrapper;

package/dist/helpers/recipients.js

@@ -95,4 +95,50 @@ export var getGroupRecipientSecondaryText = function getGroupRecipientSecondaryT
     smart_count: nbMember
   });
   return secondary + (isUserInsideMembers ? " (".concat(t('GroupRecipient.secondary_you'), ")") : '');
+};
+
+var isInstance = function isInstance(recipient, instanceUri) {
+  return recipient.instance !== undefined && recipient.instance === instanceUri;
+};
+/**
+ * Flags with `isCurrentUser` the recipients, and the members of group
+ * recipients, whose instance is the current user's one
+ *
+ * @param {object[]} recipients - Recipients of a sharing
+ * @param {string} instanceUri - URI of the current user's instance
+ * @returns {object[]} The recipients with their `isCurrentUser` flag
+ */
+
+
+export var markCurrentUser = function markCurrentUser(recipients, instanceUri) {
+  return recipients.map(function (recipient) {
+    return _objectSpread(_objectSpread({}, recipient), {}, {
+      isCurrentUser: isInstance(recipient, instanceUri)
+    }, recipient.members && {
+      members: recipient.members.map(function (member) {
+        return _objectSpread(_objectSpread({}, member), {}, {
+          isCurrentUser: isInstance(member, instanceUri)
+        });
+      })
+    });
+  });
+};
+/**
+ * @param {object} params
+ * @param {string} params.status - Status of the member in the sharing
+ * @param {boolean} params.isCurrentUser - Whether the member is the current user
+ * @param {boolean} params.isOwner - Whether the current user owns the sharing
+ * @param {boolean} params.canManageSharing - Whether the current user can manage the sharing
+ * @param {boolean} params.canManageMembers - Whether the members can be managed
+ * @returns {boolean} Whether the current user can change the member's
+ * permission type or revoke them
+ */
+
+export var hasMemberActions = function hasMemberActions(_ref2) {
+  var status = _ref2.status,
+      isCurrentUser = _ref2.isCurrentUser,
+      isOwner = _ref2.isOwner,
+      canManageSharing = _ref2.canManageSharing,
+      canManageMembers = _ref2.canManageMembers;
+  return canManageMembers && status !== 'owner' && (isCurrentUser && !isOwner || canManageSharing);
 };

package/dist/helpers/recipients.spec.js

@@ -0,0 +1,89 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { hasMemberActions, markCurrentUser } from './recipients';
+var instanceUri = 'https://alice.cozy.cc';
+describe('markCurrentUser', function () {
+  it('flags the recipient whose instance is the current one', function () {
+    var recipients = [{
+      email: 'alice@cozy.cc',
+      instance: instanceUri
+    }, {
+      email: 'bob@cozy.cc',
+      instance: 'https://bob.cozy.cc'
+    }, {
+      email: 'carol@cozy.cc'
+    }];
+    expect(markCurrentUser(recipients, instanceUri).map(function (r) {
+      return r.isCurrentUser;
+    })).toEqual([true, false, false]);
+  });
+  it('does not flag a recipient without instance when the instance is unknown', function () {
+    expect(markCurrentUser([{
+      email: 'carol@cozy.cc'
+    }], undefined)).toEqual([{
+      email: 'carol@cozy.cc',
+      isCurrentUser: false
+    }]);
+  });
+  it('flags the members of group recipients', function () {
+    var recipients = [{
+      name: 'Team',
+      members: [{
+        instance: 'https://bob.cozy.cc'
+      }, {
+        instance: instanceUri
+      }]
+    }];
+
+    var _markCurrentUser = markCurrentUser(recipients, instanceUri),
+        _markCurrentUser2 = _slicedToArray(_markCurrentUser, 1),
+        group = _markCurrentUser2[0];
+
+    expect(group.isCurrentUser).toBe(false);
+    expect(group.members.map(function (m) {
+      return m.isCurrentUser;
+    })).toEqual([false, true]);
+  });
+});
+describe('hasMemberActions', function () {
+  var ownerRights = {
+    isOwner: true,
+    canManageSharing: true,
+    canManageMembers: true
+  };
+  var memberRights = {
+    isOwner: false,
+    canManageSharing: false,
+    canManageMembers: true
+  };
+  it('gives actions on the members to whom can manage the sharing', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, ownerRights), {}, {
+      status: 'ready'
+    }))).toBe(true);
+  });
+  it('gives no action on the owner', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, ownerRights), {}, {
+      status: 'owner'
+    }))).toBe(false);
+  });
+  it('gives no action when the members cannot be managed', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, ownerRights), {}, {
+      canManageMembers: false,
+      status: 'ready'
+    }))).toBe(false);
+  });
+  it('gives actions on themselves to a member who cannot manage the sharing', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, memberRights), {}, {
+      status: 'ready',
+      isCurrentUser: true
+    }))).toBe(true);
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, memberRights), {}, {
+      status: 'ready'
+    }))).toBe(false);
+  });
+});