cozy-sharing 32.1.2 → 32.3.1

package/dist/components/ShareModal/ShareModal.spec.js

@@ -0,0 +1,197 @@
+import _extends from "@babel/runtime/helpers/extends";
+import { render } from "@testing-library/react";
+import React from "react";
+import flag from "cozy-flags";
+import { ShareModal } from "./ShareModal";
+import { useSharingContext } from "../../hooks/useSharingContext";
+var mockOnClose = jest.fn();
+var mockOnShare = jest.fn();
+var mockOnRevoke = jest.fn();
+jest.mock("cozy-flags");
+jest.mock("../../hooks/useSharingContext", function () {
+  return {
+    useSharingContext: jest.fn()
+  };
+});
+jest.mock("./EditableSharingModal", function () {
+  return {
+    __esModule: true,
+    default: function _default() {
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "editable-sharing-modal"
+      }, "EditableSharingModal");
+    }
+  };
+});
+jest.mock("./SharingDetailsModal", function () {
+  return {
+    SharingDetailsModal: function SharingDetailsModal() {
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "sharing-details-modal"
+      }, "SharingDetailsModal");
+    }
+  };
+});
+jest.mock("../FederatedFolder/FederatedFolderModal", function () {
+  return {
+    FederatedFolderModal: function FederatedFolderModal() {
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "federated-folder-modal"
+      }, "FederatedFolderModal");
+    }
+  };
+});
+jest.mock("../../hoc/withLocales", function () {
+  return {
+    __esModule: true,
+    default: function _default(Component) {
+      return Component;
+    }
+  };
+});
+describe("ShareModal", function () {
+  var defaultDocument = {
+    id: "doc-123",
+    _id: "doc-123",
+    name: "Test Document"
+  };
+  var defaultProps = {
+    document: defaultDocument,
+    onClose: mockOnClose,
+    onShare: mockOnShare,
+    onRevoke: mockOnRevoke
+  };
+
+  var setup = function setup() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return render( /*#__PURE__*/React.createElement(ShareModal, _extends({}, defaultProps, props)));
+  };
+
+  beforeEach(function () {
+    jest.clearAllMocks();
+    flag.mockImplementation(function () {
+      return false;
+    });
+    useSharingContext.mockReturnValue({
+      byDocId: {},
+      isOwner: function isOwner() {
+        return true;
+      },
+      canReshare: function canReshare() {
+        return true;
+      }
+    });
+  });
+  describe("federated mode", function () {
+    it("should render FederatedFolderModal when federated mode is enabled and no sharings exist", function () {
+      flag.mockImplementation(function (flagName) {
+        if (flagName === "drive.federated-shared-folder.enabled") {
+          return true;
+        }
+
+        return false;
+      });
+      useSharingContext.mockReturnValue({
+        byDocId: {
+          "doc-123": {
+            sharings: []
+          }
+        },
+        isOwner: function isOwner() {
+          return true;
+        },
+        canReshare: function canReshare() {
+          return true;
+        }
+      });
+
+      var _setup = setup(),
+          getByTestId = _setup.getByTestId;
+
+      expect(getByTestId("federated-folder-modal")).toBeInTheDocument();
+    });
+    it("should render EditableSharingModal when federated mode is enabled but sharings exist", function () {
+      flag.mockImplementation(function (flagName) {
+        if (flagName === "drive.federated-shared-folder.enabled") {
+          return true;
+        }
+
+        return false;
+      });
+      useSharingContext.mockReturnValue({
+        byDocId: {
+          "doc-123": {
+            sharings: [{
+              id: "sharing-1"
+            }]
+          }
+        },
+        isOwner: function isOwner() {
+          return true;
+        },
+        canReshare: function canReshare() {
+          return true;
+        }
+      });
+
+      var _setup2 = setup(),
+          getByTestId = _setup2.getByTestId;
+
+      expect(getByTestId("editable-sharing-modal")).toBeInTheDocument();
+    });
+    it("should render EditableSharingModal when federated mode is disabled", function () {
+      flag.mockImplementation(function () {
+        return false;
+      });
+      useSharingContext.mockReturnValue({
+        byDocId: {
+          "doc-123": {
+            sharings: []
+          }
+        },
+        isOwner: function isOwner() {
+          return true;
+        },
+        canReshare: function canReshare() {
+          return true;
+        }
+      });
+
+      var _setup3 = setup(),
+          getByTestId = _setup3.getByTestId;
+
+      expect(getByTestId("editable-sharing-modal")).toBeInTheDocument();
+    });
+    it("should render FederatedFolderModal when document has no sharings entry", function () {
+      flag.mockImplementation(function (flagName) {
+        if (flagName === "drive.federated-shared-folder.enabled") {
+          return true;
+        }
+
+        return false;
+      });
+      useSharingContext.mockReturnValue({
+        byDocId: {},
+        isOwner: function isOwner() {
+          return true;
+        },
+        canReshare: function canReshare() {
+          return true;
+        }
+      });
+
+      var _setup4 = setup(),
+          getByTestId = _setup4.getByTestId;
+
+      expect(getByTestId("federated-folder-modal")).toBeInTheDocument();
+    });
+  });
+  describe("regular mode", function () {
+    it("should render EditableSharingModal by default", function () {
+      var _setup5 = setup(),
+          getByTestId = _setup5.getByTestId;
+
+      expect(getByTestId("editable-sharing-modal")).toBeInTheDocument();
+    });
+  });
+});

