execute static method

Implementation

static List<ProgramRuleAction> execute(
    {required Map<String, DataValueObject> dataValueEntities,
    required List<ProgramRule> programRules,
    required List<ProgramRuleVariable> programRuleVariables,
    Map<String, dynamic> additionalValues = const {}}) {
  List<ProgramRuleAction> programRulesActions = [];

  try {
    Map<String, dynamic> evaluationContext =
        ProgramRuleEngine._getEvaluationContext(
            dataValueEntities: dataValueEntities,
            additionalValues: additionalValues,
            programRuleVariables: programRuleVariables);

    programRules.forEach((programRule) {
      String ruleConditionForEvaluation = programRule.condition;

      ruleConditionForEvaluation =
          addDataToExpression(ruleConditionForEvaluation, evaluationContext);

      ruleConditionForEvaluation = ruleConditionForEvaluation
          .replaceAll(RegExp(r'[A|V|#]\{.*?\}'), "''")
          .replaceAll('d2:length( ' ' )', '0')
          .replaceAll('d2:length(' ')', '0')
          .replaceAll(r"!''", '1 == 1');

      if (ruleConditionForEvaluation.contains('d2:')) {
        ruleConditionForEvaluation =
            dhisD2Functions(ruleConditionForEvaluation);
      }

      try {
        if (ruleConditionForEvaluation.contains('d2:')) {
          ruleConditionForEvaluation =
              dhisD2Functions(ruleConditionForEvaluation);
        }
        ruleConditionForEvaluation =
            ruleConditionForEvaluation.replaceAll("''", '0');

        dynamic evaluationResult;
        try {
          Expression expression =
              Expression.parse(ruleConditionForEvaluation);
          final evaluator = const ExpressionEvaluator();
          evaluationResult = evaluator.eval(expression, evaluationContext);
        } catch (e) {}

        final newProgramRuleActions =
            programRule.programRuleActions?.map((ruleAction) {
          String data = ruleAction.data ?? '';
          dynamic result =
              data != '' && evaluationResult == true && data.contains('#{')
                  ? MathExpressions.evaluate(data, evaluationContext)
                  : data.contains('d2:') && evaluationResult == true
                      ? evaluateD2Data(data, evaluationContext)
                      : evaluationResult == true
                          ? data
                          : '';

          return ProgramRuleAction.fromJson({
            ...ruleAction.toJson(),
            'data': result,
            'programRuleActionType': evaluationResult == true
                ? ruleAction.programRuleActionType
                : ""
          });
        }).toList();

        programRulesActions = List.from([
          ...programRulesActions,
          ...(newProgramRuleActions as List<ProgramRuleAction>)
        ]);
      } catch (e) {
        final newProgramRuleActions =
            programRule.programRuleActions?.map((ruleAction) {
          return ProgramRuleAction.fromJson(
              {...ruleAction.toJson(), 'programRuleActionType': ''});
        }).toList();

        programRulesActions = List.from([
          ...programRulesActions,
          ...(newProgramRuleActions as List<ProgramRuleAction>)
        ]);
      }
    });
  } catch (e) {}
  return programRulesActions;
}