spws/lib/services/lists/getList/parseList.js

SharePoint Web Services Wrapper

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
// Classes
var classes_1 = require("../../../classes");
// Enum
var enum_1 = require("../../../enum");
// Utils
var getListStaticName_1 = __importDefault(require("../../../utils/getListStaticName"));
/**
 * Parses a list from the provided parameters.
 *
 * @param params - The parameters for parsing the list.
 * @param params.res - The response object containing the XML data.
 * @param params.attributes - An optional array of attribute names to include in the parsed data.
 *
 * @returns An object containing the parsed list data.
 *
 * @throws {SpwsError} If the list cannot be found in the response XML.
 *
 * @remarks
 * - If the `attributes` parameter is empty or includes `StaticName`, the function attempts to get the static name.
 * - If the `attributes` parameter is empty or includes `Fields`, the function adds fields to the data.
 * - The function handles various child elements such as Choices, Validation, DefaultFormula, DefaultFormulaValue, Default, and Formula.
 */
var parseList = function (params) {
    // Destructure params
    var res = params.res, _a = params.attributes, attributes = _a === void 0 ? [] : _a;
    // Check that list exists
    var list = res.responseXML.querySelector("List");
    // If the list cannot be found
    if (!list)
        throw new classes_1.SpwsError(res);
    // Create array of attributes either from params or all of the list attributes
    var attributesArray = attributes.length > 0
        ? attributes
        : Array.from(list.attributes).map(function (el) { return el.name; });
    // Create data object with only specified attributes
    var data = attributesArray.reduce(function (object, attribute) {
        object[attribute] = list.getAttribute(attribute) || "";
        return object;
    }, {});
    // If the attributes param is empty, or it included StaticName
    if (attributes.length === 0 || attributes.includes("StaticName")) {
        // Try to get the static name
        try {
            data.StaticName = (0, getListStaticName_1.default)({
                DefaultViewUrl: data.DefaultViewUrl,
                Title: data.Title,
            });
        }
        catch (error) {
            // On error do nothing
        }
    }
    // Create parser
    var serializer = new XMLSerializer();
    // If the attributes param is empty, or it included fields
    if (attributes.length === 0 || attributes.includes(enum_1.ListAttributes.Fields))
        // Add fields to data
        data[enum_1.ListAttributes.Fields] = Array.from(
        // Field attributes must be an array
        list.querySelectorAll("".concat(enum_1.ListAttributes.Fields, " > Field"))).map(function (fieldElement) {
            // Create field object
            var field = {};
            // Get the field type
            var fieldType = fieldElement.getAttribute(enum_1.Field.Type);
            // Reduce field from available attributes
            field = Array.from(fieldElement.attributes).reduce(function (object, element) {
                // Get field name and value
                var key = element.nodeName;
                var value = element.textContent || "";
                // If the value is true or false
                if (["TRUE", "FALSE"].includes(value)) {
                    // Cast to boolean
                    value = value === "TRUE";
                }
                // Assign key and prop
                object[key] = value;
                return object;
            }, field);
            // Handle Child Elements: Choices
            if (fieldType === "Choice" || fieldType === "MultiChoice") {
                // Add choicess to the field
                field.Choices = Array.from(fieldElement.querySelectorAll("CHOICE"))
                    // Return text content
                    .map(function (_a) {
                    var textContent = _a.textContent;
                    return textContent;
                })
                    // Remove empty choices
                    .filter(function (choice) { return choice; });
            }
            // Handle Child Elements: Validation
            var validation = fieldElement.querySelector("Validation");
            if (validation)
                field.Validation = serializer.serializeToString(validation);
            // Handle Child Elements: Default Formula
            var defaultFormula = fieldElement.querySelector("DefaultFormula");
            if (defaultFormula)
                field.DefaultFormula = defaultFormula.textContent || "";
            // Handle Child Elements: Default Formula Value
            var defaultFormulaValue = fieldElement.querySelector("DefaultFormulaValue");
            if (defaultFormulaValue)
                field.DefaultFormulaValue = defaultFormulaValue.textContent || "";
            // Handle Child Elements: Default Value
            var defaultValue = fieldElement.querySelector("Default");
            if (defaultValue)
                field.Default = defaultValue.textContent || "";
            // Handle Child Elements: Formula
            if (field.Type === "Calculated") {
                // String to store formula xml
                var xml = "";
                // Check each xml node and append to xml string
                var formula = fieldElement.querySelector("Formula");
                if (formula)
                    xml += serializer.serializeToString(formula);
                var formulaDisplayNames = fieldElement.querySelector("FormulaDisplayNames");
                if (formulaDisplayNames)
                    xml += serializer.serializeToString(formulaDisplayNames);
                var fieldRefs = fieldElement.querySelector("FieldRefs");
                if (fieldRefs)
                    xml += serializer.serializeToString(fieldRefs);
                // If xml string is truthy, assign to field
                if (xml)
                    field.Formula = xml;
            }
            // Return
            return field;
        });
    return data;
};
exports.default = parseList;
//# sourceMappingURL=parseList.js.map