@oneuptime/common 8.0.5129 → 8.0.5142

package/Models/DatabaseModels/IncidentTemplate.ts

@@ -716,6 +716,77 @@ export default class IncidentTemplate extends BaseModel {
   })
   public changeMonitorStatusToId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentTemplate,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "initialIncidentStateId",
+    type: TableColumnType.Entity,
+    modelType: IncidentState,
+    title: "Initial Incident State",
+    description:
+      "Relation to Incident State Object. Incidents created from this template will start in this state.",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentState;
+    },
+    {
+      eager: false,
+      nullable: true,
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "initialIncidentStateId" })
+  public initialIncidentState?: IncidentState = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditIncidentTemplate,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    title: "Initial Incident State ID",
+    description:
+      "Relation to Incident State Object ID. Incidents created from this template will start in this state.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public initialIncidentStateId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

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

@@ -0,0 +1,41 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1757416939595 implements MigrationInterface {
+  public name = "MigrationName1757416939595";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentTemplate" ADD "initialIncidentStateId" uuid`,
+    );
+    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_36317c99429a40d3344d838223" ON "IncidentTemplate" ("initialIncidentStateId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentTemplate" ADD CONSTRAINT "FK_36317c99429a40d3344d838223f" FOREIGN KEY ("initialIncidentStateId") REFERENCES "IncidentState"("_id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentTemplate" DROP CONSTRAINT "FK_36317c99429a40d3344d838223f"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_36317c99429a40d3344d838223"`,
+    );
+    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 "IncidentTemplate" DROP COLUMN "initialIncidentStateId"`,
+    );
+  }
+}

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

@@ -165,6 +165,7 @@ import { MigrationName1756293325324 } from "./1756293325324-MigrationName";
 import { MigrationName1756296282627 } from "./1756296282627-MigrationName";
 import { MigrationName1756300358095 } from "./1756300358095-MigrationName";
 import { MigrationName1756821449686 } from "./1756821449686-MigrationName";