package/dist/components/ShareModal/ShareModalBatchContainer.js

@@ -0,0 +1,276 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { useI18n } from 'twake-i18n';
+import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert';
+import withLocales from '../../hoc/withLocales';
+import { Contact } from '../../models';
+import { ShareModal } from '../ShareModal';
+/**
+ * Merge and deduplicate recipients arrays
+ */
+
+var mergeAndDeduplicateRecipients = function mergeAndDeduplicateRecipients(arrays) {
+  var combinedArray = arrays.flat();
+  var seenIds = new Set();
+  return combinedArray.filter(function (item) {
+    if (!seenIds.has(item.id || item._id)) {
+      seenIds.add(item.id || item._id);
+      return true;
+    }
+
+    return false;
+  });
+};
+/**
+ * Container component that manages sharing recipients in batch mode.
+ * Instead of sharing immediately when adding recipients, it accumulates them
+ * and sends all at once when clicking the submit button.
+ */
+
+
+export var ShareModalBatchContainer = withLocales(function (_ref) {
+  var document = _ref.document,
+      documentType = _ref.documentType,
+      isOwner = _ref.isOwner,
+      link = _ref.link,
+      permissions = _ref.permissions,
+      existingRecipients = _ref.recipients,
+      sharing = _ref.sharing,
+      sharingDesc = _ref.sharingDesc,
+      onClose = _ref.onClose,
+      onRevoke = _ref.onRevoke,
+      onRevokeSelf = _ref.onRevokeSelf,
+      share = _ref.share,
+      createContact = _ref.createContact,
+      hasSharedChild = _ref.hasSharedChild,
+      hasSharedParent = _ref.hasSharedParent,
+      twoStepsConfirmationMethods = _ref.twoStepsConfirmationMethods;
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  var _useAlert = useAlert(),
+      showAlert = _useAlert.showAlert; // State for pending recipients (not yet shared)
+
+
+  var _useState = useState({
+    recipients: [],
+    readOnlyRecipients: []
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      pendingRecipients = _useState2[0],
+      setPendingRecipients = _useState2[1]; // Accumulate recipients when added via ShareByEmail
+
+
+  var onShare = function onShare(params) {
+    setPendingRecipients(function (prev) {
+      return {
+        recipients: mergeAndDeduplicateRecipients([prev.recipients, params.recipients || []]),
+        readOnlyRecipients: mergeAndDeduplicateRecipients([prev.readOnlyRecipients, params.readOnlyRecipients || []])
+      };
+    });
+  }; // Handle changing a recipient's permission type
+
+
+  var onSetType = function onSetType(index, newType) {
+    var recipientId = index;
+
+    if (newType === 'two-way') {
+      setPendingRecipients(function (prev) {
+        var recipientToMove = prev.readOnlyRecipients.find(function (r) {
+          return (r.id || r._id) === recipientId;
+        });
+        if (!recipientToMove) return prev;
+        return {
+          recipients: [].concat(_toConsumableArray(prev.recipients), [recipientToMove]),
+          readOnlyRecipients: prev.readOnlyRecipients.filter(function (r) {
+            return (r.id || r._id) !== recipientId;
+          })
+        };
+      });
+    } else {
+      setPendingRecipients(function (prev) {
+        var recipientToMove = prev.recipients.find(function (r) {
+          return (r.id || r._id) === recipientId;
+        });
+        if (!recipientToMove) return prev;
+        return {
+          recipients: prev.recipients.filter(function (r) {
+            return (r.id || r._id) !== recipientId;
+          }),
+          readOnlyRecipients: [].concat(_toConsumableArray(prev.readOnlyRecipients), [recipientToMove])
+        };
+      });
+    }
+  }; // Remove a pending recipient
+
+
+  var onRevokePending = function onRevokePending(index) {
+    var recipientId = index;
+    setPendingRecipients(function (prev) {
+      return {
+        recipients: prev.recipients.filter(function (r) {
+          return (r.id || r._id) !== recipientId;
+        }),
+        readOnlyRecipients: prev.readOnlyRecipients.filter(function (r) {
+          return (r.id || r._id) !== recipientId;
+        })
+      };
+    });
+  }; // Submit all pending recipients at once
+
+
+  var onSubmit = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(pendingRecipients.recipients.length === 0 && pendingRecipients.readOnlyRecipients.length === 0)) {
+              _context.next = 2;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 2:
+            _context.prev = 2;
+            _context.next = 5;
+            return share({
+              document: document,
+              recipients: pendingRecipients.recipients,
+              readOnlyRecipients: pendingRecipients.readOnlyRecipients,
+              description: sharingDesc,
+              openSharing: pendingRecipients.recipients.length > 0
+            });
+
+          case 5:
+            showAlert({
+              message: t('Share.successNotification'),
+              severity: 'success',
+              variant: 'filled'
+            }); // Clear pending recipients after successful share
+
+            setPendingRecipients({
+              recipients: [],
+              readOnlyRecipients: []
+            });
+            _context.next = 12;
+            break;
+
+          case 9:
+            _context.prev = 9;
+            _context.t0 = _context["catch"](2);
+            showAlert({
+              message: t('Share.errorNotification'),
+              severity: 'error',
+              variant: 'filled'
+            });
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[2, 9]]);
+    }));
+
+    return function onSubmit() {
+      return _ref2.apply(this, arguments);
+    };
+  }(); // Combine existing and pending recipients for display
+
+
+  var allRecipients = [].concat(_toConsumableArray(existingRecipients), _toConsumableArray(pendingRecipients.recipients.map(function (r) {
+    var _Contact$getPrimaryEm;
+
+    return {
+      index: r._id || r.id,
+      email: r.email || ((_Contact$getPrimaryEm = Contact.getPrimaryEmail) === null || _Contact$getPrimaryEm === void 0 ? void 0 : _Contact$getPrimaryEm.call(Contact, r)) || r.displayName,
+      public_name: r.displayName || r.name,
+      sharingId: null,
+      memberIndex: r._id || r.id,
+      type: 'two-way',
+      isPending: true
+    };
+  })), _toConsumableArray(pendingRecipients.readOnlyRecipients.map(function (r) {
+    var _Contact$getPrimaryEm2;
+
+    return {
+      index: r._id || r.id,
+      email: r.email || ((_Contact$getPrimaryEm2 = Contact.getPrimaryEmail) === null || _Contact$getPrimaryEm2 === void 0 ? void 0 : _Contact$getPrimaryEm2.call(Contact, r)) || r.displayName,
+      public_name: r.displayName || r.name,
+      sharingId: null,
+      memberIndex: r._id || r.id,
+      type: 'one-way',
+      isPending: true
+    };
+  })));
+  var hasPendingRecipients = pendingRecipients.recipients.length > 0 || pendingRecipients.readOnlyRecipients.length > 0; // Wrapper functions that handle both pending and existing recipients
+
+  var handleRevoke = function handleRevoke(document, sharingId, memberIndex) {
+    var recipient = allRecipients.find(function (r) {
+      return r.memberIndex === memberIndex;
+    });
+
+    if (recipient !== null && recipient !== void 0 && recipient.isPending) {
+      onRevokePending(memberIndex);
+    } else {
+      onRevoke(document, sharingId, memberIndex);
+    }
+  };
+
+  var handleSetType = function handleSetType(index, newType) {
+    var recipient = allRecipients.find(function (r) {
+      return r.index === index;
+    });
+
+    if (recipient !== null && recipient !== void 0 && recipient.isPending) {
+      onSetType(index, newType);
+    }
+  };
+
+  return /*#__PURE__*/React.createElement(ShareModal, {
+    createContact: createContact,
+    document: document,
+    documentType: documentType,
+    hasSharedChild: hasSharedChild,
+    hasSharedParent: hasSharedParent,
+    isOwner: isOwner,
+    link: link,
+    onClose: onClose,
+    onRevoke: handleRevoke,
+    onRevokeSelf: onRevokeSelf,
+    onShare: onShare,
+    onSubmit: onSubmit,
+    onSetType: handleSetType,
+    permissions: permissions,
+    recipients: allRecipients,
+    sharing: sharing,
+    sharingDesc: sharingDesc,
+    twoStepsConfirmationMethods: twoStepsConfirmationMethods,
+    batchMode: true,
+    hasPendingRecipients: hasPendingRecipients
+  });
+});
+ShareModalBatchContainer.propTypes = {
+  document: PropTypes.object.isRequired,
+  documentType: PropTypes.string,
+  isOwner: PropTypes.bool,
+  link: PropTypes.string,
+  permissions: PropTypes.array,
+  recipients: PropTypes.array,
+  sharing: PropTypes.object,
+  sharingDesc: PropTypes.string,
+  onClose: PropTypes.func.isRequired,
+  onRevoke: PropTypes.func.isRequired,
+  onRevokeSelf: PropTypes.func.isRequired,
+  share: PropTypes.func.isRequired,
+  createContact: PropTypes.func.isRequired,
+  hasSharedChild: PropTypes.bool,
+  hasSharedParent: PropTypes.bool,
+  twoStepsConfirmationMethods: PropTypes.object
+};
+export default ShareModalBatchContainer;

