gxs: bulk read-status for channels and boards (extend mark-all-as-read fix)

Same treatment as the forum bulk markRead(), now for channels and boards, so
their "mark all as read/unread" also persists in a single transaction and emits
a single event instead of one blocking request + one event per post:

- RsGxsChannels / p3GxsChannels: add setMessageReadStatus(channelId, msgIds, read).
- RsPosted / p3Posted: add setPostReadStatus(boardId, msgIds, read).

Both reuse the batched, single-transaction processMsgMetaChanges() path added
for forums, which already benefits every GXS service.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jolavillette

src/retroshare/rsgxschannels.h

@@ -430,6 +430,22 @@ class RsGxsChannels: public RsGxsIfaceHelper, public RsGxsCommentService
      */
     virtual bool setMessageReadStatus(const RsGxsGrpMsgIdPair &msgId, bool read) =0;
 
+    /**
+     * @brief Mark several messages of a channel read/unread in one batch. Blocking.
+     *
+     * Like setMessageReadStatus() but queues all the status changes at once: they
+     * are persisted in a single database transaction and only one event is
+     * emitted, so it stays cheap even for thousands of posts and is meant to be
+     * called from a background thread so the GUI never blocks.
+     * @param[in] channelId channel group identifier
+     * @param[in] msgIds     identifiers of the posts to update
+     * @param[in] read       true to mark as read, false to mark as unread
+     * @return false on error, true otherwise
+     */
+    virtual bool setMessageReadStatus( const RsGxsGroupId& channelId,
+                                       const std::vector<RsGxsMessageId>& msgIds,
+                                       bool read ) =0;
+
     /**
 	 * @brief Share channel publishing key
 	 * This can be used to authorize other peers to post on the channel

src/retroshare/rsposted.h

@@ -402,6 +402,22 @@ class RsPosted : public RsGxsIfaceHelper, public RsGxsCommentService
      */
     virtual bool setPostReadStatus(const RsGxsGrpMsgIdPair& msgId, bool read) = 0;
 
+    /**
+     * @brief Mark several posts of a board read/unread in one batch. Blocking.
+     *
+     * Like setPostReadStatus() but queues all the status changes at once: they
+     * are persisted in a single database transaction and only one event is
+     * emitted, so it stays cheap even for thousands of posts and is meant to be
+     * called from a background thread so the GUI never blocks.
+     * @param[in] boardId board group identifier
+     * @param[in] msgIds  identifiers of the posts to update
+     * @param[in] read    true to mark as read, false to mark as unread
+     * @return false on error, true otherwise
+     */
+    virtual bool setPostReadStatus( const RsGxsGroupId& boardId,
+                                    const std::vector<RsGxsMessageId>& msgIds,
+                                    bool read ) = 0;
+
 	enum RS_DEPRECATED RankType {TopRankType, HotRankType, NewRankType };
 
 	RS_DEPRECATED_FOR(getBoardsInfo)

src/services/p3gxschannels.cc

@@ -2041,6 +2041,46 @@ bool p3GxsChannels::setMessageReadStatus(const RsGxsGrpMsgIdPair &msgId, bool re
 	return true;
 }
 
