IM会话未读数和红点方案选型

import { Injectable } from '@nestjs/common';

import { InjectRepository } from '@nestjs/typeorm';

import { Repository } from 'typeorm';

import { SessionUnreads } from '../entities/session-unreads.entity';

import { Message } from '../entities/message.entity';

import { WebSocketService } from '../services/websocket.service';

import { UnreadSummary } from '../dto/unread-summary.dto';

import { WebSocketMessage } from '../dto/websocket-message.dto';

  


@Injectable()

export class UnreadService {

constructor(

@InjectRepository(SessionUnreads)

private readonly sessionUnreadsRepository: Repository<SessionUnreads>,

@InjectRepository(Message)

private readonly messageRepository: Repository<Message>,

private readonly webSocketService: WebSocketService,

) {}

  


/**

* 处理新消息，更新未读数

*/

async handleNewMessage(message: Message): Promise<void> {

const receiverId = message.receiverId;

const conversationId = message.conversationId;

  


let unread = await this.sessionUnreadsRepository.findOne({

where: {

userId: receiverId,

sessionId: conversationId,

},

});

  


if (!unread) {

unread = this.sessionUnreadsRepository.create({

userId: receiverId,

sessionId: conversationId,

unreadCount: 0,

lastReadMessageId: null,

isDisturb: 0,

});

await this.sessionUnreadsRepository.save(unread);

}

  


if (await this.shouldCountAsUnread(unread, message)) {

unread.unreadCount += 1;

await this.sessionUnreadsRepository.save(unread);

  


await this.pushUnreadUpdate(receiverId);

}

}

  


/**

* 判断消息是否需要计入未读数

*/

private async shouldCountAsUnread(unread: SessionUnreads, message: Message): Promise<boolean> {

if (unread.isDisturb === 1) {

return false;

}

  


return message.id > unread.lastReadMessageId;

}

  


/**

* 获取用户的所有未读数

*/

async getUserUnreadSummary(userId: number): Promise<UnreadSummary> {

const unreadList = await this.sessionUnreadsRepository.find({

where: { userId },

});

  


let totalUnread = 0;

const sessionUnreadMap = new Map<number, number>();

  


for (const unread of unreadList) {

sessionUnreadMap.set(unread.sessionId, unread.unreadCount);

  


if (unread.isDisturb === 0) {

totalUnread += unread.unreadCount;

}

}

  


const summary: UnreadSummary = {

totalUnread,

sessionUnreadMap: Object.fromEntries(sessionUnreadMap),

hasRedDot: totalUnread > 0,

};

  


return summary;

}

  


/**

* 标记消息已读

*/

async markMessagesAsRead(userId: number, sessionId: number, lastReadMessageId: string): Promise<void> {

const unread = await this.sessionUnreadsRepository.findOne({

where: {

userId,

sessionId,

},

});

  


if (unread) {

const unreadCount = await this.messageRepository

.createQueryBuilder('message')

.where('message.sessionId = :sessionId', { sessionId })

.andWhere('message.id > :lastReadMessageId', { lastReadMessageId: unread.lastReadMessageId })

.andWhere('message.id <= :currentReadMessageId', { currentReadMessageId: lastReadMessageId })

.getCount();

  


unread.lastReadMessageId = lastReadMessageId;

unread.unreadCount = Math.max(0, unread.unreadCount - unreadCount);

await this.sessionUnreadsRepository.save(unread);

  


await this.pushUnreadUpdate(userId);

}

}

  


/**

* 推送未读数更新通知

*/

private async pushUnreadUpdate(userId: number): Promise<void> {

const summary = await this.getUserUnreadSummary(userId);

  


const message: WebSocketMessage = {

type: 'unread_update',

data: summary,

};

  


await this.webSocketService.sendToUser(userId, message);

}

}

// 前端代码 - 服务端管理方案（HTTP请求+WebSocket推送混合）

  


class UnreadManager {

constructor() {

this.unreadData = {

total_unread: 0,

session_unread_map: {},

has_red_dot: false

};

}

  


// 初始化（登录成功后调用）

async init() {

// 1. 先通过HTTP获取初始未读数

await this.fetchUnreadSummary();

// 2. 建立WebSocket连接，监听实时更新

this.initWebSocketListener();

}

  


// HTTP请求获取未读数（只在必要时调用）

async fetchUnreadSummary() {

try {

const response = await api.get('/api/unread/summary');

this.unreadData = response.data;

this.updateUI();

} catch (error) {

console.error('获取未读数失败:', error);

}

}

  


// WebSocket监听（主要更新方式）

initWebSocketListener() {

websocket.on('unread_update', (data) => {

this.unreadData = data;

this.updateUI();

});

// 监听WebSocket重连

websocket.on('reconnect', () => {

// 重连成功后，主动拉取一次最新数据

this.fetchUnreadSummary();

});

}

  


// 标记消息已读

async markAsRead(sessionId, lastReadMessageId) {

try {

await api.post('/api/unread/mark-read', {

session_id: sessionId,

last_read_message_id: lastReadMessageId

});

// 注意：这里不需要手动更新UI，因为服务端会通过WebSocket推送更新

} catch (error) {

console.error('标记已读失败:', error);

}

}

  


// 更新UI显示

updateUI() {

// 更新会话列表未读数

Object.entries(this.unreadData.session_unread_map).forEach(([sessionId, count]) => {

const element = document.getElementById(`unread-${sessionId}`);

if (element) {

element.textContent = count > 0 ? count : '';

element.style.display = count > 0 ? 'block' : 'none';

}

});

  


// 更新应用图标红点

if (this.unreadData.has_red_dot) {

this.setAppBadge(this.unreadData.total_unread);

} else {

this.clearAppBadge();

}

}

  


// 设置应用图标角标

setAppBadge(count) {

if (navigator.setAppBadge) {

navigator.setAppBadge(count);

}

}

  


// 清除应用图标角标

clearAppBadge() {

if (navigator.clearAppBadge) {

navigator.clearAppBadge();

}

}

}

  


