kantime-rule-engine/engineFormHandler.js

A library for custom validation in the form based on the user defined json schema.

let _ = require("lodash");
let _jQ = require("jsonq");
import { Engine } from './ruleEngine.js';
import { isNullOrUndefined } from 'util';
import { skipActionlibrary, eventActionlibrary, FormStateActionlibrary } from './engineActionlibrary.js'
import { RuleParser,RuleTraversal } from './ruleEngineParser';

let engine_EventsInfo = [];
let engine_Inputdata={};
let engine_MasterRules={};
let engine_EvalFormRules={};

export const SetInputData = (EngineinputData,EnginemasterRules,EvalformRules) => {
    try { 
            engine_Inputdata = EngineinputData;
            engine_MasterRules = EnginemasterRules;
            engine_EvalFormRules = EvalformRules;

    } catch (error) {
        throw error
    }
}

export const SkipRuleEngine = (RulesfromUI) => {
    let Output = {};
    try {
        console.log('Skip Rule Engine started.');
        let StateMasterRules = {};
        let FormRules = {};

        StateMasterRules = GetMasterRulesFromState("SkipLogic");

        if (!isNullOrUndefined(RulesfromUI) && RulesfromUI.length > 0) { //Executed On Event Called
            FormRules = GetFormRules("SkipLogic", RulesfromUI);
        }
        else { //Executed On Page Load
            FormRules = GetFormRules("SkipLogic", "");
            Eventcollector(StateMasterRules, FormRules.ValidFormRules, "SkipLogic");
        }

        Output = EngineExecution(StateMasterRules, FormRules, "RuleSetForSkipLogic");

         console.log({Output})
      
        if (!isNullOrUndefined(Output)) {
            skipActionlibrary(Output.EngineResult);
        }
        console.log('Skip Rule Engine End.');
        console.log('===============================');
    } catch (error) {
        throw error;
    }
    return Output;
}

export const EventDrivenRuleEngine = (RulesfromUI) => {
    let Output = {};
    try {
        console.log('Event Driven Rule Engine started.');
        let StateMasterRules = {};
        let FormRules = {};

        StateMasterRules = GetMasterRulesFromState("EventDriven");

        if (!isNullOrUndefined(RulesfromUI) && RulesfromUI.length > 0) { //Executed On Event Called
            FormRules = GetFormRules("EventDriven", RulesfromUI);
        }
        else { //Executed On Page Load
            FormRules = GetFormRules("EventDriven", "");
            Eventcollector(StateMasterRules, FormRules.ValidFormRules, "EventDriven");
        }
          
        Output = EngineExecution(StateMasterRules, FormRules, "RuleSetForEventDriven");  

        if (!isNullOrUndefined(Output)) {
            eventActionlibrary(Output.EngineResult,StateMasterRules);
        }
       
        console.log('Event Driven Rule Engine End.');
        console.log('===============================');
    } catch (error) {
        throw error;
    }
    return Output;
}

export const FormStateRuleEngine = (RulesfromUI) => {
    let Output = {};
    try {
        console.log('Form State Rule Engine started.')

        let StateMasterRules = {};
        let FormRules = {};

        StateMasterRules = GetMasterRulesFromState("FormState");

        if (!isNullOrUndefined(RulesfromUI) && RulesfromUI.length > 0) {
            FormRules = GetFormRules("FormState", RulesfromUI);
        }
        else {
            FormRules = GetFormRules("FormState", "");
        }

        Output = EngineExecution(StateMasterRules, FormRules, "RuleSetForFormState");

        if (!isNullOrUndefined(Output)) {
            FormStateActionlibrary(Output.EngineResult);
        }

        console.log('Form State Rule Engine End.');
        console.log('===============================');
    } catch (error) {
        throw error;
    }
    return Output;
}

function EngineExecution(MasterRules, FormRules, RuleSetInternalname) {
    let Output = {};
    try {
        let _FormRules = {};
        let _MasterRulesForEngine = {};

        _jQ.setPathValue(_MasterRulesForEngine, [RuleSetInternalname], MasterRules);

        _jQ.setPathValue(_FormRules, [RuleSetInternalname], FormRules.ValidFormRules);

        _jQ.setPathValue(Output, ["InValidFormRules"], FormRules.InValidFormRules);

        let EngineResult = Engine(engine_Inputdata, _FormRules, _MasterRulesForEngine);

        _jQ.setPathValue(Output, ["EngineResult"], EngineResult);

    } catch (error) {
        throw error
    }
    return Output;
}

