@oneuptime/common 14.0.9 → 14.0.10

package/build/dist/Server/Utils/Workspace/MicrosoftTeams/Actions/Incident.js

@@ -21,14 +21,8 @@ import OnCallDutyPolicyService from "../../../../Services/OnCallDutyPolicyServic
 import IncidentStateService from "../../../../Services/IncidentStateService";
 import UserNotificationEventType from "../../../../../Types/UserNotification/UserNotificationEventType";
 import OnCallDutyPolicy from "../../../../../Models/DatabaseModels/OnCallDutyPolicy";
-import IncidentSeverityService from "../../../../Services/IncidentSeverityService";
-import MonitorService from "../../../../Services/MonitorService";
 import Monitor from "../../../../../Models/DatabaseModels/Monitor";
-import MonitorStatusService from "../../../../Services/MonitorStatusService";
-import LabelService from "../../../../Services/LabelService";
 import Label from "../../../../../Models/DatabaseModels/Label";
-import SortOrder from "../../../../../Types/BaseDatabase/SortOrder";
-import { LIMIT_PER_PROJECT } from "../../../../../Types/Database/LimitMax";
 import BadDataException from "../../../../../Types/Exception/BadDataException";
 import MicrosoftTeamsActionAuthorization from "./Authorization";
 import WorkspaceProjectReferenceValidator from "../../WorkspaceProjectReferenceValidator";
@@ -37,6 +31,13 @@ import IncidentStateTimeline from "../../../../../Models/DatabaseModels/Incident
 import IncidentPublicNote from "../../../../../Models/DatabaseModels/IncidentPublicNote";
 import IncidentInternalNote from "../../../../../Models/DatabaseModels/IncidentInternalNote";
 import OnCallDutyPolicyExecutionLog from "../../../../../Models/DatabaseModels/OnCallDutyPolicyExecutionLog";
+import ColumnLength from "../../../../../Types/Database/ColumnLength";
+import { truncateToLength } from "../../../Database/TruncateColumnValue";
+import MicrosoftTeamsCardChoices from "../MicrosoftTeamsCardChoices";
+import { MICROSOFT_TEAMS_CARD_SIZE_BUDGETS_IN_BYTES } from "../MicrosoftTeamsMessageSize";
+import MicrosoftTeamsReplies from "../MicrosoftTeamsReplies";
+// Incident.title is a LongText column.
+const MICROSOFT_TEAMS_INCIDENT_TITLE_MAX_LENGTH = ColumnLength.LongText;
 export default class MicrosoftTeamsIncidentActions {
     static isIncidentAction(data) {
         // Check if the action is related to incidents
@@ -383,11 +384,12 @@ export default class MicrosoftTeamsIncidentActions {
                         userId: oneUptimeUserId,
                     });
                 }
-                await turnContext.sendActivity("✅ Note added successfully.");
-                // Hide the form card by deleting it
-                if (turnContext.activity.replyToId) {
-                    await turnContext.deleteActivity(turnContext.activity.replyToId);
-                }
+                await MicrosoftTeamsReplies.sendBestEffort(turnContext, "✅ Note added successfully.");
+                /*
+                 * The action is done: a refused reply or a failed delete of the
+                 * form must not read as a failed action, which invites a repeat.
+                 */
+                await MicrosoftTeamsReplies.deleteBestEffort(turnContext, turnContext.activity.replyToId);
                 return;
             }
             await turnContext.sendActivity("Unable to add note: missing note data.");
@@ -440,11 +442,12 @@ export default class MicrosoftTeamsIncidentActions {
                     triggeredByIncidentId: incidentId,
                     userNotificationEventType: UserNotificationEventType.IncidentCreated,
                 });
-                await turnContext.sendActivity("✅ On-call policy executed successfully.");
-                // Hide the form card by deleting it
-                if (turnContext.activity.replyToId) {
-                    await turnContext.deleteActivity(turnContext.activity.replyToId);
-                }
+                await MicrosoftTeamsReplies.sendBestEffort(turnContext, "✅ On-call policy executed successfully.");
+                /*
+                 * The action is done: a refused reply or a failed delete of the
+                 * form must not read as a failed action, which invites a repeat.
+                 */
+                await MicrosoftTeamsReplies.deleteBestEffort(turnContext, turnContext.activity.replyToId);
                 return;
             }
             await turnContext.sendActivity("Unable to execute on-call policy: missing policy id.");
