@oneuptime/common 7.0.3717 → 7.0.3786

package/Types/Workspace/NotificationRules/NotificationRuleUtil.ts

@@ -1,3 +1,4 @@
+import logger from "../../../Server/Utils/Logger";
 import FilterCondition from "../../Filter/FilterCondition";
 import {
   ConditionType,
@@ -17,20 +18,37 @@ export class WorkspaceNotificationRuleUtil {
   }): boolean {
     const notificationRule: IncidentNotificationRule = data.notificationRule;
 
+    logger.debug("Checking if rule matches for notificationRule:");
+    logger.debug(notificationRule);
+
     // no filters means all filters are matched
     if (data.notificationRule.filters.length === 0) {
+      logger.debug("No filters found. Rule matches by default.");
       return true;
     }
 
     const filterCondition: FilterCondition = notificationRule.filterCondition;
 
+    logger.debug("Filter condition:");
+    logger.debug(filterCondition);
+
     for (const filter of notificationRule.filters) {
       const value: string | Array<string> | undefined =
         data.values[filter.checkOn];
       const condition: ConditionType | undefined = filter.conditionType;
       const filterValue: string | Array<string> | undefined = filter.value;
 
+      logger.debug("Evaluating filter:");
+      logger.debug(filter);
+      logger.debug("Value:");
+      logger.debug(value);
+      logger.debug("Condition:");
+      logger.debug(condition);
+      logger.debug("Filter value:");
+      logger.debug(filterValue);
+
       if (!condition) {
+        logger.debug("No condition found for filter. Skipping.");
         continue;
       }
 
@@ -40,27 +58,39 @@ export class WorkspaceNotificationRuleUtil {
         filterValue,
       });
 
+      logger.debug("Filter match result:");
+      logger.debug(isMatched);
+
       if (filterCondition === FilterCondition.All) {
         if (!isMatched) {
+          logger.debug(
+            "Filter condition is 'All' and a filter did not match. Rule does not match.",
+          );
           return false;
         }
       }
 
       if (filterCondition === FilterCondition.Any) {
         if (isMatched) {
+          logger.debug(
+            "Filter condition is 'Any' and a filter matched. Rule matches.",
+          );
           return true;
         }
       }
     }
 
     if (filterCondition === FilterCondition.All) {
+      logger.debug("All filters matched. Rule matches.");
       return true;
     }
 
     if (filterCondition === FilterCondition.Any) {
+      logger.debug("No filters matched. Rule does not match.");
       return false;
     }
 
+    logger.debug("No valid filter condition found. Rule does not match.");
     return false;
   }
 