function GetFormRules(fromcontext, RulesfromUI) {
    let Output = {};
    try {
        let StateFormRules = GetFormRulesFromContext(fromcontext);
        let ValidFormRules = [];
        let InValidFormRules = [];

        if (!isNullOrUndefined(RulesfromUI) && RulesfromUI.length > 0) {
            _.each(RulesfromUI, (item, index) => {
                if (_jQ.contains(StateFormRules, item))
                    ValidFormRules.push(item);
                else
                    InValidFormRules.push(item);
            });
        }
        else {
            ValidFormRules = StateFormRules;
        }

        _jQ.setPathValue(Output, ["InValidFormRules"], InValidFormRules);
        _jQ.setPathValue(Output, ["ValidFormRules"], ValidFormRules);
    } catch (error) {
        throw error
    }
    return Output;
}

function GetMasterRulesFromState(fromcontext) {
    let OutResult = {};
  //  let _MasterRules = GetMasterRules();  
    try {
        if (fromcontext == "SkipLogic") {
            OutResult = _jQ.pathValue(engine_MasterRules, ["RuleSetForSkipLogic"]);
        }

        if (fromcontext == "EventDriven") {
            OutResult = _jQ.pathValue(engine_MasterRules, ["RuleSetForEventDriven"]);
        }

        if (fromcontext == "FormState") {
            OutResult = _jQ.pathValue(engine_MasterRules, ["RuleSetForFormState"]);
        }
    } catch (error) {
        throw error;
    }
    return OutResult;
}

function GetFormRulesFromContext(fromcontext) {
    let OutResult = {};
  // let _FormRules = GetFormRulesfromRedux();

    try {
        if (fromcontext == "SkipLogic") {
            OutResult = _jQ.pathValue(engine_EvalFormRules, ["RuleSetForSkipLogic"]);
        }

        if (fromcontext == "EventDriven") {
            OutResult = _jQ.pathValue(engine_EvalFormRules, ["RuleSetForEventDriven"]);
        }

        if (fromcontext == "FormState") {
            OutResult = _jQ.pathValue(engine_EvalFormRules, ["RuleSetForFormState"]);
        }


    } catch (error) {
        throw error;
    }
    return OutResult;
}

// engine_EventsInfo = [
//     {
//         id: "txthhhd",
//         Events: [
//             { EventType: "onfocus", EventRules: ["skip.Rule1", "formstate.Rule2"] },
//             { EventType: "onChange", EventRules: ["skip.Rule1", "formstate.Rule2"] }
//         ]
//     }
// ]

function Eventcollector(MasterRule, FormRules, fromcontext) {
    try {
        if (fromcontext == "SkipLogic") {
            _.each(FormRules, (RuleID, i) => {
                try
                {
                    let Eventnames = _jQ.pathValue(MasterRule, [RuleID, "actionData", "Skip", "event"]);
                    let srceleinfo = _jQ.pathValue(MasterRule, [RuleID, "actionData", "Skip", "srcEleInfo"]);
    
                    if (isNullOrUndefined(Eventnames)) {
                        Eventnames = "focusout";
                    }
    
                    if (!isNullOrUndefined(srceleinfo) && !isNullOrUndefined(Eventnames))
                        Eventfinder("skip.", Eventnames, srceleinfo, RuleID);
                }
                catch(error)
                {
                    console.log(error);
                }
                
            });
        }

        if (fromcontext == "EventDriven") {

            _.each(FormRules, (RuleID, i) => {
                try
                {
                    let Eventnames = _jQ.pathValue(MasterRule, [RuleID, "actionData", "Mandate", "event"]);
                    let srceleinfo = _jQ.pathValue(MasterRule, [RuleID, "actionData", "Mandate", "srcEleInfo"]);
    
                    if (!isNullOrUndefined(srceleinfo) && !isNullOrUndefined(Eventnames))
                        Eventfinder("eventdriven.", Eventnames, srceleinfo, RuleID);
    
                    let tgtEleInfo = _jQ.pathValue(MasterRule, [RuleID, "actionData", "Mandate", "tgtEleInfo"]);
                    if (!isNullOrUndefined(tgtEleInfo)) {
                        _.each(tgtEleInfo, (tgele, j) => {
                            Eventfinder("eventdriven.", tgele.event, tgele.eleinfo, RuleID);
                        });
                    }
                }
                catch(error)
                {
                    console.log(error);
                }
              
            });
        }
    } catch (error) {
        throw error
    }
}

