Demo de Microsoft Rules Engine con Aplicación Web con .NET Blazor

Introducción

Microsoft Rules Engine es una libreria NuGet que permite configurar reglas de negocio de forma visual fuera del propio sistema sobre el cuál se las va a aplicar, estas reglas pueden ser aplicada a un sistema o servicio o aplicación. Provee una forma sencilla de configurar tus reglas de negocio fuera de la lógica del sistema en si, de esta forma puedes asegurar que cada cambio en las reglas no afecte al core del sistema.

¿Cómo funciona?

La arquitectura de rules engine se presenta a continuación

Imagen tomada de https://github.com/microsoft/RulesEngine/blob/main/assets/BlockDiagram.png

El diagrama que muestra la arquitectura de Microsoft Rules Engine mostrado arriba se puede interpretar de la siguiente forma, Tenemos los siguientes componentes:

Input: Las diferentes posibles entrada de donde puede originarse un mensaje o input, puede ser un servicio o microservicio, una base de datos, almacenamiento en la nube, etc.
Input message: Es el mensaje en si, si estamos en un aplicación tipo servicio o microservicio REST, el mensaje seria en si la petición http que llega al servicio.
RulesStore: Almacenamiento de reglas, puede ser un carpeta en tu sistema de archivos local en tu computadora o también puede ser una carpeta en almacenamiento en la nube o una base de datos. En si, es el repositorio en donde se almacenan los archivos que contienen las reglas a ser evaluadas posteriormente por el motor de reglas.
Rules: Son las reglas a evaluarse
Wrapper: Es el componente que ejecuta el motor de reglas como parte de su proceso.
Rules result: Una vez que las reglas fueron evaluadas se produce un resultado que puede ser usado para determinar las siguientes acciones a tomarse
Rules engine: Es el componente que ejecuta la evaluación de las reglas configuradas en archivos y almacenadas en el Rules store.

Para la demo que hemos preparado para este articulo, utilizaremos un aplicación web en blazor que será la encargada de ejecutar las reglas de negocio que estarán almacenadas localmente en una de las carpetas también subidas al repositorio.

Demo

Para esta demo hemos creado una aplicación en Microsoft Blazor, y que utilizará el motor de reglas de negocio para evaluar reglas guardaadas en una carpeta, estas reglas determinaran como la aplicación debe mostrarse.

El primer paso es crear un proyecto Blazor Web App, yo voy a usar .NET 8.0 pero se puede usar versiones anteriores también. En este articulo uso un IDE para .NET llamado Rider, de JetBrains, pero todo esto funciona también para VisualStudio sin ningún inconveniente.

Dejemos marcada la opción include sample pages, ya que será de mucha utilidad mas adelante.

El siguiente paso es agregar RulesEngine nuget package a nuestra solución, si presentas algún problema en este paso ir a la sección de troubleshooting abajo en este mismo artículo

Una vez creado el proyecto debe lucir de la siguiente forma:

Ejecjutamos el proyecto desde el menú run y debe lucir de la siguiente forma

Vamos a modificar el proyecto para ir agregando los ejemplos que necesitamos

En mi caso coloqué el nombre de proyecto rulesenginedemo, lo primero que realicé fue agregar las páginas de ejemplo, son 2 páginas de ejemplo que agregué dentro de la carpeta Pages, puedes ver estas páginas en mas detalle en el repositorio github.

Vamos a ver la primera página de ejemplo

Ejemplo 1

El ejemplo 1 es una regla estática, esta regla esta quemada en código, en realidad esto no es muy útil en escenarios reales, pero decidí incluirlo ya que es el caso más sencillo. Luce de la siguiente forma:

Entonces, este ejemplo consiste en que cada vez que se presiona el botón Click me se aumentará el contador y se evaluará la regla que se ha establecido en el código, la regla evalua si el valor del contador es menor a 3, después de evaluarse la regla se mostrará un mensaje indicando el resultado de la evaluación.

Cuando el contador es aun menor 3, el resultado será

Cuando es igual o mayor a 3 el resultado será:

El código para configurar la regla y su posterior evaluación es el siguiente:

    private void evaluateRulesBasicExample(int counter)
    {
        //creamos un objeto tipo dynamic
        dynamic data = new ExpandoObject();

        //agregamos counter que es la variable que almacena el contador que aumenta al presionar el botón click me.
        data.count = counter;

        //debemos agregar nuestro objeto data a un arreglo de tipo dynamic[], asi lo espera el motor de reglas de negocio.

        var inputs = new dynamic[]
        {
            data
        };

        //Este arreglo va a contener las reglas que se pasarán al motor de reglas de negocio.
        var rules = new List<Rule>();

        //Aqui se configuran la regla de negocio que se utilizará para ese ejemplo
        var rule = new Rule
        {
            RuleName = "Test Rule",
            SuccessEvent = "Count is within tolerance.",
            ErrorMessage = "Over expected.",
            Expression = "count < 3", //Esta es la regla en si
            RuleExpressionType = RuleExpressionType.LambdaExpression
        };
        
        rules.Add(rule);
        
        workflow = new List<Workflow>();

        //Se configura un workflow con el conjunto de reglas a evaluar.
        var exampleWorkflow = new Workflow
        {
            WorkflowName = "Example Workflow",
            Rules = rules
        };

        //Nuestro arreglo de workflows tiene un solo elemento, podría contener mas.
        workflow.Add(exampleWorkflow);

        //Creación y configuración del motor de reglas, recibe como parámetro el arreglo de workflows
        var bre = new RulesEngine.RulesEngine(workflow.ToArray());

        //Evalua todas las reglas, recibe como parámetro el nombre del workflow y la lista de inputs
        var resultList = bre.ExecuteAllRulesAsync("Example Workflow", inputs).Result;

        //Verifica si todas las reglas fueron evaluadas como verdadero.
        var outcome = resultList.TrueForAll(r => r.IsSuccess);

        //Presenta el resultado de la evaluación
        result = outcome ? $"Result count is within tolerance" : $"Result count is NOT within tolerance";
    }

}

Ejemplo 2

El ejemplo 2 recibe los datos de un formulario y evalua las reglas que se guardaron en un archivo, este es un ejemplo mas orientado a un escenario real, idealmente este archivo que contiene las reglas estará guardado en un almacenamiento en la nube, el cual puede ser modificado directamente, de esa forma se controlan las reglas de negocio aplicadas al proyecto sin necesidad de configurar código.

El archivo de reglas luce de la siguiente forma:

Todos estos archivos los pueden encontrar en el repositorio al cuál he subido este proyecto.

Repositorio github: https://github.com/rcabreras/rulesenginedemo/blob/main/README.md

Bonus

Existe un aplicativo web que permite editar las reglas de forma visual, realizado por @alexreich

El link es el siguiente: https://github.com/alexreich/RulesEngineEditor

Este editor abre la posibilidad de editar las reglas de forma visual, desde reglas sencillas hasta reglas anidadas, que podrán ser posteriormente evaluadas por el proyecto.

Según la recepción que tenga este artículo incorporaré el editor visual al proyecto.

Troubleshooting

En caso de que encuentres este error, debes asegurarte de que tengas instalado la versión del SDK de .net requerida, en mi caso tuve que instalar la versión 8.0.

/usr/local/share/dotnet/sdk/6.0.410/Sdks/Microsoft.NET.Sdk/targets/Microsoft.NET.TargetFrameworkInference.targets(144,5): error NETSDK1045: The current .NET SDK does not support targeting .NET 8.0. Either target .NET 6.0 or lower, or use a version of the .NET SDK that supports .NET 8.0. [/Users/rcsx/RiderProjects/rulesenginedemo/rulesenginedemo.csproj]
Unable to create dependency graph file for project '/Users/rcsx/RiderProjects/rulesenginedemo/rulesenginedemo.csproj'. Cannot add package reference.

Puedes usar el comando dotnet –list-sdks para confirmar que la versión que necesitas esté instalado en tu computador.