@@ -73,187 +103,287 @@ export class WorkspaceNotificationRuleUtil {
     const condition: ConditionType = data.condition;
     const filterValue: string | Array<string> | undefined = data.filterValue;
 
+    logger.debug("Checking condition match:");
+    logger.debug("Value:");
+    logger.debug(value);
+    logger.debug("Condition:");
+    logger.debug(condition);
+    logger.debug("Filter value:");
+    logger.debug(filterValue);
+
     if (value === undefined || filterValue === undefined) {
+      logger.debug(
+        "Value or filter value is undefined. Condition does not match.",
+      );
       return false;
     }
 
     switch (condition) {
       case ConditionType.EqualTo: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.includes(val);
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        const result: boolean = values.every((val: string) => {
+          return filterValues.every((fVal: string) => {
+            // if val and fVal can be  converted to numbers, compare them as numbers
+            if (!isNaN(Number(val)) && !isNaN(Number(fVal))) {
+              return Number(val) === Number(fVal);
+            }
+
+            return val === fVal;
           });
-        }
-        return value === filterValue;
+        });
+        logger.debug("EqualTo condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.NotEqualTo: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return !value.every((val: string) => {
-            return filterValue.includes(val);
-          });
-        }
-        return value !== filterValue;
+        const result: boolean =
+          Array.isArray(value) && Array.isArray(filterValue)
+            ? !value.every((val: string) => {
+                return filterValue.includes(val);
+              })
+            : value !== filterValue;
+        logger.debug("NotEqualTo condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.GreaterThan: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.every((fVal: string) => {
-              return val > fVal;
-            });
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        const result: boolean = values.every((val: string) => {
+          return filterValues.every((fVal: string) => {
+            // if val and fVal can be  converted to numbers, compare them as numbers
+            if (!isNaN(Number(val)) && !isNaN(Number(fVal))) {
+              return Number(val) > Number(fVal);
+            }
+
+            return val > fVal;
           });
-        } else if (value !== undefined && filterValue !== undefined) {
-          return value > filterValue;
-        }
-        return false;
+        });
+        logger.debug("GreaterThan condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.LessThan: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.every((fVal: string) => {
-              return val < fVal;
-            });
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        const result: boolean = values.every((val: string) => {
+          return filterValues.every((fVal: string) => {
+            // if val and fVal can be  converted to numbers, compare them as numbers
+            if (!isNaN(Number(val)) && !isNaN(Number(fVal))) {
+              return Number(val) < Number(fVal);
+            }
+
+            return val < fVal;
           });
-        } else if (value !== undefined && filterValue !== undefined) {
-          return value < filterValue;
-        }
-        return false;
+        });
+        logger.debug("LessThan condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.GreaterThanOrEqualTo: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.every((fVal: string) => {
-              return val >= fVal;
-            });
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        const result: boolean = values.every((val: string) => {
+          return filterValues.every((fVal: string) => {
+            // if val and fVal can be  converted to numbers, compare them as numbers
+            if (!isNaN(Number(val)) && !isNaN(Number(fVal))) {
+              return Number(val) >= Number(fVal);
+            }
+
+            return val >= fVal;
           });
-        } else if (value !== undefined && filterValue !== undefined) {
-          return value >= filterValue;
-        }
-        return false;
+        });
+        logger.debug("GreaterThanOrEqualTo condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.LessThanOrEqualTo: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.every((fVal: string) => {
-              return val <= fVal;
-            });
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        const result: boolean = values.every((val: string) => {
+          return filterValues.every((fVal: string) => {
+            // if val and fVal can be  converted to numbers, compare them as numbers
+            if (!isNaN(Number(val)) && !isNaN(Number(fVal))) {
+              return Number(val) <= Number(fVal);
+            }
+
+            return val <= fVal;
           });
-        } else if (value !== undefined && filterValue !== undefined) {
-          return value <= filterValue;
-        }
-        return false;
+        });
+
+        logger.debug("LessThanOrEqualTo condition result:");
+        logger.debug(result);
+        return result;
       }
 
