save variable conditions

Author: jayeshsadhwani99

executor/playbook_result_conditional_evaluators/step_condition_evaluator.py

@@ -72,8 +72,10 @@ def evaluate(self, condition: PlaybookStepResultCondition,
                 all_evaluations.append(evaluation)
 
             variable_rules: [PlaybookTaskResultRule] = rs.variable_rules
+            print("WOOOOOOO variable_rules", variable_rules)
             for vr in variable_rules:
-                variable_evaluator = self._variable_rule_map.get()
+                print("WOOOOOOO", vr)
+                variable_evaluator = self._variable_rule_map.get(vr.type)
                 print("WOOOOOOO 0", variable_evaluator, vr)
                 global_variable_set = next(
                     (tr.execution_global_variable_set for tr in playbook_task_execution_log), None)

protos/playbooks/playbook_global_variable_evaluator.proto

@@ -4,8 +4,20 @@ package protos.playbooks;
 import "protos/base.proto";
 import "google/protobuf/wrappers.proto";
 
-message GlobalVariableResultRule {
+message CompareGlobalVariable {
   google.protobuf.StringValue variable_name = 1;
   Operator operator = 2;
   google.protobuf.StringValue threshold = 3;
 }
+
+message GlobalVariableResultRule {
+  enum Type {
+    UNKOWN = 0;
+    COMPARE_GLOBAL_VARIABLE = 1;
+  }
+
+  Type type = 1;
+  oneof rule {
+    CompareGlobalVariable compare_global_variable = 101;
+  }
+}

protos/playbooks/playbook_global_variable_evaluator_pb2.py

@@ -4,20 +4,22 @@ isort:skip_file
 """
 import builtins
 import google.protobuf.descriptor
+import google.protobuf.internal.enum_type_wrapper
 import google.protobuf.message
 import google.protobuf.wrappers_pb2
 import protos.base_pb2
 import sys
+import typing
 
-if sys.version_info >= (3, 8):
+if sys.version_info >= (3, 10):
     import typing as typing_extensions
 else:
     import typing_extensions
 
 DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
 
 @typing_extensions.final
-class GlobalVariableResultRule(google.protobuf.message.Message):
+class CompareGlobalVariable(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     VARIABLE_NAME_FIELD_NUMBER: builtins.int
@@ -38,4 +40,38 @@ class GlobalVariableResultRule(google.protobuf.message.Message):
     def HasField(self, field_name: typing_extensions.Literal["threshold", b"threshold", "variable_name", b"variable_name"]) -> builtins.bool: ...
     def ClearField(self, field_name: typing_extensions.Literal["operator", b"operator", "threshold", b"threshold", "variable_name", b"variable_name"]) -> None: ...
 
+global___CompareGlobalVariable = CompareGlobalVariable
+
+@typing_extensions.final
+class GlobalVariableResultRule(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    class _Type:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _TypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[GlobalVariableResultRule._Type.ValueType], builtins.type):  # noqa: F821
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        UNKOWN: GlobalVariableResultRule._Type.ValueType  # 0
+        COMPARE_GLOBAL_VARIABLE: GlobalVariableResultRule._Type.ValueType  # 1
+
+    class Type(_Type, metaclass=_TypeEnumTypeWrapper): ...
+    UNKOWN: GlobalVariableResultRule.Type.ValueType  # 0
+    COMPARE_GLOBAL_VARIABLE: GlobalVariableResultRule.Type.ValueType  # 1
+
+    TYPE_FIELD_NUMBER: builtins.int
+    COMPARE_GLOBAL_VARIABLE_FIELD_NUMBER: builtins.int
+    type: global___GlobalVariableResultRule.Type.ValueType
+    @property
+    def compare_global_variable(self) -> global___CompareGlobalVariable: ...
+    def __init__(
+        self,
+        *,
+        type: global___GlobalVariableResultRule.Type.ValueType = ...,
+        compare_global_variable: global___CompareGlobalVariable | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing_extensions.Literal["compare_global_variable", b"compare_global_variable", "rule", b"rule"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing_extensions.Literal["compare_global_variable", b"compare_global_variable", "rule", b"rule", "type", b"type"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing_extensions.Literal["rule", b"rule"]) -> typing_extensions.Literal["compare_global_variable"] | None: ...
+
 global___GlobalVariableResultRule = GlobalVariableResultRule

protos/playbooks/playbook_global_variable_evaluator_pb2.pyi

@@ -1,5 +1,9 @@
 import CustomInput from "../Inputs/CustomInput";
-import { InputTypes, VariableConditionRule } from "../../types";
+import {
+  InputTypes,
+  VariableConditionRule,
+  VariableRuleTypes,
+} from "../../types";
 import useIsPrefetched from "../../hooks/playbooks/useIsPrefetched";
 import { useSelector } from "react-redux";
 import { currentPlaybookSelector } from "../../store/features/playbook/selectors";
@@ -24,6 +28,8 @@ function VariableCondition({
   const isPrefetched = useIsPrefetched();
   const currentPlaybook = useSelector(currentPlaybookSelector);
   const { handleRule } = useEdgeConditions(id);
+  const ruleType = condition.type?.toLowerCase() as VariableRuleTypes;
+  const ruleData = condition?.[ruleType] ?? {};
 
   const handleChange = (val: string, type: string) => {
     handleRule(type, val, i, RuleType.VARIABLE_RULE);
@@ -45,9 +51,11 @@ function VariableCondition({
               id: key,
               label: key,
             }))}
-            value={condition.variable_name}
+            value={ruleData.variable_name}
             placeholder={`Variable Name`}
-            handleChange={(id: string) => handleChange(id, "variable_name")}
+            handleChange={(id: string) =>
+              handleChange(id, `${ruleType}.variable_name`)
+            }
             disabled={!!isPrefetched}
           />
         </div>
@@ -56,21 +64,25 @@ function VariableCondition({
             inputType={InputTypes.DROPDOWN}
             disabled={!!isPrefetched}
             options={operationOptions}
-            value={condition.operator}
+            value={ruleData.operator}
             placeholder={`Select Operator`}
-            handleChange={(id: string) => handleChange(id, `operator`)}
+            handleChange={(id: string) =>
+              handleChange(id, `${ruleType}.operator`)
+            }
           />
           <CustomInput
             inputType={InputTypes.TEXT}
             disabled={!!isPrefetched}
-            value={condition.threshold}
+            value={ruleData.threshold}
             placeholder={`Threshold/Value`}
-            handleChange={(id: string) => handleChange(id, `threshold`)}
+            handleChange={(id: string) =>
+              handleChange(id, `${ruleType}.threshold`)
+            }
           />
         </div>
 
         {showDelete && (
-          <DeleteRuleButton ruleType={RuleType.RULE} ruleIndex={i} />
+          <DeleteRuleButton ruleType={RuleType.VARIABLE_RULE} ruleIndex={i} />
         )}
       </div>
     </div>

web/src/components/AddVariableCondition/VariableCondition.tsx

@@ -1,5 +1,5 @@
 import { PayloadAction } from "@reduxjs/toolkit";
-import { PlaybookUIState } from "../../../../../types";
+import { PlaybookUIState, VariableRuleTypes } from "../../../../../types";
 import { OperatorOptions } from "../../../../../utils/conditionals/types/operatorOptionTypes";
 import { playbookSlice } from "../../playbookSlice";
 
@@ -28,8 +28,11 @@ export const addVariableRuleAction = (
   const ruleSet = relation.condition.rule_sets[ruleSetIndex];
   if (!ruleSet.variable_rules) ruleSet.variable_rules = [];
   ruleSet.variable_rules.push({
-    operator: OperatorOptions.EQUAL_O,
-    variable_name: "",
-    threshold: "",
+    type: VariableRuleTypes.COMPARE_GLOBAL_VARIABLE,
+    compare_global_variable: {
+      operator: OperatorOptions.EQUAL_O,
+      variable_name: "",
+      threshold: "",
+    },
   });
 };

web/src/store/features/playbook/slices/relations/addVariableRule.ts

@@ -1,3 +1 @@
-export type LowercaseString<T extends string> = T extends `${infer F}${infer R}`
-  ? `${Lowercase<F>}${R}`
-  : T;
+export type LowercaseString<T extends string> = Lowercase<T>;

web/src/types/common/lowercaseString.ts

@@ -12,6 +12,10 @@ export enum StepRuleTypes {
   COMPARE_TIME_WITH_CRON = "COMPARE_TIME_WITH_CRON",
 }
 
+export enum VariableRuleTypes {
+  COMPARE_GLOBAL_VARIABLE = "COMPARE_GLOBAL_VARIABLE",
+}
+
 enum RuleType {
   TIMESERIES = "timeseries",
   TABLE = "table",
@@ -37,12 +41,18 @@ export type ConditionRule = {
   [key in RuleType]?: any;
 };
 
-export type VariableConditionRule = {
-  variable_name: string;
-  operator: OperatorOptionType;
-  threshold: string;
+export type VariableConditionRuleType = {
+  [key in VariableRuleTypes as LowercaseString<VariableRuleTypes>]: {
+    variable_name: string;
+    operator: OperatorOptionType;
+    threshold: string;
+  };
 };
 
+export type VariableConditionRule = {
+  type: VariableRuleTypes;
+} & VariableConditionRuleType;
+
 export type StepRuleType = {
   [key in StepRuleTypes as LowercaseString<StepRuleTypes>]: {
     operator: OperatorOptionType;