@oneuptime/common 12.0.12 → 12.0.14

package/build/dist/Server/Services/WorkspaceNotificationRuleService.js

@@ -170,170 +170,42 @@ export class Service extends DatabaseService {
                     throw new BadDataException(err === null || err === void 0 ? void 0 : err.message);
                 }
             }
-            // post message
-            for (const createdChannel of createdChannels) {
-                try {
-                    const responses = await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
-                        projectId: data.projectId,
-                        messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map((messageBlocksByWorkspaceType) => {
-                            const payload = {
-                                _type: "WorkspaceMessagePayload",
-                                workspaceType: messageBlocksByWorkspaceType.workspaceType,
-                                messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
-                                channelNames: [],
-                                channelIds: [createdChannel.id],
-                                teamId: notificationRule.existingTeam,
-                            };
-                            return payload;
-                        }),
-                    });
-                    // Log results for test sends (created channels)
-                    const getMessageSummary = (wt) => {
-                        var _a;
-                        const blocks = (_a = messageBlocksByWorkspaceTypes.find((b) => {
-                            return b.workspaceType === wt;
-                        })) === null || _a === void 0 ? void 0 : _a.messageBlocks;
-                        if (!blocks) {
-                            return "";
-                        }
-                        const texts = [];
-                        for (const block of blocks) {
-                            if (block._type ===
-                                "WorkspacePayloadMarkdown") {
-                                texts.push(block.text);
-                            }
-                        }
-                        const joined = texts.join(" \n").trim();
-                        return joined;
-                    };
-                    for (const res of responses) {
-                        const messageSummary = getMessageSummary(res.workspaceType);
-                        // Check for errors in the response
-                        if (res.errors && res.errors.length > 0) {
-                            /*
-                             * Record the failure before throwing. Test sends used to throw
-                             * straight out of here, so a failed test left no trace in
-                             * Notification Logs and support had no way to see what Microsoft
-                             * or Slack actually said.
-                             */
-                            await this.logTestSendFailures({
-                                projectId: data.projectId,
-                                workspaceType: res.workspaceType,
-                                errors: res.errors,
-                                message: messageSummary,
-                                userId: data.testByUserId,
-                            });
-                            const errorMessages = res.errors.map((error) => {
-                                return `Channel ${error.channel.name}: ${error.error}`;
-                            });
-                            throw new BadDataException(`Failed to send test message to some channels: ${errorMessages.join("; ")}`);
-                        }
-                        for (const thread of res.threads) {
-                            const log = new WorkspaceNotificationLog();
-                            log.projectId = data.projectId;
-                            log.workspaceType = res.workspaceType;
-                            log.channelId = thread.channel.id;
-                            log.channelName = thread.channel.name;
-                            log.threadId = thread.threadId;
-                            log.message = messageSummary;
-                            log.status = WorkspaceNotificationStatus.Success;
-                            log.statusMessage = "Test message posted to workspace channel";
-                            log.userId = data.testByUserId;
-                            log.actionType = WorkspaceNotificationActionType.SendMessage;
-                            await WorkspaceNotificationLogService.create({
-                                data: log,
-                                props: { isRoot: true },
-                            });
-                        }
-                    }
-                }
-                catch (err) {
-                    throw new BadDataException("Cannot post message to channel. " + (err === null || err === void 0 ? void 0 : err.message));
-                }
-            }
-            for (const channel of existingChannels) {
-                try {
-                    const responses = await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
-                        projectId: data.projectId,
-                        messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map((messageBlocksByWorkspaceType) => {
-                            const payload = {
-                                _type: "WorkspaceMessagePayload",
-                                workspaceType: messageBlocksByWorkspaceType.workspaceType,
-                                messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
-                                channelNames: [channel.name],
-                                channelIds: [],
-                            };
-                            if (messageBlocksByWorkspaceType.workspaceType ===
-                                WorkspaceType.MicrosoftTeams) {
-                                payload.teamId = channel.teamId;
-                            }
-                            return payload;
-                        }),
-                    });
-                    // Log results for test sends (existing channels)
-                    const getMessageSummary = (wt) => {
-                        var _a;
-                        const blocks = (_a = messageBlocksByWorkspaceTypes.find((b) => {
-                            return b.workspaceType === wt;
-                        })) === null || _a === void 0 ? void 0 : _a.messageBlocks;
-                        if (!blocks) {
-                            return "";
-                        }
-                        const texts = [];
-                        for (const block of blocks) {
-                            if (block._type ===
-                                "WorkspacePayloadMarkdown") {
-                                texts.push(block.text);
-                            }
-                        }
-                        const joined = texts.join(" \n").trim();
-                        return joined;
-                    };
-                    for (const res of responses) {
-                        const messageSummary = getMessageSummary(res.workspaceType);
-                        // Check for errors in the response
-                        if (res.errors && res.errors.length > 0) {
-                            /*
-                             * Record the failure before throwing. Test sends used to throw
-                             * straight out of here, so a failed test left no trace in
-                             * Notification Logs and support had no way to see what Microsoft
-                             * or Slack actually said.
-                             */
-                            await this.logTestSendFailures({
-                                projectId: data.projectId,
-                                workspaceType: res.workspaceType,
-                                errors: res.errors,
-                                message: messageSummary,
-                                userId: data.testByUserId,
-                            });
-                            const errorMessages = res.errors.map((error) => {
-                                return `Channel ${error.channel.name}: ${error.error}`;
-                            });
-                            throw new BadDataException(`Failed to send test message to some channels: ${errorMessages.join("; ")}`);
-                        }
-                        for (const thread of res.threads) {
-                            const log = new WorkspaceNotificationLog();
-                            log.projectId = data.projectId;
-                            log.workspaceType = res.workspaceType;
-                            log.channelId = thread.channel.id;
-                            log.channelName = thread.channel.name;
-                            log.threadId = thread.threadId;
-                            log.message = messageSummary;
-                            log.status = WorkspaceNotificationStatus.Success;
-                            log.statusMessage = "Test message posted to workspace channel";
-                            log.userId = data.testByUserId;
-                            log.actionType = WorkspaceNotificationActionType.SendMessage;
-                            await WorkspaceNotificationLogService.create({
-                                data: log,
-                                props: { isRoot: true },
-                            });
-                        }
-                    }
-                }
-                catch (err) {
-                    throw new BadDataException("Cannot post message to channel. " + (err === null || err === void 0 ? void 0 : err.message));
-                }
-            }
+        }
+        /*
+         * Post to the channels this test just created.
+         *
+         * This loop used to sit inside the shouldPostToExistingChannel block, so a
+         * rule that only creates a channel created it, invited nobody (a no-op on
+         * Teams) and reported success without ever attempting a send. The one
+         * action an admin runs to prove the bot can post proved nothing, and a
+         * passing test was read as evidence that the workspace app was wired up
+         * correctly when it had never been exercised.
+         */
+        for (const createdChannel of createdChannels) {
+            await this.postTestMessageToChannels({
+                projectId: data.projectId,
+                messageBlocksByWorkspaceTypes: messageBlocksByWorkspaceTypes,
+                testByUserId: data.testByUserId,
+                channelNames: [],
+                channelIds: [createdChannel.id],
+                /*
+                 * The team the channel was actually created in. This used to pass
+                 * existingTeam, which is a different field on a different rule — for a
+                 * create-only rule it is undefined, and when both are set they can name
+                 * two different teams.
+                 */
+                teamId: createdChannel.teamId,
+            });
+        }
+        for (const channel of existingChannels) {
+            await this.postTestMessageToChannels({
+                projectId: data.projectId,
+                messageBlocksByWorkspaceTypes: messageBlocksByWorkspaceTypes,
+                testByUserId: data.testByUserId,
+                channelNames: [channel.name],
+                channelIds: [],
+                teamId: channel.teamId,
+            });
         }
         // Post test message to Microsoft Teams chats.
         if (rule.workspaceType === WorkspaceType.MicrosoftTeams &&
@@ -399,6 +271,101 @@ export class Service extends DatabaseService {
             }
         }
     }
