Utils versión Javascript

Utils.js

// start
importPackage(com.liquidsoft.msurvey.api);

/**
 * Crea un array a partir del rango indicado:
 * 
 * Array.range(1,3) -> [1,2,3]
 * Array.range(0,10,2)) -> [0,2,4,6,8,10]
 *  Array.range('a','d')) -> ['a','b','c','d']
 *  Array.range('R','V')) -> ['R','S','T','U', 'V']
 * 
 * @param {Number} init (inclusive)
 * @param {Number} end (inclusive)
 * @param {Number} step indica el incremento, 1 por defecto
 * @returns {Array}
 */
Array.range = function (init, end, step) {
    var A = [];
    if (typeof init === 'number') {
        A[0] = init;
        step = step || 1;
        while (init + step <= end) {
            A[A.length] = init += step;
        }
    } else {
        var s = 'abcdefghijklmnopqrstuvwxyz';
        if (init === init.toUpperCase()) {
            end = end.toUpperCase();
            s = s.toUpperCase();
        }
        s = s.substring(s.indexOf(init), s.indexOf(end) + 1);
        A = s.split('');
    }
    return A;
};

/**
 * Agrega el método contains a la clase Array, el método retorna true si contiene el valor, false en caso contrario.
 *
 * Ej:
 * Array.range(1,9).contains(1) -> true
 * Array.range(1,9).contains("1") -> true
 * Array.range(1,9).contains(10) -> false
 * 
 * @param {type} value
 * @returns {Boolean}
 */
Array.prototype.contains = function (value) {
    return this.indexOf(value) > -1 || this.indexOf(""+value) > -1 || this.indexOf(parseFloat(value)) > -1;
};

/**
 * Retorna true si este array contiene alguno de los elementos de "valuesArray"
 * 
 * @param {type} value
 * @returns {Boolean}
 */
Array.prototype.containsOr = function (valuesArray) {
    for (var i = 0; i < valuesArray.length; i++) {
        if (this.contains(valuesArray[i])) {
            return true;
        }
    }
    return false;
};

/**
 * Retorna true si este array contiene todos los elementos de "valuesArray"
 * 
 * @param {type} value
 * @returns {Boolean}
 */
Array.prototype.containsAnd = function (valuesArray) {
    for (var i = 0; i < valuesArray.length; i++) {
        if (!this.contains(valuesArray[i])) {
            return false;
        }
    }
    return true;
};


