@oneuptime/common 9.3.22 → 9.4.0

package/Server/Infrastructure/Postgres/SchemaMigrations/1768682071562-MigrationName.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1768682071562 implements MigrationInterface {
+  public name = "MigrationName1768682071562";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyEscalationRule" ALTER COLUMN "order" DROP DEFAULT`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyEscalationRule" ALTER COLUMN "order" SET DEFAULT '1'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -221,6 +221,10 @@ import { IncreaseClientSecretLength1768216593272 } from "./1768216593272-Increas
 import { AddOAuthProviderType1768217403078 } from "./1768217403078-AddOAuthProviderType";
 import { AddIncomingEmailMonitor1768335589018 } from "./1768335589018-AddIncomingEmailMonitor";
 import { MigrationName1768422356713 } from "./1768422356713-MigrationName";
+import { MigrationName1768583966447 } from "./1768583966447-MigrationName";
+import { RemoveAlertPhoneNumberFromUser1768647802022 } from "./1768647802022-RemoveAlertPhoneNumberFromUser";
+import { MigrationName1768649699509 } from "./1768649699509-MigrationName";
+import { MigrationName1768682071562 } from "./1768682071562-MigrationName";
 
 export default [
   InitialMigration,
@@ -446,4 +450,8 @@ export default [
   AddOAuthProviderType1768217403078,
   AddIncomingEmailMonitor1768335589018,
   MigrationName1768422356713,
+  MigrationName1768583966447,
+  RemoveAlertPhoneNumberFromUser1768647802022,
+  MigrationName1768649699509,
+  MigrationName1768682071562,
 ];

package/Server/Services/IncomingCallLogItemService.ts

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

package/Server/Services/IncomingCallLogService.ts

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

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/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);