@oneuptime/common 7.0.3887 → 7.0.3899

package/Server/API/WorkspaceNotificationRuleAPI.ts

@@ -0,0 +1,48 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import WorkspaceNotificationRuleService, {
+  Service as WorkspaceNotificationRuleServiceType,
+} from "../Services/WorkspaceNotificationRuleService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
+import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+import ObjectID from "../../Types/ObjectID";
+
+export default class WorkspaceNotificationRuleAPI extends BaseAPI<
+  WorkspaceNotificationRule,
+  WorkspaceNotificationRuleServiceType
+> {
+  public constructor() {
+    super(WorkspaceNotificationRule, WorkspaceNotificationRuleService);
+
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/test/:workspaceNotifcationRuleId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          await this.service.testRule({
+            ruleId: new ObjectID(
+              req.params["workspaceNotifcationRuleId"] as string,
+            ),
+            props: databaseProps,
+            projectId: databaseProps.tenantId!,
+            testByUserId: databaseProps.userId!,
+          });
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+  }
+}

package/Server/Services/IncidentService.ts

@@ -302,7 +302,9 @@ export class Service extends DatabaseService<Model> {
       return 0;
     }
 
-    return lastIncident.incidentNumber || 0;
+    return lastIncident.incidentNumber
+      ? Number(lastIncident.incidentNumber)
+      : 0;
   }
 
   @CaptureSpan()

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -38,6 +38,8 @@ import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNot
 import UserService from "./UserService";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import Monitor from "../../Models/DatabaseModels/Monitor";
+import Text from "../../Types/Text";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 
 export interface MessageBlocksByWorkspaceType {
   workspaceType: WorkspaceType;
@@ -56,6 +58,209 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     super(WorkspaceNotificationRule);
   }
 
+  @CaptureSpan()
+  public async testRule(data: {
+    ruleId: ObjectID;
+    projectId: ObjectID;
+    testByUserId: ObjectID; // this can be useful to invite user to channels if the channels was created.
+    props: DatabaseCommonInteractionProps;
+  }): Promise<void> {
+    const rule: WorkspaceNotificationRule | null = await this.findOneById({
+      id: data.ruleId,
+      select: {
+        notificationRule: true,
+        workspaceType: true,
+        eventType: true,
+        name: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!rule) {
+      throw new BadDataException("Rule not found");
+    }
+
+    // check fi the testUser account is connected to workspace or not.
+    const userWOrkspaceAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          userId: data.testByUserId,
+          workspaceType: rule.workspaceType!,
+        },
+        select: {
+          workspaceUserId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!userWOrkspaceAuth || !userWOrkspaceAuth.workspaceUserId) {
+      throw new BadDataException(
+        "This account is not connected to " +
+          rule.workspaceType +
+          ". Please go to User Settings and connect the account.",
+      );
+    }
+
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          workspaceType: rule.workspaceType!,
+        },
+        select: {
+          workspaceType: true,
+          authToken: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!projectAuth) {
+      throw new BadDataException(
+        "This project is not connected to " +
+          rule.workspaceType +
+          ". Please go to Project Settings and connect the account.",
+      );
+    }
+
+    const projectAuthToken: string = projectAuth.authToken!;
+
+    const notificationRule: BaseNotificationRule =
+      rule.notificationRule as BaseNotificationRule;
+
+    // now send test message to these channels.
+    const messageBlocksByWorkspaceTypes: Array<MessageBlocksByWorkspaceType> =
+      [];
+
+    // use markdown to create blocks
+    messageBlocksByWorkspaceTypes.push({
+      workspaceType: rule.workspaceType!,
+      messageBlocks: [
+        {
+          _type: "WorkspacePayloadMarkdown",
+          text: `This is a test message for rule **${rule.name}**`,
+        } as WorkspacePayloadMarkdown,
+      ],
+    });
+
+    let existingChannelNames: Array<string> = [];
+
+    let createdChannels: NotificationRuleWorkspaceChannel[] = [];
+
+    if ((notificationRule as IncidentNotificationRule).shouldCreateNewChannel) {
+      const generateRandomString: string = Text.generateRandomText(5);
+
+      try {
+        // create channel
+        createdChannels = await this.createChannelsBasedOnRules({
+          projectOrUserAuthTokenForWorkspace: projectAuthToken,
+          workspaceType: rule.workspaceType!,
+          notificationRules: [rule],
+          channelNameSiffix: generateRandomString,
+          notificationEventType: rule.eventType!,
+        });
+      } catch (err) {
+        throw new BadDataException(
+          "Cannot create a new channel. " + (err as Error)?.message,
+        );
+      }
+
+      try {
+        await this.inviteUsersBasedOnRulesAndWorkspaceChannels({
+          workspaceChannels: createdChannels,
+          projectId: data.projectId,
+          notificationRules: [rule],
+          userIds: [data.testByUserId],
+        });
+      } catch (err) {
+        throw new BadDataException(
+          "Cannot invite users to the channel. " + (err as Error)?.message,
+        );
+      }
+    }
+
+    if (notificationRule.shouldPostToExistingChannel) {
+      existingChannelNames = this.getExistingChannelNamesFromNotificationRules({
+        notificationRules: [notificationRule],
+      });
+
+      for (const channelName of existingChannelNames) {
+        try {
+          // check if these channels exist.
+          const channelExists: boolean =
+            await WorkspaceUtil.getWorkspaceTypeUtil(
+              rule.workspaceType!,
+            ).doesChannelExist({
+              authToken: projectAuthToken,
+              channelName: channelName,
+            });
+
+          if (!channelExists) {
+            throw new BadDataException(
+              `Channel ${channelName} does not exist.`,
+            );
+          }
+        } catch (err) {
+          throw new BadDataException((err as Error)?.message);
+        }
+      }
+
+      // post message
+
+      for (const createdChannel of createdChannels) {
+        try {
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map(
+              (messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType) => {
+                return {
+                  _type: "WorkspaceMessagePayload",
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                  messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+                  channelNames: [],
+                  channelIds: [createdChannel.id],
+                };
+              },
+            ),
+          });
+        } catch (err) {
+          throw new BadDataException(
+            "Cannot post message to channel. " + (err as Error)?.message,
+          );
+        }
+      }
+
+      for (const existingChannelName of existingChannelNames) {
+        try {
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map(
+              (messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType) => {
+                return {
+                  _type: "WorkspaceMessagePayload",
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                  messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+                  channelNames: [existingChannelName],
+                  channelIds: [],
+                };
+              },
+            ),
+          });
+        } catch (err) {
+          throw new BadDataException(
+            "Cannot post message to channel. " + (err as Error)?.message,
+          );
+        }
+      }
+    }
+  }
+
   @CaptureSpan()
   public async sendWorkspaceMarkdownNotification(data: {
     projectId: ObjectID;
@@ -103,6 +308,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           projectId: data.projectId,
           notificationRuleEventType: NotificationRuleEventType.Monitor,
           workspaceType: messageBlocksByWorkspaceType.workspaceType,
+          notificationFor: data.notificationFor,
         });
 
       let monitorChannels: Array<WorkspaceChannel> = [];
