Merge pull request #153 from tsurdilo/addjsonmerge

adding some json manipulation util methods

Author: tsurdilo

utils/src/main/java/io/serverlessworkflow/utils/WorkflowUtils.java

@@ -15,6 +15,10 @@
  */
 package io.serverlessworkflow.utils;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.serverlessworkflow.api.Workflow;
 import io.serverlessworkflow.api.actions.Action;
 import io.serverlessworkflow.api.branches.Branch;
@@ -157,7 +161,7 @@ public static List<EventDefinition> getWorkflowProducedEvents(Workflow workflow)
    *
    * @return Returns {@code List<EventDefinition>}
    */
-  private static List<EventDefinition> getWorkflowEventDefinitions(
+  public static List<EventDefinition> getWorkflowEventDefinitions(
       Workflow workflow, EventDefinition.Kind eventKind) {
     if (!hasStates(workflow)) {
       return null;
@@ -174,7 +178,7 @@ private static List<EventDefinition> getWorkflowEventDefinitions(
   }
 
   /** Returns a list of unique event names from workflow states */
-  private static List<String> getUniqueWorkflowEventsFromStates(Workflow workflow) {
+  public static List<String> getUniqueWorkflowEventsFromStates(Workflow workflow) {
     List<String> eventReferences = new ArrayList<>();
 
     for (State state : workflow.getStates()) {
@@ -351,7 +355,7 @@ public static long getNumOfEndStates(Workflow workflow) {
     }
   }
 
-  private static List<Action> getActionsWhichUsesFunctionDefinition(
+  public static List<Action> getActionsWhichUsesFunctionDefinition(
       Workflow workflow, String functionDefinitionName) {
     List<Action> actions = new ArrayList<>();
     for (State state : workflow.getStates()) {
@@ -419,23 +423,23 @@ private static List<Action> getActionsWhichUsesFunctionDefinition(
     return actions;
   }
 
-  private static boolean checkIfActionUsesFunctionDefinition(
+  public static boolean checkIfActionUsesFunctionDefinition(
       String functionDefinitionName, Action action) {
     return action != null
         && action.getFunctionRef() != null
         && action.getFunctionRef().getRefName() != null
         && action.getFunctionRef().getRefName().equals(functionDefinitionName);
   }
 
-  private static boolean hasFunctionDefs(Workflow workflow, String functionDefinitionName) {
+  public static boolean hasFunctionDefs(Workflow workflow, String functionDefinitionName) {
     if (!hasFunctionDefs(workflow)) return false;
     List<FunctionDefinition> functionDefs = workflow.getFunctions().getFunctionDefs();
     return functionDefs.stream()
         .anyMatch(
             functionDefinition -> functionDefinition.getName().equals(functionDefinitionName));
   }
 
-  private static FunctionRef getFunctionRefFromAction(Workflow workflow, String action) {
+  public static FunctionRef getFunctionRefFromAction(Workflow workflow, String action) {
     if (!hasStates(workflow)) return null;
 
     for (State state : workflow.getStates()) {
@@ -513,28 +517,28 @@ private static FunctionRef getFunctionRefFromAction(Workflow workflow, String ac
     return null;
   }
 
-  private static boolean hasFunctionDefs(Workflow workflow) {
+  public static boolean hasFunctionDefs(Workflow workflow) {
     return workflow != null
         && workflow.getFunctions() != null
         && workflow.getFunctions().getFunctionDefs() != null
         && !workflow.getFunctions().getFunctionDefs().isEmpty();
   }
 
   /** Returns true if workflow has states, otherwise false */
-  private static boolean hasStates(Workflow workflow) {
+  public static boolean hasStates(Workflow workflow) {
     return workflow != null && workflow.getStates() != null && !workflow.getStates().isEmpty();
   }
 
   /** Returns true if workflow has events definitions, otherwise false */
-  private static boolean hasEventDefs(Workflow workflow) {
+  public static boolean hasEventDefs(Workflow workflow) {
     return workflow != null
         && workflow.getEvents() != null
         && workflow.getEvents().getEventDefs() != null
         && !workflow.getEvents().getEventDefs().isEmpty();
   }
 
   /** Gets event refs of an action */
-  private static List<String> getActionEvents(Action action) {
+  public static List<String> getActionEvents(Action action) {
     List<String> actionEvents = new ArrayList<>();
 
     if (action != null && action.getEventRef() != null) {
@@ -548,4 +552,73 @@ private static List<String> getActionEvents(Action action) {
 
     return actionEvents;
   }
+
+  /**
+   * Merges two JsonNode
+   *
+   * @param mainNode
+   * @param updateNode
+   * @return merged JsonNode
+   */
+  public static JsonNode mergeNodes(JsonNode mainNode, JsonNode updateNode) {
+
+    Iterator<String> fieldNames = updateNode.fieldNames();
+    while (fieldNames.hasNext()) {
+
+      String fieldName = fieldNames.next();
+      JsonNode jsonNode = mainNode.get(fieldName);
+      // if field exists and is an embedded object
+      if (jsonNode != null && jsonNode.isObject()) {
+        mergeNodes(jsonNode, updateNode.get(fieldName));
+      } else {
+        if (mainNode instanceof ObjectNode) {
+          // Overwrite field
+          JsonNode value = updateNode.get(fieldName);
+          ((ObjectNode) mainNode).put(fieldName, value);
+        }
+      }
+    }
+
+    return mainNode;
+  }
+
+  /**
+   * Adds node as field
+   *
+   * @param mainNode
+   * @param toAddNode
+   * @param fieldName
+   * @return original, main node with field added
+   */
+  public static JsonNode addNode(JsonNode mainNode, JsonNode toAddNode, String fieldName) {
+    ((ObjectNode) mainNode).put(fieldName, toAddNode);
+    return mainNode;
+  }
+
+  /**
+   * Adds array with name
+   *
+   * @param mainNode
+   * @param toAddArray
+   * @param arrayName
+   * @return original, main node with array added
+   */
+  public static JsonNode addArray(JsonNode mainNode, ArrayNode toAddArray, String arrayName) {
+    ((ObjectNode) mainNode).put(arrayName, toAddArray);
+    return mainNode;
+  }
+
+  /**
+   * Adds a object field
+   *
+   * @param mainNode
+   * @param toAddValue
+   * @param fieldName
+   * @return original, main node with field added
+   */
+  public static JsonNode addFieldValue(JsonNode mainNode, Object toAddValue, String fieldName) {
+    ObjectMapper mapper = new ObjectMapper();
+    ((ObjectNode) mainNode).put(fieldName, mapper.valueToTree(toAddValue));
+    return mainNode;
+  }
 }

utils/src/test/java/io/serverlessworkflow/util/JsonManipulationTest.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.util;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import io.serverlessworkflow.utils.WorkflowUtils;
+import org.junit.jupiter.api.Test;
+
+public class JsonManipulationTest {
+  private static final ObjectMapper mapper = new ObjectMapper();
+
+  @Test
+  public void testAddFieldValue() throws Exception {
+    String mainString = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
+    JsonNode mainNode = mapper.readTree(mainString);
+    String toAddString = "v3";
+
+    JsonNode added = WorkflowUtils.addFieldValue(mainNode, toAddString, "k3");
+
+    assertNotNull(added);
+    assertEquals("v3", added.get("k3").asText());
+  }
+
+  @Test
+  public void testAddNode() throws Exception {
+    String mainString = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
+    JsonNode mainNode = mapper.readTree(mainString);
+    String toAddString = "{\"k3\":\"v3\"}";
+    JsonNode toAddNode = mapper.readTree(toAddString);
+
+    JsonNode added = WorkflowUtils.addNode(mainNode, toAddNode, "newnode");
+
+    assertNotNull(added);
+    assertEquals("v3", added.get("newnode").get("k3").asText());
+  }
+
+  @Test
+  public void testAddArray() throws Exception {
+    String mainString = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
+    JsonNode mainNode = mapper.readTree(mainString);
+    String toAddString = "[\"a\", \"b\"]";
+    JsonNode toAddNode = mapper.readTree(toAddString);
+
+    JsonNode added = WorkflowUtils.addArray(mainNode, (ArrayNode) toAddNode, "newarray");
+
+    assertNotNull(added);
+    assertNotNull(added.get("newarray"));
+    assertEquals(2, added.get("newarray").size());
+    assertEquals("a", added.get("newarray").get(0).asText());
+    assertEquals("b", added.get("newarray").get(1).asText());
+  }
+
+  @Test
+  public void testMergeNodes() throws Exception {
+    String mainString = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
+    JsonNode mainNode = mapper.readTree(mainString);
+    String toMergeString = "{\"k3\":\"v3\",\"k4\":\"v4\"}";
+    JsonNode toMergeNode = mapper.readTree(toMergeString);
+
+    JsonNode merged = WorkflowUtils.mergeNodes(mainNode, toMergeNode);
+
+    assertNotNull(merged);
+    assertEquals("v3", merged.get("k3").asText());
+    assertEquals("v4", merged.get("k4").asText());
+  }
+
+  @Test
+  public void testMergeWithOverwrite() throws Exception {
+    String mainString = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
+    JsonNode mainNode = mapper.readTree(mainString);
+    String toMergeString = "{\"k2\":\"v2new\",\"k3\":\"v3\"}";
+    JsonNode toMergeNode = mapper.readTree(toMergeString);
+
+    JsonNode merged = WorkflowUtils.mergeNodes(mainNode, toMergeNode);
+
+    assertNotNull(merged);
+    assertEquals("v2new", merged.get("k2").asText());
+    assertEquals("v3", merged.get("k3").asText());
+  }
+}