@acorex/modules 20.2.0-next.1 → 20.2.0-next.2

package/fesm2022/acorex-modules-conversation.mjs

@@ -60,9 +60,9 @@ import { trigger, transition, style, animate } from '@angular/animations';
 import * as i10 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 import { Subject, filter, startWith } from 'rxjs';
+import { AXMUsersEntityService } from '@acorex/modules/security-management';
 import { AXToastService } from '@acorex/components/toast';
 import { DomSanitizer } from '@angular/platform-browser';
-import { AXMUsersEntityService } from '@acorex/modules/security-management';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { AXBasePageComponent } from '@acorex/components/page';
 import { AXDomChangeDirective } from '@acorex/cdk/dom';
@@ -939,98 +939,54 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
             type: Injectable
         }] });
 
+class AXMCommentRealtimeService {
+}
+class AXMCommentRealtimeServiceImpl extends AXMCommentRealtimeService {
+    constructor() {
+        super(...arguments);
+        this._comment$ = new Subject();
+        this.comment$ = this._comment$.asObservable();
+        this._thread$ = new Subject();
+        this.thread$ = this._thread$.asObservable();
+    }
+    notifyComment(event) {
+        this._comment$.next(event);
+    }
+    notifyThread(event) {
+        this._thread$.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentRealtimeServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentRealtimeServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentRealtimeServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 //#region ----   Abstract Comment Service   ----
 class AXMCommentService {
 }
 //#endregion
 class AXMCommentServiceImpl {
     constructor() {
-        //#region ----   Dependencies   ----
         this.roomService = inject(AXMRoomService);
         this.messageService = inject(AXMMessageService);
-        this.sessionService = inject(AXPSessionService);
-        this.usersService = inject(AXMUsersEntityService);
         this.filterService = inject(AXPFilterOperatorMiddlewareService);
-        //#endregion
-        //#region ----   Observables   ----
-        this._commentAdded$ = new Subject();
-        this.commentAdded$ = this._commentAdded$.asObservable();
-        this._commentRemoved$ = new Subject();
-        this.commentRemoved$ = this._commentRemoved$.asObservable();
-        this._commentUpdated$ = new Subject();
-        this.commentUpdated$ = this._commentUpdated$.asObservable();
-        this._threadAdded$ = new Subject();
-        this.threadAdded$ = this._threadAdded$.asObservable();
-        this._threadRemoved$ = new Subject();
-        this.threadRemoved$ = this._threadRemoved$.asObservable();
-    }
-    //#endregion
-    //#region ----   Helper Methods   ----
-    getCurrentUser() {
-        const user = this.sessionService.user;
-        if (!user) {
-            throw new Error('No authenticated user found.');
-        }
-        return {
-            id: user.id,
-            type: 'user',
-        };
     }
-    async getUserInfo(userId) {
-        try {
-            await this.usersService.getOne(userId); // check if user exists
-            return { id: userId, type: 'user' };
-        }
-        catch {
-            throw new Error(`User with ID ${userId} not found`);
-        }
-    }
-    formatComment(message, depth = 0) {
-        return {
-            ...message,
-            depth,
-            replies: [],
-            replyCount: 0,
-        };
-    }
-    buildCommentTree(comments) {
-        const commentMap = new Map(comments.map((c) => [c.id, c]));
-        const tree = [];
-        comments.forEach((comment) => {
-            if (comment.replyId && commentMap.has(comment.replyId)) {
-                const parent = commentMap.get(comment.replyId);
-                parent.replies.push(comment);
-                comment.depth = parent.depth + 1;
-            }
-            else {
-                tree.push(comment);
-            }
-        });
-        commentMap.forEach((comment) => {
-            comment.replyCount = comment.replies.length;
-        });
-        return tree;
-    }
-    //#endregion
-    //#region ----   Comment Thread Service Implementation   ----
-    async createThread(entityRef, topic, title) {
-        const currentUser = this.getCurrentUser();
+    async createThread(creatorUser, entityRef, topic, title) {
         const room = {
             type: 'comment',
             topic: topic,
             title: title || `Comments for ${entityRef.type}#${entityRef.id}`,
-            members: [currentUser],
+            members: [creatorUser],
             entityRef: entityRef,
-            createdBy: currentUser.id,
+            createdBy: creatorUser.id,
             createdAt: new Date(),
         };
-        await this.roomService.insertOne(room);
-        const newThread = await this.getThread(entityRef, topic);
-        if (!newThread) {
-            throw new Error('Failed to create or retrieve thread after creation.');
-        }
-        this._threadAdded$.next(newThread);
-        return newThread;
+        const newRoomId = await this.roomService.insertOne(room);
+        return this.roomService.getOne(newRoomId);
     }
     async getThread(entityRef, topic) {
         const { items } = await this.roomService.query({
@@ -1057,16 +1013,7 @@ class AXMCommentServiceImpl {
                 ],
             },
         });
-        const room = items[0];
-        if (!room) {
-            return null;
-        }
-        const comments = await this.getComments(room.id, true);
-        return {
-            ...room,
-            comments,
-            commentCount: comments.length,
-        };
+        return items[0] || null;
     }
     async listThreads(entityRef, topic) {
         const { items } = await this.roomService.query({
@@ -1093,33 +1040,17 @@ class AXMCommentServiceImpl {
                 ],
             },
         });
-        const threads = await Promise.all(items.map((room) => this.getThread(room.entityRef, room.topic)));
-        return threads.filter((t) => t !== null);
+        return items;
     }
-    async updateThread(entityRef, topic, data) {
-        const thread = await this.getThread(entityRef, topic);
-        if (!thread) {
-            throw new Error(`Thread for entity ${entityRef.type}#${entityRef.id} not found.`);
-        }
-        await this.roomService.updateOne(thread.id, data);
-        const updatedThread = await this.getThread(entityRef, topic);
-        if (!updatedThread) {
-            throw new Error('Failed to retrieve thread after update.');
-        }
-        return updatedThread;
+    async updateThread(threadId, data) {
+        await this.roomService.updateOne(threadId, data);
+        return this.roomService.getOne(threadId);
     }
-    async deleteThread(entityRef, topic) {
-        const thread = await this.getThread(entityRef, topic);
-        if (thread) {
-            await this.roomService.deleteOne(thread.id);
-            this._threadRemoved$.next(thread.id);
-        }
+    async deleteThread(threadId) {
+        await this.roomService.deleteOne(threadId);
         return true;
     }
-    //#endregion
-    //#region ----   Comment Service Implementation   ----
-    async addComment(threadId, content, parentCommentId, contentType = 'text', userId) {
-        const author = userId ? await this.getUserInfo(userId) : this.getCurrentUser();
+    async addComment(threadId, content, author, parentCommentId, contentType = 'text') {
         const messageContent = { content, contentType };
         const message = {
             roomId: threadId,
@@ -1132,96 +1063,232 @@ class AXMCommentServiceImpl {
             createdAt: new Date(),
         };
         const messageId = await this.messageService.insertOne(message);
-        const newComment = await this.getComment(messageId);
-        this._commentAdded$.next(newComment);
-        return newComment;
+        return this.messageService.getOne(messageId);
     }
-    async getComments(threadId, nested = true) {
+    async getComments(threadId) {
         const { items } = await this.messageService.query({
             skip: 0,
             filter: { field: 'roomId', value: threadId, operator: this.filterService.getOperator('equal') },
             sort: [{ field: 'createdAt', dir: 'asc' }],
-            take: 500, // Assuming a reasonable limit for comments per thread
+            take: 500,
         });
-        const formattedComments = items.map((c) => this.formatComment(c));
-        if (nested) {
-            return this.buildCommentTree(formattedComments);
-        }
-        return formattedComments;
+        return items;
     }
     async getComment(commentId) {
-        const message = await this.messageService.getOne(commentId);
-        return this.formatComment(message);
+        return this.messageService.getOne(commentId);
     }
-    async editComment(commentId, content, contentType = 'text') {
+    async editComment(commentId, content, editor, contentType = 'text') {
         const messageContent = { content, contentType };
         await this.messageService.updateOne(commentId, {
             message: messageContent,
             updatedAt: new Date(),
-            updatedBy: this.getCurrentUser().id,
+            updatedBy: editor.id,
         });
-        const updatedComment = await this.getComment(commentId);
-        this._commentUpdated$.next(updatedComment);
-        return updatedComment;
+        return this.messageService.getOne(commentId);
     }
     async deleteComment(commentId) {
-        // Note: This is a hard delete. Soft delete might be preferable.
         await this.messageService.deleteOne(commentId);
-        this._commentRemoved$.next(commentId);
         return true;
     }
-    //#endregion
-    //#region ----   Comment Reaction Service Implementation   ----
+    async updateReactions(commentId, reactions) {
+        await this.messageService.updateOne(commentId, { reactions });
+        return this.messageService.getOne(commentId);
+    }
+    async getReactions(commentId) {
+        const comment = await this.messageService.getOne(commentId);
+        return comment.reactions || [];
+    }
+    async pinComment(commentId, isPinned) {
+        await this.messageService.updateOne(commentId, { isPinned });
+        return this.messageService.getOne(commentId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXMCommentManagementService {
+    constructor() {
+        this.commentImplService = inject(AXMCommentServiceImpl);
+        this.sessionService = inject(AXPSessionService);
+        this.usersService = inject(AXMUsersEntityService);
+        this.realtimeService = inject(AXMCommentRealtimeService);
+    }
+    getCurrentUser() {
+        const user = this.sessionService.user;
+        if (!user) {
+            throw new Error('No authenticated user found.');
+        }
+        return {
+            id: user.id,
+            type: 'user',
+        };
+    }
+    async getUserInfo(userId) {
+        try {
+            await this.usersService.getOne(userId);
+            return { id: userId, type: 'user' };
+        }
+        catch {
+            throw new Error(`User with ID ${userId} not found`);
+        }
+    }
+    formatComment(message, depth = 0) {
+        return {
+            ...message,
+            depth,
+            replies: [],
+            replyCount: 0,
+        };
+    }
+    buildCommentTree(comments) {
+        const commentMap = new Map(comments.map((c) => [c.id, c]));
+        const tree = [];
+        comments.forEach((comment) => {
+            if (comment.replyId && commentMap.has(comment.replyId)) {
+                const parent = commentMap.get(comment.replyId);
+                parent.replies.push(comment);
+                comment.depth = (parent.depth ?? 0) + 1;
+            }
+            else {
+                tree.push(comment);
+            }
+        });
+        commentMap.forEach((comment) => {
+            comment.replyCount = comment.replies.length;
+        });
+        return tree;
+    }
+    async formatThread(room) {
+        const comments = await this.getComments(room.id, true);
+        return {
+            ...room,
+            comments,
+            commentCount: comments.length,
+        };
+    }
+    async createThread(entityRef, topic, title) {
+        const currentUser = this.getCurrentUser();
+        const newRoom = await this.commentImplService.createThread(currentUser, entityRef, topic, title);
+        const newThread = await this.formatThread(newRoom);
+        this.realtimeService.notifyThread({ type: 'add', payload: newThread });
+        return newThread;
+    }
+    async getThread(entityRef, topic) {
+        const room = await this.commentImplService.getThread(entityRef, topic);
+        if (!room) {
+            return null;
+        }
+        return this.formatThread(room);
+    }
+    async listThreads(entityRef, topic) {
+        const rooms = await this.commentImplService.listThreads(entityRef, topic);
+        return Promise.all(rooms.map((room) => this.formatThread(room)));
+    }
+    async updateThread(entityRef, topic, data) {
+        const thread = await this.getThread(entityRef, topic);
+        if (!thread) {
+            throw new Error(`Thread for entity ${entityRef.type}#${entityRef.id} not found.`);
+        }
+        const updatedRoom = await this.commentImplService.updateThread(thread.id, data);
+        const updatedThread = await this.formatThread(updatedRoom);
+        this.realtimeService.notifyThread({ type: 'update', payload: updatedThread });
+        return updatedThread;
+    }
+    async deleteThread(entityRef, topic) {
+        const thread = await this.getThread(entityRef, topic);
+        if (thread) {
+            await this.commentImplService.deleteThread(thread.id);
+            this.realtimeService.notifyThread({ type: 'remove', payload: thread.id });
+            return true;
+        }
+        return false;
+    }
+    async addComment(threadId, content, parentCommentId, contentType = 'text', userId) {
+        const author = userId ? await this.getUserInfo(userId) : this.getCurrentUser();
+        const rawComment = await this.commentImplService.addComment(threadId, content, author, parentCommentId, contentType);
+        const formattedComment = this.formatComment(rawComment);
+        this.realtimeService.notifyComment({ type: 'add', payload: formattedComment });
+        return formattedComment;
+    }
+    async getComments(threadId, nested) {
+        const rawComments = await this.commentImplService.getComments(threadId);
+        const formattedComments = rawComments.map((c) => this.formatComment(c));
+        if (nested) {
+            return this.buildCommentTree(formattedComments);
+        }
+        return formattedComments;
+    }
+    async getComment(commentId) {
+        const rawComment = await this.commentImplService.getComment(commentId);
+        return this.formatComment(rawComment);
+    }
+    async editComment(commentId, content, contentType = 'text') {
+        const editor = this.getCurrentUser();
+        const rawComment = await this.commentImplService.editComment(commentId, content, editor, contentType);
+        const formattedComment = this.formatComment(rawComment);
+        this.realtimeService.notifyComment({ type: 'update', payload: formattedComment });
+        return formattedComment;
+    }
+    async deleteComment(commentId) {
+        const result = await this.commentImplService.deleteComment(commentId);
+        if (result) {
+            this.realtimeService.notifyComment({ type: 'remove', payload: commentId });
+        }
+        return result;
+    }
     async addReaction(commentId, type) {
         const author = this.getCurrentUser();
-        const comment = await this.messageService.getOne(commentId);
+        const comment = await this.commentImplService.getComment(commentId);
         const reactions = comment.reactions || [];
         if (reactions.some((r) => r.author.id === author.id && r.type === type)) {
             return this.formatComment(comment);
         }
         const updatedReactions = [...reactions, { author, type }];
-        await this.messageService.updateOne(commentId, { reactions: updatedReactions });
-        const updatedComment = await this.getComment(commentId);
-        this._commentUpdated$.next(updatedComment);
-        return updatedComment;
+        const rawComment = await this.commentImplService.updateReactions(commentId, updatedReactions);
+        const formattedComment = this.formatComment(rawComment);
+        this.realtimeService.notifyComment({ type: 'update', payload: formattedComment });
+        return formattedComment;
     }
     async removeReaction(commentId, type) {
         const author = this.getCurrentUser();
-        const comment = await this.messageService.getOne(commentId);
+        const comment = await this.commentImplService.getComment(commentId);
         const updatedReactions = (comment.reactions || []).filter((r) => !(r.author.id === author.id && r.type === type));
-        await this.messageService.updateOne(commentId, { reactions: updatedReactions });
-        const updatedComment = await this.getComment(commentId);
-        this._commentUpdated$.next(updatedComment);
-        return updatedComment;
+        const rawComment = await this.commentImplService.updateReactions(commentId, updatedReactions);
+        const formattedComment = this.formatComment(rawComment);
+        this.realtimeService.notifyComment({ type: 'update', payload: formattedComment });
+        return formattedComment;
     }
-    async getReactions(commentId) {
-        const comment = await this.messageService.getOne(commentId);
-        return comment.reactions || [];
+    getReactions(commentId) {
+        return this.commentImplService.getReactions(commentId);
     }
-    async likeComment(commentId) {
+    likeComment(commentId) {
         return this.addReaction(commentId, 'like');
     }
-    async unlikeComment(commentId) {
+    unlikeComment(commentId) {
         return this.removeReaction(commentId, 'like');
     }
-    //#endregion
-    //#region ----   Comment Pin Service Implementation   ----
     async pinComment(commentId) {
-        await this.messageService.updateOne(commentId, { isPinned: true });
-        const updatedComment = await this.getComment(commentId);
-        this._commentUpdated$.next(updatedComment);
-        return updatedComment;
+        const rawComment = await this.commentImplService.pinComment(commentId, true);
+        const formattedComment = this.formatComment(rawComment);
+        this.realtimeService.notifyComment({ type: 'update', payload: formattedComment });
+        return formattedComment;
     }
     async unpinComment(commentId) {
-        await this.messageService.updateOne(commentId, { isPinned: false });
-        const updatedComment = await this.getComment(commentId);
-        this._commentUpdated$.next(updatedComment);
-        return updatedComment;
+        const rawComment = await this.commentImplService.pinComment(commentId, false);
+        const formattedComment = this.formatComment(rawComment);
+        this.realtimeService.notifyComment({ type: 'update', payload: formattedComment });
+        return formattedComment;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentServiceImpl, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentManagementService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentServiceImpl, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCommentManagementService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1244,7 +1311,8 @@ class AXMCommentComponent {
         this.activeEditComment = signal(undefined, ...(ngDevMode ? [{ debugName: "activeEditComment" }] : []));
         this.highlightedCommentId = signal(null, ...(ngDevMode ? [{ debugName: "highlightedCommentId" }] : []));
         this.wysiwygEditor = viewChild.required('w');
-        this.commentService = inject(AXMCommentService);
+        this.commentService = inject(AXMCommentManagementService);
+        this.realtimeService = inject(AXMCommentRealtimeService);
         this.sessionService = inject(AXPSessionService);
         this.toastService = inject(AXToastService);
         this.dialogService = inject(AXDialogService);
@@ -1280,36 +1348,51 @@ class AXMCommentComponent {
                 this.isLoading.set(false);
             }, 250);
         });
-        this.commentService.commentAdded$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((comment) => {
-            if (comment.replyId) {
-                this.comments.update((comments) => {
-                    return comments.map((c) => {
-                        if (c.id === comment.replyId) {
-                            const newReplies = c.replies ? [...c.replies, comment] : [comment];
-                            return { ...c, replies: newReplies, replyCount: newReplies.length };
-                        }
-                        return c;
-                    });
-                });
-            }
-            else {
-                this.comments.update((comments) => [...comments, comment]);
+        this.realtimeService.comment$
+            .pipe(takeUntilDestroyed(this.destroyRef), filter((event) => !!event))
+            .subscribe((event) => {
+            switch (event.type) {
+                case 'add':
+                    this.handleAddComment(event.payload);
+                    break;
+                case 'update':
+                    this.handleUpdateComment(event.payload);
+                    break;
+                case 'remove':
+                    this.removeMessageById(event.payload);
+                    break;
             }
         });
-        this.commentService.commentUpdated$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((updatedComment) => {
-            const update = (list) => {
-                return list.map((c) => {
-                    if (c.id === updatedComment.id) {
-                        return { ...c, ...updatedComment, replies: updatedComment.replies || c.replies };
-                    }
-                    if (c.replies && c.replies.length > 0) {
-                        return { ...c, replies: update(c.replies) };
+    }
+    handleAddComment(comment) {
+        if (comment.replyId) {
+            this.comments.update((comments) => {
+                return comments.map((c) => {
+                    if (c.id === comment.replyId) {
+                        const newReplies = c.replies ? [...c.replies, comment] : [comment];
+                        return { ...c, replies: newReplies, replyCount: newReplies.length };
                     }
                     return c;
                 });
-            };
-            this.comments.update((comments) => update(comments));
-        });
+            });
+        }
+        else {
+            this.comments.update((comments) => [...comments, comment]);
+        }
+    }
+    handleUpdateComment(updatedComment) {
+        const update = (list) => {
+            return list.map((c) => {
+                if (c.id === updatedComment.id) {
+                    return { ...c, ...updatedComment, replies: updatedComment.replies || c.replies };
+                }
+                if (c.replies && c.replies.length > 0) {
+                    return { ...c, replies: update(c.replies) };
+                }
+                return c;
+            });
+        };
+        this.comments.update((comments) => update(comments));
     }
     getCurrentUser() {
         const user = this.sessionService.user;
@@ -1340,7 +1423,7 @@ class AXMCommentComponent {
             const thread = await this.commentService.getThread({ type: this.refrenceType(), id: this.refrenceId() }, this.subject());
             if (thread) {
                 this.thread.set(thread);
-                this.comments.set(thread.comments);
+                this.comments.set(thread.comments || []);
             }
             else {
                 this.comments.set([]);
@@ -1376,7 +1459,7 @@ class AXMCommentComponent {
         this.activeReplyComment.set({ ...comment, userName: userName || '' });
         if (reply) {
             const author = reply.author.fullName || reply.author.id;
-            const mention = `<a data-id="${reply.id}">@${author}</a> `;
+            const mention = `<strong><a data-id="${reply.author.username}">@${userName || author}</a></strong> `;
             this.commentContent.set(mention);
             document.getElementsByClassName('ql-editor')[0].innerHTML = mention;
             this.wysiwygEditor()?.focus();
@@ -1812,16 +1895,6 @@ const AXMCommentPopupWorkflow = {
 };
 
 function convertChatMessageToNotification(room, message, currentUser) {
-    const mapToNotificationUser = (user) => {
-        return {
-            id: user.id,
-            name: user.fullName || '',
-            image: '', // You might want to add an avatar URL here if available
-            username: user.username || '',
-            firstName: user.fullName?.split(' ')[0] || '',
-            lastName: user.fullName?.split(' ')[1] || '',
-        };
-    };
     return {
         channel: 'InApp',
         template: {
@@ -1832,14 +1905,11 @@ function convertChatMessageToNotification(room, message, currentUser) {
         },
         title: room.title || 'New Message',
         body: message.message.content,
-        user: mapToNotificationUser(message.author),
-        content: {
-            type: 'Notification',
-            data: {
-                roomId: room.id,
-            },
-        },
+        sender: message.author,
+        receiver: currentUser,
+        content: message.message,
         readAt: null,
+        type: 'Chat',
     };
 }
 
@@ -3505,6 +3575,10 @@ class AXMConversationModule {
                 provide: AXMCommentService,
                 useClass: AXMCommentServiceImpl,
             },
+            {
+                provide: AXMCommentRealtimeService,
+                useClass: AXMCommentRealtimeServiceImpl,
+            },
             // Entity Provider
             {
                 provide: AXP_ENTITY_DEFINITION_LOADER,
@@ -3588,6 +3662,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
                             provide: AXMCommentService,
                             useClass: AXMCommentServiceImpl,
                         },
+                        {
+                            provide: AXMCommentRealtimeService,
+                            useClass: AXMCommentRealtimeServiceImpl,
+                        },
                         // Entity Provider
                         {
                             provide: AXP_ENTITY_DEFINITION_LOADER,
@@ -3621,5 +3699,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXMChatComponent, AXMChatItemComponent, AXMChatPreviewComponent, AXMChatService, AXMChatServiceImpl, AXMCommentComponent, AXMCommentPopupComponent, AXMCommentPopupStartAction, AXMCommentPopupWorkflow, AXMCommentService, AXMCommentServiceImpl, AXMCommentWidgetViewComponent, AXMConversationModule, AXMConversationTabService, AXMConversationTabServiceImpl, AXMMessageService, AXMMessageServiceImpl, AXMRoomService, AXMRoomServiceImpl, AXMUserLookupPopup, AXPCommentWidget, RootConfig, messageFactory, roomFactory, tabFactory };
+export { AXMChatComponent, AXMChatItemComponent, AXMChatPreviewComponent, AXMChatService, AXMChatServiceImpl, AXMCommentComponent, AXMCommentManagementService, AXMCommentPopupComponent, AXMCommentPopupStartAction, AXMCommentPopupWorkflow, AXMCommentRealtimeService, AXMCommentRealtimeServiceImpl, AXMCommentService, AXMCommentServiceImpl, AXMCommentWidgetViewComponent, AXMConversationModule, AXMConversationTabService, AXMConversationTabServiceImpl, AXMMessageService, AXMMessageServiceImpl, AXMRoomService, AXMRoomServiceImpl, AXMUserLookupPopup, AXPCommentWidget, RootConfig, messageFactory, roomFactory, tabFactory };
 //# sourceMappingURL=acorex-modules-conversation.mjs.map