@oneuptime/common 7.0.3038 → 7.0.3050

package/Models/DatabaseModels/ScheduledMaintenance.ts

@@ -34,6 +34,7 @@ import {
   ManyToMany,
   ManyToOne,
 } from "typeorm";
+import Recurring from "../../Types/Events/Recurring";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -880,4 +881,73 @@ export default class ScheduledMaintenance extends BaseModel {
     default: false,
   })
   public isOwnerNotifiedOfResourceCreation?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectScheduledMaintenance,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectScheduledMaintenance,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectScheduledMaintenance,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    required: false,
+    isDefaultValueColumn: false,
+    title: "Subscriber notifications before the event",
+    description: "Should subscribers be notified before the event?",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+    transformer: Recurring.getDatabaseTransformer(),
+  })
+  public sendSubscriberNotificationsOnBeforeTheEvent?: Array<Recurring> =
+    undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectScheduledMaintenance,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectScheduledMaintenance,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectScheduledMaintenance,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    required: false,
+    isDefaultValueColumn: false,
+    title: "Next subscriber notification before the event at?",
+    description: "When will the next notification to subscribers be sent out?",
+  })
+  @Index()
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public nextSubscriberNotificationBeforeTheEventAt?: Date = undefined;
 }

package/Models/DatabaseModels/ScheduledMaintenanceTemplate.ts

@@ -950,4 +950,39 @@ export default class ScheduledMaintenanceTemplate extends BaseModel {
     nullable: true,
   })
   public customFields?: JSONObject = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateScheduledMaintenanceTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadScheduledMaintenanceTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditScheduledMaintenanceTemplate,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    required: false,
+    isDefaultValueColumn: false,
+    title: "Subscriber notifications before the event",
+    description: "Should subscribers be notified before the event?",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+    transformer: Recurring.getDatabaseTransformer(),
+  })
+  public sendSubscriberNotificationsOnBeforeTheEvent?: Array<Recurring> =
+    undefined;
 }

package/Server/EnvironmentConfig.ts

@@ -100,6 +100,18 @@ export const IsolatedVMHostname: Hostname = Hostname.fromString(
   }`,
 );
 
+export const WorkerHostname: Hostname = Hostname.fromString(
+  `${process.env["SERVER_WORKER_HOSTNAME"] || "localhost"}:${
+    process.env["WORKER_PORT"] || 80
+  }`,
+);
+
+export const HomeHostname: Hostname = Hostname.fromString(
+  `${process.env["SERVER_HOME_HOSTNAME"] || "localhost"}:${
+    process.env["HOME_PORT"] || 80
+  }`,
+);
+
 export const AccountsHostname: Hostname = Hostname.fromString(
   `${process.env["SERVER_ACCOUNTS_HOSTNAME"] || "localhost"}:${
     process.env["ACCOUNTS_PORT"] || 80

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

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725975175669 implements MigrationInterface {
+  public name = "MigrationName1725975175669";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" ADD "sendSubscriberNotificationsOnBeforeTheEvent" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" ADD "nextSubscriberNotificationBeforeTheEventAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_37b2094ce25cc62b4766a7d3b1" ON "ScheduledMaintenance" ("nextSubscriberNotificationBeforeTheEventAt") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_37b2094ce25cc62b4766a7d3b1"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" DROP COLUMN "nextSubscriberNotificationBeforeTheEventAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" DROP COLUMN "sendSubscriberNotificationsOnBeforeTheEvent"`,
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725976810107 implements MigrationInterface {
+  public name = "MigrationName1725976810107";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "sendSubscriberNotificationsOnBeforeTheEvent" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "sendSubscriberNotificationsOnBeforeTheEvent"`,
+    );
+  }
+}

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

@@ -58,6 +58,8 @@ import { MigrationName1725884177663 } from "./1725884177663-MigrationName";
 import { MigrationName1725898621366 } from "./1725898621366-MigrationName";
 import { MigrationName1725900315712 } from "./1725900315712-MigrationName";
 import { MigrationName1725901024444 } from "./1725901024444-MigrationName";
