@oneuptime/common 9.5.2 → 9.5.3

package/Server/Infrastructure/Postgres/SchemaMigrations/1770232207959-MigrationName.ts

@@ -0,0 +1,181 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1770232207959 implements MigrationInterface {
+  public name = "MigrationName1770232207959";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "IncidentEpisodePublicNote" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "incidentEpisodeId" uuid NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, "note" text NOT NULL, "subscriberNotificationStatusOnNoteCreated" character varying NOT NULL DEFAULT 'Pending', "subscriberNotificationStatusMessage" text, "shouldStatusPageSubscribersBeNotifiedOnNoteCreated" boolean NOT NULL DEFAULT true, "isOwnerNotified" boolean NOT NULL DEFAULT false, "postedAt" TIMESTAMP WITH TIME ZONE, "postedFromSlackMessageId" character varying, CONSTRAINT "PK_7ac3241d9cf7bdf5ecac42c9c98" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_46268b7b996f3b8129136d12d2" ON "IncidentEpisodePublicNote" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_885de505291c2f6f4f86b988ca" ON "IncidentEpisodePublicNote" ("incidentEpisodeId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2e0c6dd840bbc05b9a5117f882" ON "IncidentEpisodePublicNote" ("isOwnerNotified") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_784fb865a857417194a37034ed" ON "IncidentEpisodePublicNote" ("postedFromSlackMessageId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "IncidentEpisodePublicNoteFile" ("incidentEpisodePublicNoteId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_546f0c2cf908ebf301fb164a1ed" PRIMARY KEY ("incidentEpisodePublicNoteId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8e439d24c574141d9a66d74fa5" ON "IncidentEpisodePublicNoteFile" ("incidentEpisodePublicNoteId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0dfcd7747b6e55239df9bbaac5" ON "IncidentEpisodePublicNoteFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ADD "showEpisodeOnStatusPage" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" ADD "isVisibleOnStatusPage" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" ADD "declaredAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" ADD "shouldStatusPageSubscribersBeNotifiedOnEpisodeCreated" boolean NOT NULL DEFAULT true`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" ADD "subscriberNotificationStatusOnEpisodeCreated" character varying NOT NULL DEFAULT 'Pending'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" ADD "subscriberNotificationStatusMessage" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "showEpisodesOnStatusPage" boolean NOT NULL DEFAULT true`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeStateTimeline" ADD "shouldStatusPageSubscribersBeNotified" boolean NOT NULL DEFAULT true`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeStateTimeline" ADD "subscriberNotificationStatus" character varying NOT NULL DEFAULT 'Pending'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeStateTimeline" ADD "subscriberNotificationStatusMessage" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9d7bfebab97dc56583df143ae8" ON "IncidentGroupingRule" ("showEpisodeOnStatusPage") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_298e3524e859ddb920c05e1072" ON "IncidentEpisode" ("isVisibleOnStatusPage") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_30d4a06d51be505b6233185906" ON "IncidentEpisode" ("declaredAt") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" ADD CONSTRAINT "FK_46268b7b996f3b8129136d12d21" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" ADD CONSTRAINT "FK_885de505291c2f6f4f86b988ca6" FOREIGN KEY ("incidentEpisodeId") REFERENCES "IncidentEpisode"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" ADD CONSTRAINT "FK_7711bde5254d7c1021bbbb0f944" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" ADD CONSTRAINT "FK_96d88a43c5479b67ddd7c70df16" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNoteFile" ADD CONSTRAINT "FK_8e439d24c574141d9a66d74fa5c" FOREIGN KEY ("incidentEpisodePublicNoteId") REFERENCES "IncidentEpisodePublicNote"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNoteFile" ADD CONSTRAINT "FK_0dfcd7747b6e55239df9bbaac59" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNoteFile" DROP CONSTRAINT "FK_0dfcd7747b6e55239df9bbaac59"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNoteFile" DROP CONSTRAINT "FK_8e439d24c574141d9a66d74fa5c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" DROP CONSTRAINT "FK_96d88a43c5479b67ddd7c70df16"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" DROP CONSTRAINT "FK_7711bde5254d7c1021bbbb0f944"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" DROP CONSTRAINT "FK_885de505291c2f6f4f86b988ca6"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodePublicNote" DROP CONSTRAINT "FK_46268b7b996f3b8129136d12d21"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_30d4a06d51be505b6233185906"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_298e3524e859ddb920c05e1072"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_9d7bfebab97dc56583df143ae8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeStateTimeline" DROP COLUMN "subscriberNotificationStatusMessage"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeStateTimeline" DROP COLUMN "subscriberNotificationStatus"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeStateTimeline" DROP COLUMN "shouldStatusPageSubscribersBeNotified"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "showEpisodesOnStatusPage"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" DROP COLUMN "subscriberNotificationStatusMessage"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" DROP COLUMN "subscriberNotificationStatusOnEpisodeCreated"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" DROP COLUMN "shouldStatusPageSubscribersBeNotifiedOnEpisodeCreated"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" DROP COLUMN "declaredAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" DROP COLUMN "isVisibleOnStatusPage"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" DROP COLUMN "showEpisodeOnStatusPage"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0dfcd7747b6e55239df9bbaac5"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_8e439d24c574141d9a66d74fa5"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentEpisodePublicNoteFile"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_784fb865a857417194a37034ed"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_2e0c6dd840bbc05b9a5117f882"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_885de505291c2f6f4f86b988ca"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_46268b7b996f3b8129136d12d2"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentEpisodePublicNote"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1770237245069-MigrationName.ts

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1770237245069 implements MigrationInterface {
+  public name = "MigrationName1770237245069";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "showEpisodeHistoryInDays" integer NOT NULL DEFAULT '14'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "showEpisodeLabelsOnStatusPage" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "showEpisodeLabelsOnStatusPage"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "showEpisodeHistoryInDays"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -249,6 +249,8 @@ import { MigrationName1769774527481 } from "./1769774527481-MigrationName";
 import { MigrationName1769780297584 } from "./1769780297584-MigrationName";
 import { MigrationName1769802715014 } from "./1769802715014-MigrationName";
 import { MigrationName1770054293299 } from "./1770054293299-MigrationName";
+import { MigrationName1770232207959 } from "./1770232207959-MigrationName";
+import { MigrationName1770237245069 } from "./1770237245069-MigrationName";
 
 export default [
   InitialMigration,
@@ -502,4 +504,6 @@ export default [
   MigrationName1769780297584,
   MigrationName1769802715014,
   MigrationName1770054293299,
+  MigrationName1770232207959,
+  MigrationName1770237245069,
 ];

package/Server/Services/IncidentEpisodePublicNoteService.ts

@@ -0,0 +1,254 @@
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import OneUptimeDate from "../../Types/Date";
+import Model from "../../Models/DatabaseModels/IncidentEpisodePublicNote";
+import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
+import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import { Blue500, Indigo500 } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import IncidentEpisodeService from "./IncidentEpisodeService";
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import File from "../../Models/DatabaseModels/File";
+import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async addNote(data: {
+    userId: ObjectID;
+    incidentEpisodeId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+    attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
+  }): Promise<Model> {
+    const publicNote: Model = new Model();
+    publicNote.createdByUserId = data.userId;
+    publicNote.incidentEpisodeId = data.incidentEpisodeId;
+    publicNote.projectId = data.projectId;
+    publicNote.note = data.note;
+    publicNote.postedAt = OneUptimeDate.getCurrentDate();
+
+    if (data.postedFromSlackMessageId) {
+      publicNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
+    if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
+      publicNote.attachments = data.attachmentFileIds.map(
+        (fileId: ObjectID) => {
+          const file: File = new File();
+          file.id = fileId;
+          return file;
+        },
+      );
+    }
+
+    return this.create({
+      data: publicNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    incidentEpisodeId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        incidentEpisodeId: data.incidentEpisodeId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.data.postedAt) {
+      createBy.data.postedAt = OneUptimeDate.getCurrentDate();
+    }
+
+    // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnNoteCreated
+    if (
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === false
+    ) {
+      createBy.data.subscriberNotificationStatusOnNoteCreated =
+        StatusPageSubscriberNotificationStatus.Skipped;
+      createBy.data.subscriberNotificationStatusMessage =
+        "Notifications skipped as subscribers are not to be notified for this episode note.";
+    } else if (
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === true
+    ) {
+      createBy.data.subscriberNotificationStatusOnNoteCreated =
+        StatusPageSubscriberNotificationStatus.Pending;
+    }
+
+    return {
+      createBy: createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    const incidentEpisodeId: ObjectID = createdItem.incidentEpisodeId!;
+    const projectId: ObjectID = createdItem.projectId!;
+    const episodeNumber: number | null =
+      await IncidentEpisodeService.getEpisodeNumber({
+        episodeId: incidentEpisodeId,
+      });
+
+    const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+      createdItem.id!,
+      "/incident-episode-public-note/attachment",
+    );
+
+    await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+      incidentEpisodeId: createdItem.incidentEpisodeId!,
+      projectId: createdItem.projectId!,
+      incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.PublicNote,
+      displayColor: Indigo500,
+      userId: userId || undefined,
+      feedInfoInMarkdown: `📄 posted **public note** for this [Episode ${episodeNumber}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId!, incidentEpisodeId!)).toString()}) on status page:
+
+${(createdItem.note || "") + attachmentsMarkdown}
+          `,
+    });
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  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: {
+          incidentEpisodeId: true,
+          projectId: true,
+          incidentEpisode: {
+            _id: true,
+            episodeNumber: true,
+            projectId: true,
+          },
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        const episode: IncidentEpisode = updatedItem.incidentEpisode!;
+
+        const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+          updatedItem.id!,
+          "/incident-episode-public-note/attachment",
+        );
+
+        await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+          incidentEpisodeId: updatedItem.incidentEpisodeId!,
+          projectId: updatedItem.projectId!,
+          incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.PublicNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+          feedInfoInMarkdown: `📄 updated **Public Note** for this [Episode ${episode.episodeNumber}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(episode.projectId!, episode.id!)).toString()})
+
+${(updatedItem.note || "") + attachmentsMarkdown}
+                  `,
+        });
+      }
+    }
+    return onUpdate;
+  }
+
+  private async getAttachmentsMarkdown(
+    modelId: ObjectID,
+    attachmentApiPath: string,
+  ): Promise<string> {
+    if (!modelId) {
+      return "";
+    }
+
+    const noteWithAttachments: Model | null = await this.findOneById({
+      id: modelId,
+      select: {
+        attachments: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!noteWithAttachments || !noteWithAttachments.attachments) {
+      return "";
+    }
+
+    const attachmentIds: Array<ObjectID> = noteWithAttachments.attachments
+      .map((file: File) => {
+        if (file.id) {
+          return file.id;
+        }
+
+        if (file._id) {
+          return new ObjectID(file._id);
+        }
+
+        return null;
+      })
+      .filter((id: ObjectID | null): id is ObjectID => {
+        return Boolean(id);
+      });
+
+    if (!attachmentIds.length) {
+      return "";
+    }
+
+    return await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+      modelId,
+      attachmentIds,
+      attachmentApiPath,
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentEpisodeService.ts

@@ -38,6 +38,8 @@ import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
+import IncidentGroupingRuleService from "./IncidentGroupingRuleService";
+import IncidentGroupingRule from "../../Models/DatabaseModels/IncidentGroupingRule";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -135,6 +137,30 @@ export class Service extends DatabaseService<Model> {
         createBy.data.lastIncidentAddedAt = OneUptimeDate.getCurrentDate();
       }
 
+      // Set declaredAt if not provided
+      if (!createBy.data.declaredAt) {
+        createBy.data.declaredAt = OneUptimeDate.getCurrentDate();
+      }
+
+      // Copy showEpisodeOnStatusPage from grouping rule if available
+      if (createBy.data.incidentGroupingRuleId) {
+        const groupingRule: IncidentGroupingRule | null =
+          await IncidentGroupingRuleService.findOneById({
+            id: createBy.data.incidentGroupingRuleId,
+            select: {
+              showEpisodeOnStatusPage: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (groupingRule) {
+          createBy.data.isVisibleOnStatusPage =
+            groupingRule.showEpisodeOnStatusPage ?? true;
+        }
+      }
+
       return { createBy, carryForward: { mutex } };
     } catch (error) {
       // Release the mutex if it was acquired and an error occurred

package/Server/Services/Index.ts

@@ -181,6 +181,7 @@ import IncidentEpisodeRoleMemberService from "./IncidentEpisodeRoleMemberService
 import IncidentEpisodeOwnerTeamService from "./IncidentEpisodeOwnerTeamService";
 import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
 import IncidentEpisodeStateTimelineService from "./IncidentEpisodeStateTimelineService";
+import IncidentEpisodePublicNoteService from "./IncidentEpisodePublicNoteService";
 import AlertGroupingRuleService from "./AlertGroupingRuleService";
 import IncidentSlaRuleService from "./IncidentSlaRuleService";
 import IncidentSlaService from "./IncidentSlaService";
@@ -400,6 +401,7 @@ const services: Array<BaseService> = [
   IncidentEpisodeOwnerTeamService,
   IncidentEpisodeOwnerUserService,
   IncidentEpisodeStateTimelineService,
+  IncidentEpisodePublicNoteService,
   AlertGroupingRuleService,
   IncidentSlaRuleService,
   IncidentSlaService,

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -242,6 +242,12 @@ export default class MonitorIncident {
 
         incident.isCreatedAutomatically = true;
 
+        // Set status page visibility (defaults to true if not specified)
+        if (criteriaIncident.showIncidentOnStatusPage !== undefined) {
+          incident.isVisibleOnStatusPage =
+            criteriaIncident.showIncidentOnStatusPage;
+        }
+
         if (input.props.telemetryQuery) {
           incident.telemetryQuery = input.props.telemetryQuery;
         }

package/Types/Email/EmailTemplateType.ts

@@ -53,6 +53,10 @@ enum EmailTemplateType {
   IncidentEpisodeOwnerNotePosted = "IncidentEpisodeOwnerNotePosted.hbs",
   IncidentEpisodeOwnerResourceCreated = "IncidentEpisodeOwnerResourceCreated.hbs",
 
+  SubscriberEpisodeCreated = "SubscriberEpisodeCreated.hbs",
+  SubscriberEpisodeStateChanged = "SubscriberEpisodeStateChanged.hbs",
+  SubscriberEpisodeNoteCreated = "SubscriberEpisodeNoteCreated.hbs",
+
   ScheduledMaintenanceOwnerNotePosted = "ScheduledMaintenanceOwnerNotePosted.hbs",
   ScheduledMaintenanceOwnerAdded = "ScheduledMaintenanceOwnerAdded.hbs",
   ScheduledMaintenanceOwnerStateChanged = "ScheduledMaintenanceOwnerStateChanged.hbs",