107 lines
3.7 KiB
JavaScript
107 lines
3.7 KiB
JavaScript
// Imports
|
|
const router = require("express").Router();
|
|
const storageUtil = require("../utils/storage-util");
|
|
const crudFiles = require("../crud/files");
|
|
const crudUsers = require("../crud/users");
|
|
// Constants
|
|
const bucket = "uploads";
|
|
const container = (req) => req.user.cairo_id;
|
|
const uploadField = "user-selected-file";
|
|
const upload = storageUtil.buildBucketUpload(bucket, uploadField, container);
|
|
const upsertMiddleware = [authMiddleware, bodyParserMiddleware];
|
|
const uploadMiddleware = [authMiddleware, urlEncodedMiddleware, upload];
|
|
router.get("/files", authMiddleware, (req, res) => {
|
|
crudFiles.queryOwnedFiles(req.user.cairo_id).then((files) => res.json(files));
|
|
});
|
|
|
|
router.post("/upload", uploadMiddleware, async (req, res) => {
|
|
const users = await crudUsers.queryUserByCairoId(req.user.cairo_id);
|
|
const user = users[0];
|
|
user.used_storage = parseInt(user.used_storage);
|
|
user.storage = parseInt(user.storage);
|
|
if (req.file.size + user.used_storage > user.storage) {
|
|
storageUtil.cancelUpload(req, req.file.filename);
|
|
return res.sendStatus(500);
|
|
}
|
|
const fileInsert = crudFiles.insertFile(
|
|
req.user.cairo_id,
|
|
req.file.filename,
|
|
req.file.originalname,
|
|
req.file.size
|
|
);
|
|
|
|
const userInsert = crudUsers.updateUsedStorage(
|
|
req.user.cairo_id,
|
|
req.file.size + user.used_storage
|
|
);
|
|
|
|
Promise.all([fileInsert, userInsert])
|
|
.then((results) => res.json(results[0][0]))
|
|
.catch((err) => res.sendStatus(500));
|
|
});
|
|
|
|
router.post("/delete", upsertMiddleware, (req, res) => {
|
|
if (!req.body || !Array.isArray(req.body))
|
|
return res.sendStatus(400).send("Files must be an array!");
|
|
const files = req.body;
|
|
// Technically this should be checked to see if they own it/can edit it
|
|
// but timecrunch so will fix later
|
|
const queries = files.map((fileId) =>
|
|
crudFiles.deleteFile(fileId).then((files) => {
|
|
try {
|
|
storageUtil.deleteUpload(bucket, req.user.cairo_id, files[0].filename);
|
|
return files[0];
|
|
} catch (err) {
|
|
logError("STASH", `Could not delete file(s)`, files);
|
|
return { filesize: 0 };
|
|
}
|
|
})
|
|
);
|
|
Promise.all(queries)
|
|
.then((results) => {
|
|
var deletedData = 0;
|
|
results.forEach((file) => (deletedData += file.filesize));
|
|
crudUsers
|
|
.updateUsedStorage(
|
|
req.user.cairo_id,
|
|
Math.max(parseInt(req.user.used_storage) - deletedData, 0)
|
|
)
|
|
.catch((err) =>
|
|
logError(
|
|
"STASH",
|
|
"Could not update storage for ",
|
|
req.user.cairo_id,
|
|
err
|
|
)
|
|
);
|
|
res.sendStatus(200);
|
|
})
|
|
.catch((err) => res.status(500).json([]));
|
|
// Delete the file
|
|
});
|
|
|
|
router.get("/download", authOptMiddleware, async (req, res) => {
|
|
if (!req.query || !req.query.target) return res.sendStatus(404);
|
|
const files = await crudFiles.getFile(req.query.target);
|
|
if (files.length !== 1) return res.sendStatus(404);
|
|
const file = files[0];
|
|
file.view = file.view ?? [];
|
|
file.edit = file.edit ?? [];
|
|
var fpath = storageUtil.fetchUpload(bucket, file.owner, file.filename);
|
|
if (file.public) return res.download(fpath); // Send if public
|
|
if (!req.user) return res.sendStatus(401);
|
|
const userId = req.user.cairo_id;
|
|
if (file.owner === userId) return res.download(fpath); // Send if owner
|
|
if (file.edit.includes(userId) || file.view.includes(userId))
|
|
return res.download(fpath); // Send if view/edit
|
|
return res.sendStatus(401);
|
|
});
|
|
|
|
router.post("/public", upsertMiddleware, async (req, res) => {
|
|
if (!req.body || !Array.isArray(req.body))
|
|
return res.sendStatus(400).send("Files must be an array!");
|
|
req.body.forEach((fileId) => crudFiles.setPublic(fileId));
|
|
res.sendStatus(200);
|
|
});
|
|
|
|
module.exports = router;
|