@masterportal/masterportalapi 2.36.0 → 2.37.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
+## 2.37.0 - 2024-04-23
+
+### Fixed
+- Issue Masterportal #1114: `isSecured` parameter is considered for WMS load function
+- Issue Masterportal #1114: custom loading function for WMS is now applied on non-tiled WMS, too.
+  However, because of issue 666 in ol-cesium it does not work for 3D and is enabled for `isSecured: true` layers only
+- Image layers that cannot be converted by olcs are now properly handled
+
+---
+
 ## 2.36.0 - 2024-04-11
 
 ### Changed

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.36.0",
+  "version": "2.37.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {

package/src/layer/terrain.js

@@ -26,7 +26,7 @@ async function createTerrainProvider (rawLayer) {
  * @param {OLCesium} map ol cesium map
  * @returns {void}
  */
-async function setVisible (value, rawLayer, map) {
+export async function setVisible (value, rawLayer, map) {
     if (map && typeof map.getCesiumScene === "function") {
         if (value) {
             map.getCesiumScene().terrainProvider = await createTerrainProvider(rawLayer);
@@ -64,5 +64,3 @@ export function get (key) {
     }
     return this.values[key];
 }
-
-module.exports.setVisible = setVisible;

package/src/layer/wms.js

@@ -76,11 +76,18 @@ export function makeParams (rawLayer) {
     return params;
 }
 
-async function defaultTileLoadFunction (imageTile, src) {
-    const response = await fetch(src),
-        data = await response.blob();
+/**
+ * Return a ol tile or image load function for the rawLayer.
+ * @param {object} rawLayer - layer specification as in services.json
+ * @returns {function} tile/image load function
+ */
+export function defaultLoadFunction ({isSecured}) {
+    return async (image, src) => {
+        const response = await fetch(src, {credentials: isSecured ? "include" : "omit"}),
+            data = await response.blob();
 
-    imageTile.getImage().src = URL.createObjectURL(data);
+        image.getImage().src = URL.createObjectURL(data);
+    };
 }
 
 /**
@@ -93,6 +100,7 @@ async function defaultTileLoadFunction (imageTile, src) {
  * @param {string|number} [rawLayer.tilesize] - optional needed to create the tileGrid
  * @param {string|"anonymous"} [rawLayer.crossOrigin] - optional needed for CORS requests of image data, to enable canvas export
  * @param {string} [rawLayer.cqlFilter] - optional CQL filter to add to the request
+ * @param {boolean} [rawLayer.isSecured] - whether the layer is secured by BasicAuth and should include or omit the credentials prompt
  * @param {object} options - optional resolutions and origin to create the TileGrid
  * @param {Array} [options.resolutions] - optional resolutions to create the TileGrid, must be in descending order
  * @param {Array} [options.origin] - optional origin to create the TileGrid
@@ -111,7 +119,10 @@ export function createLayerSource (rawLayer, options) {
             serverType: rawLayer.serverType,
             projection: projection,
             attributions: rawLayer.olAttribution,
-            crossOrigin: rawLayer.crossOrigin
+            crossOrigin: rawLayer.crossOrigin,
+            ...rawLayer.isSecured ? { // TODO: Remove this guard when olcs#666 is resolved
+                imageLoadFunction: defaultLoadFunction(rawLayer)
+            } : {}
         });
     }
     if (options && options.resolutions) {
@@ -129,7 +140,7 @@ export function createLayerSource (rawLayer, options) {
         projection: projection,
         attributions: rawLayer.olAttribution,
         crossOrigin: rawLayer.crossOrigin,
-        tileLoadFunction: defaultTileLoadFunction
+        tileLoadFunction: defaultLoadFunction(rawLayer)
     });
 }
 

package/src/maps/olcs/3dUtils/wmsRasterSynchronizer.js

@@ -112,7 +112,8 @@ class WMSRasterSynchronizer extends AbstractSynchronizer {
             provider = this.createProviderForTileWMS(source, viewProj, olLayer);
         }
         else if (source instanceof ImageWMS) {
-            return [this.createImageryLayerForImageWMS(olLayer, viewProj)];
+            cesiumLayer = this.createImageryLayerForImageWMS(olLayer, viewProj);
+            return cesiumLayer ? [cesiumLayer] : null;
         }
         else if (source instanceof StaticImageSource) {
             provider = this.createProviderForStaticImageSource(source);

package/test/layer/wms.test.js

@@ -102,6 +102,40 @@ describe("wms.js", function () {
         });
     });
 
+    describe("defaultLoadFunction", function () {
+        beforeEach(() => {
+            const blob = new Blob();
+
+            global.fetch = jest.fn().mockImplementation(async (url, {credentials}) => {
+                if ((url === "SECURE_WMS" && credentials === "include") ||
+                    (url === "INSECURE_WMS" && (typeof credentials === "undefined" || credentials === "omit"))) {
+                    return {
+                        ok: true,
+                        status: 200,
+                        blob: () => Promise.resolve(blob)
+                    };
+                }
+                throw new Error("Bad request");
+            });
+            URL.createObjectURL = jest.fn().mockImplementation(value => value === blob ? "blob:BLOB" : null);
+        });
+
+        it("passes credentials if isSecured is set", async function () {
+            const result = wms.defaultLoadFunction({isSecured: true}),
+                input = {src: ""};
+
+            await result({getImage: () => input}, "SECURE_WMS");
+            expect(input.src).toEqual("blob:BLOB");
+        });
+        it("does not pass credentials if isSecured is not set", async function () {
+            const result = wms.defaultLoadFunction({isSecured: false}),
+                input = {src: ""};
+
+            await result({getImage: () => input}, "INSECURE_WMS");
+            expect(input.src).toEqual("blob:BLOB");
+        });
+    });
+
     describe("createLayerSource", function () {
         it("creates a TileWMS for multi tile requests", function () {
             const source = wms.createLayerSource({singleTile: false});