// 使用示例

const unreadManager = new UnreadManager();

  


// 登录成功后调用init方法初始化未读数管理

async function onLoginSuccess() {

await unreadManager.init();

}

  


// 用户打开会话

async function openSession(sessionId) {

// 获取当前会话的最后一条消息ID

const lastMessageId = getLastMessageId(sessionId);

await unreadManager.markAsRead(sessionId, lastMessageId);

// 加载会话消息...

}

import { Injectable } from '@nestjs/common';

import { InjectRepository } from '@nestjs/typeorm';

import { Repository } from 'typeorm';

import { SessionUnreads } from '../entities/session-unreads.entity';

import { Message } from '../entities/message.entity';

import { WebSocketConnectionManager } from '../services/websocket-connection-manager.service';

import { UnreadSummary } from '../dto/unread-summary.dto';

import { WebSocketMessage } from '../dto/websocket-message.dto';

  


@Injectable()

export class UnreadService {

constructor(

@InjectRepository(SessionUnreads)

private readonly sessionUnreadsRepository: Repository<SessionUnreads>,

@InjectRepository(Message)

private readonly messageRepository: Repository<Message>,

private readonly connectionManager: WebSocketConnectionManager,

) {}

  


/**

* 处理新消息，更新未读数并推送

*/

async handleNewMessage(message: Message): Promise<void> {

const receiverId = message.receiverId;

const conversationId = message.conversationId;

  


let unread = await this.sessionUnreadsRepository.findOne({

where: {

userId: receiverId,

sessionId: conversationId,

},

});

  


if (!unread) {

unread = this.sessionUnreadsRepository.create({

userId: receiverId,

sessionId: conversationId,

unreadCount: 0,

lastReadMessageId: null,

isDisturb: 0,

});

await this.sessionUnreadsRepository.save(unread);

}

  


if (await this.shouldCountAsUnread(unread, message)) {

unread.unreadCount += 1;

await this.sessionUnreadsRepository.save(unread);

  


await this.pushUnreadUpdate(receiverId);

}

}

  


/**

* 判断消息是否需要计入未读数

*/

private async shouldCountAsUnread(unread: SessionUnreads, message: Message): Promise<boolean> {

if (unread.isDisturb === 1) {

return false;

}

return message.id > unread.lastReadMessageId;

}

  


/**

* 标记消息已读并推送

*/

async markMessagesAsRead(userId: number, sessionId: number, lastReadMessageId: string): Promise<void> {

const unread = await this.sessionUnreadsRepository.findOne({

where: {

userId,

sessionId,

},

});

  


if (unread) {

const unreadCount = await this.messageRepository

.createQueryBuilder('message')

.where('message.sessionId = :sessionId', { sessionId })

.andWhere('message.id > :lastReadMessageId', { lastReadMessageId: unread.lastReadMessageId })

.andWhere('message.id <= :currentReadMessageId', { currentReadMessageId: lastReadMessageId })

.getCount();

  


unread.lastReadMessageId = lastReadMessageId;

unread.unreadCount = Math.max(0, unread.unreadCount - unreadCount);

await this.sessionUnreadsRepository.save(unread);

  


await this.pushUnreadUpdate(userId);

}

}

  


/**

* 推送未读数更新给用户的所有在线客户端

*/

private async pushUnreadUpdate(userId: number): Promise<void> {

const summary = await this.getUserUnreadSummary(userId);

  


const message: WebSocketMessage = {

type: 'unread_update',

data: summary,

};

  


await this.connectionManager.sendToUser(userId, message);

}

  


/**

* 获取用户的所有未读数

*/

private async getUserUnreadSummary(userId: number): Promise<UnreadSummary> {

const unreadList = await this.sessionUnreadsRepository.find({

where: { userId },

});

  


let totalUnread = 0;

const sessionUnreadMap = new Map<number, number>();

  


for (const unread of unreadList) {

sessionUnreadMap.set(unread.sessionId, unread.unreadCount);

  


if (unread.isDisturb === 0) {

totalUnread += unread.unreadCount;

}

}

  


const summary: UnreadSummary = {

totalUnread,

sessionUnreadMap: Object.fromEntries(sessionUnreadMap),

hasRedDot: totalUnread > 0,

};

  


return summary;

}

}

  


