@oneuptime/common 13.0.1 → 13.0.3

package/Utils/LabelRuleImportExport.ts

@@ -34,7 +34,15 @@ import { TableColumnMetadata } from "../Types/Database/TableColumn";
 import TableColumnType from "../Types/Database/TableColumnType";
 import BadDataException from "../Types/Exception/BadDataException";
 import { JSONObject, JSONValue } from "../Types/JSON";
+import RuleCriteria, {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../Types/Rules/RuleCriteria";
 import ModelImportExport from "./ModelImportExport";
+import {
+  getRuleCriteriaValidationError,
+  isValidRuleCriteria,
+} from "./Rules/RuleCriteriaMatcher";
 import RulePatternMatchUtil from "./Rules/RulePatternMatchUtil";
 
 export const LABEL_RULE_EXPORT_FILE_TYPE: string = "oneuptime-label-rules";
@@ -77,6 +85,11 @@ export interface ParsedLabelRuleImport {
   items: Array<{ json: JSONObject; portableJson: JSONObject }>;
 }
 
+export type LabelRuleCriteriaRelationNames = Map<
+  DatabaseBaseModelType,
+  Map<string, string>
+>;
+
 export default class LabelRuleImportExport {
   public static isLabelRuleModel(modelType: DatabaseBaseModelType): boolean {
     return LABEL_RULE_MODELS.includes(modelType);
@@ -126,6 +139,7 @@ export default class LabelRuleImportExport {
     modelType: DatabaseBaseModelType;
     items: Array<BaseModel>;
     exportedAt?: Date | undefined;
+    criteriaRelationNames?: LabelRuleCriteriaRelationNames | undefined;
   }): JSONObject {
     const model: BaseModel = new data.modelType();
     const columns: Array<string> = this.getColumns(data.modelType);
@@ -136,7 +150,16 @@ export default class LabelRuleImportExport {
           const metadata: TableColumnMetadata =
             model.getTableColumnMetadata(column)!;
           const value: unknown = item.getValue(column);
-          if (metadata.type === TableColumnType.EntityArray) {
+          if (column === "criteria" && value !== undefined && value !== null) {
+            json[column] = this.toPortableCriteria({
+              modelType: data.modelType,
+              model,
+              item,
+              criteria: value,
+              criteriaRelationNames: data.criteriaRelationNames,
+              ruleIndex: index,
+            }) as unknown as JSONObject;
+          } else if (metadata.type === TableColumnType.EntityArray) {
             if (!Array.isArray(value)) {
               throw new BadDataException(
                 `Rule ${index + 1}: ${metadata.title || column} could not be read. Refresh and try exporting again.`,
@@ -253,6 +276,23 @@ export default class LabelRuleImportExport {
           }
           const metadata: TableColumnMetadata =
             source.getTableColumnMetadata(column)!;
+          if (column === "criteria") {
+            if (input[column] === null || input[column] === undefined) {
+              portableJson[column] = input[column];
+              continue;
+            }
+            const mappedCriteria: RuleCriteria = this.mapPortableCriteria({
+              criteria: input[column],
+              sourceType,
+              source,
+              destination,
+              destinationColumns,
+              mappings,
+            });
+            portableJson[column] = input[column];
+            json[column] = mappedCriteria as unknown as JSONObject;
+            continue;
+          }
           this.validateValue(
             column,
             input[column],
@@ -358,6 +398,258 @@ export default class LabelRuleImportExport {
     };
   }
 
+  private static toPortableCriteria(data: {
+    modelType: DatabaseBaseModelType;
+    model: BaseModel;
+    item: BaseModel;
+    criteria: unknown;
+    criteriaRelationNames?: LabelRuleCriteriaRelationNames | undefined;
+    ruleIndex: number;
+  }): RuleCriteria {
+    const validationError: string | null = getRuleCriteriaValidationError(
+      data.criteria,
+    );
+    if (validationError || !isValidRuleCriteria(data.criteria)) {
+      throw new BadDataException(
+        `Rule ${data.ruleIndex + 1}: Match Criteria is invalid. ${validationError || "Check the configured conditions."}`,
+      );
+    }
+
+    const allowedFields: Array<string> = this.getColumns(data.modelType).filter(
+      (column: string): boolean => {
+        return column !== "criteria";
+      },
+    );
+    const itemRelationNames: LabelRuleCriteriaRelationNames =
+      this.getItemRelationNames(data.model, data.item);
+
+    const filters: Array<RuleCriteriaFilter> = data.criteria.filters.map(
+      (filter: RuleCriteriaFilter): RuleCriteriaFilter => {
+        if (!allowedFields.includes(filter.field)) {
+          throw new BadDataException(
+            `Rule ${data.ruleIndex + 1}: Match Criteria contains unsupported field "${filter.field}".`,
+          );
+        }
+
+        const metadata: TableColumnMetadata = data.model.getTableColumnMetadata(
+          filter.field,
+        )!;
+        const relationOperator: boolean = this.isRelationCriteriaOperator(
+          filter.operator,
+        );
+
+        if (metadata.type === TableColumnType.EntityArray) {
+          if (!relationOperator || !metadata.modelType) {
+            throw new BadDataException(
+              `Rule ${data.ruleIndex + 1}: ${metadata.title || filter.field} must use a relation criteria operator.`,
+            );
+          }
+
+          const externalNames: Map<string, string> | undefined =
+            data.criteriaRelationNames?.get(metadata.modelType);
+          const loadedNames: Map<string, string> | undefined =
+            itemRelationNames.get(metadata.modelType);
+          const names: Array<string> = (filter.value as Array<string>).map(
+            (id: string): string => {
+              const name: string | undefined =
+                externalNames?.get(id) || loadedNames?.get(id);
+              if (!name) {
+                throw new BadDataException(
+                  `Rule ${data.ruleIndex + 1}: ${metadata.title || filter.field} contains a resource that could not be read. Refresh and try exporting again.`,
+                );
+              }
+              return name;
+            },
+          );
+          this.validateValue(
+            filter.field,
+            names,
+            metadata,
+            data.model.tableName!,
+          );
+          return { ...filter, value: names };
+        }
+
+        if (relationOperator) {
+          throw new BadDataException(
+            `Rule ${data.ruleIndex + 1}: ${metadata.title || filter.field} does not support a relation criteria operator.`,
+          );
+        }
+
+        return { ...filter };
+      },
+    );
+
+    return { ...data.criteria, filters };
+  }
+
+  private static getItemRelationNames(
+    model: BaseModel,
+    item: BaseModel,
+  ): LabelRuleCriteriaRelationNames {
+    const indexes: LabelRuleCriteriaRelationNames = new Map();
+
+    for (const column of model.getTableColumns().columns) {
+      const metadata: TableColumnMetadata | undefined =
+        model.getTableColumnMetadata(column);
+      if (
+        metadata?.type !== TableColumnType.EntityArray ||
+        !metadata.modelType
+      ) {
+        continue;
+      }
+
+      const relations: unknown = item.getValue(column);
+      if (!Array.isArray(relations)) {
+        continue;
+      }
+
+      const names: Map<string, string> =
+        indexes.get(metadata.modelType) || new Map<string, string>();
+      for (const relation of relations) {
+        const relationObject: Record<string, unknown> = relation as Record<
+          string,
+          unknown
+        >;
+        const idValue: unknown =
+          relation instanceof BaseModel
+            ? relation.id
+            : relationObject["_id"] || relationObject["id"];
+        const nameValue: unknown =
+          relation instanceof BaseModel
+            ? relation.getValue("name")
+            : relationObject["name"];
+        const id: string = idValue?.toString() || "";
+        if (id && typeof nameValue === "string" && nameValue.trim()) {
+          names.set(id, nameValue);
+        }
+      }
+      indexes.set(metadata.modelType, names);
+    }
+
+    return indexes;
+  }
+
+  private static mapPortableCriteria(data: {
+    criteria: unknown;
+    sourceType: DatabaseBaseModelType;
+    source: BaseModel;
+    destination: BaseModel;
+    destinationColumns: Array<string>;
+    mappings: Set<string>;
+  }): RuleCriteria {
+    const validationError: string | null = getRuleCriteriaValidationError(
+      data.criteria,
+    );
+    if (validationError || !isValidRuleCriteria(data.criteria)) {
+      throw new BadDataException(
+        `Match Criteria is invalid. ${validationError || "Check the configured conditions."}`,
+      );
+    }
+
+    const sourceColumns: Array<string> = this.getColumns(
+      data.sourceType,
+    ).filter((column: string): boolean => {
+      return column !== "criteria";
+    });
+    const targetColumns: Array<string> = data.destinationColumns.filter(
+      (column: string): boolean => {
+        return column !== "criteria";
+      },
+    );
+
+    const filters: Array<RuleCriteriaFilter> = data.criteria.filters.map(
+      (filter: RuleCriteriaFilter): RuleCriteriaFilter => {
+        if (!sourceColumns.includes(filter.field)) {
+          throw new BadDataException(
+            `Match Criteria contains unknown or protected field "${filter.field}".`,
+          );
+        }
+
+        const sourceMetadata: TableColumnMetadata =
+          data.source.getTableColumnMetadata(filter.field)!;
+        const semanticColumn: string = this.semanticColumn(
+          data.source,
+          filter.field,
+        );
+        const target: string | undefined = targetColumns.find(
+          (candidate: string): boolean => {
+            return (
+              this.semanticColumn(data.destination, candidate) ===
+              semanticColumn
+            );
+          },
+        );
+        if (!target) {
+          throw new BadDataException(
+            `${sourceMetadata.title || filter.field} is configured in Match Criteria but is not supported by ${data.destination.singularName}. No rules were imported.`,
+          );
+        }
+
+        const targetMetadata: TableColumnMetadata =
+          data.destination.getTableColumnMetadata(target)!;
+        if (sourceMetadata.type !== targetMetadata.type) {
+          throw new BadDataException(
+            `${sourceMetadata.title || filter.field} in Match Criteria is incompatible with ${data.destination.singularName}.`,
+          );
+        }
+
+        const relationOperator: boolean = this.isRelationCriteriaOperator(
+          filter.operator,
+        );
+        if (
+          (sourceMetadata.type === TableColumnType.EntityArray) !==
+          relationOperator
+        ) {
+          throw new BadDataException(
+            `${sourceMetadata.title || filter.field} uses an incompatible Match Criteria operator.`,
+          );
+        }
+
+        this.validateValue(
+          target,
+          filter.value,
+          targetMetadata,
+          data.destination.tableName!,
+          filter.operator === RuleCriteriaOperator.MatchesPattern ||
+            filter.operator === RuleCriteriaOperator.DoesNotMatchPattern,
+        );
+        if (
+          typeof filter.value === "string" &&
+          filter.value.length > 0 &&
+          data.source.tableName !== data.destination.tableName &&
+          (filter.operator === RuleCriteriaOperator.MatchesPattern ||
+            filter.operator === RuleCriteriaOperator.DoesNotMatchPattern)
+        ) {
+          this.validatePatternCompatibility(
+            filter.value,
+            data.source.tableName!,
+            data.destination.tableName!,
+          );
+        }
+
+        if (filter.field !== target) {
+          data.mappings.add(
+            `${sourceMetadata.title || filter.field} → ${targetMetadata.title || target}`,
+          );
+        }
+        return { ...filter, field: target };
+      },
+    );
+
+    return { ...data.criteria, filters };
+  }
+
+  private static isRelationCriteriaOperator(
+    operator: RuleCriteriaOperator,
+  ): boolean {
+    return [
+      RuleCriteriaOperator.HasAnyOf,
+      RuleCriteriaOperator.HasAllOf,
+      RuleCriteriaOperator.HasNoneOf,
+    ].includes(operator);
+  }
+
   private static isConfigured(value: unknown): boolean {
     return (
       value !== undefined &&
@@ -422,6 +714,7 @@ export default class LabelRuleImportExport {
     value: unknown,
     metadata: TableColumnMetadata,
     resourceType: string,
+    validatePattern: boolean = true,
   ): void {
     const title: string = metadata.title || column;
     if ((value === undefined || value === null) && !metadata.required) {
@@ -465,7 +758,7 @@ export default class LabelRuleImportExport {
         `${title} must be at most ${maxLength} characters.`,
       );
     }
-    if (column.endsWith("Pattern") && value) {
+    if (validatePattern && column.endsWith("Pattern") && value) {
       const valid: boolean =
         resourceType === "NetworkDeviceLabelRule"
           ? RulePatternMatchUtil.isSupportedPattern(value)

package/Utils/NetworkDiscovery/AutoImportRuleMatcher.ts

@@ -2,6 +2,11 @@ import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDevi
 import ObjectID from "../../Types/ObjectID";
 import CidrMatchUtil from "../NetworkSite/CidrMatchUtil";
 import RulePatternMatchUtil from "../Rules/RulePatternMatchUtil";
+import RuleCriteriaMatcher from "../Rules/RuleCriteriaMatcher";
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../Types/Rules/RuleCriteria";
 import { isPingOnlyDiscoveredHost } from "./DiscoveryImportEligibility";
 import ScanTargetUtil from "./ScanTargetUtil";
 
@@ -32,6 +37,7 @@ import ScanTargetUtil from "./ScanTargetUtil";
  * this structurally, and tests can build literals.
  */
 export interface AutoImportRuleCandidate {
+  criteria?: unknown;
   monitorTemplateId?: ObjectID | string | null | undefined;
   /*
    * The OID Collection Template imported devices are LINKED to. Purely
@@ -164,6 +170,31 @@ export class AutoImportRuleMatcher {
   public static ruleMatchesHost(
     rule: AutoImportRuleCandidate,
     host: DiscoveredNetworkDevice,
+  ): boolean {
+    if (
+      !rule.isExclusion &&
+      !rule.includePingOnlyHosts &&
+      AutoImportRuleMatcher.isPingOnlyHost(host)
+    ) {
+      return false;
+    }
+
+    if (rule.criteria !== undefined && rule.criteria !== null) {
+      return RuleCriteriaMatcher.matchesSync({
+        criteria: rule.criteria,
+        emptyResult: false,
+        matchesFilter: (filter: RuleCriteriaFilter): boolean => {
+          return AutoImportRuleMatcher.matchesConfiguredFilter(filter, host);
+        },
+      });
+    }
+
+    return AutoImportRuleMatcher.ruleMatchesHostLegacy(rule, host);
+  }
+
+  private static ruleMatchesHostLegacy(
+    rule: AutoImportRuleCandidate,
+    host: DiscoveredNetworkDevice,
   ): boolean {
     const ipMatchTarget: string = (rule.ipMatchTarget || "").trim();
     const sysNamePattern: string = (rule.sysNamePattern || "").trim();
@@ -180,14 +211,6 @@ export class AutoImportRuleMatcher {
       return false;
     }
 
-    if (
-      !rule.isExclusion &&
-      !rule.includePingOnlyHosts &&
-      AutoImportRuleMatcher.isPingOnlyHost(host)
-    ) {
-      return false;
-    }
-
     if (ipMatchTarget) {
       if (
         !host.ipAddress ||
@@ -230,6 +253,83 @@ export class AutoImportRuleMatcher {
     return true;
   }
 
+  private static matchesConfiguredFilter(
+    filter: RuleCriteriaFilter,
+    host: DiscoveredNetworkDevice,
+  ): boolean {
+    const expected: string = String(filter.value);
+
+    switch (filter.field) {
+      case "ipMatchTarget":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: host.ipAddress,
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: (
+            actual: string | undefined,
+            pattern: string,
+          ): boolean => {
+            return ScanTargetUtil.contains(pattern, actual || "");
+          },
+        });
+      case "sysNamePattern":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: clampSubject(host.sysName),
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: RulePatternMatchUtil.matches,
+        });
+      case "sysDescrPattern":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: clampSubject(host.sysDescr),
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: RulePatternMatchUtil.matches,
+        });
+      case "sysObjectIdPattern":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: clampSubject(host.sysObjectId),
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: matchesOidPattern,
+        });
+      default:
+        return false;
+    }
+  }
+
+  private static matchesTextOperator(data: {
+    actual: string | undefined;
+    expected: string;
+    operator: RuleCriteriaOperator;
+    matchesPattern: (actual: string | undefined, pattern: string) => boolean;
+  }): boolean {
+    const actual: string = data.actual || "";
+    const actualLower: string = actual.toLocaleLowerCase();
+    const expectedLower: string = data.expected.toLocaleLowerCase();
+
+    switch (data.operator) {
+      case RuleCriteriaOperator.Equals:
+        return actualLower === expectedLower;
+      case RuleCriteriaOperator.NotEquals:
+        return actualLower !== expectedLower;
+      case RuleCriteriaOperator.Contains:
+        return actualLower.includes(expectedLower);
+      case RuleCriteriaOperator.DoesNotContain:
+        return !actualLower.includes(expectedLower);
+      case RuleCriteriaOperator.StartsWith:
+        return actualLower.startsWith(expectedLower);
+      case RuleCriteriaOperator.EndsWith:
+        return actualLower.endsWith(expectedLower);
+      case RuleCriteriaOperator.MatchesPattern:
+        return data.matchesPattern(data.actual, data.expected);
+      case RuleCriteriaOperator.DoesNotMatchPattern:
+        return !data.matchesPattern(data.actual, data.expected);
+      default:
+        return false;
+    }
+  }
+
   /**
    * What the whole rule set says about one host: import, and through which
    * rules — or vetoed, and by which exclusion.

package/Utils/NetworkSite/CidrMatchUtil.ts

@@ -5,8 +5,15 @@
  * engine's decisions are unit-testable.
  */
 
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../Types/Rules/RuleCriteria";
+import RuleCriteriaMatcher from "../Rules/RuleCriteriaMatcher";
+
 // The shape NetworkSiteAssignmentRule rows are matched with.
 export interface AssignmentRuleCandidate {
+  criteria?: unknown;
   subnetCidr?: string | null | undefined;
   hostnamePattern?: string | null | undefined;
   priority?: number | null | undefined;
@@ -191,6 +198,23 @@ export class CidrMatchUtil {
   public static ruleMatches(
     rule: AssignmentRuleCandidate,
     target: RuleMatchTarget,
+  ): boolean {
+    if (rule.criteria !== undefined && rule.criteria !== null) {
+      return RuleCriteriaMatcher.matchesSync({
+        criteria: rule.criteria,
+        emptyResult: false,
+        matchesFilter: (filter: RuleCriteriaFilter): boolean => {
+          return CidrMatchUtil.matchesConfiguredFilter(filter, target);
+        },
+      });
+    }
+
+    return CidrMatchUtil.ruleMatchesLegacy(rule, target);
+  }
+
+  private static ruleMatchesLegacy(
+    rule: AssignmentRuleCandidate,
+    target: RuleMatchTarget,
   ): boolean {
     const hasCidr: boolean = Boolean(
       rule.subnetCidr && rule.subnetCidr.trim().length > 0,
@@ -236,6 +260,84 @@ export class CidrMatchUtil {
     return true;
   }
 
+  private static matchesConfiguredFilter(
+    filter: RuleCriteriaFilter,
+    target: RuleMatchTarget,
+  ): boolean {
+    const expected: string = String(filter.value);
+
+    if (filter.field === "subnetCidr") {
+      const matchesCidr: boolean = Boolean(
+        target.ip && CidrMatchUtil.ipInCidr(target.ip, expected),
+      );
+
+      if (filter.operator === RuleCriteriaOperator.MatchesPattern) {
+        return matchesCidr;
+      }
+
+      if (filter.operator === RuleCriteriaOperator.DoesNotMatchPattern) {
+        return !matchesCidr;
+      }
+
+      return false;
+    }
+
+    if (filter.field !== "hostnamePattern") {
+      return false;
+    }
+
+    const candidates: Array<string> = [
+      target.hostname,
+      target.sysName,
+      target.name,
+    ].filter((candidate: string | null | undefined): candidate is string => {
+      return typeof candidate === "string";
+    });
+    const expectedLower: string = expected.toLocaleLowerCase();
+    const anyCandidateMatches: (
+      matches: (value: string) => boolean,
+    ) => boolean = (matches: (value: string) => boolean): boolean => {
+      return candidates.some(matches);
+    };
+
+    switch (filter.operator) {
+      case RuleCriteriaOperator.Equals:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase() === expectedLower;
+        });
+      case RuleCriteriaOperator.NotEquals:
+        return !anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase() === expectedLower;
+        });
+      case RuleCriteriaOperator.Contains:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().includes(expectedLower);
+        });
+      case RuleCriteriaOperator.DoesNotContain:
+        return !anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().includes(expectedLower);
+        });
+      case RuleCriteriaOperator.StartsWith:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().startsWith(expectedLower);
+        });
+      case RuleCriteriaOperator.EndsWith:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().endsWith(expectedLower);
+        });
+      case RuleCriteriaOperator.MatchesPattern:
+        return anyCandidateMatches((value: string): boolean => {
+          return CidrMatchUtil.hostnameMatchesWildcard(value, expected);
+        });
+      case RuleCriteriaOperator.DoesNotMatchPattern:
+        return !anyCandidateMatches((value: string): boolean => {
+          return CidrMatchUtil.hostnameMatchesWildcard(value, expected);
+        });
+      default:
+        return false;
+    }
+  }
+
   /*
    * Picks the winning rule for a target: among matching rules the highest
    * priority number wins; ties go to the earlier createdAt when both rows