@oneuptime/common 7.0.3669 → 7.0.3679

package/Models/DatabaseModels/Alert.ts

@@ -36,6 +36,7 @@ import {
   ManyToOne,
 } from "typeorm";
 import { TelemetryQuery } from "../../Types/Telemetry/TelemetryQuery";
+import { WorkspaceChannel } from "../../Server/Utils/Workspace/WorkspaceBase";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -1044,14 +1045,13 @@ export default class Alert extends BaseModel {
   @TableColumn({
     isDefaultValueColumn: false,
     required: false,
-    type: TableColumnType.ShortText,
+    type: TableColumnType.JSON,
     title: "Post Updates To Workspace Channel Name",
     description: "Post Updates To Workspace Channel Name",
   })
   @Column({
-    type: ColumnType.ShortText,
-    length: ColumnLength.ShortText,
+    type: ColumnType.JSON,
     nullable: true,
   })
-  public postUpdatesToWorkspaceChannelName?: number = undefined;
+  public postUpdatesToWorkspaceChannels?: Array<WorkspaceChannel> = undefined;
 }

package/Models/DatabaseModels/Incident.ts

@@ -37,6 +37,7 @@ import {
   ManyToOne,
 } from "typeorm";
 import { TelemetryQuery } from "../../Types/Telemetry/TelemetryQuery";
+import { WorkspaceChannel } from "../../Server/Utils/Workspace/WorkspaceBase";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -1129,14 +1130,13 @@ export default class Incident extends BaseModel {
   @TableColumn({
     isDefaultValueColumn: false,
     required: false,
-    type: TableColumnType.ShortText,
+    type: TableColumnType.JSON,
     title: "Post Updates To Workspace Channel Name",
     description: "Post Updates To Workspace Channel Name",
   })
   @Column({
-    type: ColumnType.ShortText,
-    length: ColumnLength.ShortText,
+    type: ColumnType.JSON,
     nullable: true,
   })
-  public postUpdatesToWorkspaceChannelName?: number = undefined;
+  public postUpdatesToWorkspaceChannels?: Array<WorkspaceChannel> = undefined;
 }

package/Models/DatabaseModels/ScheduledMaintenance.ts

@@ -35,6 +35,7 @@ import {
   ManyToOne,
 } from "typeorm";
 import Recurring from "../../Types/Events/Recurring";
+import { WorkspaceChannel } from "../../Server/Utils/Workspace/WorkspaceBase";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -988,14 +989,13 @@ export default class ScheduledMaintenance extends BaseModel {
   @TableColumn({
     isDefaultValueColumn: false,
     required: false,
-    type: TableColumnType.ShortText,
+    type: TableColumnType.JSON,
     title: "Post Updates To Workspace Channel Name",
     description: "Post Updates To Workspace Channel Name",
   })
   @Column({
-    type: ColumnType.ShortText,
-    length: ColumnLength.ShortText,
+    type: ColumnType.JSON,
     nullable: true,
   })
-  public postUpdatesToWorkspaceChannelName?: number = undefined;
+  public postUpdatesToWorkspaceChannels?: Array<WorkspaceChannel> = undefined;
 }

package/Server/API/SlackAPI.ts

@@ -15,7 +15,7 @@ import {
   SlackAppClientId,
   SlackAppClientSecret,
 } from "../EnvironmentConfig";
-import SlackAppManifest from "../Utils/Slack/app-manifest.json";
+import SlackAppManifest from "../Utils/Workspace/Slack/app-manifest.json";
 import URL from "../../Types/API/URL";
 import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
 import HTTPResponse from "../../Types/API/HTTPResponse";

package/Server/EnvironmentConfig.ts