/**

* WebSocket连接管理器

*/

@Injectable()

export class WebSocketConnectionManager {

private readonly userSessions = new Map<number, Set<WebSocket>>();

  


/**

* 添加用户连接

*/

addUserConnection(userId: number, session: WebSocket): void {

if (!this.userSessions.has(userId)) {

this.userSessions.set(userId, new Set());

}

this.userSessions.get(userId).add(session);

}

  


/**

* 移除用户连接

*/

removeUserConnection(userId: number, session: WebSocket): void {

const sessions = this.userSessions.get(userId);

if (sessions) {

sessions.delete(session);

if (sessions.size === 0) {

this.userSessions.delete(userId);

}

}

}

  


/**

* 向用户的所有连接发送消息

*/

async sendToUser(userId: number, message: WebSocketMessage): Promise<void> {

const sessions = this.userSessions.get(userId);

if (sessions) {

const messageJson = JSON.stringify(message);

sessions.forEach(session => {

try {

session.send(messageJson);

} catch (error) {

console.error('发送WebSocket消息失败', error);

}

});

}

}

}

// 前端代码 - 实时推送方案

  


class UnreadManager {

constructor() {

this.unreadData = {

total_unread: 0,

session_unread_map: {},

has_red_dot: false

};

this.websocket = null;

this.reconnectAttempts = 0;

this.maxReconnectAttempts = 5;

this.reconnectInterval = 3000;

}

  


// 初始化（登录成功后调用）

init() {

this.connectWebSocket();

}

  


// 连接WebSocket

connectWebSocket() {

const wsUrl = `wss://your-api-domain.com/ws?token=${getToken()}`;

this.websocket = new WebSocket(wsUrl);

  


this.websocket.onopen = () => {

console.log('WebSocket连接成功');

this.reconnectAttempts = 0;

  


// 连接成功后，请求最新的未读数

this.fetchUnreadSummary();

};

  


this.websocket.onmessage = (event) => {

const message = JSON.parse(event.data);

  


if (message.type === 'unread_update') {

this.handleUnreadUpdate(message.data);

}

};

  


this.websocket.onclose = () => {

console.log('WebSocket连接关闭');

this.handleReconnect();

};

  


this.websocket.onerror = (error) => {

console.error('WebSocket错误:', error);

};

}

  


// 处理重连

handleReconnect() {

if (this.reconnectAttempts < this.maxReconnectAttempts) {

this.reconnectAttempts++;

console.log(`尝试重连 (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);

setTimeout(() => {

this.connectWebSocket();

}, this.reconnectInterval);

} else {

console.error('重连失败，超过最大尝试次数');

}

}

  


// 处理未读数更新

handleUnreadUpdate(data) {

this.unreadData = data;

this.updateUI();

}

  


// 从服务端获取未读数（用于初始化或重连后）

async fetchUnreadSummary() {

try {

const response = await api.get('/api/unread/summary');

this.unreadData = response.data;

this.updateUI();

} catch (error) {

console.error('获取未读数失败:', error);

}

}

  


// 标记消息已读

async markAsRead(sessionId, lastReadMessageId) {

try {

await api.post('/api/unread/mark-read', {

session_id: sessionId,

last_read_message_id: lastReadMessageId

});

// 未读数会通过WebSocket推送更新，无需手动处理

} catch (error) {

console.error('标记已读失败:', error);

}

}

  


// 更新UI显示

updateUI() {

// 更新会话列表未读数

Object.entries(this.unreadData.session_unread_map).forEach(([sessionId, count]) => {

const element = document.getElementById(`unread-${sessionId}`);

if (element) {

element.textContent = count > 0 ? count : '';

element.style.display = count > 0 ? 'block' : 'none';

}

});

  


// 更新应用图标红点

if (this.unreadData.has_red_dot) {

this.setAppBadge(this.unreadData.total_unread);

} else {

this.clearAppBadge();

}

}

  


// 设置应用图标角标

setAppBadge(count) {

if (navigator.setAppBadge) {

navigator.setAppBadge(count);

}

}

  


// 清除应用图标角标

clearAppBadge() {

if (navigator.clearAppBadge) {

navigator.clearAppBadge();

}

}

  


// 发送心跳

startHeartbeat() {

setInterval(() => {

if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {

this.websocket.send(JSON.stringify({ type: 'ping' }));

}

}, 30000); // 30秒发送一次心跳

}

}

  


// 使用示例

const unreadManager = new UnreadManager();

  


// 登录成功后调用init方法初始化未读数管理

async function onLoginSuccess() {

await unreadManager.init();

// 启动心跳

unreadManager.startHeartbeat();

}

  


// 用户打开会话

async function openSession(sessionId) {

const lastMessageId = getLastMessageId(sessionId);

await unreadManager.markAsRead(sessionId, lastMessageId);

// 加载会话消息...

}