package/dist/components/ShareModal/ShareModalBatchContainer.spec.js

@@ -0,0 +1,131 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { render, fireEvent, waitFor, screen } from '@testing-library/react';
+import React from 'react';
+import { act } from 'react-dom/test-utils';
+import { ShareModalBatchContainer } from './ShareModalBatchContainer';
+import AppLike from '../../../test/AppLike'; // Mock ShareModal to avoid rendering the whole sub-tree
+
+jest.mock('../ShareModal', function () {
+  return {
+    ShareModal: function ShareModal(_ref) {
+      var onShare = _ref.onShare,
+          onSubmit = _ref.onSubmit,
+          recipients = _ref.recipients;
+      return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
+        "data-testid": "recipients-count"
+      }, recipients.length), /*#__PURE__*/React.createElement("button", {
+        onClick: function onClick() {
+          return onShare({
+            recipients: [{
+              id: 'new',
+              email: 'new@cozy.cc'
+            }]
+          });
+        }
+      }, "Add Recipient"), /*#__PURE__*/React.createElement("button", {
+        onClick: onSubmit
+      }, "Submit"));
+    }
+  };
+});
+describe('ShareModalBatchContainer', function () {
+  var defaultProps = {
+    document: {
+      _id: 'doc1',
+      name: 'Doc 1'
+    },
+    documentType: 'Files',
+    onClose: jest.fn(),
+    onRevoke: jest.fn(),
+    onRevokeSelf: jest.fn(),
+    share: jest.fn(),
+    createContact: jest.fn(),
+    recipients: []
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('should accumulate recipients and call share on submit', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(ShareModalBatchContainer, defaultProps))); // Add a recipient
+
+          act(function () {
+            fireEvent.click(screen.getByText('Add Recipient'));
+          });
+          expect(screen.getByTestId('recipients-count').textContent).toBe('1'); // Submit
+
+          act(function () {
+            fireEvent.click(screen.getByText('Submit'));
+          });
+          _context.next = 6;
+          return waitFor(function () {
+            expect(defaultProps.share).toHaveBeenCalledWith(expect.objectContaining({
+              recipients: [{
+                id: 'new',
+                email: 'new@cozy.cc'
+              }],
+              readOnlyRecipients: []
+            }));
+          });
+
+        case 6:
+          _context.next = 8;
+          return waitFor(function () {
+            expect(screen.getByTestId('recipients-count').textContent).toBe('0');
+          });
+
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('should not call share if no pending recipients', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(ShareModalBatchContainer, defaultProps)));
+          act(function () {
+            fireEvent.click(screen.getByText('Submit'));
+          });
+          expect(defaultProps.share).not.toHaveBeenCalled();
+
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('should combine existing and pending recipients correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var existingRecipients;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          existingRecipients = [{
+            index: 'old1',
+            email: 'old1@cozy.cc',
+            public_name: 'Old 1'
+          }];
+          render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(ShareModalBatchContainer, _extends({}, defaultProps, {
+            recipients: existingRecipients
+          })))); // Initial count should be 1 (the existing one)
+
+          expect(screen.getByTestId('recipients-count').textContent).toBe('1'); // Add a recipient
+
+          act(function () {
+            fireEvent.click(screen.getByText('Add Recipient'));
+          }); // Count should be 2
+
+          expect(screen.getByTestId('recipients-count').textContent).toBe('2');
+
+        case 5:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+});