@@ -260,6 +260,10 @@ export const WorkflowScriptTimeoutInMS: number = process.env[
   ? parseInt(process.env["WORKFLOW_SCRIPT_TIMEOUT_IN_MS"].toString())
   : 5000;
 
+export const WorkflowTimeoutInMs: number = process.env["WORKFLOW_TIMEOUT_IN_MS"]
+  ? parseInt(process.env["WORKFLOW_TIMEOUT_IN_MS"].toString())
+  : 5000;
+
 export const AllowedActiveMonitorCountInFreePlan: number = process.env[
   "ALLOWED_ACTIVE_MONITOR_COUNT_IN_FREE_PLAN"
 ]

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

@@ -0,0 +1,65 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1739569321582 implements MigrationInterface {
+  public name = "MigrationName1739569321582";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" RENAME COLUMN "postUpdatesToWorkspaceChannelName" TO "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Alert" RENAME COLUMN "postUpdatesToWorkspaceChannelName" TO "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" RENAME COLUMN "postUpdatesToWorkspaceChannelName" TO "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Incident" DROP COLUMN "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Incident" ADD "postUpdatesToWorkspaceChannels" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Alert" DROP COLUMN "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Alert" ADD "postUpdatesToWorkspaceChannels" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" DROP COLUMN "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" ADD "postUpdatesToWorkspaceChannels" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" DROP COLUMN "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" ADD "postUpdatesToWorkspaceChannels" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Alert" DROP COLUMN "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Alert" ADD "postUpdatesToWorkspaceChannels" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Incident" DROP COLUMN "postUpdatesToWorkspaceChannels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Incident" ADD "postUpdatesToWorkspaceChannels" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" RENAME COLUMN "postUpdatesToWorkspaceChannels" TO "postUpdatesToWorkspaceChannelName"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Alert" RENAME COLUMN "postUpdatesToWorkspaceChannels" TO "postUpdatesToWorkspaceChannelName"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Incident" RENAME COLUMN "postUpdatesToWorkspaceChannels" TO "postUpdatesToWorkspaceChannelName"`,
+    );
+  }
+}

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

@@ -104,6 +104,7 @@ import { MigrationName1739210586538 } from "./1739210586538-MigrationName";
 import { MigrationName1739217257089 } from "./1739217257089-MigrationName";
 import { MigrationName1739282331053 } from "./1739282331053-MigrationName";
 import { MigrationName1739374537088 } from "./1739374537088-MigrationName";
