@builder6/rooms 0.10.8 → 0.11.0

package/dist/rooms/rooms.controller.js

@@ -11,12 +11,22 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+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.RoomsController = void 0;
 const core_1 = require("@builder6/core");
 const files_1 = require("@builder6/files");
 const rooms_service_1 = require("./rooms.service");
 const lodash_1 = require("lodash");
+const swagger_1 = require("@nestjs/swagger");
 const common_1 = require("@nestjs/common");
 const jwt_1 = require("@nestjs/jwt");
 const rooms_guard_1 = require("./rooms.guard");
@@ -24,292 +34,347 @@ const rawBody = require("raw-body");
 const rooms_gateway_1 = require("./rooms.gateway");
 const ServerMsg_1 = require("./protocol/ServerMsg");
 const notifications_service_1 = require("./notifications.service");
+const emailNotification_service_1 = require("./emailNotification.service");
 let RoomsController = class RoomsController {
-    constructor(roomsService, filesService, jwtService, roomsGateway, notificationsService) {
+    constructor(roomsService, filesService, jwtService, roomsGateway, notificationsService, emailNotificationService) {
         this.roomsService = roomsService;
         this.filesService = filesService;
         this.jwtService = jwtService;
         this.roomsGateway = roomsGateway;
         this.notificationsService = notificationsService;
+        this.emailNotificationService = emailNotificationService;
     }
-    async getToken(body, req) {
-        const user = req['user'];
-        const { room = 'test', permission = 'read' } = body;
-        return await this.roomsService.getRoomToken({
-            spaceId: user.space,
-            userId: user.user,
-            roomId: room,
-            readonly: permission === 'read',
+    getToken(body, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = req['user'];
+            const { room = 'test', permission = 'read' } = body;
+            return yield this.roomsService.getRoomToken({
+                spaceId: user.space,
+                userId: user.user,
+                roomId: room,
+                readonly: permission === 'read',
+            });
         });
     }
-    async getUsers(userIds) {
-        const users = await this.roomsService.getUsers(userIds);
-        return users;
-    }
-    async searchUsers(req, keyword, roomdId) {
-        const spaceId = req['jwt'].sid;
-        const users = await this.roomsService.searchUsers(spaceId, keyword, roomdId);
-        return users;
-    }
-    async getRooms(roomIds) {
-        const rooms = await this.roomsService.getRooms(roomIds);
-        return rooms;
-    }
-    async getThreads(req, roomId) {
-        const threads = await this.roomsService.getThreads(roomId);
-        const inboxNotifications = await this.notificationsService.findNotifications({
-            userId: req['jwt'].uid,
-            roomId,
+    getUsers(userIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof userIds === 'string') {
+                userIds = [userIds];
+            }
+            const users = yield this.roomsService.resolveUsers({ userIds });
+            return users;
         });
-        return {
-            data: threads,
-            inboxNotifications: inboxNotifications.map((inboxNotification) => (0, lodash_1.omit)(inboxNotification, ['userId', '_id'])),
-            meta: {
-                nextCursor: null,
-                requestedAt: new Date().toISOString(),
-                permissionHints: {
-                    [roomId]: ['room:write'],
-                },
-            },
-            deletedThreads: [],
-            deletedInboxNotifications: [],
-        };
     }
-    async getThreadsDelta(req, roomId, since) {
-        const sinceDate = new Date(since);
-        const threads = await this.roomsService.getThreads(roomId, sinceDate);
-        const inboxNotifications = await this.notificationsService.findNotifications({
-            userId: req['jwt'].uid,
-            roomId,
-            sinceDate,
+    searchUsers(req, keyword, roomdId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spaceId = req['jwt'].sid;
+            const users = yield this.roomsService.searchUsers(spaceId, keyword, roomdId);
+            return users;
         });
-        return {
-            data: threads,
-            inboxNotifications: inboxNotifications.map((inboxNotification) => (0, lodash_1.omit)(inboxNotification, ['userId', '_id'])),
-            meta: {
-                nextCursor: null,
-                requestedAt: new Date().toISOString(),
-                permissionHints: {
-                    [roomId]: ['room:write'],
-                },
-            },
-            deletedThreads: [],
-            deletedInboxNotifications: [],
-        };
     }
-    async createThread(req, roomId, record) {
-        const userId = req['jwt'].uid;
-        const newThread = await this.roomsService.createThread({
-            id: record.id,
-            comment: record.comment,
-            roomId,
-            userId,
-            metadata: {},
-            resolved: false,
+    getRooms(roomIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof roomIds === 'string') {
+                roomIds = [roomIds];
+            }
+            const rooms = yield this.roomsService.resolveRoomInfo({ roomIds });
+            return rooms;
         });
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.THREAD_CREATED,
-            threadId: record.id,
-        });
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.COMMENT_CREATED,
-            threadId: record.id,
-            commentId: record.comment.id,
-        });
-        return newThread;
     }
