@oneuptime/common 14.0.6 → 14.0.8

package/Server/Services/IncidentStateTimelineService.ts

@@ -34,6 +34,7 @@ import AIIncidentPostmortemRunner from "../Utils/AI/SRE/IncidentPostmortemRunner
 import InvestigationGrader from "../Utils/AI/SRE/InvestigationGrader";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import SubscriberNotificationResendAccess from "../Utils/StatusPage/SubscriberNotificationResendAccess";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
@@ -748,6 +749,18 @@ ${createdItem.rootCause}`,
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<IncidentStateTimeline>,
   ): Promise<OnUpdate<IncidentStateTimeline>> {
+    /*
+     * Retry - a user's Pending - over a state change notification that is
+     * being sent would let a second run send it alongside, or be overwritten
+     * when the send settles (SubscriberNotificationResendAccess).
+     */
+    await SubscriberNotificationResendAccess.assertNotQueuedWhileBeingSent({
+      modelType: IncidentStateTimeline,
+      service: this,
+      updateBy: updateBy,
+      statusColumns: ["subscriberNotificationStatus"],
+    });
+
     const incidentIds: Array<ObjectID> =
       await this.getIncidentIdsForTimelineQuery(updateBy);
 

package/Server/Services/IncidentTemplateService.ts

@@ -10,6 +10,7 @@ import LabelService from "./LabelService";
 import MonitorService from "./MonitorService";
 import MonitorStatusService from "./MonitorStatusService";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import StatusPageService from "./StatusPageService";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import Dictionary from "../../Types/Dictionary";
@@ -28,6 +29,8 @@ import Query from "../Types/Database/Query";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
 import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
+import StatusPageReadAccess from "../Utils/StatusPage/StatusPageReadAccess";
+import IncidentScopeAddedPagesNotification from "../../Types/StatusPage/IncidentScopeAddedPagesNotification";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -52,6 +55,12 @@ export class Service extends DatabaseService<Model> {
     const projectId: ObjectID | undefined =
       createBy.props.tenantId || createBy.data.projectId;
 
+    // Derived from the list, whatever the caller sent (see the column).
+    createBy.data.isScopedToStatusPages =
+      IncidentScopeAddedPagesNotification.normalizeStatusPageIds(
+        createBy.data.statusPages,
+      ).length > 0;
+
     await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
       projectId: projectId,
       subject: "incident template",
@@ -64,6 +73,19 @@ export class Service extends DatabaseService<Model> {
       ],
     });
 
+    /*
+     * A template's status pages are picked for everyone who declares from
+     * it, so picking them needs the same read access as picking an
+     * incident's (see StatusPageReadAccess).
+     */
+    await StatusPageReadAccess.assertCallerCanPickStatusPages({
+      statusPageIds: IncidentScopeAddedPagesNotification.normalizeStatusPageIds(
+        createBy.data.statusPages,
+      ),
+      props: createBy.props,
+      subject: "incident template",
+    });
+
     return { createBy, carryForward: null };
   }
 
@@ -71,6 +93,22 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
+    /*
+     * The scope flag follows a write to the list and nothing else: a client
+     * value is dropped, and deleting the template's pages (join rows
+     * cascading away) never clears it.
+     */
+    const data: Dictionary<unknown> = updateBy.data as Dictionary<unknown>;
+
+    delete data["isScopedToStatusPages"];
+
+    if (data["statusPages"] !== undefined) {
+      data["isScopedToStatusPages"] =
+        IncidentScopeAddedPagesNotification.normalizeStatusPageIds(
+          data["statusPages"],
+        ).length > 0;
+    }
+
     const references: Array<ProjectScopedReference> =
       this.getProjectScopedReferences(updateBy.data);
 
@@ -131,9 +169,75 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    // Once the pages are known to be the project's.
+    await this.assertCallerCanReadAddedStatusPages(updateBy);
+
     return { updateBy, carryForward: null };
   }
 
+  /*
+   * The status pages an update adds to a template must be pages the caller
+   * can read (see StatusPageReadAccess). Pages the template already holds are
+   * not checked, so saving a template limited to a page the editor cannot
+   * see does not fail. The templates are read as root, limited to the
+   * caller's project: the update's own tenant filter is only added after
+   * this hook.
+   */
+  private async assertCallerCanReadAddedStatusPages(
+    updateBy: UpdateBy<Model>,
+  ): Promise<void> {
+    const requested: unknown = (updateBy.data as Dictionary<unknown>)[
+      "statusPages"
+    ];
+
+    if (updateBy.props.isRoot || requested === undefined) {
+      return;
+    }
+
+    const requestedIds: Array<string> =
+      IncidentScopeAddedPagesNotification.normalizeStatusPageIds(requested);
+
+    if (requestedIds.length === 0) {
+      return;
+    }
+
+    const templates: Array<Model> = await this.findBy({
+      query: updateBy.props.tenantId
+        ? { ...updateBy.query, projectId: updateBy.props.tenantId }
+        : updateBy.query,
+      select: {
+        _id: true,
+        statusPages: {
+          _id: true,
+        },
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const addedIds: Array<string> = [];
+
+    for (const template of templates) {
+      for (const id of IncidentScopeAddedPagesNotification.getScopeChange({
+        before: template.statusPages,
+        after: requestedIds,
+      }).addedStatusPageIds) {
+        if (!addedIds.includes(id)) {
+          addedIds.push(id);
+        }
+      }
+    }
+
+    await StatusPageReadAccess.assertCallerCanPickStatusPages({
+      statusPageIds: addedIds,
+      props: updateBy.props,
+      subject: "incident template",
+    });
+  }
+
   /*
    * The many-to-many lists whose ids must belong to the template's project.
    * Built per call rather than at module load: these services sit in an
@@ -157,6 +261,11 @@ export class Service extends DatabaseService<Model> {
         modelName: "On-Call Policy",
         service: OnCallDutyPolicyService,
       },
+      {
+        column: "statusPages",
+        modelName: "Status Page",
+        service: StatusPageService,
+      },
       ...getAffectedResourceRelations(this.getModel()),
     ];
   }

package/Server/Services/InventoryItemService.ts

@@ -10,6 +10,8 @@ import ColumnLength from "../../Types/Database/ColumnLength";
 import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
 import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate } from "../Types/Database/Hooks";
+import { AggregateRow } from "../Types/Database/AggregateBy";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import BadDataException from "../../Types/Exception/BadDataException";
 import Dictionary from "../../Types/Dictionary";
 import { JSONObject } from "../../Types/JSON";
@@ -22,6 +24,12 @@ import {
   MANUAL_ENTITY_IDENTITY_ATTRIBUTE,
 } from "../../Utils/Telemetry/EntityKey";
 import logger from "../Utils/Logger";
+import {
+  INVENTORY_OVERVIEW_GROUP_BY,
+  INVENTORY_OVERVIEW_SELECT,
+  InventoryOverviewCounts,
+  readInventoryOverviewGroups,
+} from "../Utils/Inventory/InventoryOverviewAggregation";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { ExtractedEntity } from "../Utils/Telemetry/TelemetryEntity";
 import {
@@ -147,6 +155,36 @@ export class InventoryItemService extends DatabaseService<Model> {
     return { createBy, carryForward: null };
   }
 
+  /**
+   * The Inventory Overview's tiles and per-type breakdown, counted over the
+   * project's whole unarchived estate. See INVENTORY_OVERVIEW_SELECT.
+   *
+   * Archived rows are excluded because every tile drills into the live Items
+   * list, which excludes them too.
+   *
+   * The GROUP BY carries no limit: capping it would cap the totals summed
+   * from it. The number of groups is bounded by the entity-type vocabulary —
+   * ingest maps to a fixed set of types, manual creates are confined to
+   * MANUAL_ENTITY_TYPES, and the column is not updatable.
+   */
+  @CaptureSpan()
+  public async getOverviewCounts(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<InventoryOverviewCounts> {
+    const rows: Array<AggregateRow> = await this.aggregateBy({
+      query: {
+        projectId: data.projectId,
+        isArchived: false,
+      },
+      groupBy: INVENTORY_OVERVIEW_GROUP_BY,
+      select: INVENTORY_OVERVIEW_SELECT,
+      props: data.props,
+    });
+
+    return readInventoryOverviewGroups(rows);
+  }
+
   /**
    * Forward-only registry reconciliation: upsert a catalog row per
    * discovered entity, bump `lastSeenAt`, merge descriptive attributes

package/Server/Services/IoTDeviceCredentialService.ts

@@ -204,14 +204,23 @@ export class Service extends DatabaseService<Model> {
       return cached;
     }
 
-    let idObject: ObjectID;
-    try {
-      idObject = new ObjectID(credentialId);
-    } catch {
+    /*
+     * Validated rather than caught. ObjectID's constructor stores whatever
+     * string it is handed and never throws, so the try/catch this replaced
+     * caught nothing: a malformed id reached Postgres as an invalid uuid
+     * literal, which errors on every attempt AND skipped the negative cache
+     * below, because the row was never absent - the query failed. credentialId
+     * is an MQTT username, so it is attacker-controlled, and that made the
+     * negative cache bypassable with random garbage. Same guard, and the same
+     * reason for it, as ProjectAuthorization's API-key check.
+     */
+    if (!ObjectID.isValidUUID(credentialId)) {
       this.contextCache.set(credentialId, null, NEGATIVE_TTL_MS);
       return null;
     }
 
+    const idObject: ObjectID = new ObjectID(credentialId);
+
     const credential: Model | null = await this.findOneBy({
       query: { _id: idObject },
       select: {

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -19,6 +19,7 @@ import Query from "../Types/Database/Query";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
+import SubscriberNotificationResendAccess from "../Utils/StatusPage/SubscriberNotificationResendAccess";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -122,11 +123,24 @@ export class Service extends DatabaseService<Model> {
    * An edit tells subscribers nothing unless the editor asked for it on this
    * edit (see SubscriberUpdateNotification). When they did, queue the update
    * notification; the ScheduledMaintenancePublicNote worker job sends it.
+   *
+   * Sending the note's 'posted' notification again - its status written back
+   * to Pending, as the dashboard's Retry does - needs the permission to post
+   * a note that notifies subscribers, and a note whose notification can go
+   * out again (see SubscriberNotificationResendAccess). So does telling
+   * subscribers about an edit, which is also refused while that update
+   * notification is being sent.
    */
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
+    await SubscriberNotificationResendAccess.assertPublicNoteResendAllowed({
+      modelType: Model,
+      service: this,
+      updateBy: updateBy,
+    });
+
     if (SubscriberUpdateNotification.isRequested(updateBy.miscDataProps)) {
       updateBy.data.subscriberNotificationStatusOnNoteUpdated =
         StatusPageSubscriberNotificationStatus.Pending;
@@ -134,6 +148,20 @@ export class Service extends DatabaseService<Model> {
         SubscriberUpdateNotification.queuedMessage;
     }
 
+    /*
+     * Telling subscribers about the edit - asked for above, or written as
+     * Pending directly (the dashboard's Retry of a failed update) - needs
+     * the permission to post a note that notifies subscribers too, and is
+     * refused while the update notification is being sent.
+     */
+    await SubscriberNotificationResendAccess.assertPublicNoteUpdateNotificationAllowed(
+      {
+        modelType: Model,
+        service: this,
+        updateBy: updateBy,
+      },
+    );
+
     return {
       updateBy: updateBy,
       carryForward: null,
@@ -246,8 +274,9 @@ ${(createdItem.note || "") + attachmentsMarkdown}
           {
             scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
             projectId: updatedItem.projectId!,
+            // An edit to a public note is a public note event, not a private one.
             scheduledMaintenanceFeedEventType:
-              ScheduledMaintenanceFeedEventType.PrivateNote,
+              ScheduledMaintenanceFeedEventType.PublicNote,
             displayColor: Blue500,
             userId: userId || undefined,
 

package/Server/Services/ScheduledMaintenanceService.ts

@@ -9,6 +9,10 @@ import DatabaseService from "./DatabaseService";
 import ScheduledMaintenanceCustomField from "../../Models/DatabaseModels/ScheduledMaintenanceCustomField";
 import CustomFieldMappingService from "./CustomFieldMappingService";
 import MonitorService from "./MonitorService";
+import LinkedAffectedResources, {
+  LinkedAffectedResource,
+  LinkedAffectedResourceRelation,
+} from "../Utils/AffectedResources/LinkedAffectedResources";
 import ScheduledMaintenanceOwnerTeamService from "./ScheduledMaintenanceOwnerTeamService";
 import ScheduledMaintenanceOwnerUserService from "./ScheduledMaintenanceOwnerUserService";
 import ScheduledMaintenanceStateService from "./ScheduledMaintenanceStateService";
@@ -56,6 +60,7 @@ import SmsService from "../../Server/Services/SmsService";
 import StatusPageResourceService from "../../Server/Services/StatusPageResourceService";
 import StatusPageService from "../../Server/Services/StatusPageService";
 import StatusPageSubscriberService from "../../Server/Services/StatusPageSubscriberService";
+import StatusPageSubscriberUnsubscribe from "../../Types/StatusPage/StatusPageSubscriberUnsubscribe";
 import QueryHelper from "../../Server/Types/Database/QueryHelper";
 import Markdown, { MarkdownContentType } from "../../Server/Types/Markdown";
 import logger, { LogAttributes } from "../../Server/Utils/Logger";
@@ -86,6 +91,8 @@ import ProjectService from "./ProjectService";
 import StatusPageSubscriberNotificationTemplateService, {
   Service as StatusPageSubscriberNotificationTemplateServiceClass,
 } from "./StatusPageSubscriberNotificationTemplateService";
+import StatusPageResourceUtil from "../Utils/StatusPageResource";
+import SafeHtml from "../../Types/SafeHtml";
 import StatusPageSubscriberNotificationTemplate from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
 import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
 import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
@@ -204,12 +211,20 @@ export class Service extends DatabaseService<Model> {
 
         // Send email to Email subscribers.
 
+        /*
+         * The resources are read without their groups, so both forms are the
+         * names joined by commas. The HTML one, for email bodies, has every
+         * name escaped; SMS, Slack, subjects and webhooks get the names as
+         * written.
+         */
         const resourcesAffected: string =
-          statusPageToResources[statuspage._id!]
-            ?.map((r: StatusPageResource) => {
-              return r.displayName;
-            })
-            .join(", ") || "";
+          StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+            statusPageToResources[statuspage._id!] || [],
+          );
+        const resourcesAffectedHtml: string =
+          StatusPageResourceUtil.getResourcesGroupedByGroupName(
+            statusPageToResources[statuspage._id!] || [],
+          );
 
         // Fetch custom templates for each notification method
         const [
@@ -266,7 +281,7 @@ export class Service extends DatabaseService<Model> {
           const unsubscribeUrl: string =
             StatusPageSubscriberService.getUnsubscribeLink(
               URL.fromString(statusPageURL),
-              subscriber.id!,
+              subscriber,
             ).toString();
 
           // Template variables for custom templates, as Markdown (Slack)
@@ -294,6 +309,19 @@ export class Service extends DatabaseService<Model> {
           };
 
           if (subscriber.subscriberPhone) {
+            /*
+             * On a public status page the SMS keeps the shorter manage link,
+             * which works there without signing in: an SMS is billed by the
+             * segment (see StatusPageSubscriberUnsubscribe.buildSmsLink).
+             */
+            const smsUnsubscribeUrl: string =
+              StatusPageSubscriberUnsubscribe.buildSmsLink({
+                isPublicStatusPage: statuspage.isPublicStatusPage,
+                statusPageUrl: statusPageURL,
+                subscriberId: subscriber.id!,
+                unsubscribeUrl: unsubscribeUrl,
+              });
+
             let smsMessage: string;
 
             if (
@@ -305,11 +333,14 @@ export class Service extends DatabaseService<Model> {
               smsMessage =
                 StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
                   smsTemplate.templateBody,
-                  plainTextTemplateVariables,
+                  {
+                    ...plainTextTemplateVariables,
+                    unsubscribeUrl: smsUnsubscribeUrl,
+                  },
                 );
             } else {
               // Use default template
-              smsMessage = `Scheduled Maintenance: ${event.title || ""} on ${statusPageName}.${resourcesAffected ? ` Impact: ${resourcesAffected}.` : ""} Details: ${scheduledEventDetailsUrl}. Unsub: ${unsubscribeUrl}`;
+              smsMessage = `Scheduled Maintenance: ${event.title || ""} on ${statusPageName}.${resourcesAffected ? ` Impact: ${resourcesAffected}.` : ""} Details: ${scheduledEventDetailsUrl}. Unsub: ${smsUnsubscribeUrl}`;
             }
 
             const sms: SMS = {
@@ -404,7 +435,20 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
             const statusPageIdString: string | null =
               statuspage.id?.toString() || statuspage._id?.toString() || null;
 
-            // Prepare email variables
+            const scheduledAtHtml: string =
+              OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
+                date: event.startsAt!,
+                timezones: statuspage.subscriberTimezones || [],
+                use12HourFormat: true,
+              });
+
+            /*
+             * The default template's variables. resourcesAffected,
+             * scheduledAt and eventDescription are HTML (the template puts
+             * them in its raw-HTML slot); the footer is HTML the status
+             * page's admins wrote, as they write the template. Everything
+             * else is plain text, which the template escapes.
+             */
             const emailVars: Record<string, string> = {
               statusPageName: statusPageName,
               statusPageUrl: statusPageURL,
@@ -421,13 +465,8 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                 : "false",
               subscriberEmailNotificationFooterText:
                 statuspage.subscriberEmailNotificationFooterText || "",
-              resourcesAffected: resourcesAffected,
-              scheduledAt:
-                OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
-                  date: event.startsAt!,
-                  timezones: statuspage.subscriberTimezones || [],
-                  use12HourFormat: true,
-                }),
+              resourcesAffected: resourcesAffectedHtml,
+              scheduledAt: scheduledAtHtml,
               eventTitle: event.title || "",
               eventDescription: eventDescriptionHtml,
               unsubscribeUrl: unsubscribeUrl,
@@ -444,14 +483,29 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                * is configured. The body is HTML, so the description is too.
                * The subject is plain text, including the email-only
                * variables that are HTML in the body.
+               *
+               * In the body, the plain values are escaped
+               * (compileEmailBodyTemplate) and only the ones wrapped in
+               * SafeHtml below go in as HTML.
                */
               const customEmailBody: string =
-                StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
+                StatusPageSubscriberNotificationTemplateServiceClass.compileEmailBodyTemplate(
                   emailTemplate.templateBody,
                   {
                     ...templateVariables,
                     ...emailVars,
-                    scheduledMaintenanceDescription: eventDescriptionHtml,
+                    resourcesAffected: SafeHtml.fromTrustedHtml(
+                      resourcesAffectedHtml,
+                    ),
+                    scheduledAt: SafeHtml.fromTrustedHtml(scheduledAtHtml),
+                    eventDescription:
+                      SafeHtml.fromTrustedHtml(eventDescriptionHtml),
+                    scheduledMaintenanceDescription:
+                      SafeHtml.fromTrustedHtml(eventDescriptionHtml),
+                    subscriberEmailNotificationFooterText:
+                      SafeHtml.fromTrustedHtml(
+                        emailVars["subscriberEmailNotificationFooterText"],
+                      ),
                   },
                 );
               const customEmailSubject: string = emailTemplate.emailSubject
@@ -1180,10 +1234,6 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
         },
         startsAt: true,
         endsAt: true,
-        monitors: {
-          name: true,
-          _id: true,
-        },
         labels: {
           name: true,
         },
@@ -1448,14 +1498,23 @@ ${scheduledMaintenance.description || "No description provided."}
         feedInfoInMarkdown += `⏳ **Scheduled Maintenance State**: ${scheduledMaintenance.currentScheduledMaintenanceState.name} \n\n`;
       }
 
-      if (
-        scheduledMaintenance.monitors &&
-        scheduledMaintenance.monitors.length > 0
-      ) {
+      // Everything the event's Affected Resources card lists, monitors first.
+      const resources: Array<LinkedAffectedResource> =
+        await LinkedAffectedResources.readForScheduledMaintenance({
+          service: this,
+          projectId: scheduledMaintenance.projectId!,
+          scheduledMaintenanceId: scheduledMaintenance.id!,
+        });
+
+      if (resources.length > 0) {
         feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
 
-        for (const monitor of scheduledMaintenance.monitors) {
-          feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(scheduledMaintenance.projectId!, monitor.id!)).toString()})\n`;
+        for (const resourceLine of LinkedAffectedResources.getMarkdownLines({
+          dashboardUrl: await DatabaseConfig.getDashboardUrl(),
+          projectId: scheduledMaintenance.projectId!,
+          resources: resources,
+        })) {
+          feedInfoInMarkdown += `${resourceLine}\n`;
         }
 
         feedInfoInMarkdown += `\n\n`;