+import { MigrationName1739569321582 } from "./1739569321582-MigrationName";
 
 export default [
   InitialMigration,
@@ -212,4 +213,5 @@ export default [
   MigrationName1739217257089,
   MigrationName1739282331053,
   MigrationName1739374537088,
+  MigrationName1739569321582,
 ];

package/Server/Services/IncidentService.ts

@@ -58,6 +58,9 @@ import {
   WorkspaceMessageBlock,
   WorkspacePayloadMarkdown,
 } from "../../Types/Workspace/WorkspaceMessagePayload";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -472,6 +475,32 @@ ${createdItem.remediationNotes || "No remediation notes provided."}`,
       }
     }
 
+    // // send message to workspaces - slack, teams,   etc.
+    // const createdChannels: {
+    //   channelsCreated: Array<WorkspaceChannel>;
+    // } | null = await this.notifyWorkspaceOnIncidentCreate({
+    //   projectId: createdItem.projectId,
+    //   incidentId: createdItem.id!,
+    //   incidentNumber: createdItem.incidentNumber!,
+    // });
+
+    // if (
+    //   createdChannels &&
+    //   createdChannels.channelsCreated &&
+    //   createdChannels.channelsCreated.length > 0
+    // ) {
+    //   // update incident with these channels.
+    //   await this.updateOneById({
+    //     id: createdItem.id!,
+    //     data: {
+    //       postUpdatesToWorkspaceChannels: createdChannels.channelsCreated,
+    //     },
+    //     props: {
+    //       isRoot: true,
+    //     },
+    //   });
+    // }
+
     return createdItem;
   }
 
@@ -1319,6 +1348,35 @@ ${incidentSeverity.name}
     });
   }
 
+  public async notifyWorkspaceOnIncidentCreate(data: {
+    projectId: ObjectID;
+    incidentId: ObjectID;
+    incidentNumber: number;
+  }): Promise<{
+    channelsCreated: WorkspaceChannel[];
+  } | null> {
+    try {
+      // we will notify the workspace about the incident creation with the bot tokken which is in WorkspaceProjectAuth Table.
+      return await WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules(
+        {
+          projectId: data.projectId,
+          notificationFor: {
+            incidentId: data.incidentId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Incident,
+          channelNameSiffix: data.incidentNumber.toString(),
+          messageBlocks: await this.getWorkspaceMessageBlocksForIncidentCreate({
+            incidentId: data.incidentId,
+          }),
+        },
+      );
+    } catch (err) {
+      // log the error and continue.
+      logger.error(err);
+      return null;
+    }
+  }
+
   public async getWorkspaceMessageBlocksForIncidentCreate(data: {
     incidentId: ObjectID;
   }): Promise<Array<WorkspaceMessageBlock>> {

package/Server/Services/ProjectService.ts

@@ -67,7 +67,7 @@ import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
 import AlertState from "../../Models/DatabaseModels/AlertState";
 import AlertStateService from "./AlertStateService";
-import SlackUtil from "../Utils/Slack/Slack";
+import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import URL from "../../Types/API/URL";
 import Exception from "../../Types/Exception/Exception";
 

package/Server/Services/UserService.ts

@@ -28,7 +28,7 @@ import Text from "../../Types/Text";
 import EmailVerificationToken from "Common/Models/DatabaseModels/EmailVerificationToken";
 import TeamMember from "Common/Models/DatabaseModels/TeamMember";
 import Model from "Common/Models/DatabaseModels/User";
-import SlackUtil from "../Utils/Slack/Slack";
+import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import UserTwoFactorAuth from "Common/Models/DatabaseModels/UserTwoFactorAuth";
 import UserTwoFactorAuthService from "./UserTwoFactorAuthService";
 import BadDataException from "../../Types/Exception/BadDataException";

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -20,9 +20,17 @@ import MonitorStatusTimelineService from "./MonitorStatusTimelineService";
 import { WorkspaceNotificationRuleUtil } from "../../Types/Workspace/NotificationRules/NotificationRuleUtil";
 import TeamMemberService from "./TeamMemberService";
 import User from "../../Models/DatabaseModels/User";
-import AlertNotificationRule from "../../Types/Workspace/NotificationRules/NotificationRuleTypes/AlertNotificationRule";
-import ScheduledMaintenanceNotificationRule from "../../Types/Workspace/NotificationRules/NotificationRuleTypes/ScheduledMaintenanceNotificationRule";
 import BaseNotificationRule from "../../Types/Workspace/NotificationRules/BaseNotificationRule";
+import CreateChannelNotificationRule from "../../Types/Workspace/NotificationRules/CreateChannelNotificationRule";
+import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
+import WorkspaceUtil from "../Utils/Workspace/Workspace";
+import WorkspaceUserAuthToken from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
+import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
+import WorkspaceMessagePayload, {
+  WorkspaceMessageBlock,
+} from "../../Types/Workspace/WorkspaceMessagePayload";
+import WorkspaceProjectAuthToken from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
 
 export interface NotificationFor {
   incidentId?: ObjectID | undefined;
@@ -36,20 +44,235 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  public async createInviteAndPostToChannelsBasedOnRules(data: {
+    projectId: ObjectID;
+    notificationRuleEventType: NotificationRuleEventType;
+    notificationFor: NotificationFor;
+    channelNameSiffix: string;
+    messageBlocks: Array<WorkspaceMessageBlock>;
+  }): Promise<{
+    channelsCreated: Array<WorkspaceChannel>;
+  } | null> {
+    const channelsCreated: Array<WorkspaceChannel> = [];
+
+    const projectAuths: Array<WorkspaceProjectAuthToken> =
+      await WorkspaceProjectAuthTokenService.getProjectAuths({
+        projectId: data.projectId,
+      });
+
+    if (!projectAuths || projectAuths.length === 0) {
+      // do nothing.
+      return null;
+    }
+
+    for (const projectAuth of projectAuths) {
+      if (!projectAuth.authToken) {
+        continue;
+      }
+
+      if (!projectAuth.workspaceType) {
+        continue;
+      }
+
+      const authToken: string = projectAuth.authToken;
+      const workspaceType: WorkspaceType = projectAuth.workspaceType;
+
+      const notificationRules: Array<Model> =
+        await this.getMatchingNotificationRules({
+          projectId: data.projectId,
+          workspaceType: workspaceType,
+          notificationRuleEventType: data.notificationRuleEventType,
+          notificationFor: data.notificationFor,
+        });
+
+      if (!notificationRules || notificationRules.length === 0) {
+        return null;
+      }
+
+      const createdWorkspaceChannels: Array<WorkspaceChannel> =
+        await this.createChannelsBasedOnRules({
+          projectOrUserAuthTokenForWorkspasce: authToken,
+          workspaceType: workspaceType,
+          notificationRules: notificationRules.map((rule: Model) => {
+            return rule.notificationRule as CreateChannelNotificationRule;
+          }),
+          channelNameSiffix: data.channelNameSiffix,
+          notificationEventType: data.notificationRuleEventType,
+        });
+
+      await this.inviteUsersAndTeamsToChannelsBasedOnRules({
+        projectId: data.projectId,
+        projectOrUserAuthTokenForWorkspasce: authToken,
+        workspaceType: workspaceType,
+        notificationRules: notificationRules.map((rule: Model) => {
+          return rule.notificationRule as CreateChannelNotificationRule;
+        }),
+        channelNames: createdWorkspaceChannels.map(
+          (channel: WorkspaceChannel) => {
+            return channel.name;
+          },
+        ),
+      });
+
+      const existingChannelNames: Array<string> =
+        this.getExistingChannelNamesFromNotificationRules({
+          notificationRules: notificationRules.map((rule: Model) => {
+            return rule.notificationRule as BaseNotificationRule;
+          }),
+        }) || [];
+
+      // add created channel names to existing channel names.
+      for (const channel of createdWorkspaceChannels) {
+        if (!existingChannelNames.includes(channel.name)) {
+          existingChannelNames.push(channel.name);
+        }
+      }
+
+      await this.postToWorkspaceChannels({
+        projectOrUserAuthTokenForWorkspasce: authToken,
+        workspaceType: workspaceType,
+        workspaceMessagePayload: {
+          _type: "WorkspaceMessagePayload",
+          channelNames: existingChannelNames,
+          messageBlocks: data.messageBlocks,
+        },
+      });
+
+      channelsCreated.push(...createdWorkspaceChannels);
+    }
+
+    return {
+      channelsCreated: channelsCreated,
+    };
+  }
+
+  public async postToWorkspaceChannels(data: {
+    projectOrUserAuthTokenForWorkspasce: string;
+    workspaceType: WorkspaceType;
+    workspaceMessagePayload: WorkspaceMessagePayload;
+  }): Promise<void> {
+    await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).sendMessage({
+      workspaceMessagePayload: data.workspaceMessagePayload,
+      authToken: data.projectOrUserAuthTokenForWorkspasce,
+    });
+  }
+
+  public async inviteUsersAndTeamsToChannelsBasedOnRules(data: {
+    projectId: ObjectID;
+    projectOrUserAuthTokenForWorkspasce: string;
+    workspaceType: WorkspaceType;
+    notificationRules: Array<CreateChannelNotificationRule>;
+    channelNames: Array<string>;
+  }): Promise<void> {
+    const inviteUserIds: Array<ObjectID> =
+      await this.getUsersIdsToInviteToChannel({
+        notificationRules: data.notificationRules,
+      });
+
+    const workspaceUserIds: Array<string> = [];
+
+    for (const userId of inviteUserIds) {
+      const workspaceUserId: string | null =
+        await this.getWorkspaceUserIdFromOneUptimeUserId({
+          projectId: data.projectId,
+          workspaceType: data.workspaceType,
+          oneupitmeUserId: userId,
+        });
+
+      if (workspaceUserId) {
+        workspaceUserIds.push(workspaceUserId);
+      }
+    }
+
+    await WorkspaceUtil.getWorkspaceTypeUtil(
+      data.workspaceType,
+    ).inviteUsersToChannels({
+      authToken: data.projectOrUserAuthTokenForWorkspasce,
+      workspaceChannelInvitationPayload: {
+        channelNames: data.channelNames,
+        workspaceUserIds: workspaceUserIds,
+      },
+    });
+  }
+
+  public async getWorkspaceUserIdFromOneUptimeUserId(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    oneupitmeUserId: ObjectID;
+  }): Promise<string | null> {
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          workspaceType: data.workspaceType,
+          userId: data.oneupitmeUserId,
+        },
+        select: {
+          workspaceUserId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!userAuth) {
+      return null;
+    }
+
+    return userAuth.workspaceUserId?.toString() || null;
+  }
+
+  public async createChannelsBasedOnRules(data: {
+    projectOrUserAuthTokenForWorkspasce: string;
+    workspaceType: WorkspaceType;
+    notificationRules: Array<CreateChannelNotificationRule>;
+    channelNameSiffix: string;
+    notificationEventType: NotificationRuleEventType;
+  }): Promise<Array<WorkspaceChannel>> {
+    const createdWorkspaceChannels: Array<WorkspaceChannel> = [];
+    const createdChannelNames: Array<string> = [];
+
+    const newChannelNames: Array<string> =
+      this.getNewChannelNamesFromNotificationRules({
+        notificationRules: data.notificationRules,
+        channelNameSiffix: data.channelNameSiffix,
+        notificationEventType: data.notificationEventType,
+      });
+
+    if (!newChannelNames || newChannelNames.length === 0) {
+      return [];
+    }
+
+    for (const newChannelName of newChannelNames) {
+      // if already created then skip it.
+      if (createdChannelNames.includes(newChannelName)) {
+        continue;
+      }
+
+      // create channel.
+      const channel: WorkspaceChannel =
+        await WorkspaceUtil.getWorkspaceTypeUtil(
+          data.workspaceType,
+        ).createChannel({
+          authToken: data.projectOrUserAuthTokenForWorkspasce,
+          channelName: newChannelName,
+        });
+
+      createdChannelNames.push(channel.name);
+
+      createdWorkspaceChannels.push(channel);
+    }
+
+    return createdWorkspaceChannels;
+  }
+
   public async getUsersIdsToInviteToChannel(data: {
-    notificationRules: Array<
-      | IncidentNotificationRule
-      | AlertNotificationRule
-      | ScheduledMaintenanceNotificationRule
-    >;
+    notificationRules: Array<CreateChannelNotificationRule>;
   }): Promise<Array<ObjectID>> {
     const inviteUserIds: Array<ObjectID> = [];
 
     for (const notificationRule of data.notificationRules) {
-      const workspaceRules:
-        | IncidentNotificationRule
-        | AlertNotificationRule
-        | ScheduledMaintenanceNotificationRule = notificationRule;
+      const workspaceRules: CreateChannelNotificationRule = notificationRule;
 
       if (workspaceRules.shouldCreateNewChannel) {
         if (
@@ -103,7 +326,7 @@ export class Service extends DatabaseService<Model> {
     return inviteUserIds;
   }
 
-  public getChannelNamesFromNotificaitonRules(data: {
+  public getExistingChannelNamesFromNotificationRules(data: {
     notificationRules: Array<BaseNotificationRule>;
   }): Array<string> {
     const channelNames: Array<string> = [];
@@ -132,6 +355,37 @@ export class Service extends DatabaseService<Model> {
     return channelNames;
   }
 
+  public getNewChannelNamesFromNotificationRules(data: {
+    notificationEventType: NotificationRuleEventType;
+    notificationRules: Array<CreateChannelNotificationRule>;
+    channelNameSiffix: string;
+  }): Array<string> {
+    const channelNames: Array<string> = [];
+
+    for (const notificationRule of data.notificationRules) {
+      const workspaceRules: CreateChannelNotificationRule = notificationRule;
+
+      if (
+        workspaceRules.shouldCreateNewChannel &&
+        workspaceRules.newChannelTemplateName
+      ) {
+        const newChannelName: string =
+          workspaceRules.newChannelTemplateName ||
+          `oneuptime-${data.notificationEventType.toLowerCase()}-`;
+
+        // add suffix and then check if it is already added or not.
+        const channelName: string = newChannelName + data.channelNameSiffix;
+
+        if (!channelNames.includes(channelName)) {
+          // if channel name is not already added then add it.
+          channelNames.push(channelName);
+        }
+      }
+    }
+
+    return channelNames;
+  }
+
   private async getNotificationRules(data: {
     projectId: ObjectID;
     workspaceType: WorkspaceType;

package/Server/Types/Workflow/Components/Slack/SendMessageToChannel.ts

@@ -8,7 +8,7 @@ import { JSONObject } from "Common/Types/JSON";
 import ComponentMetadata, { Port } from "Common/Types/Workflow/Component";
 import ComponentID from "Common/Types/Workflow/ComponentID";
 import SlackComponents from "Common/Types/Workflow/Components/Slack";
-import SlackUtil from "../../../../Utils/Slack/Slack";
+import SlackUtil from "../../../../Utils/Workspace/Slack/Slack";
 
 export default class SendMessageToChannel extends ComponentCode {
   public constructor() {

package/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.ts

@@ -0,0 +1,3 @@
+import WorkspaceBase from "../WorkspaceBase";
+
+export default class MicrosoftTeams extends WorkspaceBase {}