-    async threadWithNotification(req, roomId, threadId) {
-        const thread = await this.roomsService.getThread(roomId, threadId);
-        const inboxNotifications = await this.notificationsService.findNotifications({
-            userId: req['jwt'].uid,
-            roomId,
-            threadId,
+    getThreads(req, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const threads = yield this.roomsService.getThreads(roomId);
+            const inboxNotifications = yield this.notificationsService.findNotifications({
+                userId: req['jwt'].uid,
+                roomId,
+            });
+            return {
+                data: threads,
+                inboxNotifications: inboxNotifications.map((inboxNotification) => (0, lodash_1.omit)(inboxNotification, ['userId', '_id'])),
+                meta: {
+                    nextCursor: null,
+                    requestedAt: new Date().toISOString(),
+                    permissionHints: {
+                        [roomId]: ['room:write'],
+                    },
+                },
+                deletedThreads: [],
+                deletedInboxNotifications: [],
+            };
         });
-        return {
-            thread,
-            inboxNotification: inboxNotifications[0]
-                ? (0, lodash_1.omit)(inboxNotifications[0], ['userId', '_id'])
-                : undefined,
-        };
     }
-    async threadMarkasResolved(req, roomId, threadId) {
-        const newThread = await this.roomsService.updateThread(threadId, {
-            resolved: true,
-        });
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.THREAD_UPDATED,
-            threadId: threadId,
+    getThreadsDelta(req, roomId, since) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sinceDate = new Date(since);
+            const threads = yield this.roomsService.getThreads(roomId, sinceDate);
+            const inboxNotifications = yield this.notificationsService.findNotifications({
+                userId: req['jwt'].uid,
+                roomId,
+                sinceDate,
+            });
+            return {
+                data: threads,
+                inboxNotifications: inboxNotifications.map((inboxNotification) => (0, lodash_1.omit)(inboxNotification, ['userId', '_id'])),
+                meta: {
+                    nextCursor: null,
+                    requestedAt: new Date().toISOString(),
+                    permissionHints: {
+                        [roomId]: ['room:write'],
+                    },
+                },
+                deletedThreads: [],
+                deletedInboxNotifications: [],
+            };
         });
-        return newThread;
     }
-    async threadMarkasUnResolved(req, roomId, threadId) {
-        const newThread = await this.roomsService.updateThread(threadId, {
-            resolved: false,
+    createThread(req, roomId, record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const newThread = yield this.roomsService.createThread({
+                id: record.id,
+                comment: record.comment,
+                roomId,
+                userId,
+                metadata: {},
+                resolved: false,
+            });
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.THREAD_CREATED,
+                threadId: record.id,
+            });
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.COMMENT_CREATED,
+                threadId: record.id,
+                commentId: record.comment.id,
+            });
+            return newThread;
         });
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.THREAD_UPDATED,
-            threadId: threadId,
+    }
+    threadWithNotification(req, roomId, threadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const thread = yield this.roomsService.getThread({ roomId, threadId });
+            const inboxNotifications = yield this.notificationsService.findNotifications({
+                userId: req['jwt'].uid,
+                roomId,
+                threadId,
+            });
+            return {
+                thread,
+                inboxNotification: inboxNotifications[0]
+                    ? (0, lodash_1.omit)(inboxNotifications[0], ['userId', '_id'])
+                    : undefined,
+            };
         });