@@ -490,11 +493,12 @@ export default class MicrosoftTeamsIncidentActions {
                     },
                     props: databaseProps,
                 });
-                await turnContext.sendActivity("✅ Incident state changed successfully.");
-                // Hide the form card by deleting it
-                if (turnContext.activity.replyToId) {
-                    await turnContext.deleteActivity(turnContext.activity.replyToId);
-                }
+                await MicrosoftTeamsReplies.sendBestEffort(turnContext, "✅ Incident state changed successfully.");
+                /*
+                 * The action is done: a refused reply or a failed delete of the
+                 * form must not read as a failed action, which invites a repeat.
+                 */
+                await MicrosoftTeamsReplies.deleteBestEffort(turnContext, turnContext.activity.replyToId);
                 return;
             }
             await turnContext.sendActivity("Unable to change incident state: missing state id.");
@@ -502,8 +506,8 @@ export default class MicrosoftTeamsIncidentActions {
         }
         if (actionType === MicrosoftTeamsIncidentActionType.SubmitNewIncident) {
             // Handle new incident submission
-            const title = value["incidentTitle"] || "";
-            const description = value["incidentDescription"] || "";
+            const title = (value["incidentTitle"] || "").trim();
+            const description = (value["incidentDescription"] || "").trim();
             const severityId = value["incidentSeverity"] || "";
             const monitorIds = value["incidentMonitors"] || "";
             const monitorStatusId = value["monitorStatus"] || "";
@@ -513,8 +517,9 @@ export default class MicrosoftTeamsIncidentActions {
                 await turnContext.sendActivity("Unable to create incident: missing required fields (title, description, or severity).");
                 return;
             }
+            let createdIncident;
             try {
-                const createdIncident = await this.createIncidentInProject({
+                createdIncident = await this.createIncidentInProject({
                     projectId,
                     oneUptimeUserId,
                     title,
@@ -525,35 +530,69 @@ export default class MicrosoftTeamsIncidentActions {
                     labelIds,
                     onCallPolicyIds,
                 });
-                // Hide the form card by deleting it first
-                if (turnContext.activity.replyToId) {
-                    await turnContext.deleteActivity(turnContext.activity.replyToId);
-                }
-                // Get the incident link
-                const incidentLink = await IncidentService.getIncidentLinkInDashboard(projectId, createdIncident.id);
-                // Send confirmation message as a new message in the thread
-                await turnContext.sendActivity(`✅ Incident created successfully!\n\nView incident: ${incidentLink.toString()}`);
-                return;
             }
             catch (error) {
-                logger.error("Error creating incident from Microsoft Teams:", {
+                MicrosoftTeamsReplies.logFailure("Could not create an incident from Microsoft Teams", error, {
                     projectId: projectId.toString(),
                 });
-                logger.error(error);
-                await turnContext.sendActivity("❌ Failed to create incident. Please try again.");
+                await MicrosoftTeamsReplies.sendBestEffort(turnContext, await this.getIncidentCreateFailedMessage({
+                    error: error,
+                    projectId: projectId,
+                }));
                 return;
             }
+            /*
+             * The incident exists from here on, so nothing below may report the
+             * create as failed: a user told it failed submits again, which creates
+             * a second incident and pages its on-call policies a second time. The
+             * confirmation goes first; removing the submitted form is a courtesy.
+             */
+            await MicrosoftTeamsReplies.sendBestEffort(turnContext, await this.getIncidentCreatedMessage({
+                projectId: projectId,
+                incidentId: createdIncident.id || undefined,
+            }));
+            await MicrosoftTeamsReplies.deleteBestEffort(turnContext, turnContext.activity.replyToId);
+            return;
         }
         // Default fallback for unimplemented actions
         await turnContext.sendActivity("Sorry, but the action " +
             actionType +
             " you requested is not implemented yet.");
     }
+    /*
+     * Why a submitted incident was not created, for the user: the reason when
+     * OneUptime wrote one for them (a reference to another project's monitor,
+     * say), otherwise a generic line; the details go to the log.
+     */
+    static async getIncidentCreateFailedMessage(data) {
+        const reason = MicrosoftTeamsReplies.getUserFacingErrorMessage(data.error);
+        if (reason) {
+            return `❌ Could not create the incident: ${reason}`;
+        }
+        const createInOneUptimeUrl = await MicrosoftTeamsReplies.getDashboardLink({
+            projectId: data.projectId,
+            route: "/incidents/create",
+        });
+        return `❌ Could not create the incident because of an unexpected error. Please try again, or create it in OneUptime${createInOneUptimeUrl ? `: ${createInOneUptimeUrl}` : "."}`;
+    }
+    // The confirmation, with a link to the incident when one can be built.
+    static async getIncidentCreatedMessage(data) {
+        if (data.incidentId) {
+            try {
+                const incidentLink = await IncidentService.getIncidentLinkInDashboard(data.projectId, data.incidentId);
+                return `✅ Incident created successfully!\n\nView incident: ${incidentLink.toString()}`;
+            }
+            catch (error) {
+                logger.debug("Could not build the link to a new incident");
+                logger.debug(error);
+            }
+        }
+        return "✅ Incident created successfully!";
+    }
     /*
      * Every id below comes from the submitted card, not from the form we sent,
-     * and the writes run as root. So they are checked against the linked project
-     * before anything is created, and the monitor status write is scoped to that
-     * project as well.
+     * and the incident is created as root. So they are checked against the
+     * linked project before anything is created.
      */
     static async createIncidentInProject(data) {
         var _a, _b;
@@ -601,6 +640,16 @@ export default class MicrosoftTeamsIncidentActions {
                 return policy;
             });
         }
+        /*
+         * IncidentService moves the incident's monitors to this status, as it does
+         * for an incident declared in the dashboard or from Slack: with a status
+         * timeline entry and owner notifications, and back again once the
+         * incident is resolved. Teams used to write currentMonitorStatusId on the
+         * monitors directly, which did none of that.
+         */
+        if (monitorStatusId) {
+            incident.changeMonitorStatusToId = monitorStatusId;
+        }
         // Save the incident
         const createdIncident = await IncidentService.create({
             data: incident,
@@ -612,23 +661,6 @@ export default class MicrosoftTeamsIncidentActions {
             projectId: projectId.toString(),
             incidentId: (_b = createdIncident.id) === null || _b === void 0 ? void 0 : _b.toString(),
         });
-        // Update monitor status if specified
-        if (monitorStatusId) {
-            for (const monitorId of monitorIdArray) {
-                await MonitorService.updateOneBy({
-                    query: {
-                        _id: monitorId.toString(),
-                        projectId: projectId,
-                    },
-                    data: {
-                        currentMonitorStatusId: monitorStatusId,
-                    },
-                    props: {
-                        isRoot: true,
-                    },
-                });
-            }
-        }
         return createdIncident;
     }
     static buildAddIncidentNoteCard(incidentId) {
@@ -870,135 +902,60 @@ export default class MicrosoftTeamsIncidentActions {
             logger.error(error);
         }
     }
-    static async buildNewIncidentCard(projectId) {
-        // Fetch severities
-        const severities = await IncidentSeverityService.findBy({
-            query: {
-                projectId: projectId,
-            },
-            sort: {
-                order: SortOrder.Ascending,
-            },
-            skip: 0,
-            limit: LIMIT_PER_PROJECT,
-            select: {
-                name: true,
-            },
-            props: {
-                isRoot: true,
-            },
-        });
-        const severityChoices = severities.map((severity) => {
-            var _a;
-            return {
-                title: severity.name || "",
-                value: ((_a = severity._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
-            };
-        });
-        // Fetch monitors
-        const monitors = await MonitorService.findBy({
-            query: {
-                projectId: projectId,
-            },
-            select: {
-                name: true,
-            },
-            props: {
-                isRoot: true,
-            },
-            limit: LIMIT_PER_PROJECT,
-            skip: 0,
-        });
-        const monitorChoices = monitors
-            .map((monitor) => {
-            var _a;
-            return {
-                title: monitor.name || "",
-                value: ((_a = monitor._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
-            };
-        })
-            .filter((choice) => {
-            return choice.title && choice.value;
-        });
-        // Fetch monitor statuses
-        const monitorStatuses = await MonitorStatusService.findBy({
-            query: {
-                projectId: projectId,
-            },
-            select: {
-                name: true,
-            },
-            props: {
-                isRoot: true,
-            },
-            sort: {
-                priority: SortOrder.Ascending,
-            },
-            limit: LIMIT_PER_PROJECT,
-            skip: 0,
-        });
-        const monitorStatusChoices = monitorStatuses
-            .map((status) => {
-            var _a;
-            return {
-                title: status.name || "",
-                value: ((_a = status._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
-            };
-        })
-            .filter((choice) => {
-            return choice.title && choice.value;
-        });
-        // Fetch labels
-        const labels = await LabelService.findBy({
-            query: {
-                projectId: projectId,
-            },
-            select: {
-                name: true,
-            },
-            props: {
-                isRoot: true,
-            },
-            limit: LIMIT_PER_PROJECT,
-            skip: 0,
-        });
-        const labelChoices = labels
-            .map((label) => {
-            var _a;
-            return {
-                title: label.name || "",
-                value: ((_a = label._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
-            };
-        })
-            .filter((choice) => {
-            return choice.title && choice.value;
+    // Every list the "Create New Incident" card offers, read for one project.
+    static async getNewIncidentFormChoices(projectId) {
+        const [severities, monitors, monitorStatuses, labels, onCallDutyPolicies] = await Promise.all([
+            MicrosoftTeamsCardChoices.getIncidentSeverityChoices(projectId),
+            MicrosoftTeamsCardChoices.getMonitorChoices(projectId),
+            MicrosoftTeamsCardChoices.getMonitorStatusChoices(projectId),
+            MicrosoftTeamsCardChoices.getLabelChoices(projectId),
+            MicrosoftTeamsCardChoices.getOnCallDutyPolicyChoices(projectId),
+        ]);
+        return {
+            severities: severities,
+            monitors: monitors,
+            monitorStatuses: monitorStatuses,
+            labels: labels,
+            onCallDutyPolicies: onCallDutyPolicies,
+        };
+    }
+    /*
+     * The "Create New Incident" card for a project, fitted to the first size
+     * budget. The bot itself sends the card through
+     * MicrosoftTeamsCreateCommands, which also tries the smaller budgets.
+     */
+    static async buildNewIncidentCard(projectId, options) {
+        return this.buildNewIncidentCardForBudget({
+            choices: await this.getNewIncidentFormChoices(projectId),
+            budgetInBytes: MICROSOFT_TEAMS_CARD_SIZE_BUDGETS_IN_BYTES[0],
+            initialTitle: options === null || options === void 0 ? void 0 : options.initialTitle,
         });
-        // Fetch on-call policies
-        const onCallPolicies = await OnCallDutyPolicyService.findBy({
-            query: {
-                projectId: projectId,
-            },
-            select: {
-                name: true,
-            },
-            props: {
-                isRoot: true,
+    }
+    /*
+     * The "Create New Incident" card with its monitor, label and on-call policy
+     * lists shortened until it fits the budget (issue #4111: listing all of
+     * them made Teams refuse the card). Severities are required, so they are
+     * never shortened to fit (they are read up to 50).
+     */
+    static buildNewIncidentCardForBudget(data) {
+        return MicrosoftTeamsCardChoices.fitCardToBudget({
+            lists: data.choices,
+            trimmableKeys: ["monitors", "labels", "onCallDutyPolicies"],
+            budgetInBytes: data.budgetInBytes,
+            buildCard: (shown) => {
+                return this.buildNewIncidentCardBody({
+                    shown: shown,
+                    initialTitle: data.initialTitle,
+                    createInOneUptimeUrl: data.createInOneUptimeUrl,
+                });
             },
-            limit: LIMIT_PER_PROJECT,
-            skip: 0,
-        });
-        const onCallPolicyChoices = onCallPolicies
-            .map((policy) => {
-            var _a;
-            return {
-                title: policy.name || "",
-                value: ((_a = policy._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
-            };
-        })
-            .filter((choice) => {
-            return choice.title && choice.value;
-        });
-        // Build the card
+        }).card;
+    }
+    static buildNewIncidentCardBody(data) {
+        const { shown } = data;
+        const initialTitle = (data.initialTitle || "").trim();
+        let isAnythingLeftOff = false;
+        const addLaterHint = "You can add them to the incident in OneUptime after it is created.";
         const bodyElements = [
             {
                 type: "TextBlock",
@@ -1006,13 +963,11 @@ export default class MicrosoftTeamsIncidentActions {
                 size: "Large",
                 weight: "Bolder",
             },
-            {
-                type: "Input.Text",
-                id: "incidentTitle",
-                label: "Incident Title",
-                placeholder: "Enter incident title",
-                isRequired: true,
-            },
+            Object.assign({ type: "Input.Text", id: "incidentTitle", label: "Incident Title", placeholder: "Enter incident title", isRequired: true, maxLength: MICROSOFT_TEAMS_INCIDENT_TITLE_MAX_LENGTH }, (initialTitle
+                ? {
+                    value: truncateToLength(initialTitle, MICROSOFT_TEAMS_INCIDENT_TITLE_MAX_LENGTH),
+                }
+                : {})),
             {
                 type: "Input.Text",
                 id: "incidentDescription",
@@ -1022,74 +977,93 @@ export default class MicrosoftTeamsIncidentActions {
                 isRequired: true,
             },
         ];
+        const addNotShownNote = (list, pluralNoun) => {
+            const note = MicrosoftTeamsCardChoices.buildNotShownNoteElement({
+                list: list,
+                pluralNoun: pluralNoun,
+                addLaterHint: addLaterHint,
+            });
+            if (note) {
+                isAnythingLeftOff = true;
+                bodyElements.push(note);
+            }
+        };
         // Add severity dropdown if we have severities
-        if (severityChoices.length > 0) {
+        if (shown.severities.choices.length > 0) {
             bodyElements.push({
                 type: "Input.ChoiceSet",
                 id: "incidentSeverity",
                 label: "Incident Severity",
                 style: "compact",
                 isRequired: true,
-                choices: severityChoices,
+                choices: shown.severities.choices,
             });
         }
         // Add monitor multi-select if we have monitors
-        if (monitorChoices.length > 0) {
+        if (shown.monitors.choices.length > 0) {
             bodyElements.push({
                 type: "Input.ChoiceSet",
                 id: "incidentMonitors",
                 label: "Affected Monitors (Optional)",
                 style: "compact",
                 isMultiSelect: true,
-                choices: monitorChoices,
+                choices: shown.monitors.choices,
             });
         }
+        addNotShownNote(shown.monitors, "monitors");
         // Add monitor status dropdown if we have statuses and monitors
-        if (monitorStatusChoices.length > 0 && monitorChoices.length > 0) {
+        if (shown.monitorStatuses.choices.length > 0 &&
+            shown.monitors.choices.length > 0) {
             bodyElements.push({
                 type: "Input.ChoiceSet",
                 id: "monitorStatus",
                 label: "Change Monitor Status To (Optional)",
                 style: "compact",
-                choices: monitorStatusChoices,
+                choices: shown.monitorStatuses.choices,
             });
         }
         // Add on-call policy multi-select if we have policies
-        if (onCallPolicyChoices.length > 0) {
+        if (shown.onCallDutyPolicies.choices.length > 0) {
             bodyElements.push({
                 type: "Input.ChoiceSet",
                 id: "onCallDutyPolicies",
                 label: "Execute On-Call Policies (Optional)",
                 style: "compact",
                 isMultiSelect: true,
-                choices: onCallPolicyChoices,
+                choices: shown.onCallDutyPolicies.choices,
             });
         }
+        addNotShownNote(shown.onCallDutyPolicies, "on-call policies");
         // Add labels multi-select if we have labels
-        if (labelChoices.length > 0) {
+        if (shown.labels.choices.length > 0) {
             bodyElements.push({
                 type: "Input.ChoiceSet",
                 id: "labels",
                 label: "Labels (Optional)",
                 style: "compact",
                 isMultiSelect: true,
-                choices: labelChoices,
+                choices: shown.labels.choices,
             });
         }
+        addNotShownNote(shown.labels, "labels");
+        const actions = [
+            {
+                type: "Action.Submit",
+                title: "Create Incident",
+                data: {
+                    action: MicrosoftTeamsIncidentActionType.SubmitNewIncident,
+                },
+            },
+        ];
+        if (isAnythingLeftOff && data.createInOneUptimeUrl) {
+            actions.push(MicrosoftTeamsCardChoices.buildCreateInOneUptimeAction(data.createInOneUptimeUrl));
+        }
         return {
             type: "AdaptiveCard",
             $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
             version: "1.5",
             body: bodyElements,
-            actions: [
-                {
-                    type: "Action.Submit",
-                    title: "Create Incident",
-                    data: {
-                        action: MicrosoftTeamsIncidentActionType.SubmitNewIncident,
-                    },
-                },
-            ],
+            actions: actions,
         };
     }
 }