@oneuptime/common 7.0.3621 → 7.0.3652

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
+    }
+}

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

@@ -0,0 +1,67 @@
+{
+    "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": [
+                "identity.email",
+                "identity.basic",
+                "email"
+            ],
+            "bot": [
+                "commands"
+            ]
+        }
+    },
+    "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
+    }
+}

package/Server/Utils/StartServer.ts

@@ -12,6 +12,7 @@ import Express, {
   ExpressStatic,
   ExpressUrlEncoded,
   NextFunction,
+  OneUptimeRequest,
   RequestHandler,
 } from "./Express";
 import logger from "./Logger";
@@ -82,7 +83,7 @@ app.set("view engine", "ejs");
  * https://stackoverflow.com/questions/19917401/error-request-entity-too-large
  */
 
-app.use((req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+app.use((req: OneUptimeRequest, res: ExpressResponse, next: NextFunction) => {
   if (req.headers["content-encoding"] === "gzip") {
     const buffers: any = [];
 

package/Types/Filter/FilterCondition.ts

@@ -1,6 +1,6 @@
 enum FilterCondition {
-  And = "And",
-  Or = "Or",
+  All = "All",
+  Any = "Any",
 }
 
 export default FilterCondition;

package/Types/Monitor/CriteriaFilter.ts

@@ -110,12 +110,38 @@ export enum FilterType {
   IsNotExecuting = "Is Not Executing",
 }
 
-export enum FilterCondition {
-  All = "All",
-  Any = "Any",
-}
-
 export class CriteriaFilterUtil {
+  public static hasValueField(data: {
+    checkOn: CheckOn;
+    filterType: FilterType | undefined;
+  }): boolean {
+    const { checkOn } = data;
+
+    if (checkOn === CheckOn.IsOnline) {
+      return false;
+    }
+
+    if (
+      checkOn === CheckOn.IsValidCertificate ||
+      checkOn === CheckOn.IsSelfSignedCertificate ||
+      checkOn === CheckOn.IsExpiredCertificate ||
+      checkOn === CheckOn.IsNotAValidCertificate
+    ) {
+      return false;
+    }
+
+    if (
+      FilterType.IsEmpty === data.filterType ||
+      FilterType.IsNotEmpty === data.filterType ||
+      FilterType.True === data.filterType ||
+      FilterType.False === data.filterType
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
   public static getEvaluateOverTimeTypeByCriteriaFilter(
     criteriaFilter: CriteriaFilter | undefined,
   ): Array<EvaluateOverTimeType> {

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -1,5 +1,6 @@
 import DatabaseProperty from "../Database/DatabaseProperty";
 import BadDataException from "../Exception/BadDataException";
+import FilterCondition from "../Filter/FilterCondition";
 import { JSONObject, ObjectType } from "../JSON";
 import JSONFunctions from "../JSONFunctions";
 import ObjectID from "../ObjectID";
@@ -8,9 +9,9 @@ import { CriteriaAlert } from "./CriteriaAlert";
 import {
   CheckOn,
   CriteriaFilter,
-  FilterCondition,
   FilterType,
   EvaluateOverTimeType,
+  CriteriaFilterUtil,
 } from "./CriteriaFilter";
 import { CriteriaIncident } from "./CriteriaIncident";
 import MonitorType from "./MonitorType";
@@ -699,19 +700,19 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
     monitorType: MonitorType,
   ): string | null {
     if (!value.data) {
-      return "Monitor Step is required";
+      return `Monitor Step is required.`;
     }
 
     if (value.data.filters.length === 0) {
-      return "Monitor Criteria filter is required";
+      return `Filter is required for criteria "${value.data.name}"`;
     }
 
     if (!value.data.name) {
-      return "Monitor Criteria name is required";
+      return `Name is required for criteria "${value.data.name}"`;
     }
 
     if (!value.data.description) {
-      return "Monitor Criteria description is required";
+      return `Description is required for criteria "${value.data.name}"`;
     }
 
     for (const incident of value.data.incidents) {
@@ -720,21 +721,39 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       }
 
       if (!incident.title) {
-        return "Monitor Criteria incident title is required";
+        return `Incident title is required for criteria "${value.data.name}"`;
       }
 
       if (!incident.description) {
-        return "Monitor Criteria incident description is required";
+        return `Incident description is required for criteria "${value.data.name}"`;
       }
 
       if (!incident.incidentSeverityId) {
-        return "Monitor Criteria incident severity is required";
+        return `Incident severity is required for criteria "${value.data.name}"`;
+      }
+    }
+
+    for (const alert of value.data.alerts) {
+      if (!alert) {
+        continue;
+      }
+
+      if (!alert.title) {
+        return `Alert title is required for criteria "${value.data.name}"`;
+      }
+
+      if (!alert.description) {
+        return `Alert description is required for criteria "${value.data.name}"`;
+      }
+
+      if (!alert.alertSeverityId) {
+        return `Alert severity is required for criteria "${value.data.name}"`;
       }
     }
 
     for (const filter of value.data.filters) {
       if (!filter.checkOn) {
-        return "Monitor Criteria filter check on is required";
+        return `Filter Type is required for criteria "${value.data.name}"`;
       }
 
       if (
@@ -742,7 +761,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         filter.checkOn !== CheckOn.IsOnline &&
         filter.checkOn !== CheckOn.ResponseTime
       ) {
-        return "Ping  Monitor cannot have filter criteria: " + filter.checkOn;
+        return "Ping Monitor cannot have filter type: " + filter.checkOn;
       }
 
       if (
@@ -751,6 +770,17 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       ) {
         return "Disk Path is required for Disk Usage Percent";
       }
+
+      if (
+        CriteriaFilterUtil.hasValueField({
+          checkOn: filter.checkOn,
+          filterType: filter.filterType,
+        })
+      ) {
+        if (!filter.value && filter.value !== 0) {
+          return `Value is required for criteria "${value.data.name}" on filter type: ${filter.checkOn}`;
+        }
+      }
     }
 
     return null;

package/Types/Monitor/MonitorStep.ts

@@ -252,7 +252,7 @@ export default class MonitorStep extends DatabaseProperty {
     }
 
     if (
-      !MonitorCriteria.getValidationError(
+      MonitorCriteria.getValidationError(
         value.data.monitorCriteria,
         monitorType,
       )