package/dist/components/ShareModal/SharedDriveEditModal.js

@@ -0,0 +1,59 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["document"];
+import PropTypes from "prop-types";
+import React from "react";
+import { useClient } from "cozy-client";
+import flag from "cozy-flags";
+import withLocales from "../../hoc/withLocales";
+import { useFetchDocumentPath } from "../../hooks/useFetchDocumentPath";
+import { useSharingContext } from "../../hooks/useSharingContext";
+import { Contact } from "../../models";
+import { ShareModal } from "../ShareModal";
+export var SharedDriveEditModal = withLocales(function (_ref) {
+  var document = _ref.document,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  var client = useClient();
+  var documentPath = useFetchDocumentPath(client, document);
+
+  var _useSharingContext = useSharingContext(),
+      documentType = _useSharingContext.documentType,
+      getDocumentPermissions = _useSharingContext.getDocumentPermissions,
+      getRecipients = _useSharingContext.getRecipients,
+      getSharingForSelf = _useSharingContext.getSharingForSelf,
+      getSharingLink = _useSharingContext.getSharingLink,
+      hasSharedChild = _useSharingContext.hasSharedChild,
+      hasSharedParent = _useSharingContext.hasSharedParent,
+      isOwner = _useSharingContext.isOwner,
+      revoke = _useSharingContext.revoke,
+      revokeSelf = _useSharingContext.revokeSelf,
+      share = _useSharingContext.share; // TODO get sharing from document
+
+
+  var sharingDoc = getSharingForSelf(document._id);
+  var sharingDesc = sharingDoc.rules[0].title;
+  return /*#__PURE__*/React.createElement(ShareModal, _extends({
+    createContact: function createContact(contact) {
+      return client.create(Contact.doctype, contact);
+    },
+    document: document,
+    documentType: documentType,
+    hasSharedChild: documentPath && hasSharedChild(documentPath),
+    hasSharedParent: documentPath && hasSharedParent(documentPath),
+    isOwner: isOwner(document._id),
+    link: getSharingLink(document._id),
+    onRevoke: revoke,
+    onRevokeSelf: revokeSelf,
+    onShare: share,
+    showShareByLink: false,
+    permissions: getDocumentPermissions(document._id),
+    recipients: getRecipients(document._id),
+    sharing: getSharingForSelf(document._id),
+    sharingDesc: sharingDesc
+  }, rest));
+});
+SharedDriveEditModal.propTypes = {
+  document: PropTypes.object
+};
+export default SharedDriveEditModal;