+import { MigrationName1725975175669 } from "./1725975175669-MigrationName";
+import { MigrationName1725976810107 } from "./1725976810107-MigrationName";
 
 export default [
   InitialMigration,
@@ -120,4 +122,6 @@ export default [
   MigrationName1725898621366,
   MigrationName1725900315712,
   MigrationName1725901024444,
+  MigrationName1725975175669,
+  MigrationName1725976810107,
 ];

package/Server/Services/IncidentService.ts

@@ -40,6 +40,51 @@ export class Service extends DatabaseService<Model> {
     this.hardDeleteItemsOlderThanInDays("createdAt", 120);
   }
 
+  public async isIncidentAcknowledged(data: {
+    incidentId: ObjectID;
+  }): Promise<boolean> {
+    const incident: Model | null = await this.findOneBy({
+      query: {
+        _id: data.incidentId,
+      },
+      select: {
+        projectId: true,
+        currentIncidentState: {
+          order: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      throw new BadDataException("Incident not found");
+    }
+
+    if (!incident.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    const ackIncidentState: IncidentState =
+      await IncidentStateService.getAcknowledgedIncidentState({
+        projectId: incident.projectId,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const currentIncidentStateOrder: number =
+      incident.currentIncidentState!.order!;
+    const ackIncidentStateOrder: number = ackIncidentState.order!;
+
+    if (currentIncidentStateOrder >= ackIncidentStateOrder) {
+      return true;
+    }
+
+    return false;
+  }
+
   public async acknowledgeIncident(
     incidentId: ObjectID,
     acknowledgedByUserId: ObjectID,

package/Server/Services/IncidentStateService.ts

@@ -152,13 +152,13 @@ export class Service extends DatabaseService<IncidentState> {
     }
   }
 
-  public async getUnresolvedIncidentStates(
-    projectId: ObjectID,
-    props: DatabaseCommonInteractionProps,
-  ): Promise<IncidentState[]> {
+  public async getAllIncidentStates(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<Array<IncidentState>> {
     const incidentStates: Array<IncidentState> = await this.findBy({
       query: {
-        projectId: projectId,
+        projectId: data.projectId,
       },
       skip: 0,
       limit: LIMIT_MAX,
@@ -168,10 +168,26 @@ export class Service extends DatabaseService<IncidentState> {
       select: {
         _id: true,
         isResolvedState: true,
+        isAcknowledgedState: true,
+        isCreatedState: true,
+        order: true,
       },
-      props: props,
+      props: data.props,
     });
 
+    return incidentStates;
+  }
+
+  public async getUnresolvedIncidentStates(
+    projectId: ObjectID,
+    props: DatabaseCommonInteractionProps,
+  ): Promise<IncidentState[]> {
+    const incidentStates: Array<IncidentState> =
+      await this.getAllIncidentStates({
+        projectId: projectId,
+        props: props,
+      });
+
     const unresolvedIncidentStates: Array<IncidentState> = [];
 
     for (const state of incidentStates) {
@@ -184,5 +200,30 @@ export class Service extends DatabaseService<IncidentState> {
 
     return unresolvedIncidentStates;
   }
+
+  public async getAcknowledgedIncidentState(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<IncidentState> {
+    const incidentStates: Array<IncidentState> =
+      await this.getAllIncidentStates({
+        projectId: data.projectId,
+        props: data.props,
+      });
+
+    const ackIncidentState: IncidentState | undefined = incidentStates.find(
+      (incidentState: IncidentState) => {
+        return incidentState?.isAcknowledgedState;
+      },
+    );
+
+    if (!ackIncidentState) {
+      throw new BadDataException(
+        "Acknowledged Incident State not found for this project",
+      );
+    }
+
+    return ackIncidentState;
+  }
 }
 export default new Service();

package/Server/Services/ProjectService.ts

@@ -347,6 +347,17 @@ export class ProjectService extends DatabaseService<Model> {
               " completed.",
           );
 
+          // refresh subscription status.
+          const subscriptionState: SubscriptionStatus =
+            await BillingService.getSubscriptionStatus(
+              subscription.subscriptionId as string,
+            );
+
+          const meteredSubscriptionState: SubscriptionStatus =
+            await BillingService.getSubscriptionStatus(
+              subscription.meteredSubscriptionId as string,
+            );
+
           await this.updateOneById({
             id: new ObjectID(updateBy.query._id! as string),
             data: {
@@ -357,6 +368,9 @@ export class ProjectService extends DatabaseService<Model> {
               planName: SubscriptionPlan.getPlanType(
                 updateBy.data.paymentProviderPlanId! as string,
               ),
+              paymentProviderMeteredSubscriptionStatus:
+                meteredSubscriptionState,
+              paymentProviderSubscriptionStatus: subscriptionState,
             },
             props: {
               isRoot: true,

package/Server/Services/ScheduledMaintenanceService.ts

@@ -23,6 +23,28 @@ import ScheduledMaintenanceOwnerUser from "Common/Models/DatabaseModels/Schedule
 import ScheduledMaintenanceState from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
 import ScheduledMaintenanceStateTimeline from "Common/Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
 import User from "Common/Models/DatabaseModels/User";
+import Recurring from "../../Types/Events/Recurring";
+import OneUptimeDate from "../../Types/Date";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { FileRoute } from "Common/ServiceRoute";
+import Dictionary from "Common/Types/Dictionary";
+import EmailTemplateType from "Common/Types/Email/EmailTemplateType";
+import SMS from "Common/Types/SMS/SMS";
+import MailService from "Common/Server/Services/MailService";
+import ProjectCallSMSConfigService from "Common/Server/Services/ProjectCallSMSConfigService";
+import ProjectSmtpConfigService from "Common/Server/Services/ProjectSmtpConfigService";
+import SmsService from "Common/Server/Services/SmsService";
+import StatusPageResourceService from "Common/Server/Services/StatusPageResourceService";
+import StatusPageService from "Common/Server/Services/StatusPageService";
+import StatusPageSubscriberService from "Common/Server/Services/StatusPageSubscriberService";
+import QueryHelper from "Common/Server/Types/Database/QueryHelper";
+import Markdown, { MarkdownContentType } from "Common/Server/Types/Markdown";
+import logger from "Common/Server/Utils/Logger";
+import StatusPage from "Common/Models/DatabaseModels/StatusPage";
+import StatusPageResource from "Common/Models/DatabaseModels/StatusPageResource";
+import StatusPageSubscriber from "Common/Models/DatabaseModels/StatusPageSubscriber";
+import Hostname from "../../Types/API/Hostname";
+import Protocol from "../../Types/API/Protocol";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -30,6 +52,242 @@ export class Service extends DatabaseService<Model> {
     this.hardDeleteItemsOlderThanInDays("createdAt", 120);
   }
 
+  public async notififySubscribersOnEventScheduled(
+    scheduledEvents: Array<Model>,
+  ): Promise<void> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    for (const event of scheduledEvents) {
+      // get status page resources from monitors.
+
+      let statusPageResources: Array<StatusPageResource> = [];
+
+      if (event.monitors && event.monitors.length > 0) {
+        statusPageResources = await StatusPageResourceService.findBy({
+          query: {
+            monitorId: QueryHelper.any(
+              event.monitors
+                .filter((m: Monitor) => {
+                  return m._id;
+                })
+                .map((m: Monitor) => {
+                  return new ObjectID(m._id!);
+                }),
+            ),
+          },
+          props: {
+            isRoot: true,
+            ignoreHooks: true,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          select: {
+            _id: true,
+            displayName: true,
+            statusPageId: true,
+          },
+        });
+      }
+
+      const statusPageToResources: Dictionary<Array<StatusPageResource>> = {};
+
+      for (const resource of statusPageResources) {
+        if (!resource.statusPageId) {
+          continue;
+        }
+
+        if (!statusPageToResources[resource.statusPageId?.toString()]) {
+          statusPageToResources[resource.statusPageId?.toString()] = [];
+        }
+
+        statusPageToResources[resource.statusPageId?.toString()]?.push(
+          resource,
+        );
+      }
+
+      const statusPages: Array<StatusPage> =
+        await StatusPageSubscriberService.getStatusPagesToSendNotification(
+          event.statusPages?.map((i: StatusPage) => {
+            return i.id!;
+          }) || [],
+        );
+
+      for (const statuspage of statusPages) {
+        if (!statuspage.id) {
+          continue;
+        }
+
+        const subscribers: Array<StatusPageSubscriber> =
+          await StatusPageSubscriberService.getSubscribersByStatusPage(
+            statuspage.id!,
+            {
+              isRoot: true,
+              ignoreHooks: true,
+            },
+          );
+
+        const statusPageURL: string = await StatusPageService.getStatusPageURL(
+          statuspage.id,
+        );
+
+        const statusPageName: string =
+          statuspage.pageTitle || statuspage.name || "Status Page";
+
+        // Send email to Email subscribers.
+
+        const resourcesAffected: string =
+          statusPageToResources[statuspage._id!]
+            ?.map((r: StatusPageResource) => {
+              return r.displayName;
+            })
+            .join(", ") || "";
+
+        for (const subscriber of subscribers) {
+          if (!subscriber._id) {
+            continue;
+          }
+
+          const shouldNotifySubscriber: boolean =
+            StatusPageSubscriberService.shouldSendNotification({
+              subscriber: subscriber,
+              statusPageResources: statusPageToResources[statuspage._id!] || [],
+              statusPage: statuspage,
+            });
+
+          if (!shouldNotifySubscriber) {
+            continue;
+          }
+
+          const unsubscribeUrl: string =
+            StatusPageSubscriberService.getUnsubscribeLink(
+              URL.fromString(statusPageURL),
+              subscriber.id!,
+            ).toString();
+
+          if (subscriber.subscriberPhone) {
+            const sms: SMS = {
+              message: `
+                            Scheduled Maintenance - ${statusPageName}
+
+                            ${event.title || ""}
+
+                            ${
+                              resourcesAffected
+                                ? "Resources Affected: " + resourcesAffected
+                                : ""
+                            }
+
+                            To view this event, visit ${statusPageURL}
+
+                            To update notification preferences or unsubscribe, visit ${unsubscribeUrl}
+                            `,
+              to: subscriber.subscriberPhone,
+            };
+
+            // send sms here.
+            SmsService.sendSms(sms, {
+              projectId: statuspage.projectId,
+              customTwilioConfig: ProjectCallSMSConfigService.toTwilioConfig(
+                statuspage.callSmsConfig,
+              ),
+            }).catch((err: Error) => {
+              logger.error(err);
+            });
+          }
+
+          if (subscriber.subscriberEmail) {
+            // send email here.
+
+            MailService.sendMail(
+              {
+                toEmail: subscriber.subscriberEmail,
+                templateType:
+                  EmailTemplateType.SubscriberScheduledMaintenanceEventCreated,
+                vars: {
+                  statusPageName: statusPageName,
+                  statusPageUrl: statusPageURL,
+                  logoUrl: statuspage.logoFileId
+                    ? new URL(httpProtocol, host)
+                        .addRoute(FileRoute)
+                        .addRoute("/image/" + statuspage.logoFileId)
+                        .toString()
+                    : "",
+                  isPublicStatusPage: statuspage.isPublicStatusPage
+                    ? "true"
+                    : "false",
+                  resourcesAffected: resourcesAffected,
+                  scheduledAt:
+                    OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
+                      date: event.startsAt!,
+                      timezones: statuspage.subscriberTimezones || [],
+                    }),
+                  eventTitle: event.title || "",
+                  eventDescription: await Markdown.convertToHTML(
+                    event.description || "",
+                    MarkdownContentType.Email,
+                  ),
+                  unsubscribeUrl: unsubscribeUrl,
+                },
+                subject: "[Scheduled Maintenance] " + statusPageName,
+              },
+              {
+                mailServer: ProjectSmtpConfigService.toEmailServer(
+                  statuspage.smtpConfig,
+                ),
+                projectId: statuspage.projectId!,
+              },
+            ).catch((err: Error) => {
+              logger.error(err);
+            });
+          }
+        }
+      }
+    }
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    if (
+      updateBy.query.id &&
+      updateBy.data.sendSubscriberNotificationsOnBeforeTheEvent
+    ) {
+      const scheduledMaintenance: Model | null = await this.findOneById({
+        id: updateBy.query.id! as ObjectID,
+        select: {
+          startsAt: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!scheduledMaintenance) {
+        throw new BadDataException("Scheduled Maintennace Event not found");
+      }
+
+      const startsAt: Date =
+        (updateBy.data.startsAt as Date) ||
+        (scheduledMaintenance.startsAt! as Date);
+
+      const nextTimeToNotifyBeforeTheEvent: Date | null =
+        this.getNextTimeToNotify({
+          eventScheduledDate: startsAt,
+          sendSubscriberNotifiationsOn: updateBy.data
+            .sendSubscriberNotificationsOnBeforeTheEvent as Array<Recurring>,
+        });
+
+      updateBy.data.nextSubscriberNotificationBeforeTheEventAt =
+        nextTimeToNotifyBeforeTheEvent;
+    }
+
+    return {
+      updateBy,
+      carryForward: null,
+    };
+  }
+
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<Model>,
   ): Promise<OnDelete<Model>> {
@@ -73,6 +331,36 @@ export class Service extends DatabaseService<Model> {
     return onDelete;
   }
 
+  public getNextTimeToNotify(data: {
+    eventScheduledDate: Date;
+    sendSubscriberNotifiationsOn: Array<Recurring>;
+  }): Date | null {
+    let recurringDate: Date | null = null;
+
+    for (const recurringItem of data.sendSubscriberNotifiationsOn) {
+      const notificationDate: Date = Recurring.getNextDateInterval(
+        data.eventScheduledDate,
+        recurringItem,
+        true,
+      );
+
+      // if this date is in the future. set it to recurring date.
+      if (OneUptimeDate.isInTheFuture(notificationDate)) {
+        recurringDate = notificationDate;
+      }
+
+      // if this new date is less than the recurring date then set it to recuring date. We need to get the least date.
+
+      if (recurringDate) {
+        if (OneUptimeDate.isBefore(notificationDate, recurringDate)) {
+          recurringDate = notificationDate;
+        }
+      }
+    }
+
+    return recurringDate;
+  }
+
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
@@ -105,6 +393,25 @@ export class Service extends DatabaseService<Model> {
     createBy.data.currentScheduledMaintenanceStateId =
       scheduledMaintenanceState.id;
 
+    // get next notification date.
+
+    if (
+      createBy.data.sendSubscriberNotificationsOnBeforeTheEvent &&
+      createBy.data.startsAt
+    ) {
+      const nextNotificationDate: Date | null = this.getNextTimeToNotify({
+        eventScheduledDate: createBy.data.startsAt,
+        sendSubscriberNotifiationsOn:
+          createBy.data.sendSubscriberNotificationsOnBeforeTheEvent,
+      });
+
+      if (nextNotificationDate) {
+        // set this.
+        createBy.data.nextSubscriberNotificationBeforeTheEventAt =
+          nextNotificationDate;
+      }
+    }
+
     return { createBy, carryForward: null };
   }