kantime-rule-engine/engineActionlibrary.js

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

import { isNullOrUndefined } from "util";
import { GetRuleEvalOutput } from './engineFormHandler';
let _ = require("lodash");
let _jQ = require("jsonq");

export const skipActionlibrary = (RulesOutput) => {
    try {
        _.each(RulesOutput.RuleSetForSkipLogic, (outrule) => {
            try
            {
                let skipeles = _jQ.pathValue(outrule, ["actionData", "Skip", "skipEleInfo"]);
                let ActionType = "Disable";
    
                if (outrule.val) {
                    ExecuteAction(ActionType, skipeles);
                } else {
                    ExecuteAction(InverseActionEnum[ActionType], skipeles);
                }
            }
            catch(error)
            {
                console.log(error);
            }
           
        });
    } catch (error) {
        console.log(error);
    }
}

export const eventActionlibrary = (RulesOutput,StateMasterRules) => {
    try {
        _.each(RulesOutput.RuleSetForEventDriven, (outrule) => {
            try{
                if (outrule.val) {
                    // let srcEleId = _jQ.pathValue(outrule, ["actionData", "Mandate", "srcEleInfo", 1]);
                    let srcEleId = _jQ.pathValue(outrule, ["actionData", "Mandate", "srcEleInfo"]);
                    let srcEleMsgObj = _jQ.pathValue(outrule, ["actionData", "Mandate", "message"])
    
                    if (!isNullOrUndefined(srcEleMsgObj)) {
                        let srcEleMsg = _jQ.pathValue(srcEleMsgObj, [0]);
                        let srcEleprintType = _jQ.pathValue(srcEleMsgObj, [1]);
    
                        showToolTip(srcEleId, srcEleMsg, srcEleprintType);
                    }
    
                    let tgtEleInfo = _jQ.pathValue(outrule, ["actionData", "Mandate", "tgtEleInfo"]);
    
    
                    if (!isNullOrUndefined(tgtEleInfo) && tgtEleInfo.length > 0) {
                        _.each(tgtEleInfo, (tgtEle, i) => {
    
                            let RuleSetdefinition = {};
                            let RulesQueue = ["Rule"];
    
                            //_jQ.setPathValue(RuleSetdefinition, ["Rule"], tgtEle);                        
                           _jQ.setPathValue(StateMasterRules, ["Rule"], tgtEle); 
    
                            let tgtRuleOutput = GetRuleEvalOutput(RulesQueue, StateMasterRules);
    
                            if (tgtRuleOutput.val) {
                                //let trgt_EleId = _jQ.pathValue(tgtEle, ["eleinfo", 1]);
                                let trgt_EleId = _jQ.pathValue(tgtEle, ["eleinfo"]);
                                let trgt_EleMsgObj = _jQ.pathValue(tgtEle, ["message"])
    
                                if (!isNullOrUndefined(trgt_EleMsgObj)) {
                                    let trgt_EleMsg = _jQ.pathValue(trgt_EleMsgObj, [0]);
                                    let trgt_EleprintType = _jQ.pathValue(trgt_EleMsgObj, [1]);
                                    showToolTip(trgt_EleId, trgt_EleMsg, trgt_EleprintType);
                                }
                            }
                            else {
                                //let trgt_EleId = _jQ.pathValue(tgtEle, ["eleinfo", 1]);
                                let trgt_EleId = _jQ.pathValue(tgtEle, ["eleinfo"]);
                                hideToolTip(trgt_EleId);
                            }
                        });
                    }
                }
                else {
                    // let srcEleId = _jQ.pathValue(outrule, ["actionData", "Mandate", "srcEleInfo", 1]);
                    let srcEleId = _jQ.pathValue(outrule, ["actionData", "Mandate", "srcEleInfo"]);
                    hideToolTip(srcEleId);
    
                    let tgtEleInfo = _jQ.pathValue(outrule, ["actionData", "Mandate", "tgtEleInfo"]);
                    if (!isNullOrUndefined(tgtEleInfo) && tgtEleInfo.length > 0) {
                        _.each(tgtEleInfo, (tgtEle, i) => {
                            // let trgt_EleId = _jQ.pathValue(tgtEle, ["eleinfo", 1]);
                            let trgt_EleId = _jQ.pathValue(tgtEle, ["eleinfo"]);
                            hideToolTip(trgt_EleId);
                        });
                    }
                }
            }
            catch(error)
            {
                console.log(error);
            }
           
        });
    } catch (error) {
        console.log(error);
    }
}



export const FormStateActionlibrary = (rulesOutput) => {
    try {
        _.each(rulesOutput.RuleSetForFormState, (outrule) => {
            try{
                if (outrule.val) {
                    let ActionData = _jQ.pathValue(outrule, ["actionData"]);
                    let ActionTypes = Object.keys(ActionData);
                    _.each(ActionTypes, (action) => {
                        let trgtEles = _jQ.pathValue(ActionData, [action]);
                        ExecuteAction(action, trgtEles);                
                    });
                }
            }
            catch(error){
                console.log(error);
            }
        });
    } catch (error) {
        console.log(error);
    }
}

