Skip to content

Node.js based forum software built for the modern web

6.8 KB
Raw Blame
'use strict';

const path = require('path');
const { fileTypeFromFile } = require('file-type');
const nconf = require('nconf');

const user = require('../user');
const meta = require('../meta');
const file = require('../file');
const plugins = require('../plugins');
const image = require('../image');
const privileges = require('../privileges');

const helpers = require('./helpers');

const uploadsController = module.exports;

uploadsController.upload = async function (req, res, filesIterator) {
	const { files } = req;

	if (!Array.isArray(files)) {
		return helpers.formatApiResponse(500, res, new Error('[[error:invalid-file]]'));
	}

	try {
		const images = [];
		for (const fileObj of files) {
			/* eslint-disable no-await-in-loop */
			await validateFileExtension(fileObj);
			images.push(await filesIterator(fileObj));
		}

		helpers.formatApiResponse(200, res, { images });

		return images;
	} catch (err) {
		return helpers.formatApiResponse(500, res, err);
	}
};

uploadsController.uploadPost = async function (req, res) {
	await uploadsController.upload(req, res, async (uploadedFile) => {
		const detected = await fileTypeFromFile(uploadedFile.path);
		const isImage = detected && detected.mime.startsWith('image/');
		if (isImage) {
			return await uploadAsImage(req, uploadedFile);
		}
		return await uploadAsFile(req, uploadedFile);
	});
};

async function uploadAsImage(req, uploadedFile) {
	const canUpload = await privileges.global.can('upload:post:image', req.uid);
	if (!canUpload) {
		throw new Error('[[error:no-privileges]]');
	}
	await image.checkDimensions(uploadedFile.path);
	await image.stripEXIF({ path: uploadedFile.path, type: uploadedFile.type });

	if (plugins.hooks.hasListeners('filter:uploadImage')) {
		return await plugins.hooks.fire('filter:uploadImage', {
			image: uploadedFile,
			uid: req.uid,
			folder: 'files',
		});
	}
	await image.isFileTypeAllowed(uploadedFile.path);

	let fileObj = await uploadsController.uploadFile(req.uid, uploadedFile);
	// sharp can't save svgs skip resize for them
	const isSVG = uploadedFile.type === 'image/svg+xml';
	const resizeDisabled = meta.config.resizeImageWidth === 0 || meta.config.resizeImageWidthThreshold === 0;
	if (!isSVG && !resizeDisabled) {
		fileObj = await resizeImage({ ...fileObj, type: uploadedFile.type });
	}

	return { url: fileObj.url, name: fileObj.name };
}

async function uploadAsFile(req, uploadedFile) {
	const canUpload = await privileges.global.can('upload:post:file', req.uid);
	if (!canUpload) {
		throw new Error('[[error:no-privileges]]');
	}

	const fileObj = await uploadsController.uploadFile(req.uid, uploadedFile);
	return {
		url: fileObj.url,
		name: fileObj.name,
	};
}

async function resizeImage(fileObj) {
	const imageData = await image.size(fileObj.path);
	if (
		imageData.width < meta.config.resizeImageWidthThreshold ||
		meta.config.resizeImageWidth > meta.config.resizeImageWidthThreshold
	) {
		return fileObj;
	}

	await image.resizeImage({
		path: fileObj.path,
		type: fileObj.type,
		target: meta.config.resizeImageKeepOriginal ?
			file.appendToFileName(fileObj.path, '-resized') :
			fileObj.path,
		width: meta.config.resizeImageWidth,
		quality: meta.config.resizeImageQuality,
	});
	// Return the resized version to the composer/postData
	if (meta.config.resizeImageKeepOriginal) {
		fileObj.url = file.appendToFileName(fileObj.url, '-resized');
	}

	return fileObj;
}

uploadsController.uploadThumb = async function (req, res) {
	if (!meta.config.allowTopicsThumbnail) {
		return helpers.formatApiResponse(503, res, new Error('[[error:topic-thumbnails-are-disabled]]'));
	}
	const canUpload = await privileges.global.can('upload:post:image', req.uid);
	if (!canUpload) {
		throw new Error('[[error:no-privileges]]');
	}

	return await uploadsController.upload(req, res, async (uploadedFile) => {
		const detected = await fileTypeFromFile(uploadedFile.path);
		const isImage = detected && detected.mime.startsWith('image/');
		if (!isImage) {
			throw new Error('[[error:invalid-file]]');
		}

		await image.isFileTypeAllowed(uploadedFile.path);
		const dimensions = await image.checkDimensions(uploadedFile.path);

		if (dimensions.width > parseInt(meta.config.topicThumbSize, 10)) {
			await image.resizeImage({
				path: uploadedFile.path,
				type: uploadedFile.type,
				width: meta.config.topicThumbSize,
			});
		}
		if (plugins.hooks.hasListeners('filter:uploadImage')) {
			return await plugins.hooks.fire('filter:uploadImage', {
				image: uploadedFile,
				uid: req.uid,
				folder: 'files',
			});
		}

		const storedFile = await uploadsController.uploadFile(req.uid, uploadedFile);
		return {
			url: storedFile.url,
			name: storedFile.name,
		};
	});
};

uploadsController.uploadFile = async function (uid, uploadedFile) {
	if (plugins.hooks.hasListeners('filter:uploadFile')) {
		return await plugins.hooks.fire('filter:uploadFile', {
			file: uploadedFile,
			uid: uid,
			folder: 'files',
		});
	}

	if (!uploadedFile) {
		throw new Error('[[error:invalid-file]]');
	}
	const isAdmin = await user.isAdministrator(uid);
	if (!isAdmin && uploadedFile.size > meta.config.maximumFileSize * 1024) {
		throw new Error(`[[error:file-too-big, ${meta.config.maximumFileSize}]]`);
	}

	return await saveFileToLocal(uid, 'files', uploadedFile);
};

async function saveFileToLocal(uid, folder, uploadedFile) {
	const name = uploadedFile.name || 'upload';
	const extension = path.extname(name) || '';

	const basename = extension ? name.slice(0, -extension.length) : name;
	const filename = `${Date.now()}-${basename.slice(0, 255)}${extension}`;

	const upload = await file.saveFileToLocal(filename, folder, uploadedFile.path, { unique: true });
	const storedFile = {
		url: nconf.get('relative_path') + upload.url,
		path: upload.path,
		name: uploadedFile.name,
	};

	await user.associateUpload(uid, upload.url.replace(`${nconf.get('upload_url')}`, ''));
	const data = await plugins.hooks.fire('filter:uploadStored', {
		uid,
		uploadedFile,
		storedFile,
	});
	return data.storedFile;
}

async function validateFileExtension(uploadedFile) {
	const allowed = file.allowedExtensions();
	const blocked = file.blockedExtensions();
	function validateExtension(extension) {
		if (allowed.length > 0 && (!extension || extension === '.' || !allowed.includes(extension))) {
			throw new Error(`[[error:invalid-file-type, ${extension}, ${allowed.join('&#44; ')}]]`);
		}
		if (blocked.length > 0 && (!extension || extension === '.' || blocked.includes(extension))) {
			throw new Error(`[[error:blocked-file-type, ${extension || 'unknown'}]]`);
		}
	}
	const extension = path.extname(uploadedFile.name).toLowerCase();
	validateExtension(extension);

	const detected = await fileTypeFromFile(uploadedFile.path);
	const detectedExtension = detected ? `.${detected.ext}` : '';
	if (detectedExtension && detectedExtension !== extension) {
		validateExtension(detectedExtension);
	}
}

require('../promisify')(uploadsController, ['upload', 'uploadPost', 'uploadThumb']);