cozy-sharing 18.0.0 → 19.0.0

package/dist/components/ShareRestrictionModal/ShareRestrictionModal.js

@@ -0,0 +1,260 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { addDays } from 'date-fns';
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { useClient } from 'cozy-client';
+import { getSharingLink as makeSharingLink } from 'cozy-client/dist/models/sharing';
+import { isMobile } from 'cozy-device-helper';
+import Button from 'cozy-ui/transpiled/react/Buttons';
+import { ConfirmDialog } from 'cozy-ui/transpiled/react/CozyDialogs';
+import Icon from 'cozy-ui/transpiled/react/Icon';
+import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert';
+import { useI18n } from 'cozy-ui/transpiled/react/providers/I18n';
+import { ShareRestrictionContentModal } from './ShareRestrictionContentModal';
+import { copyToClipboard, forwardFile, updatePermissions, makeTTL, READ_ONLY_PERMS, WRITE_PERMS, revokePermissions } from './helpers';
+import { checkIsReadOnlyPermissions } from '../../helpers/permissions';
+import { useSharingContext } from '../../hooks/useSharingContext';
+var PASSWORD_MIN_LENGTH = 4;
+export var ShareRestrictionModal = function ShareRestrictionModal(_ref) {
+  var file = _ref.file,
+      onClose = _ref.onClose;
+  var client = useClient();
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  var _useAlert = useAlert(),
+      showAlert = _useAlert.showAlert;
+
+  var _useState = useState(''),
+      _useState2 = _slicedToArray(_useState, 2),
+      password = _useState2[0],
+      setPassword = _useState2[1];
+
+  var _useState3 = useState(addDays(new Date(), 30)),
+      _useState4 = _slicedToArray(_useState3, 2),
+      selectedDate = _useState4[0],
+      setSelectedDate = _useState4[1];
+
+  var _useState5 = useState(true),
+      _useState6 = _slicedToArray(_useState5, 2),
+      isValidDate = _useState6[0],
+      setIsValidDate = _useState6[1];
+
+  var _useState7 = useState(true),
+      _useState8 = _slicedToArray(_useState7, 2),
+      isValidPassword = _useState8[0],
+      setIsValidPassword = _useState8[1];
+
+  var _useState9 = useState(true),
+      _useState10 = _slicedToArray(_useState9, 2),
+      dateToggle = _useState10[0],
+      setDateToggle = _useState10[1];
+
+  var _useState11 = useState(false),
+      _useState12 = _slicedToArray(_useState11, 2),
+      passwordToggle = _useState12[0],
+      setPasswordToggle = _useState12[1];
+
+  var _useState13 = useState(false),
+      _useState14 = _slicedToArray(_useState13, 2),
+      loading = _useState14[0],
+      setLoading = _useState14[1];
+
+  var _useSharingContext = useSharingContext(),
+      documentType = _useSharingContext.documentType,
+      getDocumentPermissions = _useSharingContext.getDocumentPermissions,
+      updateDocumentPermissions = _useSharingContext.updateDocumentPermissions,
+      shareByLink = _useSharingContext.shareByLink,
+      getSharingLink = _useSharingContext.getSharingLink,
+      revokeSharingLink = _useSharingContext.revokeSharingLink;
+
+  var hasSharingLink = getSharingLink(file._id) !== null;
+  var permissions = getDocumentPermissions(file._id);
+  var isReadOnlyPermissions = checkIsReadOnlyPermissions(permissions);
+
+  var _useState15 = useState(isReadOnlyPermissions || permissions.length === 0 ? 'readOnly' : 'write'),
+      _useState16 = _slicedToArray(_useState15, 2),
+      editingRights = _useState16[0],
+      setEditingRights = _useState16[1];
+
+  var isDesktopOrMobileWithoutShareAPI = isMobile() && !navigator.share || !isMobile();
+  var helperTextPassword = !isValidPassword ? t('ShareRestrictionModal.invalidPasswordMessage', {
+    smart_count: PASSWORD_MIN_LENGTH - password.length
+  }) : null;
+
+  var handleDateChange = function handleDateChange(date, isValid) {
+    setSelectedDate(date);
+    setIsValidDate(isValid);
+  };
+
+  var handleClick = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var verbs, url, ttl, _url;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            setLoading(true); // If the file is not shared, we create a new sharing link
+
+            if (hasSharingLink) {
+              _context.next = 10;
+              break;
+            }
+
+            verbs = editingRights === 'readOnly' ? READ_ONLY_PERMS : WRITE_PERMS;
+            _context.next = 5;
+            return shareByLink(file, {
+              verbs: verbs
+            });
+
+          case 5:
+            url = getSharingLink(file._id);
+            _context.next = 8;
+            return copyToClipboard(url, {
+              t: t,
+              showAlert: showAlert
+            });
+
+          case 8:
+            onClose();
+            return _context.abrupt("return");
+
+          case 10:
+            _context.next = 12;
+            return updatePermissions({
+              file: file,
+              t: t,
+              editingRights: editingRights,
+              documentType: documentType,
+              updateDocumentPermissions: updateDocumentPermissions,
+              showAlert: showAlert
+            });
+
+          case 12:
+            ttl = makeTTL(dateToggle && selectedDate);
+
+            if (!isDesktopOrMobileWithoutShareAPI) {
+              _context.next = 21;
+              break;
+            }
+
+            _context.next = 16;
+            return makeSharingLink(client, [file._id], {
+              ttl: ttl,
+              password: password
+            });
+
+          case 16:
+            _url = _context.sent;
+            _context.next = 19;
+            return copyToClipboard(_url, {
+              t: t,
+              showAlert: showAlert
+            });
+
+          case 19:
+            _context.next = 23;
+            break;
+
+          case 21:
+            _context.next = 23;
+            return forwardFile({
+              client: client,
+              file: file,
+              t: t,
+              ttl: ttl,
+              password: password,
+              showAlert: showAlert
+            });
+
+          case 23:
+            onClose();
+
+          case 24:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+
+    return function handleClick() {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  var handleRevokeLink = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            setLoading(true);
+            _context2.next = 3;
+            return revokePermissions({
+              file: file,
+              t: t,
+              documentType: documentType,
+              revokeSharingLink: revokeSharingLink,
+              showAlert: showAlert
+            });
+
+          case 3:
+            onClose();
+
+          case 4:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+
+    return function handleRevokeLink() {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  return /*#__PURE__*/React.createElement(ConfirmDialog, {
+    open: true,
+    onClose: onClose,
+    content: /*#__PURE__*/React.createElement(ShareRestrictionContentModal, {
+      file: file // Date
+      ,
+      dateToggle: dateToggle,
+      setDateToggle: setDateToggle,
+      setSelectedDate: handleDateChange,
+      selectedDate: selectedDate,
+      setIsValidDate: setIsValidDate // Password
+      ,
+      helperTextPassword: helperTextPassword,
+      passwordToggle: passwordToggle,
+      setPasswordToggle: setPasswordToggle,
+      password: password,
+      setPassword: setPassword,
+      setIsValidPassword: setIsValidPassword // Editing rights
+      ,
+      editingRights: editingRights,
+      setEditingRights: setEditingRights
+    }),
+    actions: /*#__PURE__*/React.createElement(React.Fragment, null, hasSharingLink && /*#__PURE__*/React.createElement(Button, {
+      label: t('Share.permissionLink.deactivate'),
+      variant: "secondary",
+      color: "error",
+      startIcon: /*#__PURE__*/React.createElement(Icon, {
+        icon: "trash"
+      }),
+      onClick: handleRevokeLink,
+      busy: loading
+    }), /*#__PURE__*/React.createElement(Button, {
+      label: t('ShareRestrictionModal.action.confirm'),
+      onClick: handleClick,
+      disabled: !isValidDate || !isValidPassword,
+      busy: loading
+    }))
+  });
+};
+ShareRestrictionModal.propTypes = {
+  file: PropTypes.object.isRequired,
+  onClose: PropTypes.func
+};

package/dist/components/ShareRestrictionModal/helpers.js

@@ -0,0 +1,275 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { getSharingLink } from 'cozy-client/dist/models/sharing';
+import minilog from 'cozy-minilog';
+var log = minilog('ShareRestrictionModal/helpers');
+export var WRITE_PERMS = ['GET', 'POST', 'PUT', 'PATCH'];
+export var READ_ONLY_PERMS = ['GET'];
+/**
+ * Copy a string to the clipboard
+ *
+ * @param {string} value - The string saved to the clipboard
+ * @param {object} [options]
+ * @param {number} options.t - Translation function
+ * @param {Function} options.showAlert - Function to display an alert
+ */
+
+export var copyToClipboard = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(value) {
+    var _ref2,
+        t,
+        showAlert,
+        _args = arguments;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _ref2 = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, t = _ref2.t, showAlert = _ref2.showAlert;
+
+          if (value) {
+            _context.next = 3;
+            break;
+          }
+
+          return _context.abrupt("return", false);
+
+        case 3:
+          _context.prev = 3;
+          _context.next = 6;
+          return navigator.clipboard.writeText(value);
+
+        case 6:
+          showAlert({
+            message: t('copyReminderContent.success'),
+            severity: 'success',
+            variant: 'filled'
+          });
+          _context.next = 13;
+          break;
+
+        case 9:
+          _context.prev = 9;
+          _context.t0 = _context["catch"](3);
+          showAlert({
+            message: t('copyReminderContent.error'),
+            severity: 'error',
+            variant: 'filled'
+          });
+          log.error("Error in 'copyToClipboard' function when trying to copy to clipboard", _context.t0);
+
+        case 13:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[3, 9]]);
+  }));
+
+  return function copyToClipboard(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Make a TTL string from a date
+ * @param {Date|string} selectedDate
+ * @returns {string} - TTL string in seconds (e.g. '1234s')
+ */
+
+export var makeTTL = function makeTTL(selectedDate) {
+  if (!selectedDate) return;
+
+  try {
+    var selectedDateConverted = selectedDate;
+
+    if (typeof selectedDate === 'string') {
+      var _selectedDateConverte;
+
+      selectedDateConverted = new Date(selectedDate);
+
+      if (((_selectedDateConverte = selectedDateConverted) === null || _selectedDateConverte === void 0 ? void 0 : _selectedDateConverte.toString()) === 'Invalid Date') {
+        throw new Error("Invalid date: ".concat(selectedDate));
+      }
+    }
+
+    if (selectedDateConverted instanceof Date) {
+      var now = new Date();
+      var ttl = selectedDateConverted > now ? "".concat(Math.round((selectedDateConverted - now) / 1000), "s") : undefined;
+      return ttl;
+    }
+
+    throw new Error("Invalid date: ".concat(selectedDate));
+  } catch (error) {
+    log.error(error);
+    return;
+  }
+};
+/**
+ * forwardFile - Triggers the download of one or multiple files by the browser
+ * @param {object} options
+ * @param {import('cozy-client/types/CozyClient').default} options.client
+ * @param {import('cozy-client/types/types').IOCozyFile} options.file File to download
+ * @param {Function} options.t i18n function
+ * @param {string} options.ttl Time to live of the sharing link
+ * @param {string} options.password Password of the sharing link
+ * @param {Function} options.showAlert - Function to display an alert
+ */
+
+export var forwardFile = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref3) {
+    var client, file, t, ttl, password, showAlert, url, isZipFile, shareData;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          client = _ref3.client, file = _ref3.file, t = _ref3.t, ttl = _ref3.ttl, password = _ref3.password, showAlert = _ref3.showAlert;
+          _context2.prev = 1;
+          _context2.next = 4;
+          return getSharingLink(client, [file._id], {
+            ttl: ttl,
+            password: password
+          });
+
+        case 4:
+          url = _context2.sent;
+          isZipFile = file.class === 'zip';
+          shareData = {
+            title: t('shareFile.title', {
+              name: file.name,
+              smart_count: isZipFile ? 2 : 1
+            }),
+            text: t('shareFile.text', {
+              name: file.name,
+              smart_count: isZipFile ? 2 : 1
+            }),
+            url: url
+          };
+          navigator.share(shareData);
+          _context2.next = 13;
+          break;
+
+        case 10:
+          _context2.prev = 10;
+          _context2.t0 = _context2["catch"](1);
+          showAlert({
+            message: t('shareFile.error'),
+            severity: 'error',
+            variant: 'filled'
+          });
+
+        case 13:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[1, 10]]);
+  }));
+
+  return function forwardFile(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+/**
+ * updatePermissions - Updates the permissions of a file
+ * @param {object} options
+ * @param {import('cozy-client/types/types').IOCozyFile} options.file File to update permissions
+ * @param {Function} options.t i18n function
+ * @param {string} options.documentType - Type of the document
+ * @param {'readOnly'|'write'} options.editingRights - Editing rights
+ * @param {Function} options.updateDocumentPermissions - Function to update permissions
+ * @param {Function} options.showAlert - Function to display an alert
+ */
+
+export var updatePermissions = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
+    var file, t, editingRights, documentType, updateDocumentPermissions, showAlert;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          file = _ref5.file, t = _ref5.t, editingRights = _ref5.editingRights, documentType = _ref5.documentType, updateDocumentPermissions = _ref5.updateDocumentPermissions, showAlert = _ref5.showAlert;
+          _context3.t0 = editingRights;
+          _context3.next = _context3.t0 === 'readOnly' ? 4 : _context3.t0 === 'write' ? 13 : 22;
+          break;
+
+        case 4:
+          _context3.prev = 4;
+          return _context3.abrupt("return", updateDocumentPermissions(file, READ_ONLY_PERMS));
+
+        case 8:
+          _context3.prev = 8;
+          _context3.t1 = _context3["catch"](4);
+          showAlert({
+            message: t("".concat(documentType, ".share.shareByLink.permserror")),
+            severity: 'error',
+            variant: 'filled'
+          });
+          log.error("Error in 'readOnlyPermissionLink' function when trying to change permission", _context3.t1);
+
+        case 12:
+          return _context3.abrupt("break", 22);
+
+        case 13:
+          _context3.prev = 13;
+          return _context3.abrupt("return", updateDocumentPermissions(file, WRITE_PERMS));
+
+        case 17:
+          _context3.prev = 17;
+          _context3.t2 = _context3["catch"](13);
+          showAlert({
+            message: t("".concat(documentType, ".share.shareByLink.permserror")),
+            severity: 'error',
+            variant: 'filled'
+          });
+          log.error("Error in 'editPermissionLink' function when trying to change permission", _context3.t2);
+
+        case 21:
+          return _context3.abrupt("break", 22);
+
+        case 22:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[4, 8], [13, 17]]);
+  }));
+
+  return function updatePermissions(_x3) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+/**
+ * revokePermissions - Revokes the permissions of a file
+ * @param {object} options
+ * @param {import('cozy-client/types/types').IOCozyFile} options.file File to revoke permissions
+ * @param {Function} options.t i18n function
+ * @param {string} options.documentType - Type of the document
+ * @param {Function} options.revokeSharingLink - Function to revoke permissions
+ * @param {Function} options.showAlert - Function to display an alert
+ */
+
+export var revokePermissions = /*#__PURE__*/function () {
+  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref7) {
+    var file, t, documentType, revokeSharingLink, showAlert;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          file = _ref7.file, t = _ref7.t, documentType = _ref7.documentType, revokeSharingLink = _ref7.revokeSharingLink, showAlert = _ref7.showAlert;
+          _context4.prev = 1;
+          return _context4.abrupt("return", revokeSharingLink(file));
+
+        case 5:
+          _context4.prev = 5;
+          _context4.t0 = _context4["catch"](1);
+          showAlert({
+            message: t("".concat(documentType, ".share.error.revoke")),
+            severity: 'error',
+            variant: 'filled'
+          });
+          log.error("Error in 'revokePermissions' function when trying to revoke sharing link", _context4.t0);
+
+        case 9:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[1, 5]]);
+  }));
+
+  return function revokePermissions(_x4) {
+    return _ref8.apply(this, arguments);
+  };
+}();

