mirror of https://gitgud.io/fatchan/jschan.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
313 lines
11 KiB
313 lines
11 KiB
'use strict';
|
|
|
|
const Posts = require(__dirname+'/../../db/posts.js')
|
|
, Boards = require(__dirname+'/../../db/boards.js')
|
|
, Mongo = require(__dirname+'/../../db/db.js')
|
|
, banPoster = require(__dirname+'/ban-poster.js')
|
|
, deletePosts = require(__dirname+'/delete-post.js')
|
|
, spoilerPosts = require(__dirname+'/spoiler-post.js')
|
|
, stickyPosts = require(__dirname+'/stickyposts.js')
|
|
, sagePosts = require(__dirname+'/sageposts.js')
|
|
, lockPosts = require(__dirname+'/lockposts.js')
|
|
, deletePostsFiles = require(__dirname+'/deletepostsfiles.js')
|
|
, reportPosts = require(__dirname+'/report-post.js')
|
|
, globalReportPosts = require(__dirname+'/globalreportpost.js')
|
|
, dismissReports = require(__dirname+'/dismiss-report.js')
|
|
, dismissGlobalReports = require(__dirname+'/dismissglobalreport.js')
|
|
, { buildCatalog, buildThread, buildBoardMultiple } = require(__dirname+'/../../build.js');
|
|
|
|
module.exports = async (req, res, next) => {
|
|
|
|
//get the ids
|
|
const postMongoIds = res.locals.posts.map(post => Mongo.ObjectId(post._id));
|
|
let passwordPostMongoIds = [];
|
|
let passwordPosts = [];
|
|
if (!res.locals.hasPerms && res.locals.actions.anyPasswords) {
|
|
//just to avoid multiple filters and mapping, do it all here
|
|
passwordPosts = res.locals.posts.filter(post => {
|
|
if (post.password != null
|
|
&& post.password.length > 0
|
|
&& post.password == req.body.password) {
|
|
passwordPostMongoIds.push(Mongo.ObjectId(post._id))
|
|
return true;
|
|
}
|
|
});
|
|
if (passwordPosts.length === 0) {
|
|
return res.status(403).render('message', {
|
|
'title': 'Forbidden',
|
|
'error': 'Password did not match any selected posts',
|
|
'redirect': `/${req.params.board ? req.params.board+'/' : 'globalmanage.html'}`
|
|
});
|
|
}
|
|
} else {
|
|
passwordPosts = res.locals.posts;
|
|
passwordPostMongoIds = postMongoIds;
|
|
}
|
|
|
|
const messages = [];
|
|
const combinedQuery = {};
|
|
const passwordCombinedQuery = {};
|
|
let aggregateNeeded = false;
|
|
try {
|
|
// if getting global banned, board ban doesnt matter
|
|
if (req.body.global_ban) {
|
|
const { message, action, query } = await banPoster(req, res, next, null, res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
} else if (req.body.ban) {
|
|
const { message, action, query } = await banPoster(req, res, next, req.params.board, res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
if (req.body.delete_ip_board || req.body.delete_ip_global) {
|
|
const deletePostIps = res.locals.posts.map(x => x.ip);
|
|
let query = {
|
|
'ip': {
|
|
'$in': deletePostIps
|
|
}
|
|
};
|
|
if (req.body.delete_ip_board) {
|
|
query['board'] = req.params.board;
|
|
}
|
|
const deleteIpPosts = await Posts.db.find(query).toArray();
|
|
res.locals.posts = res.locals.posts.concat(deleteIpPosts);
|
|
if (deleteIpPosts && deleteIpPosts.length > 0) {
|
|
const { message } = await deletePosts(req, res, next, deleteIpPosts, req.params.board);
|
|
messages.push(message);
|
|
aggregateNeeded = true;
|
|
}
|
|
} else if (req.body.delete) {
|
|
const { message } = await deletePosts(req, res, next, passwordPosts, req.params.board);
|
|
messages.push(message);
|
|
aggregateNeeded = true;
|
|
} else {
|
|
// if it was getting deleted, we cant do any of these
|
|
if (req.body.delete_file || req.body.unlink_file) {
|
|
const { message, action, query } = await deletePostsFiles(passwordPosts, req.body.unlink_file);
|
|
if (action) {
|
|
aggregateNeeded = true;
|
|
passwordCombinedQuery[action] = { ...passwordCombinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
} else if (req.body.spoiler) {
|
|
const { message, action, query } = spoilerPosts(passwordPosts);
|
|
if (action) {
|
|
passwordCombinedQuery[action] = { ...passwordCombinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
//lock, sticky, sage
|
|
if (req.body.sage) {
|
|
const { message, action, query } = sagePosts(res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
if (req.body.lock) {
|
|
const { message, action, query } = lockPosts(res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
if (req.body.sticky) {
|
|
const { message, action, query } = stickyPosts(res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
// cannot report and dismiss at same time
|
|
if (req.body.report) {
|
|
const { message, action, query } = reportPosts(req, res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
} else if (req.body.dismiss) {
|
|
const { message, action, query } = dismissReports(res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
// cannot report and dismiss at same time
|
|
if (req.body.global_report) {
|
|
const { message, action, query } = globalReportPosts(req, res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
} else if (req.body.global_dismiss) {
|
|
const { message, action, query } = dismissGlobalReports(res.locals.posts);
|
|
if (action) {
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query}
|
|
}
|
|
messages.push(message);
|
|
}
|
|
}
|
|
const bulkWrites = []
|
|
if (Object.keys(combinedQuery).length > 0) {
|
|
bulkWrites.push({
|
|
'updateMany': {
|
|
'filter': {
|
|
'_id': {
|
|
'$in': postMongoIds
|
|
}
|
|
},
|
|
'update': combinedQuery
|
|
}
|
|
});
|
|
}
|
|
if (Object.keys(passwordCombinedQuery).length > 0) {
|
|
bulkWrites.push({
|
|
'updateMany': {
|
|
'filter': {
|
|
'_id': {
|
|
'$in': passwordPostMongoIds
|
|
}
|
|
},
|
|
'update': passwordCombinedQuery
|
|
}
|
|
});
|
|
}
|
|
|
|
//get a map of boards to threads affected
|
|
const boardThreadMap = {};
|
|
const queryOrs = [];
|
|
for (let i = 0; i < res.locals.posts.length; i++) {
|
|
const post = res.locals.posts[i];
|
|
if (!boardThreadMap[post.board]) {
|
|
boardThreadMap[post.board] = [];
|
|
}
|
|
boardThreadMap[post.board].push(post.thread || post.postId);
|
|
}
|
|
|
|
const beforePages = {};
|
|
const threadBoards = Object.keys(boardThreadMap);
|
|
//get how many pages each board is to know whether we should rebuild all pages (because of page nav changes)
|
|
//only if deletes actions selected because this could result in number of pages to change
|
|
if (req.body.delete || req.body.delete_ip_board || req.body.delete_ip_global) {
|
|
await Promise.all(threadBoards.map(async board => {
|
|
beforePages[board] = Math.ceil((await Posts.getPages(board)) / 10);
|
|
}));
|
|
}
|
|
|
|
//execute actions now
|
|
if (bulkWrites.length > 0) {
|
|
await Posts.db.bulkWrite(bulkWrites);
|
|
}
|
|
|
|
//get only posts (so we can use them for thread ids
|
|
const postThreadsToUpdate = res.locals.posts.filter(post => post.thread !== null);
|
|
if (aggregateNeeded) {
|
|
//recalculate replies and image counts
|
|
await Promise.all(postThreadsToUpdate.map(async (post) => {
|
|
const replyCounts = await Posts.getReplyCounts(post.board, post.thread);
|
|
let replyposts = 0;
|
|
let replyfiles = 0;
|
|
if (replyCounts[0]) {
|
|
replyposts = replyCounts[0].replyposts;
|
|
replyfiles = replyCounts[0].replyfiles;
|
|
}
|
|
Posts.setReplyCounts(post.board, post.thread, replyposts, replyfiles);
|
|
}));
|
|
}
|
|
|
|
//make it into an OR query for the db
|
|
for (let i = 0; i < threadBoards.length; i++) {
|
|
const threadBoard = threadBoards[i];
|
|
boardThreadMap[threadBoard] = [...new Set(boardThreadMap[threadBoard])]
|
|
queryOrs.push({
|
|
'board': threadBoard,
|
|
'postId': {
|
|
'$in': boardThreadMap[threadBoard]
|
|
}
|
|
})
|
|
}
|
|
|
|
//fetch threads per board that we only checked posts for
|
|
let threadsEachBoard = await Posts.db.find({
|
|
'thread': null,
|
|
'$or': queryOrs
|
|
}).toArray();
|
|
//combine it with what we already had
|
|
threadsEachBoard = threadsEachBoard.concat(res.locals.posts.filter(post => post.thread === null))
|
|
|
|
//get the oldest and newest thread for each board to determine how to delete
|
|
const threadBounds = threadsEachBoard.reduce((acc, curr) => {
|
|
if (!acc[curr.board] || curr.bumped < acc[curr.board].bumped) {
|
|
acc[curr.board] = { oldest: null, newest: null};
|
|
}
|
|
if (!acc[curr.board].oldest || curr.bumped < acc[curr.board].oldest.bumped) {
|
|
acc[curr.board].oldest = curr;
|
|
}
|
|
if (!acc[curr.board].newest || curr.bumped > acc[curr.board].newest.bumped) {
|
|
acc[curr.board].newest = curr;
|
|
}
|
|
return acc;
|
|
}, {});
|
|
|
|
//now we need to delete outdated html
|
|
//TODO: not do this for reports, handle global actions & move to separate handler + optimize and test
|
|
const parallelPromises = []
|
|
const boardNames = Object.keys(threadBounds);
|
|
const buildBoards = {};
|
|
const multiBoards = await Boards.db.find({
|
|
'_id': {
|
|
'$in': boardNames
|
|
}
|
|
}).toArray();
|
|
multiBoards.forEach(board => {
|
|
buildBoards[board._id] = board;
|
|
})
|
|
for (let i = 0; i < boardNames.length; i++) {
|
|
const boardName = boardNames[i];
|
|
const bounds = threadBounds[boardName];
|
|
//always need to refresh catalog
|
|
parallelPromises.push(buildCatalog(buildBoards[boardName]));
|
|
//rebuild impacted threads
|
|
for (let j = 0; j < boardThreadMap[boardName].length; j++) {
|
|
parallelPromises.push(buildThread(boardThreadMap[boardName][j], buildBoards[boardName]));
|
|
}
|
|
//refersh any pages affected
|
|
const afterPages = Math.ceil((await Posts.getPages(boardName)) / 10);
|
|
if (beforePages[boardName] && beforePages[boardName] !== afterPages) {
|
|
//amount of pages changed, rebuild all pages
|
|
parallelPromises.push(buildBoardMultiple(buildBoards[boardName], 1, afterPages));
|
|
} else {
|
|
const threadPageOldest = await Posts.getThreadPage(boardName, bounds.oldest);
|
|
const threadPageNewest = await Posts.getThreadPage(boardName, bounds.newest);
|
|
if (req.body.delete || req.body.delete_ip_board || req.body.delete_ip_global) {
|
|
//rebuild current and older pages for deletes
|
|
parallelPromises.push(buildBoardMultiple(buildBoards[boardName], threadPageNewest, afterPages));
|
|
} else if (req.body.sticky) { //else if -- if deleting, other actions are not executed/irrelevant
|
|
//rebuild current and newer pages
|
|
parallelPromises.push(buildBoardMultiple(buildBoards[boardName], 1, threadPageOldest));
|
|
} else if (req.body.lock || req.body.sage || req.body.spoiler || req.body.ban || req.body.global_ban || req.body.unlink_file) {
|
|
//rebuild inbewteen pages for things that dont cause page/thread movement
|
|
//should rebuild only affected pages, but finding the page of all affected
|
|
//threads could end up being slower/more resource intensive. this is simpler.
|
|
//it avoids rebuilding _some_ but not all pages unnecessarily
|
|
parallelPromises.push(buildBoardMultiple(buildBoards[boardName], threadPageNewest, threadPageOldest));
|
|
}
|
|
}
|
|
}
|
|
await Promise.all(parallelPromises);
|
|
|
|
} catch (err) {
|
|
return next(err);
|
|
}
|
|
|
|
return res.render('message', {
|
|
'title': 'Success',
|
|
'messages': messages,
|
|
'redirect': `/${req.params.board ? req.params.board+'/' : 'globalmanage.html'}`
|
|
});
|
|
|
|
}
|
|
|