@oneuptime/common 7.0.3035 → 7.0.3040

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,10 +331,40 @@ 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>> {
-    if (!createBy.props.tenantId) {
+    if (!createBy.props.tenantId && !createBy.data.projectId) {
       throw new BadDataException(
         "ProjectId required to create scheduled maintenane.",
       );
@@ -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 };
   }
 

package/Server/Services/ScheduledMaintenanceTemplateOwnerTeamService.ts

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

package/Server/Services/ScheduledMaintenanceTemplateOwnerUserService.ts

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

package/Server/Services/ScheduledMaintenanceTemplateService.ts

@@ -0,0 +1,318 @@
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import ScheduledMaintenanceTemplateOwnerTeamService from "./ScheduledMaintenanceTemplateOwnerTeamService";
+import ScheduledMaintenanceTemplateOwnerUserService from "./ScheduledMaintenanceTemplateOwnerUserService";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import ObjectID from "../../Types/ObjectID";
+import Typeof from "../../Types/Typeof";
+import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplate";
+import ScheduledMaintenanceTemplateOwnerTeam from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerTeam";
+import ScheduledMaintenanceTemplateOwnerUser from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerUser";
+import CreateBy from "../Types/Database/CreateBy";
+import OneUptimeDate from "../../Types/Date";
+import Recurring from "../../Types/Events/Recurring";
+import UpdateBy from "../Types/Database/UpdateBy";
+import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public validateEventTemplate(template: Model): void {
+    // if recurring then start, end, scheduled time should not be null and all of them should be in the future.
+    if (template.isRecurringEvent) {
+      const startDate: Date | undefined = template.firstEventStartsAt;
+      const endDate: Date | undefined = template.firstEventEndsAt;
+      const scheduledTime: Date | undefined = template.firstEventScheduledAt;
+
+      if (!startDate) {
+        throw new BadDataException(
+          "Start date is required for recurring events.",
+        );
+      }
+
+      if (!endDate) {
+        throw new BadDataException(
+          "End date is required for recurring events.",
+        );
+      }
+
+      if (!scheduledTime) {
+        throw new BadDataException(
+          "Scheduled time is required for recurring events.",
+        );
+      }
+
+      // check if all dates are in the future.
+
+      if (OneUptimeDate.isInTheFuture(startDate) === false) {
+        throw new BadDataException("Start date should be in the future.");
+      }
+
+      if (OneUptimeDate.isInTheFuture(endDate) === false) {
+        throw new BadDataException("End date should be in the future.");
+      }
+
+      if (OneUptimeDate.isInTheFuture(scheduledTime) === false) {
+        throw new BadDataException("Scheduled time should be in the future.");
+      }
+
+      // make sure scheduedDate is < start date
+      if (!OneUptimeDate.isBefore(scheduledTime, startDate)) {
+        throw new BadDataException(
+          "Scheduled time should be less than start date.",
+        );
+      }
+
+      // make sure scheduledDate is < end date
+
+      if (!OneUptimeDate.isBefore(scheduledTime, endDate)) {
+        throw new BadDataException(
+          "Scheduled time should be less than end date.",
+        );
+      }
+
+      // make sure start date is < end date
+
+      if (!OneUptimeDate.isBefore(startDate, endDate)) {
+        throw new BadDataException("Start date should be less than end date.");
+      }
+
+      // check recurring internval
+
+      if (template.recurringInterval === undefined) {
+        throw new BadDataException(
+          "Recurring interval is required for recurring events.",
+        );
+      }
+    }
+  }
+
+  public getNextEventTime(data: {
+    dateAndTime: Date;
+    recurringInterval: Recurring;
+  }): Date {
+    // check if firstScheduledAt is in the future, and if yes return that.
+
+    if (OneUptimeDate.isInTheFuture(data.dateAndTime)) {
+      return data.dateAndTime;
+    }
+
+    // if not then calculate the next event time.
+
+    return Recurring.getNextDate(data.dateAndTime, data.recurringInterval);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    this.validateEventTemplate(createBy.data);
+
+    if (createBy.data.isRecurringEvent) {
+      // if all is good then the next scheduled at time should be set.
+      createBy.data.scheduleNextEventAt = this.getNextEventTime({
+        dateAndTime: createBy.data.firstEventScheduledAt!,
+        recurringInterval: createBy.data.recurringInterval!,
+      });
+    }
+
+    return {
+      createBy: createBy,
+      carryForward: false,
+    };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const newTemplate: QueryDeepPartialEntity<Model> = updateBy.data;
+
+    const existingTemplates: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        _id: true,
+        isRecurringEvent: true,
+        firstEventScheduledAt: true,
+        recurringInterval: true,
+        firstEventEndsAt: true,
+        firstEventStartsAt: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const template of existingTemplates) {
+      let isRecurring: boolean = Boolean(template.isRecurringEvent);
+
+      if (Object.keys(newTemplate).includes("isRecurringEvent")) {
+        isRecurring = newTemplate.isRecurringEvent as boolean;
+      }
+
+      let firstEventScheduledAt: Date | undefined =
+        template.firstEventScheduledAt;
+
+      if (Object.keys(newTemplate).includes("firstEventScheduledAt")) {
+        firstEventScheduledAt = newTemplate.firstEventScheduledAt as Date;
+      }
+
+      let recurringInterval: Recurring | undefined = template.recurringInterval;
+
+      if (Object.keys(newTemplate).includes("recurringInterval")) {
+        recurringInterval = newTemplate.recurringInterval as Recurring;
+      }
+
+      let firstEventEndsAt: Date | undefined = template.firstEventEndsAt;
+
+      if (Object.keys(newTemplate).includes("firstEventEndsAt")) {
+        firstEventEndsAt = newTemplate.firstEventEndsAt as Date;
+      }
+
+      let firstEventStartsAt: Date | undefined = template.firstEventStartsAt;
+
+      if (Object.keys(newTemplate).includes("firstEventStartsAt")) {
+        firstEventStartsAt = newTemplate.firstEventStartsAt as Date;
+      }
+
+      if (isRecurring) {
+        // make sure all are not null.
+
+        if (!firstEventScheduledAt) {
+          throw new BadDataException(
+            "First event scheduled at is required for recurring events.",
+          );
+        }
+
+        if (!recurringInterval) {
+          throw new BadDataException(
+            "Recurring interval is required for recurring events.",
+          );
+        }
+
+        if (!firstEventEndsAt) {
+          throw new BadDataException(
+            "First event ends at is required for recurring events.",
+          );
+        }
+
+        if (!firstEventStartsAt) {
+          throw new BadDataException(
+            "First event starts at is required for recurring events.",
+          );
+        }
+
+        // make sure scheduedDate is < start date
+        if (
+          !OneUptimeDate.isBefore(firstEventScheduledAt, firstEventStartsAt)
+        ) {
+          throw new BadDataException(
+            "Scheduled time should be less than start date.",
+          );
+        }
+
+        // make sure scheduledDate is < end date
+
+        if (!OneUptimeDate.isBefore(firstEventScheduledAt, firstEventEndsAt)) {
+          throw new BadDataException(
+            "Scheduled time should be less than end date.",
+          );
+        }
+
+        // make sure start date is < end date
+
+        if (!OneUptimeDate.isBefore(firstEventStartsAt, firstEventEndsAt)) {
+          throw new BadDataException(
+            "Start date should be less than end date.",
+          );
+        }
+
+        // now get next interval time.
+
+        newTemplate.scheduleNextEventAt = this.getNextEventTime({
+          dateAndTime: firstEventScheduledAt,
+          recurringInterval: recurringInterval,
+        });
+      }
+    }
+
+    updateBy.data = newTemplate;
+
+    return {
+      updateBy: updateBy,
+      carryForward: false,
+    };
+  }
+
+  protected override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add owners.
+
+    if (
+      createdItem.projectId &&
+      createdItem.id &&
+      onCreate.createBy.miscDataProps &&
+      (onCreate.createBy.miscDataProps["ownerTeams"] ||
+        onCreate.createBy.miscDataProps["ownerUsers"])
+    ) {
+      await this.addOwners(
+        createdItem.projectId,
+        createdItem.id,
+        (onCreate.createBy.miscDataProps["ownerUsers"] as Array<ObjectID>) ||
+          [],
+        (onCreate.createBy.miscDataProps["ownerTeams"] as Array<ObjectID>) ||
+          [],
+        onCreate.createBy.props,
+      );
+    }
+
+    return createdItem;
+  }
+
+  public async addOwners(
+    projectId: ObjectID,
+    scheduledMaintenanceTemplateId: ObjectID,
+    userIds: Array<ObjectID>,
+    teamIds: Array<ObjectID>,
+    props: DatabaseCommonInteractionProps,
+  ): Promise<void> {
+    for (let teamId of teamIds) {
+      if (typeof teamId === Typeof.String) {
+        teamId = new ObjectID(teamId.toString());
+      }
+
+      const teamOwner: ScheduledMaintenanceTemplateOwnerTeam =
+        new ScheduledMaintenanceTemplateOwnerTeam();
+      teamOwner.scheduledMaintenanceTemplateId = scheduledMaintenanceTemplateId;
+      teamOwner.projectId = projectId;
+      teamOwner.teamId = teamId;
+
+      await ScheduledMaintenanceTemplateOwnerTeamService.create({
+        data: teamOwner,
+        props: props,
+      });
+    }
+
+    for (let userId of userIds) {
+      if (typeof userId === Typeof.String) {
+        userId = new ObjectID(userId.toString());
+      }
+      const teamOwner: ScheduledMaintenanceTemplateOwnerUser =
+        new ScheduledMaintenanceTemplateOwnerUser();
+      teamOwner.scheduledMaintenanceTemplateId = scheduledMaintenanceTemplateId;
+      teamOwner.projectId = projectId;
+      teamOwner.userId = userId;
+      await ScheduledMaintenanceTemplateOwnerUserService.create({
+        data: teamOwner,
+        props: props,
+      });
+    }
+  }
+}
+export default new Service();

package/Types/Database/DatabaseProperty.ts

@@ -11,19 +11,22 @@ export default class DatabaseProperty extends SerializableObject {
 
   protected static fromDatabase(
     _value: string | number | JSONObject | JSONArray,
-  ): DatabaseProperty | null {
+  ): DatabaseProperty | Array<DatabaseProperty> | null {
     throw new NotImplementedException();
   }
 
   protected static toDatabase(
-    _value: DatabaseProperty | FindOperator<DatabaseProperty>,
+    _value:
+      | DatabaseProperty
+      | Array<DatabaseProperty>
+      | FindOperator<DatabaseProperty>,
   ): string | number | JSONObject | JSONArray | null {
     throw new NotImplementedException();
   }
 
   protected static _fromDatabase(
     value: string | number | JSONObject | JSONArray,
-  ): DatabaseProperty | null {
+  ): DatabaseProperty | Array<DatabaseProperty> | null {
     return this.fromDatabase(value);
   }