function Eventfinder(frmtxt, Eventnames, srceleinfo, RuleID) {
    try {

         if(!isNullOrUndefined(srceleinfo)){
             _.each(srceleinfo,(srcele,indx)=>{
                if(indx!=0 && !isNullOrUndefined(srcele)) {
                    if (!(_jQ.contains(engine_EventsInfo, { "id": srcele }, true))) {
                        let eventsdetail = {};
                        eventsdetail = _jQ.setPathValue(eventsdetail, ["id"], srcele);
                        if (!isNullOrUndefined(Eventnames)) {
                            _.each(Eventnames.split(','), (evt, i) => {
                                eventsdetail = _jQ.setPathValue(eventsdetail, ["Events", i, "EventType"], evt);
                                eventsdetail = _jQ.setPathValue(eventsdetail, ["Events", i, "EventRules", 0], frmtxt + RuleID);
                            });
                        }            
                        engine_EventsInfo.push(eventsdetail);
                    }
                    else {
                        let existseleindex = _jQ.index(engine_EventsInfo, { "id": srcele }, true);
            
                        if (!isNullOrUndefined(Eventnames)) {
                            _.each(Eventnames.split(','), (evt, i) => {
            
                                if (_jQ.contains(engine_EventsInfo[existseleindex].Events, { "EventType": evt }, true)) {
                                    let existseventtypeindex = _jQ.index(engine_EventsInfo[existseleindex].Events, { "EventType": evt }, true);
                                    if (engine_EventsInfo[existseleindex].Events[existseventtypeindex].EventRules.indexOf(frmtxt + RuleID) < 0)
                                        engine_EventsInfo[existseleindex].Events[existseventtypeindex].EventRules.push(frmtxt + RuleID);
                                }
                                else {
                                    let Event = {};
                                    _jQ.setPathValue(Event, ["EventType"], evt);
                                    _jQ.setPathValue(Event, ["EventRules", 0], frmtxt + RuleID);
                                    engine_EventsInfo[existseleindex].Events.push(Event);
                                }
                            });
                        }
                    }
                }

             });
         }
       

    } catch (error) {
        throw error
    }
}



export const EventBinding = () => {
    try {
        if (engine_EventsInfo.length > 0) {
            _.each(engine_EventsInfo, (eng_Evtinfo, i) => {

                var inputele = document.getElementById(eng_Evtinfo.id);
                if (!isNullOrUndefined(inputele) && !isNullOrUndefined(eng_Evtinfo.Events)) {
                    _.each(eng_Evtinfo.Events, (evt) => {                  
                        inputele.addEventListener(evt.EventType, function () { EventEngineexecution(evt.EventRules) });
                    });
                }
            });
        }
    } catch (error) {
        throw error;
    }
}

export const EventEngineexecution = (EngineRuleList) => {
    try {

        let EventDrivenRules = [];
        let skipRules = [];

        if (EngineRuleList.length > 0 && !isNullOrUndefined(EngineRuleList)) {
            EngineRuleList.map((item) => {
                if (item.indexOf('eventdriven') > -1)
                    EventDrivenRules.push(item.split('.')[1]);
                if (item.indexOf('skip') > -1)
                    skipRules.push(item.split('.')[1]);
            });

            if (!isNullOrUndefined(skipRules) && skipRules.length > 0)
                SkipRuleEngine(skipRules);

            if (!isNullOrUndefined(EventDrivenRules) && EventDrivenRules.length > 0)
                EventDrivenRuleEngine(EventDrivenRules);
        }
    } catch (error) {
        throw error
    }
}

export const GetRuleEvalOutput = (RulesQueue, RuleSetDefinition) => {

    let getRefRuleQueue=[];
     
    getRefRuleQueue = RuleTraversal(RulesQueue, RuleSetDefinition);

    let RuleOutput = RuleParser(getRefRuleQueue.items, RuleSetDefinition,engine_Inputdata);
  
    return RuleOutput.Rule;
}

export const OnDemandRuleEngineExecution = (formRules) => {
    let Output = {};
    try {
        Output = Engine(engine_Inputdata, formRules, engine_MasterRules)

    } catch (error) {
        throw error
    }
    return Output;
}