qwc2
Version:
QGIS Web Client
752 lines (731 loc) • 31.8 kB
JavaScript
/**
* Copyright 2016-2024 Sourcepole AG
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
var urlUtil = require('url');
var axios = require('axios');
var XMLParser = require('fast-xml-parser').XMLParser;
var fs = require('fs');
var path = require('path');
var objectPath = require('object-path');
var isEmpty = require('lodash.isempty');
var uuidv4 = require('uuid').v1;
var os = require('os');
var dns = require('dns');
var _dns$promises = dns.promises,
lookup = _dns$promises.lookup,
lookupService = _dns$promises.lookupService;
var hostFqdn = "";
var themesConfigPath = process.env.QWC2_THEMES_CONFIG || "static/themesConfig.json";
var usedThemeIds = [];
var autogenExternalLayers = [];
function uniqueThemeId(themeName) {
if (!themeName) {
return uuidv4();
}
if (usedThemeIds.includes(themeName)) {
var i = 1;
for (; usedThemeIds.includes(themeName + i); ++i);
usedThemeIds.push(themeName + i);
return themeName + i;
} else {
usedThemeIds.push(themeName);
return themeName;
}
}
// load thumbnail from file or GetMap
function getThumbnail(configItem, resultItem, layers, crs, extent, resolve, proxy) {
if (configItem.thumbnail !== undefined) {
// check if thumbnail can be read
if (fs.existsSync("./static/assets/img/mapthumbs/" + configItem.thumbnail)) {
resultItem.thumbnail = "img/mapthumbs/" + configItem.thumbnail;
// finish task
resolve(true);
return;
}
}
/* eslint-disable-next-line */
console.error("Using WMS GetMap to generate thumbnail for " + configItem.url);
// WMS GetMap request
var parsedUrl = urlUtil.parse(urlUtil.resolve(hostFqdn, configItem.url), true);
parsedUrl.search = '';
parsedUrl.query.SERVICE = "WMS";
parsedUrl.query.VERSION = "1.3.0";
parsedUrl.query.REQUEST = "GetMap";
parsedUrl.query.FORMAT = "image/png";
parsedUrl.query.TRANSPARENT = "TRUE";
parsedUrl.query.STYLES = "";
parsedUrl.query.WIDTH = 200;
parsedUrl.query.HEIGHT = 100;
parsedUrl.query.CRS = crs;
var bboxw = extent[2] - extent[0];
var bboxh = extent[3] - extent[1];
var bboxcx = 0.5 * (extent[0] + extent[2]);
var bboxcy = 0.5 * (extent[1] + extent[3]);
var imgratio = 200 / 100;
if (bboxw > bboxh) {
var bboxratio = bboxw / bboxh;
if (bboxratio > imgratio) {
bboxh = bboxw / imgratio;
} else {
bboxw = bboxh * imgratio;
}
} else {
bboxw = bboxh * imgratio;
}
var adjustedExtent = [bboxcx - 0.5 * bboxw, bboxcy - 0.5 * bboxh, bboxcx + 0.5 * bboxw, bboxcy + 0.5 * bboxh];
parsedUrl.query.BBOX = adjustedExtent.join(',');
parsedUrl.query.LAYERS = layers.join(',');
var getMapUrl = urlUtil.format(parsedUrl);
axios.get(getMapUrl, {
proxy: proxy,
responseType: "arraybuffer",
auth: configItem.wmsBasicAuth
}).then(function (response) {
var basename = configItem.url.replace(/.*\//, "").replace(/\?.*$/, "") + ".png";
try {
fs.mkdirSync("./static/assets/img/genmapthumbs/");
} catch (err) {
if (err.code !== 'EEXIST') throw err;
}
fs.writeFileSync("./static/assets/img/genmapthumbs/" + basename, response.data);
resultItem.thumbnail = "img/genmapthumbs/" + basename;
// finish task
resolve(true);
})["catch"](function (error) {
/* eslint-disable-next-line */
console.error("ERROR generating thumbnail for WMS " + configItem.url + ":\n", error);
resultItem.thumbnail = "img/mapthumbs/default.jpg";
// finish task
resolve(false);
});
}
function getEditConfig(editConfig) {
if (isEmpty(editConfig)) {
return null;
} else if (_typeof(editConfig) === "object") {
return editConfig;
} else if (path.isAbsolute(editConfig) && fs.existsSync(editConfig)) {
return JSON.parse(fs.readFileSync(path, "utf8"));
} else if (fs.existsSync(process.cwd() + '/' + editConfig)) {
return JSON.parse(fs.readFileSync(process.cwd() + '/' + editConfig, "utf8"));
}
return null;
}
// convert non-array object to array containing the object
// used to restore arrays lost by xml -> json conversion
function toArray(obj) {
if (obj !== undefined) {
return Array.isArray(obj) ? obj : [obj];
}
return [];
}
// recursively get layer tree
function getLayerTree(layer, resultLayers, visibleLayers, printLayers, level, collapseBelowLevel, titleNameMap, featureReports, externalLayers) {
// skip print layers
var _iterator = _createForOfIteratorHelper(printLayers),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var printLayer = _step.value;
if (Array.isArray(printLayer)) {
if (printLayer.find(function (entry) {
return entry.name === layer.Name;
})) {
return;
}
} else if (printLayer === layer.Name) {
return;
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
var layerEntry = {
name: layer.Name,
title: layer.Title
};
if (layer.Layer === undefined) {
if (layer.$_geometryType === "WKBNoGeometry" || layer.$_geometryType === "NoGeometry") {
// skip layers without geometry
return;
}
// layer
layerEntry.geometryType = layer.$_geometryType;
if (layer.$_visibilityChecked !== undefined) {
layerEntry.visibility = layer.$_visibilityChecked === '1';
} else {
layerEntry.visibility = layer.$_visible === '1';
}
if (layerEntry.visibility) {
// collect visible layers
visibleLayers.push(layer.Name);
}
layerEntry.queryable = layer.$_queryable === '1';
if (layerEntry.queryable) {
layerEntry.displayField = layer.$_displayField;
}
if (layer.Attribution) {
layerEntry.attribution = {
Title: layer.Attribution.Title,
OnlineResource: layer.Attribution.OnlineResource ? layer.Attribution.OnlineResource.$_href : ""
};
}
if (layer.Abstract) {
layerEntry["abstract"] = layer.Abstract;
}
if (layer.DataURL && layer.DataURL.OnlineResource) {
layerEntry.dataUrl = layer.DataURL.OnlineResource.$_href;
if (layerEntry.dataUrl.startsWith("wms:")) {
externalLayers.push({
internalLayer: layer.Name,
name: layerEntry.dataUrl
});
layerEntry.dataUrl = "";
}
}
if (layer.MetadataURL && layer.MetadataURL.OnlineResource) {
layerEntry.metadataUrl = layer.MetadataURL.OnlineResource.$_href;
}
if (layer.$_transparency) {
layerEntry.opacity = 255 - Math.floor(parseFloat(layer.$_transparency) * 255);
} else if (layer.$_opacity) {
layerEntry.opacity = Math.round(parseFloat(layer.$_opacity) * 255);
} else {
layerEntry.opacity = 255;
}
if (layer.KeywordList) {
var keywords = [];
toArray(layer.KeywordList.Keyword).map(function (entry) {
keywords.push(_typeof(entry) === 'object' ? entry._ : entry);
});
layerEntry.keywords = keywords.join(", ");
}
if (layer.Style) {
var _Object$keys$;
layerEntry.styles = toArray(layer.Style).reduce(function (res, entry) {
return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, entry.Name, entry.Title));
}, {});
layerEntry.style = layerEntry.styles["default"] ? 'default' : (_Object$keys$ = Object.keys(layerEntry.styles)[0]) !== null && _Object$keys$ !== void 0 ? _Object$keys$ : '';
}
if (layer.MinScaleDenominator !== undefined) {
layerEntry.minScale = Math.round(parseFloat(layer.MinScaleDenominator));
layerEntry.maxScale = Math.round(parseFloat(layer.MaxScaleDenominator));
}
// use geographic bounding box, as default CRS may have inverted axis order with WMS 1.3.0
if (layer.EX_GeographicBoundingBox) {
layerEntry.bbox = {
crs: "EPSG:4326",
bounds: [parseFloat(layer.EX_GeographicBoundingBox.westBoundLongitude), parseFloat(layer.EX_GeographicBoundingBox.southBoundLatitude), parseFloat(layer.EX_GeographicBoundingBox.eastBoundLongitude), parseFloat(layer.EX_GeographicBoundingBox.northBoundLatitude)]
};
}
if (featureReports[layer.Name]) {
layerEntry.featureReport = featureReports[layer.Name];
}
layerEntry.dimensions = [];
toArray(layer.Dimension).forEach(function (dim) {
layerEntry.dimensions.push({
units: dim.$_units,
name: dim.$_name,
multiple: dim.$_multipleValues === "1",
value: dim._,
fieldName: dim.$_fieldName,
endFieldName: dim.$_endFieldName
});
});
} else {
// group
layerEntry.mutuallyExclusive = layer.$_mutuallyExclusive === '1';
if (layer.$_visibilityChecked !== undefined) {
layerEntry.visibility = layer.$_visibilityChecked === '1';
} else {
layerEntry.visibility = layer.$_visible === '1';
}
layerEntry.sublayers = [];
if (layer.$_expanded === '0' || collapseBelowLevel >= 0 && level >= collapseBelowLevel) {
layerEntry.expanded = false;
} else {
layerEntry.expanded = true;
}
var _iterator2 = _createForOfIteratorHelper(toArray(layer.Layer)),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var subLayer = _step2.value;
getLayerTree(subLayer, layerEntry.sublayers, visibleLayers, printLayers, level + 1, collapseBelowLevel, titleNameMap, featureReports, externalLayers);
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
if (layerEntry.sublayers.length === 0) {
// skip empty groups
return;
}
}
resultLayers.push(layerEntry);
titleNameMap[layer.TreeName] = layer.Name;
}
function flatLayers(layer) {
var result = [layer];
(layer.Layer || []).forEach(function (sublayer) {
return result.push(sublayer);
});
return result;
}
// parse GetCapabilities for theme
function getTheme(config, configItem, result, resultItem, proxy) {
if (configItem.disabled) {
/* eslint-disable-next-line no-console */
console.log("Item ".concat(configItem.url) + (configItem.title ? " (".concat(configItem.title, ")") : "") + " has been disabled");
return null;
}
var parsedUrl = urlUtil.parse(urlUtil.resolve(hostFqdn, configItem.url), true);
parsedUrl.search = '';
parsedUrl.query.SERVICE = "WMS";
parsedUrl.query.VERSION = "1.3.0";
parsedUrl.query.REQUEST = "GetProjectSettings";
var getCapabilitiesUrl = urlUtil.format(parsedUrl);
return new Promise(function (resolve, reject) {
axios.get(getCapabilitiesUrl, {
proxy: proxy,
auth: configItem.wmsBasicAuth
}).then(function (response) {
var _XMLParser$parse;
// parse capabilities
var parseOptions = {
removeNSPrefix: true,
isArray: function isArray() {
return false;
},
ignoreAttributes: false,
attributeNamePrefix: "$_",
textNodeName: "_"
};
var capabilities = (_XMLParser$parse = new XMLParser(parseOptions).parse(response.data)) === null || _XMLParser$parse === void 0 ? void 0 : _XMLParser$parse.WMS_Capabilities;
if (capabilities === undefined) {
// show response data on parse error
throw new Error(response.data);
}
/* eslint-disable-next-line */
console.log("Parsing WMS GetProjectSettings of " + configItem.url + (configItem.title ? " (".concat(configItem.title, ")") : ""));
var topLayer = capabilities.Capability.Layer;
var wmsName = configItem.url.replace(/.*\//, '').replace(/\?^/, '');
// use name from config or fallback to WMS title
var wmsTitle = configItem.title || capabilities.Service.Title || topLayer.Title || wmsName;
// keywords
var keywords = [];
if (capabilities.Service.KeywordList) {
toArray(capabilities.Service.KeywordList.Keyword).map(function (entry) {
var value = _typeof(entry) === 'object' ? entry._ : entry;
if (value !== "infoMapAccessService") {
keywords.push(value);
}
});
}
// use first CRS for thumbnail request
var crs = toArray(topLayer.CRS).filter(function (item) {
return item !== 'CRS:84';
})[0];
var extent = [];
var _iterator3 = _createForOfIteratorHelper(toArray(topLayer.BoundingBox)),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var bbox = _step3.value;
if (bbox.$_CRS === crs) {
extent = [parseFloat(bbox.$_minx), parseFloat(bbox.$_miny), parseFloat(bbox.$_maxx), parseFloat(bbox.$_maxy)];
break;
}
}
// collect WMS layers for printing
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
var printLayers = configItem.extraPrintLayers || [];
if (configItem.backgroundLayers !== undefined) {
printLayers = configItem.backgroundLayers.reduce(function (printLyrs, entry) {
if (entry.printLayer) {
printLyrs.push(entry.printLayer);
}
return printLyrs;
}, []);
}
// layer tree and visible layers
var collapseLayerGroupsBelowLevel = configItem.collapseLayerGroupsBelowLevel || -1;
var layerTree = [];
var visibleLayers = [];
var titleNameMap = {};
var externalLayers = [];
getLayerTree(topLayer, layerTree, visibleLayers, printLayers, 1, collapseLayerGroupsBelowLevel, titleNameMap, configItem.featureReport || {}, externalLayers);
autogenExternalLayers.push.apply(autogenExternalLayers, _toConsumableArray(externalLayers.map(function (entry) {
return entry.name;
})));
externalLayers.push.apply(externalLayers, _toConsumableArray(configItem.externalLayers || []));
visibleLayers.reverse();
// print templates
var printTemplates = [];
if (capabilities.Capability.ComposerTemplates !== undefined) {
var templates = capabilities.Capability.ComposerTemplates.ComposerTemplate;
if (!templates.length) {
templates = [templates];
}
var composerTemplateMap = {};
var _iterator4 = _createForOfIteratorHelper(templates),
_step4;
try {
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
var composerTemplate = _step4.value;
if (composerTemplate.ComposerMap !== undefined) {
composerTemplateMap[composerTemplate.$_name] = composerTemplate;
}
}
} catch (err) {
_iterator4.e(err);
} finally {
_iterator4.f();
}
Object.values(composerTemplateMap).forEach(function (composerTemplate) {
var templateName = composerTemplate.$_name;
if (templateName.endsWith("_legend") && templateName.slice(0, -7) in composerTemplateMap) {
return;
}
// use first map from GetProjectSettings
var composerMap = toArray(composerTemplate.ComposerMap)[0];
var printTemplate = {
name: templateName,
map: {
name: composerMap.$_name,
width: parseFloat(composerMap.$_width),
height: parseFloat(composerMap.$_height)
}
};
if (printTemplate.name + "_legend" in composerTemplateMap) {
printTemplate.legendLayout = printTemplate.name + "_legend";
}
if (composerTemplate.ComposerLabel !== undefined) {
printTemplate.labels = toArray(composerTemplate.ComposerLabel).map(function (entry) {
return entry.$_name;
}).filter(function (label) {
return !(configItem.printLabelBlacklist || []).includes(label);
});
}
printTemplate["default"] = configItem.defaultPrintLayout === printTemplate.name;
if (composerTemplate.$_atlasEnabled === '1') {
var atlasLayer = composerTemplate.$_atlasCoverageLayer;
try {
var layers = flatLayers(capabilities.Capability.Layer);
var pk = layers.find(function (l) {
return l.Name === atlasLayer;
}).PrimaryKey.PrimaryKeyAttribute;
printTemplate.atlasCoverageLayer = atlasLayer;
printTemplate.atlas_pk = pk;
} catch (e) {
/* eslint-disable-next-line */
console.warn("Failed to determine primary key for atlas layer " + atlasLayer);
}
}
printTemplates.push(printTemplate);
});
}
// drawing order
var drawingOrder = (capabilities.Capability.LayerDrawingOrder || "").split(",").map(function (title) {
return title in titleNameMap ? titleNameMap[title] : title;
});
// update theme config
resultItem.url = configItem.url;
resultItem.id = uniqueThemeId(configItem.id || wmsName);
resultItem.name = topLayer.Name;
resultItem.title = wmsTitle;
resultItem.description = configItem.description || "";
resultItem.attribution = {
Title: configItem.attribution || "",
OnlineResource: configItem.attributionUrl || ""
};
// service info
resultItem["abstract"] = capabilities.Service.Abstract || "";
resultItem.keywords = keywords.join(', ');
resultItem.onlineResource = capabilities.Service.OnlineResource.$_href;
resultItem.contact = {
person: objectPath.get(capabilities, "Service.ContactInformation.ContactPersonPrimary.ContactPerson", ""),
organization: objectPath.get(capabilities, "Service.ContactInformation.ContactPersonPrimary.ContactOrganization", ""),
position: objectPath.get(capabilities, "Service.ContactInformation.ContactPosition", ""),
phone: objectPath.get(capabilities, "Service.ContactInformation.ContactVoiceTelephone", ""),
email: objectPath.get(capabilities, "Service.ContactInformation.ContactElectronicMailAddress", "")
};
resultItem.format = configItem.format;
resultItem.availableFormats = capabilities.Capability.Request.GetMap.Format;
resultItem.tiled = configItem.tiled;
resultItem.tileSize = configItem.tileSize;
resultItem.version = configItem.version ? configItem.version : config.defaultWMSVersion;
resultItem.infoFormats = capabilities.Capability.Request.GetFeatureInfo.Format;
// use geographic bounding box for theme, as default CRS may have inverted axis order with WMS 1.3.0
var bounds = [parseFloat(topLayer.EX_GeographicBoundingBox.westBoundLongitude), parseFloat(topLayer.EX_GeographicBoundingBox.southBoundLatitude), parseFloat(topLayer.EX_GeographicBoundingBox.eastBoundLongitude), parseFloat(topLayer.EX_GeographicBoundingBox.northBoundLatitude)];
resultItem.bbox = {
crs: "EPSG:4326",
bounds: bounds
};
if (configItem.extent) {
resultItem.initialBbox = {
crs: configItem.mapCrs || result.themes.defaultMapCrs,
bounds: configItem.extent
};
} else {
resultItem.initialBbox = resultItem.bbox;
}
resultItem.scales = configItem.scales;
resultItem.printScales = configItem.printScales;
resultItem.printResolutions = configItem.printResolutions;
resultItem.printGrid = configItem.printGrid;
// NOTE: skip root WMS layer
resultItem.sublayers = isEmpty(layerTree) ? [] : layerTree[0].sublayers;
resultItem.expanded = true;
resultItem.externalLayers = externalLayers;
resultItem.backgroundLayers = configItem.backgroundLayers;
resultItem.searchProviders = configItem.searchProviders;
resultItem.additionalMouseCrs = configItem.additionalMouseCrs;
resultItem.mapCrs = configItem.mapCrs || result.themes.defaultMapCrs;
resultItem.defaultDisplayCrs = configItem.defaultDisplayCrs;
if (printTemplates.length > 0) {
resultItem.print = printTemplates;
}
resultItem.drawingOrder = drawingOrder;
if (configItem.extraDxfParameters) {
resultItem.extraDxfParameters = configItem.extraDxfParameters;
}
if (configItem.extraPrintParameters) {
resultItem.extraPrintParameters = configItem.extraPrintParameters;
}
if (configItem.legendUrl) {
resultItem.legendUrl = configItem.legendUrl;
} else {
resultItem.legendUrl = capabilities.Capability.Request.GetLegendGraphic.DCPType.HTTP.Get.OnlineResource.$_href.replace(/\?$/, "") + "?" + (configItem.extraLegendParameters ? configItem.extraLegendParameters : '');
}
if (configItem.featureInfoUrl) {
resultItem.featureInfoUrl = configItem.featureInfoUrl;
} else {
resultItem.featureInfoUrl = capabilities.Capability.Request.GetFeatureInfo.DCPType.HTTP.Get.OnlineResource.$_href.replace(/\?$/, "") + "?";
}
if (configItem.printUrl) {
resultItem.printUrl = configItem.printUrl;
} else {
resultItem.printUrl = capabilities.Capability.Request.GetPrint.DCPType.HTTP.Get.OnlineResource.$_href.replace(/\?$/, "") + "?";
}
if (configItem.printLabelForSearchResult) {
resultItem.printLabelForSearchResult = configItem.printLabelForSearchResult;
}
if (configItem.printLabelForAttribution) {
resultItem.printLabelForAttribution = configItem.printLabelForAttribution;
}
if (configItem.printLabelConfig) {
resultItem.printLabelConfig = configItem.printLabelConfig;
}
if (configItem.watermark) {
resultItem.watermark = configItem.watermark;
}
if (configItem.pluginData) {
resultItem.pluginData = configItem.pluginData;
}
if (configItem.predefinedFilters) {
resultItem.predefinedFilters = configItem.predefinedFilters;
}
if (configItem.snapping) {
resultItem.snapping = configItem.snapping;
}
if (configItem.minSearchScaleDenom) {
resultItem.minSearchScaleDenom = configItem.minSearchScaleDenom;
} else if (configItem.minSearchScale) {
// Legacy name
resultItem.minSearchScaleDenom = configItem.minSearchScale;
}
if (configItem.themeInfoLinks) {
resultItem.themeInfoLinks = configItem.themeInfoLinks;
}
if (configItem.layerTreeHiddenSublayers) {
resultItem.layerTreeHiddenSublayers = configItem.layerTreeHiddenSublayers;
}
resultItem.skipEmptyFeatureAttributes = configItem.skipEmptyFeatureAttributes;
resultItem.config = configItem.config;
resultItem.flags = configItem.flags;
resultItem.mapTips = configItem.mapTips;
resultItem.userMap = configItem.userMap;
resultItem.map3d = configItem.map3d;
resultItem.obliqueDatasets = configItem.obliqueDatasets;
resultItem.viewMode = configItem.viewMode;
resultItem.editConfig = getEditConfig(configItem.editConfig);
// set default theme
if (configItem["default"] || !result.themes.defaultTheme) {
result.themes.defaultTheme = resultItem.id;
}
// get thumbnail asynchronously
getThumbnail(configItem, resultItem, visibleLayers, crs, extent, resolve, proxy);
})["catch"](function (error) {
/* eslint-disable-next-line */
console.error("ERROR reading WMS GetProjectSettings of " + configItem.url + ":\n", error);
resultItem.error = "Could not read GetProjectSettings";
resultItem.title = "Error";
// finish task
reject(resultItem.error);
});
});
}
// asynchronous tasks
var tasks = [];
// recursively get themes for groups
function getGroupThemes(config, configGroup, result, resultGroup, proxy, groupCounter) {
var _iterator5 = _createForOfIteratorHelper(configGroup.items),
_step5;
try {
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
var item = _step5.value;
var itemEntry = {};
var task = getTheme(config, item, result, itemEntry, proxy);
if (task) {
tasks.push(task);
resultGroup.items.push(itemEntry);
}
}
} catch (err) {
_iterator5.e(err);
} finally {
_iterator5.f();
}
if (configGroup.groups !== undefined) {
var _iterator6 = _createForOfIteratorHelper(configGroup.groups),
_step6;
try {
for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
var group = _step6.value;
var groupEntry = {
id: 'g' + ++groupCounter,
title: group.title,
titleMsgId: group.titleMsgId,
items: [],
subdirs: []
};
getGroupThemes(config, group, result, groupEntry, proxy, groupCounter);
resultGroup.subdirs.push(groupEntry);
}
} catch (err) {
_iterator6.e(err);
} finally {
_iterator6.f();
}
}
}
function genThemes(themesConfig) {
// load themesConfig.json
var config = JSON.parse(fs.readFileSync(process.cwd() + '/' + themesConfig, "utf8"));
var result = {
themes: {
title: "root",
subdirs: [],
items: [],
defaultTheme: config.defaultTheme,
defaultMapCrs: config.defaultMapCrs || 'EPSG:3857',
defaultDisplayCrs: config.defaultDisplayCrs,
defaultScales: config.defaultScales,
defaultPrintScales: config.defaultPrintScales,
defaultPrintResolutions: config.defaultPrintResolutions,
defaultPrintGrid: config.defaultPrintGrid,
defaultSearchProviders: config.defaultSearchProviders,
defaultBackgroundLayers: config.defaultBackgroundLayers || [],
externalLayers: config.themes.externalLayers || [],
pluginData: config.themes.pluginData,
themeInfoLinks: config.themes.themeInfoLinks,
backgroundLayers: config.themes.backgroundLayers.map(function (bglayer) {
bglayer.attribution = {
Title: bglayer.attribution,
OnlineResource: bglayer.attributionUrl
};
delete bglayer.attributionUrl;
return bglayer;
}),
defaultWMSVersion: config.defaultWMSVersion
}
};
var proxy = config.proxy || null;
var groupCounter = 0;
getGroupThemes(config, config.themes, result, result.themes, proxy, groupCounter);
Promise.all(tasks).then(function () {
for (var _i = 0, _autogenExternalLayer = autogenExternalLayers; _i < _autogenExternalLayer.length; _i++) {
var entry = _autogenExternalLayer[_i];
var cpos = entry.indexOf(":");
var hpos = entry.lastIndexOf('#');
var type = entry.slice(0, cpos);
var url = entry.slice(cpos + 1, hpos);
var layername = entry.slice(hpos + 1);
result.themes.externalLayers.push({
name: entry,
type: type,
url: url,
params: {
LAYERS: layername
},
infoFormats: ["text/plain"]
});
}
if (result.themes.backgroundLayers !== undefined) {
// get thumbnails for background layers
result.themes.backgroundLayers.map(function (backgroundLayer) {
var imgPath = "img/mapthumbs/" + backgroundLayer.thumbnail;
if (!fs.existsSync("./static/assets/" + imgPath)) {
imgPath = "img/mapthumbs/default.jpg";
}
backgroundLayer.thumbnail = imgPath;
});
}
// write config file
fs.writeFile(process.cwd() + '/static/themes.json', JSON.stringify(result, null, 2), function (error) {
if (error) {
/* eslint-disable-next-line */
console.error("ERROR:", error);
process.exit(1);
} else {
/* eslint-disable-next-line */
console.log("\nCreated themes.json\n\n");
}
});
})["catch"](function (error) {
/* eslint-disable-next-line */
console.error("ERROR:", error);
process.exit(1);
});
return result;
}
lookup(os.hostname(), {
hints: dns.ADDRCONFIG
}).then(function (result) {
return lookupService(result.address, 0);
}).then(function (result) {
hostFqdn = "http://" + result.hostname;
/* eslint-disable-next-line */
console.log("Reading " + themesConfigPath);
genThemes(themesConfigPath);
})["catch"](function (error) {
process.nextTick(function () {
throw error;
});
});