|
|
|
'use strict';
|
|
|
|
|
|
|
|
const { Posts, Boards, Modlogs } = require(__dirname+'/../../db/')
|
|
|
|
, Mongo = require(__dirname+'/../../db/db.js')
|
|
|
|
, banPoster = require(__dirname+'/banposter.js')
|
|
|
|
, deletePosts = require(__dirname+'/deletepost.js')
|
|
|
|
, spoilerPosts = require(__dirname+'/spoilerpost.js')
|
|
|
|
, stickyPosts = require(__dirname+'/stickyposts.js')
|
|
|
|
, bumplockPosts = require(__dirname+'/bumplockposts.js')
|
|
|
|
, lockPosts = require(__dirname+'/lockposts.js')
|
|
|
|
, cyclePosts = require(__dirname+'/cycleposts.js')
|
|
|
|
, deletePostsFiles = require(__dirname+'/deletepostsfiles.js')
|
|
|
|
, reportPosts = require(__dirname+'/reportpost.js')
|
|
|
|
, dismissReports = require(__dirname+'/dismissreport.js')
|
|
|
|
, movePosts = require(__dirname+'/moveposts.js')
|
|
|
|
, { remove } = require('fs-extra')
|
|
|
|
, uploadDirectory = require(__dirname+'/../../lib/file/uploaddirectory.js')
|
|
|
|
, getAffectedBoards = require(__dirname+'/../../lib/misc/affectedboards.js')
|
|
|
|
, dynamicResponse = require(__dirname+'/../../lib/misc/dynamic.js')
|
|
|
|
, Permissions = require(__dirname+'/../../lib/permission/permissions.js')
|
|
|
|
, buildQueue = require(__dirname+'/../../lib/build/queue.js')
|
|
|
|
, { postPasswordSecret } = require(__dirname+'/../../configs/secrets.js')
|
|
|
|
, threadRegex = /\/[a-z0-9]+\/(?:manage\/)?thread\/(\d+)\.html/i
|
|
|
|
, { createHash, timingSafeEqual } = require('crypto');
|
|
|
|
|
|
|
|
module.exports = async (req, res, next) => {
|
|
|
|
|
|
|
|
//try to set a good redirect
|
|
|
|
let redirect = req.headers.referer;
|
|
|
|
if (!redirect) {
|
|
|
|
if (!req.params.board) {
|
|
|
|
redirect = '/globalmanage/recent.html';
|
|
|
|
} else {
|
|
|
|
redirect = `/${req.params.board}/${req.path.endsWith('modactions') ? 'manage/reports' : 'index'}.html`;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Handle checking passwords (in a time-constant) when doing actions that require a password.
|
|
|
|
Staff skip this section because they don't need passwords to do such actions.
|
|
|
|
*/
|
|
|
|
const isStaffOrGlobal = res.locals.permissions.hasAny(Permissions.MANAGE_GLOBAL_GENERAL, Permissions.MANAGE_BOARD_GENERAL);
|
|
|
|
if (!isStaffOrGlobal && res.locals.actions.numPasswords > 0) {
|
|
|
|
let passwordPosts = [];
|
|
|
|
if (req.body.postpassword && req.body.postpassword.length > 0) {
|
|
|
|
const inputPasswordHash = createHash('sha256').update(postPasswordSecret + req.body.postpassword).digest('base64');
|
|
|
|
const inputPasswordBuffer = Buffer.from(inputPasswordHash);
|
|
|
|
passwordPosts = res.locals.posts.filter(post => {
|
|
|
|
if (post.password != null) { //null password doesnt matter for timing attack, it cant be deleted by non-staff
|
|
|
|
const postBuffer = Buffer.from(post.password);
|
|
|
|
return timingSafeEqual(inputPasswordBuffer, postBuffer);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
if (passwordPosts.length === 0) {
|
|
|
|
return dynamicResponse(req, res, 403, 'message', {
|
|
|
|
'title': 'Forbidden',
|
|
|
|
'error': 'Password did not match any selected posts',
|
|
|
|
redirect,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
//if the password is correct for at least *some* posts, silently ignore the wrong ones (dont action them), and continue.
|
|
|
|
res.locals.posts = passwordPosts;
|
|
|
|
}
|
|
|
|
|
|
|
|
const deleting = req.body.delete || req.body.delete_ip_board || req.body.delete_ip_global || req.body.delete_ip_thread;
|
|
|
|
|
|
|
|
//affected boards, their threads, and how many pages each one has before the actions
|
|
|
|
let { boardThreadMap, numPagesBeforeActions, affectedBoardNames } = await getAffectedBoards(res.locals.posts, deleting);
|
|
|
|
let minimalThreadsMap = await Posts.getMinimalThreads(affectedBoardNames);
|
|
|
|
|
|
|
|
//adjust the redirect to go back to the thread if it was done from there
|
|
|
|
if (deleting
|
|
|
|
&& req.params.board
|
|
|
|
&& req.headers.referer
|
|
|
|
&& boardThreadMap[req.params.board]) {
|
|
|
|
const threadRefMatch = req.headers.referer.match(threadRegex);
|
|
|
|
if (threadRefMatch && boardThreadMap[req.params.board].directThreads.has(+threadRefMatch[1])) {
|
|
|
|
redirect = `/${req.params.board}/${req.path.endsWith('modactions') ? 'manage/' : ''}index.html`;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const messages = [];
|
|
|
|
const modlogActions = [];
|
|
|
|
const combinedQuery = {};
|
|
|
|
let recalculateThreadMetadata = false;
|
|
|
|
|
|
|
|
//handle bans, independent of other actions
|
|
|
|
if (req.body.ban || req.body.global_ban || req.body.report_ban || req.body.global_report_ban) {
|
|
|
|
const { message, action, query } = await banPoster(req, res, next);
|
|
|
|
if (req.body.ban) {
|
|
|
|
modlogActions.push('Ban');
|
|
|
|
} else if (req.body.global_ban) {
|
|
|
|
modlogActions.push('Global Ban');
|
|
|
|
}
|
|
|
|
if (req.body.report_ban) {
|
|
|
|
modlogActions.push('Ban reporter');
|
|
|
|
} else if (req.body.global_report_ban) {
|
|
|
|
modlogActions.push('Global ban reporter');
|
|
|
|
}
|
|
|
|
if (action) {
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (deleting) {
|
|
|
|
|
|
|
|
//OP delete protection. for old OPs or with a lot of replies
|
|
|
|
if (!isStaffOrGlobal) {
|
|
|
|
const { deleteProtectionAge, deleteProtectionCount } = res.locals.board.settings;
|
|
|
|
if (deleteProtectionAge > 0 || deleteProtectionCount > 0) {
|
|
|
|
const protectedThread = res.locals.posts.some(p => {
|
|
|
|
return p.thread === null //is a thread
|
|
|
|
&& ((deleteProtectionCount > 0 && p.replyposts > deleteProtectionCount) //and it has more replies than the protection count
|
|
|
|
|| (deleteProtectionAge > 0 && new Date() > new Date(p.date.getTime() + deleteProtectionAge))); //or was created too long ago
|
|
|
|
});
|
|
|
|
if (protectedThread === true) {
|
|
|
|
return dynamicResponse(req, res, 403, 'message', {
|
|
|
|
'title': 'Forbidden',
|
|
|
|
'error': 'You cannot delete old threads or threads with too many replies',
|
|
|
|
redirect,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const postsBefore = res.locals.posts.length;
|
|
|
|
|
|
|
|
if (req.body.delete_ip_board || req.body.delete_ip_global || req.body.delete_ip_thread) {
|
|
|
|
const deletePostIps = res.locals.posts.map(x => x.ip.cloak);
|
|
|
|
const deletePostMongoIds = res.locals.posts.map(x => x._id);
|
|
|
|
let query = {
|
|
|
|
'_id': {
|
|
|
|
'$nin': deletePostMongoIds
|
|
|
|
},
|
|
|
|
'ip.cloak': {
|
|
|
|
'$in': deletePostIps
|
|
|
|
}
|
|
|
|
};
|
|
|
|
if (req.body.delete_ip_thread) {
|
|
|
|
const ips_threads = [...boardThreadMap[req.params.board].threads];
|
|
|
|
query['board'] = req.params.board;
|
|
|
|
query['$or'] = [
|
|
|
|
{
|
|
|
|
'thread': {
|
|
|
|
'$in': ips_threads
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
'postId': {
|
|
|
|
'$in': ips_threads
|
|
|
|
}
|
|
|
|
}
|
|
|
|
];
|
|
|
|
} else 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 (res.locals.posts.length > postsBefore) {
|
|
|
|
//recalc for extra fetched posts
|
|
|
|
({ boardThreadMap, numPagesBeforeActions, affectedBoardNames } = await getAffectedBoards(res.locals.posts, deleting));
|
|
|
|
minimalThreadsMap = await Posts.getMinimalThreads(affectedBoardNames);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req.body.delete_file) {
|
|
|
|
const { message } = await deletePostsFiles(res.locals.posts, false); //delete files, not just unlink
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
const { action, message } = await deletePosts(res.locals.posts, req.body.delete_ip_global ? null : req.params.board);
|
|
|
|
messages.push(message);
|
|
|
|
if (action) {
|
|
|
|
if (req.body.delete) {
|
|
|
|
modlogActions.push('Delete');
|
|
|
|
} else if (req.body.delete_ip_board) {
|
|
|
|
modlogActions.push('Delete by IP');
|
|
|
|
} else if (req.body.delete_ip_global) {
|
|
|
|
modlogActions.push('Global delete by IP');
|
|
|
|
}
|
|
|
|
recalculateThreadMetadata = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (req.body.move) {
|
|
|
|
|
|
|
|
if (boardThreadMap[req.params.board].directThreads.size > 0) {
|
|
|
|
const threadIds = [...boardThreadMap[req.params.board].directThreads];
|
|
|
|
const fetchMovePosts = await Posts.db.find({
|
|
|
|
'board': req.params.board,
|
|
|
|
'thread': {
|
|
|
|
'$in': threadIds
|
|
|
|
}
|
|
|
|
}).toArray();
|
|
|
|
res.locals.posts = res.locals.posts.concat(fetchMovePosts);
|
|
|
|
}
|
|
|
|
const { message, action } = await movePosts(req, res);
|
|
|
|
if (action) {
|
|
|
|
modlogActions.push('Moved');
|
|
|
|
recalculateThreadMetadata = true;
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
// if it was getting deleted/moved, dont do these actions
|
|
|
|
if (req.body.unlink_file || req.body.delete_file) {
|
|
|
|
const { message, action, query } = await deletePostsFiles(res.locals.posts, req.body.unlink_file);
|
|
|
|
if (action) {
|
|
|
|
if (req.body.unlink_file) {
|
|
|
|
modlogActions.push('Unlink files');
|
|
|
|
} else if (req.body.delete_file) {
|
|
|
|
modlogActions.push('Delete files');
|
|
|
|
}
|
|
|
|
recalculateThreadMetadata = true;
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
} else if (req.body.spoiler) {
|
|
|
|
const { message, action, query } = spoilerPosts(res.locals.posts);
|
|
|
|
if (action) {
|
|
|
|
modlogActions.push('Spoiler files');
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
//lock, sticky, bumplock, cyclic
|
|
|
|
if (req.body.bumplock) {
|
|
|
|
const { message, action, query } = bumplockPosts(res.locals.posts);
|
|
|
|
if (action) {
|
|
|
|
modlogActions.push('Bumplock');
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
if (req.body.lock) {
|
|
|
|
const { message, action, query } = lockPosts(res.locals.posts);
|
|
|
|
if (action) {
|
|
|
|
modlogActions.push('Lock');
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
if (req.body.sticky != null) {
|
|
|
|
const { message, action, query } = stickyPosts(res.locals.posts, req.body.sticky);
|
|
|
|
if (action) {
|
|
|
|
modlogActions.push('Sticky');
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
if (req.body.cyclic) {
|
|
|
|
const { message, action, query } = cyclePosts(res.locals.posts);
|
|
|
|
if (action) {
|
|
|
|
modlogActions.push('Cycle');
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
// cannot report and dismiss at same time
|
|
|
|
if (req.body.report || req.body.global_report) {
|
|
|
|
const { message, action, query } = reportPosts(req, res);
|
|
|
|
if (action) {
|
|
|
|
//no modlog entry for making reports
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
} else if (req.body.dismiss || req.body.global_dismiss) {
|
|
|
|
const { message, action, query } = dismissReports(req, res);
|
|
|
|
if (action) {
|
|
|
|
if (req.body.dismiss) {
|
|
|
|
modlogActions.push('Dismiss reports');
|
|
|
|
} else if (req.body.global_dismiss) {
|
|
|
|
modlogActions.push('Dismiss global reports');
|
|
|
|
}
|
|
|
|
combinedQuery[action] = { ...combinedQuery[action], ...query};
|
|
|
|
}
|
|
|
|
messages.push(message);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//execute the actions from the resulting combined query in one shot
|
|
|
|
if (Object.keys(combinedQuery).length > 0) {
|
|
|
|
await Posts.db.updateMany({
|
|
|
|
'_id': {
|
|
|
|
'$in': res.locals.posts.map(p => Mongo.ObjectId(p._id))
|
|
|
|
}
|
|
|
|
}, combinedQuery);
|
|
|
|
}
|
|
|
|
|
|
|
|
//fetch boards for templates if necessary. can be multiple boards from global actions
|
|
|
|
let buildBoards = {};
|
|
|
|
if (modlogActions.length > 0 || res.locals.actions.numBuild > 0) {
|
|
|
|
buildBoards = (await Boards.db.find({
|
|
|
|
'_id': {
|
|
|
|
'$in': affectedBoardNames
|
|
|
|
},
|
|
|
|
}).toArray()).reduce((acc, curr) => {
|
|
|
|
if (!acc[curr._id]) {
|
|
|
|
acc[curr._id] = curr;
|
|
|
|
}
|
|
|
|
return acc;
|
|
|
|
}, buildBoards);
|
|
|
|
}
|
|
|
|
|
|
|
|
const parallelPromises = [];
|
|
|
|
|
|
|
|
//modlog
|
|
|
|
if (modlogActions.length > 0) {
|
|
|
|
const modlog = {};
|
|
|
|
const logDate = new Date(); //all events current date
|
|
|
|
const message = req.body.log_message || null;
|
|
|
|
let logUser;
|
|
|
|
//could even do if (req.session.user) {...}, but might cause cross-board log username contamination
|
|
|
|
if (isStaffOrGlobal) {
|
|
|
|
logUser = req.session.user;
|
|
|
|
} else {
|
|
|
|
logUser = 'Unregistered User';
|
|
|
|
}
|
|
|
|
for (let i = 0; i < res.locals.posts.length; i++) {
|
|
|
|
const post = res.locals.posts[i];
|
|
|
|
if (!modlog[post.board]) {
|
|
|
|
//per board actions, all actions combined to one event
|
|
|
|
modlog[post.board] = {
|
|
|
|
showLinks: !deleting,
|
|
|
|
postLinks: [],
|
|
|
|
actions: modlogActions,
|
|
|
|
date: logDate,
|
|
|
|
showUser: !req.body.hide_name || logUser === 'Unregistered User' ? true : false,
|
|
|
|
message: message,
|
|
|
|
user: logUser,
|
|
|
|
ip: {
|
|
|
|
cloak: res.locals.ip.cloak,
|
|
|
|
raw: res.locals.ip.raw
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
modlog[post.board].postLinks.push({
|
|
|
|
postId: post.postId,
|
|
|
|
thread: req.body.move ? req.body.move_to_thread : post.thread,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
const modlogDocuments = [];
|
|
|
|
for (let i = 0; i < affectedBoardNames.length; i++) {
|
|
|
|
const boardName = affectedBoardNames[i];
|
|
|
|
const boardLog = modlog[boardName];
|
|
|
|
//make it into documents for the db
|
|
|
|
modlogDocuments.push({
|
|
|
|
...boardLog,
|
|
|
|
'board': boardName
|
|
|
|
});
|
|
|
|
}
|
|
|
|
if (modlogDocuments.length > 0) {
|
|
|
|
//insert the modlog docs
|
|
|
|
await Modlogs.insertMany(modlogDocuments);
|
|
|
|
for (let i = 0; i < affectedBoardNames.length; i++) {
|
|
|
|
const board = buildBoards[affectedBoardNames[i]];
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildModLog',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildModLogList',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//if there are actions that can cause some rebuilding
|
|
|
|
if (res.locals.actions.numBuild > 0) {
|
|
|
|
|
|
|
|
//Make a map of all the unique threads for any posts we selected in those threads (and directly selected threads)
|
|
|
|
const queryOrs = [];
|
|
|
|
for (let i = 0; i < affectedBoardNames.length; i++) {
|
|
|
|
const threadBoard = affectedBoardNames[i];
|
|
|
|
//convert this to an array while we are here
|
|
|
|
boardThreadMap[threadBoard].threads = [...boardThreadMap[threadBoard].threads];
|
|
|
|
boardThreadMap[threadBoard].directThreads = [...boardThreadMap[threadBoard].directThreads];
|
|
|
|
queryOrs.push({
|
|
|
|
'board': threadBoard,
|
|
|
|
'postId': {
|
|
|
|
'$in': boardThreadMap[threadBoard].threads
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
let threadsEachBoard = [];
|
|
|
|
if (queryOrs.length > 0) {
|
|
|
|
threadsEachBoard = await Posts.db.find({
|
|
|
|
'thread': null,
|
|
|
|
'$or': queryOrs
|
|
|
|
}).toArray();
|
|
|
|
}
|
|
|
|
const selectedThreads = res.locals.posts.filter(post => post.thread === null);
|
|
|
|
threadsEachBoard = threadsEachBoard.concat(selectedThreads);
|
|
|
|
|
|
|
|
//recalculate replies and image counts if necessary
|
|
|
|
if (recalculateThreadMetadata) {
|
|
|
|
const selectedPosts = res.locals.posts.filter(p => p.thread !== null);
|
|
|
|
if (selectedPosts.length > 0) {
|
|
|
|
const replyOrs = selectedPosts.map(p => ({ board: p.board, thread: p.thread }));
|
|
|
|
const threadReplyAggregates = await Posts.getThreadAggregates(replyOrs);
|
|
|
|
const bulkWrites = [];
|
|
|
|
const threads = threadsEachBoard;
|
|
|
|
for (let i = 0; i < threads.length; i++) {
|
|
|
|
const replyAggregate = threadReplyAggregates.find(ra => ra._id.thread === threads[i].postId && ra._id.board === threads[i].board);
|
|
|
|
if (!replyAggregate) {
|
|
|
|
//thread no longer has any reply post/files, set to 0 and reset bump date to post date
|
|
|
|
bulkWrites.push({
|
|
|
|
'updateOne': {
|
|
|
|
'filter': {
|
|
|
|
'postId': threads[i].postId,
|
|
|
|
'board': threads[i].board
|
|
|
|
},
|
|
|
|
'update': {
|
|
|
|
'$set': {
|
|
|
|
'replyposts': 0,
|
|
|
|
'replyfiles': 0,
|
|
|
|
'bumped': threads[i].date
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
//use results from first aggregate for threads with replies still existing
|
|
|
|
const aggregateSet = {
|
|
|
|
'replyposts': replyAggregate.replyposts,
|
|
|
|
'replyfiles': replyAggregate.replyfiles,
|
|
|
|
};
|
|
|
|
if (!threads[i].bumplocked) {
|
|
|
|
aggregateSet['bumped'] = replyAggregate.bumped;
|
|
|
|
}
|
|
|
|
bulkWrites.push({
|
|
|
|
'updateOne': {
|
|
|
|
'filter': {
|
|
|
|
'postId': replyAggregate._id.thread,
|
|
|
|
'board': replyAggregate._id.board
|
|
|
|
},
|
|
|
|
'update': {
|
|
|
|
'$set': aggregateSet,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bulkWrites.length > 0) {
|
|
|
|
await Posts.db.bulkWrite(bulkWrites);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
await Posts.fixLatest(affectedBoardNames);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Get a minimal data of the threads for each affected board, used to get the page of a thread later.
|
|
|
|
Using the proper ordering of threads, to account for sticky, bumplocks, etc.
|
|
|
|
*/
|
|
|
|
const pageBounds = threadsEachBoard.reduce((acc, t) => {
|
|
|
|
if (!acc[t.board]) { acc[t.board] = { first: null, last: null }; }
|
|
|
|
const threadIndex = minimalThreadsMap[t.board].findIndex(p => p.postId === t.postId);
|
|
|
|
const threadPage = Math.max(1, Math.ceil((threadIndex+1)/10));
|
|
|
|
if (!acc[t.board].first || threadPage < acc[t.board].first) {
|
|
|
|
acc[t.board].first = threadPage;
|
|
|
|
}
|
|
|
|
if (!acc[t.board].last || threadPage > acc[t.board].last) {
|
|
|
|
acc[t.board].last = threadPage;
|
|
|
|
}
|
|
|
|
return acc;
|
|
|
|
}, {});
|
|
|
|
|
|
|
|
for (let i = 0; i < affectedBoardNames.length; i++) {
|
|
|
|
|
|
|
|
//always assume catalog rebuild, gets set to false in specific cases later
|
|
|
|
let catalogRebuild = true;
|
|
|
|
|
|
|
|
//get the board data for build tasks, and highest/lowest affected pages for rebuilding
|
|
|
|
const boardName = affectedBoardNames[i];
|
|
|
|
const board = buildBoards[boardName];
|
|
|
|
|
|
|
|
//rebuild destination thread for "move" action
|
|
|
|
if (req.body.move) {
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildThread',
|
|
|
|
'options': {
|
|
|
|
'threadId': req.body.move_to_thread,
|
|
|
|
'board': board,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
//rebuild affected threads
|
|
|
|
for (let j = 0; j < boardThreadMap[boardName].threads.length; j++) {
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildThread',
|
|
|
|
'options': {
|
|
|
|
'threadId': boardThreadMap[boardName].threads[j],
|
|
|
|
'board': board,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
//use to compare number of pages after actions. fetch from db again if any actions that can change number of pages (delete and move)
|
|
|
|
let numPagesAfterActions = numPagesBeforeActions[boardName];
|
|
|
|
if (deleting || req.body.move) {
|
|
|
|
numPagesAfterActions = Math.ceil((await Posts.getPages(boardName)) / 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((numPagesBeforeActions[boardName] && numPagesBeforeActions[boardName] !== numPagesAfterActions) || req.body.move) {
|
|
|
|
|
|
|
|
//if number of pages changed, or doing a "move", rebuild all pages for simplicity and delete any pages that would no longer exist
|
|
|
|
if (numPagesAfterActions < numPagesBeforeActions[boardName]) {
|
|
|
|
for (let k = numPagesBeforeActions[boardName]; k > numPagesAfterActions; k--) {
|
|
|
|
parallelPromises.push(remove(`${uploadDirectory}/html/${boardName}/${k}.html`));
|
|
|
|
parallelPromises.push(remove(`${uploadDirectory}/json/${boardName}/${k}.json`));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildBoardMultiple',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
'startpage': 1,
|
|
|
|
'endpage': numPagesAfterActions,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
//build between pages
|
|
|
|
const rebuildPageFirst = pageBounds[boardName].first;
|
|
|
|
const rebuildPageLast = pageBounds[boardName].last;
|
|
|
|
|
|
|
|
if (deleting) {
|
|
|
|
|
|
|
|
if (boardThreadMap[boardName].directThreads.length === 0) {
|
|
|
|
//only deleting posts from threads, so thread order wont change, thus we dont delete all pages after
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildBoardMultiple',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
'startpage': rebuildPageFirst,
|
|
|
|
'endpage': rebuildPageLast,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
//deleting threads, so we delete all pages after
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildBoardMultiple',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
'startpage': rebuildPageFirst,
|
|
|
|
'endpage': numPagesAfterActions,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (req.body.sticky) {
|
|
|
|
|
|
|
|
//rebuild current and newer pages
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildBoardMultiple',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
'startpage': 1,
|
|
|
|
'endpage': rebuildPageLast,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
} else if (req.body.lock || req.body.bumplock || req.body.cyclic || req.body.unlink_file) {
|
|
|
|
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildBoardMultiple',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
'startpage': rebuildPageFirst,
|
|
|
|
'endpage': rebuildPageLast,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
} else if (req.body.spoiler || req.body.ban || req.body.global_ban) {
|
|
|
|
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildBoardMultiple',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
'startpage': rebuildPageFirst,
|
|
|
|
'endpage': numPagesAfterActions,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
//these actions dont affect the catalog tiles if no OPs selected, so dont bother rebuilding the catalog
|
|
|
|
if (boardThreadMap[boardName].directThreads.length === 0) {
|
|
|
|
catalogRebuild = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (catalogRebuild) {
|
|
|
|
|
|
|
|
buildQueue.push({
|
|
|
|
'task': 'buildCatalog',
|
|
|
|
'options': {
|
|
|
|
'board': board,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parallelPromises.length > 0) {
|
|
|
|
await Promise.all(parallelPromises);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dynamicResponse(req, res, 200, 'message', {
|
|
|
|
'title': 'Success',
|
|
|
|
'messages': messages,
|
|
|
|
redirect,
|
|
|
|
});
|
|
|
|
|
|
|
|
};
|