cozy-client 25.0.2 → 25.0.3

package/dist/models/file.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.normalize = normalize;
 exports.ensureFilePath = ensureFilePath;
 exports.getParentFolderId = getParentFolderId;
-exports.hasMetadataAttribute = exports.isReferencedByAlbum = exports.fetchFilesByQualificationRules = exports.saveFileQualification = exports.isSharingShorcutNew = exports.isSharingShortcutNew = exports.isSharingShorcut = exports.isSharingShortcut = exports.getSharingShortcutTargetDoctype = exports.getSharingShortcutTargetMime = exports.getSharingShortcutStatus = exports.isShortcut = exports.shouldBeOpenedByOnlyOffice = exports.isOnlyOfficeFile = exports.isNote = exports.isDirectory = exports.isFile = exports.splitFilename = exports.ALBUMS_DOCTYPE = void 0;
+exports.doMobileUpload = exports.readMobileFile = exports.uploadFileWithConflictStrategy = exports.generateFileNameForRevision = exports.generateNewFileNameOnConflict = exports.overrideFileForPath = exports.move = exports.getFullpath = exports.hasMetadataAttribute = exports.isReferencedByAlbum = exports.fetchFilesByQualificationRules = exports.saveFileQualification = exports.isSharingShorcutNew = exports.isSharingShortcutNew = exports.isSharingShorcut = exports.isSharingShortcut = exports.getSharingShortcutTargetDoctype = exports.getSharingShortcutTargetMime = exports.getSharingShortcutStatus = exports.isShortcut = exports.shouldBeOpenedByOnlyOffice = exports.isOnlyOfficeFile = exports.isNote = exports.isDirectory = exports.isFile = exports.splitFilename = exports.ALBUMS_DOCTYPE = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -22,6 +22,8 @@ var _isString = _interopRequireDefault(require("lodash/isString"));
 
 var _has = _interopRequireDefault(require("lodash/has"));
 
+var _trimEnd = _interopRequireDefault(require("lodash/trimEnd"));
+
 var _document = require("./document");
 
 var _dsl = require("../queries/dsl");
@@ -137,7 +139,7 @@ var shouldBeOpenedByOnlyOffice = function shouldBeOpenedByOnlyOffice(file) {
 };
 /**
  *
- * @param {IOCozyFile} file io.cozy.files
+ * @param {IOCozyFile} file - io.cozy.files document
  * @returns {boolean} true if the file is a shortcut
  */
 
