@oneuptime/common 7.0.3815 → 7.0.3826

package/Server/Services/MonitorStatusTimelineService.ts

@@ -19,7 +19,7 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
   public constructor() {
     super(MonitorStatusTimeline);
     if (IsBillingEnabled) {
-      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+      this.hardDeleteItemsOlderThanInDays("startsAt", 120);
     }
   }
 
@@ -71,31 +71,64 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       }
     }
 
-    const lastMonitorStatusTimeline: MonitorStatusTimeline | null =
-      await this.findOneBy({
-        query: {
-          monitorId: createBy.data.monitorId,
-        },
-        sort: {
-          createdAt: SortOrder.Descending,
-        },
-        props: {
-          isRoot: true,
-        },
-        select: {
-          _id: true,
-        },
-      });
+    const stateBeforeThis: MonitorStatusTimeline | null = await this.findOneBy({
+      query: {
+        monitorId: createBy.data.monitorId,
+        startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
+      },
+      sort: {
+        startsAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        monitorStatusId: true,
+        startsAt: true,
+        endsAt: true,
+      },
+    });
 
-    if (!lastMonitorStatusTimeline) {
+    logger.debug("State Before this");
+    logger.debug(stateBeforeThis);
+
+    // If this is the first state, then do not notify the owner.
+    if (!stateBeforeThis) {
       // since this is the first status, do not notify the owner.
       createBy.data.isOwnerNotified = true;
     }
 
+    const stateAfterThis: MonitorStatusTimeline | null = await this.findOneBy({
+      query: {
+        monitorId: createBy.data.monitorId,
+        startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
+      },
+      sort: {
+        startsAt: SortOrder.Ascending,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        monitorStatusId: true,
+        startsAt: true,
+        endsAt: true,
+      },
+    });
+
+    // compute ends at. It's the start of the next status.
+    if (stateAfterThis && stateAfterThis.startsAt) {
+      createBy.data.endsAt = stateAfterThis.startsAt;
+    }
+
+    logger.debug("State After this");
+    logger.debug(stateAfterThis);
+
     return {
       createBy,
       carryForward: {
-        lastMonitorStatusTimelineId: lastMonitorStatusTimeline?.id || null,
+        statusTimelineBeforeThisStatus: stateBeforeThis || null,
+        statusTimelineAfterThisStatus: stateAfterThis || null,
         mutex: mutex,
       },
     };
@@ -115,27 +148,72 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
 
     // update the last status as ended.
 
-    if (onCreate.carryForward.lastMonitorStatusTimelineId) {
+    logger.debug("Status Timeline Before this");
+    logger.debug(onCreate.carryForward.statusTimelineBeforeThisStatus);
+
+    logger.debug("Status Timeline After this");
+    logger.debug(onCreate.carryForward.statusTimelineAfterThisStatus);
+
+    logger.debug("Created Item");
+    logger.debug(createdItem);
+
+    // now there are three cases.
+    // 1. This is the first status OR there's no status after this.
+    if (!onCreate.carryForward.statusTimelineBeforeThisStatus) {
+      // This is the first status, no need to update previous status.
+      logger.debug("This is the first status.");
+    } else if (!onCreate.carryForward.statusTimelineAfterThisStatus) {
+      // 2. This is the last status.
+      // Update the previous status to end at the start of this status.
       await this.updateOneById({
-        id: onCreate.carryForward.lastMonitorStatusTimelineId!,
+        id: onCreate.carryForward.statusTimelineBeforeThisStatus.id!,
         data: {
-          endsAt: createdItem.createdAt || OneUptimeDate.getCurrentDate(),
+          endsAt: createdItem.startsAt!,
         },
         props: {
           isRoot: true,
         },
       });
+      logger.debug("This is the last status.");
+    } else {
+      // 3. This is in the middle.
+      // Update the previous status to end at the start of this status.
+      await this.updateOneById({
+        id: onCreate.carryForward.statusTimelineBeforeThisStatus.id!,
+        data: {
+          endsAt: createdItem.startsAt!,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // Update the next status to start at the end of this status.
+      await this.updateOneById({
+        id: onCreate.carryForward.statusTimelineAfterThisStatus.id!,
+        data: {
+          startsAt: createdItem.endsAt!,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+      logger.debug("This status is in the middle.");
     }
 
-    await MonitorService.updateOneBy({
-      query: {
-        _id: createdItem.monitorId?.toString(),
-      },
-      data: {
-        currentMonitorStatusId: createdItem.monitorStatusId,
-      },
-      props: onCreate.createBy.props,
-    });
+    if (!createdItem.endsAt) {
+      // if this is the last status, then update the monitor status.
+
+      await MonitorService.updateOneBy({
+        query: {
+          _id: createdItem.monitorId?.toString(),
+        },
+        data: {
+          currentMonitorStatusId: createdItem.monitorStatusId,
+        },
+        props: onCreate.createBy.props,
+      });
+    }
 
     if (onCreate.carryForward.mutex) {
       const mutex: SemaphoreMutex = onCreate.carryForward.mutex;
@@ -155,6 +233,7 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
           select: {
             monitorId: true,
             startsAt: true,
+            endsAt: true,
           },
           props: {
             isRoot: true,
@@ -174,82 +253,104 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
           },
         });
 
+        if (!monitorStatusTimelineToBeDeleted) {
+          throw new BadDataException("Monitor status timeline not found.");
+        }
+
         if (monitorStatusTimeline.isOne()) {
           throw new BadDataException(
             "Cannot delete the only status timeline. Monitor should have at least one status timeline.",
           );
         }
 
-        // adjust times of other timeline events. get the state before this status timeline.
-
-        if (monitorStatusTimelineToBeDeleted?.startsAt) {
-          const beforeState: MonitorStatusTimeline | null =
-            await this.findOneBy({
-              query: {
-                monitorId: monitorId,
-                startsAt: QueryHelper.lessThan(
-                  monitorStatusTimelineToBeDeleted?.startsAt,
-                ),
-              },
-              sort: {
-                createdAt: SortOrder.Descending,
-              },
-              props: {
-                isRoot: true,
-              },
-              select: {
-                _id: true,
-                startsAt: true,
-              },
-            });
-
-          if (beforeState) {
-            const afterState: MonitorStatusTimeline | null =
-              await this.findOneBy({
-                query: {
-                  monitorId: monitorId,
-                  startsAt: QueryHelper.greaterThan(
-                    monitorStatusTimelineToBeDeleted?.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,
-                },
-              });
-            }
-          }
+        // There are three cases.
+        // 1. This is the first status.
+        // 2. This is the last status.
+        // 3. This is in the middle.
+
+        const stateBeforeThis: MonitorStatusTimeline | null =
+          await this.findOneBy({
+            query: {
+              _id: QueryHelper.notEquals(deleteBy.query._id as string),
+              monitorId: monitorId,
+              startsAt: QueryHelper.lessThanEqualTo(
+                monitorStatusTimelineToBeDeleted.startsAt!,
+              ),
+            },
+            sort: {
+              startsAt: SortOrder.Descending,
+            },
+            props: {
+              isRoot: true,
+            },
+            select: {
+              monitorStatusId: true,
+              startsAt: true,
+              endsAt: true,
+            },
+          });
+
+        const stateAfterThis: MonitorStatusTimeline | null =
+          await this.findOneBy({
+            query: {
+              monitorId: monitorId,
+              startsAt: QueryHelper.greaterThan(
+                monitorStatusTimelineToBeDeleted.startsAt!,
+              ),
+            },
+            sort: {
+              startsAt: SortOrder.Ascending,
+            },
+            props: {
+              isRoot: true,
+            },
+            select: {
+              monitorStatusId: true,
+              startsAt: true,
+              endsAt: true,
+            },
+          });
+
+        if (!stateBeforeThis) {
+          // This is the first status, no need to update previous status.
+          logger.debug("This is the first status.");
+        } else if (!stateAfterThis) {
+          // This is the last status.
+          // Update the previous status to end at the start of this status.
+          await this.updateOneById({
+            id: stateBeforeThis.id!,
+            data: {
+              endsAt: monitorStatusTimelineToBeDeleted.endsAt!,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+          logger.debug("This is the last status.");
+        } else {
+          // This status is in the middle.
+          // Update the previous status to end at the start of this status.
+          await this.updateOneById({
+            id: stateBeforeThis.id!,
+            data: {
+              endsAt: stateAfterThis.startsAt!,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Update the next status to start at the end of this status.
+          await this.updateOneById({
+            id: stateAfterThis.id!,
+            data: {
+              startsAt: monitorStatusTimelineToBeDeleted.startsAt!,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+          logger.debug("This status is in the middle.");
         }
       }
 
@@ -274,7 +375,7 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
             monitorId: monitorId,
           },
           sort: {
-            createdAt: SortOrder.Descending,
+            startsAt: SortOrder.Descending,
           },
           props: {
             isRoot: true,