Source: map/importer/binder/OgcBinder.js

import { Folder } from '../../layer/Folder/Folder.js';
import { createVEFLayerConfig } from "../../../utils/universal/ogc/createVEFLayerConfig.js";
import { parseWMSCapabilities } from "../../../utils/universal/ogc/parseWMSCapabilities.js";
import { parseWFSCapabilities } from "../../../utils/universal/ogc/parseWFSCapabilities.js";
import { loadLayer } from '../../utils/loadLayer.js';

export { OgcBinder };

/**
 * Class with static functions to load WMS and WFS Capabilities
 * @memberof vef.map.importer.binder
 */
class OgcBinder {

    /**
     * @private
     * @param {object} json 
     * @returns {object} layers
     */
    static async createLayers_(json) {
        try {
            // root folder
            const root = new Folder({ title: json.service.title })
            const layers = {}
            const structure = { "#": [root.uniqueId] }
            layers[root.uniqueId] = root;
            structure[root.uniqueId] = []

            const definitions = Object.values(json.layers);


            // prepare folders

            for (const definition of Object.values(json.layers)) {
                const parentId = definition.metadata?.parentId;
                const parent = json.layers[parentId];

                if (parent && !(parentId in structure)) {
                    const folder = new Folder({ title: parent.title }, null, parentId);
                    layers[parentId] = folder;
                    structure[parentId] = [];
                }
            }


            // prepare layers

            for (const definition of definitions) {
                structure[definition.metadata?.parentId || root.uniqueId].push(definition.uniqueId);
                if (definition.uniqueId in structure) continue;

                definition.resources.push(json.link, json.service);
                const config = await createVEFLayerConfig(definition);
                const layer = loadLayer({}, config);
                layers[definition.uniqueId] = layer;
            }

            return {
                layers: layers,
                structure: structure
            }
        } catch (e) {
            console.error(e);
        }
        return null;
    }

    /**
     * Get the response of the ogccapabilities tool
     * 
     * @param {string} parserUrl
     * @param {string} serviceUrl
     * @param {string} type (optional)
     * 
     * @returns {object} json response
     */
    static loadCapabilities(parserUrl, serviceUrl, type) {
        serviceUrl = serviceUrl.split("?")[0].trim();

        const promises = [];
        const types = ["wms", "wfs"];

        for (let t of types) {
            if (type && (type.toLowerCase() != t)) continue;
            switch (t) {
                case "wms":
                    promises.push(parseWMSCapabilities(serviceUrl));
                    break;
                case "wfs":
                    promises.push(parseWFSCapabilities(serviceUrl));
                    break;
            }
        }

        return Promise.all(promises)
    }

    /**
     * Creates layers from GetCapabilitites responses
     * 
     * @param {Array} capabilities responses from the ogccapabilities tool requests
     * 
     * @returns {Array} List with layer objects
     */
    static createLayerFromCapabilities(capabilities) {
        const promises = []
        for (let capability of capabilities) {
            promises.push(new Promise((resolve, reject) => { resolve(this.createLayers_(capability)) }))
        }
        return new Promise(resolve => {
            Promise.all(promises).then((data) => {
                resolve(data);
            }).catch(e => resolve(null));
        });
    }

    /**
     * Creates WMSLayers from a URL and parses the GetCapabilitites
     * 
     * @param {string} parserUrl
     * @param {string} serviceUrl
     * @param {string} type (optional)
     * 
     * @returns {object} object with layers and structure
     */
    static getCapabilities(parserUrl, serviceUrl, type) {
        return this.loadCapabilities(parserUrl, serviceUrl, type).then((responses) => {
            return this.createLayerFromCapabilities(responses)
        })
    }

}