export const ExecuteAction = (actionType, elementArray) => {
    switch (actionType) {
        case "Enable":
            enableAllElements(elementArray);
            break;
        case "Disable":
            disableAllElements(elementArray);
            break;
        case "Show":
            showAllElements(elementArray);
            break;
        case "Hide":
            hideAllElements(elementArray);
            break;
        case "ReadOnly":
            readOnlyAllElements(elementArray);
            break;
        case "RemoveReadOnly":
            removeReadOnlyAllElements(elementArray);
            break;
    }
}

export const InverseActionEnum = {
    Enable: "Disable",
    Disable: "Enable",
    Show: "Hide",
    Hide: "Show",
    ReadOnly: "RemoveReadOnly",
    RemoveReadOnly: "ReadOnly"
}

export const showToolTip = (srcEleIds, srcEleMsg, srcEleprintType) => {
    if(!isNullOrUndefined(srcEleIds))
    {
        _.each(srcEleIds, (srcEleId, i) => {
            if(i!=0)
            {
                let srcele = document.getElementById(srcEleId);

                if (!isNullOrUndefined(srcEleMsg) && srcEleMsg != '' && !isNullOrUndefined(srcele)) {
                    if (!isNullOrUndefined(srcEleprintType) && srcEleprintType == "warning" && srcEleprintType != "") {
                        finddoc_ele_upTo(srcele, 'div').setAttribute('tooltip_warning', srcEleMsg);
                        srcele.classList.add('engineWarningField');
                    } else if (!isNullOrUndefined(srcEleprintType) && srcEleprintType == "info" && srcEleprintType != "") {
                        finddoc_ele_upTo(srcele, 'div').setAttribute('tooltip_Info', srcEleMsg);
                        srcele.classList.add('engineInfoField');
                    }
                    else {
                        finddoc_ele_upTo(srcele, 'div').setAttribute('tooltip_error', srcEleMsg);
                        srcele.classList.add('engineErrorField');
                    }
                }
            }
            
        });
    }
   
}

export const hideToolTip = (srcEleIds) => {
    if(!isNullOrUndefined(srcEleIds))
    {
        _.each(srcEleIds, (srcEleId, i) => {
            if(i!=0)
            {
                let srcele = document.getElementById(srcEleId);

                if (!isNullOrUndefined(srcele)) {
                    finddoc_ele_upTo(srcele, 'div').removeAttribute('tooltip_warning');
                    srcele.classList.remove('engineWarningField');
                    finddoc_ele_upTo(srcele, 'div').removeAttribute('tooltip_error');
                    srcele.classList.remove('engineErrorField');
                    finddoc_ele_upTo(srcele, 'div').removeAttribute('tooltip_Info');
                    srcele.classList.remove('engineInfoField');
                }
            }
            
        });
    }
}

export const enableAllElements = (elementarray) => {
    try {
        _.each(elementarray, (eleID) => {
            let ele = document.getElementById(eleID);
            if (!isNullOrUndefined(ele))
                ele.removeAttribute("disabled");
        });
    } catch (error) {
        throw error
    }
}

export const disableAllElements = (elementarray) => {
    try {
        _.each(elementarray, (eleID) => {
            var ele = document.getElementById(eleID);
            if (!isNullOrUndefined(ele)) {
                ele.value = "";
                ele.dispatchEvent(new Event('blur'));
                ele.disabled = true;
            }
        });
    } catch (error) {
        throw error
    }
}

export const showAllElements = (elementarray) => {
    try {
        _.each(elementarray, (eleID) => {
            let ele = document.getElementById(eleID);
            if (!isNullOrUndefined(ele))
                ele.style.removeProperty('display');
        });
    } catch (error) {
        throw error
    }
}

export const hideAllElements = (elementarray) => {
    try {
        _.each(elementarray, (eleID) => {
            let ele = document.getElementById(eleID);
            if (!isNullOrUndefined(ele))
                ele.style.display = "none";
        });
    } catch (error) {
        throw error
    }
}

export const readOnlyAllElements = (elementarray) => {
    try {
        _.each(elementarray, (eleID) => {
            let ele = document.getElementById(eleID);
            if (!isNullOrUndefined(ele)) {
                
                _.each(ele.children, (childele) => {
                    if (!isNullOrUndefined(childele))
                        childele.style.pointerEvents = "none";
                });
            }
            else {
                if (!isNullOrUndefined(ele))
                    ele.style.pointerEvents = "none";
            }
        });

    } catch (error) {
        throw error;
    }
}

export const removeReadOnlyAllElements = (elementarray) => {
    try {
      
        _.each(elementarray, (eleID) => {
            let ele = document.getElementById(eleID);            
            if (!isNullOrUndefined(ele)) {
                ele.style.pointerEvents = "";                
                _.each(ele.children, (childele) => {
                    if (!isNullOrUndefined(childele))
                        childele.style.pointerEvents = "";
                });
            }
            else {
                if (!isNullOrUndefined(ele))
                    ele.style.pointerEvents = "";
            }
            
        });
    } catch (error) {
        throw error;
    }
}

function finddoc_ele_upTo(el, tagName) {
    try {
        tagName = tagName.toLowerCase();
        var el1 = el;
        while (el && el.parentNode) {
            el = el.parentNode;
            if (el.tagName && el.tagName.toLowerCase() == tagName) {
                return el;
            }
        }
    } catch (error) {
        throw error
    }
    return el1;
}