@oneuptime/common 7.0.3517 → 7.0.3526

package/Server/Services/ScheduledMaintenanceFeedService.ts

@@ -4,6 +4,7 @@ import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger from "../Utils/Logger";
 import DatabaseService from "./DatabaseService";
 import Model, {
   ScheduledMaintenanceFeedEventType,
@@ -27,56 +28,66 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
-  }): Promise<Model> {
-    if (!data.scheduledMaintenanceId) {
-      throw new BadDataException("Scheduled Maintenance ID is required");
-    }
+  }): Promise<void> {
+    try {
+      if (!data.scheduledMaintenanceId) {
+        throw new BadDataException("Scheduled Maintenance ID is required");
+      }
 
-    if (!data.feedInfoInMarkdown) {
-      throw new BadDataException("Log in markdown is required");
-    }
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
 
-    if (!data.scheduledMaintenanceFeedEventType) {
-      throw new BadDataException("Scheduled Maintenance log event is required");
-    }
+      if (!data.scheduledMaintenanceFeedEventType) {
+        throw new BadDataException(
+          "Scheduled Maintenance log event is required",
+        );
+      }
 
-    if (!data.projectId) {
-      throw new BadDataException("Project ID is required");
-    }
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
 
-    if (!data.displayColor) {
-      data.displayColor = Blue500;
-    }
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
 
-    const scheduledMaintenanceFeed: Model = new Model();
+      const scheduledMaintenanceFeed: Model = new Model();
 
-    scheduledMaintenanceFeed.displayColor = data.displayColor;
-    scheduledMaintenanceFeed.scheduledMaintenanceId =
-      data.scheduledMaintenanceId;
-    scheduledMaintenanceFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
-    scheduledMaintenanceFeed.scheduledMaintenanceFeedEventType =
-      data.scheduledMaintenanceFeedEventType;
-    scheduledMaintenanceFeed.projectId = data.projectId;
+      scheduledMaintenanceFeed.displayColor = data.displayColor;
+      scheduledMaintenanceFeed.scheduledMaintenanceId =
+        data.scheduledMaintenanceId;
+      scheduledMaintenanceFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      scheduledMaintenanceFeed.scheduledMaintenanceFeedEventType =
+        data.scheduledMaintenanceFeedEventType;
+      scheduledMaintenanceFeed.projectId = data.projectId;
 
-    if (data.userId) {
-      scheduledMaintenanceFeed.userId = data.userId;
-    }
+      if (data.userId) {
+        scheduledMaintenanceFeed.userId = data.userId;
+      }
 
-    if (data.moreInformationInMarkdown) {
-      scheduledMaintenanceFeed.moreInformationInMarkdown =
-        data.moreInformationInMarkdown;
-    }
+      if (data.moreInformationInMarkdown) {
+        scheduledMaintenanceFeed.moreInformationInMarkdown =
+          data.moreInformationInMarkdown;
+      }
 
-    if (!data.postedAt) {
-      scheduledMaintenanceFeed.postedAt = OneUptimeDate.getCurrentDate();
-    }
+      if (!data.postedAt) {
+        scheduledMaintenanceFeed.postedAt = OneUptimeDate.getCurrentDate();
+      }
 
-    return await this.create({
-      data: scheduledMaintenanceFeed,
-      props: {
-        isRoot: true,
-      },
-    });
+      await this.create({
+        data: scheduledMaintenanceFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (error) {
+      logger.error(
+        "ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed",
+      );
+      logger.error(error);
+      // we dont want to throw the error here, as this is not critical but we still log it.
+    }
   }
 }
 

package/Server/Services/ScheduledMaintenanceInternalNoteService.ts

@@ -1,10 +1,85 @@
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceInternalNote";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Blue500 } from "../../Types/BrandColors";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+      scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
+      projectId: createdItem.projectId!,
+      scheduledMaintenanceFeedEventType:
+        ScheduledMaintenanceFeedEventType.PrivateNote,
+      displayColor: Blue500,
+      userId: userId || undefined,
+
+      feedInfoInMarkdown: `**Posted Internal / Private Note**
+  
+${createdItem.note}
+            `,
+    });
+
+    return createdItem;
+  }
+
+  public override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (onUpdate.updateBy.data.note) {
+      const updatedItems: Array<Model> = await this.findBy({
+        query: onUpdate.updateBy.query,
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          scheduledMaintenanceId: true,
+          projectId: true,
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+          scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
+          projectId: updatedItem.projectId!,
+          scheduledMaintenanceFeedEventType:
+            ScheduledMaintenanceFeedEventType.PrivateNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+
+          feedInfoInMarkdown: `**Updated Private Note**
+      
+${updatedItem.note}
+                `,
+        });
+      }
+    }
+    return onUpdate;
+  }
 }
 
 export default new Service();

