309 lines
7.4 KiB
JavaScript
309 lines
7.4 KiB
JavaScript
"use strict";
|
|
|
|
const path = require('path'),
|
|
Promise = require('bluebird'),
|
|
fs = Promise.promisifyAll(require('fs-extra')),
|
|
multer = require('multer'),
|
|
request = require('request'),
|
|
url = require('url'),
|
|
farmhash = require('farmhash'),
|
|
_ = require('lodash');
|
|
|
|
var regFolderName = new RegExp("^[a-z0-9][a-z0-9\-]*[a-z0-9]$");
|
|
const maxDownloadFileSize = 3145728; // 3 MB
|
|
|
|
/**
|
|
* Uploads
|
|
*/
|
|
module.exports = {
|
|
|
|
_uploadsPath: './repo/uploads',
|
|
_uploadsThumbsPath: './data/thumbs',
|
|
|
|
/**
|
|
* Initialize Local Data Storage model
|
|
*
|
|
* @param {Object} appconfig The application config
|
|
* @return {Object} Uploads model instance
|
|
*/
|
|
init(appconfig) {
|
|
|
|
this._uploadsPath = path.resolve(ROOTPATH, appconfig.paths.repo, 'uploads');
|
|
this._uploadsThumbsPath = path.resolve(ROOTPATH, appconfig.paths.data, 'thumbs');
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
/**
|
|
* Gets the thumbnails folder path.
|
|
*
|
|
* @return {String} The thumbs path.
|
|
*/
|
|
getThumbsPath() {
|
|
return this._uploadsThumbsPath;
|
|
},
|
|
|
|
/**
|
|
* Gets the uploads folders.
|
|
*
|
|
* @return {Array<String>} The uploads folders.
|
|
*/
|
|
getUploadsFolders() {
|
|
return db.UplFolder.find({}, 'name').sort('name').exec().then((results) => {
|
|
return (results) ? _.map(results, 'name') : [{ name: '' }];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Creates an uploads folder.
|
|
*
|
|
* @param {String} folderName The folder name
|
|
* @return {Promise} Promise of the operation
|
|
*/
|
|
createUploadsFolder(folderName) {
|
|
|
|
let self = this;
|
|
|
|
folderName = _.kebabCase(_.trim(folderName));
|
|
|
|
if(_.isEmpty(folderName) || !regFolderName.test(folderName)) {
|
|
return Promise.resolve(self.getUploadsFolders());
|
|
}
|
|
|
|
return fs.ensureDirAsync(path.join(self._uploadsPath, folderName)).then(() => {
|
|
return db.UplFolder.findOneAndUpdate({
|
|
_id: 'f:' + folderName
|
|
}, {
|
|
name: folderName
|
|
}, {
|
|
upsert: true
|
|
});
|
|
}).then(() => {
|
|
return self.getUploadsFolders();
|
|
});
|
|
|
|
},
|
|
|
|
/**
|
|
* Check if folder is valid and exists
|
|
*
|
|
* @param {String} folderName The folder name
|
|
* @return {Boolean} True if valid
|
|
*/
|
|
validateUploadsFolder(folderName) {
|
|
|
|
return db.UplFolder.findOne({ name: folderName }).then((f) => {
|
|
return (f) ? path.resolve(this._uploadsPath, folderName) : false;
|
|
});
|
|
|
|
},
|
|
|
|
/**
|
|
* Adds one or more uploads files.
|
|
*
|
|
* @param {Array<Object>} arrFiles The uploads files
|
|
* @return {Void} Void
|
|
*/
|
|
addUploadsFiles(arrFiles) {
|
|
if(_.isArray(arrFiles) || _.isPlainObject(arrFiles)) {
|
|
//this._uploadsDb.Files.insert(arrFiles);
|
|
}
|
|
return;
|
|
},
|
|
|
|
/**
|
|
* Gets the uploads files.
|
|
*
|
|
* @param {String} cat Category type
|
|
* @param {String} fld Folder
|
|
* @return {Array<Object>} The files matching the query
|
|
*/
|
|
getUploadsFiles(cat, fld) {
|
|
|
|
return db.UplFile.find({
|
|
category: cat,
|
|
folder: 'f:' + fld
|
|
}).sort('filename').exec();
|
|
|
|
},
|
|
|
|
/**
|
|
* Deletes an uploads file.
|
|
*
|
|
* @param {string} uid The file unique ID
|
|
* @return {Promise} Promise of the operation
|
|
*/
|
|
deleteUploadsFile(uid) {
|
|
|
|
let self = this;
|
|
|
|
return db.UplFile.findOneAndRemove({ _id: uid }).then((f) => {
|
|
if(f) {
|
|
return self.deleteUploadsFileTry(f, 0);
|
|
}
|
|
return true;
|
|
});
|
|
},
|
|
|
|
deleteUploadsFileTry(f, attempt) {
|
|
|
|
let self = this;
|
|
|
|
let fFolder = (f.folder && f.folder !== 'f:') ? f.folder.slice(2) : './';
|
|
|
|
return Promise.join(
|
|
fs.removeAsync(path.join(self._uploadsThumbsPath, f._id + '.png')),
|
|
fs.removeAsync(path.resolve(self._uploadsPath, fFolder, f.filename))
|
|
).catch((err) => {
|
|
if(err.code === 'EBUSY' && attempt < 5) {
|
|
return Promise.delay(100).then(() => {
|
|
return self.deleteUploadsFileTry(f, attempt + 1);
|
|
});
|
|
} else {
|
|
winston.warn('Unable to delete uploads file ' + f.filename + '. File is locked by another process and multiple attempts failed.');
|
|
return true;
|
|
}
|
|
});
|
|
|
|
},
|
|
|
|
/**
|
|
* Downloads a file from url.
|
|
*
|
|
* @param {String} fFolder The folder
|
|
* @param {String} fUrl The full URL
|
|
* @return {Promise} Promise of the operation
|
|
*/
|
|
downloadFromUrl(fFolder, fUrl) {
|
|
|
|
let self = this;
|
|
|
|
let fUrlObj = url.parse(fUrl);
|
|
let fUrlFilename = _.last(_.split(fUrlObj.pathname, '/'));
|
|
let destFolder = _.chain(fFolder).trim().toLower().value();
|
|
|
|
return upl.validateUploadsFolder(destFolder).then((destFolderPath) => {
|
|
|
|
if(!destFolderPath) {
|
|
return Promise.reject(new Error('Invalid Folder'));
|
|
}
|
|
|
|
return lcdata.validateUploadsFilename(fUrlFilename, destFolder).then((destFilename) => {
|
|
|
|
let destFilePath = path.resolve(destFolderPath, destFilename);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
let rq = request({
|
|
url: fUrl,
|
|
method: 'GET',
|
|
followRedirect: true,
|
|
maxRedirects: 5,
|
|
timeout: 10000
|
|
});
|
|
|
|
let destFileStream = fs.createWriteStream(destFilePath);
|
|
let curFileSize = 0;
|
|
|
|
rq.on('data', (data) => {
|
|
curFileSize += data.length;
|
|
if(curFileSize > maxDownloadFileSize) {
|
|
rq.abort();
|
|
destFileStream.destroy();
|
|
fs.remove(destFilePath);
|
|
reject(new Error('Remote file is too large!'));
|
|
}
|
|
}).on('error', (err) => {
|
|
destFileStream.destroy();
|
|
fs.remove(destFilePath);
|
|
reject(err);
|
|
});
|
|
|
|
destFileStream.on('finish', () => {
|
|
resolve(true);
|
|
});
|
|
|
|
rq.pipe(destFileStream);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
},
|
|
|
|
/**
|
|
* Move/Rename a file
|
|
*
|
|
* @param {String} uid The file ID
|
|
* @param {String} fld The destination folder
|
|
* @param {String} nFilename The new filename (optional)
|
|
* @return {Promise} Promise of the operation
|
|
*/
|
|
moveUploadsFile(uid, fld, nFilename) {
|
|
|
|
let self = this;
|
|
|
|
return db.UplFolder.findById('f:' + fld).then((folder) => {
|
|
if(folder) {
|
|
return db.UplFile.findById(uid).then((originFile) => {
|
|
|
|
//-> Check if rename is valid
|
|
|
|
let nameCheck = null;
|
|
if(nFilename) {
|
|
let originFileObj = path.parse(originFile.filename);
|
|
nameCheck = lcdata.validateUploadsFilename(nFilename + originFileObj.ext, folder.name);
|
|
} else {
|
|
nameCheck = Promise.resolve(originFile.filename);
|
|
}
|
|
|
|
return nameCheck.then((destFilename) => {
|
|
|
|
let originFolder = (originFile.folder && originFile.folder !== 'f:') ? originFile.folder.slice(2) : './';
|
|
let sourceFilePath = path.resolve(self._uploadsPath, originFolder, originFile.filename);
|
|
let destFilePath = path.resolve(self._uploadsPath, folder.name, destFilename);
|
|
let preMoveOps = [];
|
|
|
|
//-> Check for invalid operations
|
|
|
|
if(sourceFilePath === destFilePath) {
|
|
return Promise.reject(new Error('Invalid Operation!'));
|
|
}
|
|
|
|
//-> Delete DB entry
|
|
|
|
preMoveOps.push(db.UplFile.findByIdAndRemove(uid));
|
|
|
|
//-> Move thumbnail ahead to avoid re-generation
|
|
|
|
if(originFile.category === 'image') {
|
|
let fUid = farmhash.fingerprint32(folder.name + '/' + destFilename);
|
|
let sourceThumbPath = path.resolve(self._uploadsThumbsPath, originFile._id + '.png');
|
|
let destThumbPath = path.resolve(self._uploadsThumbsPath, fUid + '.png');
|
|
preMoveOps.push(fs.moveAsync(sourceThumbPath, destThumbPath));
|
|
} else {
|
|
preMoveOps.push(Promise.resolve(true));
|
|
}
|
|
|
|
//-> Proceed to move actual file
|
|
|
|
return Promise.all(preMoveOps).then(() => {
|
|
return fs.moveAsync(sourceFilePath, destFilePath, {
|
|
clobber: false
|
|
});
|
|
});
|
|
|
|
})
|
|
|
|
});
|
|
} else {
|
|
return Promise.reject(new Error('Invalid Destination Folder'));
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
}; |