@oneuptime/common 7.0.3148 → 7.0.3153

package/Server/Services/AlertStateService.ts

@@ -0,0 +1,227 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import QueryHelper from "../Types/Database/QueryHelper";
+import UpdateBy from "../Types/Database/UpdateBy";
+import DatabaseService from "./DatabaseService";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import AlertState from "Common/Models/DatabaseModels/AlertState";
+
+export class Service extends DatabaseService<AlertState> {
+  public constructor() {
+    super(AlertState);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<AlertState>,
+  ): Promise<OnCreate<AlertState>> {
+    if (!createBy.data.order) {
+      throw new BadDataException("Alert State order is required");
+    }
+
+    if (!createBy.data.projectId) {
+      throw new BadDataException("Alert State projectId is required");
+    }
+
+    await this.rearrangeOrder(
+      createBy.data.order,
+      createBy.data.projectId,
+      true,
+    );
+
+    return {
+      createBy: createBy,
+      carryForward: null,
+    };
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<AlertState>,
+  ): Promise<OnDelete<AlertState>> {
+    if (!deleteBy.query._id && !deleteBy.props.isRoot) {
+      throw new BadDataException(
+        "_id should be present when deleting alert states. Please try the delete with objectId",
+      );
+    }
+
+    let alertState: AlertState | null = null;
+
+    if (!deleteBy.props.isRoot) {
+      alertState = await this.findOneBy({
+        query: deleteBy.query,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          order: true,
+          projectId: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: alertState,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<AlertState>,
+    _itemIdsBeforeDelete: ObjectID[],
+  ): Promise<OnDelete<AlertState>> {
+    const deleteBy: DeleteBy<AlertState> = onDelete.deleteBy;
+    const alertState: AlertState | null = onDelete.carryForward;
+
+    if (!deleteBy.props.isRoot && alertState) {
+      if (alertState && alertState.order && alertState.projectId) {
+        await this.rearrangeOrder(
+          alertState.order,
+          alertState.projectId,
+          false,
+        );
+      }
+    }
+
+    return {
+      deleteBy: deleteBy,
+      carryForward: null,
+    };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<AlertState>,
+  ): Promise<OnUpdate<AlertState>> {
+    if (updateBy.data.order && !updateBy.props.isRoot) {
+      throw new BadDataException(
+        "Alert State order should not be updated. Delete this alert state and create a new state with the right order.",
+      );
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  private async rearrangeOrder(
+    currentOrder: number,
+    projectId: ObjectID,
+    increaseOrder: boolean = true,
+  ): Promise<void> {
+    // get alert with this order.
+    const alertStates: Array<AlertState> = await this.findBy({
+      query: {
+        order: QueryHelper.greaterThanEqualTo(currentOrder),
+        projectId: projectId,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+        order: true,
+      },
+      sort: {
+        order: SortOrder.Ascending,
+      },
+    });
+
+    let newOrder: number = currentOrder;
+
+    for (const alertState of alertStates) {
+      if (increaseOrder) {
+        newOrder = alertState.order! + 1;
+      } else {
+        newOrder = alertState.order! - 1;
+      }
+
+      await this.updateOneBy({
+        query: {
+          _id: alertState._id!,
+        },
+        data: {
+          order: newOrder,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+
+  public async getAllAlertStates(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<Array<AlertState>> {
+    const alertStates: Array<AlertState> = await this.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      select: {
+        _id: true,
+        isResolvedState: true,
+        isAcknowledgedState: true,
+        isCreatedState: true,
+        order: true,
+      },
+      props: data.props,
+    });
+
+    return alertStates;
+  }
+
+  public async getUnresolvedAlertStates(
+    projectId: ObjectID,
+    props: DatabaseCommonInteractionProps,
+  ): Promise<AlertState[]> {
+    const alertStates: Array<AlertState> = await this.getAllAlertStates({
+      projectId: projectId,
+      props: props,
+    });
+
+    const unresolvedAlertStates: Array<AlertState> = [];
+
+    for (const state of alertStates) {
+      if (!state.isResolvedState) {
+        unresolvedAlertStates.push(state);
+      } else {
+        break; // everything after resolved state is resolved
+      }
+    }
+
+    return unresolvedAlertStates;
+  }
+
+  public async getAcknowledgedAlertState(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<AlertState> {
+    const alertStates: Array<AlertState> = await this.getAllAlertStates({
+      projectId: data.projectId,
+      props: data.props,
+    });
+
+    const ackAlertState: AlertState | undefined = alertStates.find(
+      (alertState: AlertState) => {
+        return alertState?.isAcknowledgedState;
+      },
+    );
+
+    if (!ackAlertState) {
+      throw new BadDataException(
+        "Acknowledged Alert State not found for this project",
+      );
+    }
+
+    return ackAlertState;
+  }
+}
+export default new Service();

package/Server/Services/AlertStateTimelineService.ts

@@ -0,0 +1,334 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import QueryHelper from "../Types/Database/QueryHelper";
+import DatabaseService from "./DatabaseService";
+import AlertService from "./AlertService";
+import AlertStateService from "./AlertStateService";
+import UserService from "./UserService";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import OneUptimeDate from "../../Types/Date";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import AlertState from "Common/Models/DatabaseModels/AlertState";
+import AlertStateTimeline from "Common/Models/DatabaseModels/AlertStateTimeline";
+import User from "Common/Models/DatabaseModels/User";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import { JSONObject } from "../../Types/JSON";
+import AlertInternalNote from "../../Models/DatabaseModels/AlertInternalNote";
+import AlertInternalNoteService from "./AlertInternalNoteService";
+
+export class Service extends DatabaseService<AlertStateTimeline> {
+  public constructor() {
+    super(AlertStateTimeline);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
+  }
+
+  public async getResolvedStateIdForProject(
+    projectId: ObjectID,
+  ): Promise<ObjectID> {
+    const resolvedState: AlertState | null = await AlertStateService.findOneBy({
+      query: {
+        projectId: projectId,
+        isResolvedState: true,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+      },
+    });
+
+    if (!resolvedState) {
+      throw new BadDataException("No resolved state found for the project");
+    }
+
+    return resolvedState.id!;
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<AlertStateTimeline>,
+  ): Promise<OnCreate<AlertStateTimeline>> {
+    if (!createBy.data.alertId) {
+      throw new BadDataException("alertId is null");
+    }
+
+    if (!createBy.data.startsAt) {
+      createBy.data.startsAt = OneUptimeDate.getCurrentDate();
+    }
+
+    if (
+      (createBy.data.createdByUserId ||
+        createBy.data.createdByUser ||
+        createBy.props.userId) &&
+      !createBy.data.rootCause
+    ) {
+      let userId: ObjectID | undefined = createBy.data.createdByUserId;
+
+      if (createBy.props.userId) {
+        userId = createBy.props.userId;
+      }
+
+      if (createBy.data.createdByUser && createBy.data.createdByUser.id) {
+        userId = createBy.data.createdByUser.id;
+      }
+
+      const user: User | null = await UserService.findOneBy({
+        query: {
+          _id: userId?.toString() as string,
+        },
+        select: {
+          _id: true,
+          name: true,
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (user) {
+        createBy.data.rootCause = `Alert state created by ${user.name} (${user.email})`;
+      }
+    }
+
+    const lastAlertStateTimeline: AlertStateTimeline | null =
+      await this.findOneBy({
+        query: {
+          alertId: createBy.data.alertId,
+        },
+        sort: {
+          createdAt: SortOrder.Descending,
+        },
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+        },
+      });
+
+    const internalNote: string | undefined = (
+      createBy.miscDataProps as JSONObject | undefined
+    )?.["internalNote"] as string | undefined;
+
+    if (internalNote) {
+      const alertNote: AlertInternalNote = new AlertInternalNote();
+      alertNote.alertId = createBy.data.alertId;
+      alertNote.note = internalNote;
+      alertNote.createdAt = createBy.data.startsAt;
+      alertNote.projectId = createBy.data.projectId!;
+
+      await AlertInternalNoteService.create({
+        data: alertNote,
+        props: createBy.props,
+      });
+    }
+
+    return {
+      createBy,
+      carryForward: {
+        lastAlertStateTimelineId: lastAlertStateTimeline?.id || null,
+      },
+    };
+  }
+
+  protected override async onCreateSuccess(
+    onCreate: OnCreate<AlertStateTimeline>,
+    createdItem: AlertStateTimeline,
+  ): Promise<AlertStateTimeline> {
+    if (!createdItem.alertId) {
+      throw new BadDataException("alertId is null");
+    }
+
+    if (!createdItem.alertStateId) {
+      throw new BadDataException("alertStateId is null");
+    }
+
+    // update the last status as ended.
+
+    if (onCreate.carryForward.lastAlertStateTimelineId) {
+      await this.updateOneById({
+        id: onCreate.carryForward.lastAlertStateTimelineId!,
+        data: {
+          endsAt: createdItem.createdAt || OneUptimeDate.getCurrentDate(),
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    await AlertService.updateOneBy({
+      query: {
+        _id: createdItem.alertId?.toString(),
+      },
+      data: {
+        currentAlertStateId: createdItem.alertStateId,
+      },
+      props: onCreate.createBy.props,
+    });
+
+    return createdItem;
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<AlertStateTimeline>,
+  ): Promise<OnDelete<AlertStateTimeline>> {
+    if (deleteBy.query._id) {
+      const alertStateTimelineToBeDeleted: AlertStateTimeline | null =
+        await this.findOneById({
+          id: new ObjectID(deleteBy.query._id as string),
+          select: {
+            alertId: true,
+            startsAt: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      const alertId: ObjectID | undefined =
+        alertStateTimelineToBeDeleted?.alertId;
+
+      if (alertId) {
+        const alertStateTimeline: PositiveNumber = await this.countBy({
+          query: {
+            alertId: alertId,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (alertStateTimeline.isOne()) {
+          throw new BadDataException(
+            "Cannot delete the only state timeline. Alert should have at least one state in its timeline.",
+          );
+        }
+
+        if (alertStateTimelineToBeDeleted?.startsAt) {
+          const beforeState: AlertStateTimeline | null = await this.findOneBy({
+            query: {
+              alertId: alertId,
+              startsAt: QueryHelper.lessThan(
+                alertStateTimelineToBeDeleted?.startsAt,
+              ),
+            },
+            sort: {
+              createdAt: SortOrder.Descending,
+            },
+            props: {
+              isRoot: true,
+            },
+            select: {
+              _id: true,
+              startsAt: true,
+            },
+          });
+
+          if (beforeState) {
+            const afterState: AlertStateTimeline | null = await this.findOneBy({
+              query: {
+                alertId: alertId,
+                startsAt: QueryHelper.greaterThan(
+                  alertStateTimelineToBeDeleted?.startsAt,
+                ),
+              },
+              sort: {
+                createdAt: SortOrder.Ascending,
+              },
+              props: {
+                isRoot: true,
+              },
+              select: {
+                _id: true,
+                startsAt: true,
+              },
+            });
+
+            if (!afterState) {
+              // if there's nothing after then end date of before state is null.
+
+              await this.updateOneById({
+                id: beforeState.id!,
+                data: {
+                  endsAt: null as any,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+            } else {
+              // if there's something after then end date of before state is start date of after state.
+
+              await this.updateOneById({
+                id: beforeState.id!,
+                data: {
+                  endsAt: afterState.startsAt!,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+            }
+          }
+        }
+      }
+
+      return { deleteBy, carryForward: alertId };
+    }
+
+    return { deleteBy, carryForward: null };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<AlertStateTimeline>,
+    _itemIdsBeforeDelete: ObjectID[],
+  ): Promise<OnDelete<AlertStateTimeline>> {
+    if (onDelete.carryForward) {
+      // this is alertId.
+      const alertId: ObjectID = onDelete.carryForward as ObjectID;
+
+      // get last status of this monitor.
+      const alertStateTimeline: AlertStateTimeline | null =
+        await this.findOneBy({
+          query: {
+            alertId: alertId,
+          },
+          sort: {
+            createdAt: SortOrder.Descending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            _id: true,
+            alertStateId: true,
+          },
+        });
+
+      if (alertStateTimeline && alertStateTimeline.alertStateId) {
+        await AlertService.updateOneBy({
+          query: {
+            _id: alertId.toString(),
+          },
+          data: {
+            currentAlertStateId: alertStateTimeline.alertStateId,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    }
+
+    return onDelete;
+  }
+}
+
+export default new Service();

package/Server/Services/CallLogService.ts

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

package/Server/Services/DatabaseService.ts

@@ -671,28 +671,25 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
         );
       }
 
-      // hit workflow.;
-      if (this.getModel().enableWorkflowOn?.create) {
-        let tenantId: ObjectID | undefined = createBy.props.tenantId;
+      let tenantId: ObjectID | undefined = createBy.props.tenantId;
 
-        if (!tenantId && this.getModel().getTenantColumn()) {
-          tenantId = createBy.data.getValue<ObjectID>(
-            this.getModel().getTenantColumn()!,
-          );
-        }
+      if (!tenantId && this.getModel().getTenantColumn()) {
+        tenantId = createBy.data.getValue<ObjectID>(
+          this.getModel().getTenantColumn()!,
+        );
+      }
 
-        if (tenantId) {
-          await this.onTriggerWorkflow(
-            createBy.data.id!,
-            tenantId,
-            "on-create",
-          );
-          await this.onTriggerRealtime(
-            createBy.data.id!,
-            tenantId,
-            ModelEventType.Create,
-          );
-        }
+      // hit workflow.;
+      if (this.getModel().enableWorkflowOn?.create && tenantId) {
+        await this.onTriggerWorkflow(createBy.data.id!, tenantId, "on-create");
+      }
+
+      if (tenantId) {
+        await this.onTriggerRealtime(
+          createBy.data.id!,
+          tenantId,
+          ModelEventType.Create,
+        );
       }
 
       return createBy.data;

package/Server/Services/EmailLogService.ts

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

package/Server/Services/IncidentService.ts

@@ -33,11 +33,14 @@ import Monitor from "Common/Models/DatabaseModels/Monitor";
 import MonitorStatus from "Common/Models/DatabaseModels/MonitorStatus";
 import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
 import User from "Common/Models/DatabaseModels/User";
+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 isIncidentAcknowledged(data: {

package/Server/Services/IncidentStateTimelineService.ts

@@ -18,11 +18,14 @@ import IncidentPublicNote from "Common/Models/DatabaseModels/IncidentPublicNote"
 import IncidentState from "Common/Models/DatabaseModels/IncidentState";
 import IncidentStateTimeline from "Common/Models/DatabaseModels/IncidentStateTimeline";
 import User from "Common/Models/DatabaseModels/User";
+import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<IncidentStateTimeline> {
   public constructor() {
     super(IncidentStateTimeline);
-    this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
   }
 
   public async getResolvedStateIdForProject(