@builder6/rooms 0.10.7 → 0.11.0

package/dist/rooms/rooms.service.js

@@ -8,6 +8,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoomsService = exports.CommentBodyInlineType = exports.CommentType = void 0;
 const core_1 = require("@builder6/core");
@@ -17,6 +26,7 @@ const rooms_dto_1 = require("./dtos/rooms.dto");
 const lodash_1 = require("lodash");
 const notifications_service_1 = require("./notifications.service");
 const uuid_1 = require("uuid");
+const emailNotification_service_1 = require("./emailNotification.service");
 var CommentType;
 (function (CommentType) {
     CommentType["Paragraph"] = "paragraph";
@@ -27,399 +37,457 @@ var CommentBodyInlineType;
     CommentBodyInlineType["Link"] = "link";
 })(CommentBodyInlineType = exports.CommentBodyInlineType || (exports.CommentBodyInlineType = {}));
 let RoomsService = class RoomsService {
-    constructor(mongodbService, jwtService, notificationsService) {
+    constructor(mongodbService, jwtService, notificationsService, emailNotificationService) {
         this.mongodbService = mongodbService;
         this.jwtService = jwtService;
         this.notificationsService = notificationsService;
+        this.emailNotificationService = emailNotificationService;
     }
-    async getToken({ spaceId, userId, perms, }) {
-        const payload = {
-            k: 'acc',
-            pid: spaceId,
-            sid: spaceId,
-            uid: userId,
-            mcpr: 10,
-            perms: perms,
-            jti: 'S4EMiESTDe6k',
-        };
-        const token = await this.jwtService.signAsync(payload);
-        return { token };
+    getToken({ spaceId, userId, perms, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = {
+                k: 'acc',
+                pid: spaceId,
+                sid: spaceId,
+                uid: userId,
+                mcpr: 10,
+                perms: perms,
+                jti: 'S4EMiESTDe6k',
+            };
+            const token = yield this.jwtService.signAsync(payload);
+            return { token };
+        });
     }
-    async getRoomToken({ roomId, spaceId, userId, readonly = false, }) {
-        let room = await this.getRoom(roomId);
-        if (!room) {
-            room = await this.createRoom({
-                _id: roomId,
-                name: 'Room ' + roomId,
-            });
-        }
-        let member = await this.getRoomMember(roomId, userId);
-        if (!member) {
-            member = await this.createRoomMember(room, {
+    getRoomToken({ roomId, spaceId, userId, readonly = false, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let room = yield this.getRoom(roomId);
+            if (!room) {
+                room = yield this.createRoom({
+                    _id: roomId,
+                    name: 'Room ' + roomId,
+                });
+            }
+            let member = yield this.getRoomMember(roomId, userId);
+            if (!member) {
+                member = yield this.createRoomMember(room, {
+                    userId,
+                });
+            }
+            const scopes = readonly ? rooms_dto_1.READ_ACCESS : member.scopes;
+            const perms = {
+                [roomId]: scopes,
+            };
+            return yield this.getToken({
+                spaceId,
                 userId,
+                perms,
             });
-        }
-        const scopes = readonly ? rooms_dto_1.READ_ACCESS : member.scopes;
-        const perms = {
-            [roomId]: scopes,
-        };
-        return await this.getToken({
-            spaceId,
-            userId,
-            perms,
-        });
-    }
-    async getAttachmentById(attachmentId) {
-        const attachment = await this.mongodbService.findOne('cfs.files.filerecord', {
-            _id: attachmentId,
         });
-        return {
-            id: attachmentId,
-            mimeType: attachment.original.type,
-            name: attachment.original.name,
-            size: attachment.original.size,
-            type: 'attachment',
-        };
     }
-    async getUsers(userIds) {
-        if (typeof userIds === 'string') {
-            userIds = [userIds];
-        }
-        const users = [];
-        for (const userId of userIds) {
-            const user = await this.mongodbService.findOne('users', {
-                _id: userId,
+    getAttachmentById(attachmentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attachment = yield this.mongodbService.findOne('cfs.files.filerecord', {
+                _id: attachmentId,
             });
-            users.push({
-                name: user ? user.name : 'Unknown',
-                avatar: '/api/v6/users/' + userId + '/avatar',
-            });
-        }
-        return users;
+            return {
+                id: attachmentId,
+                mimeType: attachment.original.type,
+                name: attachment.original.name,
+                size: attachment.original.size,
+                type: 'attachment',
+            };
+        });
     }
-    async searchUsers(spaceId, keyword, roomId) {
-        const spaceUsers = await this.mongodbService.find('space_users', {
-            space: spaceId,
-            $or: [
-                { username: { $regex: keyword, $options: 'i' } },
-                { email: { $regex: keyword, $options: 'i' } },
-                { name: { $regex: keyword, $options: 'i' } },
-            ],
+    resolveUsers({ userIds }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const users = [];
+            for (const userId of userIds) {
+                const user = yield this.mongodbService.findOne('users', {
+                    _id: userId,
+                });
+                users.push({
+                    name: user ? user.name : 'Unknown',
+                    avatar: `${process.env.B6_HOST}/api/v6/users/${userId}/avatar`,
+                });
+            }
+            return users;
         });
-        return spaceUsers.map((spaceUser) => spaceUser.user);
     }
-    async getThread(roomId, threadId) {
-        const thread = await this.mongodbService.findOne('b6_threads', {
-            roomId: roomId,
-            _id: threadId,
+    searchUsers(spaceId, keyword, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spaceUsers = yield this.mongodbService.find('space_users', {
+                space: spaceId,
+                $or: [
+                    { username: { $regex: keyword, $options: 'i' } },
+                    { email: { $regex: keyword, $options: 'i' } },
+                    { name: { $regex: keyword, $options: 'i' } },
+                ],
+            });
+            return spaceUsers.map((spaceUser) => spaceUser.user);
         });
-        if (!thread) {
-            return null;
-        }
-        const comments = await this.getComments(roomId, threadId);
-        thread.comments = comments;
-        return thread;
     }
-    async getThreads(roomId, since) {
-        const queryOptions = { roomId: roomId };
-        if (since) {
-            queryOptions.updatedAt = { $gt: since };
-        }
-        const threads = await this.mongodbService.find('b6_threads', queryOptions);
-        for (const thread of threads) {
-            const comments = await this.getComments(roomId, thread.id);
+    getThread({ roomId, threadId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const thread = yield this.mongodbService.findOne('b6_threads', {
+                roomId: roomId,
+                _id: threadId,
+            });
+            if (!thread) {
+                return null;
+            }
+            const comments = yield this.getComments(roomId, threadId);
             thread.comments = comments;
-        }
-        return threads;
+            return thread;
+        });
     }
-    async getThreadsByIds(notifications) {
-        const threadPromises = [];
-        for (let i = 0; i < notifications.length; i++) {
-            const notification = notifications[i];
-            threadPromises.push(this.getThread(notification.roomId, notification.threadId));
-        }
-        if (threadPromises.length > 0) {
-            return Promise.all(threadPromises);
-        }
-        return [];
+    getThreads(roomId, since) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryOptions = { roomId: roomId };
+            if (since) {
+                queryOptions.updatedAt = { $gt: since };
+            }
+            const threads = yield this.mongodbService.find('b6_threads', queryOptions);
+            for (const thread of threads) {
+                const comments = yield this.getComments(roomId, thread.id);
+                thread.comments = comments;
+            }
+            return threads;
+        });
     }
-    async getComments(roomId, threadId) {
-        const comments = await this.mongodbService.find('b6_comments', {
-            roomId: roomId,
-            threadId: threadId,
+    getThreadsByIds(notifications) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const threadPromises = [];
+            for (let i = 0; i < notifications.length; i++) {
+                const notification = notifications[i];
+                threadPromises.push(this.getThread({
+                    roomId: notification.roomId,
+                    threadId: notification.threadId,
+                }));
+            }
+            if (threadPromises.length > 0) {
+                return Promise.all(threadPromises);
+            }
+            return [];
         });
-        for (const comment of comments) {
-            comment.attachments = [];
-            for (const attachmentId of comment.attachmentIds) {
-                const attachment = await this.getAttachmentById(attachmentId);
-                comment.attachments.push(attachment);
+    }
+    getComments(roomId, threadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const comments = yield this.mongodbService.find('b6_comments', {
+                roomId: roomId,
+                threadId: threadId,
+            });
+            for (const comment of comments) {
+                comment.attachments = [];
+                for (const attachmentId of comment.attachmentIds) {
+                    const attachment = yield this.getAttachmentById(attachmentId);
+                    comment.attachments.push(attachment);
+                }
             }
-        }
-        return comments;
+            return comments;
+        });
     }
-    async createThread({ id, comment, metadata, resolved = false, roomId, userId, }) {
-        const newThread = {
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            _id: id,
-            id,
-            resolved,
-            metadata,
-            type: 'thread',
-            roomId,
-            userId,
-        };
-        const result = await this.mongodbService.insertOne('b6_threads', newThread);
-        const newComment = await this.createComment({
-            id: comment.id,
-            attachmentIds: comment.attachmentIds,
-            body: comment.body,
-            roomId,
-            threadId: id,
-            userId,
+    createThread({ id, comment, metadata, resolved = false, roomId, userId, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newThread = {
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                _id: id,
+                id,
+                resolved,
+                metadata,
+                type: 'thread',
+                roomId,
+                userId,
+            };
+            const result = yield this.mongodbService.insertOne('b6_threads', newThread);
+            const newComment = yield this.createComment({
+                id: comment.id,
+                attachmentIds: comment.attachmentIds,
+                body: comment.body,
+                roomId,
+                threadId: id,
+                userId,
+            });
+            result.comments = [newComment];
+            return result;
         });
-        result.comments = [newComment];
-        return result;
     }
-    async updateThread(threadId, thread) {
-        const newThread = {
-            updatedAt: new Date().toISOString(),
-            ...thread,
-        };
-        const result = await this.mongodbService.findOneAndUpdate('b6_threads', { _id: threadId }, newThread);
-        return result;
+    updateThread(threadId, thread) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newThread = Object.assign({ updatedAt: new Date().toISOString() }, thread);
+            const result = yield this.mongodbService.findOneAndUpdate('b6_threads', { _id: threadId }, newThread);
+            return result;
+        });
     }
-    async createComment({ id, attachmentIds, body, roomId, threadId, userId, }) {
-        const newComment = {
-            createdAt: new Date().toISOString(),
-            _id: id,
-            id,
-            reactions: [],
-            roomId,
-            threadId,
-            userId,
-            type: 'comment',
-            attachmentIds,
-            body,
-        };
-        const result = await this.mongodbService.insertOne('b6_comments', newComment);
-        result.attachments = [];
-        for (const attachmentId of attachmentIds) {
-            const attachment = await this.getAttachmentById(attachmentId);
-            result.attachments.push(attachment);
-        }
-        const { content } = body;
-        let notificationsPromises;
-        let createRoomMentionPromises;
-        const mentionUsers = [];
-        for (const message of content) {
-            if (message.type === CommentType.Paragraph) {
-                message.children
-                    .filter((child) => child?.type === CommentBodyInlineType.Mention)
-                    .forEach((child) => mentionUsers.push(child.id));
+    createComment({ id, attachmentIds, body, roomId, threadId, userId, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newComment = {
+                createdAt: new Date().toISOString(),
+                _id: id,
+                id,
+                reactions: [],
+                roomId,
+                threadId,
+                userId,
+                type: 'comment',
+                attachmentIds,
+                body,
+            };
+            const result = yield this.mongodbService.insertOne('b6_comments', newComment);
+            result.attachments = [];
+            for (const attachmentId of attachmentIds) {
+                const attachment = yield this.getAttachmentById(attachmentId);
+                result.attachments.push(attachment);
             }
-        }
-        if (mentionUsers && mentionUsers.length > 0) {
-            const uniqUsers = (0, lodash_1.uniq)(mentionUsers);
-            notificationsPromises = uniqUsers.map((mentionedUserId) => {
-                const _id = (0, uuid_1.v4)();
-                return this.notificationsService.createInboxNotification({
-                    _id,
-                    userId: mentionedUserId,
-                    kind: 'thread',
-                    notifiedAt: new Date(),
-                    readAt: null,
-                    roomId,
-                    threadId,
-                });
-            });
-            createRoomMentionPromises = uniqUsers.map((mentionedUserId) => {
-                return this.notificationsService.createRoomMention({
-                    userId: mentionedUserId,
-                    roomId,
-                    fromUserId: userId,
+            const { content } = body;
+            let notificationsPromises;
+            let createRoomMentionPromises;
+            const mentionUsers = [];
+            for (const message of content) {
+                if (message.type === CommentType.Paragraph) {
+                    message.children
+                        .filter((child) => (child === null || child === void 0 ? void 0 : child.type) === CommentBodyInlineType.Mention)
+                        .forEach((child) => mentionUsers.push(child.id));
+                }
+            }
+            if (mentionUsers && mentionUsers.length > 0) {
+                const uniqUsers = (0, lodash_1.uniq)(mentionUsers);
+                notificationsPromises = uniqUsers.map((mentionedUserId) => __awaiter(this, void 0, void 0, function* () {
+                    const _id = (0, uuid_1.v4)();
+                    const notification = yield this.notificationsService.createInboxNotification({
+                        _id,
+                        userId: mentionedUserId,
+                        kind: 'thread',
+                        notifiedAt: new Date(),
+                        readAt: null,
+                        roomId,
+                        threadId,
+                    });
+                    yield this.emailNotificationService.sendThreadNotificationEmail({
+                        roomId,
+                        threadId,
+                        userId: mentionedUserId,
+                        fromUserId: userId,
+                        inboxNotificationId: notification._id,
+                    });
+                }));
+                createRoomMentionPromises = uniqUsers.map((mentionedUserId) => {
+                    return this.notificationsService.createRoomMention({
+                        userId: mentionedUserId,
+                        roomId,
+                        fromUserId: userId,
+                    });
                 });
-            });
-            await Promise.all([].concat(notificationsPromises, createRoomMentionPromises));
-        }
-        delete result['_id'];
-        delete result['attachmentIds'];
-        return result;
-    }
-    async updateComment(commentId, { attachmentIds, body, userId }) {
-        const newComment = {
-            updatedAt: new Date().toISOString(),
-            type: 'comment',
-            attachmentIds,
-            body,
-            userId,
-        };
-        const result = (await this.mongodbService.findOneAndUpdate('b6_comments', { _id: commentId }, newComment));
-        result.attachments = [];
-        for (const attachmentId of attachmentIds) {
-            const attachment = await this.getAttachmentById(attachmentId);
-            result.attachments.push(attachment);
-        }
-        delete result['_id'];
-        delete result['attachmentIds'];
-        return result;
+                yield Promise.all([].concat(notificationsPromises, createRoomMentionPromises));
+            }
+            delete result['_id'];
+            delete result['attachmentIds'];
+            return result;
+        });
     }
-    async deleteComment(commentId) {
-        const result = await this.mongodbService.deleteOne('b6_comments', {
-            _id: commentId,
+    updateComment(commentId, { attachmentIds, body, userId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newComment = {
+                updatedAt: new Date().toISOString(),
+                type: 'comment',
+                attachmentIds,
+                body,
+                userId,
+            };
+            const result = (yield this.mongodbService.findOneAndUpdate('b6_comments', { _id: commentId }, newComment));
+            result.attachments = [];
+            for (const attachmentId of attachmentIds) {
+                const attachment = yield this.getAttachmentById(attachmentId);
+                result.attachments.push(attachment);
+            }
+            delete result['_id'];
+            delete result['attachmentIds'];
+            return result;
         });
-        return result;
     }
-    async createReaction(commentId, { userId, emoji }) {
-        const comment = await this.mongodbService.findOne('b6_comments', {
-            _id: commentId,
+    deleteComment(commentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.mongodbService.deleteOne('b6_comments', {
+                _id: commentId,
+            });
+            return result;
         });
-        if (!comment) {
-            throw new Error('Comment not found');
-        }
-        let reaction = comment.reactions.find((reaction) => reaction.emoji === emoji);
-        if (reaction) {
-            const userExists = reaction.users.some((user) => user.id === userId);
-            if (!userExists) {
-                reaction.users.push({ id: userId });
+    }
+    createReaction(commentId, { userId, emoji }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const comment = yield this.mongodbService.findOne('b6_comments', {
+                _id: commentId,
+            });
+            if (!comment) {
+                throw new Error('Comment not found');
+            }
+            let reaction = comment.reactions.find((reaction) => reaction.emoji === emoji);
+            if (reaction) {
+                const userExists = reaction.users.some((user) => user.id === userId);
+                if (!userExists) {
+                    reaction.users.push({ id: userId });
+                }
+            }
+            else {
+                reaction = {
+                    emoji,
+                    createdAt: new Date().toISOString(),
+                    users: [{ id: userId }],
+                };
+                comment.reactions.push(reaction);
             }
-        }
-        else {
-            reaction = {
+            yield this.mongodbService.findOneAndUpdate('b6_comments', { _id: commentId }, comment);
+            return {
                 emoji,
-                createdAt: new Date().toISOString(),
-                users: [{ id: userId }],
+                createdAt: reaction.createdAt,
+                userId,
             };
-            comment.reactions.push(reaction);
-        }
-        await this.mongodbService.findOneAndUpdate('b6_comments', { _id: commentId }, comment);
-        return {
-            emoji,
-            createdAt: reaction.createdAt,
-            userId,
-        };
-    }
-    async deleteReaction(commentId, { userId, emoji }) {
-        const comment = await this.mongodbService.findOne('b6_comments', {
-            _id: commentId,
         });
-        if (!comment) {
-            throw new Error('Comment not found');
-        }
-        const reaction = comment.reactions.find((reaction) => reaction.emoji === emoji);
-        if (!reaction) {
-            throw new Error('Reaction not found');
-        }
-        reaction.users = reaction.users.filter((user) => user.id !== userId);
-        comment.reactions = comment.reactions.filter((reaction) => reaction.users.length > 0);
-        await this.mongodbService.findOneAndUpdate('b6_comments', { _id: commentId }, comment);
-        return null;
     }
-    async createRoom({ _id, name, description = '', membershipType = 'standard', members = [], defaultNotifications = ['replies', 'mentions'], defaultScopes = ['room:write'], }) {
-        const newRoom = {
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            _id,
-            name,
-            description,
-            membershipType,
-            defaultNotifications,
-            defaultScopes,
-        };
-        const room = await this.mongodbService.insertOne('b6_rooms', newRoom);
-        room.members = [];
-        for (const member of members) {
-            const newMember = await this.createRoomMember(room, member);
-            room.members.push(newMember);
-        }
-        return room;
+    deleteReaction(commentId, { userId, emoji }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const comment = yield this.mongodbService.findOne('b6_comments', {
+                _id: commentId,
+            });
+            if (!comment) {
+                throw new Error('Comment not found');
+            }
+            const reaction = comment.reactions.find((reaction) => reaction.emoji === emoji);
+            if (!reaction) {
+                throw new Error('Reaction not found');
+            }
+            reaction.users = reaction.users.filter((user) => user.id !== userId);
+            comment.reactions = comment.reactions.filter((reaction) => reaction.users.length > 0);
+            yield this.mongodbService.findOneAndUpdate('b6_comments', { _id: commentId }, comment);
+            return null;
+        });
     }
-    async createRoomMember(room, member) {
-        const { _id, userId, roles = [], notifications = room.defaultNotifications, scopes = room.defaultScopes, } = member;
-        const newMember = {
-            _id,
-            userId,
-            roles,
-            roomId: room._id,
-            notifications,
-            scopes,
-            createdAt: new Date().toISOString(),
-        };
-        const result = await this.mongodbService.insertOne('b6_room_members', newMember);
-        return result;
+    createRoom({ _id, name, description = '', membershipType = 'standard', members = [], defaultNotifications = ['replies', 'mentions'], defaultScopes = ['room:write'], }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newRoom = {
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                _id,
+                name,
+                description,
+                membershipType,
+                defaultNotifications,
+                defaultScopes,
+            };
+            const room = yield this.mongodbService.insertOne('b6_rooms', newRoom);
+            room.members = [];
+            for (const member of members) {
+                const newMember = yield this.createRoomMember(room, member);
+                room.members.push(newMember);
+            }
+            return room;
+        });
     }
-    async getRoom(roomId) {
-        const room = await this.mongodbService.findOne('b6_rooms', {
-            _id: roomId,
+    createRoomMember(room, member) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _id, userId, roles = [], notifications = room.defaultNotifications, scopes = room.defaultScopes, } = member;
+            const newMember = {
+                _id,
+                userId,
+                roles,
+                roomId: room._id,
+                notifications,
+                scopes,
+                createdAt: new Date().toISOString(),
+            };
+            const result = yield this.mongodbService.insertOne('b6_room_members', newMember);
+            return result;
         });
-        if (!room) {
-            return null;
-        }
-        room.members = await this.getRoomMembers(roomId);
-        return room;
     }
-    async getRoomMembers(roomId) {
-        const members = await this.mongodbService.find('b6_room_members', {
-            roomId,
+    getRoom(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const room = yield this.mongodbService.findOne('b6_rooms', {
+                _id: roomId,
+            });
+            if (!room) {
+                return null;
+            }
+            room.members = yield this.getRoomMembers(roomId);
+            return room;
         });
-        return members;
     }
-    async getRoomMember(roomId, userId) {
-        const member = await this.mongodbService.findOne('b6_room_members', {
-            roomId,
-            userId,
+    getRoomMembers(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const members = yield this.mongodbService.find('b6_room_members', {
+                roomId,
+            });
+            return members;
         });
-        return member;
     }
-    async getMyRooms(userId) {
-        const roomMembers = await this.mongodbService.find('b6_room_members', {
-            userId,
+    getRoomMember(roomId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const member = yield this.mongodbService.findOne('b6_room_members', {
+                roomId,
+                userId,
+            });
+            return member;
         });
-        const rooms = [];
-        for (const roomMember of roomMembers) {
-            const room = await this.getRoom(roomMember.roomId);
-            rooms.push(room);
-        }
-        return rooms;
     }
-    async getRooms(roomIds) {
-        if (typeof roomIds === 'string') {
-            roomIds = [roomIds];
-        }
-        const result = [];
-        for (const roomId of roomIds) {
-            if (roomId &&
-                roomId.split(':').length === 3 &&
-                roomId.split(':')[0] === 'objects') {
-                const [, objectName, recordId] = roomId.split(':');
-                const record = await this.mongodbService.findOne(objectName, {
-                    _id: recordId,
-                }, {
-                    projection: {
-                        name: 1,
-                    },
-                });
-                result.push({
-                    id: roomId,
-                    name: record ? record.name : roomId,
-                    url: record ? `/b6/steedos/${objectName}/${recordId}` : null,
-                });
+    getMyRooms(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roomMembers = yield this.mongodbService.find('b6_room_members', {
+                userId,
+            });
+            const rooms = [];
+            for (const roomMember of roomMembers) {
+                const room = yield this.getRoom(roomMember.roomId);
+                rooms.push(room);
             }
-            else {
-                result.push({
-                    id: roomId,
-                    name: roomId,
-                });
+            return rooms;
+        });
+    }
+    resolveRoomInfo({ roomIds }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = [];
+            for (const roomId of roomIds) {
+                if (roomId &&
+                    roomId.split(':').length === 3 &&
+                    roomId.split(':')[0] === 'objects') {
+                    const [, objectName, recordId] = roomId.split(':');
+                    const record = yield this.mongodbService.findOne(objectName, {
+                        _id: recordId,
+                    }, {
+                        projection: {
+                            name: 1,
+                        },
+                    });
+                    result.push({
+                        id: roomId,
+                        name: record ? record.name : roomId,
+                        url: record ? `${process.env.B6_HOST}/b6/rooms/${roomId}` : null,
+                    });
+                }
+                else {
+                    result.push({
+                        id: roomId,
+                        name: roomId,
+                    });
+                }
             }
-        }
-        return result;
+            return result;
+        });
+    }
+    getInboxNotification({ inboxNotificationId, userId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notification = yield this.notificationsService.getInboxNotification({
+                inboxNotificationId,
+                userId,
+            });
+            return notification;
+        });
     }
 };
 RoomsService = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [core_1.MongodbService,
         jwt_1.JwtService,
-        notifications_service_1.NotificationsService])
+        notifications_service_1.NotificationsService,
+        emailNotification_service_1.EmailNotificationService])
 ], RoomsService);
 exports.RoomsService = RoomsService;
 //# sourceMappingURL=rooms.service.js.map