-      case ConditionType.ContainsAny: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.some((val: string) => {
-            return filterValue.includes(val);
-          });
-        } else if (
-          value !== undefined &&
-          filterValue !== undefined &&
-          typeof value === "string"
-        ) {
-          return filterValue.includes(value);
+      case ConditionType.ContainsAny:
+      case ConditionType.Contains: {
+        const result: boolean = false;
+
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        logger.debug("Values:");
+        logger.debug(values);
+        logger.debug("Filter values:");
+        logger.debug(filterValues);
+
+        for (const val of values) {
+          for (const fVal of filterValues) {
+            if (val.includes(fVal)) {
+              logger.debug("ContainsAny condition result:");
+              logger.debug(true);
+              return true;
+            }
+          }
         }
-        return false;
+
+        logger.debug("ContainsAny condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.NotContains: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return !value.some((val: string) => {
-            return filterValue.includes(val);
-          });
-        } else if (
-          value !== undefined &&
-          filterValue !== undefined &&
-          typeof value === "string"
-        ) {
-          return !filterValue.includes(value);
+        const result: boolean = true;
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        for (const val of values) {
+          for (const fVal of filterValues) {
+            if (val.includes(fVal)) {
+              logger.debug("NotContains condition result:");
+              logger.debug(false);
+              return false;
+            }
+          }
         }
-        return false;
+
+        logger.debug("NotContains condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.StartsWith: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.every((fVal: string) => {
-              return val.startsWith(fVal);
-            });
-          });
-        } else if (
-          value !== undefined &&
-          filterValue !== undefined &&
-          typeof value === "string"
-        ) {
-          return value.startsWith(filterValue.toString());
+        const result: boolean = false;
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        for (const val of values) {
+          for (const fVal of filterValues) {
+            if (val.startsWith(fVal)) {
+              logger.debug("StartsWith condition result:");
+              logger.debug(true);
+              return true;
+            }
+          }
         }
-        return false;
+
+        logger.debug("StartsWith condition result:");
+        logger.debug(result);
+
+        return result;
       }
 
       case ConditionType.EndsWith: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return value.every((val: string) => {
-            return filterValue.every((fVal: string) => {
-              return val.endsWith(fVal);
-            });
-          });
-        } else if (
-          value !== undefined &&
-          filterValue !== undefined &&
-          typeof value === "string"
-        ) {
-          return value.endsWith(filterValue.toString());
+        const result: boolean = false;
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        for (const val of values) {
+          for (const fVal of filterValues) {
+            if (val.endsWith(fVal)) {
+              logger.debug("StartsWith condition result:");
+              logger.debug(true);
+              return true;
+            }
+          }
         }
-        return false;
+
+        logger.debug("StartsWith condition result:");
+        logger.debug(result);
+
+        return result;
       }
 
       case ConditionType.IsEmpty: {
-        if (Array.isArray(value)) {
-          return value.length === 0;
-        }
-        return value === "" || value === undefined;
+        const result: boolean = Array.isArray(value)
+          ? value.length === 0
+          : value === "";
+        logger.debug("IsEmpty condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.IsNotEmpty: {
-        if (Array.isArray(value)) {
-          return value.length > 0;
-        }
-        return value !== "" && value !== undefined;
+        const result: boolean = Array.isArray(value)
+          ? value.length > 0
+          : value !== "";
+        logger.debug("IsNotEmpty condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.True: {
-        if (Array.isArray(value)) {
-          return value.every((val: string) => {
-            return val === "true";
-          });
-        }
-        return value === "true";
+        const result: boolean = value === "true";
+        logger.debug("True condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.False: {
-        if (Array.isArray(value)) {
-          return value.every((val: string) => {
-            return val === "false";
-          });
-        }
-        return value === "false";
+        const result: boolean = value === "false";
+        logger.debug("False condition result:");
+        logger.debug(result);
+        return result;
       }
 
       case ConditionType.ContainsAll: {
-        if (Array.isArray(value) && Array.isArray(filterValue)) {
-          return filterValue.every((fVal: string) => {
-            return value.includes(fVal);
+        const values: string[] = Array.isArray(value) ? value : [value];
+        const filterValues: string[] = Array.isArray(filterValue)
+          ? filterValue
+          : [filterValue];
+
+        const result: boolean = filterValues.every((fVal: string) => {
+          return values.some((val: string) => {
+            return val.includes(fVal);
           });
-        }
-        return false;
+        });
+        logger.debug("ContainsAll condition result:");
+        logger.debug(result);
+        return result;
       }
 
       default: {
+        logger.debug("Unknown condition type. Condition does not match.");
         return false;
       }
     }

package/Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel.ts

@@ -0,0 +1,6 @@
+import { WorkspaceChannel } from "../../../Server/Utils/Workspace/WorkspaceBase";
+
+export default interface NotificationRuleWorkspaceChannel
+  extends WorkspaceChannel {
+  notificationRuleId: string;
+}

package/Types/Workspace/WorkspaceMessagePayload.ts

@@ -1,11 +1,17 @@
+import { DropdownOption } from "../../UI/Components/Dropdown/Dropdown";
+import URL from "../API/URL";
+import WorkspaceType from "./WorkspaceType";
+
 export interface WorkspaceMessageBlock {
   _type: string;
-  onlyPostToTheseChannelNames?: Array<string>;
 }
 
 export interface WorkspaceMessagePayloadButton {
+  _type: "WorkspaceMessagePayloadButton";
   title: string; // Button title.
-  onlyPostToTheseChannelNames?: Array<string>; // Channel names to send message to.
+  value: string; // Button value.
+  actionId: string; // Button action id.
+  url?: URL | undefined; // Button url.
 }
 
 export interface WorkspacePayloadHeader extends WorkspaceMessageBlock {
@@ -13,11 +19,72 @@ export interface WorkspacePayloadHeader extends WorkspaceMessageBlock {
   text: string;
 }
 
+export interface WorkspaceTextAreaBlock extends WorkspaceMessageBlock {
+  _type: "WorkspaceTextAreaBlock";
+  label: string;
+  blockId: string;
+  placeholder: string;
+  initialValue?: string | undefined;
+  description?: string | undefined;
+  optional?: boolean | undefined;
+}
+
+export interface WorkspaceTextBoxBlock extends WorkspaceMessageBlock {
+  _type: "WorkspaceTextBoxBlock";
+  label: string;
+  blockId: string;
+  placeholder: string;
+  initialValue?: string | undefined;
+  description?: string | undefined;
+  optional?: boolean | undefined;
+}
+
+export interface WorkspacePayloadImage extends WorkspaceMessageBlock {
+  _type: "WorkspacePayloadImage";
+  imageUrl: URL;
+  altText: string;
+}
+
+export interface WorkspaceCheckboxBlock extends WorkspaceMessageBlock {
+  _type: "WorkspaceCheckboxBlock";
+  label: string;
+  blockId: string;
+  initialValue?: boolean | undefined;
+  description?: string | undefined;
+  optional?: boolean | undefined;
+}
+
+export interface WorkspaceDropdownBlock extends WorkspaceMessageBlock {
+  _type: "WorkspaceDropdownBlock";
+  label: string;
+  blockId: string;
+  options: Array<DropdownOption>;
+  placeholder: string;
+  initialValue?: string | undefined;
+  description?: string | undefined;
+  multiSelect?: boolean | undefined;
+  optional?: boolean | undefined;
+}
+
+export interface WorkspaceModalBlock extends WorkspaceMessageBlock {
+  _type: "WorkspaceModalBlock";
+  title: string;
+  actionId: string;
+  actionValue: string;
+  submitButtonTitle: string;
+  cancelButtonTitle: string;
+  blocks: Array<WorkspaceMessageBlock>;
+}
+
 export interface WorkspacePayloadMarkdown extends WorkspaceMessageBlock {
   _type: "WorkspacePayloadMarkdown";
   text: string;
 }
 
+export interface WorkspacePayloadDivider extends WorkspaceMessageBlock {
+  _type: "WorkspacePayloadDivider";
+}
+
 export interface WorkspacePayloadButtons extends WorkspaceMessageBlock {
   _type: "WorkspacePayloadButtons";
   buttons: Array<WorkspaceMessagePayloadButton>;
@@ -26,5 +93,7 @@ export interface WorkspacePayloadButtons extends WorkspaceMessageBlock {
 export default interface WorkspaceMessagePayload {
   _type: "WorkspaceMessagePayload";
   channelNames: Array<string>; // Channel ids to send message to.
+  channelIds: Array<string>; // Channel ids to send message to.
   messageBlocks: Array<WorkspaceMessageBlock>; // Message to add to blocks.
+  workspaceType: WorkspaceType;
 }

package/UI/Components/ComingSoon/ComingSoon.tsx

@@ -2,13 +2,23 @@ import EmptyState from "../EmptyState/EmptyState";
 import IconProp from "Common/Types/Icon/IconProp";
 import React, { FunctionComponent, ReactElement } from "react";
 
-const ComingSoon: FunctionComponent = (): ReactElement => {
+export interface ComponentProps {
+  title?: string | undefined;
+  description?: string | undefined;
+}
+
+const ComingSoon: FunctionComponent<ComponentProps> = (
+  props: ComponentProps,
+): ReactElement => {
   return (
     <EmptyState
       id="coming-soon"
       icon={IconProp.CursorArrowRays}
-      title="Coming soon!"
-      description="We will be launching this feature very soon. Stay Tuned!"
+      title={props.title || "Coming soon!"}
+      description={
+        props.description ||
+        "We will be launching this feature very soon. Stay Tuned!"
+      }
     />
   );
 };

package/UI/Components/Forms/Fields/FormField.tsx

@@ -394,7 +394,7 @@ const FormField: <T extends GenericObject>(
                   },
                 ) || []
               }
-              initialValue={
+              value={
                 props.currentValues &&
                 (props.currentValues as any)[props.fieldName]
                   ? (props.currentValues as any)[props.fieldName]
@@ -584,7 +584,7 @@ const FormField: <T extends GenericObject>(
                 props.setFieldTouched(props.fieldName, true);
               }}
               dataTestId={props.field.dataTestId}
-              initialValue={booleanValue}
+              value={booleanValue}
             />
           )}