Skip to content

Node.js based forum software built for the modern web

fix: closes #14717, add uid:<uid>:blocker_uids

Barış Soner Uşaklı85da0d17f18a
diff --git a/public/src/modules/chat.js b/public/src/modules/chat.js
index 0a80c883e6..e3c0491d52 100644
--- a/public/src/modules/chat.js
+++ b/public/src/modules/chat.js
@@ -163,7 +163,7 @@ define('chat', [
};
Chat.isFromBlockedUser = function (fromUid) {
- return app.user.blocks.includes(parseInt(fromUid, 10));
+ return app.user.blocks.includes(String(fromUid));
};
Chat.isLookingAtRoom = function (roomId) {
diff --git a/src/messaging/index.js b/src/messaging/index.js
index 212db2df52..8eb3ec9f1a 100644
--- a/src/messaging/index.js
+++ b/src/messaging/index.js
@@ -361,7 +361,7 @@ Messaging.getTeasers = async (uid, roomIds) => {
user.blocks.list(uid),
]);
const uids = _.uniq(
- teasers.map(t => t && t.fromuid).filter(uid => uid && !blockedUids.includes(uid))
+ teasers.map(t => t && t.fromuid).filter(uid => uid && !blockedUids.includes(String(uid)))
);
const userMap = _.zipObject(
diff --git a/src/topics/teaser.js b/src/topics/teaser.js
index 6a80f6ee87..93405e4d6b 100644
--- a/src/topics/teaser.js
+++ b/src/topics/teaser.js
@@ -105,7 +105,7 @@ module.exports = function (Topics) {
}
return await Promise.all(teasers.map(async (postData) => {
- if (blockedUids.includes(parseInt(postData.uid, 10))) {
+ if (blockedUids.includes(String(postData.uid))) {
return await getPreviousNonBlockedPost(postData, blockedUids);
}
return postData;
@@ -121,7 +121,7 @@ module.exports = function (Topics) {
let checkedAllReplies = false;
function checkBlocked(post) {
- const isPostBlocked = blockedUids.includes(parseInt(post.uid, 10));
+ const isPostBlocked = blockedUids.includes(String(post.uid));
prevPost = !isPostBlocked ? post : prevPost;
return isPostBlocked;
}
diff --git a/src/topics/unread.js b/src/topics/unread.js
index 405183c5b6..0122c1cc35 100644
--- a/src/topics/unread.js
+++ b/src/topics/unread.js
@@ -274,7 +274,7 @@ module.exports = function (Topics) {
return hasUnblockedUnread;
}
let postData = await posts.getPostsFields(pidsSinceLastVisit, ['pid', 'uid']);
- postData = postData.filter(post => !params.blockedUids.includes(parseInt(post.uid, 10)));
+ postData = postData.filter(post => !params.blockedUids.includes(String(post.uid)));
done = postData.length > 0;
hasUnblockedUnread = postData.length > 0;
diff --git a/src/upgrades/4.15.2/blocker-uids-zset.js b/src/upgrades/4.15.2/blocker-uids-zset.js
new file mode 100644
index 0000000000..8be387375e
--- /dev/null
+++ b/src/upgrades/4.15.2/blocker-uids-zset.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const db = require('../../database');
+const batch = require('../../batch');
+const User = require('../../user');
+
+module.exports = {
+ name: 'Add uid:<uid>:blocker_uids zset',
+ timestamp: Date.UTC(2026, 7, 30),
+ method: async function () {
+ const { progress } = this;
+ await batch.processSortedSet('users:joindate', async (uids) => {
+ const blocks = await User.blocks.list(uids);
+ const bulkAdd = [];
+ const now = Date.now();
+ uids.forEach((uid, index) => {
+ const blockedUids = blocks[index] || [];
+ if (blockedUids.length) {
+ blockedUids.forEach((blockedUid) => {
+ bulkAdd.push([
+ `uid:${blockedUid}:blocker_uids`,
+ now,
+ uid,
+ ]);
+ });
+ }
+ });
+
+ await db.sortedSetAddBulk(bulkAdd);
+ progress.incr(uids.length);
+ }, {
+ batch: 500,
+ progress,
+ });
+ },
+};
diff --git a/src/user/blocks.js b/src/user/blocks.js
index 723ace7628..4292e5dfcd 100644
--- a/src/user/blocks.js
+++ b/src/user/blocks.js
@@ -2,7 +2,6 @@
const db = require('../database');
const plugins = require('../plugins');
-const utils = require('../utils');
const cacheCreate = require('../cache/lru');
module.exports = function (User) {
@@ -18,9 +17,10 @@ module.exports = function (User) {
const isArray = Array.isArray(uids);
uids = isArray ? uids : [uids];
const blocks = await User.blocks.list(uids);
- const isBlocked = uids.map((uid, index) => blocks[index] && blocks[index].includes(
- utils.isNumber(targetUid) ? parseInt(targetUid, 10) : targetUid
- ));
+ targetUid = String(targetUid);
+ const isBlocked = uids.map(
+ (uid, index) => blocks[index] && blocks[index].includes(targetUid)
+ );
return isArray ? isBlocked : isBlocked[0];
};
@@ -54,7 +54,7 @@ module.exports = function (User) {
if (unCachedUids.length) {
const unCachedData = await db.getSortedSetsMembers(unCachedUids.map(uid => `uid:${uid}:blocked_uids`));
unCachedUids.forEach((uid, index) => {
- cachedData[uid] = (unCachedData[index] || []).map(uid => (utils.isNumber(uid) ? parseInt(uid, 10) : uid));
+ cachedData[uid] = (unCachedData[index] || []);
User.blocks._cache.set(String(uid), cachedData[uid]);
});
}
@@ -64,7 +64,11 @@ module.exports = function (User) {
User.blocks.add = async function (targetUid, uid) {
await User.blocks.applyChecks('block', targetUid, uid);
- await db.sortedSetAdd(`uid:${uid}:blocked_uids`, Date.now(), targetUid);
+ const now = Date.now();
+ await db.sortedSetAddBulk([
+ [`uid:${uid}:blocked_uids`, now, targetUid],
+ [`uid:${targetUid}:blocker_uids`, now, uid],
+ ]);
await User.incrementUserFieldBy(uid, 'blocksCount', 1);
User.blocks._cache.del(String(uid));
plugins.hooks.fire('action:user.blocks.add', { uid: uid, targetUid: targetUid });
@@ -72,7 +76,10 @@ module.exports = function (User) {
User.blocks.remove = async function (targetUid, uid) {
await User.blocks.applyChecks('unblock', targetUid, uid);
- await db.sortedSetRemove(`uid:${uid}:blocked_uids`, targetUid);
+ await db.sortedSetRemoveBulk([
+ [`uid:${uid}:blocked_uids`, targetUid],
+ [`uid:${targetUid}:blocker_uids`, uid],
+ ]);
await User.decrementUserFieldBy(uid, 'blocksCount', 1);
User.blocks._cache.del(String(uid));
plugins.hooks.fire('action:user.blocks.remove', { uid: uid, targetUid: targetUid });
@@ -109,11 +116,12 @@ module.exports = function (User) {
const blockedSet = new Set(blocked_uids);
set = set.filter((item) => {
- let uid = isPlain ? item : (item && item[property]);
- uid = utils.isNumber(uid) ? parseInt(uid, 10) : uid;
- return !blockedSet.has(uid);
+ const uid = isPlain ? item : (item && item[property]);
+ return !blockedSet.has(String(uid));
+ });
+ const data = await plugins.hooks.fire('filter:user.blocks.filter', {
+ set, property, uid, blockedSet,
});
- const data = await plugins.hooks.fire('filter:user.blocks.filter', { set: set, property: property, uid: uid, blockedSet: blockedSet });
return data.set;
};
diff --git a/src/user/delete.js b/src/user/delete.js
index f22ab4fc7d..6568d8bc4a 100644
--- a/src/user/delete.js
+++ b/src/user/delete.js
@@ -122,7 +122,6 @@ module.exports = function (User) {
`uid:${uid}:bookmarks`,
`uid:${uid}:tids_read`,
`uid:${uid}:tids_unread`,
- `uid:${uid}:blocked_uids`,
`user:${uid}:settings`,
`user:${uid}:usernames`,
`user:${uid}:emails`,
@@ -162,6 +161,7 @@ module.exports = function (User) {
db.deleteAll(keys),
db.setRemove('invitation:uids', uid),
deleteUserIps(uid),
+ deleteBlocks(uid),
deleteUserFromFollowers(uid),
deleteUserFromFollowedTopics(uid),
deleteUserFromIgnoredTopics(uid),
@@ -224,6 +224,13 @@ module.exports = function (User) {
]);
}
+ async function deleteBlocks(uid) {
+ const blockerUids = await db.getSortedSetRange(`uid:${uid}:blocker_uids`, 0, -1);
+ await db.sortedSetsRemove(blockerUids.map(uid => `uid:${uid}:blocked_uids`), uid);
+ await db.deleteAll([`uid:${uid}:blocked_uids`, `uid:${uid}:blocker_uids`]);
+ User.blocks._cache.del([String(uid), ...blockerUids]);
+ }
+
async function deleteUserFromFollowers(uid) {
const [followers, following] = await Promise.all([
db.getSortedSetRange(`followers:${uid}`, 0, -1),
diff --git a/src/user/search.js b/src/user/search.js
index 5d2a56df73..cdb917c687 100644
--- a/src/user/search.js
+++ b/src/user/search.js
@@ -112,7 +112,7 @@ module.exports = function (User) {
if (blocks.length) {
userData.forEach((user) => {
if (user) {
- user.isBlocked = blocks.includes(user.uid);
+ user.isBlocked = blocks.includes(String(user.uid));
}
});
}
diff --git a/test/user.js b/test/user.js
index 794647a9ea..a1e63378aa 100644
--- a/test/user.js
+++ b/test/user.js
@@ -4,7 +4,6 @@ const assert = require('assert');
const fs = require('fs');
const path = require('path');
const nconf = require('nconf');
-const validator = require('validator');
const jwt = require('jsonwebtoken');
const { setTimeout } = require('node:timers/promises');
@@ -2632,198 +2631,6 @@ describe('User', () => {
});
});
- describe('user blocking methods', (done) => {
- let blockeeUid;
- before((done) => {
- User.create({
- username: 'blockee',
- email: '[email protected]',
- fullname: 'Block me',
- }, (err, uid) => {
- blockeeUid = uid;
- done(err);
- });
- });
-
- describe('.toggle()', () => {
- it('should toggle block', (done) => {
- socketUser.toggleBlock({ uid: 1 }, { blockerUid: 1, blockeeUid: blockeeUid, action: 'block' }, (err) => {
- assert.ifError(err);
- User.blocks.is(blockeeUid, 1, (err, blocked) => {
- assert.ifError(err);
- assert(blocked);
- done();
- });
- });
- });
-
- it('should toggle block', (done) => {
- socketUser.toggleBlock({ uid: 1 }, { blockerUid: 1, blockeeUid: blockeeUid, action: 'unblock' }, (err) => {
- assert.ifError(err);
- User.blocks.is(blockeeUid, 1, (err, blocked) => {
- assert.ifError(err);
- assert(!blocked);
- done();
- });
- });
- });
- });
-
- describe('.add()', () => {
- it('should block a uid', (done) => {
- User.blocks.add(blockeeUid, 1, (err) => {
- assert.ifError(err);
- User.blocks.list(1, (err, blocked_uids) => {
- assert.ifError(err);
- assert.strictEqual(Array.isArray(blocked_uids), true);
- assert.strictEqual(blocked_uids.length, 1);
- assert.strictEqual(blocked_uids.includes(blockeeUid), true);
- done();
- });
- });
- });
-
- it('should automatically increment corresponding user field', (done) => {
- db.getObjectField('user:1', 'blocksCount', (err, count) => {
- assert.ifError(err);
- assert.strictEqual(parseInt(count, 10), 1);
- done();
- });
- });
-
- it('should error if you try to block the same uid again', (done) => {
- User.blocks.add(blockeeUid, 1, (err) => {
- assert.equal(err.message, '[[error:already-blocked]]');
- done();
- });
- });
- });
-
- describe('.remove()', () => {
- it('should unblock a uid', (done) => {
- User.blocks.remove(blockeeUid, 1, (err) => {
- assert.ifError(err);
- User.blocks.list(1, (err, blocked_uids) => {
- assert.ifError(err);
- assert.strictEqual(Array.isArray(blocked_uids), true);
- assert.strictEqual(blocked_uids.length, 0);
- done();
- });
- });
- });
-
- it('should automatically decrement corresponding user field', (done) => {
- db.getObjectField('user:1', 'blocksCount', (err, count) => {
- assert.ifError(err);
- assert.strictEqual(parseInt(count, 10), 0);
- done();
- });
- });
-
- it('should error if you try to unblock the same uid again', (done) => {
- User.blocks.remove(blockeeUid, 1, (err) => {
- assert.equal(err.message, '[[error:already-unblocked]]');
- done();
- });
- });
- });
-
- describe('.is()', () => {
- before((done) => {
- User.blocks.add(blockeeUid, 1, done);
- });
-
- it('should return a Boolean with blocked status for the queried uid', (done) => {
- User.blocks.is(blockeeUid, 1, (err, blocked) => {
- assert.ifError(err);
- assert.strictEqual(blocked, true);
- done();
- });
- });
- });
-
- describe('.list()', () => {
- it('should return a list of blocked uids', (done) => {
- User.blocks.list(1, (err, blocked_uids) => {
- assert.ifError(err);
- assert.strictEqual(Array.isArray(blocked_uids), true);
- assert.strictEqual(blocked_uids.length, 1);
- assert.strictEqual(blocked_uids.includes(blockeeUid), true);
- done();
- });
- });
- });
-
- describe('.filter()', () => {
- it('should remove entries by blocked uids and return filtered set', (done) => {
- User.blocks.filter(1, [{
- foo: 'foo',
- uid: blockeeUid,
- }, {
- foo: 'bar',
- uid: 1,
- }, {
- foo: 'baz',
- uid: blockeeUid,
- }], (err, filtered) => {
- assert.ifError(err);
- assert.strictEqual(Array.isArray(filtered), true);
- assert.strictEqual(filtered.length, 1);
- assert.equal(filtered[0].uid, 1);
- done();
- });
- });
-
- it('should allow property argument to be passed in to customise checked property', (done) => {
- User.blocks.filter(1, 'fromuid', [{
- foo: 'foo',
- fromuid: blockeeUid,
- }, {
- foo: 'bar',
- fromuid: 1,
- }, {
- foo: 'baz',
- fromuid: blockeeUid,
- }], (err, filtered) => {
- assert.ifError(err);
- assert.strictEqual(Array.isArray(filtered), true);
- assert.strictEqual(filtered.length, 1);
- assert.equal(filtered[0].fromuid, 1);
- done();
- });
- });
-
- it('should not process invalid sets', (done) => {
- User.blocks.filter(1, [{ foo: 'foo' }, { foo: 'bar' }, { foo: 'baz' }], (err, filtered) => {
- assert.ifError(err);
- assert.strictEqual(Array.isArray(filtered), true);
- assert.strictEqual(filtered.length, 3);
- filtered.forEach((obj) => {
- assert.strictEqual(obj.hasOwnProperty('foo'), true);
- });
- done();
- });
- });
-
- it('should process plain sets that just contain uids', (done) => {
- User.blocks.filter(1, [1, blockeeUid], (err, filtered) => {
- assert.ifError(err);
- assert.strictEqual(filtered.length, 1);
- assert.strictEqual(filtered[0], 1);
- done();
- });
- });
-
- it('should filter uids that are blocking targetUid', (done) => {
- User.blocks.filterUids(blockeeUid, [1, 2], (err, filtered) => {
- assert.ifError(err);
- assert.deepEqual(filtered, [2]);
- done();
- });
- });
- });
- });
-
describe('status/online', () => {
it('should return offline if user is guest', (done) => {
const status = User.getStatus({ uid: 0 });
diff --git a/test/user/blocks.js b/test/user/blocks.js
new file mode 100644
index 0000000000..dba0f9df17
--- /dev/null
+++ b/test/user/blocks.js
@@ -0,0 +1,209 @@
+'use strict';
+
+const assert = require('assert');
+
+const db = require('../mocks/databasemock');
+const User = require('../../src/user');
+const socketUser = require('../../src/socket.io/user');
+const utils = require('../../src/utils');
+
+describe('user blocking methods', () => {
+ let blockeeUid;
+ let blockerUid;
+ before(async () => {
+ blockeeUid = String(await User.create({
+ username: 'blockee',
+ email: '[email protected]',
+ fullname: 'Block me',
+ }));
+ blockerUid = String(await User.create({
+ username: 'blocker',
+ email: '[email protected]',
+ fullname: 'Blocker',
+ }));
+ });
+
+ describe('.toggle()', () => {
+ it('should toggle block', async () => {
+ await socketUser.toggleBlock({ uid: blockerUid }, { blockerUid, blockeeUid, action: 'block' });
+ const blocked = await User.blocks.is(blockeeUid, blockerUid);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), [blockeeUid]);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockeeUid}:blocker_uids`, 0, -1), [blockerUid]);
+ assert(blocked);
+ });
+
+
+ it('should toggle block', async () => {
+ await socketUser.toggleBlock({ uid: blockerUid }, { blockerUid, blockeeUid, action: 'unblock' });
+ const blocked = await User.blocks.is(blockeeUid, blockerUid);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), []);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockeeUid}:blocker_uids`, 0, -1), []);
+ assert(!blocked);
+ });
+ });
+
+ describe('.add()', () => {
+ it('should block a uid', (done) => {
+ User.blocks.add(blockeeUid, blockerUid, (err) => {
+ assert.ifError(err);
+ User.blocks.list(blockerUid, (err, blocked_uids) => {
+ assert.ifError(err);
+ assert.strictEqual(Array.isArray(blocked_uids), true);
+ assert.strictEqual(blocked_uids.length, 1);
+ assert.strictEqual(blocked_uids.includes(blockeeUid), true);
+ done();
+ });
+ });
+ });
+
+ it('should automatically increment corresponding user field', (done) => {
+ db.getObjectField(`user:${blockerUid}`, 'blocksCount', (err, count) => {
+ assert.ifError(err);
+ assert.strictEqual(parseInt(count, 10), 1);
+ done();
+ });
+ });
+
+ it('should error if you try to block the same uid again', (done) => {
+ User.blocks.add(blockeeUid, blockerUid, (err) => {
+ assert.equal(err.message, '[[error:already-blocked]]');
+ done();
+ });
+ });
+ });
+
+ it('should clean up blocker/blocked sets when blocked user is deleted', async () => {
+ const deleteUid = String(await User.create({ username: utils.generateUUID().slice(0, 6) }));
+ const blockerUid = String(await User.create({ username: utils.generateUUID().slice(0, 6) }));
+ await User.blocks.add(deleteUid, blockerUid);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), [deleteUid]);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${deleteUid}:blocker_uids`, 0, -1), [blockerUid]);
+ await User.deleteAccount(deleteUid);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), []);
+ assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${deleteUid}:blocker_uids`, 0, -1), []);
+ });
+
+ describe('.remove()', () => {
+ it('should unblock a uid', (done) => {
+ User.blocks.remove(blockeeUid, blockerUid, (err) => {
+ assert.ifError(err);
+ User.blocks.list(blockerUid, (err, blocked_uids) => {
+ assert.ifError(err);
+ assert.strictEqual(Array.isArray(blocked_uids), true);
+ assert.strictEqual(blocked_uids.length, 0);
+ done();
+ });
+ });
+ });
+
+ it('should automatically decrement corresponding user field', (done) => {
+ db.getObjectField(`user:${blockerUid}`, 'blocksCount', (err, count) => {
+ assert.ifError(err);
+ assert.strictEqual(parseInt(count, 10), 0);
+ done();
+ });
+ });
+
+ it('should error if you try to unblock the same uid again', (done) => {
+ User.blocks.remove(blockeeUid, blockerUid, (err) => {
+ assert.equal(err.message, '[[error:already-unblocked]]');
+ done();
+ });
+ });
+ });
+
+ describe('.is()', () => {
+ before((done) => {
+ User.blocks.add(blockeeUid, blockerUid, done);
+ });
+
+ it('should return a Boolean with blocked status for the queried uid', (done) => {
+ User.blocks.is(blockeeUid, blockerUid, (err, blocked) => {
+ assert.ifError(err);
+ assert.strictEqual(blocked, true);
+ done();
+ });
+ });
+ });
+
+ describe('.list()', () => {
+ it('should return a list of blocked uids', (done) => {
+ User.blocks.list(blockerUid, (err, blocked_uids) => {
+ assert.ifError(err);
+ assert.strictEqual(Array.isArray(blocked_uids), true);
+ assert.strictEqual(blocked_uids.length, 1);
+ assert.strictEqual(blocked_uids.includes(blockeeUid), true);
+ done();
+ });
+ });
+ });
+
+ describe('.filter()', () => {
+ it('should remove entries by blocked uids and return filtered set', (done) => {
+ User.blocks.filter(blockerUid, [{
+ foo: 'foo',
+ uid: blockeeUid,
+ }, {
+ foo: 'bar',
+ uid: blockerUid,
+ }, {
+ foo: 'baz',
+ uid: blockeeUid,
+ }], (err, filtered) => {
+ assert.ifError(err);
+ assert.strictEqual(Array.isArray(filtered), true);
+ assert.strictEqual(filtered.length, 1);
+ assert.equal(filtered[0].uid, blockerUid);
+ done();
+ });
+ });
+
+ it('should allow property argument to be passed in to customise checked property', (done) => {
+ User.blocks.filter(blockerUid, 'fromuid', [{
+ foo: 'foo',
+ fromuid: blockeeUid,
+ }, {
+ foo: 'bar',
+ fromuid: blockerUid,
+ }, {
+ foo: 'baz',
+ fromuid: blockeeUid,
+ }], (err, filtered) => {
+ assert.ifError(err);
+ assert.strictEqual(Array.isArray(filtered), true);
+ assert.strictEqual(filtered.length, 1);
+ assert.equal(filtered[0].fromuid, blockerUid);
+ done();
+ });
+ });
+
+ it('should not process invalid sets', (done) => {
+ User.blocks.filter(blockerUid, [{ foo: 'foo' }, { foo: 'bar' }, { foo: 'baz' }], (err, filtered) => {
+ assert.ifError(err);
+ assert.strictEqual(Array.isArray(filtered), true);
+ assert.strictEqual(filtered.length, 3);
+ filtered.forEach((obj) => {
+ assert.strictEqual(obj.hasOwnProperty('foo'), true);
+ });
+ done();
+ });
+ });
+
+ it('should process plain sets that just contain uids', (done) => {
+ User.blocks.filter(blockerUid, [blockerUid, blockeeUid], (err, filtered) => {
+ assert.ifError(err);
+ assert.strictEqual(filtered.length, 1);
+ assert.strictEqual(filtered[0], blockerUid);
+ done();
+ });
+ });
+
+ it('should filter uids that are blocking targetUid', (done) => {
+ User.blocks.filterUids(blockeeUid, [blockerUid, blockeeUid], (err, filtered) => {
+ assert.ifError(err);
+ assert.deepEqual(filtered, [blockeeUid]);
+ done();
+ });
+ });
+ });
+});
\ No newline at end of file