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 {
            const folder = new Folder({ title: json.service.title })
            const layers = {}
            const structure = { "#": [folder.uniqueId] }
            layers[folder.uniqueId] = folder;
            structure[folder.uniqueId] = []

            for (let l in json.layers) {
                json.layers[l].resources.push(json.link, json.service);
                const config = await createVEFLayerConfig(json.layers[l]);
                const layer = loadLayer({}, config);
                layers[layer.uniqueId] = layer;
                structure[folder.uniqueId].push(layer.uniqueId)
            }

            return {
                layers: layers,
                structure: structure
            }
        } catch (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)
        })
    }

}