theendsoaper/modules/xmlparse.js

Access Untill Tills with SOAP from Node.js and parse the results as objects, some extra useful functions in as well.

const Types = require('./function-types');
const parser = require('fast-xml-parser')
var he = require('he');
const Transaction = require('./classes/transaction');
const print = require('./printobject');
const ActiveOrder = require('./classes/active-orders');
const CancelledItem = require('./classes/cancelled-item');
const InOutItem = require('./classes/in-out-item');
const Report = require('./classes/report');
const Article = require('./classes/article');


module.exports = class XmlParse {

    parse(text, type) {
        // console.log("Parsing text: " + text);
        // console.log("Type:", type);
        var types = new Types();
        text = JSON.parse(this.xmlToJson(text));
        text = text["SOAP-ENV:Envelope"]['SOAP-ENV:Body']['NS1:' + type + 'Response']['return'];
        switch (type) {

            case types.getArticlesInfo(): return this.parseArticlesInfo(text);
            case types.getCancelledItemsReport(): return this.parseCancelledItems(text);
            case types.getActiveOrders(): return this.parseActiveOrders(text);
            case types.getActiveTableInfo(): return this.parseActiveTables(text);
            case types.getDetailedTurnoverReport(): return this.parseTurnover(text);
            case types.getInOutCashReport(): return this.parseInOutCash(text);
        }
    }

    parseArticlesInfo(text) {
        var articles = [];
        if (text["Articles"]["item"].length === undefined) {
            console.log("1 article???");
        } else {
            for (var i in text["Articles"]["item"]) {
                articles.push(new Article(text["Articles"]["item"][i]));
            }
        }
        return articles;
    }

    parseCancelledItems(text) {
        var list = [];

        if (text['Items']['item'] !== undefined) {
            if (text['Items']['item'].length === undefined) {
                list.push(new CancelledItem(text['Items']['item']));
            } else {
                for (var i in text['Items']['item']) {
                    list.push(new CancelledItem(text['Items']['item'][i]));
                }
            }
        }
        //print.print(list);
        return list;
    }

    //Finished
    parseActiveOrders(text) {
        var order = new ActiveOrder(text['Orders']);
        //print.print(order);
        return order;
    }

    //Finished
    parseActiveTables(text) {
        var order = {};
        if (text['Transaction'] !== '') {
            order = new Transaction(text['Transaction']);
        }
        return order;
    }


    parseTurnover(text) {
        var list = [];
        print.print(list);
        if (!text['Data'] || !text['Data']['item']) {
            return "fail, no data?"
        }
        if (text['Data']['item'].length === undefined) {
            list.push(new Report(text['Data']['item']));
        } else {
            for (var i in text['Data']['item']) {
                list.push(new Report(text['Data']['item'][i]));
            }
        }

        return list;
    }

    //Finished
    parseInOutCash(text) {
        var list = [];
        if (text['Items']['item'] !== undefined) {
            if (text['Items']['item'].length === undefined) {
                list.push(new InOutItem(text['Items']['item']));
            } else {
                for (var i in text['Items']['item']) {
                    list.push(new InOutItem(text['Items']['item'][i]));
                }
            }
        }
        //print.print(list);
        return list;
    }

    xmlToJson(text) {
        var options = {
            attributeNamePrefix: "@_",
            attrNodeName: "attr", //default is 'false'
            textNodeName: "#text",
            ignoreAttributes: true,
            ignoreNameSpace: false,
            allowBooleanAttributes: true,
            parseNodeValue: true,
            parseAttributeValue: false,
            trimValues: true,
            cdataTagName: "__cdata", //default is 'false'
            cdataPositionChar: "\\c",
            parseTrueNumberOnly: false,
            arrayMode: false, //"strict"
            attrValueProcessor: (val, attrName) => he.decode(val, { isAttributeValue: true }),//default is a=>a
            tagValueProcessor: (val, tagName) => he.decode(val), //default is a=>a
            stopNodes: ["parse-me-as-string"]
        };

        if (parser.validate(text) === true) {
            var json = parser.parse(text, options);
            return JSON.stringify(json);
        }
    }


}