Add option to set WFS flag & fylr tag for newly drawn geometries (for marking them as temporary)

tkleinke · tkleinke · commit 18ccdd209c55 · 2025-10-28T16:48:26.000+01:00
diff --git a/l10n/custom-data-type-nfis-geometry.csv b/l10n/custom-data-type-nfis-geometry.csv
@@ -37,6 +37,9 @@ server.config.parameter.system.nfisGeoservices.geoserver_write_password.label,Ge
 server.config.parameter.system.nfisGeoservices.wfs_geometry_id_field_name.label,Name des Geometrie-ID-Feldes im WFS,Name of the geometry ID field in the WFS
 server.config.parameter.system.nfisGeoservices.show_upload_button.label,Hochladen von Geometrien im Masterportal,Upload geometries in Masterportal
 server.config.parameter.system.nfisGeoservices.show_upload_button.checkbox,Button anzeigen,Show button
+server.config.parameter.system.nfisGeoservices.show_upload_button.label,Hochladen von Geometrien im Masterportal,Upload geometries in Masterportal
+server.config.parameter.system.nfisGeoservices.wfs_temporary_geometry_field_name.label,Name des Feldes zur Kennzeichnung provisorischer Geometrien im WFS,Name of field for marking geometries as temporary in WFS
+server.config.parameter.system.nfisGeoservices.temporary_geometry_tag_id.label,ID des Tags zur Kennzeichnung von Objekten mit provisorischen Geometrien,ID of tag for marking objects with temporary geometries
 server.config.parameter.system.nfisGeoservices.wfs_configuration.label,Objekttypen,Object types
 server.config.parameter.system.nfisGeoservices.wfs_configuration.object_type.label,Name des Objekttyps,Object type name
 server.config.parameter.system.nfisGeoservices.wfs_configuration.geometry_fields.label,Geometrie-Felder,Geometry fields
diff --git a/manifest.master.yml b/manifest.master.yml
@@ -59,6 +59,12 @@ base_config:
       show_upload_button:
         type: bool
         position: 7
+      wfs_temporary_geometry_field_name:
+        type: text
+        position: 8
+      temporary_geometry_tag_id:
+        type: int
+        position: 9
       wfs_configuration:
         type: table
         fields:
@@ -142,7 +148,7 @@ base_config:
                     position: 0
                 position: 14
             position: 1
-        position: 8
+        position: 10
       linked_objects:
         type: table
         fields:
@@ -152,7 +158,7 @@ base_config:
           - name: link_field_name
             type: text
             position: 1
-        position: 9
+        position: 11
       masterportal_configurations:
         type: table
         fields:
@@ -165,7 +171,7 @@ base_config:
           - name: file_name
             type: text
             position: 2
-        position: 10
+        position: 12
 
 callbacks:
   db_pre_save:
diff --git a/src/server/sendDataToGeoserver.js b/src/server/sendDataToGeoserver.js
@@ -16,22 +16,26 @@ process.stdin.on('data', d => {
 
 process.stdin.on('end', async () => {
     const data = JSON.parse(input);
+    const changedObjects = [];
 
     for (let object of data.objects) {
         await updateObject(
             getObjectData(object),
             object._current ? getObjectData(object._current) : undefined
         );
+        if (await handleNewlyDrawnGeometries(object)) changedObjects.push(object);
     }
 
-    console.log(JSON.stringify({ objects: [] }));
-    console.error('No changes');
-    process.exit(0);
-    return;
+    console.log(JSON.stringify({ objects: changedObjects }));
+
+    if (!changedObjects.length) {
+        console.error('No changes');
+        process.exit(0);
+    }
 });
 
 function getObjectData(object) {
-    const objectData = object[object._objecttype];
+    const objectData = JSON.parse(JSON.stringify(object[object._objecttype]));
     objectData._uuid = object._uuid;
     objectData._objecttype = object._objecttype;
     return objectData;
@@ -46,16 +50,8 @@ function getWFSConfiguration(configuration, objectType) {
     return wfsConfiguration?.find(configuration => configuration.object_type === objectType);
 }
 
-function getAuthorizationString(configuration) {
-    const username = configuration.geoserver_write_username;
-    const password = configuration.geoserver_write_password;
-
-    return btoa(username + ':' + password);
-}
-
 async function updateObject(object, currentObject) {
     const configuration = getPluginConfiguration();
-    const authorizationString = getAuthorizationString(configuration);
 
     if (currentObject) addDataFromCurrentObject(object, currentObject);
     addToObjectCache(object);
@@ -72,8 +68,8 @@ async function updateObject(object, currentObject) {
             return throwErrorToFrontend('Eine oder mehrere Geometrien sind bereits mit anderen Objekten verknüpft.', undefined, 'multipleGeometryLinking');
         }
 
-        await editGeometries(object, fieldConfiguration, geometryIds, authorizationString);
-        if (currentObject) await deleteGeometries(fieldConfiguration, geometryIds, currentObject, authorizationString);
+        await editGeometries(object, fieldConfiguration, geometryIds);
+        if (currentObject) await deleteGeometries(fieldConfiguration, geometryIds, currentObject);
     }
 }
 
@@ -145,19 +141,20 @@ function getGeometryFieldPaths(configuration) {
     return fieldPaths;
 }
 
-async function editGeometries(object, fieldConfiguration, geometryIds, authorizationString) {
+async function editGeometries(object, fieldConfiguration, geometryIds) {
     if (isSendingDataToGeoserverActivated(fieldConfiguration, geometryIds)) {
         const changeMap = await getChangeMap(object, fieldConfiguration);
         if (Object.keys(changeMap).length) {
-            await performEditTransaction(geometryIds, changeMap, fieldConfiguration, authorizationString);
+            const requestXml = getEditRequestXml(geometryIds, changeMap, fieldConfiguration.edit_wfs_feature_type);
+            await performEditTransaction(geometryIds, requestXml, fieldConfiguration);
         }
     }
 }
 
-async function deleteGeometries(fieldConfiguration, geometryIds, currentObject, authorizationString) {
+async function deleteGeometries(fieldConfiguration, geometryIds, currentObject) {
     if (!currentObject) return;
     const deletedGeometryIds = await getDeletedGeometryIds(geometryIds, currentObject, fieldConfiguration);
-    if (deletedGeometryIds.length) await performDeleteTransaction(deletedGeometryIds, fieldConfiguration, authorizationString);
+    if (deletedGeometryIds.length) await performDeleteTransaction(deletedGeometryIds, fieldConfiguration);
 }
 
 async function getDeletedGeometryIds(geometryIds, currentObject, fieldConfiguration) {
@@ -332,39 +329,34 @@ function isDanteConcept(fieldValue) {
         && fieldValue.conceptURI !== undefined && typeof fieldValue.conceptURI === 'string';
 }
 
-async function performEditTransaction(geometryIds, changeMap, fieldConfiguration, authorizationString) {
-    const result = await performTransaction(
-        getEditRequestXml(geometryIds, changeMap, fieldConfiguration.edit_wfs_feature_type),
-        fieldConfiguration.edit_wfs_url,
-        authorizationString
-    );
+async function performEditTransaction(geometryIds, requestXml, fieldConfiguration) {
+    const result = await performTransaction(requestXml, fieldConfiguration.edit_wfs_url);
 
     if (!new RegExp('<wfs:totalUpdated>' + geometryIds.length + '<\/wfs:totalUpdated>').test(result)) {
         throwErrorToFrontend('Bei der Aktualisierung von Geometrie-Datensätzen ist ein Fehler aufgetreten:', result);
     }
 }
 
-async function performDeleteTransaction(geometryIds, fieldConfiguration, authorizationString) {
+async function performDeleteTransaction(geometryIds, fieldConfiguration) {
     const result = await performTransaction(
         getDeleteRequestXml(geometryIds, fieldConfiguration.edit_wfs_feature_type),
-        fieldConfiguration.edit_wfs_url,
-        authorizationString
+        fieldConfiguration.edit_wfs_url
     );
 
     if (!new RegExp('<wfs:totalDeleted>' + geometryIds.length + '<\/wfs:totalDeleted>').test(result)) {
         throwErrorToFrontend('Beim Löschen von Geometrie-Datensätzen ist ein Fehler aufgetreten:', result);
     }
 }
 
-async function performTransaction(requestXml, wfsUrl, authorizationString) {
-    const transactionUrl = wfsUrl + '?service=WFS&version=1.1.0&request=Transaction';
+async function performTransaction(requestXml, wfsUrl) {
+    const transactionUrl = wfsUrl + '?service=WFS&version=1.1.0&request=Transaction';;
 
     try {
         const response = await fetch(transactionUrl, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/xml',
-                'Authorization': 'Basic ' + authorizationString
+                'Authorization': 'Basic ' + getAuthorizationString(getPluginConfiguration())
             },
             body: requestXml
         });
@@ -383,6 +375,18 @@ function getEditRequestXml(geometryIds, changeMap, featureType) {
     );
 }
 
+function getMarkAsTemporaryRequestXml(geometryIds, propertyName, featureType) {
+    return getTransactionXml(
+        '<wfs:Update typeName="' + featureType + '">'
+        + '<wfs:Property>'
+        + '<wfs:Name>' + propertyName + '</wfs:Name>'
+        + '<wfs:Value>true</wfs:Value>'
+        + '</wfs:Property>'
+        + getFilterXml(geometryIds)
+        + '</wfs:Update>'
+    );
+}
+
 function getDeleteRequestXml(geometryIds, featureType) {
     return getTransactionXml(
         '<wfs:Delete typeName="' + featureType + '">'
@@ -431,6 +435,44 @@ function getGeometryFilterXml(geometryId) {
         + '</ogc:PropertyIsEqualTo>';
 }
 
+async function handleNewlyDrawnGeometries(object) {
+    const configuration = getPluginConfiguration();
+    const wfsConfiguration = getWFSConfiguration(configuration, object._objecttype);
+    if (!wfsConfiguration) return false;
+
+    const wfsTemporaryGeometryFieldName = configuration.wfs_temporary_geometry_field_name;
+    const temporaryGeometryTagId = configuration.temporary_geometry_tag_id;
+
+    let changed = false;
+    for (let fieldConfiguration of wfsConfiguration.geometry_fields) {
+        for (let fieldValue of await getFieldValues(object[object._objecttype], fieldConfiguration.field_path.split('.'))) {
+            const newlyDrawnGeometryIds = fieldValue.newly_drawn_geometry_ids;
+            delete fieldValue.newly_drawn_geometry_ids;
+            changed = true;
+            if (!newlyDrawnGeometryIds?.length) continue;
+
+            if (wfsTemporaryGeometryFieldName) {
+                await markGeometriesAsTemporary(newlyDrawnGeometryIds, fieldConfiguration, wfsTemporaryGeometryFieldName);
+            }
+            if (temporaryGeometryTagId) object._tags = [{ _id: temporaryGeometryTagId }];
+        }
+    }
+
+    return changed;
+}
+
+async function markGeometriesAsTemporary(geometryIds, fieldConfiguration, wfsTemporaryGeometryFieldName) {
+    const requestXml = getMarkAsTemporaryRequestXml(geometryIds, wfsTemporaryGeometryFieldName, fieldConfiguration.edit_wfs_feature_type);
+    await performEditTransaction(geometryIds, requestXml, fieldConfiguration);
+}
+
+function getAuthorizationString(configuration) {
+    const username = configuration.geoserver_write_username;
+    const password = configuration.geoserver_write_password;
+
+    return btoa(username + ':' + password);
+}
+
 function throwErrorToFrontend(error, description, realm) {
     console.log(JSON.stringify({
         error: {
diff --git a/src/webfrontend/js/customDataType/contentLoader.js b/src/webfrontend/js/customDataType/contentLoader.js
@@ -195,7 +195,7 @@ function createGeometry(contentElement, cdata, settings, wfsData, extent, upload
     const newGeometryId = window.crypto.randomUUID();
     navigator.clipboard.writeText(newGeometryId);
     window.open(getEditGeometryUrl(settings, wfsData, extent, upload), '_blank');
-    openCreateGeometryModal(contentElement, cdata, settings, newGeometryId);
+    openCreateGeometryModal(contentElement, cdata, settings, newGeometryId, !upload);
 }
 
 function openEditGeometryModal(contentElement, cdata, settings) {
@@ -216,7 +216,7 @@ function openEditGeometryModal(contentElement, cdata, settings) {
     return modalDialog.show();
 }
 
-function openCreateGeometryModal(contentElement, cdata, settings, newGeometryId, error) {
+function openCreateGeometryModal(contentElement, cdata, settings, newGeometryId, drawn, error) {
     let text = '';
     if (error) text += $$('custom.data.type.nfis.geometry.create.modal.error.notFound') + '\n\n';
     text += $$('custom.data.type.nfis.geometry.create.modal.text.1') + '\n\n'
@@ -234,12 +234,12 @@ function openCreateGeometryModal(contentElement, cdata, settings, newGeometryId,
             text: $$('custom.data.type.nfis.geometry.modal.ok'),
             primary: true,
             onClick: () => {
-                setGeometryId(contentElement, cdata, settings, newGeometryId).then(
+                setGeometryId(contentElement, cdata, settings, newGeometryId, drawn).then(
                     () => {},
                     error => {
                         if (error) console.error(error);
                         openCreateGeometryModal(
-                            contentElement, cdata, settings, newGeometryId, true
+                            contentElement, cdata, settings, newGeometryId, drawn, true
                         );
                     }
                 );
@@ -270,12 +270,15 @@ function openSetGeometryModal(contentElement, cdata, settings, title, error) {
     });
 }
 
-function setGeometryId(contentElement, cdata, settings, newGeometryId) {
+function setGeometryId(contentElement, cdata, settings, newGeometryId, drawn = false) {
     return new Promise((resolve, reject) => {
         loadWFSData(settings, [newGeometryId]).then((wfsData) => {
             if (wfsData.totalFeatures > 0) {
                 if (!cdata.geometry_ids.includes(newGeometryId)) {
                     cdata.geometry_ids = cdata.geometry_ids.concat([newGeometryId]);
+                    if (drawn && !cdata.newly_drawn_geometry_ids.includes(newGeometryId)) {
+                        cdata.newly_drawn_geometry_ids = cdata.newly_drawn_geometry_ids.concat([newGeometryId]);
+                    }
                 }
                 applyChanges(
                     contentElement, cdata, settings, wfsData,
@@ -333,7 +336,6 @@ function renderMap(contentElement, cdata, settings, wfsData, allowSelection, onL
     CUI.dom.append(mapElement, createLegendButton(mapElement, settings.fieldConfiguration));
 
     initializeMap(contentElement, mapElement, cdata, settings, wfsData, allowSelection, onLoad);
-    
 }
 
 function createLegendButton(mapElement, fieldConfiguration) {
diff --git a/src/webfrontend/js/customDataType/main.js b/src/webfrontend/js/customDataType/main.js
@@ -50,6 +50,7 @@ CustomDataTypeNFISGeometry = (function(superClass) {
         }
 
         if (!cdata.geometry_ids) cdata.geometry_ids = [];
+        cdata.newly_drawn_geometry_ids = [];
 
         return cdata;
     }
@@ -94,7 +95,8 @@ CustomDataTypeNFISGeometry = (function(superClass) {
         const cdata = data[this.name()];
         if (this.__isValidData(cdata)) {
             save_data[this.name()] = {
-                geometry_ids: cdata.geometry_ids
+                geometry_ids: cdata.geometry_ids,
+                newly_drawn_geometry_ids: cdata.newly_drawn_geometry_ids
             };
         } else {
             save_data[this.name()] = null;