-        return newThread;
     }
-    async createComment(req, roomId, threadId, record) {
-        const userId = req['jwt'].uid;
-        const newComment = await this.roomsService.createComment({
-            id: record.id,
-            attachmentIds: record.attachmentIds,
-            body: record.body,
-            roomId,
-            threadId: threadId,
-            userId: userId,
+    threadMarkasResolved(req, roomId, threadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newThread = yield this.roomsService.updateThread(threadId, {
+                resolved: true,
+            });
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.THREAD_UPDATED,
+                threadId: threadId,
+            });
+            return newThread;
         });
-        await this.roomsService.updateThread(threadId);
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.COMMENT_CREATED,
-            threadId: threadId,
-            commentId: record.id,
+    }
+    threadMarkasUnResolved(req, roomId, threadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newThread = yield this.roomsService.updateThread(threadId, {
+                resolved: false,
+            });
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.THREAD_UPDATED,
+                threadId: threadId,
+            });
+            return newThread;
         });
-        return newComment;
     }
-    async updateComment(req, roomId, threadId, commentId, record) {
-        const userId = req['jwt'].uid;
-        const newComment = await this.roomsService.updateComment(commentId, {
-            attachmentIds: record.attachmentIds,
-            body: record.body,
-            userId,
+    createComment(req, roomId, threadId, record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const newComment = yield this.roomsService.createComment({
+                id: record.id,
+                attachmentIds: record.attachmentIds,
+                body: record.body,
+                roomId,
+                threadId: threadId,
+                userId: userId,
+            });
+            yield this.roomsService.updateThread(threadId);
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.COMMENT_CREATED,
+                threadId: threadId,
+                commentId: record.id,
+            });
+            return newComment;
         });
-        await this.roomsService.updateThread(threadId);
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.COMMENT_EDITED,
-            threadId: threadId,
-            commentId: commentId,
+    }
+    updateComment(req, roomId, threadId, commentId, record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const newComment = yield this.roomsService.updateComment(commentId, {
+                attachmentIds: record.attachmentIds,
+                body: record.body,
+                userId,
+            });
+            yield this.roomsService.updateThread(threadId);
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.COMMENT_EDITED,
+                threadId: threadId,
+                commentId: commentId,
+            });
+            return newComment;
         });
-        return newComment;
     }
-    async deleteComment(req, roomId, threadId, commentId) {
-        await this.roomsService.deleteComment(commentId);
-        await this.roomsService.updateThread(threadId);
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.COMMENT_DELETED,
-            threadId: threadId,
-            commentId: commentId,
+    deleteComment(req, roomId, threadId, commentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.roomsService.deleteComment(commentId);
+            yield this.roomsService.updateThread(threadId);
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.COMMENT_DELETED,
+                threadId: threadId,
+                commentId: commentId,
+            });
+            return {};
         });
-        return {};
     }
-    async getInboxNotificationsSince(req, since) {
-        const userId = req['jwt'].uid;
-        const sinceDate = new Date(since);
-        const requestedAt = new Date();
-        const notifications = await this.notificationsService.findNotifications({
-            userId,
-            sinceDate,
+    getInboxNotificationsSince(req, since) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const sinceDate = new Date(since);
+            const requestedAt = new Date();
+            const notifications = yield this.notificationsService.findNotifications({
+                userId,
+                sinceDate,
+            });
+            const threads = yield this.roomsService.getThreadsByIds((0, lodash_1.uniqBy)(notifications, (notification) => `${notification.roomId}-${notification.threadId}`));
+            return {
+                inboxNotifications: notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id'])),
+                threads,
+                meta: { requestedAt },
+                deletedThreads: [],
+                deletedInboxNotifications: [],
+            };
         });
-        const threads = await this.roomsService.getThreadsByIds((0, lodash_1.uniqBy)(notifications, (notification) => `${notification.roomId}-${notification.threadId}`));
-        return {
-            inboxNotifications: notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id'])),
-            threads,
-            meta: { requestedAt },
-            deletedThreads: [],
-            deletedInboxNotifications: [],
-        };
     }
