🥅 Trying to insert group for singular fields

Author: Pa-Touche

sormas-api/src/main/java/de/symeda/sormas/api/patch/DataPatchFailureCause.java

@@ -75,6 +75,11 @@ public enum DataPatchFailureCause {
 	 */
 	DUPLICATE_FIELD,
 
+	/**
+	 * Means the field does not support being inserted multiple in groups. Most fields are "singulars".
+	 */
+	FORBIDDEN_MULTI_GROUP_FIELD,
+
 	/**
 	 * This means there is a hole in the implementation.
 	 */

sormas-backend/src/main/java/de/symeda/sormas/backend/patch/DataPatcherImpl.java

@@ -99,11 +99,19 @@ public DataPatchResponse patch(CaseDataPatchRequest request) {
 		List<SinglePatchResult> results = patchingTuples.stream().map(singleFieldPatchResult -> {
 			PatchField patchField = singleFieldPatchResult.field;
 			SinglePatchResult singlePatchResult = new SinglePatchResult().setField(patchField);
-
-			Supplier<AttachedEntityWrapper> target = () -> findAppropriateTarget(patchField, caseData, entityCache);
-
 			try {
+				Supplier<AttachedEntityWrapper> target = () -> findAppropriateTarget(patchField, caseData, entityCache);
+
 				return produceSinglePatchResult(request, singleFieldPatchResult, disease, target);
+			} catch (DataPatchingException e) {
+				DataPatchFailureCause failureCause = e.getFailureCause();
+				logger.error(
+					"DataPatching-specific failure during patch operation for request: [{}], [{}], of type [{}]",
+					request,
+					singleFieldPatchResult,
+					failureCause,
+					e);
+				return singlePatchResult.setFailure(new DataPatchFailure().setDataPatchFailureCause(failureCause));
 			} catch (RuntimeException e) {
 				logger.error("Failure during patch operation for request: [{}], [{}]", request, singleFieldPatchResult, e);
 				return singlePatchResult.setFailure(new DataPatchFailure().setDataPatchFailureCause(DataPatchFailureCause.TECHNICAL));
@@ -373,8 +381,18 @@ private AttachedEntityWrapper findAppropriateTarget(
 
 		Optional<AttachedEntityWrapper> fetched = businessDtoFacade.tryFetchByI18nNameForCreateUpdate(prefix, caseData);
 		if (fetched.isPresent()) {
-			entityCache.put(key, fetched.get());
-			return fetched.get();
+			AttachedEntityWrapper appropriateEntityWrapper = fetched.get();
+
+			if (patchField.getGroupIndex() != null && appropriateEntityWrapper.isAttached()) {
+				throw new DataPatchingException(
+					String.format(
+						"The field [%s] is already attached, this means no new entities can be added as group: only a single instance is valid for the Case-'data-Tree'",
+						prefix),
+					DataPatchFailureCause.FORBIDDEN_MULTI_GROUP_FIELD);
+			}
+
+			entityCache.put(key, appropriateEntityWrapper);
+			return appropriateEntityWrapper;
 		}
 
 		logger.error("Fallbacked to entity for resolved path: [{}]. This should not occur as CaseData is already in entityCache", resolvedPath);

sormas-backend/src/main/java/de/symeda/sormas/backend/patch/DataPatchingException.java

@@ -0,0 +1,20 @@
+package de.symeda.sormas.backend.patch;
+
+import de.symeda.sormas.api.patch.DataPatchFailureCause;
+
+/**
+ * In some scenarios, it's simpler to throw a specific exception for exceptional exceptions that should not happen too often.
+ */
+public class DataPatchingException extends RuntimeException {
+
+	private final DataPatchFailureCause failureCause;
+
+	public DataPatchingException(String message, DataPatchFailureCause failureCause) {
+		super(message);
+		this.failureCause = failureCause;
+	}
+
+	public DataPatchFailureCause getFailureCause() {
+		return failureCause;
+	}
+}

sormas-backend/src/test/java/de/symeda/sormas/patch/DataPatcherImplTest.java

@@ -1027,6 +1027,40 @@ void patch_activityAsCase() {
 			() -> Assertions.assertEquals("office work", activities.get(0).getDescription()));
 	}
 
+	@Test
+	void patch_forbiddenMultiGroupField() {
+		// PREPARE
+		CaseDataDto originalCase = creator.createUnclassifiedCase(Disease.PERTUSSIS);
+		PersonDto originalPerson = getPersonFacade().getByUuid(originalCase.getPerson().getUuid());
+		String originalLastName = originalPerson.getLastName();
+
+		String secondPersonLastName = "secondPersonLastName";
+
+		// Use PatchDictionary with groupIndex=1 to simulate inserting a "second person".
+		// Person is a singular entity (always attached), so grouping is forbidden.
+		PatchDictionary patchDictionary = new PatchDictionary();
+		patchDictionary.put(PatchField.of("Person.lastName", 1), secondPersonLastName);
+
+		CaseDataPatchRequest request = new CaseDataPatchRequest().setCaseUuid(originalCase.getUuid())
+			.setReplacementStrategy(DataReplacementStrategy.ALWAYS)
+			.setPatchDictionary(patchDictionary);
+
+		// EXECUTE
+		DataPatchResponse response = victim().patch(request);
+
+		// CHECK
+		PersonDto actualPerson = getPersonFacade().getByUuid(originalCase.getPerson().getUuid());
+
+		PatchField expectedField = PatchField.of("Person.lastName", 1);
+		DataPatchFailure expectedFailure = new DataPatchFailure().setDataPatchFailureCause(DataPatchFailureCause.FORBIDDEN_MULTI_GROUP_FIELD);
+
+		Assertions.assertAll(
+			() -> Assertions.assertTrue(response.getValidPatchDictionary().isEmpty(), "Nothing should have been patched"),
+			() -> Assertions.assertFalse(response.isApplied()),
+			() -> Assertions.assertEquals(Map.of(expectedField, expectedFailure), response.getFailures()),
+			() -> Assertions.assertEquals(originalLastName, actualPerson.getLastName(), "Person lastName must not be altered"));
+	}
+
 	private static String toFieldName(String prefix, String field) {
 		return prefix + '.' + field;
 	}