@@ -198,15 +404,17 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     projectId: ObjectID;
     workspaceType: WorkspaceType;
     notificationRuleEventType: NotificationRuleEventType;
+    notificationFor: NotificationFor;
   }): Promise<Array<string>> {
     logger.debug("getExistingChannelNamesBasedOnEventType called with data:");
     logger.debug(data);
 
     const notificationRules: Array<WorkspaceNotificationRule> =
-      await this.getNotificationRules({
+      await this.getMatchingNotificationRules({
         projectId: data.projectId,
         workspaceType: data.workspaceType,
         notificationRuleEventType: data.notificationRuleEventType,
+        notificationFor: data.notificationFor,
       });
 
     logger.debug("Notification rules retrieved:");

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -30,6 +30,7 @@ import SlackifyMarkdown from "slackify-markdown";
 import { DropdownOption } from "../../../../UI/Components/Dropdown/Dropdown";
 import OneUptimeDate from "../../../../Types/Date";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
+import BadDataException from "../../../../Types/Exception/BadDataException";
 
 export default class SlackUtil extends WorkspaceBase {
   @CaptureSpan()
@@ -123,7 +124,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((result.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(result.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (result.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     logger.debug("Modal shown to user successfully.");
@@ -187,7 +191,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     logger.debug("Channel joined successfully with data:");
@@ -240,7 +247,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     logger.debug("User invited to channel successfully.");
@@ -344,7 +354,7 @@ export default class SlackUtil extends WorkspaceBase {
 
     if (!channels[data.channelName]) {
       logger.error("Channel not found.");
-      throw new Error("Channel not found.");
+      throw new BadDataException("Channel not found.");
     }
 
     logger.debug("Workspace channel ID obtained:");
@@ -386,7 +396,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     if (
@@ -440,7 +453,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     const channels: Dictionary<WorkspaceChannel> = {};
@@ -527,6 +543,33 @@ export default class SlackUtil extends WorkspaceBase {
     return values;
   }
 
+  @CaptureSpan()
+  public static override async doesChannelExist(data: {
+    authToken: string;
+    channelName: string;
+  }): Promise<boolean> {
+    // if channel name starts with #, remove it
+    if (data.channelName && data.channelName.startsWith("#")) {
+      data.channelName = data.channelName.substring(1);
+    }
+
+    // convert channel name to lowercase
+    data.channelName = data.channelName.toLowerCase();
+
+    // get channel id from channel name
+    const channels: Dictionary<WorkspaceChannel> =
+      await this.getAllWorkspaceChannels({
+        authToken: data.authToken,
+      });
+
+    // if this channel exists
+    if (channels[data.channelName]) {
+      return true;
+    }
+
+    return false;
+  }
+
   @CaptureSpan()
   public static override async sendMessage(data: {
     workspaceMessagePayload: WorkspaceMessagePayload;
@@ -664,7 +707,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     logger.debug("Payload blocks sent to channel successfully.");
@@ -736,7 +782,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     if (
@@ -1111,7 +1160,10 @@ export default class SlackUtil extends WorkspaceBase {
     if ((response.jsonData as JSONObject)?.["ok"] !== true) {
       logger.error("Invalid response from Slack API:");
       logger.error(response.jsonData);
-      throw new BadRequestException("Invalid response");
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
     }
 
     // check if the user is in the channel
@@ -1175,7 +1227,10 @@ export default class SlackUtil extends WorkspaceBase {
       if ((response.jsonData as JSONObject)?.["ok"] !== true) {
         logger.error("Invalid response from Slack API:");
         logger.error(response.jsonData);
-        throw new BadRequestException("Invalid response");
+        const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+          "error"
+        ] as string;
+        throw new BadRequestException("Error from Slack " + messageFromSlack);
       }
 
       // check if the user is in the channel

package/Server/Utils/Workspace/WorkspaceBase.ts

@@ -48,6 +48,15 @@ export default class WorkspaceBase {
   }): Promise<boolean> {
     throw new NotImplementedException();
   }
+
+  @CaptureSpan()
+  public static async doesChannelExist(_data: {
+    authToken: string;
+    channelName: string;
+  }): Promise<boolean> {
+    throw new NotImplementedException();
+  }
+
   @CaptureSpan()
   public static async getUsernameFromUserId(_data: {
     authToken: string;

package/build/dist/Server/API/WorkspaceNotificationRuleAPI.js

@@ -0,0 +1,29 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import WorkspaceNotificationRuleService from "../Services/WorkspaceNotificationRuleService";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+import ObjectID from "../../Types/ObjectID";
+export default class WorkspaceNotificationRuleAPI extends BaseAPI {
+    constructor() {
+        var _a;
+        super(WorkspaceNotificationRule, WorkspaceNotificationRuleService);
+        this.router.get(`${(_a = new this.entityType().getCrudApiPath()) === null || _a === void 0 ? void 0 : _a.toString()}/test/:workspaceNotifcationRuleId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const databaseProps = await CommonAPI.getDatabaseCommonInteractionProps(req);
+                await this.service.testRule({
+                    ruleId: new ObjectID(req.params["workspaceNotifcationRuleId"]),
+                    props: databaseProps,
+                    projectId: databaseProps.tenantId,
+                    testByUserId: databaseProps.userId,
+                });
+                return Response.sendEmptySuccessResponse(req, res);
+            }
+            catch (e) {
+                next(e);
+            }
+        });
+    }
+}
+//# sourceMappingURL=WorkspaceNotificationRuleAPI.js.map

package/build/dist/Server/API/WorkspaceNotificationRuleAPI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceNotificationRuleAPI.js","sourceRoot":"","sources":["../../../../Server/API/WorkspaceNotificationRuleAPI.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,iCAAiC,CAAC;AAC7D,OAAO,gCAEN,MAAM,8CAA8C,CAAC;AAMtD,OAAO,QAAQ,MAAM,mBAAmB,CAAC;AACzC,OAAO,OAAO,MAAM,WAAW,CAAC;AAChC,OAAO,SAAS,MAAM,aAAa,CAAC;AAEpC,OAAO,yBAAyB,MAAM,wDAAwD,CAAC;AAC/F,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAE5C,MAAM,CAAC,OAAO,OAAO,4BAA6B,SAAQ,OAGzD;IACC;;QACE,KAAK,CAAC,yBAAyB,EAAE,gCAAgC,CAAC,CAAC;QAEnE,IAAI,CAAC,MAAM,CAAC,GAAG,CACb,GAAG,MAAA,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,cAAc,EAAE,0CAAE,QAAQ,EAAE,mCAAmC,EACxF,cAAc,CAAC,iBAAiB,EAChC,KAAK,EAAE,GAAmB,EAAE,GAAoB,EAAE,IAAkB,EAAE,EAAE;YACtE,IAAI,CAAC;gBACH,MAAM,aAAa,GACjB,MAAM,SAAS,CAAC,iCAAiC,CAAC,GAAG,CAAC,CAAC;gBAEzD,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;oBAC1B,MAAM,EAAE,IAAI,QAAQ,CAClB,GAAG,CAAC,MAAM,CAAC,4BAA4B,CAAW,CACnD;oBACD,KAAK,EAAE,aAAa;oBACpB,SAAS,EAAE,aAAa,CAAC,QAAS;oBAClC,YAAY,EAAE,aAAa,CAAC,MAAO;iBACpC,CAAC,CAAC;gBAEH,OAAO,QAAQ,CAAC,wBAAwB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACrD,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,CAAC,CAAC,CAAC;YACV,CAAC;QACH,CAAC,CACF,CAAC;IACJ,CAAC;CACF"}

package/build/dist/Server/Services/IncidentService.js

@@ -228,7 +228,9 @@ export class Service extends DatabaseService {
         if (!lastIncident) {
             return 0;
         }
-        return lastIncident.incidentNumber || 0;
+        return lastIncident.incidentNumber
+            ? Number(lastIncident.incidentNumber)
+            : 0;
     }
     async onBeforeCreate(createBy) {
         if (!createBy.props.tenantId && !createBy.props.isRoot) {