@oneuptime/common 12.0.12 → 12.0.14

package/Server/Services/UserNotificationRuleService.ts

@@ -644,6 +644,14 @@ export class Service extends DatabaseService<Model> {
           deviceType: true,
           isVerified: true,
           userId: true,
+          /*
+           * Whether this handset asked to be rung through silent mode. Unselected
+           * it reads as undefined, which Boolean()s to false further down - the
+           * page still goes out, just quietly, which is the wrong outcome for the
+           * one channel a sleeping responder relies on. It is selected here so
+           * that cannot happen.
+           */
+          isCriticalAlertEnabled: true,
         },
       },
       props: {
@@ -2419,6 +2427,16 @@ export class Service extends DatabaseService<Model> {
       notificationRuleItem.userPush?.deviceToken &&
       notificationRuleItem.userPush?.isVerified
     ) {
+      /*
+       * This is the on-call paging path - the notification that exists to wake
+       * somebody at 3am - so it is the only push in the product allowed to
+       * override the ringer switch, and then only for a device whose owner
+       * turned the option on. Owner subscriptions and note-posted notifications
+       * go out through UserNotificationSettingService and never set this.
+       */
+      const isCriticalAlert: boolean = Boolean(
+        notificationRuleItem.userPush.isCriticalAlertEnabled,
+      );
       // send push notification for alert
       if (
         options.userNotificationEventType ===
@@ -2459,6 +2477,8 @@ export class Service extends DatabaseService<Model> {
             projectId: alert.projectId!.toString(),
           });
 
+        pushMessage.isCriticalAlert = isCriticalAlert;
+
         // send push notification.
         PushNotificationService.sendPushNotification(
           {
@@ -2540,6 +2560,8 @@ export class Service extends DatabaseService<Model> {
             projectId: incident.projectId!.toString(),
           });
 
+        pushMessage.isCriticalAlert = isCriticalAlert;
+
         // send push notification.
         PushNotificationService.sendPushNotification(
           {
@@ -2620,6 +2642,8 @@ export class Service extends DatabaseService<Model> {
             projectId: alertEpisode.projectId!.toString(),
           });
 
+        pushMessage.isCriticalAlert = isCriticalAlert;
+
         PushNotificationService.sendPushNotification(
           {
             devices: [
@@ -2699,6 +2723,8 @@ export class Service extends DatabaseService<Model> {
             projectId: incidentEpisode.projectId!.toString(),
           });
 
+        pushMessage.isCriticalAlert = isCriticalAlert;
+
         PushNotificationService.sendPushNotification(
           {
             devices: [

package/Server/Services/UserPushService.ts

@@ -12,6 +12,7 @@ import PositiveNumber from "../../Types/PositiveNumber";
 import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import UserPush from "../../Models/DatabaseModels/UserPush";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<UserPush> {
   public constructor() {
@@ -120,6 +121,94 @@ export class Service extends DatabaseService<UserPush> {
       },
     });
   }
+
+  /**
+   * Turn on-call critical alerts on or off for a handset.
+   *
+   * Keyed on the device TOKEN rather than a row id, because one phone owns one
+   * row per project it is registered against, and "ring me through silent
+   * mode" is a property of the phone. Toggling it per row would leave a
+   * responder loud for one project and silent for the next - a distinction
+   * nothing in the app offers to make and nobody would think to check.
+   * Deletion already works this way for the same reason (see the unregister
+   * route).
+   *
+   * Scoped to `userId` so a token cannot be used to reconfigure somebody
+   * else's device, and to the two mobile platforms because no browser can
+   * override a device's ringer: storing the preference on a web row would
+   * read back as though it did something.
+   *
+   * Returns how many rows were updated, so the caller can tell a real toggle
+   * apart from one that matched no device at all.
+   */
+  @CaptureSpan()
+  public async setCriticalAlertEnabledForDeviceToken(data: {
+    userId: ObjectID;
+    deviceToken: string;
+    isEnabled: boolean;
+  }): Promise<number> {
+    const devices: Array<UserPush> = await this.findBy({
+      query: {
+        userId: data.userId,
+        deviceToken: data.deviceToken,
+      },
+      select: {
+        _id: true,
+        deviceType: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (devices.length === 0) {
+      throw new BadDataException(
+        "No registered device was found for this device token.",
+      );
+    }
+
+    const mobileDeviceIds: Array<string> = devices
+      .filter((device: UserPush) => {
+        return (
+          device.deviceType === PushDeviceType.iOS ||
+          device.deviceType === PushDeviceType.Android
+        );
+      })
+      .map((device: UserPush) => {
+        return device._id!.toString();
+      });
+
+    if (mobileDeviceIds.length === 0) {
+      throw new BadDataException(
+        "Critical alerts are only available on iOS and Android devices.",
+      );
+    }
+
+    let updatedCount: number = 0;
+
+    /*
+     * One update per row rather than an `_id: In([...])` query: the query
+     * builder used here takes a single value per column, and the count of
+     * projects a responder belongs to is small.
+     */
+    for (const deviceId of mobileDeviceIds) {
+      updatedCount += await this.updateOneBy({
+        query: {
+          _id: deviceId,
+        },
+        data: {
+          isCriticalAlertEnabled: data.isEnabled,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    return updatedCount;
+  }
 }
 
 export default new Service();

package/Server/Services/UserSmsService.ts

@@ -15,7 +15,8 @@ import LIMIT_MAX from "../../Types/Database/LimitMax";
 import TwilioConfig from "../../Types/CallAndSMS/TwilioConfig";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
-import Text from "../../Types/Text";
+import TooManyRequestsException from "../../Types/Exception/TooManyRequestsException";
+import ChannelVerification from "../Utils/ChannelVerification";
 import Project from "../../Models/DatabaseModels/Project";
 import Model from "../../Models/DatabaseModels/UserSMS";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -143,7 +144,8 @@ export class Service extends DatabaseService<Model> {
     createdItem: Model,
   ): Promise<Model> {
     if (!createdItem.isVerified) {
-      this.sendVerificationCode(createdItem);
+      // issue and send the first verification code
+      await this.issueAndSendVerificationCode(createdItem);
     }
 
     return createdItem;
@@ -158,9 +160,10 @@ export class Service extends DatabaseService<Model> {
       },
       select: {
         phone: true,
-        verificationCode: true,
         isVerified: true,
         projectId: true,
+        userId: true,
+        verificationCodeSentAt: true,
       },
     });
 
@@ -215,23 +218,54 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
-    // generate new verification code
-    item.verificationCode = Text.generateRandomNumber(6);
+    /*
+     * Resend cooldown.
+     *
+     * Without it, spending the attempt budget on a code and asking for
+     * another one is free, which turns the attempt limit into a speed bump
+     * rather than a wall — and the resend control doubles as a way to send
+     * somebody unsolicited messages as fast as the network allows, at the
+     * project's expense.
+     */
+    const retryAfterSeconds: number =
+      ChannelVerification.getResendRetryAfterSeconds({
+        lastSentAt: item.verificationCodeSentAt,
+      });
 
-    await this.updateOneById({
-      id: item.id!,
-      props: {
-        isRoot: true,
-      },
-      data: {
-        verificationCode: item.verificationCode,
-      },
+    if (retryAfterSeconds > 0) {
+      throw new TooManyRequestsException(
+        `Please wait ${retryAfterSeconds} seconds before requesting another verification code.`,
+      );
+    }
+
+    await this.issueAndSendVerificationCode(item);
+  }
+
+  /*
+   * Mint a fresh code for this row, store only its digest, and send the
+   * plaintext to the channel.
+   *
+   * The plaintext exists in memory for exactly as long as it takes to hand it
+   * to the notification service and is never written anywhere. Everything
+   * about why — expiry, the attempt counter, rotation, the resend cooldown —
+   * is in Common/Server/Utils/ChannelVerification.ts.
+   *
+   * This does NOT check whether a send is allowed. Callers decide that:
+   * onCreateSuccess because a brand new row has never been sent to, and
+   * resendVerificationCode after the cooldown and the channel's own
+   * preconditions have passed.
+   */
+  @CaptureSpan()
+  public async issueAndSendVerificationCode(item: Model): Promise<void> {
+    const plainCode: string = await ChannelVerification.issueCodeOnItem({
+      service: this,
+      itemId: item.id!,
     });
 
-    this.sendVerificationCode(item);
+    this.sendVerificationCode(item, plainCode);
   }
 
-  public sendVerificationCode(item: Model): void {
+  public sendVerificationCode(item: Model, code: string): void {
     (async () => {
       const projectTwilioConfig: TwilioConfig | undefined =
         await ProjectCallSMSConfigService.getProjectDefaultTwilioConfig(
@@ -242,8 +276,7 @@ export class Service extends DatabaseService<Model> {
         {
           to: item.phone!,
           message:
-            "This message is from OneUptime. Your verification code is " +
-            item.verificationCode,
+            "This message is from OneUptime. Your verification code is " + code,
         },
         {
           projectId: item.projectId,

package/Server/Services/UserWhatsAppService.ts

@@ -13,7 +13,8 @@ import WhatsAppService from "./WhatsAppService";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
-import Text from "../../Types/Text";
+import TooManyRequestsException from "../../Types/Exception/TooManyRequestsException";
+import ChannelVerification from "../Utils/ChannelVerification";
 import Project from "../../Models/DatabaseModels/Project";
 import Model from "../../Models/DatabaseModels/UserWhatsApp";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -139,7 +140,7 @@ export class Service extends DatabaseService<Model> {
     createdItem: Model,
   ): Promise<Model> {
     if (!createdItem.isVerified) {
-      this.sendVerificationCode(createdItem).catch((error: Error) => {
+      this.issueAndSendVerificationCode(createdItem).catch((error: Error) => {
         logger.error(error, {
           projectId: createdItem.projectId?.toString(),
           userId: createdItem.userId?.toString(),
@@ -159,10 +160,10 @@ export class Service extends DatabaseService<Model> {
       },
       select: {
         phone: true,
-        verificationCode: true,
         isVerified: true,
         projectId: true,
         userId: true,
+        verificationCodeSentAt: true,
       },
     });
 
@@ -176,22 +177,54 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("WhatsApp number already verified");
     }
 
-    item.verificationCode = Text.generateRandomNumber(6);
+    /*
+     * Resend cooldown.
+     *
+     * Without it, spending the attempt budget on a code and asking for
+     * another one is free, which turns the attempt limit into a speed bump
+     * rather than a wall — and the resend control doubles as a way to send
+     * somebody unsolicited messages as fast as the network allows, at the
+     * project's expense.
+     */
+    const retryAfterSeconds: number =
+      ChannelVerification.getResendRetryAfterSeconds({
+        lastSentAt: item.verificationCodeSentAt,
+      });
 
-    await this.updateOneById({
-      id: item.id!,
-      props: {
-        isRoot: true,
-      },
-      data: {
-        verificationCode: item.verificationCode,
-      },
+    if (retryAfterSeconds > 0) {
+      throw new TooManyRequestsException(
+        `Please wait ${retryAfterSeconds} seconds before requesting another verification code.`,
+      );
+    }
+
+    await this.issueAndSendVerificationCode(item);
+  }
+
+  /*
+   * Mint a fresh code for this row, store only its digest, and send the
+   * plaintext to the channel.
+   *
+   * The plaintext exists in memory for exactly as long as it takes to hand it
+   * to the notification service and is never written anywhere. Everything
+   * about why — expiry, the attempt counter, rotation, the resend cooldown —
+   * is in Common/Server/Utils/ChannelVerification.ts.
+   *
+   * This does NOT check whether a send is allowed. Callers decide that:
+   * onCreateSuccess because a brand new row has never been sent to, and
+   * resendVerificationCode after the cooldown and the channel's own
+   * preconditions have passed.
+   */
+  @CaptureSpan()
+  public async issueAndSendVerificationCode(item: Model): Promise<void> {
+    const plainCode: string = await ChannelVerification.issueCodeOnItem({
+      service: this,
+      itemId: item.id!,
     });
 
-    await this.sendVerificationCode(item);
+    await this.sendVerificationCode(item, plainCode);
   }
 
-  public async sendVerificationCode(item: Model): Promise<void> {
+  public async sendVerificationCode(item: Model, code: string): Promise<void> {
     if (!item.projectId || !item.userId || !item.phone) {
       logger.warn("Cannot send WhatsApp verification code. Missing data.", {
         projectId: item.projectId?.toString(),
@@ -205,7 +238,7 @@ export class Service extends DatabaseService<Model> {
     const templateKey: WhatsAppTemplateId =
       WhatsAppTemplateIds.VerificationCode;
     const templateVariables: Record<string, string> = {
-      "1": item.verificationCode || "",
+      "1": code,
     };
 
     const whatsAppMessage: WhatsAppMessage = {