filesafe/controllers/uploadController.js

290 lines
8.1 KiB
JavaScript
Raw Normal View History

2017-10-04 00:13:38 +00:00
const config = require('../config.js');
const path = require('path');
const multer = require('multer');
const randomstring = require('randomstring');
const db = require('knex')(config.database);
const crypto = require('crypto');
const fs = require('fs');
const utils = require('./utilsController.js');
2017-01-13 07:34:21 +00:00
2017-10-04 00:13:38 +00:00
const uploadsController = {};
2017-01-13 07:34:21 +00:00
const storage = multer.diskStorage({
2017-03-17 04:14:24 +00:00
destination: function(req, file, cb) {
2017-10-04 00:13:38 +00:00
cb(null, path.join(__dirname, '..', config.uploads.folder));
2017-01-13 07:34:21 +00:00
},
2017-03-17 04:14:24 +00:00
filename: function(req, file, cb) {
2017-10-04 00:13:38 +00:00
cb(null, randomstring.generate(config.uploads.fileLength) + path.extname(file.originalname));
2017-01-13 07:34:21 +00:00
}
2017-10-04 00:13:38 +00:00
});
2017-01-13 07:34:21 +00:00
const upload = multer({
storage: storage,
limits: { fileSize: config.uploads.maxSize },
fileFilter: function(req, file, cb) {
if (config.blockedExtensions !== undefined) {
if (config.blockedExtensions.some(extension => path.extname(file.originalname).toLowerCase() === extension)) {
return cb('This file extension is not allowed');
}
return cb(null, true);
}
return cb(null, true);
}
2017-10-04 00:13:38 +00:00
}).array('files[]');
2017-01-13 07:34:21 +00:00
2017-10-04 00:13:38 +00:00
uploadsController.upload = async (req, res, next) => {
if (config.private === true) {
await utils.authorize(req, res);
}
2017-01-13 07:34:21 +00:00
2017-10-04 00:13:38 +00:00
const token = req.headers.token || '';
const user = await db.table('users').where('token', token).first();
if (user.enabled === false || user.enabled === 0) return res.json({
success: false,
description: 'This account has been disabled'
});
2017-10-04 00:13:38 +00:00
const albumid = req.headers.albumid || req.params.albumid;
2017-01-19 06:34:48 +00:00
2017-10-04 00:13:38 +00:00
if (albumid && user) {
const album = await db.table('albums').where({ id: albumid, userid: user.id }).first();
2017-10-04 00:13:38 +00:00
if (!album) {
2017-08-30 22:35:40 +00:00
return res.json({
success: false,
2017-10-04 00:13:38 +00:00
description: 'Album doesn\'t exist or it doesn\'t belong to the user'
});
2017-08-30 22:35:40 +00:00
}
2017-10-04 18:20:07 +00:00
return uploadsController.actuallyUpload(req, res, user, albumid);
2017-10-04 00:13:38 +00:00
}
2017-10-04 18:13:23 +00:00
return uploadsController.actuallyUpload(req, res, user, albumid);
2017-10-04 00:13:38 +00:00
};
2017-01-19 06:34:48 +00:00
2017-10-04 00:13:38 +00:00
uploadsController.actuallyUpload = async (req, res, userid, album) => {
upload(req, res, async err => {
if (err) {
console.error(err);
return res.json({ success: false, description: err });
}
2017-01-19 06:34:48 +00:00
2017-10-04 00:13:38 +00:00
if (req.files.length === 0) return res.json({ success: false, description: 'no-files' });
2017-01-19 06:34:48 +00:00
2017-10-04 00:13:38 +00:00
const files = [];
const existingFiles = [];
let iteration = 1;
2017-01-19 06:34:48 +00:00
2017-10-04 00:13:38 +00:00
req.files.forEach(async file => {
2017-08-30 22:35:40 +00:00
// Check if the file exists by checking hash and size
2017-10-04 00:13:38 +00:00
let hash = crypto.createHash('md5');
let stream = fs.createReadStream(path.join(__dirname, '..', config.uploads.folder, file.filename));
stream.on('data', data => {
hash.update(data, 'utf8');
});
stream.on('end', async () => {
const fileHash = hash.digest('hex');
const dbFile = await db.table('files')
.where(function() {
if (userid === undefined) this.whereNull('userid');
2017-10-04 18:13:23 +00:00
else this.where('userid', userid.id);
2017-10-04 00:13:38 +00:00
})
.where({
hash: fileHash,
size: file.size
})
.first();
if (!dbFile) {
files.push({
name: file.filename,
original: file.originalname,
type: file.mimetype,
size: file.size,
hash: fileHash,
ip: req.ip,
albumid: album,
userid: userid !== undefined ? userid.id : null,
2017-10-04 00:13:38 +00:00
timestamp: Math.floor(Date.now() / 1000)
});
} else {
uploadsController.deleteFile(file.filename).then(() => {}).catch(err => console.error(err));
existingFiles.push(dbFile);
}
2017-01-21 20:24:20 +00:00
2017-10-04 00:13:38 +00:00
if (iteration === req.files.length) {
return uploadsController.processFilesForDisplay(req, res, files, existingFiles);
}
iteration++;
});
});
});
};
uploadsController.processFilesForDisplay = async (req, res, files, existingFiles) => {
let basedomain = config.domain;
2017-03-17 04:14:24 +00:00
if (files.length === 0) {
return res.json({
success: true,
files: existingFiles.map(file => {
return {
name: file.name,
size: file.size,
2017-10-04 00:13:38 +00:00
url: `${basedomain}/${file.name}`
};
2017-01-13 07:34:21 +00:00
})
2017-10-04 00:13:38 +00:00
});
}
2017-10-04 00:13:38 +00:00
await db.table('files').insert(files);
for (let efile of existingFiles) files.push(efile);
res.json({
success: true,
files: files.map(file => {
return {
name: file.name,
size: file.size,
url: `${basedomain}/${file.name}`
};
})
2017-10-04 00:13:38 +00:00
});
2017-10-04 00:13:38 +00:00
for (let file of files) {
let ext = path.extname(file.name).toLowerCase();
if (utils.imageExtensions.includes(ext) || utils.videoExtensions.includes(ext)) {
file.thumb = `${basedomain}/thumbs/${file.name.slice(0, -ext.length)}.png`;
utils.generateThumbs(file);
}
if (file.albumid) {
db.table('albums').where('id', file.albumid).update('editedAt', file.timestamp).then(() => {})
.catch(error => { console.log(error); res.json({ success: false, description: 'Error updating album' }); });
}
2017-10-04 00:13:38 +00:00
}
};
2017-10-04 00:13:38 +00:00
uploadsController.delete = async (req, res) => {
const user = await utils.authorize(req, res);
const id = req.body.id;
if (id === undefined || id === '') {
return res.json({ success: false, description: 'No file specified' });
}
2017-10-04 00:13:38 +00:00
const file = await db.table('files')
2017-01-30 01:51:54 +00:00
.where('id', id)
2017-03-17 04:14:24 +00:00
.where(function() {
2017-10-04 00:13:38 +00:00
if (user.username !== 'root') {
this.where('userid', user.id);
}
})
2017-10-04 00:13:38 +00:00
.first();
try {
await uploadsController.deleteFile(file.name);
await db.table('files').where('id', id).del();
if (file.albumid) {
await db.table('albums').where('id', file.albumid).update('editedAt', Math.floor(Date.now() / 1000));
}
2017-10-04 00:13:38 +00:00
} catch (err) {
console.log(err);
}
2017-10-04 00:13:38 +00:00
return res.json({ success: true });
};
2017-03-17 04:14:24 +00:00
uploadsController.deleteFile = function(file) {
2017-10-04 00:13:38 +00:00
const ext = path.extname(file).toLowerCase();
return new Promise((resolve, reject) => {
fs.stat(path.join(__dirname, '..', config.uploads.folder, file), (err, stats) => {
if (err) { return reject(err); }
fs.unlink(path.join(__dirname, '..', config.uploads.folder, file), err => {
if (err) { return reject(err); }
if (!utils.imageExtensions.includes(ext) && !utils.videoExtensions.includes(ext)) {
return resolve();
}
2017-10-04 00:13:38 +00:00
file = file.substr(0, file.lastIndexOf('.')) + '.png';
fs.stat(path.join(__dirname, '..', config.uploads.folder, 'thumbs/', file), (err, stats) => {
if (err) {
console.log(err);
return resolve();
}
fs.unlink(path.join(__dirname, '..', config.uploads.folder, 'thumbs/', file), err => {
if (err) { return reject(err); }
return resolve();
});
});
});
});
});
};
uploadsController.list = async (req, res) => {
const user = await utils.authorize(req, res);
let offset = req.params.page;
if (offset === undefined) offset = 0;
const files = await db.table('files')
2017-03-17 04:14:24 +00:00
.where(function() {
2017-10-04 00:13:38 +00:00
if (req.params.id === undefined) this.where('id', '<>', '');
else this.where('albumid', req.params.id);
2017-01-30 01:51:54 +00:00
})
2017-03-17 04:14:24 +00:00
.where(function() {
2017-10-04 00:13:38 +00:00
if (user.username !== 'root') this.where('userid', user.id);
2017-01-30 01:51:54 +00:00
})
.orderBy('id', 'DESC')
.limit(25)
.offset(25 * offset)
2017-10-04 00:13:38 +00:00
.select('id', 'albumid', 'timestamp', 'name', 'userid');
const albums = await db.table('albums');
let basedomain = config.domain;
let userids = [];
for (let file of files) {
file.file = `${basedomain}/${file.name}`;
file.date = new Date(file.timestamp * 1000);
file.date = utils.getPrettyDate(file.date);
file.album = '';
if (file.albumid !== undefined) {
for (let album of albums) {
if (file.albumid === album.id) {
file.album = album.name;
2017-01-22 21:01:39 +00:00
}
2017-10-04 00:13:38 +00:00
}
}
2017-10-04 00:13:38 +00:00
// Only push usernames if we are root
if (user.username === 'root') {
if (file.userid !== undefined && file.userid !== null && file.userid !== '') {
userids.push(file.userid);
}
}
let ext = path.extname(file.name).toLowerCase();
if (utils.imageExtensions.includes(ext) || utils.videoExtensions.includes(ext)) {
file.thumb = `${basedomain}/thumbs/${file.name.slice(0, -ext.length)}.png`;
}
}
// If we are a normal user, send response
if (user.username !== 'root') return res.json({ success: true, files });
2017-10-04 00:13:38 +00:00
// If we are root but there are no uploads attached to a user, send response
if (userids.length === 0) return res.json({ success: true, files });
2017-03-17 04:14:24 +00:00
2017-10-04 00:13:38 +00:00
const users = await db.table('users').whereIn('id', userids);
for (let dbUser of users) {
for (let file of files) {
if (file.userid === dbUser.id) {
file.username = dbUser.username;
}
}
}
2017-10-04 00:13:38 +00:00
return res.json({ success: true, files });
};
2017-10-04 00:13:38 +00:00
module.exports = uploadsController;