@@ -1820,47 +1879,42 @@ ${(
           shouldAddScheduledMaintenanceFeed = true;
         }
 
-        if (
-          onUpdate.updateBy.data.monitors &&
-          onUpdate.updateBy.data.monitors.length > 0 &&
-          Array.isArray(onUpdate.updateBy.data.monitors)
-        ) {
-          const monitorIds: Array<ObjectID> = (
-            onUpdate.updateBy.data.monitors as any
-          )
-            .map((monitor: Label) => {
-              if (monitor._id) {
-                return new ObjectID(monitor._id?.toString());
-              }
+        /*
+         * Any affected-resource list in the payload - not only monitors - is
+         * a change to what the event affects. The event is read back rather
+         * than the ids in the payload being looked up: the read is held to
+         * this project, and it names the whole list the card now shows.
+         */
+        const affectedResourcesChanged: boolean =
+          LinkedAffectedResources.getRelations(this.getModel()).some(
+            (relation: LinkedAffectedResourceRelation): boolean => {
+              const value: unknown = (
+                onUpdate.updateBy.data as Record<string, unknown>
+              )[relation.column];
+
+              return Array.isArray(value) && value.length > 0;
+            },
+          );
 
-              return null;
-            })
-            .filter((monitorId: ObjectID | null) => {
-              return monitorId !== null;
-            });
+        if (affectedResourcesChanged && onUpdate.updateBy.props.tenantId) {
+          const projectId: ObjectID = onUpdate.updateBy.props
+            .tenantId as ObjectID;
 
-          const monitors: Array<Label> = await MonitorService.findBy({
-            query: {
-              _id: QueryHelper.any(monitorIds),
-            },
-            select: {
-              name: true,
-            },
-            limit: LIMIT_PER_PROJECT,
-            skip: 0,
-            props: {
-              isRoot: true,
-            },
-          });
+          const resources: Array<LinkedAffectedResource> =
+            await LinkedAffectedResources.readForScheduledMaintenance({
+              service: this,
+              projectId: projectId,
+              scheduledMaintenanceId: scheduledMaintenanceId,
+            });
 
-          if (monitors.length > 0) {
+          if (resources.length > 0) {
             feedInfoInMarkdown += `\n\n**Resources Affected**:
 
-${monitors
-  .map((monitor: Monitor) => {
-    return `- ${monitor.name}`;
-  })
-  .join("\n")}
+${LinkedAffectedResources.getMarkdownLines({
+  dashboardUrl: await DatabaseConfig.getDashboardUrl(),
+  projectId: projectId,
+  resources: resources,
+}).join("\n")}
 `;
 
             shouldAddScheduledMaintenanceFeed = true;

package/Server/Services/SmsService.ts

@@ -41,6 +41,15 @@ export class SmsService extends BaseService {
       onCallDutyPolicyExecutionLogTimelineId?: ObjectID | undefined;
       onCallScheduleId?: ObjectID | undefined;
       teamId?: ObjectID | undefined;
+      /*
+       * Answer with an error, not success, when the Notification service
+       * deliberately does not send the SMS: the project has SMS notifications
+       * turned off, or too little SMS balance. The status page subscriber
+       * sends that count what they delivered pass it
+       * (SubscriberNotificationDeliveryRecord), so such an SMS counts as
+       * failed rather than sent.
+       */
+      failIfNotSent?: boolean | undefined;
     },
   ): Promise<HTTPResponse<EmptyResponseData>> {
     const body: JSONObject = {
@@ -74,6 +83,7 @@ export class SmsService extends BaseService {
         options.onCallDutyPolicyExecutionLogTimelineId?.toString(),
       onCallScheduleId: options.onCallScheduleId?.toString(),
       teamId: options.teamId?.toString(),
+      ...(options.failIfNotSent ? { failIfNotSent: true } : {}),
     };
 
     return await API.post<EmptyResponseData>({