package/Server/Services/ScheduledMaintenanceOwnerTeamService.ts

@@ -1,10 +1,126 @@
+import Team from "../../Models/DatabaseModels/Team";
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceOwnerTeam";
+import TeamService from "./TeamService";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        scheduledMaintenanceId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const scheduledMaintenanceId: ObjectID | undefined =
+        item.scheduledMaintenanceId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (scheduledMaintenanceId && teamId && projectId) {
+        const team: Team | null = await TeamService.findOneById({
+          id: teamId,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (team && team.name) {
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            projectId: projectId,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.OwnerTeamRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**Team ${team.name}** was removed from the scheduled maintenance as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add scheduledMaintenance feed.
+
+    const scheduledMaintenanceId: ObjectID | undefined =
+      createdItem.scheduledMaintenanceId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (scheduledMaintenanceId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+          scheduledMaintenanceId: scheduledMaintenanceId,
+          projectId: projectId,
+          scheduledMaintenanceFeedEventType:
+            ScheduledMaintenanceFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**Team ${team.name}** was added to the scheduled maintenance as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/ScheduledMaintenanceOwnerUserService.ts

@@ -1,10 +1,128 @@
+import User from "../../Models/DatabaseModels/User";
+import ObjectID from "../../Types/ObjectID";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceOwnerUser";
+import UserService from "./UserService";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        scheduledMaintenanceId: true,
+        projectId: true,
+        userId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const scheduledMaintenanceId: ObjectID | undefined =
+        item.scheduledMaintenanceId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (scheduledMaintenanceId && userId && projectId) {
+        const user: User | null = await UserService.findOneById({
+          id: userId,
+          select: {
+            name: true,
+            email: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (user && user.name) {
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            projectId: projectId,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.OwnerUserRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the scheduled maintenance as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add scheduledMaintenance feed.
+
+    const scheduledMaintenanceId: ObjectID | undefined =
+      createdItem.scheduledMaintenanceId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (scheduledMaintenanceId && userId && projectId) {
+      const user: User | null = await UserService.findOneById({
+        id: userId,
+        select: {
+          name: true,
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (user && user.name) {
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+          scheduledMaintenanceId: scheduledMaintenanceId,
+          projectId: projectId,
+          scheduledMaintenanceFeedEventType:
+            ScheduledMaintenanceFeedEventType.OwnerUserAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the scheduled maintenance as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -1,8 +1,13 @@
 import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import Model from "Common/Models/DatabaseModels/ScheduledMaintenancePublicNote";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import ObjectID from "../../Types/ObjectID";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Blue500, Indigo500 } from "../../Types/BrandColors";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -21,6 +26,74 @@ export class Service extends DatabaseService<Model> {
       carryForward: null,
     };
   }
+
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+      scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
+      projectId: createdItem.projectId!,
+      scheduledMaintenanceFeedEventType:
+        ScheduledMaintenanceFeedEventType.PublicNote,
+      displayColor: Indigo500,
+      userId: userId || undefined,
+      feedInfoInMarkdown: `**Posted public note for this scheduled maintenance on status page**
+  
+${createdItem.note}
+            `,
+    });
+
+    return createdItem;
+  }
+
+  public override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (onUpdate.updateBy.data.note) {
+      const updatedItems: Array<Model> = await this.findBy({
+        query: onUpdate.updateBy.query,
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          scheduledMaintenanceId: true,
+          projectId: true,
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+          scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
+          projectId: updatedItem.projectId!,
+          scheduledMaintenanceFeedEventType:
+            ScheduledMaintenanceFeedEventType.PublicNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+
+          feedInfoInMarkdown: `**Updated Public Note**
+    
+${updatedItem.note}
+              `,
+        });
+      }
+    }
+    return onUpdate;
+  }
 }
 
 export default new Service();

package/Server/Services/ScheduledMaintenanceService.ts

@@ -47,6 +47,9 @@ import Hostname from "../../Types/API/Hostname";
 import Protocol from "../../Types/API/Protocol";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -439,6 +442,29 @@ export class Service extends DatabaseService<Model> {
   ): Promise<Model> {
     // create new scheduled maintenance state timeline.
 
+    const createdByUserId: ObjectID | undefined | null =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+      scheduledMaintenanceId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      scheduledMaintenanceFeedEventType:
+        ScheduledMaintenanceFeedEventType.ScheduledMaintenanceCreated,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Scheduled Maintenance Created**: 
+          
+**Scheduled Maintenance Title**:
+
+${createdItem.title || "No title provided."}
+
+**Description**:
+
+${createdItem.description || "No description provided."}
+    
+          `,
+      userId: createdByUserId || undefined,
+    });
+
     const timeline: ScheduledMaintenanceStateTimeline =
       new ScheduledMaintenanceStateTimeline();
     timeline.projectId = createdItem.projectId!;
@@ -664,6 +690,48 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    if (updatedItemIds.length > 0) {
+      for (const scheduledMaintenanceId of updatedItemIds) {
+        if (onUpdate.updateBy.data.title) {
+          // add scheduledMaintenance feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.ScheduledMaintenanceUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Scheduled Maintenance title was updated.** Here's the new title.
+    
+${onUpdate.updateBy.data.title || "No title provided."}
+              `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.description) {
+          // add scheduledMaintenance feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.ScheduledMaintenanceUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Scheduled Maintenance description was updated.** Here's the new description.
+          
+    ${onUpdate.updateBy.data.description || "No description provided."}
+            `,
+            userId: createdByUserId || undefined,
+          });
+        }
+      }
+    }
+
     return onUpdate;
   }
 

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -23,6 +23,8 @@ import ScheduledMaintenancePublicNote from "Common/Models/DatabaseModels/Schedul
 import ScheduledMaintenanceState from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
 import ScheduledMaintenanceStateTimeline from "Common/Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 
 export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline> {
   public constructor() {
@@ -136,6 +138,34 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
       },
     });
 
+    const scheduledMaintenanceState: ScheduledMaintenanceState | null =
+      await ScheduledMaintenanceStateService.findOneBy({
+        query: {
+          _id: createdItem.scheduledMaintenanceStateId.toString()!,
+        },
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          color: true,
+          name: true,
+        },
+      });
+
+    const stateName: string = scheduledMaintenanceState?.name || "";
+
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+      scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
+      projectId: createdItem.projectId!,
+      scheduledMaintenanceFeedEventType:
+        ScheduledMaintenanceFeedEventType.ScheduledMaintenanceStateChanged,
+      displayColor: scheduledMaintenanceState?.color,
+      feedInfoInMarkdown:
+        "**Scheduled Maintenance State** changed to **" + stateName + "**",
+      userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+    });
+
     // TODO: DELETE THIS WHEN WORKFLOW IS IMPLEMENMTED.
     // check if this is resolved state, and if it is then resolve all the monitors.