@@ -202,7 +204,7 @@ function getParentFolderId(file) {
 /**
  * Returns the status of a sharing shortcut.
  *
- * @param {IOCozyFile} file  - io.cozy.files document
+ * @param {IOCozyFile} file - io.cozy.files document
  *
  * @returns {string} A description of the status
  */
@@ -228,7 +230,7 @@ var getSharingShortcutTargetMime = function getSharingShortcutTargetMime(file) {
 /**
  * Returns the doctype of the target of the sharing shortcut.
  *
- * @param {IOCozyFile} file  - io.cozy.files document
+ * @param {IOCozyFile} file - io.cozy.files document
  *
  * @returns {string} A doctype
  */
@@ -242,7 +244,7 @@ var getSharingShortcutTargetDoctype = function getSharingShortcutTargetDoctype(f
 /**
  * Returns whether the file is a shortcut to a sharing
  *
- * @param {IOCozyFile} file  - io.cozy.files document
+ * @param {IOCozyFile} file - io.cozy.files document
  *
  * @returns {boolean}
  */
@@ -257,7 +259,7 @@ var isSharingShortcut = function isSharingShortcut(file) {
  * Returns whether the file is a shortcut to a sharing
  *
  * @deprecated Prefer to use isSharingShortcut.
- * @param {IOCozyFile} file  - io.cozy.files document
+ * @param {IOCozyFile} file - io.cozy.files document
  *
  * @returns {boolean}
  */
@@ -272,7 +274,7 @@ var isSharingShorcut = function isSharingShorcut(file) {
 /**
  * Returns whether the sharing shortcut is new
  *
- * @param {IOCozyFile} file  - io.cozy.files document
+ * @param {IOCozyFile} file - io.cozy.files document
  *
  * @returns {boolean}
  */
@@ -287,7 +289,7 @@ var isSharingShortcutNew = function isSharingShortcutNew(file) {
  * Returns whether the sharing shortcut is new
  *
  * @deprecated Prefer to use isSharingShortcutNew.
- * @param {object} file  - io.cozy.files document
+ * @param {object} file - io.cozy.files document
  *
  * @returns {boolean}
  */
@@ -305,7 +307,7 @@ var isSharingShorcutNew = function isSharingShorcutNew(file) {
  * @param {CozyClient} client - The CozyClient instance
  * @param {IOCozyFile} file - The file to qualify
  * @param {object} qualification - The file qualification
- * @returns {Promise<IOCozyFile>} - The saved file
+ * @returns {Promise<IOCozyFile>} The saved file
  */
 
 
@@ -338,7 +340,7 @@ var saveFileQualification = /*#__PURE__*/function () {
  *
  * @param {object} client - The CozyClient instance
  * @param {object} docRules - the rules containing the searched qualification and the count
- * @returns {Promise<QueryResult>} - The files found by the rules
+ * @returns {Promise<QueryResult>} The files found by the rules
  */
 
 
@@ -427,5 +429,553 @@ var hasMetadataAttribute = function hasMetadataAttribute(_ref3) {
       attribute = _ref3.attribute;
   return (0, _has.default)(file, "metadata.".concat(attribute));
 };
+/**
+ * async getFullpath - Gets a file's path
+ *
+ * @param {CozyClient} client - The CozyClient instance
+ * @param {string} dirId  - The id of the parent directory
+ * @param {string} name  - The file's name
+ * @returns {Promise<string>} The full path of the file in the cozy
+ **/
+
+
+exports.hasMetadataAttribute = hasMetadataAttribute;
+
+var getFullpath = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, dirId, name) {
+    var _yield$client$query, parentDir, parentDirectoryPath;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            if (dirId) {
+              _context3.next = 2;
+              break;
+            }
+
+            throw new Error('You must provide a dirId');
+
+          case 2:
+            _context3.next = 4;
+            return client.query((0, _dsl.Q)(_const.DOCTYPE_FILES).getById(dirId));
+
+          case 4:
+            _yield$client$query = _context3.sent;
+            parentDir = _yield$client$query.data;
+            parentDirectoryPath = (0, _trimEnd.default)(parentDir.path, '/');
+            return _context3.abrupt("return", "".concat(parentDirectoryPath, "/").concat(name));
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function getFullpath(_x6, _x7, _x8) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+/**
+ * Move file to destination.
+ *
+ * @param {CozyClient} client             - The CozyClient instance
+ * @param   {string} fileId               - The file's id (required)
+ * @param   {object} destination
+ * @param   {string} destination.folderId - The destination folder's id (required)
+ * @param   {string} destination.path     - The file's path after the move (optional, used to optimize performance in case of conflict)
+ * @param   {boolean} force               - Whether we should overwrite, i.e. put to trash, the destination in case of conflict (defaults to false).
+ * @returns {Promise}                     - A promise that returns the move action response and the deleted file id (if any) if resolved or an Error if rejected
+ *
+ */
+
+
+exports.getFullpath = getFullpath;
+
+var move = /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client, fileId, destination) {
+    var force,
+        folderId,
+        path,
+        resp,
+        destinationPath,
+        _yield$client$query2,
+        movedFile,
+        filename,
+        conflictResp,
+        _resp,
+        _args4 = arguments;
+
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            force = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : false;
+            folderId = destination.folderId, path = destination.path;
+            _context4.prev = 2;
+            _context4.next = 5;
+            return client.collection(_const.DOCTYPE_FILES).updateFileMetadata(fileId, {
+              dir_id: folderId
+            });
+
+          case 5:
+            resp = _context4.sent;
+            return _context4.abrupt("return", {
+              moved: resp.data,
+              deleted: null
+            });
+
+          case 9:
+            _context4.prev = 9;
+            _context4.t0 = _context4["catch"](2);
+
+            if (!(_context4.t0.status === 409 && force)) {
+              _context4.next = 35;
+              break;
+            }
+
+            if (!path) {
+              _context4.next = 16;
+              break;
+            }
+
+            destinationPath = path;
+            _context4.next = 24;
+            break;
+
+          case 16:
+            _context4.next = 18;
+            return client.query((0, _dsl.Q)(_const.DOCTYPE_FILES).getById(fileId));
+
+          case 18:
+            _yield$client$query2 = _context4.sent;
+            movedFile = _yield$client$query2.data;
+            filename = movedFile.name;
+            _context4.next = 23;
+            return getFullpath(client, folderId, filename);
+
+          case 23:
+            destinationPath = _context4.sent;
+
+          case 24:
+            _context4.next = 26;
+            return client.collection(_const.DOCTYPE_FILES).statByPath(destinationPath);
+
+          case 26:
+            conflictResp = _context4.sent;
+            _context4.next = 29;
+            return client.collection(_const.DOCTYPE_FILES).destroy(conflictResp.data);
+
+          case 29:
+            _context4.next = 31;
+            return client.collection(_const.DOCTYPE_FILES).updateFileMetadata(fileId, {
+              dir_id: folderId
+            });
+
+          case 31:
+            _resp = _context4.sent;
+            return _context4.abrupt("return", {
+              moved: _resp.data,
+              deleted: conflictResp.data.id
+            });
+
+          case 35:
+            throw _context4.t0;
+
+          case 36:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[2, 9]]);
+  }));
+
+  return function move(_x9, _x10, _x11) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+/**
+ *
+ * Method to upload a file even if a file with the same name already exists.
+ *
+ * @param {CozyClient} client   - The CozyClient instance
+ * @param {string} dirPath      - Fullpath of directory to upload to ex: path/to/
+ * @param {object} file         - HTML Object file
+ * @param {object} metadata     - An object containing the wanted metadata to attach
+ * @returns {Promise<IOCozyFile>} The overrided file
+ */
+
+
+exports.move = move;
+
+var overrideFileForPath = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(client, dirPath, file, metadata) {
+    var path, filesCollection, existingFile, _existingFile$data, fileId, dirId, resp, _dirId, createdFile;
+
+    return _regenerator.default.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            path = dirPath;
+            if (!path.endsWith('/')) path = path + '/';
+            filesCollection = client.collection(_const.DOCTYPE_FILES);
+            _context5.prev = 3;
+            _context5.next = 6;
+            return filesCollection.statByPath(path + file.name);
+
+          case 6:
+            existingFile = _context5.sent;
+            _existingFile$data = existingFile.data, fileId = _existingFile$data.id, dirId = _existingFile$data.dir_id;
+            _context5.next = 10;
+            return filesCollection.updateFile(file, {
+              dirId: dirId,
+              fileId: fileId,
+              metadata: metadata
+            });
+
+          case 10:
+            resp = _context5.sent;
+            return _context5.abrupt("return", resp);
+
+          case 14:
+            _context5.prev = 14;
+            _context5.t0 = _context5["catch"](3);
+
+            if (!/Not Found/.test(_context5.t0)) {
+              _context5.next = 24;
+              break;
+            }
+
+            _context5.next = 19;
+            return filesCollection.ensureDirectoryExists(path);
+
+          case 19:
+            _dirId = _context5.sent;
+            _context5.next = 22;
+            return filesCollection.createFile(file, {
+              dirId: _dirId,
+              metadata: metadata
+            });
+
+          case 22:
+            createdFile = _context5.sent;
+            return _context5.abrupt("return", createdFile);
+
+          case 24:
+            throw _context5.t0;
+
+          case 25:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5, null, [[3, 14]]);
+  }));
+
+  return function overrideFileForPath(_x12, _x13, _x14, _x15) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+/**
+ * Method to generate a new filename if there is a conflict
+ *
+ * @param {string} filenameWithoutExtension - A filename without the extension
+ * @returns {string} A filename with the right suffix
+ */
+
+
+exports.overrideFileForPath = overrideFileForPath;
+
+var generateNewFileNameOnConflict = function generateNewFileNameOnConflict(filenameWithoutExtension) {
+  //Check if the string ends by _1
+  var regex = new RegExp('(?<=_)([0-9]+)$'); // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Assertions#other_assertions
+
+  var matches = filenameWithoutExtension.match(regex);
+
+  if (matches) {
+    var versionNumber = parseInt(matches[1]); //increment versionNumber
+
+    versionNumber++;
+    var newFilenameWithoutExtension = filenameWithoutExtension.replace(regex, "".concat(versionNumber));
+    return newFilenameWithoutExtension;
+  } else {
+    return "".concat(filenameWithoutExtension, "_1");
+  }
+};
+/**
+ * Generate a file name for a revision
+ *
+ * @param {IOCozyFile} file - io.cozy.files document
+ * @param {object} revision - The revision containing the updated_at
+ * @param {function} f      - A function taking a a date and a format as arguments to generate the name.
+ */
+
+
+exports.generateNewFileNameOnConflict = generateNewFileNameOnConflict;
+
+var generateFileNameForRevision = function generateFileNameForRevision(file, revision, f) {
+  var _splitFilename = splitFilename(file),
+      filename = _splitFilename.filename,
+      extension = _splitFilename.extension;
+
+  return "".concat(filename, "_").concat(f(revision.updated_at, 'DD MMMM - HH[h]mm')).concat(extension);
+};
+/**
+ * @typedef FileUploadOptions
+ * @property {string} [name]              - The file name to upload
+ * @property {string} [dirId]             - The dirId to upload the file to
+ * @property {object} [metadata]          - An object containing the metadata to attach
+ * @property {string} [contentType]       - The file Content-Type
+ * @property {string} [conflictStrategy]  - Erase / rename
+ */
+
+/**
+ * The goal of this method is to upload a file based on a conflict strategy.
+ * Be careful: We need to check if the file exists by doing a statByPath query
+ * before trying to upload the file since if we post and the stack return a
+ * 409 conflict, we will get a SPDY_ERROR_PROTOCOL on Chrome. This is the only
+ * viable workaround
+ * If there is no conflict, then we upload the file.
+ * If there is a conflict, then we apply the conflict strategy : `erase` or `rename`:
+ *   - The `erase` strategy means an upload with a new version
+ *   - The `rename` strategy means a new upload with a new name
+ *
+ * @param {CozyClient} client         - The CozyClient instance
+ * @param {string|ArrayBuffer} file   - Can be the file path (file://) or the binary itself
+ * @param {FileUploadOptions} options - The upload options
+ */
+
+
+exports.generateFileNameForRevision = generateFileNameForRevision;
+
+var uploadFileWithConflictStrategy = /*#__PURE__*/function () {
+  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(client, file, options) {
+    var name, dirId, conflictStrategy, path, existingFile, fileId, resp, _splitFilename2, filename, extension, newFileName;
+
+    return _regenerator.default.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            name = options.name, dirId = options.dirId, conflictStrategy = options.conflictStrategy;
+            _context6.prev = 1;
+            _context6.next = 4;
+            return getFullpath(client, dirId, name);
+
+          case 4:
+            path = _context6.sent;
+            _context6.next = 7;
+            return client.collection(_const.DOCTYPE_FILES).statByPath(path);
+
+          case 7:
+            existingFile = _context6.sent;
+            fileId = existingFile.data.id;
+
+            if (!(conflictStrategy === 'erase')) {
+              _context6.next = 16;
+              break;
+            }
+
+            _context6.next = 12;
+            return client.collection(_const.DOCTYPE_FILES).updateFile(file, _objectSpread(_objectSpread({}, options), {}, {
+              fileId: fileId
+            }));
+
+          case 12:
+            resp = _context6.sent;
+            return _context6.abrupt("return", resp);
+
+          case 16:
+            // @ts-ignore
+            _splitFilename2 = splitFilename({
+              name: name,
+              type: 'file'
+            }), filename = _splitFilename2.filename, extension = _splitFilename2.extension;
+            newFileName = generateNewFileNameOnConflict(filename) + extension; //recall itself with the newFilename.
+
+            return _context6.abrupt("return", uploadFileWithConflictStrategy(client, file, _objectSpread(_objectSpread({}, options), {}, {
+              name: newFileName
+            })));
+
+          case 19:
+            _context6.next = 26;
+            break;
+
+          case 21:
+            _context6.prev = 21;
+            _context6.t0 = _context6["catch"](1);
+
+            if (!/Not Found/.test(_context6.t0.message)) {
+              _context6.next = 25;
+              break;
+            }
+
+            return _context6.abrupt("return", client.collection(_const.DOCTYPE_FILES).createFile(file, options));
+
+          case 25:
+            throw _context6.t0;
+
+          case 26:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6, null, [[1, 21]]);
+  }));
+
+  return function uploadFileWithConflictStrategy(_x16, _x17, _x18) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+/**
+ * Read a file on a mobile
+ *
+ * @param {string} fileURL - The local file path (file://)
+ */
+
+
+exports.uploadFileWithConflictStrategy = uploadFileWithConflictStrategy;
+
+var readMobileFile = /*#__PURE__*/function () {
+  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(fileURL) {
+    var p;
+    return _regenerator.default.wrap(function _callee10$(_context10) {
+      while (1) {
+        switch (_context10.prev = _context10.next) {
+          case 0:
+            /** Cordova plugin doesn't support promise since they are supporting Android 4.X.X
+             * so we have to create manually a promise to be able to write beautiful code ;)
+             */
+            p = new Promise(function (resolve, reject) {
+              var onResolvedLocalFS = /*#__PURE__*/function () {
+                var _ref9 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(fileEntry) {
+                  return _regenerator.default.wrap(function _callee9$(_context9) {
+                    while (1) {
+                      switch (_context9.prev = _context9.next) {
+                        case 0:
+                          fileEntry.file( /*#__PURE__*/function () {
+                            var _ref10 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(file) {
+                              var reader;
+                              return _regenerator.default.wrap(function _callee8$(_context8) {
+                                while (1) {
+                                  switch (_context8.prev = _context8.next) {
+                                    case 0:
+                                      reader = new FileReader();
+                                      reader.onloadend = /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+                                        return _regenerator.default.wrap(function _callee7$(_context7) {
+                                          while (1) {
+                                            switch (_context7.prev = _context7.next) {
+                                              case 0:
+                                                resolve(reader.result);
+
+                                              case 1:
+                                              case "end":
+                                                return _context7.stop();
+                                            }
+                                          }
+                                        }, _callee7);
+                                      })); // Read the file as an ArrayBuffer
+
+                                      reader.readAsArrayBuffer(file);
+
+                                    case 3:
+                                    case "end":
+                                      return _context8.stop();
+                                  }
+                                }
+                              }, _callee8);
+                            }));
+
+                            return function (_x21) {
+                              return _ref10.apply(this, arguments);
+                            };
+                          }(), function (err) {
+                            // Since this module is pretty recent, let's have this info in sentry if needed
+                            console.error('error getting fileentry file!' + err); // eslint-disable-line no-console
+
+                            reject(err);
+                          });
+
+                        case 1:
+                        case "end":
+                          return _context9.stop();
+                      }
+                    }
+                  }, _callee9);
+                }));
+
+                return function onResolvedLocalFS(_x20) {
+                  return _ref9.apply(this, arguments);
+                };
+              }();
+
+              var onError = function onError(error) {
+                reject(error);
+              };
+              /**
+               * file:/// can not be converted to a fileEntry without the Cordova's File plugin.
+               * `resolveLocalFileSystemURL` is provided by this plugin and can resolve the native
+               * path to a fileEntry readable by a `FileReader`
+               *
+               * When we finished to read the fileEntry as buffer, we start the upload process
+               *
+               */
+              // @ts-ignore
+
+
+              window.resolveLocalFileSystemURL(fileURL, onResolvedLocalFS, onError);
+            });
+            return _context10.abrupt("return", p);
+
+          case 2:
+          case "end":
+            return _context10.stop();
+        }
+      }
+    }, _callee10);
+  }));
+
+  return function readMobileFile(_x19) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+/**
+ * Upload a file on a mobile
+ *
+ * @param {CozyClient} client         - The CozyClient instance
+ * @param {string} fileURL            - The local file path (file://)
+ * @param {FileUploadOptions} options - The upload options
+ */
+
+
+exports.readMobileFile = readMobileFile;
+
+var doMobileUpload = /*#__PURE__*/function () {
+  var _ref12 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(client, fileURL, options) {
+    var file;
+    return _regenerator.default.wrap(function _callee11$(_context11) {
+      while (1) {
+        switch (_context11.prev = _context11.next) {
+          case 0:
+            _context11.next = 2;
+            return readMobileFile(fileURL);
+
+          case 2:
+            file = _context11.sent;
+            return _context11.abrupt("return", uploadFileWithConflictStrategy(client, file, options));
+
+          case 4:
+          case "end":
+            return _context11.stop();
+        }
+      }
+    }, _callee11);
+  }));
+
+  return function doMobileUpload(_x22, _x23, _x24) {
+    return _ref12.apply(this, arguments);
+  };
+}();
 
-exports.hasMetadataAttribute = hasMetadataAttribute;
+exports.doMobileUpload = doMobileUpload;