-    async getInboxNotifications(req, unread, limit) {
-        const userId = req['jwt'].uid;
-        const requestedAt = new Date();
-        const notifications = await this.notificationsService.findNotifications({
-            userId,
-            unread: unread === 'true',
-            limit: Number(limit),
+    getInboxNotifications(req, unread, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const requestedAt = new Date();
+            const notifications = yield this.notificationsService.findNotifications({
+                userId,
+                unread: unread === 'true',
+                limit: Number(limit),
+            });
+            const threads = yield this.roomsService.getThreadsByIds((0, lodash_1.uniqBy)(notifications, (notification) => `${notification.roomId}-${notification.threadId}`));
+            return {
+                inboxNotifications: notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id'])),
+                threads,
+                meta: {
+                    nextCursor: null,
+                    requestedAt,
+                },
+                deletedThreads: [],
+                deletedInboxNotifications: [],
+            };
         });
-        const threads = await this.roomsService.getThreadsByIds((0, lodash_1.uniqBy)(notifications, (notification) => `${notification.roomId}-${notification.threadId}`));
-        return {
-            inboxNotifications: notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id'])),
-            threads,
-            meta: {
-                nextCursor: null,
-                requestedAt,
-            },
-            deletedThreads: [],
-            deletedInboxNotifications: [],
-        };
     }
-    async read(req, inboxNotificationIds) {
-        const userId = req['jwt'].uid;
-        const notifications = await this.notificationsService.markAsRead({
-            userId,
-            inboxNotificationIds,
+    read(req, inboxNotificationIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const notifications = yield this.notificationsService.markAsRead({
+                userId,
+                inboxNotificationIds,
+            });
+            return {
+                data: (notifications === null || notifications === void 0 ? void 0 : notifications.length) > 0
+                    ? notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id']))
+                    : undefined,
+            };
         });
-        return {
-            data: notifications?.length > 0
-                ? notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id']))
-                : undefined,
-        };
     }
-    async roomRead(req, roomId, inboxNotificationIds) {
-        const userId = req['jwt'].uid;
-        const notifications = await this.notificationsService.markAsRead({
-            roomId,
-            userId,
-            inboxNotificationIds,
+    roomRead(req, roomId, inboxNotificationIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const notifications = yield this.notificationsService.markAsRead({
+                roomId,
+                userId,
+                inboxNotificationIds,
+            });
+            return {
+                data: (notifications === null || notifications === void 0 ? void 0 : notifications.length) > 0
+                    ? notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id']))
+                    : undefined,
+            };
         });
-        return {
-            data: notifications?.length > 0
-                ? notifications.map((notification) => (0, lodash_1.omit)(notification, ['userId', '_id']))
-                : undefined,
-        };
     }
-    async presignedUrls(attachmentIds) {
-        const urls = await Promise.all(attachmentIds.map(async (attachmentId) => {
-            return this.filesService.getPreSignedUrl('cfs.files.filerecord', attachmentId);
-        }));
-        return { urls };
+    presignedUrls(attachmentIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urls = yield Promise.all(attachmentIds.map((attachmentId) => __awaiter(this, void 0, void 0, function* () {
+                return this.filesService.getPreSignedUrl('cfs.files.filerecord', attachmentId);
+            })));
+            return { urls };
+        });
     }
-    async uploadFile(roomId, attachmentId, fileName, fileSize, req) {
-        if (req.headers['content-type'] !== 'application/octet-stream') {
-            throw new common_1.HttpException('Invalid content type', common_1.HttpStatus.BAD_REQUEST);
-        }
-        const fileBuffer = await rawBody(req);
-        const file = {
-            buffer: fileBuffer,
-            originalname: fileName,
-            size: fileSize,
-        };
-        const metadata = {
-            _id: attachmentId,
-            objectName: 'b6_rooms',
-            recordId: roomId,
-        };
-        if (!file) {
-            throw new Error('未找到上传的文件');
-        }
-        const fileRecord = await this.filesService.uploadFile('cfs.files.filerecord', file, metadata);
-        return fileRecord;
+    uploadFile(roomId, attachmentId, fileName, fileSize, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (req.headers['content-type'] !== 'application/octet-stream') {
+                throw new common_1.HttpException('Invalid content type', common_1.HttpStatus.BAD_REQUEST);
+            }
+            const fileBuffer = yield rawBody(req);
+            const file = {
+                buffer: fileBuffer,
+                originalname: fileName,
+                size: fileSize,
+            };
+            const metadata = {
+                _id: attachmentId,
+                objectName: 'b6_rooms',
+                recordId: roomId,
+            };
+            if (!file) {
+                throw new Error('未找到上传的文件');
+            }
+            const fileRecord = yield this.filesService.uploadFile('cfs.files.filerecord', file, metadata);
+            return fileRecord;
+        });
     }
-    async createReaction(req, roomId, threadId, commentId, emoji) {
-        const userId = req['jwt'].uid;
-        const newComment = await this.roomsService.createReaction(commentId, {
-            userId: userId,
-            emoji: emoji,
+    createReaction(req, roomId, threadId, commentId, emoji) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            const newComment = yield this.roomsService.createReaction(commentId, {
+                userId: userId,
+                emoji: emoji,
+            });
+            yield this.roomsService.updateThread(threadId);
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.COMMENT_REACTION_ADDED,
+                threadId: threadId,
+                commentId: commentId,
+                emoji: emoji,
+            });
+            return newComment;
         });
