@oneuptime/common 7.0.3148 → 7.0.3153

package/Server/Services/Index.ts

@@ -137,6 +137,18 @@ import ScheduledMaintenanceTemplateService from "./ScheduledMaintenanceTemplateS
 import ScheduledMaintenanceTemplateOwnerTeamService from "./ScheduledMaintenanceTemplateOwnerTeamService";
 import ScheduledMaintenanceTemplateOwnerUserService from "./ScheduledMaintenanceTemplateOwnerUserService";
 
+// Alert Services
+import AlertStateService from "./AlertStateService";
+import AlertService from "./AlertService";
+import AlertCustomFieldService from "./AlertCustomFieldService";
+import AlertStateTimelineService from "./AlertStateTimelineService";
+import AlertInternalNoteService from "./AlertInternalNoteService";
+import AlertOwnerTeamService from "./AlertOwnerTeamService";
+import AlertOwnerUserService from "./AlertOwnerUserService";
+import AlertSeverityService from "./AlertSeverityService";
+import AlertNoteTemplateService from "./AlertNoteTemplateService";
+import TableViewService from "./TableViewService";
+
 const services: Array<BaseService> = [
   AcmeCertificateService,
   PromoCodeService,
@@ -285,6 +297,17 @@ const services: Array<BaseService> = [
   ScheduledMaintenanceTemplateService,
   ScheduledMaintenanceTemplateOwnerTeamService,
   ScheduledMaintenanceTemplateOwnerUserService,
+
+  AlertStateService,
+  AlertService,
+  AlertCustomFieldService,
+  AlertStateTimelineService,
+  AlertInternalNoteService,
+  AlertOwnerTeamService,
+  AlertOwnerUserService,
+  AlertSeverityService,
+  AlertNoteTemplateService,
+  TableViewService,
 ];
 
 export const AnalyticsServices: Array<

package/Server/Services/MonitorStatusTimelineService.ts

@@ -14,11 +14,14 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
 import User from "Common/Models/DatabaseModels/User";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<MonitorStatusTimeline> {
   public constructor() {
     super(MonitorStatusTimeline);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
   }
 
   protected override async onBeforeCreate(

package/Server/Services/OnCallDutyPolicyExecutionLogService.ts

@@ -6,11 +6,14 @@ import OnCallDutyPolicyStatus from "../../Types/OnCallDutyPolicy/OnCallDutyPolic
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import OnCallDutyPolicyEscalationRule from "Common/Models/DatabaseModels/OnCallDutyPolicyEscalationRule";
 import Model from "Common/Models/DatabaseModels/OnCallDutyPolicyExecutionLog";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 30);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 30);
+    }
   }
 
   protected override async onBeforeCreate(

package/Server/Services/OnCallDutyPolicyService.ts

@@ -16,6 +16,7 @@ export class Service extends DatabaseService<OnCallDutyPolicy> {
     policyId: ObjectID,
     options: {
       triggeredByIncidentId?: ObjectID | undefined;
+      triggeredByAlertId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
     },
   ): Promise<void> {
@@ -31,6 +32,16 @@ export class Service extends DatabaseService<OnCallDutyPolicy> {
       );
     }
 
+    if (
+      UserNotificationEventType.AlertCreated ===
+        options.userNotificationEventType &&
+      !options.triggeredByAlertId
+    ) {
+      throw new BadDataException(
+        "triggeredByAlertId is required when userNotificationEventType is IncidentCreated",
+      );
+    }
+
     const policy: OnCallDutyPolicy | null = await this.findOneById({
       id: policyId,
       select: {
@@ -62,6 +73,10 @@ export class Service extends DatabaseService<OnCallDutyPolicy> {
       log.triggeredByIncidentId = options.triggeredByIncidentId;
     }
 
+    if (options.triggeredByAlertId) {
+      log.triggeredByAlertId = options.triggeredByAlertId;
+    }
+
     await OnCallDutyPolicyExecutionLogService.create({
       data: log,
       props: {

package/Server/Services/ProjectService.ts

@@ -28,7 +28,14 @@ import SubscriptionPlan, {
   PlanType,
 } from "../../Types/Billing/SubscriptionPlan";
 import SubscriptionStatus from "../../Types/Billing/SubscriptionStatus";
-import { Black, Green, Moroon500, Red, Yellow } from "../../Types/BrandColors";
+import {
+  Black,
+  Green,
+  Moroon500,
+  Red,
+  Yellow,
+  Yellow500,
+} from "../../Types/BrandColors";
 import Color from "../../Types/Color";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import OneUptimeDate from "../../Types/Date";
@@ -50,6 +57,10 @@ import TeamPermission from "Common/Models/DatabaseModels/TeamPermission";
 import User from "Common/Models/DatabaseModels/User";
 import Select from "../Types/Database/Select";
 import Query from "../Types/Database/Query";
+import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
+import AlertSeverityService from "./AlertSeverityService";
+import AlertState from "../../Models/DatabaseModels/AlertState";
+import AlertStateService from "./AlertStateService";
 
 export interface CurrentPlan {
   plan: PlanType | null;
@@ -543,10 +554,12 @@ export class ProjectService extends DatabaseService<Model> {
     }
 
     createdItem = await this.addDefaultIncidentSeverity(createdItem);
+    createdItem = await this.addDefaultAlertSeverity(createdItem);
     createdItem = await this.addDefaultProjectTeams(createdItem);
     createdItem = await this.addDefaultMonitorStatus(createdItem);
     createdItem = await this.addDefaultIncidentState(createdItem);
     createdItem = await this.addDefaultScheduledMaintenanceState(createdItem);
+    createdItem = await this.addDefaultAlertState(createdItem);
 
     return createdItem;
   }
@@ -603,6 +616,91 @@ export class ProjectService extends DatabaseService<Model> {
     return createdItem;
   }
 
+  public async addDefaultAlertState(createdItem: Model): Promise<Model> {
+    let createdAlertState: AlertState = new AlertState();
+    createdAlertState.name = "Identified";
+    createdAlertState.description =
+      "When an alert is created, it belongs to this state";
+    createdAlertState.color = Red;
+    createdAlertState.isCreatedState = true;
+    createdAlertState.projectId = createdItem.id!;
+    createdAlertState.order = 1;
+
+    createdAlertState = await AlertStateService.create({
+      data: createdAlertState,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    let acknowledgedAlertState: AlertState = new AlertState();
+    acknowledgedAlertState.name = "Acknowledged";
+    acknowledgedAlertState.description =
+      "When an alert is acknowledged, it belongs to this state.";
+    acknowledgedAlertState.color = Yellow;
+    acknowledgedAlertState.isAcknowledgedState = true;
+    acknowledgedAlertState.projectId = createdItem.id!;
+    acknowledgedAlertState.order = 2;
+
+    acknowledgedAlertState = await AlertStateService.create({
+      data: acknowledgedAlertState,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    let resolvedAlertState: AlertState = new AlertState();
+    resolvedAlertState.name = "Resolved";
+    resolvedAlertState.description =
+      "When an incident is resolved, it belongs to this state.";
+    resolvedAlertState.color = Green;
+    resolvedAlertState.isResolvedState = true;
+    resolvedAlertState.projectId = createdItem.id!;
+    resolvedAlertState.order = 3;
+
+    resolvedAlertState = await AlertStateService.create({
+      data: resolvedAlertState,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return createdItem;
+  }
+
+  public async addDefaultAlertSeverity(createdItem: Model): Promise<Model> {
+    let highSeverity: AlertSeverity = new AlertSeverity();
+    highSeverity.name = "High";
+    highSeverity.description =
+      "Issues causing very high impact to customers. Immediate attention is required.";
+    highSeverity.color = Moroon500;
+    highSeverity.projectId = createdItem.id!;
+    highSeverity.order = 1;
+
+    highSeverity = await AlertSeverityService.create({
+      data: highSeverity,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    let lowSeverity: AlertSeverity = new AlertSeverity();
+    lowSeverity.name = "Low";
+    lowSeverity.description = "Issues causing low impact to customers.";
+    lowSeverity.color = Yellow500;
+    lowSeverity.projectId = createdItem.id!;
+    lowSeverity.order = 2;
+
+    lowSeverity = await AlertSeverityService.create({
+      data: lowSeverity,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return createdItem;
+  }
+
   private async addDefaultIncidentSeverity(createdItem: Model): Promise<Model> {
     let criticalIncident: IncidentSeverity = new IncidentSeverity();
     criticalIncident.name = "Critical Incident";

package/Server/Services/ScheduledMaintenanceService.ts

@@ -45,11 +45,14 @@ 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";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
   }
 
   public async notififySubscribersOnEventScheduled(

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -22,11 +22,14 @@ import ScheduledMaintenance from "Common/Models/DatabaseModels/ScheduledMaintena
 import ScheduledMaintenancePublicNote from "Common/Models/DatabaseModels/ScheduledMaintenancePublicNote";
 import ScheduledMaintenanceState from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
 import ScheduledMaintenanceStateTimeline from "Common/Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline> {
   public constructor() {
     super(ScheduledMaintenanceStateTimeline);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
   }
 
   protected override async onBeforeCreate(

package/Server/Services/ShortLinkService.ts

@@ -9,11 +9,14 @@ import Route from "../../Types/API/Route";
 import URL from "../../Types/API/URL";
 import Text from "../../Types/Text";
 import Model from "Common/Models/DatabaseModels/ShortLink";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 3); //expire links in 3 days.
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3); //expire links in 3 days.
+    }
   }
 
   protected override async onBeforeCreate(

package/Server/Services/SmsLogService.ts

@@ -1,10 +1,13 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/SmsLog";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+    }
   }
 }
 

package/Server/Services/TableViewService.ts

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

package/Server/Services/TelemetryUsageBillingService.ts

@@ -10,11 +10,14 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ProductType from "../../Types/MeteredPlan/ProductType";
 import ObjectID from "../../Types/ObjectID";
 import Model from "Common/Models/DatabaseModels/TelemetryUsageBilling";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
   }
 
   public async getUnreportedUsageBilling(data: {

package/Server/Services/UserNotificationSettingService.ts

@@ -282,6 +282,34 @@ export class Service extends DatabaseService<UserNotificationSetting> {
       });
     }
 
+    const alertCreatedNotificationEvent: PositiveNumber = await this.countBy({
+      query: {
+        userId,
+        projectId,
+        eventType:
+          NotificationSettingEventType.SEND_ALERT_CREATED_OWNER_NOTIFICATION,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (alertCreatedNotificationEvent.toNumber() === 0) {
+      const item: UserNotificationSetting = new UserNotificationSetting();
+      item.userId = userId;
+      item.projectId = projectId;
+      item.eventType =
+        NotificationSettingEventType.SEND_ALERT_CREATED_OWNER_NOTIFICATION;
+      item.alertByEmail = true;
+
+      await this.create({
+        data: item,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     // check monitor state changed notification
     const monitorStateChangedNotificationEvent: PositiveNumber =
       await this.countBy({
@@ -404,6 +432,36 @@ export class Service extends DatabaseService<UserNotificationSetting> {
         },
       });
     }
+
+    // check alert state changed notification
+    const alertStateChangedNotificationEvent: PositiveNumber =
+      await this.countBy({
+        query: {
+          userId,
+          projectId,
+          eventType:
+            NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (alertStateChangedNotificationEvent.toNumber() === 0) {
+      const item: UserNotificationSetting = new UserNotificationSetting();
+      item.userId = userId;
+      item.projectId = projectId;
+      item.eventType =
+        NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION;
+      item.alertByEmail = true;
+
+      await this.create({
+        data: item,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
   }
 
   protected override async onBeforeCreate(

package/Server/Services/UserOnCallLogService.ts

@@ -15,11 +15,14 @@ import UserNotificationExecutionStatus from "../../Types/UserNotification/UserNo
 import Incident from "Common/Models/DatabaseModels/Incident";
 import UserNotificationRule from "Common/Models/DatabaseModels/UserNotificationRule";
 import Model from "Common/Models/DatabaseModels/UserOnCallLog";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 30);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 30);
+    }
   }
 
   protected override async onBeforeCreate(

package/Server/Services/WorkflowLogService.ts

@@ -1,10 +1,13 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/WorkflowLog";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+    }
   }
 }
 export default new Service();

package/Server/Types/Workflow/Components/API/Post.ts

@@ -11,6 +11,7 @@ import ComponentMetadata, { Port } from "Common/Types/Workflow/Component";
 import ComponentID from "Common/Types/Workflow/ComponentID";
 import APIComponents from "Common/Types/Workflow/Components/API";
 import API from "Common/Utils/API";
+import logger from "../../../../Utils/Logger";
 
 export default class ApiPost extends ComponentCode {
   public constructor() {
@@ -38,6 +39,25 @@ export default class ApiPost extends ComponentCode {
 
     let apiResult: HTTPResponse<JSONObject> | HTTPErrorResponse | null = null;
 
+    logger.debug("API Post Component is running.");
+
+    const url: URL = args["url"] as URL;
+    if (!url) {
+      throw options.onError(new BadDataException("URL is required"));
+    }
+
+    logger.debug(`URL: ${url}`);
+
+    const requestBody: JSONObject = args["request-body"] as JSONObject;
+
+    logger.debug(`Request Body: ${JSON.stringify(requestBody)}`);
+
+    const requestHeaders: Dictionary<string> = args[
+      "request-headers"
+    ] as Dictionary<string>;
+
+    logger.debug(`Request Headers: ${JSON.stringify(requestHeaders)}`);
+
     try {
       apiResult = await API.post(
         args["url"] as URL,
@@ -45,6 +65,8 @@ export default class ApiPost extends ComponentCode {
         args["request-headers"] as Dictionary<string>,
       );
 
+      logger.debug("API Post Component is done.");
+
       return Promise.resolve({
         returnValues: ApiComponentUtils.getReturnValues(apiResult),
         executePort: result.successPort,
@@ -64,6 +86,9 @@ export default class ApiPost extends ComponentCode {
         });
       }
 
+      logger.debug("API Post Component is done with error.");
+      logger.debug(err);
+
       throw options.onError(new APIException("Something wrong happened."));
     }
   }