hyperzlib
/
nodebb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: async/await uploads

Browse Source
v1.18.x
Barış Soner Uşaklı 6 years ago
parent b2423baeec
commit 5c0266d8c4
1 changed files with 135 additions and 178 deletions
Show Stats Download Patch File Download Diff File

313
src/controllers/uploads.js
Unescape Escape 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 = function (req, res, next) { uploadsController.uploadPost = async function (req, res) {
uploadsController.upload(req, res, function (uploadedFile, next) { await uploadsController.upload(req, res, async function (uploadedFile) {
var isImage = uploadedFile.type.match(/image./); const isImage = uploadedFile.type.match(/image./);
if (isImage) { if (isImage) {
uploadAsImage(req, uploadedFile, next); return await uploadAsImage(req, uploadedFile);
} else {
uploadAsFile(req, uploadedFile, next);
} }
}, next); return await uploadAsFile(req, uploadedFile);
});
}; };
function uploadAsImage(req, uploadedFile, callback) { async function uploadAsImage(req, uploadedFile) {
async.waterfall([ const canUpload = await privileges.global.can('upload:post:image', req.uid);
function (next) { if (!canUpload) {
privileges.global.can('upload:post:image', req.uid, next); throw new Error('[[error:no-privileges]]');
}, }
function (canUpload, next) { await image.checkDimensions(uploadedFile.path);
if (!canUpload) { await image.stripEXIF(uploadedFile.path);
return next(new Error('[[error:no-privileges]]'));
} if (plugins.hasListeners('filter:uploadImage')) {
image.checkDimensions(uploadedFile.path, next); return await plugins.fireHook('filter:uploadImage', {
}, image: uploadedFile,
function (next) { uid: req.uid,
image.stripEXIF(uploadedFile.path, next); });
}, }
function (next) { await file.isFileTypeAllowed(uploadedFile.path);
if (plugins.hasListeners('filter:uploadImage')) {
return plugins.fireHook('filter:uploadImage', { let fileObj = await uploadsController.uploadFile(req.uid, uploadedFile);
image: uploadedFile,
uid: req.uid, if (meta.config.resizeImageWidth === 0 || meta.config.resizeImageWidthThreshold === 0) {
}, callback); return fileObj;
} }
file.isFileTypeAllowed(uploadedFile.path, next);
}, fileObj = await resizeImage(fileObj);
function (next) { return { url: fileObj.url };
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);
},
function (fileObj, next) {
next(null, { url: fileObj.url });
},
], callback);
} }
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) { await image.resizeImage({
return callback(null, fileObj); path: fileObj.path,
} target: file.appendToFileName(fileObj.path, '-resized'),
width: meta.config.resizeImageWidth,
image.resizeImage({ quality: meta.config.resizeImageQuality,
path: fileObj.path, });
target: file.appendToFileName(fileObj.path, '-resized'), // Return the resized version to the composer/postData
width: meta.config.resizeImageWidth, fileObj.url = file.appendToFileName(fileObj.url, '-resized');
quality: meta.config.resizeImageQuality,
}, next); return fileObj;
},
function (next) {
// Return the resized version to the composer/postData
fileObj.url = file.appendToFileName(fileObj.url, '-resized');
next(null, 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,
file.isFileTypeAllowed(uploadedFile.path, next); width: meta.config.topicThumbSize,
}, height: meta.config.topicThumbSize,
function (next) { });
image.resizeImage({ if (plugins.hasListeners('filter:uploadImage')) {
path: uploadedFile.path, return await plugins.fireHook('filter:uploadImage', {
width: meta.config.topicThumbSize, image: uploadedFile,
height: meta.config.topicThumbSize, uid: req.uid,
}, next); });
}, }
function (next) {
if (plugins.hasListeners('filter:uploadImage')) { return await uploadsController.uploadFile(req.uid, uploadedFile);
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([ const upload = await file.saveFileToLocal(filename, 'files', uploadedFile.path);
function (next) { const storedFile = {
file.saveFileToLocal(filename, 'files', uploadedFile.path, next); url: nconf.get('relative_path') + upload.url,
}, path: upload.path,
function (upload, next) { name: uploadedFile.name,
storedFile = { };
url: nconf.get('relative_path') + upload.url, const fileKey = upload.url.replace(nconf.get('upload_url'), '');
path: upload.path, await db.sortedSetAdd('uid:' + uid + ':uploads', Date.now(), fileKey);
name: uploadedFile.name, const data = await plugins.fireHook('filter:uploadStored', { uid: uid, uploadedFile: uploadedFile, storedFile: storedFile });
}; return data.storedFile;
var fileKey = upload.url.replace(nconf.get('upload_url'), '');
db.sortedSetAdd('uid:' + uid + ':uploads', Date.now(), fileKey, next);
},
function (next) {
plugins.fireHook('filter:uploadStored', { uid: uid, uploadedFile: uploadedFile, storedFile: storedFile }, next);
},
function (data, next) {
next(null, data.storedFile);
},
], callback);
} }
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']);

Write Preview
Loading…
Cancel
Save