+    /*
+     * The markdown of a test message, for the Notification Log entry.
+     */
+    getTestMessageSummary(data) {
+        var _a;
+        const blocks = (_a = data.messageBlocksByWorkspaceTypes.find((b) => {
+            return b.workspaceType === data.workspaceType;
+        })) === null || _a === void 0 ? void 0 : _a.messageBlocks;
+        if (!blocks) {
+            return "";
+        }
+        const texts = [];
+        for (const block of blocks) {
+            if (block._type === "WorkspacePayloadMarkdown") {
+                texts.push(block.text);
+            }
+        }
+        return texts.join(" \n").trim();
+    }
+    /*
+     * Post one test message to one set of destinations, then record the outcome in
+     * Notification Logs.
+     *
+     * Created channels and existing channels ran two byte-identical copies of
+     * this, which is how the created-channel copy ended up nested in the wrong
+     * conditional without anyone noticing. One path now serves both.
+     */
+    async postTestMessageToChannels(data) {
+        try {
+            const responses = await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+                projectId: data.projectId,
+                messagePayloadsByWorkspace: data.messageBlocksByWorkspaceTypes.map((messageBlocksByWorkspaceType) => {
+                    const payload = {
+                        _type: "WorkspaceMessagePayload",
+                        workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                        messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+                        channelNames: data.channelNames,
+                        channelIds: data.channelIds,
+                    };
+                    // teamId is a Microsoft Teams concept; Slack has no equivalent.
+                    if (messageBlocksByWorkspaceType.workspaceType ===
+                        WorkspaceType.MicrosoftTeams) {
+                        payload.teamId = data.teamId;
+                    }
+                    return payload;
+                }),
+            });
+            for (const res of responses) {
+                const messageSummary = this.getTestMessageSummary({
+                    messageBlocksByWorkspaceTypes: data.messageBlocksByWorkspaceTypes,
+                    workspaceType: res.workspaceType,
+                });
+                // Check for errors in the response
+                if (res.errors && res.errors.length > 0) {
+                    /*
+                     * Record the failure before throwing. Test sends used to throw
+                     * straight out of here, so a failed test left no trace in
+                     * Notification Logs and support had no way to see what Microsoft
+                     * or Slack actually said.
+                     */
+                    await this.logTestSendFailures({
+                        projectId: data.projectId,
+                        workspaceType: res.workspaceType,
+                        errors: res.errors,
+                        message: messageSummary,
+                        userId: data.testByUserId,
+                    });
+                    const errorMessages = res.errors.map((error) => {
+                        return `Channel ${error.channel.name}: ${error.error}`;
+                    });
+                    throw new BadDataException(`Failed to send test message to some channels: ${errorMessages.join("; ")}`);
+                }
+                for (const thread of res.threads) {
+                    const log = new WorkspaceNotificationLog();
+                    log.projectId = data.projectId;
+                    log.workspaceType = res.workspaceType;
+                    log.channelId = thread.channel.id;
+                    log.channelName = thread.channel.name;
+                    log.threadId = thread.threadId;
+                    log.message = messageSummary;
+                    log.status = WorkspaceNotificationStatus.Success;
+                    log.statusMessage = "Test message posted to workspace channel";
+                    log.userId = data.testByUserId;
+                    log.actionType = WorkspaceNotificationActionType.SendMessage;
+                    await WorkspaceNotificationLogService.create({
+                        data: log,
+                        props: { isRoot: true },
+                    });
+                }
+            }
+        }
+        catch (err) {
+            throw new BadDataException("Cannot post message to channel. " + (err === null || err === void 0 ? void 0 : err.message));
+        }
+    }
     /*
      * Persist per-destination failures from a test send so they show up in
      * Settings > Notification Logs alongside real notification failures. Real
@@ -2106,6 +2073,12 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], Service.prototype, "testRule", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "postTestMessageToChannels", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),