package/dist/components/ShareRestrictionModal/helpers.spec.js

@@ -0,0 +1,110 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { makeTTL, revokePermissions, updatePermissions } from './helpers';
+describe('ShareRestrictionModal/helpers', function () {
+  describe('makeTTL', function () {
+    it('sould return undefined', function () {
+      expect(makeTTL()).toBeUndefined();
+      expect(makeTTL(123)).toBeUndefined();
+      expect(makeTTL('abc')).toBeUndefined();
+      expect(makeTTL(new Date('2023-01-01T00:00:00.000Z'))).toBeUndefined();
+      expect(makeTTL(new Date('abc'))).toBeUndefined();
+      expect(makeTTL('2023-01-01T00:00:00.000Z')).toBeUndefined();
+    });
+    it('sould return TTL in seconds', function () {
+      expect(makeTTL(new Date('2100-01-01T00:00:00.000Z'))).toBeDefined();
+      expect(makeTTL('2100-01-01T00:00:00.000Z')).toBeDefined();
+    });
+  });
+  describe('updatePermissions', function () {
+    var documentType = 'Files';
+    it('should call updateDocumentPermissions with "readOnly" permission', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var updateDocumentPermissions, file, editingRights;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            updateDocumentPermissions = jest.fn();
+            file = {
+              _id: '123'
+            };
+            editingRights = 'readOnly';
+            _context.next = 5;
+            return updatePermissions({
+              file: file,
+              t: jest.fn(),
+              editingRights: editingRights,
+              documentType: documentType,
+              updateDocumentPermissions: updateDocumentPermissions,
+              showAlert: jest.fn()
+            });
+
+          case 5:
+            expect(updateDocumentPermissions).toHaveBeenCalledWith(file, ['GET']);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('should call updateDocumentPermissions with "write" permissions', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var updateDocumentPermissions, file, editingRights;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            updateDocumentPermissions = jest.fn();
+            file = {
+              _id: '123'
+            };
+            editingRights = 'write';
+            _context2.next = 5;
+            return updatePermissions({
+              file: file,
+              t: jest.fn(),
+              editingRights: editingRights,
+              documentType: documentType,
+              updateDocumentPermissions: updateDocumentPermissions,
+              showAlert: jest.fn()
+            });
+
+          case 5:
+            expect(updateDocumentPermissions).toHaveBeenCalledWith(file, ['GET', 'POST', 'PUT', 'PATCH']);
+
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+  });
+  describe('revokePermissions', function () {
+    var documentType = 'Files';
+    it('should call revokeSharingLink', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var revokeSharingLink, file;
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            revokeSharingLink = jest.fn();
+            file = {
+              _id: '123'
+            };
+            _context3.next = 4;
+            return revokePermissions({
+              file: file,
+              t: jest.fn(),
+              documentType: documentType,
+              revokeSharingLink: revokeSharingLink,
+              showAlert: jest.fn()
+            });
+
+          case 4:
+            expect(revokeSharingLink).toHaveBeenCalledWith(file);
+
+          case 5:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
+});

package/dist/components/WhoHasAccess.js

@@ -40,9 +40,7 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
       onRevokeSelf = _ref2.onRevokeSelf,
       verifyRecipient = _ref2.verifyRecipient,
       link = _ref2.link,
-      permissions = _ref2.permissions,
-      onUpdateShareLinkPermissions = _ref2.onUpdateShareLinkPermissions,
-      onRevokeLink = _ref2.onRevokeLink;
+      permissions = _ref2.permissions;
   var previousLink = usePrevious(link);
   var linkHasBeenJustCreated = link && previousLink === null;
   return /*#__PURE__*/React.createElement("div", {
@@ -56,8 +54,6 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
     onRevokeSelf: onRevokeSelf,
     link: link,
     permissions: permissions,
-    onChangePermissions: onUpdateShareLinkPermissions,
-    onDisable: onRevokeLink,
     fadeIn: linkHasBeenJustCreated
   }), /*#__PURE__*/React.createElement(OwnerRecipient, {
     recipients: recipients

package/locales/en.json

@@ -416,5 +416,33 @@
       },
       "addEmail": "Enter an email address to invite the contact"
     }
+  },
+  "ShareRestrictionModal": {
+    "action": {
+      "confirm": "Confirm"
+    },
+    "invalidPasswordMessage": "%{smart_count} character is missing |||| %{smart_count} characters are missings"
+  },
+  "BoxDate": {
+    "label": "Deadline",
+    "text": "Remove access after a deadline"
+  },
+  "BoxPassword": {
+    "label": "Password",
+    "text": "Limit access with a password"
+  },
+  "BoxEditingRights": {
+    "editSubText": "People with access to the link can modify the content",
+    "readOnlySubText": "People who have access to the link can only view the content",
+    "text": "Editing rights"
+  },
+  "copyReminderContent": {
+    "success": "Copied to clipboard",
+    "error": "Cannot copy to clipboard"
+  },
+  "shareFile": {
+    "error": "Problem with link recovery: %{error}",
+    "text": "Link to my document %{name}: |||| Link to my documents %{name}: ",
+    "title": "Link to my document %{name} |||| Link to my documents %{name}"
   }
 }