-        await this.roomsService.updateThread(threadId);
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.COMMENT_REACTION_ADDED,
-            threadId: threadId,
-            commentId: commentId,
-            emoji: emoji,
+    }
+    deleteReaction(req, roomId, threadId, commentId, emoji) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = req['jwt'].uid;
+            yield this.roomsService.deleteReaction(commentId, { emoji, userId });
+            yield this.roomsService.updateThread(threadId);
+            this.roomsGateway.broadcastToRoom(roomId, {
+                type: ServerMsg_1.ServerMsgCode.COMMENT_REACTION_REMOVED,
+                threadId: threadId,
+                commentId: commentId,
+                emoji: emoji,
+            });
+            return {};
         });
-        return newComment;
     }
-    async deleteReaction(req, roomId, threadId, commentId, emoji) {
-        const userId = req['jwt'].uid;
-        await this.roomsService.deleteReaction(commentId, { emoji, userId });
-        await this.roomsService.updateThread(threadId);
-        this.roomsGateway.broadcastToRoom(roomId, {
-            type: ServerMsg_1.ServerMsgCode.COMMENT_REACTION_REMOVED,
-            threadId: threadId,
-            commentId: commentId,
-            emoji: emoji,
+    sendEmail(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emailNotificationService.sendThreadNotificationEmail(body);
         });
-        return {};
     }
 };
 __decorate([
@@ -522,13 +587,26 @@ __decorate([
     __metadata("design:paramtypes", [Object, String, String, String, String]),
     __metadata("design:returntype", Promise)
 ], RoomsController.prototype, "deleteReaction", null);
+__decorate([
+    (0, common_1.Post)('email'),
+    (0, swagger_1.ApiBody)({
+        schema: {
+            type: 'object',
+        },
+    }),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], RoomsController.prototype, "sendEmail", null);
 RoomsController = __decorate([
     (0, common_1.Controller)('v2/c/'),
     __metadata("design:paramtypes", [rooms_service_1.RoomsService,
         files_1.FilesService,
         jwt_1.JwtService,
         rooms_gateway_1.RoomsGateway,
-        notifications_service_1.NotificationsService])
+        notifications_service_1.NotificationsService,
+        emailNotification_service_1.EmailNotificationService])
 ], RoomsController);
 exports.RoomsController = RoomsController;
 //# sourceMappingURL=rooms.controller.js.map