WIP for #594

Author: oharsta

server/src/main/java/access/api/ConnectionController.java

@@ -6,6 +6,7 @@
 import access.jira.JiraIssue;
 import access.manage.ChangeRequest;
 import access.manage.ConnectionProviderConverter;
+import access.manage.ListMerger;
 import access.manage.Manage;
 import access.manage.PathUpdateType;
 import access.manage.RequestType;
@@ -19,6 +20,7 @@
 import access.repository.ApplicationRepository;
 import access.repository.ConnectionRepository;
 import access.repository.UserRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import lombok.SneakyThrows;
 import org.apache.commons.logging.Log;
@@ -44,9 +46,11 @@
 
 import java.time.Instant;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 import static access.SwaggerOpenIdConfig.API_TOKENS_SCHEME_NAME;
 import static access.SwaggerOpenIdConfig.OPEN_ID_SCHEME_NAME;
@@ -72,19 +76,22 @@ public class ConnectionController implements UserAccessRights {
     private final PasswordGenerator passwordGenerator = new PasswordGenerator();
     private final List<CharacterRule> rules = initPasswordGeneratorRules();
     private final ConnectionProviderConverter connectionProviderConverter;
+    private final ObjectMapper objectMapper;
 
     public ConnectionController(ConnectionRepository connectionRepository,
                                 ApplicationRepository applicationRepository,
                                 UserRepository userRepository,
                                 Manage manage,
                                 JiraClient jiraClient,
-                                ConnectionProviderConverter connectionProviderConverter) {
+                                ConnectionProviderConverter connectionProviderConverter,
+                                ObjectMapper objectMapper) {
         this.connectionRepository = connectionRepository;
         this.applicationRepository = applicationRepository;
         this.userRepository = userRepository;
         this.manage = manage;
         this.jiraClient = jiraClient;
         this.connectionProviderConverter = connectionProviderConverter;
+        this.objectMapper = objectMapper;
     }
 
     private List<CharacterRule> initPasswordGeneratorRules() {
@@ -322,11 +329,42 @@ private Connection productionReadyChangeRequests(Connection connection, User use
                 //Now we need to ensure that previous change requests, with the same pathUpdate and value a List, does not overwrite changes
                 //And therefore we don't create a new change request, but update the existing one
                 Map<String, Object> existingChangeRequest = existingChangeRequests.getFirst();
-                ChangeRequest changeRequest = changeRequestOptional.get();
-                existingChangeRequest.get("pathUpdates");
-                //TODO , add / override all new pathUpdates, except if the value is a List, then sort out the difference
-
-
+                ChangeRequest newChangeRequest = changeRequestOptional.get();
+                Map<String, Object> existingPathUpdates = (Map<String, Object>) existingChangeRequest.get("pathUpdates");
+                Map<String, Object> newPathUpdates = newChangeRequest.getPathUpdates();
+                newPathUpdates.forEach((key, value) -> {
+                    if (key.equals("arp") && existingPathUpdates.containsKey(key)) {
+                        //three way merge on the attributes and profile, motivation from the latest change
+                        Map<String, Object> attributes   = (Map<String, Object>) ((Map<String, Object>)value).get("attributes");
+                        List<String> attibuteNames = attributes.keySet().stream().toList();
+
+                        Map<String, Object> arpPath = (Map<String, Object>) existingPathUpdates.get("arp");
+                        Map<String, Object> pathAttributes   = (Map<String, Object>) arpPath.get("attributes");
+                        List<String> pathValues = pathAttributes.keySet().stream().toList();
+
+                        Map<String, Object> baseArp= (Map<String, Object>) getData(provider).get("arp");
+                        Map<String, Object> baseAttributes   = (Map<String, Object>) baseArp.get("attributes");
+                        List<String> baseValues = baseAttributes.keySet().stream().toList();
+
+                        List<String> newValues = ListMerger.threeWayMerge(baseValues, pathValues, attibuteNames);
+                        //Now we need to construct a new attributes Map with all the values from the three attributes Map
+                        Map<String, Object> newAttributes = newValues.stream().collect(Collectors.toMap(
+                                attrName -> attrName,
+                                attrName -> attributes.getOrDefault(attrName, pathAttributes.getOrDefault(attrName, baseAttributes.get(attrName)))));
+                        arpPath.put("attributes", newAttributes);
+                    } else if  (value instanceof List && existingPathUpdates.containsKey(key)) {
+                        //three way merge
+                        List<String> pathUpdateValue = (List<String>) existingPathUpdates.get(key);
+                        List<String> base = (List<String>) getMetaDataFields(getData(provider)).get(key.substring(key.indexOf(".") + 1));
+                        List<String> newValues = ListMerger.threeWayMerge(base, pathUpdateValue, (List<String>) value);
+                        existingPathUpdates.put(key, newValues);
+                    } else {
+                        //simply override
+                        existingPathUpdates.put(key, value);
+                    }
+                });
+                ChangeRequest changeRequest = objectMapper.convertValue(existingChangeRequest, ChangeRequest.class);
+                manage.updateChangeRequest(Environment.PROD, changeRequest);
             }
         }
 

server/src/main/java/access/api/DefaultErrorController.java

@@ -32,9 +32,9 @@ public class DefaultErrorController implements ErrorController {
 
     private static final Log LOG = LogFactory.getLog(DefaultErrorController.class);
 
-    private static final List<Class> suppressStackTraceClasses = List.of(
-            UserRestrictionException.class,
-            NotFoundException.class);
+    private static final List<Class<?>> suppressStackTraceClasses = List.of(
+            NotFoundException.class
+    );
 
     private final ErrorAttributes errorAttributes;
 

server/src/main/java/access/exception/UserRestrictionException.java

@@ -4,7 +4,7 @@
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.web.bind.annotation.ResponseStatus;
 
-    @ResponseStatus(HttpStatus.FORBIDDEN)
+@ResponseStatus(HttpStatus.FORBIDDEN)
 public class UserRestrictionException extends AuthenticationException {
 
     public UserRestrictionException(String msg) {

server/src/main/java/access/manage/ChangeRequest.java

@@ -9,6 +9,7 @@
 
 
 import java.io.Serializable;
+import java.time.Instant;
 import java.util.Map;
 import java.util.Objects;
 
@@ -37,6 +38,8 @@ public class ChangeRequest implements Serializable {
 
     private RequestType requestType;
 
+    private Instant created;
+
     @Setter
     private String ticketKey;
 

server/src/main/java/access/manage/ListMerger.java

@@ -0,0 +1,86 @@
+package access.manage;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class ListMerger {
+
+    private ListMerger() {
+    }
+
+    public static List<String> threeWayMerge(
+            List<String> base,   // list1: original
+            List<String> left,   // list2: your changes
+            List<String> right   // list3: their changes
+    ) {
+        // Compute diffs against the base
+        Map<Integer, String> leftChanges = diff(base, left);
+        Map<Integer, String> rightChanges = diff(base, right);
+
+        // Start from the longer of left/right to preserve additions
+        int maxSize = Math.max(left.size(), right.size());
+        List<String> result = new ArrayList<>();
+
+        for (int i = 0; i < maxSize; i++) {
+            boolean leftChanged = leftChanges.containsKey(i);
+            boolean rightChanged = rightChanges.containsKey(i);
+
+            if (leftChanged && rightChanged) {
+                String leftVal = leftChanges.get(i);
+                String rightVal = rightChanges.get(i);
+
+                if (Objects.equals(leftVal, rightVal)) {
+                    // Both made the same change — no real conflict
+                    if (leftVal != null) result.add(leftVal);
+                } else if (i >= base.size()) {
+                    // ✅ CHANGED: both added different items past the end of base — keep both
+                    if (leftVal != null) result.add(leftVal);
+                    if (rightVal != null) result.add(rightVal);
+                } else {
+                    // True conflict on an existing line: prefer left
+                    if (leftVal != null) {
+                        result.add(leftVal);
+                    }
+                }
+            } else if (leftChanged) {
+                // Only left modified this index
+                String val = leftChanges.get(i);
+                if (val != null) result.add(val);   // null = deleted
+
+            } else if (rightChanged) {
+                // Only right modified this index
+                String val = rightChanges.get(i);
+                if (val != null) result.add(val);   // null = deleted
+
+            } else {
+                // Neither side touched this index — take from base
+                if (i < base.size()) result.add(base.get(i));
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Produces a map of { index → newValue } representing what changed.
+     * A null value means "deleted at this index".
+     * Indices beyond base.size() are pure additions.
+     */
+    private static Map<Integer, String> diff(List<String> base, List<String> updated) {
+        Map<Integer, String> changes = new HashMap<>();
+        int maxLen = Math.max(base.size(), updated.size());
+
+        for (int i = 0; i < maxLen; i++) {
+            String baseVal = i < base.size() ? base.get(i) : null;
+            String updatedVal = i < updated.size() ? updated.get(i) : null;
+
+            if (!Objects.equals(baseVal, updatedVal)) {
+                changes.put(i, updatedVal); // null = deletion
+            }
+        }
+        return changes;
+    }
+}

server/src/test/java/access/manage/ListMergerTest.java

@@ -0,0 +1,38 @@
+package access.manage;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ListMergerTest {
+
+
+    @Test
+    void threeWayMerge() {
+        List<String> list1 = List.of("alpha", "beta", "gamma", "delta");
+
+        // list2: changed "beta"→"BETA", removed "delta", added "epsilon"
+        List<String> list2 = List.of("alpha", "BETA", "gamma", "epsilon");
+
+        // list3: changed "alpha"→"ALPHA", changed "gamma"→"GAMMA"
+        List<String> list3 = List.of("ALPHA", "beta", "GAMMA", "delta");
+
+        List<String> list4 = ListMerger.threeWayMerge(list1, list2, list3);
+        assertEquals(list4, List.of("ALPHA", "BETA", "GAMMA", "epsilon"));
+
+        list1 = List.of("red1", "red2");
+
+        // list2: changed "beta"→"BETA", removed "delta", added "epsilon"
+        list2 = List.of("red1", "red2", "red3");
+
+        // list3: changed "alpha"→"ALPHA", changed "gamma"→"GAMMA"
+        list3 = List.of("red1", "red2", "red4");
+
+        list4 = ListMerger.threeWayMerge(list1, list2, list3);
+        assertEquals(list4, List.of("red1", "red2", "red3", "red4"));
+    }
+
+
+}