@oneuptime/common 9.3.22 → 9.4.1

package/Server/Services/IncomingCallPolicyEscalationRuleService.ts

@@ -0,0 +1,267 @@
+import DatabaseService from "./DatabaseService";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import Query from "../Types/Database/Query";
+import QueryHelper from "../Types/Database/QueryHelper";
+import BadDataException from "../../Types/Exception/BadDataException";
+import PositiveNumber from "../../Types/PositiveNumber";
+import ObjectID from "../../Types/ObjectID";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import IncomingCallPolicyEscalationRule from "../../Models/DatabaseModels/IncomingCallPolicyEscalationRule";
+
+export class Service extends DatabaseService<IncomingCallPolicyEscalationRule> {
+  public constructor() {
+    super(IncomingCallPolicyEscalationRule);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<IncomingCallPolicyEscalationRule>,
+  ): Promise<OnCreate<IncomingCallPolicyEscalationRule>> {
+    // Validate mutual exclusivity: either userId OR onCallDutyPolicyScheduleId must be set
+    const hasUser: boolean = Boolean(createBy.data.userId);
+    const hasSchedule: boolean = Boolean(
+      createBy.data.onCallDutyPolicyScheduleId,
+    );
+
+    if (!hasUser && !hasSchedule) {
+      throw new BadDataException(
+        "Either a User or an On-Call Schedule must be specified for the escalation rule",
+      );
+    }
+
+    if (hasUser && hasSchedule) {
+      throw new BadDataException(
+        "Only one of User or On-Call Schedule can be specified, not both",
+      );
+    }
+
+    if (!createBy.data.incomingCallPolicyId) {
+      throw new BadDataException("incomingCallPolicyId is required");
+    }
+
+    // Auto-generate order if not provided
+    if (!createBy.data.order) {
+      const query: Query<IncomingCallPolicyEscalationRule> = {
+        incomingCallPolicyId: createBy.data.incomingCallPolicyId,
+      };
+
+      const count: PositiveNumber = await this.countBy({
+        query: query,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      createBy.data.order = count.toNumber() + 1;
+    }
+
+    await this.rearrangeOrder(
+      createBy.data.order,
+      createBy.data.incomingCallPolicyId,
+      true,
+    );
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<IncomingCallPolicyEscalationRule>,
+  ): Promise<OnDelete<IncomingCallPolicyEscalationRule>> {
+    if (!deleteBy.query._id && !deleteBy.props.isRoot) {
+      throw new BadDataException(
+        "_id should be present when deleting escalation rule. Please try the delete with objectId",
+      );
+    }
+
+    let resource: IncomingCallPolicyEscalationRule | null = null;
+
+    if (!deleteBy.props.isRoot) {
+      resource = await this.findOneBy({
+        query: deleteBy.query,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          order: true,
+          incomingCallPolicyId: true,
+          projectId: true,
+        },
+      });
+
+      if (!resource) {
+        throw new BadDataException(
+          "IncomingCallPolicyEscalationRule with this id not found",
+        );
+      }
+    }
+
+    return {
+      deleteBy,
+      carryForward: resource,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<IncomingCallPolicyEscalationRule>,
+    _itemIdsBeforeDelete: ObjectID[],
+  ): Promise<OnDelete<IncomingCallPolicyEscalationRule>> {
+    const deleteBy: DeleteBy<IncomingCallPolicyEscalationRule> =
+      onDelete.deleteBy;
+    const resource: IncomingCallPolicyEscalationRule | null =
+      onDelete.carryForward;
+
+    if (!deleteBy.props.isRoot && resource) {
+      if (resource && resource.order && resource.incomingCallPolicyId) {
+        await this.rearrangeOrder(
+          resource.order,
+          resource.incomingCallPolicyId,
+          false,
+        );
+      }
+    }
+
+    return {
+      deleteBy: deleteBy,
+      carryForward: null,
+    };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<IncomingCallPolicyEscalationRule>,
+  ): Promise<OnUpdate<IncomingCallPolicyEscalationRule>> {
+    if (updateBy.data.order && !updateBy.props.isRoot && updateBy.query._id) {
+      const resource: IncomingCallPolicyEscalationRule | null =
+        await this.findOneBy({
+          query: {
+            _id: updateBy.query._id!,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            order: true,
+            incomingCallPolicyId: true,
+            _id: true,
+          },
+        });
+
+      const currentOrder: number = resource?.order as number;
+      const newOrder: number = updateBy.data.order as number;
+
+      const resources: Array<IncomingCallPolicyEscalationRule> =
+        await this.findBy({
+          query: {
+            incomingCallPolicyId: resource?.incomingCallPolicyId as ObjectID,
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+          select: {
+            order: true,
+            incomingCallPolicyId: true,
+            _id: true,
+          },
+        });
+
+      if (currentOrder > newOrder) {
+        // moving up.
+        for (const resource of resources) {
+          if (resource.order! >= newOrder && resource.order! < currentOrder) {
+            // increment order.
+            await this.updateOneBy({
+              query: {
+                _id: resource._id!,
+              },
+              data: {
+                order: resource.order! + 1,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+          }
+        }
+      }
+
+      if (newOrder > currentOrder) {
+        // moving down.
+        for (const resource of resources) {
+          if (resource.order! <= newOrder) {
+            // increment order.
+            await this.updateOneBy({
+              query: {
+                _id: resource._id!,
+              },
+              data: {
+                order: resource.order! - 1,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  private async rearrangeOrder(
+    currentOrder: number,
+    incomingCallPolicyId: ObjectID,
+    increaseOrder: boolean = true,
+  ): Promise<void> {
+    const resources: Array<IncomingCallPolicyEscalationRule> =
+      await this.findBy({
+        query: {
+          order: QueryHelper.greaterThanEqualTo(currentOrder),
+          incomingCallPolicyId: incomingCallPolicyId,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          order: true,
+        },
+        sort: {
+          order: SortOrder.Ascending,
+        },
+      });
+
+    let newOrder: number = currentOrder;
+
+    for (const resource of resources) {
+      if (increaseOrder) {
+        newOrder = resource.order! + 1;
+      } else {
+        newOrder = resource.order! - 1;
+      }
+
+      await this.updateOneBy({
+        query: {
+          _id: resource._id!,
+        },
+        data: {
+          order: newOrder,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/IncomingCallPolicyService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import IncomingCallPolicy from "../../Models/DatabaseModels/IncomingCallPolicy";
+
+export class Service extends DatabaseService<IncomingCallPolicy> {
+  public constructor() {
+    super(IncomingCallPolicy);
+  }
+}
+
+export default new Service();

package/Server/Services/Index.ts

@@ -134,6 +134,7 @@ import UserSessionService from "./UserSessionService";
 import UserTotpAuthService from "./UserTotpAuthService";
 import UserWebAuthnService from "./UserWebAuthnService";
 import UserSmsService from "./UserSmsService";
+import UserIncomingCallNumberService from "./UserIncomingCallNumberService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import WorkflowLogService from "./WorkflowLogService";
 // Workflows.
@@ -173,6 +174,8 @@ import OnCallDutyPolicyUserOverrideService from "./OnCallDutyPolicyUserOverrideS
 import MonitorLogService from "./MonitorLogService";
 
 import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
+import ProjectSCIMLogService from "./ProjectSCIMLogService";
+import StatusPageSCIMLogService from "./StatusPageSCIMLogService";
 
 const services: Array<BaseService> = [
   OnCallDutyPolicyTimeLogService,
@@ -299,6 +302,7 @@ const services: Array<BaseService> = [
   UserOnCallLogService,
   UserOnCallLogTimelineService,
   UserSmsService,
+  UserIncomingCallNumberService,
   UserWhatsAppService,
   UserTotpAuthService,
   UserWebAuthnService,
@@ -355,6 +359,9 @@ const services: Array<BaseService> = [
   WorkspaceSettingService,
   WorkspaceNotificationRuleService,
   WorkspaceNotificationLogService,
+
+  ProjectSCIMLogService,
+  StatusPageSCIMLogService,
 ];
 
 export const AnalyticsServices: Array<

package/Server/Services/MonitorProbeService.ts

@@ -1,7 +1,7 @@
 import ObjectID from "../../Types/ObjectID";
 import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
-import DatabaseService from "./DatabaseService";
+import DatabaseService, { EntityManager } from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import MonitorProbe from "../../Models/DatabaseModels/MonitorProbe";
@@ -69,6 +69,101 @@ export class Service extends DatabaseService<MonitorProbe> {
     }
   }
 
+  /**
+   * Atomically claims monitor probes for a specific probe instance.
+   * Uses PostgreSQL's FOR UPDATE SKIP LOCKED to prevent multiple probe instances
+   * from picking up the same monitors simultaneously.
+   *
+   * @param data - Object containing probeId, limit, and nextPingAt
+   * @returns Array of claimed MonitorProbe IDs
+   */
+  public async claimMonitorProbesForProbing(data: {
+    probeId: ObjectID;
+    limit: number;
+  }): Promise<Array<ObjectID>> {
+    const currentDate: Date = OneUptimeDate.getCurrentDate();
+
+    /*
+     * Use a transaction with FOR UPDATE SKIP LOCKED to atomically claim monitors
+     * This prevents multiple probe instances from picking up the same monitors
+     */
+    const claimedIds: Array<ObjectID> = await this.executeTransaction(
+      async (transactionalEntityManager: EntityManager) => {
+        /*
+         * First, select and lock the monitor probes that need to be processed
+         * FOR UPDATE SKIP LOCKED ensures that:
+         * 1. Rows are locked for this transaction
+         * 2. Rows already locked by other transactions are skipped
+         */
+        const selectQuery: string = `
+        SELECT mp."_id"
+        FROM "MonitorProbe" mp
+        INNER JOIN "Monitor" m ON mp."monitorId" = m."_id"
+        INNER JOIN "Project" p ON mp."projectId" = p."_id"
+        WHERE mp."probeId" = $1
+          AND mp."isEnabled" = true
+          AND mp."deletedAt" IS NULL
+          AND (mp."nextPingAt" IS NULL OR mp."nextPingAt" <= $2)
+          AND m."disableActiveMonitoring" = false
+          AND m."disableActiveMonitoringBecauseOfManualIncident" = false
+          AND m."disableActiveMonitoringBecauseOfScheduledMaintenanceEvent" = false
+          AND m."deletedAt" IS NULL
+          AND p."deletedAt" IS NULL
+          AND (p."paymentProviderSubscriptionStatus" IS NULL
+               OR p."paymentProviderSubscriptionStatus" IN ('active', 'trialing'))
+          AND (p."paymentProviderMeteredSubscriptionStatus" IS NULL
+               OR p."paymentProviderMeteredSubscriptionStatus" IN ('active', 'trialing'))
+        ORDER BY mp."nextPingAt" ASC NULLS FIRST
+        LIMIT $3
+        FOR UPDATE OF mp SKIP LOCKED
+      `;
+
+        const selectedRows: Array<{ _id: string }> =
+          await transactionalEntityManager.query(selectQuery, [
+            data.probeId.toString(),
+            currentDate,
+            data.limit,
+          ]);
+
+        if (selectedRows.length === 0) {
+          return [];
+        }
+
+        const ids: Array<string> = selectedRows.map((row: { _id: string }) => {
+          return row._id;
+        });
+
+        /*
+         * Update the claimed monitors to set nextPingAt to 1 minute from now
+         * This is a temporary value; the actual nextPingAt will be calculated
+         * based on the monitor's interval after the probe fetches the full details
+         */
+        const tempNextPingAt: Date = OneUptimeDate.addRemoveMinutes(
+          currentDate,
+          1,
+        );
+
+        const updateQuery: string = `
+        UPDATE "MonitorProbe"
+        SET "lastPingAt" = $1, "nextPingAt" = $2
+        WHERE "_id" = ANY($3::uuid[])
+      `;
+
+        await transactionalEntityManager.query(updateQuery, [
+          currentDate,
+          tempNextPingAt,
+          ids,
+        ]);
+
+        return ids.map((id: string) => {
+          return new ObjectID(id);
+        });
+      },
+    );
+
+    return claimedIds;
+  }
+
   protected override async onBeforeCreate(
     createBy: CreateBy<MonitorProbe>,
   ): Promise<OnCreate<MonitorProbe>> {

package/Server/Services/ProjectSCIMLogService.ts

@@ -0,0 +1,11 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ProjectSCIMLog";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+  }
+}
+
+export default new Service();

package/Server/Services/StatusPageSCIMLogService.ts

@@ -0,0 +1,11 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/StatusPageSCIMLog";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+  }
+}
+
+export default new Service();

package/Server/Services/UserCallService.ts

@@ -137,6 +137,37 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("Phone Number already verified");
     }
 
+    // Check if Call notifications are enabled for this project
+    const project: Project | null = await ProjectService.findOneById({
+      id: item.projectId!,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        enableCallNotifications: true,
+        smsOrCallCurrentBalanceInUSDCents: true,
+      },
+    });
+
+    if (!project) {
+      throw new BadDataException("Project not found");
+    }
+
+    if (!project.enableCallNotifications) {
+      throw new BadDataException(
+        "Call notifications are disabled for this project. Please enable them in Project Settings > Notification Settings.",
+      );
+    }
+
+    if (
+      (project.smsOrCallCurrentBalanceInUSDCents as number) <= 100 &&
+      IsBillingEnabled
+    ) {
+      throw new BadDataException(
+        "Your SMS balance is low. Please recharge your SMS balance in Project Settings > Notification Settings.",
+      );
+    }
+
     // generate new verification code
     item.verificationCode = Text.generateRandomNumber(6);