@masterportal/masterportalapi 2.34.0 → 2.35.0

package/CHANGELOG.md

@@ -11,6 +11,17 @@
 ### Removed
 ### Fixed
 
+---
+
+## 2.35.0 - 2024-04-02
+
+### Added
+- WMS: Support for using CQL filters by attribute added.
+
+### Fixed
+- Issue Masterportal #1127: fixed styling of clustered and not clustered circles.
+- WFST parsing featureType wfs.js with attribute required true by default.
+
 ---
 ## 2.34.0 - 2024-03-04
 

package/package.json

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

package/src/layer/wfs.js

@@ -447,7 +447,7 @@ function parseDescribeFeatureTypeResponse (responseData, featureType) {
             key: "",
             value: null,
             type: "string",
-            required: false
+            required: true
         }));
     }
     return [];

package/src/layer/wms.js

@@ -55,6 +55,7 @@ export function addOptionalParams (params, rawLayer) {
  * @param {boolean} rawLayer.singleTile - whether only one tile shall be requested that fills the whole view
  * @param {boolean} rawLayer.STYLES - styles of the layer, if available
  * @param {(string|number)} rawLayer.tilesize - if singleTile is true, this is the requested tilesize
+ * @param {string} rawLayer.cqlFilter - CQL filter
  * @returns {object} maps query parameter names to values
  */
 export function makeParams (rawLayer) {
@@ -66,7 +67,8 @@ export function makeParams (rawLayer) {
         LAYERS: rawLayer.layers,
         VERSION: rawLayer.version,
         TRANSPARENT: rawLayer.transparent,
-        SINGLETILE: rawLayer.singleTile
+        SINGLETILE: rawLayer.singleTile,
+        CQL_FILTER: rawLayer.cqlFilter
     }, rawLayer.singleTile ? {} : {WIDTH: rawLayer.tilesize, HEIGHT: rawLayer.tilesize});
 
     params = addOptionalParams(params, rawLayer);
@@ -90,6 +92,7 @@ async function defaultTileLoadFunction (imageTile, src) {
  * @param {function} [rawLayer.olAttribution] - optional function that takes a module:ol/Map~FrameState and returns a string or an array of strings representing source attributions
  * @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 {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

package/src/vectorStyle/styles/point/stylePoint.js

@@ -61,7 +61,7 @@ class PointStyle extends StyleClass {
             return createIconStyle(this.attributes, this.feature, isClustered);
         }
         else if (type === "circle") {
-            return createCircleStyle(this.attributes, isClustered);
+            return createCircleStyle(this.attributes, this.feature, isClustered);
         }
         else if (type === "nominal") {
             return isClustered ? createIconStyle(this.attributes, this.feature, isClustered) : createNominalPointStyle(this.attributes, this.feature, defaultStyle.point.imageName);

package/src/vectorStyle/styles/point/stylePointCircle.js

@@ -5,14 +5,16 @@ import {returnColor} from "../../lib/colorConvertions";
 * Creates pointStyle as circle.
 * all features get same circle.
 * @param {Object} attributes - The attributes from the circle
+* @param {Object} feature - The feature
 * @param {Boolean} isClustered - true if features are clustered
 * @returns {ol/style} - The created style.
 */
-export function createCircleStyle (attributes, isClustered) {
-    const radius = isClustered ? parseFloat(attributes.clusterCircleRadius, 10) : parseFloat(attributes.circleRadius, 10),
-        fillcolor = isClustered ? returnColor(attributes.clusterCircleFillColor, "rgb") : returnColor(attributes.circleFillColor, "rgb"),
-        strokecolor = isClustered ? returnColor(attributes.clusterCircleStrokeColor, "rgb") : returnColor(attributes.circleStrokeColor, "rgb"),
-        strokewidth = isClustered ? parseFloat(attributes.clusterCircleStrokeWidth, 10) : parseFloat(attributes.circleStrokeWidth, 10);
+export function createCircleStyle (attributes, feature, isClustered) {
+    const showCluster = isClustered && feature.get("features")?.length > 1,
+        radius = showCluster ? parseFloat(attributes.clusterCircleRadius, 10) : parseFloat(attributes.circleRadius, 10),
+        fillcolor = showCluster ? returnColor(attributes.clusterCircleFillColor, "rgb") : returnColor(attributes.circleFillColor, "rgb"),
+        strokecolor = showCluster ? returnColor(attributes.clusterCircleStrokeColor, "rgb") : returnColor(attributes.circleStrokeColor, "rgb"),
+        strokewidth = showCluster ? parseFloat(attributes.clusterCircleStrokeWidth, 10) : parseFloat(attributes.circleStrokeWidth, 10);
 
     return new Style({
         image: new CircleStyle({

package/test/layer/wms.test.js

@@ -25,7 +25,8 @@ describe("wms.js", function () {
                 LAYERS: "b",
                 VERSION: "c",
                 TRANSPARENT: "d",
-                SINGLETILE: "e"
+                SINGLETILE: "e",
+                CQL_FILTER: "f"
             };
         });
 
@@ -38,6 +39,7 @@ describe("wms.js", function () {
             expect(extendedParams.VERSION).toEqual("c");
             expect(extendedParams.TRANSPARENT).toEqual("d");
             expect(extendedParams.SINGLETILE).toEqual("e");
+            expect(extendedParams.CQL_FILTER).toEqual("f");
             expect(extendedParams.TIME).toEqual("The time");
             expect(extendedParams.STYLES).not.toBeDefined();
         });
@@ -50,6 +52,7 @@ describe("wms.js", function () {
             expect(extendedParams.VERSION).toEqual("c");
             expect(extendedParams.TRANSPARENT).toEqual("d");
             expect(extendedParams.SINGLETILE).toEqual("e");
+            expect(extendedParams.CQL_FILTER).toEqual("f");
             expect(extendedParams.STYLES).toEqual("The style");
             expect(extendedParams.TIME).not.toBeDefined();
         });

package/test/vectorStyle/createStyle.test.js

@@ -402,8 +402,17 @@ describe("getSimpleGeometryStyle", function () {
     });
 
     it("should return ol point style - clustered", function () {
+        const geometry = jsonObjects[0].getGeometry();
+        let styleObject = null;
+
         isClustered = true;
-        const styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
+        jsonObjects[0].get = (key) => {
+            if (key === "features") {
+                return [{id: "cluster1"}, {id: "cluster2"}];
+            }
+            return geometry;
+        };
+        styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
 
         expect(styleObject).toBeInstanceOf(PointStyle);
         expect(typeof styleObject).toBe("object");
@@ -470,9 +479,18 @@ describe("getMultiGeometryStyle", function () {
         expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
     });
     it("should include ol point style- is clustered and use rules for stroke color", function () {
+        const geometry = jsonObjects[3].getGeometry();
+        let style = null;
+
         isClustered = true;
+        jsonObjects[3].get = (key) => {
+            if (key === "features") {
+                return [{id: "cluster1"}, {id: "cluster2"}];
+            }
+            return geometry;
+        };
         rules[0].style.clusterCircleStrokeColor = [1, 2, 3, 4];
-        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+        style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
 
         expect(style[0]).toBeInstanceOf(PointStyle);
         expect(style[1]).toBeInstanceOf(PointStyle);

package/test/vectorStyle/styles/point/stylePointCircle.test.js

@@ -7,24 +7,61 @@ describe("stylePointCircle.js", () => {
                 circleRadius: 15,
                 circleFillColor: [10, 200, 100, 0.5],
                 circleStrokeColor: [10, 200, 100, 0.5],
-                circleStrokeWidth: 1
-            },
-            clusterAttributes = {
+                circleStrokeWidth: 1,
                 clusterCircleRadius: 20,
                 clusterCircleFillColor: [10, 200, 100, 0.5],
                 clusterCircleStrokeColor: [10, 200, 100, 0.5],
                 clusterCircleStrokeWidth: 1
+            },
+            feature = {
+                getProperties: () => {
+                    return {
+                        name: "singleFeature",
+                        id: "123"
+                    };
+                },
+                get: () => {
+                    return [];
+                }
+            },
+            clusteredFeature = {
+                get: () => {
+                    return [
+                        {
+                            name: "singleFeature1",
+                            id: "123"
+                        },
+                        {
+                            name: "singleFeature2",
+                            id: "456"
+                        }
+                    ];
+                }
             };
 
         it("should create circle style", () => {
-            expect(stylePointCircle.createCircleStyle(attributes, false)).toBeInstanceOf(Style);
-            expect(stylePointCircle.createCircleStyle(attributes, false).getImage()).toBeInstanceOf(Circle);
-            expect(stylePointCircle.createCircleStyle(attributes, false).getImage().getRadius()).toEqual(15);
+            const style = stylePointCircle.createCircleStyle(attributes, feature, false);
+
+            expect(style).toBeInstanceOf(Style);
+            expect(style.getImage()).toBeInstanceOf(Circle);
+            expect(style.getImage().getRadius()).toEqual(15);
+            expect(style.getImage().getFill().getColor()).toEqual(attributes.circleFillColor);
         });
         it("should create circle cluster style", () => {
-            expect(stylePointCircle.createCircleStyle(clusterAttributes, true)).toBeInstanceOf(Style);
-            expect(stylePointCircle.createCircleStyle(clusterAttributes, true).getImage()).toBeInstanceOf(Circle);
-            expect(stylePointCircle.createCircleStyle(clusterAttributes, true).getImage().getRadius()).toEqual(20);
+            const style = stylePointCircle.createCircleStyle(attributes, clusteredFeature, true);
+
+            expect(style).toBeInstanceOf(Style);
+            expect(style.getImage()).toBeInstanceOf(Circle);
+            expect(style.getImage().getRadius()).toEqual(20);
+            expect(style.getImage().getFill().getColor()).toEqual(attributes.clusterCircleFillColor);
+        });
+        it("should create circle not cluster style - respects feature.get('features')", () => {
+            const style = stylePointCircle.createCircleStyle(attributes, feature, true);
+
+            expect(style).toBeInstanceOf(Style);
+            expect(style.getImage()).toBeInstanceOf(Circle);
+            expect(style.getImage().getRadius()).toEqual(15);
+            expect(style.getImage().getFill().getColor()).toEqual(attributes.circleFillColor);
         });
     });
 });