Utils = {

    // Obtiene el valor de las opciones seleccionadas en una pregunta de opciones múltiples
   enterOptsValues: function (alias) {
        var answer = ApiClient.findAnswerOptions(alias);
        return Utils.enterOptsValuesByAnswer(answer);
   },

   enterOptsValuesByAnswer: function (answer) {
        if (answer==null) {
            return [];
        }

        var enterOptions = answer.getEnterOptions();
        var valuesSel = [];
        for (var i = 0; i < enterOptions.length(); i++) {
            var optAlias = enterOptions.get(i);
            var opt = ApiClient.findItem(optAlias);
            valuesSel.push(""+opt.getValue());
        }   
        return valuesSel;
   },

   enterOptValue: function (alias) {
        var answer = ApiClient.findAnswer(alias);
        return Utils.enterOptValueByAnswer(answer);
   },

   // Obtiene el valor de la opción seleccionada en una pregunta de opciones simples
   enterOptValueByAnswer: function (answer) {
        var valuesSel = Utils.enterOptsValuesByAnswer(answer);
        if (valuesSel.length>1) {
            throw "La pregunta " + answer.getQAlias() +" tiene más de una respuesta";
        }
        if (valuesSel.length==0) { // respuesta nula
            return -1;
        }

        return valuesSel[0];
   },

   enterColumnValByAnswer: function(answer, rowValue) {
        if (answer!=null) {
            var matrixJsonObj = answer.getEnterMatrix(); // matrix single format: jsonobject {"aliasOpt1":"aliasCol1", "aliasOpt2":"aliasCol1"}
            var options = matrixJsonObj.names();
            for (var i = 0; i < options.length(); i++) {
                var optionAlias = options.get(i);
                var opt = ApiClient.findItem(optionAlias);
                if (opt.getValue() == rowValue) {
                    var colAlias = matrixJsonObj.get(optionAlias);
                    var col = ApiClient.findItem(colAlias);
                    return col.getValue(); 
                }
            }
        }
        return -1;
   }, 

   // Obtiene el valor de la columna que se capturó en la fila con valor "rowValue" dentro de la pregunta con alias "alias"
   enterColumnVal: function(alias, rowValue) {
        var answer = ApiClient.findAnswer(alias);
        return Utils.enterColumnValByAnswer(answer, rowValue);
    },

    // Obtiene el texto capturado en la pregunta de texto abierto
    enterTextByAnswer: function(answer) {
        return answer!=null ? answer.getEnterText() : "";
    },

    enterTextFloatByAnswer: function(answer) {
        return parseFloat(Utils.enterTextByAnswer(answer));
    },

    enterTextIntByAnswer: function(answer) {
        return parseInt(Utils.enterTextByAnswer(answer), 10); // radix 10
    },

    enterTextInt: function(alias) {
        var answer = ApiClient.findAnswer(alias);
        return Utils.enterTextIntByAnswer(answer);
    },

    enterTextFloat: function(alias) {
        var answer = ApiClient.findAnswer(alias);
        return Utils.enterTextFloatByAnswer(answer);
    },

    // Obtiene el texto capturado en una opción de una pregunta de opciones abiertas
    // alias: alias del nodo 
    // optAlias: alias de la opción de la cual se desea obtener el texto
    enterOptText: function(alias, optAlias) {
        var answer = ApiClient.findAnswerOptions(alias);
        if (answer!=null) {
            var optionsText = answer.getOptionsText(); // jsonObject {"aliasopt":"text", "aliasopt2":"text2"}
            var text = optionsText.get(optAlias);
            return text!=null && text.trim()!="" ? text : null;
        } else {
            return null;
        }
    },

    // Obtiene el texto capturado en una opción de una pregunta de opciones abiertas
    // alias: alias del nodo 
    // optValue: valor de la opción de la cual se desea obtener el texto
    enterOptTextByValue: function(alias, optValue) {
        var opt = Utils.findItemByValue(alias, optValue);
        return Utils.enterOptText(alias, opt.getAlias());
    },

    // Obtiene el texto de la opción seleccionada en una pregunta de opciones simples o simples con otra.
    // Esta función se puede invocar con un solo argumento si no se trata de una pregunta de opciones con otra: Utils.enterOptSingleText("P10")
    enterOptSingleText: function(alias, otherValue) {
        var answer = ApiClient.findAnswerOptions(alias); // opc simples
        if (answer==null) {
            return null;
        }
        if (otherValue==null) {// no se envió el argumento, -1 por defecto
            otherValue = -1;
        }

        var enterOptAlias = answer.getEnterOption();
        var enterOpt = ApiClient.findItem(enterOptAlias);
        var enterVal = enterOpt.getValue();
        return enterVal != otherValue ? enterOpt.getText() : answer.getEnterOtherText(); // 997 (otra)
    }, 

    // Pone visibles todas las opciones del nodo "alias" a excepción de "skip" (opcional, por defecto [])
    setVisibleAllOptions: function(alias, skip) {
        if (skip==undefined) {
            skip=[];
        }
        
        var node=ApiClient.findQuestionOptions(alias);
        var nodeOpts = node.getOptions();
        for (var i = 0; i < nodeOpts.length; i++) {
            var opt = nodeOpts[i];
            if (!skip.contains(opt.getValue())) {
                opt.setVisible(true);    
            }
        }
    },
    
    // alias: alias del nodo sobre el que se va incluir las opciones, debe ser de tipo opciones/matriz
    // includeAliasNodesArray: includeAliasNodes array con los alias de los nodos de los cuales se van a incluir los valores de las opciones contestadas, pueden no traer respuesta.
    // skipValues array que contiene los valores de las opciones del nodo a omitir, las opciones con estos valores no las toca y las deja con su propiedad setVisible intacta (parámetro opcional, por defecto []).
    // resetAllOptions true: hace visibles todas las opciones antes de hacer el include, false: deja intactas las opciones en su propiedad visible (parámetro opcional, por defecto true)
    // Ejemplo:
    // includeOptionsValues("P2B", ["P2", "P2A"], [99]) : Muestra en P2B las opciones capturadas en P2/P2A, la opción con código 99 se queda visible (intacta)
    includeOptionsValues: function(alias, includeAliasNodesArray, skipValuesArray, resetAllOptions) {
        if (resetAllOptions == undefined) {
            resetAllOptions = true;
        }
        if (resetAllOptions) {
            Utils.setVisibleAllOptions(alias, skipValuesArray);
        }
        
        if (skipValuesArray==undefined) {
            skipValuesArray=[];
        }

        var valuesSel = [];
        for (var i = 0; i < includeAliasNodesArray.length; i++) {
            var aliasNode = includeAliasNodesArray[i];
            var answerOpts = ApiClient.findAnswerOptions(aliasNode);
            if (answerOpts!=null) {
                var valuesSel2 = Utils.enterOptsValuesByAnswer(answerOpts);
                for (var j = 0; j < valuesSel2.length; j++) {
                    valuesSel.push(""+valuesSel2[j]);
                }
            }
        }

        var node=ApiClient.findQuestionOptions(alias);
        var nodeOpts = node.getOptions();
        for (var i = 0; i < nodeOpts.length; i++) {
            var opt = nodeOpts[i];
            var value = opt.getValue();

            if (!skipValuesArray.contains(value) && opt.isVisible()) {
                if (valuesSel.contains(value)) { // la opción fue seleccionada
                    opt.setVisible(true);
                } else {
                    opt.setVisible(false);
                }
            }
        }
    },

    // Utils.excludeOptionsValues("P48A", ["P48"]);
    // Utils.excludeOptionsValues("P48B", ["P48", "P48A"]);
    excludeOptionsValues: function(alias, excludeAliasNodesArray, skipValuesArray, resetAllOptions) {
        if (resetAllOptions == undefined) {
            resetAllOptions = true;
        }
        if (resetAllOptions) {
            Utils.setVisibleAllOptions(alias, skipValuesArray);
        }
        
        if (skipValuesArray==undefined) {
            skipValuesArray=[];
        }

        var valuesSel = [];
        for (var i = 0; i < excludeAliasNodesArray.length; i++) {
            var aliasNode = excludeAliasNodesArray[i];
            var answerOpts = ApiClient.findAnswerOptions(aliasNode);
            if (answerOpts!=null) {
                var valuesSel2 = Utils.enterOptsValuesByAnswer(answerOpts);
                for (var j = 0; j < valuesSel2.length; j++) {
                    valuesSel.push(""+valuesSel2[j]);
                }
            }
        }

        var node=ApiClient.findQuestionOptions(alias);
        var nodeOpts = node.getOptions();
        for (var i = 0; i < nodeOpts.length; i++) {
            var opt = nodeOpts[i];
            var value = opt.getValue();

            if (!skipValuesArray.contains(value) && opt.isVisible()) {
                if (valuesSel.contains(value)) { // la opción fue seleccionada
                    opt.setVisible(false);
                } else {
                    opt.setVisible(true);
                }
            }
        }
    },

    // Ej. Utils.replaceNodeTextVars("P59", {"P12_TEXT": P12_TEXT, "P2_TEXT": P2_TEXT});
    replaceNodeTextVars: function (alias, mapVars) {
        var data = new JSONObject();
        for (var key in mapVars) {
            data.put(""+key, mapVars[key]);
        }
        var node = ApiClient.findNode(alias);
        node.expandText(data);
    },

    // valida si está capturada al menos la primer opción de la pregunta de opciones de texto abierto
    isEnterFirstMentionOptsText: function (answer) {
        if (answer==null){
            return false;
        }

        var alias = answer.getQAlias();
        var node = ApiClient.findNode(alias);
        var nodeOpts = node.getOptions();
        var firstOptAlias = nodeOpts[0].getAlias();
        var optionsText = answer.getOptionsText(); // jsonObject {"aliasopt":"text", "aliasopt2":"text2"}
        var options = optionsText.names();//jsonarray
        var firstMention = optionsText.get(firstOptAlias);
        return firstMention != null ? firstMention.trim()!="": false;
    },

    isBlank: function(text) {
        return text==null || text.trim()=="";
    },

    isInt:function(text) {
        return !isNaN(text) && (function(x) { return (x | 0) === x; })(parseFloat(text));
    },

    isEnterAllOptsText: function (answer) {
        if (answer==null){
            return false;
        }

        var firstOptAlias = nodeOpts[0].getAlias();
        var optionsText = answer.getOptionsText(); // jsonObject {"aliasopt":"text", "aliasopt2":"text2"}
        var alias = answer.getQAlias();
        var node = ApiClient.findNode(alias);   
        var nodeOpts = node.getOptions();
        for (var i = 0; i < nodeOpts.length; i++) {
            var opt = nodeOpts[i];
            var text = optionsText.get(opt.getAlias());
            if (Utils.isBlank(text)) {
                return false;
            }
        }
        return true;
    },

    // Todos lo valores de las casillas (visibles) deben ser enteros mayores o iguales a 0
    isEnterAllOptsTextAsPosInt: function (answer) {
        if (answer==null){
            return false;
        }

        var optionsText = answer.getOptionsText(); // jsonObject {"aliasopt":"text", "aliasopt2":"text2"}
        var alias = answer.getQAlias();
        var node = ApiClient.findNode(alias);   
        var nodeOpts = node.getOptions();
        for (var i = 0; i < nodeOpts.length; i++) {
            var opt = nodeOpts[i];
            if (!opt.isVisible()){
                continue;
            }

            if (optionsText.has(opt.getAlias())) {
                var text = optionsText.get(opt.getAlias());
                if (!Utils.isInt(text) || text<0) {
                    return false;
                }   
            } else {
                return false;
            }
        }
        return true;
    },

    // retorna true si ninguna columna o solo 1 tiene el valor de la columna indicada
    isTwoOrMoreRowsWithColValue: function(answer, colValue) {
        var matrixJsonObj = answer.getEnterMatrix(); // jsonobject {"aliasOpt1":"aliasCol1", "aliasOpt2":"aliasCol1"}
        var options = matrixJsonObj.names();
        var countCol = 0;
        for (var i = 0; i < options.length(); i++) {
            var optionAlias = options.get(i);
            var colAlias = matrixJsonObj.get(optionAlias);
            var col = ApiClient.findItem(colAlias);
            var colVal = col.getValue();
            if (colVal==colValue) {
                countCol++;
            }
        }

        return countCol>=2;
    },

    // oculta el item con valor "itemValue" que se encuentra dentro del nodo "alias"
    hideItemWithValue: function(alias, itemValue) {
        var node = ApiClient.findNode(alias);
        var item = Utils.findItemByValue(alias, itemValue);
        item.setVisible(false);
    },

    // muestra el item con valor "itemValue" que se encuentra dentro del nodo "alias"
    showItemWithValue: function(alias, itemValue) {
        var node = ApiClient.findNode(alias);
        var item = Utils.findItemByValue(alias, itemValue);
        item.setVisible(true);
    },

    // Busca dentro del nodo "alias" el item con valor itemValue
    findItemByValue: function(alias, itemValue) {
        var node = ApiClient.findNode(alias);
        var items = node.getItems();
        for (var i = 0; i < items.length; i++) {
            var item = items[i];
            if (item.getValue() == itemValue) {
                return item;
            }
        }
        throw "no existe el item " + itemValue + " dentro del nodo " + alias;
    },

    // Si eligen el código que se encuentra en la llave del mapa dentro de "aliasValues", mostrará "aliasShows" con el valor del código del mapa.
    // 
    // Ejemplo:
    // ThisUtils.showAndWaitByMapRules("P12", "F8", {1:"A", 2:"B", 3:"C", 4:"D"});
    // Muestra P12A si eligen F8(cod1)
    // Muestra P12B si eligen F8(cod2)
    // Muestra P12C si eligen F8(cod3)
    // Muestra P12D si eligen F8(cod4)
    showAndWaitByMapRules: function(aliasShows, aliasValues, map) {
        var enterValues = Utils.enterOptsValues(aliasValues);
        for (var key in map) {
            if (enterValues.contains(key)) {
                var letter = map[key];
                ApiClient.showAndWait(aliasShows+letter);
            }
        }

    },

    // muestra el nodo "alias" sustituyendo previamente las variables de "mapVars"
    showAndWaitWithReplace: function(alias, mapVars) {
        Utils.replaceNodeTextVars(alias, mapVars);
        ApiClient.showAndWait(alias);
    },

    onlyShowItemWithValue: function(alias, itemValue, skipValuesArray) {
        if (skipValuesArray==null) {
            skipValuesArray=[];
        }

        var node = ApiClient.findNode(alias);
        var items = node.getItems();
        for (var i = 0; i < items.length; i++) {
            var item = items[i];
            var val = item.getValue();
            if(!skipValuesArray.contains(val)) {
                item.setVisible(val == itemValue);
            }
        }
    },

   // Obtiene los valores de las opciones seleccionadas en los nodos "nodesArray"
   // nodesArray: array con los alias de los nodos 
   enterNodesOptsValues: function (nodesArray) {
        var valuesSelAll = [];
        for (var i = 0; i < nodesArray.length; i++) {
            var nodeValuesSel = Utils.enterOptsValues(nodesArray[i]);
            valuesSelAll = valuesSelAll.concat(nodeValuesSel);
        }
        return valuesSelAll;
   },
}

ThisUtils = {
    // obtiene los textos de las opciones OTRA1/OTRA2/OTRA3
    getP2OtherTexts123: function() {
        var text1=null;
        var text2=null;
        var text3=null;
        var enterValP2 = Utils.enterOptValue("P2");
        if (enterValP2 == 997) {
            // Si contestan algo en P2/OTRA:
            // T1: P2/OTRA
            // T2: P2T_1
            // T3: P2T_2
            text1 = Utils.enterOptSingleText("P2", 997);
            text2 = Utils.enterOptTextByValue("P2T", 9971);
            text3 = Utils.enterOptTextByValue("P2T", 9972);
        } else {
            // Si NO contestan algo en P2/OTRA:
            // T1: P2T_1
            // T2: P2T_2
            // T3: P2T_3    
            text1 = Utils.enterOptTextByValue("P2T", 9971);
            text2 = Utils.enterOptTextByValue("P2T", 9972);
            text3 = Utils.enterOptTextByValue("P2T", 9973);
        }

        return [text1,text2,text3];
    },
}

 
function onNavigate(params) {
    ApiClient.showAndWait($node);
    var next = ApiClient.findNext($node);
    return next;
}