+bool p3GxsChannels::setMessageReadStatus(const RsGxsGroupId& channelId, const std::vector<RsGxsMessageId>& msgIds, bool read)
+{
+	if(msgIds.empty())
+		return true;
+
+	uint32_t mask   = GXS_SERV::GXS_MSG_STATUS_GUI_NEW | GXS_SERV::GXS_MSG_STATUS_GUI_UNREAD;
+	uint32_t status = read ? 0 : GXS_SERV::GXS_MSG_STATUS_GUI_UNREAD;
+
+	// Queue every status change at once. They are all drained together by a
+	// single processMsgMetaChanges() tick (one DB transaction), instead of one
+	// blocking request + one detached thread + one event per message.
+	std::vector<uint32_t> tokens;
+	tokens.reserve(msgIds.size());
+
+	for(const RsGxsMessageId& msgId : msgIds)
+	{
+		uint32_t token;
+		setMsgStatusFlags(token, RsGxsGrpMsgIdPair(channelId, msgId), status, mask);
+		tokens.push_back(token);
+	}
+
+	// All tokens complete in the same tick, so waiting on the last is enough.
+	waitToken(tokens.back(), std::chrono::milliseconds(30000));
+
+	RsGxsGrpMsgIdPair p;
+	for(uint32_t token : tokens)
+		acknowledgeMsg(token, p);
+
+	// One single event for the whole batch (consumers only need the group id).
+	if(rsEvents)
+	{
+		auto ev = std::make_shared<RsGxsChannelEvent>();
+		ev->mChannelGroupId   = channelId;
+		ev->mChannelEventCode = RsChannelEventCode::READ_STATUS_CHANGED;
+		rsEvents->postEvent(ev);
+	}
+
+	return true;
+}
+
 bool p3GxsChannels::shareChannelKeys(
         const RsGxsGroupId& channelId, const std::set<RsPeerId>& peers)
 {

src/services/p3gxschannels.h

@@ -106,6 +106,11 @@ class p3GxsChannels: public RsGenExchange, public RsGxsChannels,
     /// @see RsGxsChannels
     bool setMessageReadStatus(const RsGxsGrpMsgIdPair& msgId, bool read) override;
 
+    /// @see RsGxsChannels (batch variant)
+    bool setMessageReadStatus( const RsGxsGroupId& channelId,
+                               const std::vector<RsGxsMessageId>& msgIds,
+                               bool read ) override;
+
     virtual bool groupShareKeys(const RsGxsGroupId &groupId, const std::set<RsPeerId>& peers) override;
 
     // no tokens... should be cached.

src/services/p3posted.cc

@@ -707,6 +707,45 @@ bool p3Posted::setPostReadStatus(const RsGxsGrpMsgIdPair &msgId, bool read)
 {
     return setCommentReadStatus(msgId,read);
 }
+bool p3Posted::setPostReadStatus(const RsGxsGroupId& boardId, const std::vector<RsGxsMessageId>& msgIds, bool read)
+{
+    if(msgIds.empty())
+        return true;
+
+    uint32_t mask   = GXS_SERV::GXS_MSG_STATUS_GUI_NEW | GXS_SERV::GXS_MSG_STATUS_GUI_UNREAD;
+    uint32_t status = read ? 0 : GXS_SERV::GXS_MSG_STATUS_GUI_UNREAD;
+
+    // Queue every status change at once. They are all drained together by a
+    // single processMsgMetaChanges() tick (one DB transaction), instead of one
+    // blocking request + one detached thread + one event per message.
+    std::vector<uint32_t> tokens;
+    tokens.reserve(msgIds.size());
+
+    for(const RsGxsMessageId& msgId : msgIds)
+    {
+        uint32_t token;
+        setMsgStatusFlags(token, RsGxsGrpMsgIdPair(boardId, msgId), status, mask);
+        tokens.push_back(token);
+    }
+
+    // All tokens complete in the same tick, so waiting on the last is enough.
+    waitToken(tokens.back(), std::chrono::milliseconds(30000));
+
+    RsGxsGrpMsgIdPair p;
+    for(uint32_t token : tokens)
+        acknowledgeMsg(token, p);
+
+    // One single event for the whole batch (consumers only need the group id).
+    if(rsEvents)
+    {
+        auto ev = std::make_shared<RsGxsPostedEvent>();
+        ev->mPostedGroupId   = boardId;
+        ev->mPostedEventCode = RsPostedEventCode::READ_STATUS_CHANGED;
+        rsEvents->postEvent(ev);
+    }
+
+    return true;
+}
 bool p3Posted::setCommentReadStatus(const RsGxsGrpMsgIdPair &msgId, bool read)
 {
     uint32_t token;

src/services/p3posted.h

@@ -125,6 +125,9 @@ virtual void receiveHelperChanges(std::vector<RsGxsNotify*>& changes)
 
     bool setCommentReadStatus(const RsGxsGrpMsgIdPair &msgId, bool read) override;
     bool setPostReadStatus(const RsGxsGrpMsgIdPair &msgId, bool read) override;
+    bool setPostReadStatus( const RsGxsGroupId& boardId,
+                            const std::vector<RsGxsMessageId>& msgIds,
+                            bool read ) override;
 
     bool getRelatedComments( const RsGxsGroupId& gid,const std::set<RsGxsMessageId>& msgIds, std::vector<RsGxsComment> &comments ) override;