executeRules method

Future<RulesResult> executeRules(Map<String, dynamic> context)

Executes rules with raw context (for custom events)

Implementation

Future<RulesResult> executeRules(Map<String, dynamic> context) async {
  try {
    // Extract rule definition from context with safe casting
    final ruleDefinitionRaw = context['ruleDefinition'];
    final ruleDefinition =
        ruleDefinitionRaw is Map<String, dynamic> ? ruleDefinitionRaw : null;

    if (ruleDefinitionRaw != null && ruleDefinition == null) {
      print(
          'Warning: ruleDefinition is not a Map<String, dynamic>: ${ruleDefinitionRaw.runtimeType} = $ruleDefinitionRaw');
    }

    if (ruleDefinition != null) {
      // Transform rule definition to engine format (same as test)
      print(
          '--- BEFORE TRANSFORMATION ---\n${jsonEncode(ruleDefinition)}\n---------------------------');
      final transformedRule = _transformRuleDefinition(ruleDefinition);
      print(
          '--- AFTER TRANSFORMATION ---\n${jsonEncode(transformedRule)}\n--------------------------');

      // Extract event context (separate from rule definition)
      final eventContext = Map<String, dynamic>.from(context);
      eventContext.remove('ruleDefinition'); // Remove rule from context

      // Use DartRulesEngine executeRules method (same as successful test)
      final engineResult = await _dartEngine.executeRules(
        ruleDefinition: transformedRule,
        eventContext: eventContext,
      );

      // Convert engine result to RulesResult, preserving raw result
      // DartRulesEngine always returns Map<String, dynamic>
      try {
        final cleanEngineResult = Map<String, dynamic>.from(engineResult);
        return RulesResult.fromMap(cleanEngineResult,
            rawResult: engineResult);
      } catch (conversionError, conversionStackTrace) {
        print(
            'Error converting engine result to RulesResult: $conversionError');
        print('Conversion stack trace: $conversionStackTrace');
        print('Raw engine result: $engineResult');
        rethrow; // Preserve original stack trace
      }
    } else {
      // No rule definition provided, return empty result
      return const RulesResult.empty();
    }
  } catch (e, stackTrace) {
    print('Rules engine execution error: $e');
    print('Stack trace: $stackTrace');
    return RulesResult.error(
        'Rules execution failed: $e\nStack trace: $stackTrace');
  }
}