Api.cs

using System.Collections.Concurrent;
using CodeEffects.Rule.Common.Attributes;
using CodeEffects.Rule.Common.Models;
using CodeEffects.Rule.Editor;
using CodeEffects.Rule.Editor.Models;
using CodeEffects.Rule.Engine;
using Microsoft.AspNetCore.Mvc;

namespace CodeEffects.Demo.Asp;

public static class Api
{
	// Simple in-memory rule storage for the sake of this demo
	private static readonly ConcurrentDictionary<string, Rule> Storage = new();

	// Set the license file path here if you are using the Engine Subscription edition
	//Evaluator.LicenseFileFullPath = "C:\\YourFolder\\codeeffects.ce";

	public static void MapEndpoints(this WebApplication app)
	{
		// Returns client settings for the editor
		app.MapGet("/api/settings", () =>
		{
			var settings = new Settings();
			var editor = GetControl(settings);

			// Set all evaluation type rules to be used by the
			// editor as bool properties (i.e. reusable rules) in menus
			editor.ContextMenuRules = [.. Storage
				.Where(r => r.Value.Eval)
				.Select(r => new MenuItem(r.Key, r.Value.Name))];

			if(settings.Toolbar)
			{
				// Load all available rules into the Rules menu of the Toolbar
				editor.ToolBarRules = [.. Storage.Select(r => new MenuItem(r.Key, r.Value.Name))];
			}

			// Set UI settings for the editor (Help String, etc)
			settings.GlobalData = editor.GetGlobalData();

			// Set the source-related settings for the editor
			settings.EditorData = editor.GetEditorData();

			return Results.Ok(settings);
		});

		// Loads a rule by its ID
		app.MapGet("/api/load/{ruleId}", (string ruleId) =>
		{
			Storage.TryGetValue(ruleId, out var value);

			var editor = GetControl(new Settings());
			editor.LoadRuleXml(value?.Xml);

			return Results.Ok(editor.GetRuleData());
		});

		app.MapPost("/api/save", ([FromBody] string rule) =>
		{
			var editor = GetControl(new Settings());
			editor.LoadRuleData(rule);

			var response = new Response();

			if(editor.IsEmpty)
			{
				response.IsRuleEmpty = true;
			}
			else if(!editor.IsValid)
			{
				response.IsRuleValid = false;

				// Load invalid elements into the editor
				response.ClientInvalidData = editor.GetInvalidData();
			}
			else
			{
				Storage[editor.Rule.ID] = new Rule
				{
					Eval = editor.Rule.IsEvalType.HasValue && editor.Rule.IsEvalType.Value,
					Name = editor.Rule.Name,
					Xml = editor.GetRuleXml()
				};

				response.Output = editor.Rule.ID;
			}

			return Results.Ok(response);
		});

		app.MapPost("/api/delete", ([FromBody] string ruleId) =>
		{
			Storage.TryRemove(ruleId, out _);
		});

		app.MapPost("/api/evaluate", (Request req) =>
		{
			var editor = GetControl(new Settings());
			editor.RuleNameIsRequired = false; // No need to validate the rule name
			editor.LoadRuleData(req.Rule);   // Load the rule into the editor

			var response = new Response();

			if(editor.IsEmpty)
			{
				response.IsRuleEmpty = true;
				response.Output = "The rule is empty";
			}
			else if(!editor.IsValid)
			{
				response.IsRuleValid = false;
				response.Output = "The rule is invalid";

				// Load invalid rule elements into the editor
				response.ClientInvalidData = editor.GetInvalidData();
			}
			else
			{
				// Get the rule XML
				var ruleXml = editor.GetRuleXml();

				// Create an instanve of the Evaluator.
				// This compiles your rule into IL
				var ev = new Evaluator<SourceObject>(ruleXml);

				// Evaluate the rule
				bool success = ev.Evaluate(req.Source);

				// Output the evaluation result
				response.Output = success ?
					"The rule evaluated to TRUE" :
					"The rule evaluated to FALSE";

				response.Source = req.Source;
			}

			return Results.Ok(response);
		});
	}

	private static Control GetControl(Settings settings)
	{
		// Use the ID of the div element that contains the editor
		var editor = new Control("divEditor");

		// Set the editor to use the source object
		editor.SourceType = typeof(SourceObject);

		editor.EvaluationMode = settings.Mode;
		editor.ShowHelpString = settings.HelpString;
		editor.ShowToolBar = settings.Toolbar;
		editor.ShowLineDots = settings.Dots;

		return editor;
	}
}

public class SourceObject
{
	public int Id { get; set; } = 0;
	public string? Name { get; set; }

	[Field(DisplayName = "Date of Birth", DateTimeFormat = "MMM dd, yyyy")]
	public DateTime? Dob { get; set; }
}

public class Rule
{
	public bool Eval { get; set; } = false;
	public string? Name {  set; get; }
	public string? Xml { get; set; }
}

public class Settings
{
	public string? GlobalData { get; set; }
	public string? EditorData { get; set; }

	public bool Toolbar { get; set; } = true;
	public bool HelpString { get; set; } = true;
	public bool Dots { get; set; } = false;

	public EvaluationMode Mode { get; set; } = EvaluationMode.Execution;
}

public class Request
{
	public string? Rule {  get; set; }
	public SourceObject Source { get; set; } = new SourceObject();
}
public class Response
{
	public bool IsRuleEmpty { get; set; } = false;
	public bool IsRuleValid { get; set; } = true;

	public string? Output { get; set; }
	public string? ClientInvalidData { get; set; }
	public SourceObject Source {  set; get; } = new SourceObject();
}