+import { MigrationName1757416939595 } from "./1757416939595-MigrationName";
 
 export default [
   InitialMigration,
@@ -334,4 +335,5 @@ export default [
   MigrationName1756296282627,
   MigrationName1756300358095,
   MigrationName1756821449686,
+  MigrationName1757416939595,
 ];

package/Server/Services/IncidentService.ts

@@ -64,6 +64,8 @@ import MetricType from "../../Models/DatabaseModels/MetricType";
 import UpdateBy from "../Types/Database/UpdateBy";
 import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
 import Dictionary from "../../Types/Dictionary";
+import IncidentTemplateService from "./IncidentTemplateService";
+import IncidentTemplate from "../../Models/DatabaseModels/IncidentTemplate";
 
 // key is incidentId for this dictionary.
 type UpdateCarryForward = Dictionary<{
@@ -466,24 +468,97 @@ export class Service extends DatabaseService<Model> {
     const projectId: ObjectID =
       createBy.props.tenantId || createBy.data.projectId!;
 
-    const incidentState: IncidentState | null =
-      await IncidentStateService.findOneBy({
-        query: {
-          projectId: projectId,
-          isCreatedState: true,
-        },
-        select: {
-          _id: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
+    // Determine the initial incident state
+    let initialIncidentStateId: ObjectID | undefined = undefined;
 
-    if (!incidentState || !incidentState.id) {
-      throw new BadDataException(
-        "Created incident state not found for this project. Please add created incident state from settings.",
-      );
+    // If currentIncidentStateId is already provided (manual selection), use it
+    if (createBy.data.currentIncidentStateId) {
+      initialIncidentStateId = createBy.data.currentIncidentStateId;
+
+      // Validate that the provided state exists and belongs to the project
+      const providedState: IncidentState | null =
+        await IncidentStateService.findOneBy({
+          query: {
+            _id: initialIncidentStateId.toString(),
+            projectId: projectId,
+          },
+          select: {
+            _id: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!providedState) {
+        throw new BadDataException(
+          "Invalid incident state provided. The state does not exist or does not belong to this project.",
+        );
+      }
+    } else if (createBy.data.createdIncidentTemplateId) {
+      // If created from a template, check if template has a custom initial state
+      const incidentTemplate: IncidentTemplate | null =
+        await IncidentTemplateService.findOneBy({
+          query: {
+            _id: createBy.data.createdIncidentTemplateId.toString(),
+            projectId: projectId,
+          },
+          select: {
+            initialIncidentStateId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (incidentTemplate?.initialIncidentStateId) {
+        initialIncidentStateId = incidentTemplate.initialIncidentStateId;
+
+        // Validate that the template's state exists and belongs to the project
+        const templateState: IncidentState | null =
+          await IncidentStateService.findOneBy({
+            query: {
+              _id: initialIncidentStateId.toString(),
+              projectId: projectId,
+            },
+            select: {
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (!templateState) {
+          // Fall back to default if template state is invalid
+          initialIncidentStateId = undefined;
+        }
+      }
+    }
+
+    // If no custom state is provided or found, fall back to default created state
+    if (!initialIncidentStateId) {
+      const incidentState: IncidentState | null =
+        await IncidentStateService.findOneBy({
+          query: {
+            projectId: projectId,
+            isCreatedState: true,
+          },
+          select: {
+            _id: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!incidentState || !incidentState.id) {
+        throw new BadDataException(
+          "Created incident state not found for this project. Please add created incident state from settings.",
+        );
+      }
+
+      initialIncidentStateId = incidentState.id;
     }
 
     let mutex: SemaphoreMutex | null = null;
@@ -517,7 +592,7 @@ export class Service extends DatabaseService<Model> {
         projectId: projectId,
       })) + 1;
 
-    createBy.data.currentIncidentStateId = incidentState.id;
+    createBy.data.currentIncidentStateId = initialIncidentStateId;
     createBy.data.incidentNumber = incidentNumberForThisIncident;
 
     if (

package/Server/Services/ScheduledMaintenanceService.ts

@@ -261,7 +261,7 @@ export class Service extends DatabaseService<Model> {
           if (subscriber.slackIncomingWebhookUrl) {
             const slackMessage: string = `## 🔧 Scheduled Maintenance - ${event.title || ""}
 
-**Scheduled Date:** ${OneUptimeDate.getDateAsFormattedString(event.startsAt!)}
+**Scheduled Date:** ${OneUptimeDate.getDateAsUserFriendlyFormattedString(event.startsAt!)}
 
 ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
 
@@ -305,6 +305,7 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                     OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
                       date: event.startsAt!,
                       timezones: statuspage.subscriberTimezones || [],
+                      use12HourFormat: true,
                     }),
                   eventTitle: event.title || "",
                   eventDescription: await Markdown.convertToHTML(
@@ -769,11 +770,11 @@ ${scheduledMaintenance.description || "No description provided."}
 
       // add starts at and ends at.
       if (scheduledMaintenance.startsAt) {
-        feedInfoInMarkdown += `**Starts At**: ${OneUptimeDate.getDateAsLocalFormattedString(scheduledMaintenance.startsAt)} \n\n`;
+        feedInfoInMarkdown += `**Starts At**: ${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(scheduledMaintenance.startsAt)} \n\n`;
       }
 
       if (scheduledMaintenance.endsAt) {
-        feedInfoInMarkdown += `**Ends At**: ${OneUptimeDate.getDateAsLocalFormattedString(scheduledMaintenance.endsAt)} \n\n`;
+        feedInfoInMarkdown += `**Ends At**: ${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(scheduledMaintenance.endsAt)} \n\n`;
       }
 
       if (scheduledMaintenance.currentScheduledMaintenanceState?.name) {
@@ -1064,7 +1065,7 @@ ${onUpdate.updateBy.data.title || "No title provided."}
           // add scheduledMaintenance feed.
 
           feedInfoInMarkdown += `\n\n**Starts At**: 
-${OneUptimeDate.getDateAsLocalFormattedString(onUpdate.updateBy.data.startsAt as Date) || "No title provided."}
+${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(onUpdate.updateBy.data.startsAt as Date) || "No title provided."}
 `;
           shouldAddScheduledMaintenanceFeed = true;
         }
@@ -1073,7 +1074,7 @@ ${OneUptimeDate.getDateAsLocalFormattedString(onUpdate.updateBy.data.startsAt as
           // add scheduledMaintenance feed.
 
           feedInfoInMarkdown += `\n\n**Ends At**:
-${OneUptimeDate.getDateAsLocalFormattedString(onUpdate.updateBy.data.endsAt as Date) || "No title provided."}
+${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(onUpdate.updateBy.data.endsAt as Date) || "No title provided."}
 `;
           shouldAddScheduledMaintenanceFeed = true;
         }

package/Server/Services/StatusPageService.ts

@@ -877,7 +877,7 @@ export class Service extends DatabaseService<StatusPage> {
 
     const endDate: Date = OneUptimeDate.getCurrentDate();
     const startDate: Date = OneUptimeDate.getSomeDaysAgo(numberOfDays);
-    const startAndEndDate: string = `${numberOfDays} days (${OneUptimeDate.getDateAsLocalFormattedString(startDate, true)} - ${OneUptimeDate.getDateAsLocalFormattedString(endDate, true)})`;
+    const startAndEndDate: string = `${numberOfDays} days (${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(startDate, true)} - ${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(endDate, true)})`;
 
     if (statusPageResources.length === 0) {
       return {

package/Tests/UI/Components/MarkdownEditor.test.tsx

@@ -1,9 +1,55 @@
 import React from "react";
 import MarkdownEditor from "../../../UI/Components/Markdown.tsx/MarkdownEditor";
-import { render, screen } from "@testing-library/react";
+import { render, screen, fireEvent } from "@testing-library/react";
 import { describe, expect, test } from "@jest/globals";
 
-describe("MarkdownEditor with SpellCheck", () => {
+describe("MarkdownEditor", () => {
+  test("should render with toolbar buttons", () => {
+    render(
+      <MarkdownEditor
+        initialValue="This is a test"
+        placeholder="Enter markdown here..."
+      />,
+    );
+
+    // Check for toolbar buttons
+    expect(screen.getByTitle("Bold (Ctrl+B)")).toBeInTheDocument();
+    expect(screen.getByTitle("Italic (Ctrl+I)")).toBeInTheDocument();
+    expect(screen.getByTitle("Underline")).toBeInTheDocument();
+    expect(screen.getByTitle("Strikethrough")).toBeInTheDocument();
+    expect(screen.getByTitle("Heading 1")).toBeInTheDocument();
+    expect(screen.getByTitle("Heading 2")).toBeInTheDocument();
+    expect(screen.getByTitle("Heading 3")).toBeInTheDocument();
+    expect(screen.getByTitle("Bullet List")).toBeInTheDocument();
+    expect(screen.getByTitle("Numbered List")).toBeInTheDocument();
+    expect(screen.getByTitle("Task List")).toBeInTheDocument();
+    expect(screen.getByTitle("Link")).toBeInTheDocument();
+    expect(screen.getByTitle("Image")).toBeInTheDocument();
+    expect(screen.getByTitle("Table")).toBeInTheDocument();
+    expect(screen.getByTitle("Code")).toBeInTheDocument();
+    expect(screen.getByTitle("Quote")).toBeInTheDocument();
+    expect(screen.getByTitle("Horizontal Rule")).toBeInTheDocument();
+  });
+
+  test("should toggle preview mode", () => {
+    render(
+      <MarkdownEditor
+        initialValue="**bold text**"
+        placeholder="Enter markdown here..."
+      />,
+    );
+
+    const previewButton: HTMLElement = screen.getByText("Preview");
+    fireEvent.click(previewButton);
+
+    // Should show preview
+    expect(screen.getByText("Write")).toBeInTheDocument();
+
+    // Click to go back to write mode
+    fireEvent.click(screen.getByText("Write"));
+    expect(screen.getByText("Preview")).toBeInTheDocument();
+  });
+
   test("should enable spell check by default", () => {
     render(
       <MarkdownEditor
@@ -18,6 +64,21 @@ describe("MarkdownEditor with SpellCheck", () => {
     expect(textarea.spellcheck).toBe(true);
   });
 
+  test("should enable spell check when disableSpellCheck is undefined", () => {
+    render(
+      <MarkdownEditor
+        initialValue="This is a test with spelling errors"
+        placeholder="Enter markdown here..."
+        disableSpellCheck={undefined}
+      />,
+    );
+
+    const textarea: HTMLTextAreaElement = screen.getByRole(
+      "textbox",
+    ) as HTMLTextAreaElement;
+    expect(textarea.spellcheck).toBe(true);
+  });
+
   test("should disable spell check when disableSpellCheck is true", () => {
     render(
       <MarkdownEditor
@@ -58,4 +119,28 @@ describe("MarkdownEditor with SpellCheck", () => {
     textarea = screen.getByRole("textbox") as HTMLTextAreaElement;
     expect(textarea.spellcheck).toBe(false);
   });
+
+  test("should show help text", () => {
+    render(
+      <MarkdownEditor initialValue="" placeholder="Enter markdown here..." />,
+    );
+
+    expect(screen.getByText("Markdown help")).toBeInTheDocument();
+  });
+
+  test("should handle onChange callback", () => {
+    const mockOnChange: jest.Mock = jest.fn();
+    render(
+      <MarkdownEditor
+        initialValue=""
+        placeholder="Enter markdown here..."
+        onChange={mockOnChange}
+      />,
+    );
+
+    const textarea: HTMLElement = screen.getByRole("textbox");
+    fireEvent.change(textarea, { target: { value: "new text" } });
+
+    expect(mockOnChange).toHaveBeenCalledWith("new text");
+  });
 });

package/Types/Date.ts

@@ -201,12 +201,19 @@ export default class OneUptimeDate {
     return this.secondsToFormattedFriendlyTimeString(seconds);
   }
 
-  public static toTimeString(date: Date | string): string {
+  public static toTimeString(
+    date: Date | string,
+    use12HourFormat?: boolean,
+  ): string {
     if (typeof date === "string") {
       date = this.fromString(date);
     }
 
-    return moment(date).format("HH:mm");
+    const format: "hh:mm A" | "HH:mm" =
+      use12HourFormat || this.getUserPrefers12HourFormat()
+        ? "hh:mm A"
+        : "HH:mm";
+    return moment(date).format(format);
   }
 
   public static isSame(date1: Date, date2: Date): boolean {
@@ -879,23 +886,72 @@ export default class OneUptimeDate {
   public static getCurrentDateAsFormattedString(options?: {
     onlyShowDate?: boolean;
     showSeconds?: boolean;
+    use12HourFormat?: boolean;
   }): string {
     return this.getDateAsFormattedString(new Date(), options);
   }
 
+  public static getUserPrefers12HourFormat(): boolean {
+    if (typeof window === "undefined") {
+      // Server-side: default to 12-hour format for user-friendly display
+      return true;
+    }
+
+    // Client-side: detect user's preferred time format from browser locale
+    const testDate: Date = new Date();
+    const timeString: string = testDate.toLocaleTimeString();
+    return (
+      timeString.toLowerCase().includes("am") ||
+      timeString.toLowerCase().includes("pm")
+    );
+  }
+
+  public static getDateAsUserFriendlyFormattedString(
+    date: string | Date,
+    options?: {
+      onlyShowDate?: boolean;
+      showSeconds?: boolean;
+    },
+  ): string {
+    return this.getDateAsFormattedString(date, {
+      ...options,
+      use12HourFormat: this.getUserPrefers12HourFormat(),
+    });
+  }
+
+  public static getDateAsUserFriendlyLocalFormattedString(
+    date: string | Date,
+    onlyShowDate?: boolean,
+  ): string {
+    return this.getDateAsLocalFormattedString(
+      date,
+      onlyShowDate,
+      this.getUserPrefers12HourFormat(),
+    );
+  }
+
   public static getDateAsFormattedString(
     date: string | Date,
     options?: {
       onlyShowDate?: boolean;
       showSeconds?: boolean;
+      use12HourFormat?: boolean;
     },
   ): string {
     date = this.fromString(date);
 
     let formatstring: string = "MMM DD YYYY, HH:mm";
 
+    if (options?.use12HourFormat) {
+      formatstring = "MMM DD YYYY, hh:mm A";
+    }
+
     if (options?.showSeconds) {
-      formatstring = "MMM DD YYYY, HH:mm:ss";
+      if (options?.use12HourFormat) {
+        formatstring = "MMM DD YYYY, hh:mm:ss A";
+      } else {
+        formatstring = "MMM DD YYYY, HH:mm:ss";
+      }
     }
 
     if (options?.onlyShowDate) {
@@ -1061,15 +1117,22 @@ export default class OneUptimeDate {
     date: string | Date;
     onlyShowDate?: boolean | undefined;
     timezones?: Array<Timezone> | undefined;
+    use12HourFormat?: boolean | undefined;
   }): Array<string> {
     let date: string | Date = data.date;
     const onlyShowDate: boolean | undefined = data.onlyShowDate;
     let timezones: Array<Timezone> | undefined = data.timezones;
+    const use12HourFormat: boolean =
+      data.use12HourFormat ?? this.getUserPrefers12HourFormat();
 
     date = this.fromString(date);
 
     let formatstring: string = "MMM DD YYYY, HH:mm";
 
+    if (use12HourFormat) {
+      formatstring = "MMM DD YYYY, hh:mm A";
+    }
+
     if (onlyShowDate) {
       formatstring = "MMM DD, YYYY";
     }
@@ -1106,15 +1169,18 @@ export default class OneUptimeDate {
     date: string | Date;
     onlyShowDate?: boolean;
     timezones?: Array<Timezone> | undefined; // if this is skipped, then it will show the default timezones in the order of UTC, EST, PST, IST, ACT
+    use12HourFormat?: boolean | undefined;
   }): string {
     const date: string | Date = data.date;
     const onlyShowDate: boolean | undefined = data.onlyShowDate;
     const timezones: Array<Timezone> | undefined = data.timezones;
+    const use12HourFormat: boolean | undefined = data.use12HourFormat;
 
     return this.getDateAsFormattedArrayInMultipleTimezones({
       date,
       onlyShowDate,
       timezones,
+      use12HourFormat,
     }).join("<br/>");
   }
 
@@ -1122,26 +1188,34 @@ export default class OneUptimeDate {
     date: string | Date;
     onlyShowDate?: boolean | undefined;
     timezones?: Array<Timezone> | undefined; // if this is skipped, then it will show the default timezones in the order of UTC, EST, PST, IST, ACT
+    use12HourFormat?: boolean | undefined;
   }): string {
     const date: string | Date = data.date;
     const onlyShowDate: boolean | undefined = data.onlyShowDate;
     const timezones: Array<Timezone> | undefined = data.timezones;
+    const use12HourFormat: boolean | undefined = data.use12HourFormat;
 
     return this.getDateAsFormattedArrayInMultipleTimezones({
       date,
       onlyShowDate,
       timezones,
+      use12HourFormat,
     }).join("\n");
   }
 
   public static getDateAsLocalFormattedString(
     date: string | Date,
     onlyShowDate?: boolean,
+    use12HourFormat?: boolean,
   ): string {
     date = this.fromString(date);
 
     let formatstring: string = "MMM DD YYYY, HH:mm";
 
+    if (use12HourFormat) {
+      formatstring = "MMM DD YYYY, hh:mm A";
+    }
+
     if (onlyShowDate) {
       formatstring = "MMM DD, YYYY";
     }

package/UI/Components/Date/RangeStartAndEndDateView.tsx

@@ -29,10 +29,10 @@ const DashboardStartAndEndDateView: FunctionComponent<ComponentProps> = (
 
   const getContent: GetReactElementFunction = (): ReactElement => {
     const title: string = isCustomRange
-      ? `${OneUptimeDate.getDateAsLocalFormattedString(
+      ? `${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
           props.dashboardStartAndEndDate.startAndEndDate?.startValue ||
             OneUptimeDate.getCurrentDate(),
-        )} - ${OneUptimeDate.getDateAsLocalFormattedString(
+        )} - ${OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
           props.dashboardStartAndEndDate.startAndEndDate?.endValue ||
             OneUptimeDate.getCurrentDate(),
         )}`

package/UI/Components/Detail/Detail.tsx

@@ -178,7 +178,7 @@ const Detail: DetailFunction = <T extends GenericObject>(
 
     if (field.fieldType === FieldType.Date) {
       if (data) {
-        data = OneUptimeDate.getDateAsLocalFormattedString(
+        data = OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
           data as string,
           true,
         );
@@ -197,7 +197,7 @@ const Detail: DetailFunction = <T extends GenericObject>(
 
     if (field.fieldType === FieldType.DateTime) {
       if (data) {
-        data = OneUptimeDate.getDateAsLocalFormattedString(
+        data = OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
           data as string,
           false,
         );

package/UI/Components/EventHistoryList/EventHistoryDayList.tsx

@@ -55,7 +55,10 @@ const EventHistoryDayList: FunctionComponent<ComponentProps> = (
           width: isMobile ? "100%" : "15%",
         }}
       >
-        {OneUptimeDate.getDateAsLocalFormattedString(props.date, true)}
+        {OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
+          props.date,
+          true,
+        )}
       </div>
       <div
         style={{

package/UI/Components/EventItem/EventItem.tsx

@@ -224,7 +224,7 @@ const EventItem: FunctionComponent<ComponentProps> = (
                             </div>
                             <div>
                               <span className="text-sm leading-8 text-gray-500 whitespace-nowrap">
-                                {OneUptimeDate.getDateAsLocalFormattedString(
+                                {OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
                                   item.date,
                                 )}
                               </span>
@@ -269,7 +269,7 @@ const EventItem: FunctionComponent<ComponentProps> = (
                               </div>
                               <p className="mt-0.5 text-sm text-gray-500">
                                 posted on{" "}
-                                {OneUptimeDate.getDateAsLocalFormattedString(
+                                {OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
                                   item.date,
                                 )}
                               </p>

package/UI/Components/Feed/FeedItem.tsx

@@ -117,7 +117,7 @@ const FeedItem: FunctionComponent<ComponentProps> = (
                 )}
                 <div className="mt-0.5 text-sm text-gray-500 w-fit">
                   <Tooltip
-                    text={OneUptimeDate.getDateAsLocalFormattedString(
+                    text={OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
                       props.itemDateTime,
                     )}
                   >