@oneuptime/common 7.0.3617 → 7.0.3652

package/Server/Services/ScheduledMaintenanceService.ts

@@ -61,6 +61,32 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  public async getExistingScheduledMaintenanceNumberForProject(data: {
+    projectId: ObjectID;
+  }): Promise<number> {
+    // get last scheduledMaintenance number.
+    const lastScheduledMaintenance: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        scheduledMaintenanceNumber: true,
+      },
+      sort: {
+        createdAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!lastScheduledMaintenance) {
+      return 0;
+    }
+
+    return lastScheduledMaintenance.scheduledMaintenanceNumber || 0;
+  }
+
   public async notififySubscribersOnEventScheduled(
     scheduledEvents: Array<Model>,
   ): Promise<void> {
@@ -395,10 +421,13 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    const projectId: ObjectID =
+      createBy.props.tenantId || createBy.data.projectId!;
+
     const scheduledMaintenanceState: ScheduledMaintenanceState | null =
       await ScheduledMaintenanceStateService.findOneBy({
         query: {
-          projectId: createBy.props.tenantId,
+          projectId: projectId,
           isScheduledState: true,
         },
         select: {
@@ -418,6 +447,14 @@ export class Service extends DatabaseService<Model> {
     createBy.data.currentScheduledMaintenanceStateId =
       scheduledMaintenanceState.id;
 
+    const scheduledMaintenanceNumberForThisScheduledMaintenance: number =
+      (await this.getExistingScheduledMaintenanceNumberForProject({
+        projectId: projectId,
+      })) + 1;
+
+    createBy.data.scheduledMaintenanceNumber =
+      scheduledMaintenanceNumberForThisScheduledMaintenance;
+
     // get next notification date.
 
     if (
@@ -455,7 +492,7 @@ export class Service extends DatabaseService<Model> {
       scheduledMaintenanceFeedEventType:
         ScheduledMaintenanceFeedEventType.ScheduledMaintenanceCreated,
       displayColor: Red500,
-      feedInfoInMarkdown: `**Scheduled Maintenance Created**: 
+      feedInfoInMarkdown: `**Scheduled Maintenance #${createdItem.scheduledMaintenanceNumber?.toString()} Created**: 
           
 **Scheduled Maintenance Title**:
 

package/Server/Services/UserService.ts

@@ -1,7 +1,7 @@
 import DatabaseConfig from "../DatabaseConfig";
 import {
   IsBillingEnabled,
-  NotificationWebhookOnCreateUser,
+  NotificationSlackWebhookOnCreateUser,
 } from "../EnvironmentConfig";
 import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import UpdateBy from "../Types/Database/UpdateBy";
@@ -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";
+import SlackUtil from "../Utils/Slack/Slack";
 import UserTwoFactorAuth from "Common/Models/DatabaseModels/UserTwoFactorAuth";
 import UserTwoFactorAuthService from "./UserTwoFactorAuthService";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -42,9 +42,9 @@ export class Service extends DatabaseService<Model> {
     _onCreate: OnCreate<Model>,
     createdItem: Model,
   ): Promise<Model> {
-    if (NotificationWebhookOnCreateUser) {
+    if (NotificationSlackWebhookOnCreateUser) {
       SlackUtil.sendMessageToChannel({
-        url: URL.fromString(NotificationWebhookOnCreateUser),
+        url: URL.fromString(NotificationSlackWebhookOnCreateUser),
         text: `*New OneUptime User:* 
   *Email:* ${createdItem.email?.toString() || "N/A"}
   *Name:* ${createdItem.name?.toString() || "N/A"}

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -0,0 +1,22 @@
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import { WorkspaceNotificationPayload } from "../../Types/Workspace/WorkspaceNotificationPayload";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import logger from "../Utils/Logger";
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async notifyWorkspace(data: {
+    workspaceType: WorkspaceType;
+    notificationRuleEventType: NotificationRuleEventType;
+    workspaceNotificationPayload: WorkspaceNotificationPayload;
+  }): Promise<void> {
+    logger.debug("Notify Workspace");
+    logger.debug(data);
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceProjectAuthTokenService.ts

@@ -0,0 +1,84 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackMiscData,
+} from "Common/Models/DatabaseModels/WorkspaceProjectAuthToken";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshAuthToken(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    authToken: string;
+    workspaceProjectId: string;
+    miscData: SlackMiscData;
+  }): Promise<void> {
+    let projectAuth: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!projectAuth) {
+      projectAuth = new Model();
+
+      projectAuth.projectId = data.projectId;
+      projectAuth.authToken = data.authToken;
+      projectAuth.workspaceType = data.workspaceType;
+      projectAuth.workspaceProjectId = data.workspaceProjectId;
+      projectAuth.miscData = data.miscData;
+
+      await this.create({
+        data: projectAuth,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: projectAuth.id!,
+        data: {
+          authToken: data.authToken,
+          workspaceProjectId: data.workspaceProjectId,
+          miscData: data.miscData,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceSettingService.ts

@@ -0,0 +1,78 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackSettings,
+} from "Common/Models/DatabaseModels/WorkspaceSetting";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshSetting(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    settings: SlackSettings;
+  }): Promise<void> {
+    let workspaceSetting: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!workspaceSetting) {
+      workspaceSetting = new Model();
+
+      workspaceSetting.projectId = data.projectId;
+      workspaceSetting.settings = data.settings;
+      workspaceSetting.workspaceType = data.workspaceType;
+
+      await this.create({
+        data: workspaceSetting,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: workspaceSetting.id!,
+        data: {
+          settings: data.settings,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceUserAuthTokenService.ts

@@ -0,0 +1,89 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackMiscData,
+} from "Common/Models/DatabaseModels/WorkspaceUserAuthToken";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            userId: data.userId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshAuthToken(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    workspaceType: WorkspaceType;
+    authToken: string;
+    workspaceUserId: string;
+    miscData: SlackMiscData;
+  }): Promise<void> {
+    let userAuth: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        userId: data.userId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!userAuth) {
+      userAuth = new Model();
+
+      userAuth.projectId = data.projectId;
+      userAuth.userId = data.userId;
+      userAuth.authToken = data.authToken;
+      userAuth.workspaceType = data.workspaceType;
+      userAuth.workspaceUserId = data.workspaceUserId;
+      userAuth.miscData = data.miscData;
+
+      await this.create({
+        data: userAuth,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: userAuth.id!,
+        data: {
+          authToken: data.authToken,
+          workspaceUserId: data.workspaceUserId,
+          miscData: data.miscData,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

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";
+import SlackUtil from "../../../../Utils/Slack/Slack";
 
 export default class SendMessageToChannel extends ComponentCode {
   public constructor() {

package/Server/Utils/Express.ts

@@ -37,7 +37,8 @@ export interface OneUptimeRequest extends express.Request {
   userAuthorization?: JSONWebTokenData;
   tenantId?: ObjectID;
   userGlobalAccessPermission?: UserGlobalAccessPermission;
-  userTenantAccessPermission?: Dictionary<UserTenantAccessPermission>; // tenantId <-> UserTenantAccessPermission
+  userTenantAccessPermission?: Dictionary<UserTenantAccessPermission>; // tenantId <-> UserTenantAccessPermission;
+  rawBody?: string; // raw body of the request before json parsing.
 }
 
 export interface OneUptimeResponse extends express.Response {

package/Server/Utils/Monitor/MonitorResource.ts

@@ -16,11 +16,7 @@ import BadDataException from "Common/Types/Exception/BadDataException";
 import BasicInfrastructureMetrics from "Common/Types/Infrastructure/BasicMetrics";
 import ReturnResult from "Common/Types/IsolatedVM/ReturnResult";
 import { JSONObject } from "Common/Types/JSON";
-import {
-  CheckOn,
-  CriteriaFilter,
-  FilterCondition,
-} from "Common/Types/Monitor/CriteriaFilter";
+import { CheckOn, CriteriaFilter } from "Common/Types/Monitor/CriteriaFilter";
 import IncomingMonitorRequest from "Common/Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import MonitorCriteria from "Common/Types/Monitor/MonitorCriteria";
 import MonitorCriteriaInstance from "Common/Types/Monitor/MonitorCriteriaInstance";
@@ -57,6 +53,7 @@ import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
 import TelemetryUtil from "../Telemetry/Telemetry";
 import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
 
 export default class MonitorResourceUtil {
   public static async monitorResource(

package/Server/Utils/{Slack.ts → Slack/Slack.ts}

@@ -5,6 +5,46 @@ import { JSONObject } from "Common/Types/JSON";
 import API from "Common/Utils/API";
 
 export default class SlackUtil {
+  public async getTextboxField(data: {
+    title: string;
+    placeholder: string;
+    actionId: string;
+    initialValue?: string;
+  }): Promise<JSONObject> {
+    return {
+      type: "input",
+      element: {
+        type: "plain_text_input",
+        action_id: data.actionId,
+        placeholder: {
+          type: "plain_text",
+          text: data.placeholder,
+        },
+        initial_value: data.initialValue,
+      },
+      label: {
+        type: "plain_text",
+        text: data.title,
+      },
+    };
+  }
+
+  public getButtonField(data: {
+    text: string;
+    actionId: string;
+    value: string;
+  }): JSONObject {
+    return {
+      type: "button",
+      text: {
+        type: "plain_text",
+        text: data.text,
+      },
+      action_id: data.actionId,
+      value: data.value,
+    };
+  }
+
   public static async sendMessageToChannel(data: {
     url: URL;
     text: string;

package/Server/Utils/Slack/app-manifest-temp.json

@@ -0,0 +1,198 @@
+{
+    "display_information": {
+        "name": "OneUptime",
+        "description": "The Complete Open-Source Observability Platform",
+        "background_color": "#000000",
+        "long_description": "OneUptime is a comprehensive solution for monitoring and managing your online services. Whether you need to check the availability of your website, dashboard, API, or any other online resource, OneUptime can alert your team when downtime happens and keep your customers informed with a status page. OneUptime also helps you handle incidents, set up on-call rotations, run tests, secure your services, analyze logs, track performance, and debug errors."
+    },
+    "features": {
+        "app_home": {
+            "home_tab_enabled": true,
+            "messages_tab_enabled": false,
+            "messages_tab_read_only_enabled": false
+        },
+        "bot_user": {
+            "display_name": "OneUptime",
+            "always_online": true
+        },
+        "shortcuts": [
+            {
+                "name": "Create Scheduled Event",
+                "type": "global",
+                "callback_id": "create-scheduled-maintenance",
+                "description": "Create a new scheduled event in OneUptime"
+            },
+            {
+                "name": "Create New Incident",
+                "type": "global",
+                "callback_id": "create-incident",
+                "description": "Creates a new incident in OneUptime"
+            }
+        ],
+        "slash_commands": [
+            {
+                "command": "/oneuptime",
+                "url": "https://local.genosyn.com/api/slack/command",
+                "description": "OneUptime command",
+                "usage_hint": "incident, scheduled event.",
+                "should_escape": false
+            }
+        ]
+    },
+    "oauth_config": {
+        "redirect_urls": [
+            "https://local.genosyn.com/api/slack/auth"
+        ],
+        "scopes": {
+            "user": [
+                "users:read",
+                "users:read.email",
+                "bookmarks:read",
+                "workflows.templates:write",
+                "workflows.templates:read",
+                "users:write",
+                "users.profile:write",
+                "users.profile:read",
+                "usergroups:write",
+                "usergroups:read",
+                "team:read",
+                "team.preferences:read",
+                "team.billing:read",
+                "stars:write",
+                "stars:read",
+                "search:read",
+                "remote_files:share",
+                "reminders:read",
+                "remote_files:read",
+                "reminders:write",
+                "reactions:write",
+                "reactions:read",
+                "profile",
+                "pins:write",
+                "pins:read",
+                "openid",
+                "mpim:write.topic",
+                "mpim:write",
+                "mpim:read",
+                "mpim:history",
+                "links:write",
+                "links:read",
+                "links.embed:write",
+                "im:write.topic",
+                "im:write",
+                "im:read",
+                "im:history",
+                "identity.team",
+                "identity.email",
+                "identity.basic",
+                "identity.avatar",
+                "identify",
+                "groups:write.topic",
+                "groups:write.invites",
+                "groups:write",
+                "groups:read",
+                "groups:history",
+                "files:write",
+                "files:read",
+                "emoji:read",
+                "email",
+                "dnd:write",
+                "dnd:read",
+                "chat:write",
+                "channels:write.topic",
+                "channels:write.invites",
+                "channels:write",
+                "channels:read",
+                "channels:history",
+                "canvases:write",
+                "canvases:read",
+                "calls:write",
+                "calls:read",
+                "bookmarks:write"
+            ],
+            "bot": [
+                "app_mentions:read",
+                "assistant:write",
+                "bookmarks:read",
+                "bookmarks:write",
+                "calls:write",
+                "calls:read",
+                "canvases:read",
+                "canvases:write",
+                "channels:history",
+                "channels:join",
+                "channels:manage",
+                "channels:read",
+                "channels:write.invites",
+                "channels:write.topic",
+                "chat:write",
+                "chat:write.customize",
+                "chat:write.public",
+                "commands",
+                "conversations.connect:manage",
+                "conversations.connect:read",
+                "files:read",
+                "conversations.connect:write",
+                "dnd:read",
+                "emoji:read",
+                "files:write",
+                "groups:history",
+                "groups:read",
+                "groups:write",
+                "groups:write.invites",
+                "groups:write.topic",
+                "im:read",
+                "im:history",
+                "incoming-webhook",
+                "links.embed:write",
+                "im:write.topic",
+                "im:write",
+                "links:read",
+                "links:write",
+                "metadata.message:read",
+                "mpim:history",
+                "pins:read",
+                "users:read.email",
+                "users:read",
+                "mpim:read",
+                "mpim:write",
+                "mpim:write.topic",
+                "pins:write",
+                "reactions:write",
+                "reactions:read",
+                "reminders:read",
+                "search:read.files",
+                "remote_files:write",
+                "remote_files:share",
+                "reminders:write",
+                "remote_files:read",
+                "search:read.im",
+                "team.billing:read",
+                "team.preferences:read",
+                "search:read.mpim",
+                "search:read.private",
+                "search:read.public",
+                "usergroups:read",
+                "usergroups:write",
+                "triggers:write",
+                "team:read",
+                "triggers:read",
+                "users.profile:read",
+                "users:write",
+                "workflows.templates:read",
+                "workflow.steps:execute",
+                "workflows.templates:write"
+            ]
+        }
+    },
+    "settings": {
+        "interactivity": {
+            "is_enabled": true,
+            "request_url": "https://local.genosyn.com/api/slack/interactive",
+            "message_menu_options_url": "https://local.genosyn.com/api/slack/options-load"
+        },
+        "org_deploy_enabled": true,
+        "socket_mode_enabled": false,
+        "token_rotation_enabled": false
+    }
+}