@masterportal/masterportalapi 2.46.0 → 2.47.0

package/CHANGELOG.md

@@ -18,6 +18,23 @@
 ### Fixed
 
 ---
+
+## 2.47.0 - 2025-03-20
+
+### Added
+- An interface to OGC API Processes has been added.
+
+### Changed
+- The following package has been updated:
+    - peerDependencies:
+        - cesium/engine: 13.0.0 to 15.0.0
+
+### Fixed
+- Reset the depthTestAgainstTerrain parameter to true due to problems with the height of the terrain model.
+- WMS-Layer: fixed setting of projection for olcs.
+
+---
+
 ## 2.46.0 - 2025-03-10
 
 ### Changed

package/example/config/services.json

@@ -44,6 +44,17 @@
     "version": "1.1.0",
     "featureNS": "http://www.deegree.org/app"
   },
+  {
+    "id": "2426",
+    "name": "Bezirke",
+    "url": "https://geodienste.hamburg.de/HH_WMS_Verwaltungsgrenzen",
+    "typ": "WMS",
+    "layers": "bezirke",
+    "version": "1.3.0",
+    "singleTile": true,
+    "transparent": true,
+    "transparency": 0
+  },
   {
     "id": "4001",
     "name": "Gelaende",

package/example/index.js

@@ -132,7 +132,7 @@ services.find(({id}) => id === "5001").style = styleOaf;
 map2D = mapsAPI.map.createMap(config, "2D", {errorCallback});
 window.mpapi.map = map2D;
 
-["2001", "2002", "1002", "3001", "5001"].forEach(id => window.mpapi.map.addLayer(id, {errorCallback}));
+["2001", "2002", "1002", "3001", "5001", "2426"].forEach(id => window.mpapi.map.addLayer(id, {errorCallback}));
 
 // ping all layers
 services
@@ -231,8 +231,36 @@ window.mpapi.search("Mümmelmannsberg 72", {
     searchAddress: true
 }).then(x => console.log(x)).catch(e => console.error(e));
 
-//*/
+// */
+
+/* OGC API - PROCESSES EXAMPLE */
+/*
+// Enter the URL to an OGC API - Processes service here.
+const ogcApiProcessUrl = ""; // eslint-disable-line
+
+async function testOgcApiProcesses (processUrl) {
+    const processList = await window.mpapi.ogcApiProcesses.processList(processUrl),
+        processDescription = await window.mpapi.ogcApiProcesses.processDescription(processUrl, processList[0].id),
+        jobList = await window.mpapi.ogcApiProcesses.jobList(processUrl),
+        data = {};
+
+    console.log("### OGC API - PROCESSES EXAMPLE ###"); // eslint-disable-line
+    console.log("Process list:", processList); // eslint-disable-line
+    console.log("Process Description:", processDescription); // eslint-disable-line
+
+    // create example data from process input schema
+    Object.keys(processDescription.inputs).forEach(key => data[key] = `Example ${key}`); // eslint-disable-line
+    console.log("Execute Process:", await window.mpapi.ogcApiProcesses.executeProcess(processUrl, processList[0].id, data)); // eslint-disable-line
+
+    console.log("Job List:", jobList); // eslint-disable-line
+    console.log("Job Status of last job:", await window.mpapi.ogcApiProcesses.jobStatus(processUrl, jobList.at(-1).jobID)); // eslint-disable-line
+    console.log("Job Results of last job:", await window.mpapi.ogcApiProcesses.jobResults(processUrl, jobList.at(-1).jobID)); // eslint-disable-line
+    console.log("Cancle the last Job:", await window.mpapi.ogcApiProcesses.cancelJob(processUrl, jobList.at(-1).jobID)); // eslint-disable-line
+    console.log("Job list:", await window.mpapi.ogcApiProcesses.jobList(processUrl)); // eslint-disable-line
+}
 
+testOgcApiProcesses(ogcApiProcessUrl);
+// */
 
 // Add 3D functionality to the example:
 // ---------------------------------------

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.46.0",
+  "version": "2.47.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -56,7 +56,7 @@
     "util": "^0.12.5"
   },
   "peerDependencies": {
-    "@cesium/engine": "^13.0.0"
+    "@cesium/engine": "^15.0.0"
   },
   "engines": {
     "node": "^16.13.2 || ^18.12.0 || ^20.12.2",

package/src/api/ogcApiProcesses.js

@@ -0,0 +1,205 @@
+/**
+ * This is an implementation of the interface to OGC API - Processes - Part 1: Core.
+ * @module api/ogcApiProcesses
+ * @see {@link https://ogcapi.ogc.org/processes|OGC API - Processes} for further information
+ */
+
+/**
+ * Returns the url params for a DELETE request.
+ * @returns {object} The url params for DELETE request.
+ */
+function fetchDeleteParams () {
+    return {
+        method: "DELETE"
+    };
+}
+
+/**
+ * Returns the url params for a GET request.
+ * @returns {object} The url params for GET request.
+ */
+function fetchGetParams () {
+    return {
+        method: "GET"
+    };
+}
+
+/**
+ * Returns the url params for a POST request.
+ * @param {object} body The request body.
+ * @returns {object} The url params for poPOSTst request.
+ */
+function fetchPostParams (body) {
+    return {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    };
+}
+
+/**
+ * Returns the fetch params by request method.
+ * @param {string} method The fetch method.
+ * @param {object} body The request body.
+ * @returns {object} The fetch params.
+ */
+function fetchParams (method, body) {
+    const fetchParamsByMethod = {
+        DELETE: fetchDeleteParams,
+        GET: fetchGetParams,
+        POST: fetchPostParams
+    };
+
+    return fetchParamsByMethod[method](body);
+}
+/**
+ * Fetch the url with fetch api and catch errors.
+ * @param {string} processUrl The process url.
+ * @param {string} [method=GET] The fetch method.
+ * @param {object} [body={}] The request body, only used if request-method is POST.
+ * @returns {object} The response object.
+ */
+function fetchUrl (processUrl, method = "GET", body = {}) {
+    return new Promise((resolve, reject) => {
+        fetch(processUrl, fetchParams(method, body))
+            .then(response => {
+                const errorMessage = `Status code: ${response.status}.`;
+
+                if (response.ok) {
+                    return response.json();
+                }
+                else if (response.status === "400") {
+                    throw new Error(`${errorMessage} The URL: ${response.url} is an bad request! Perhaps the status of the process or job is failure!`);
+                }
+                else if (response.status === "404") {
+                    throw new Error(`${errorMessage} The URL: ${response.url} was not found!`);
+                }
+
+                throw new Error(`${errorMessage} The response of the URL: ${response.url} has an error occured!`);
+            })
+            .then(responseJson => resolve(responseJson))
+            .catch(error => {
+                reject(error);
+            });
+    });
+}
+
+/**
+ * Retrieve the list of available processes.
+ * @param {string} processUrl The process url.
+ * @param {boolean} [nextLink=false] If processurl is a nextLink.
+ * @returns {object[]} The process list.
+ */
+async function processList (processUrl, nextLink = false) {
+    const url = nextLink ? processUrl : `${processUrl}/processes`,
+        responseJson = await fetchUrl(url),
+        nextLinkObject = responseJson?.links?.find(link => link.rel === "next");
+    let processes = responseJson.processes;
+
+    if (typeof nextLinkObject !== "undefined") {
+        processes = processes.concat(await processList(nextLinkObject.href, true));
+    }
+
+    return processes;
+}
+
+/**
+ * Retrieve the description of a process.
+ * @param {string} processUrl The process url.
+ * @param {string} processId The process id.
+ * @returns {object} The process description.
+ */
+async function processDescription (processUrl, processId) {
+    const url = `${processUrl}/processes/${processId}`,
+        responseJson = await fetchUrl(url);
+
+    return responseJson;
+}
+
+/**
+ * Execute a process.
+ * @param {string} processUrl The process url.
+ * @param {string} processId The process id.
+ * @param {object} data The data.
+ * @returns {object} The response data.
+ */
+async function executeProcess (processUrl, processId, data) {
+    const url = `${processUrl}/processes/${processId}/execution`,
+        body = {
+            inputs: data
+        },
+        responseJson = await fetchUrl(url, "POST", body);
+
+    return responseJson;
+}
+
+/**
+ * Retrieve the list of jobs.
+ * @param {string} processUrl The process url.
+ * @param {boolean} [nextLink=false] If processurl is a nextLink.
+ * @returns {object[]} The job list.
+ */
+async function jobList (processUrl, nextLink = false) {
+    const url = nextLink ? processUrl : `${processUrl}/jobs`,
+        responseJson = await fetchUrl(url),
+        nextLinkObject = responseJson?.links?.find(link => link.rel === "next");
+    let jobs = responseJson.jobs;
+
+    if (typeof nextLinkObject !== "undefined") {
+        jobs = jobs.concat(await jobList(nextLinkObject.href, true));
+    }
+
+    return jobs;
+}
+
+/**
+ * Retrieve the status of a job.
+ * @param {string} processUrl The process url.
+ * @param {string} jobId The job id.
+ * @returns {object} The job status.
+ */
+async function jobStatus (processUrl, jobId) {
+    const url = `${processUrl}/jobs/${jobId}`,
+        responseJson = await fetchUrl(url);
+
+    return responseJson;
+}
+
+/**
+ * Cancel a job execution, remove a finished job.
+ * @param {string} processUrl The process url.
+ * @param {string} jobId The job id.
+ * @returns {object} The canceled job status.
+ */
+async function cancelJob (processUrl, jobId) {
+    const url = `${processUrl}/jobs/${jobId}`,
+        responseJson = await fetchUrl(url, "DELETE");
+
+    return responseJson;
+}
+
+/**
+ * Retrieve the result(s) of a job.
+ * @param {string} processUrl The process url.
+ * @param {string} jobId The job id.
+ * @param {string} [format=json] The result format can be `html` or `json`.
+ * @returns {object} The job dismissed status.
+ */
+async function jobResults (processUrl, jobId, format = "json") {
+    const url = `${processUrl}/jobs/${jobId}/results?f=${format}`,
+        responseJson = await fetchUrl(url);
+
+    return responseJson;
+}
+
+export default {
+    processList,
+    processDescription,
+    executeProcess,
+    jobList,
+    cancelJob,
+    jobStatus,
+    jobResults
+};

package/src/defaults.js

@@ -40,7 +40,7 @@ export default {
             enableTerrainAdjustmentWhenLoading: true
         },
         globe: {
-            depthTestAgainstTerrain: false
+            depthTestAgainstTerrain: true // is necessary for scene.pickedPosition and correct height of the terrain. @see {https://github.com/CesiumGS/cesium/issues/5676}
         },
         highDynamicRange: false,
         pickTranslucentDepth: true,

package/src/index.js

@@ -15,6 +15,7 @@ import * as layerLib from "./layer/lib";
 import {search, setGazetteerUrl} from "./searchAddress";
 import setBackgroundImage from "./lib/setBackgroundImage";
 import ping from "./lib/ping";
+import ogcApiProcesses from "./api/ogcApiProcesses";
 
 export {
     createMapView,
@@ -34,5 +35,6 @@ export {
     ping,
     search,
     crs,
-    webgl
+    webgl,
+    ogcApiProcesses
 };

package/src/layer/wms.js

@@ -164,7 +164,7 @@ export function createLayer (rawLayer, layerParams = {}, options) {
     const source = createLayerSource(rawLayer, options),
         Layer = rawLayer.singleTile ? ImageLayer : TileLayer;
 
-    source.set("olcs.projection", getProjection(OLCS_DEFAULT_OLCS_PROJECTION_CRS));
+    source.set("olcs_projection", getProjection(OLCS_DEFAULT_OLCS_PROJECTION_CRS));
 
     return new Layer(Object.assign({
         source,

package/test/api/ogcApiProcesses.test.js

@@ -0,0 +1,113 @@
+import ogcApiProcesses from "../../src/api/ogcApiProcesses";
+
+describe("ogcApiProcesses.js", () => {
+    const processUrl = "https://example.de",
+        processId = "process-id",
+        jobId = "job-id";
+
+    beforeEach(() => {
+        if (global.fetch) {
+            fetch.mockClear();
+        }
+
+        global.fetch = jest.fn().mockImplementationOnce(() => {
+            return new Promise((resolve) => {
+                resolve({
+                    ok: true,
+                    status: 200,
+                    json: () => {
+                        return {};
+                    }
+                });
+            });
+        });
+    });
+
+    describe("processList", () => {
+        it("should return a process list", async () => {
+            await ogcApiProcesses.processList(processUrl);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/processes`, {method: "GET"});
+        });
+
+        it("should return a process list with next link", async () => {
+            const offsetProcessUrl = `${processUrl}/processes?offset=30`;
+
+            await ogcApiProcesses.processList(offsetProcessUrl, true);
+
+            expect(fetch).toHaveBeenCalledWith(offsetProcessUrl, {method: "GET"});
+        });
+    });
+
+    describe("processDescription", () => {
+        it("should return a process description", async () => {
+            await ogcApiProcesses.processDescription(processUrl, processId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/processes/${processId}`, {method: "GET"});
+        });
+    });
+
+    describe("executeProcess", () => {
+        it("should execute a process", async () => {
+            const data = {
+                attr: "test-attribute"
+            };
+
+            await ogcApiProcesses.executeProcess(processUrl, processId, data);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/processes/${processId}/execution`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: "{\"inputs\":{\"attr\":\"test-attribute\"}}"
+            });
+        });
+    });
+
+    describe("jobList", () => {
+        it("should return a job list", async () => {
+            await ogcApiProcesses.jobList(processUrl);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs`, {method: "GET"});
+        });
+
+        it("should return a job list with next link", async () => {
+            const offsetProcessUrl = `${processUrl}/jobs?offset=20`;
+
+            await ogcApiProcesses.processList(offsetProcessUrl, true);
+
+            expect(fetch).toHaveBeenCalledWith(offsetProcessUrl, {method: "GET"});
+        });
+    });
+
+    describe("jobStatus", () => {
+        it("should return a job status", async () => {
+            await ogcApiProcesses.jobStatus(processUrl, jobId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}`, {method: "GET"});
+        });
+    });
+
+    describe("cancelJob", () => {
+        it("should cancle a job", async () => {
+            await ogcApiProcesses.cancelJob(processUrl, jobId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}`, {method: "DELETE"});
+        });
+    });
+
+    describe("jobResults", () => {
+        it("should return job results in json format", async () => {
+            await ogcApiProcesses.jobResults(processUrl, jobId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}/results?f=json`, {method: "GET"});
+        });
+
+        it("should return job results in html format", async () => {
+            await ogcApiProcesses.jobResults(processUrl, jobId, "html");
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}/results?f=html`, {method: "GET"});
+        });
+    });
+});