@oneuptime/common 7.0.3786 → 7.0.3822

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,

package/Server/Services/ScheduledMaintenanceFeedService.ts

@@ -9,6 +9,15 @@ import DatabaseService from "./DatabaseService";
 import Model, {
   ScheduledMaintenanceFeedEventType,
 } from "Common/Models/DatabaseModels/ScheduledMaintenanceFeed";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
+import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
+import WorkspaceUtil from "../Utils/Workspace/Workspace";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
+import WorkspaceMessagePayload from "../../Types/Workspace/WorkspaceMessagePayload";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -28,6 +37,13 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    workspaceNotification?:
+      | {
+          notifyUserId?: ObjectID | undefined; // this is oneuptime user id.
+          sendWorkspaceNotification: boolean;
+          appendMessageBlocks?: Array<MessageBlocksByWorkspaceType> | undefined;
+        }
+      | undefined;
   }): Promise<void> {
     try {
       if (!data.scheduledMaintenanceId) {
@@ -81,6 +97,93 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      try {
+        // send notification to slack and teams
+        if (data.workspaceNotification?.sendWorkspaceNotification) {
+          let messageBlocksByWorkspaceTypes: Array<MessageBlocksByWorkspaceType> =
+            [];
+
+          // use markdown to create blocks
+          messageBlocksByWorkspaceTypes =
+            await WorkspaceUtil.getMessageBlocksByMarkdown({
+              userId: data.workspaceNotification.notifyUserId,
+              markdown: data.feedInfoInMarkdown,
+              projectId: data.projectId,
+            });
+
+          if (data.workspaceNotification.appendMessageBlocks) {
+            for (const messageBlocksByWorkspaceType of data
+              .workspaceNotification.appendMessageBlocks) {
+              const workspaceType: WorkspaceType =
+                messageBlocksByWorkspaceType.workspaceType;
+
+              messageBlocksByWorkspaceTypes
+                .find(
+                  (
+                    messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType,
+                  ) => {
+                    return (
+                      messageBlocksByWorkspaceType.workspaceType ===
+                      workspaceType
+                    );
+                  },
+                )
+                ?.messageBlocks.push(
+                  ...messageBlocksByWorkspaceType.messageBlocks,
+                );
+            }
+          }
+
+          const workspaceNotificationPaylaods: Array<WorkspaceMessagePayload> =
+            [];
+
+          for (const messageBlocksByWorkspaceType of messageBlocksByWorkspaceTypes) {
+            const existingChannels: Array<string> =
+              await WorkspaceNotificationRuleService.getExistingChannelNamesBasedOnEventType(
+                {
+                  projectId: data.projectId,
+                  notificationRuleEventType:
+                    NotificationRuleEventType.ScheduledMaintenance,
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                },
+              );
+
+            const scheduledMaintenanceChannels: Array<WorkspaceChannel> =
+              await ScheduledMaintenanceService.getWorkspaceChannelForScheduledMaintenance(
+                {
+                  scheduledMaintenanceId: data.scheduledMaintenanceId,
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                },
+              );
+
+            const workspaceMessagePayload: WorkspaceMessagePayload = {
+              _type: "WorkspaceMessagePayload",
+              workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+              channelNames: existingChannels,
+              channelIds:
+                scheduledMaintenanceChannels.map(
+                  (channel: WorkspaceChannel) => {
+                    return channel.id;
+                  },
+                ) || [],
+            };
+
+            workspaceNotificationPaylaods.push(workspaceMessagePayload);
+          }
+
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: workspaceNotificationPaylaods,
+          });
+        }
+      } catch (e) {
+        logger.error("Error in sending notification to slack and teams");
+        logger.error(e);
+
+        // we dont throw this error as it is not a critical error
+      }
     } catch (error) {
       logger.error(
         "ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem",

package/Server/Services/ScheduledMaintenanceInternalNoteService.ts

@@ -6,12 +6,34 @@ import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import { Blue500 } from "../../Types/BrandColors";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  public async addNote(data: {
+    userId: ObjectID;
+    scheduledMaintenanceId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.scheduledMaintenanceId = data.scheduledMaintenanceId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
     createdItem: Model,
@@ -19,6 +41,14 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
+    const scheduledMaintenanceId: ObjectID =
+      createdItem.scheduledMaintenanceId!;
+
+    const scheduledMaintenanceNumber: number | null =
+      await ScheduledMaintenanceService.getScheduledMaintenanceNumber({
+        scheduledMaintenanceId: scheduledMaintenanceId,
+      });
+
     await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
       projectId: createdItem.projectId!,
@@ -27,10 +57,14 @@ export class Service extends DatabaseService<Model> {
       displayColor: Blue500,
       userId: userId || undefined,
 
-      feedInfoInMarkdown: `**Posted Internal / Private Note**
-  
+      feedInfoInMarkdown: `📄 posted **private note** for this [Scheduled Maintenance ${scheduledMaintenanceNumber}](${(await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(createdItem.projectId!, scheduledMaintenanceId)).toString()}):
+    
 ${createdItem.note}
-            `,
+              `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -56,6 +90,9 @@ ${createdItem.note}
           createdByUser: {
             _id: true,
           },
+          scheduledMaintenance: {
+            scheduledMaintenanceNumber: true,
+          },
         },
       });
 
@@ -63,6 +100,9 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
+        const scheduledMaintenance: ScheduledMaintenance =
+          updatedItem.scheduledMaintenance!;
+
         await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
           {
             scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
@@ -72,10 +112,14 @@ ${createdItem.note}
             displayColor: Blue500,
             userId: userId || undefined,
 
-            feedInfoInMarkdown: `**Updated Private Note**
-      
+            feedInfoInMarkdown: `📄 updated **Private Note** for this [Scheduled Maintenance ${scheduledMaintenance.scheduledMaintenanceNumber}](${(await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(scheduledMaintenance.projectId!, scheduledMaintenance.id!)).toString()})
+        
 ${updatedItem.note}
-                `,
+                  `,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
           },
         );
       }

package/Server/Services/ScheduledMaintenanceOwnerTeamService.ts

@@ -8,6 +8,11 @@ import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/S
 import { Gray500, Red500 } from "../../Types/BrandColors";
 import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DeleteBy from "../Types/Database/DeleteBy";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import logger from "../Utils/Logger";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -123,6 +128,38 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: projectId!,
+          notificationFor: {
+            scheduledMaintenanceId: scheduledMaintenanceId,
+          },
+          notificationRuleEventType:
+            NotificationRuleEventType.ScheduledMaintenance,
+        },
+      );
+
+    logger.debug(`Notification Rules for ScheduledMaintenance Owner Teams`);
+    logger.debug(notificationRules);
+
+    WorkspaceNotificationRuleService.inviteTeamsBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels:
+          await ScheduledMaintenanceService.getWorkspaceChannelForScheduledMaintenance(
+            {
+              scheduledMaintenanceId: scheduledMaintenanceId!,
+            },
+          ),
+        teamIds: [teamId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }