Nemcio/NodeBB
1
0
Fork 0
mirror of https://github.com/NodeBB/NodeBB.git synced 2025-11-01 11:35:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: async/await uploads

Browse Source
This commit is contained in:
Barış Soner Uşaklı
2019-09-12 12:41:59 -04:00
parent b2423baeec
commit 5c0266d8c4
1 changed files with 131 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

305
src/controllers/uploads.js
View File

@@ -1,21 +1,22 @@
'use strict'; 'use strict';
var path = require('path'); const path = require('path');
var async = require('async'); const nconf = require('nconf');
var nconf = require('nconf'); const validator = require('validator');
var validator = require('validator'); const winston = require('winston');
const util = require('util');
var db = require('../database'); const db = require('../database');
var meta = require('../meta'); const meta = require('../meta');
var file = require('../file'); const file = require('../file');
var plugins = require('../plugins'); const plugins = require('../plugins');
var image = require('../image'); const image = require('../image');
var privileges = require('../privileges'); const privileges = require('../privileges');
var uploadsController = module.exports; const uploadsController = module.exports;
uploadsController.upload = function (req, res, filesIterator) { uploadsController.upload = async function (req, res, filesIterator) {
var files = req.files.files; let files = req.files.files;
if (!Array.isArray(files)) { if (!Array.isArray(files)) {
return res.status(500).json('invalid files'); return res.status(500).json('invalid files');
@@ -25,210 +26,166 @@ uploadsController.upload = function (req, res, filesIterator) {
files = files[0]; files = files[0];
} }
async.mapSeries(files, filesIterator, function (err, images) { // backwards compatibility
deleteTempFiles(files); if (filesIterator.constructor && filesIterator.constructor.name !== 'AsyncFunction') {
winston.warn('[deprecated] uploadsController.upload, use an async function as iterator');
if (err) { filesIterator = util.promisify(filesIterator);
return res.status(500).json({ path: req.path, error: err.message }); }
}
try {
const images = await Promise.all(files.map(fileObj => filesIterator(fileObj)));
res.status(200).json(images); res.status(200).json(images);
} catch (err) {
res.status(500).json({ path: req.path, error: err.message });
} finally {
deleteTempFiles(files);
}
};
uploadsController.uploadPost = async function (req, res) {
await uploadsController.upload(req, res, async function (uploadedFile) {
const isImage = uploadedFile.type.match(/image./);
if (isImage) {
return await uploadAsImage(req, uploadedFile);
}
return await uploadAsFile(req, uploadedFile);
}); });
}; };
uploadsController.uploadPost = function (req, res, next) { async function uploadAsImage(req, uploadedFile) {
uploadsController.upload(req, res, function (uploadedFile, next) { const canUpload = await privileges.global.can('upload:post:image', req.uid);
var isImage = uploadedFile.type.match(/image./); if (!canUpload) {
if (isImage) { throw new Error('[[error:no-privileges]]');
uploadAsImage(req, uploadedFile, next); }
} else { await image.checkDimensions(uploadedFile.path);
uploadAsFile(req, uploadedFile, next); await image.stripEXIF(uploadedFile.path);
}
}, next);
};
function uploadAsImage(req, uploadedFile, callback) { if (plugins.hasListeners('filter:uploadImage')) {
async.waterfall([ return await plugins.fireHook('filter:uploadImage', {
function (next) { image: uploadedFile,
privileges.global.can('upload:post:image', req.uid, next); uid: req.uid,
}, });
function (canUpload, next) { }
if (!canUpload) { await file.isFileTypeAllowed(uploadedFile.path);
return next(new Error('[[error:no-privileges]]'));
}
image.checkDimensions(uploadedFile.path, next);
},
function (next) {
image.stripEXIF(uploadedFile.path, next);
},
function (next) {
if (plugins.hasListeners('filter:uploadImage')) {
return plugins.fireHook('filter:uploadImage', {
image: uploadedFile,
uid: req.uid,
}, callback);
}
file.isFileTypeAllowed(uploadedFile.path, next);
},
function (next) {
uploadsController.uploadFile(req.uid, uploadedFile, next);
},
function (fileObj, next) {
if (meta.config.resizeImageWidth === 0 || meta.config.resizeImageWidthThreshold === 0) {
return next(null, fileObj);
}
resizeImage(fileObj, next); let fileObj = await uploadsController.uploadFile(req.uid, uploadedFile);
},
function (fileObj, next) { if (meta.config.resizeImageWidth === 0 || meta.config.resizeImageWidthThreshold === 0) {
next(null, { url: fileObj.url }); return fileObj;
}, }
], callback);
fileObj = await resizeImage(fileObj);
return { url: fileObj.url };
} }
function uploadAsFile(req, uploadedFile, callback) { async function uploadAsFile(req, uploadedFile) {
async.waterfall([ const canUpload = await privileges.global.can('upload:post:file', req.uid);
function (next) { if (!canUpload) {
privileges.global.can('upload:post:file', req.uid, next); throw new Error('[[error:no-privileges]]');
}, }
function (canUpload, next) {
if (!canUpload) { if (!meta.config.allowFileUploads) {
return next(new Error('[[error:no-privileges]]')); throw new Error('[[error:uploads-are-disabled]]');
} }
if (!meta.config.allowFileUploads) {
return next(new Error('[[error:uploads-are-disabled]]')); const fileObj = await uploadsController.uploadFile(req.uid, uploadedFile);
} return {
uploadsController.uploadFile(req.uid, uploadedFile, next); url: fileObj.url,
}, name: fileObj.name,
function (fileObj, next) { };
next(null, {
url: fileObj.url,
name: fileObj.name,
});
},
], callback);
} }
function resizeImage(fileObj, callback) { async function resizeImage(fileObj) {
async.waterfall([ const imageData = await image.size(fileObj.path);
function (next) { if (imageData.width < meta.config.resizeImageWidthThreshold || meta.config.resizeImageWidth > meta.config.resizeImageWidthThreshold) {
image.size(fileObj.path, next); return fileObj;
}, }
function (imageData, next) {
if (imageData.width < meta.config.resizeImageWidthThreshold || meta.config.resizeImageWidth > meta.config.resizeImageWidthThreshold) {
return callback(null, fileObj);
}
image.resizeImage({ await image.resizeImage({
path: fileObj.path, path: fileObj.path,
target: file.appendToFileName(fileObj.path, '-resized'), target: file.appendToFileName(fileObj.path, '-resized'),
width: meta.config.resizeImageWidth, width: meta.config.resizeImageWidth,
quality: meta.config.resizeImageQuality, quality: meta.config.resizeImageQuality,
}, next); });
}, // Return the resized version to the composer/postData
function (next) { fileObj.url = file.appendToFileName(fileObj.url, '-resized');
// Return the resized version to the composer/postData
fileObj.url = file.appendToFileName(fileObj.url, '-resized');
next(null, fileObj); return fileObj;
},
], callback);
} }
uploadsController.uploadThumb = function (req, res, next) { uploadsController.uploadThumb = async function (req, res, next) {
if (!meta.config.allowTopicsThumbnail) { if (!meta.config.allowTopicsThumbnail) {
deleteTempFiles(req.files.files); deleteTempFiles(req.files.files);
return next(new Error('[[error:topic-thumbnails-are-disabled]]')); return next(new Error('[[error:topic-thumbnails-are-disabled]]'));
} }
uploadsController.upload(req, res, function (uploadedFile, next) { await uploadsController.upload(req, res, async function (uploadedFile) {
async.waterfall([ if (!uploadedFile.type.match(/image./)) {
function (next) { throw new Error('[[error:invalid-file]]');
if (!uploadedFile.type.match(/image./)) { }
return next(new Error('[[error:invalid-file]]')); await file.isFileTypeAllowed(uploadedFile.path);
} await image.resizeImage({
path: uploadedFile.path,
width: meta.config.topicThumbSize,
height: meta.config.topicThumbSize,
});
if (plugins.hasListeners('filter:uploadImage')) {
return await plugins.fireHook('filter:uploadImage', {
image: uploadedFile,
uid: req.uid,
});
}
file.isFileTypeAllowed(uploadedFile.path, next); return await uploadsController.uploadFile(req.uid, uploadedFile);
}, });
function (next) {
image.resizeImage({
path: uploadedFile.path,
width: meta.config.topicThumbSize,
height: meta.config.topicThumbSize,
}, next);
},
function (next) {
if (plugins.hasListeners('filter:uploadImage')) {
return plugins.fireHook('filter:uploadImage', {
image: uploadedFile,
uid: req.uid,
}, next);
}
uploadsController.uploadFile(req.uid, uploadedFile, next);
},
], next);
}, next);
}; };
uploadsController.uploadFile = function (uid, uploadedFile, callback) { uploadsController.uploadFile = async function (uid, uploadedFile) {
if (plugins.hasListeners('filter:uploadFile')) { if (plugins.hasListeners('filter:uploadFile')) {
return plugins.fireHook('filter:uploadFile', { return await plugins.fireHook('filter:uploadFile', {
file: uploadedFile, file: uploadedFile,
uid: uid, uid: uid,
}, callback); });
} }
if (!uploadedFile) { if (!uploadedFile) {
return callback(new Error('[[error:invalid-file]]')); throw new Error('[[error:invalid-file]]');
} }
if (uploadedFile.size > meta.config.maximumFileSize * 1024) { if (uploadedFile.size > meta.config.maximumFileSize * 1024) {
return callback(new Error('[[error:file-too-big, ' + meta.config.maximumFileSize + ']]')); throw new Error('[[error:file-too-big, ' + meta.config.maximumFileSize + ']]');
} }
var allowed = file.allowedExtensions(); const allowed = file.allowedExtensions();
var extension = path.extname(uploadedFile.name).toLowerCase(); const extension = path.extname(uploadedFile.name).toLowerCase();
if (allowed.length > 0 && (!extension || extension === '.' || !allowed.includes(extension))) { if (allowed.length > 0 && (!extension || extension === '.' || !allowed.includes(extension))) {
return callback(new Error('[[error:invalid-file-type, ' + allowed.join('&#44; ') + ']]')); throw new Error('[[error:invalid-file-type, ' + allowed.join('&#44; ') + ']]');
} }
saveFileToLocal(uid, uploadedFile, callback); return await saveFileToLocal(uid, uploadedFile);
}; };
function saveFileToLocal(uid, uploadedFile, callback) { async function saveFileToLocal(uid, uploadedFile) {
var filename = uploadedFile.name || 'upload'; const name = uploadedFile.name || 'upload';
var extension = path.extname(filename) || ''; const extension = path.extname(name) || '';
filename = Date.now() + '-' + validator.escape(filename.substr(0, filename.length - extension.length)).substr(0, 255) + extension; const filename = Date.now() + '-' + validator.escape(name.substr(0, name.length - extension.length)).substr(0, 255) + extension;
var storedFile;
async.waterfall([
function (next) {
file.saveFileToLocal(filename, 'files', uploadedFile.path, next);
},
function (upload, next) {
storedFile = {
url: nconf.get('relative_path') + upload.url,
path: upload.path,
name: uploadedFile.name,
};
var fileKey = upload.url.replace(nconf.get('upload_url'), ''); const upload = await file.saveFileToLocal(filename, 'files', uploadedFile.path);
db.sortedSetAdd('uid:' + uid + ':uploads', Date.now(), fileKey, next); const storedFile = {
}, url: nconf.get('relative_path') + upload.url,
function (next) { path: upload.path,
plugins.fireHook('filter:uploadStored', { uid: uid, uploadedFile: uploadedFile, storedFile: storedFile }, next); name: uploadedFile.name,
}, };
function (data, next) { const fileKey = upload.url.replace(nconf.get('upload_url'), '');
next(null, data.storedFile); await db.sortedSetAdd('uid:' + uid + ':uploads', Date.now(), fileKey);
}, const data = await plugins.fireHook('filter:uploadStored', { uid: uid, uploadedFile: uploadedFile, storedFile: storedFile });
], callback); return data.storedFile;
} }
function deleteTempFiles(files) { function deleteTempFiles(files) {
async.each(files, function (fileObj, next) { files.forEach(fileObj => file.delete(fileObj.path));
file.delete(fileObj.path);
next();
});
} }
require('../promisify')(uploadsController, ['upload', 'uploadPost', 'uploadThumb']);