@oneuptime/common 9.2.12 → 9.2.14

package/Server/Middleware/SlackAuthorization.ts

@@ -37,8 +37,11 @@ export default class SlackAuthorization {
     const timestamp: string = req.headers[
       "x-slack-request-timestamp"
     ] as string;
+    // Use rawBody for both JSON and URL-encoded requests, fallback to rawFormUrlEncodedBody for backward compatibility
     const requestBody: string =
-      (req as OneUptimeRequest).rawFormUrlEncodedBody || "";
+      (req as OneUptimeRequest).rawBody ||
+      (req as OneUptimeRequest).rawFormUrlEncodedBody ||
+      "";
 
     logger.debug(`slackSignature: ${slackSignature}`);
     logger.debug(`timestamp: ${timestamp}`);

package/Server/Services/AlertInternalNoteService.ts

@@ -24,6 +24,7 @@ export class Service extends DatabaseService<Model> {
     projectId: ObjectID;
     note: string;
     attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
   }): Promise<Model> {
     const internalNote: Model = new Model();
     internalNote.createdByUserId = data.userId;
@@ -31,6 +32,10 @@ export class Service extends DatabaseService<Model> {
     internalNote.projectId = data.projectId;
     internalNote.note = data.note;
 
+    if (data.postedFromSlackMessageId) {
+      internalNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
     if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
       internalNote.attachments = data.attachmentFileIds.map(
         (fileId: ObjectID) => {
@@ -49,6 +54,27 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    alertId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        alertId: data.alertId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
   @CaptureSpan()
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,

package/Server/Services/IncidentInternalNoteService.ts

@@ -24,6 +24,7 @@ export class Service extends DatabaseService<Model> {
     projectId: ObjectID;
     note: string;
     attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
   }): Promise<Model> {
     const internalNote: Model = new Model();
     internalNote.createdByUserId = data.userId;
@@ -31,6 +32,10 @@ export class Service extends DatabaseService<Model> {
     internalNote.projectId = data.projectId;
     internalNote.note = data.note;
 
+    if (data.postedFromSlackMessageId) {
+      internalNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
     if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
       internalNote.attachments = data.attachmentFileIds.map(
         (fileId: ObjectID) => {
@@ -49,6 +54,27 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    incidentId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        incidentId: data.incidentId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
   @CaptureSpan()
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,

package/Server/Services/IncidentPublicNoteService.ts

@@ -27,6 +27,7 @@ export class Service extends DatabaseService<Model> {
     projectId: ObjectID;
     note: string;
     attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
   }): Promise<Model> {
     const publicNote: Model = new Model();
     publicNote.createdByUserId = data.userId;
@@ -35,6 +36,10 @@ export class Service extends DatabaseService<Model> {
     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) => {
@@ -53,6 +58,27 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    incidentId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        incidentId: data.incidentId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
   @CaptureSpan()
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,

package/Server/Services/Index.ts

@@ -11,8 +11,6 @@ import BillingPaymentMethodsService from "./BillingPaymentMethodService";
 import BillingService from "./BillingService";
 import CallLogService from "./CallLogService";
 import CallService from "./CallService";
-import CodeRepositoryService from "./CopilotCodeRepositoryService";
-import CopilotActionService from "./CopilotActionService";
 import DataMigrationService from "./DataMigrationService";
 import DomainService from "./DomainService";
 import EmailLogService from "./EmailLogService";
@@ -33,6 +31,7 @@ import IncidentStateService from "./IncidentStateService";
 import IncidentStateTimelineService from "./IncidentStateTimelineService";
 //Labels.
 import LabelService from "./LabelService";
+import LlmProviderService from "./LlmProviderService";
 import LogService from "./LogService";
 import MailService from "./MailService";
 import MetricService from "./MetricService";
@@ -88,7 +87,6 @@ import ServiceCatalogOwnerUserService from "./ServiceCatalogOwnerUserService";
 import ServiceCatalogService from "./ServiceCatalogService";
 import ServiceCatalogMonitorService from "./ServiceCatalogMonitorService";
 import ServiceCatalogTelemetryServiceService from "./ServiceCatalogTelemetryServiceService";
-import ServiceCopilotCodeRepositoryService from "./ServiceCopilotCodeRepositoryService";
 import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
 import SmsLogService from "./SmsLogService";
@@ -138,11 +136,9 @@ import WorkflowLogService from "./WorkflowLogService";
 import WorkflowService from "./WorkflowService";
 import WorkflowVariablesService from "./WorkflowVariableService";
 import AnalyticsBaseModel from "../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
-import CopilotPullRequestService from "./CopilotPullRequestService";
 import ServiceCatalogDependencyService from "./ServiceCatalogDependencyService";
 import TelemetryExceptionService from "./TelemetryExceptionService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
-import CopilotActionTypePriorityService from "./CopilotActionTypePriorityService";
 import ScheduledMaintenanceTemplateService from "./ScheduledMaintenanceTemplateService";
 import ScheduledMaintenanceTemplateOwnerTeamService from "./ScheduledMaintenanceTemplateOwnerTeamService";
 import ScheduledMaintenanceTemplateOwnerUserService from "./ScheduledMaintenanceTemplateOwnerUserService";
@@ -217,6 +213,7 @@ const services: Array<BaseService> = [
   IncidentFeedService,
 
   LabelService,
+  LlmProviderService,
 
   MailService,
   MonitorCustomFieldService,
@@ -325,12 +322,6 @@ const services: Array<BaseService> = [
   ServiceCatalogMonitorService,
   ServiceCatalogTelemetryServiceService,
 
-  CodeRepositoryService,
-  CopilotActionService,
-  ServiceCopilotCodeRepositoryService,
-  CopilotPullRequestService,
-  CopilotActionTypePriorityService,
-
   TelemetryExceptionService,
 
   // scheduled maintenance templates

package/Server/Services/LlmProviderService.ts

@@ -0,0 +1,100 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LlmProvider";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import ObjectID from "../../Types/ObjectID";
+import UpdateBy from "../Types/Database/UpdateBy";
+import QueryHelper from "../Types/Database/QueryHelper";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    // When creating a new LLM provider, set it as default by default
+    if (createBy.data.isDefault === undefined) {
+      createBy.data.isDefault = true;
+    }
+
+    // If this provider is being set as default, unset other defaults in the same project
+    if (createBy.data.isDefault && createBy.data.projectId) {
+      await this.updateBy({
+        query: {
+          projectId: createBy.data.projectId,
+          isDefault: true,
+        },
+        data: {
+          isDefault: false,
+        },
+        props: {
+          isRoot: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+      });
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    // If setting isDefault to true, we need to unset other defaults in the same project
+    if (updateBy.data.isDefault === true) {
+      // Get the items being updated to find their project IDs
+      const itemsToUpdate: Array<Model> = await this.findBy({
+        query: updateBy.query,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+      });
+
+      // Collect unique project IDs
+      const projectIds: Set<string> = new Set();
+      const itemIds: Set<string> = new Set();
+      for (const item of itemsToUpdate) {
+        if (item.projectId) {
+          projectIds.add(item.projectId.toString());
+        }
+        if (item._id) {
+          itemIds.add(item._id);
+        }
+      }
+
+      // For each project, unset the default on other providers
+      for (const projectIdStr of projectIds) {
+        const projectId: ObjectID = new ObjectID(projectIdStr);
+        await this.updateBy({
+          query: {
+            projectId: projectId,
+            isDefault: true,
+            _id: QueryHelper.notInOrNull(Array.from(itemIds)),
+          },
+          data: {
+            isDefault: false,
+          },
+          props: {
+            isRoot: true,
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+        });
+      }
+    }
+
+    return { updateBy, carryForward: null };
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceInternalNoteService.ts

@@ -24,6 +24,7 @@ export class Service extends DatabaseService<Model> {
     projectId: ObjectID;
     note: string;
     attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
   }): Promise<Model> {
     const internalNote: Model = new Model();
     internalNote.createdByUserId = data.userId;
@@ -31,6 +32,10 @@ export class Service extends DatabaseService<Model> {
     internalNote.projectId = data.projectId;
     internalNote.note = data.note;
 
+    if (data.postedFromSlackMessageId) {
+      internalNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
     if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
       internalNote.attachments = data.attachmentFileIds.map(
         (fileId: ObjectID) => {
@@ -49,6 +54,27 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    scheduledMaintenanceId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        scheduledMaintenanceId: data.scheduledMaintenanceId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
   @CaptureSpan()
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -162,6 +162,7 @@ ${(updatedItem.note || "") + attachmentsMarkdown}
     projectId: ObjectID;
     note: string;
     attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
   }): Promise<Model> {
     const publicNote: Model = new Model();
     publicNote.createdByUserId = data.userId;
@@ -170,6 +171,10 @@ ${(updatedItem.note || "") + attachmentsMarkdown}
     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) => {
@@ -188,6 +193,27 @@ ${(updatedItem.note || "") + attachmentsMarkdown}
     });
   }
 
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    scheduledMaintenanceId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        scheduledMaintenanceId: data.scheduledMaintenanceId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
   private async getAttachmentsMarkdown(
     modelId: ObjectID,
     attachmentApiPath: string,

package/Server/Services/StatusPageService.ts

@@ -1193,6 +1193,9 @@ export class Service extends DatabaseService<StatusPage> {
         },
         select: {
           statusPageGroupId: true,
+          statusPageGroup: {
+            name: true,
+          },
           monitorId: true,
           displayTooltip: true,
           displayDescription: true,

package/Server/Utils/Express.ts

@@ -40,6 +40,7 @@ export interface OneUptimeRequest extends express.Request {
   userGlobalAccessPermission?: UserGlobalAccessPermission;
   userTenantAccessPermission?: Dictionary<UserTenantAccessPermission>; // tenantId <-> UserTenantAccessPermission;
   rawFormUrlEncodedBody?: string;
+  rawBody?: string; // Raw body for signature verification (JSON or URL-encoded)
 }
 
 export interface OneUptimeResponse extends express.Response {

package/Server/Utils/StartServer.ts

@@ -50,6 +50,10 @@ app.use(CookieParser());
 const jsonBodyParserMiddleware: RequestHandler = ExpressJson({
   limit: "50mb",
   extended: true,
+  verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer) => {
+    (req as OneUptimeRequest).rawBody = buf.toString();
+    logger.debug(`Raw JSON Body for signature verification captured`);
+  },
 }); // 50 MB limit.
 
 const urlEncodedMiddleware: RequestHandler = ExpressUrlEncoded({
@@ -57,6 +61,7 @@ const urlEncodedMiddleware: RequestHandler = ExpressUrlEncoded({
   extended: true,
   verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer) => {
     (req as OneUptimeRequest).rawFormUrlEncodedBody = buf.toString();
+    (req as OneUptimeRequest).rawBody = buf.toString(); // Also set rawBody for consistency
     logger.debug(
       `Raw Form Url Encoded Body: ${(req as OneUptimeRequest).rawFormUrlEncodedBody}`,
     );

package/Server/Utils/StatusPageResource.ts

@@ -0,0 +1,89 @@
+import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
+import Dictionary from "../../Types/Dictionary";
+
+export interface GetResourcesGroupedByGroupNameOptions {
+  resources: Array<StatusPageResource>;
+  defaultValue?: string;
+}
+
+export default class StatusPageResourceUtil {
+  /**
+   * Formats an array of StatusPageResource items into a string grouped by their resource group.
+   *
+   * If resources have no group or only one resource exists without a group, returns a simple comma-separated list.
+   * If resources are grouped, returns a formatted string like:
+   * "EU: Infrastructure, Website; UK: Infrastructure, API"
+   *
+   * @param resources - Array of StatusPageResource items with displayName, statusPageGroupId, and optionally statusPageGroup.name
+   * @param defaultValue - Value to return if no resources (defaults to "None")
+   * @returns Formatted string of resources grouped by their resource group
+   */
+  public static getResourcesGroupedByGroupName(
+    resources: Array<StatusPageResource>,
+    defaultValue: string = "",
+  ): string {
+    if (!resources || resources.length === 0) {
+      return defaultValue;
+    }
+
+    // Check if any resource has a group
+    const hasAnyGroup: boolean = resources.some((r: StatusPageResource) => {
+      return r.statusPageGroupId || r.statusPageGroup;
+    });
+
+    // If no resources have groups, return simple comma-separated list
+    if (!hasAnyGroup) {
+      return (
+        resources
+          .map((r: StatusPageResource) => {
+            return r.displayName;
+          })
+          .filter((name: string | undefined) => {
+            return name;
+          })
+          .join(", ") || ""
+      );
+    }
+
+    // Group resources by their group name
+    const resourcesByGroup: Dictionary<Array<string>> = {};
+    const ungroupedResources: Array<string> = [];
+
+    for (const resource of resources) {
+      const displayName: string | undefined = resource.displayName;
+      if (!displayName) {
+        continue;
+      }
+
+      const groupName: string | undefined =
+        resource.statusPageGroup?.name || undefined;
+
+      if (groupName) {
+        if (!resourcesByGroup[groupName]) {
+          resourcesByGroup[groupName] = [];
+        }
+        resourcesByGroup[groupName]!.push(displayName);
+      } else {
+        ungroupedResources.push(displayName);
+      }
+    }
+
+    // Build the formatted string
+    const formattedGroups: Array<string> = [];
+
+    // Add grouped resources
+    for (const groupName in resourcesByGroup) {
+      const groupResources: Array<string> = resourcesByGroup[groupName]!;
+      formattedGroups.push(`${groupName}: ${groupResources.join(", ")}`);
+    }
+
+    // Add ungrouped resources on separate lines (without "Other" label)
+    if (ungroupedResources.length > 0) {
+      for (const resourceName of ungroupedResources) {
+        formattedGroups.push(resourceName);
+      }
+    }
+
+    return formattedGroups.join("<br/>") || defaultValue;
+  }
+}