@oneuptime/common 7.0.3822 → 7.0.3827

package/Server/Services/IncidentStateTimelineService.ts

@@ -26,7 +26,7 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
   public constructor() {
     super(IncidentStateTimeline);
     if (IsBillingEnabled) {
-      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+      this.hardDeleteItemsOlderThanInDays("startsAt", 120);
     }
   }
 
@@ -91,21 +91,58 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
       }
     }
 
-    const lastIncidentStateTimeline: IncidentStateTimeline | null =
-      await this.findOneBy({
-        query: {
-          incidentId: createBy.data.incidentId,
-        },
-        sort: {
-          createdAt: SortOrder.Descending,
-        },
-        props: {
-          isRoot: true,
-        },
-        select: {
-          _id: true,
-        },
-      });
+    const stateBeforeThis: IncidentStateTimeline | null = await this.findOneBy({
+      query: {
+        incidentId: createBy.data.incidentId,
+        startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
+      },
+      sort: {
+        startsAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        incidentStateId: true,
+        startsAt: true,
+        endsAt: true,
+      },
+    });
+
+    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: IncidentStateTimeline | null = await this.findOneBy({
+      query: {
+        incidentId: createBy.data.incidentId,
+        startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
+      },
+      sort: {
+        startsAt: SortOrder.Ascending,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        incidentStateId: 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);
 
     const publicNote: string | undefined = (
       createBy.miscDataProps as JSONObject | undefined
@@ -121,7 +158,8 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
     return {
       createBy,
       carryForward: {
-        lastIncidentStateTimelineId: lastIncidentStateTimeline?.id || null,
+        statusTimelineBeforeThisStatus: stateBeforeThis || null,
+        statusTimelineAfterThisStatus: stateAfterThis || null,
         publicNote: publicNote,
       },
     };
@@ -138,33 +176,72 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
     if (!createdItem.incidentStateId) {
       throw new BadDataException("incidentStateId is null");
     }
-
     // update the last status as ended.
 
-    if (onCreate.carryForward.lastIncidentStateTimelineId) {
+    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.lastIncidentStateTimelineId!,
+        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,
         },
       });
-    }
 
-    await IncidentService.updateOneBy({
-      query: {
-        _id: createdItem.incidentId?.toString(),
-      },
-      data: {
-        currentIncidentStateId: createdItem.incidentStateId,
-      },
-      props: onCreate.createBy.props,
-    });
+      // 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.");
+    }
 
-    // TODO: DELETE THIS WHEN WORKFLOW IS IMPLEMENMTED.
-    // check if this is resolved state, and if it is then resolve all the monitors.
+    if (!createdItem.endsAt) {
+      await IncidentService.updateOneBy({
+        query: {
+          _id: createdItem.incidentId?.toString(),
+        },
+        data: {
+          currentIncidentStateId: createdItem.incidentStateId,
+        },
+        props: onCreate.createBy.props,
+      });
+    }
 
     const incidentState: IncidentState | null =
       await IncidentStateService.findOneBy({
@@ -291,6 +368,7 @@ ${createdItem.rootCause}`,
           select: {
             incidentId: true,
             startsAt: true,
+            endsAt: true,
           },
           props: {
             isRoot: true,
@@ -310,80 +388,104 @@ ${createdItem.rootCause}`,
           },
         });
 
+        if (!incidentStateTimelineToBeDeleted) {
+          throw new BadDataException("Incident state timeline not found.");
+        }
+
         if (incidentStateTimeline.isOne()) {
           throw new BadDataException(
             "Cannot delete the only state timeline. Incident should have at least one state in its timeline.",
           );
         }
 
-        if (incidentStateTimelineToBeDeleted?.startsAt) {
-          const beforeState: IncidentStateTimeline | null =
-            await this.findOneBy({
-              query: {
-                incidentId: incidentId,
-                startsAt: QueryHelper.lessThan(
-                  incidentStateTimelineToBeDeleted?.startsAt,
-                ),
-              },
-              sort: {
-                createdAt: SortOrder.Descending,
-              },
-              props: {
-                isRoot: true,
-              },
-              select: {
-                _id: true,
-                startsAt: true,
-              },
-            });
-
-          if (beforeState) {
-            const afterState: IncidentStateTimeline | null =
-              await this.findOneBy({
-                query: {
-                  incidentId: incidentId,
-                  startsAt: QueryHelper.greaterThan(
-                    incidentStateTimelineToBeDeleted?.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 state.
+        // 2. This is the last state.
+        // 3. This is in the middle.
+
+        const stateBeforeThis: IncidentStateTimeline | null =
+          await this.findOneBy({
+            query: {
+              _id: QueryHelper.notEquals(deleteBy.query._id as string),
+              incidentId: incidentId,
+              startsAt: QueryHelper.lessThanEqualTo(
+                incidentStateTimelineToBeDeleted.startsAt!,
+              ),
+            },
+            sort: {
+              startsAt: SortOrder.Descending,
+            },
+            props: {
+              isRoot: true,
+            },
+            select: {
+              incidentStateId: true,
+              startsAt: true,
+              endsAt: true,
+            },
+          });
+
+        const stateAfterThis: IncidentStateTimeline | null =
+          await this.findOneBy({
+            query: {
+              incidentId: incidentId,
+              startsAt: QueryHelper.greaterThan(
+                incidentStateTimelineToBeDeleted.startsAt!,
+              ),
+            },
+            sort: {
+              startsAt: SortOrder.Ascending,
+            },
+            props: {
+              isRoot: true,
+            },
+            select: {
+              incidentStateId: true,
+              startsAt: true,
+              endsAt: true,
+            },
+          });
+
+        if (!stateBeforeThis) {
+          // This is the first state, no need to update previous state.
+          logger.debug("This is the first state.");
+        } else if (!stateAfterThis) {
+          // This is the last state.
+          // Update the previous state to end at the end of this state.
+          await this.updateOneById({
+            id: stateBeforeThis.id!,
+            data: {
+              endsAt: incidentStateTimelineToBeDeleted.endsAt!,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+          logger.debug("This is the last state.");
+        } else {
+          // This state is in the middle.
+          // Update the previous state to end at the start of the next state.
+          await this.updateOneById({
+            id: stateBeforeThis.id!,
+            data: {
+              endsAt: stateAfterThis.startsAt!,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Update the next state to start at the start of this state.
+          await this.updateOneById({
+            id: stateAfterThis.id!,
+            data: {
+              startsAt: incidentStateTimelineToBeDeleted.startsAt!,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+          logger.debug("This state is in the middle.");
         }
       }
 
@@ -401,14 +503,14 @@ ${createdItem.rootCause}`,
       // this is incidentId.
       const incidentId: ObjectID = onDelete.carryForward as ObjectID;
 
-      // get last status of this monitor.
+      // get last status of this incident.
       const incidentStateTimeline: IncidentStateTimeline | null =
         await this.findOneBy({
           query: {
             incidentId: incidentId,
           },
           sort: {
-            createdAt: SortOrder.Descending,
+            startsAt: SortOrder.Descending,
           },
           props: {
             isRoot: true,