Merge pull request #56 from codeblessing/main

sprint 2 completed

pom.xml

@@ -14,7 +14,9 @@
     <groupId>pl.poznan.put</groupId>
     <artifactId>json-tools</artifactId>
 
-    <version>1.2.20211222-2</version>
+
+    <version>1.7.20220125</version>
+
 
 
 	<properties>
@@ -56,6 +58,11 @@
             <artifactId>validation-api</artifactId>
             <version>2.0.1.Final</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.9</version>
+        </dependency>
     </dependencies>
 
 

src/main/java/pl/poznan/put/jsontools/app/JsonToolsApplication.java

@@ -4,7 +4,7 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication(scanBasePackages = {"pl.poznan.put.jsontools"})
-public class JsonToolsApplication {
+public class  JsonToolsApplication {
     public static void main(String[] args) {
         SpringApplication.run(JsonToolsApplication.class, args);
     }

src/main/java/pl/poznan/put/jsontools/logic/JsonTransformCountFieldsValues.java

@@ -0,0 +1,87 @@
+package pl.poznan.put.jsontools.logic;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import pl.poznan.put.jsontools.error.JsonToolsInvalidJsonError;
+
+import java.util.*;
+
+/**
+ * Counts values in JSON file nodes.
+ */
+public class JsonTransformCountFieldsValues extends JsonTransformer {
+    /**
+     * Class-level logger instance.
+     */
+    private static final Logger logger = LoggerFactory.getLogger(JsonTransformCountFieldsValues.class);
+    /**
+     * Object mapper to retrieve JSON structure from string.
+     */
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    /**
+     * @param transform transform to be executed before flatten JSON.
+     */
+    public JsonTransformCountFieldsValues(JsonTransform transform) {
+        super(transform);
+        logger.info("CountFieldsValues transform created.");
+    }
+
+    /**
+     * Counts values in JSON file fields and determines their type.
+     *
+     * @return Transformed JSON.
+     */
+    @Override
+    public String execute() {
+        String json = super.execute();
+        logger.debug("Executing counting nodes' values.");
+        try {
+            JsonNode jsonNode = objectMapper.readTree(json);
+            JsonNode counted = count(jsonNode);
+
+            return counted.toString();
+        } catch (JsonProcessingException e) {
+            logger.error("Invalid JSON: " + json);
+            throw new JsonToolsInvalidJsonError(e.getLocation().toString(), json);
+        }
+    }
+
+    /**
+     * Provides number of values for each JSON file attribute.
+     * Checks whether the value is:
+     * - object,
+     * - array,
+     * - text.
+     *
+     * @param jsonNode JsonNode to be transformed.
+     * @return JSON with counted values per node in form of Jackson's ObjectNode.
+     */
+    private JsonNode count(JsonNode jsonNode) {
+
+        List<Map.Entry<String, JsonNode>> fields = new ArrayList<>();
+        jsonNode.fields().forEachRemaining(fields::add);
+        ObjectNode objectNode = objectMapper.createObjectNode();
+
+        for (var field : fields) {
+            if (field.getValue().isArray()) {
+                String fieldName = field.getKey();
+                int fieldValues = field.getValue().size();
+                objectNode.put(fieldName, fieldValues + " elements in array");
+            } else if (field.getValue().isObject()) {
+                String fieldName = field.getKey();
+                int fieldValues = field.getValue().size();
+                objectNode.put(fieldName, fieldValues + " fields in object");
+            } else if (field.getValue().isEmpty()) {
+                String fieldName = field.getKey();
+                objectNode.put(fieldName, 1 + " value in node");
+            }
+
+        }
+        return objectNode;
+    }
+}

src/main/java/pl/poznan/put/jsontools/logic/JsonTransformDeleteNulls.java

@@ -0,0 +1,49 @@
+package pl.poznan.put.jsontools.logic;
+
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import pl.poznan.put.jsontools.error.JsonToolsInvalidJsonError;
+
+/**
+ * Class enables to get JSON with no empty fields.
+ */
+public class JsonTransformDeleteNulls extends JsonTransformer {
+
+    /**
+     * Class-level logger instance.
+     */
+    private static final Logger _logger = LoggerFactory.getLogger(JsonTransformDeleteNulls.class);
+
+    /**
+     * @param transform transform to be executed before empty values removal.
+     */
+    public JsonTransformDeleteNulls(JsonTransform transform) {
+        super(transform);
+        _logger.debug("DeleteNulls transform created.");
+    }
+
+    /**
+     * Removes attributes with empty values.
+     *
+     * @return Transformed JSON.
+     */
+    @Override
+    public String execute() {
+        String input = super.execute();
+        _logger.debug("Executing deleting null values");
+        try {
+            String json = input.replace("\"\"", "null");
+            JsonObject jsonObject = new Gson().fromJson(json, JsonObject.class);
+            Gson gson = new GsonBuilder().create();
+            return gson.toJson(jsonObject);
+        } catch (Exception e) {
+            throw new JsonToolsInvalidJsonError(e.getMessage());
+        }
+    }
+}
+
+

src/main/java/pl/poznan/put/jsontools/logic/JsonTransformFlatten.java

@@ -0,0 +1,91 @@
+package pl.poznan.put.jsontools.logic;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import pl.poznan.put.jsontools.error.JsonToolsInvalidJsonError;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class enables to get flattened JSON
+ */
+public class JsonTransformFlatten extends JsonTransformer {
+
+    /**
+     * Class-level logger instance.
+     */
+    private static final Logger _logger = LoggerFactory.getLogger(JsonTransformFlatten.class);
+
+
+    /**
+     * @param transform transform to be executed before flatten JSON
+     */
+    public JsonTransformFlatten(JsonTransform transform) {
+        super(transform);
+        _logger.debug("Flatten transform created.");
+    }
+
+    /**
+     * flatten json.
+     *
+     * @return recursively flattened JSON
+     */
+    @Override
+    public String execute() {
+        String json = super.execute();
+        _logger.debug("Executing flatten json");
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            JsonNode jsonNode = mapper.readTree(json);
+            JsonNode flattenJsonNode = mapper.createObjectNode();
+
+            flattenNodes(jsonNode, flattenJsonNode, "");
+
+            return flattenJsonNode.toString();
+        } catch (JsonProcessingException e) {
+            throw new JsonToolsInvalidJsonError(e.getLocation().toString(), json);
+        }
+    }
+
+    private void flattenNodes(JsonNode root, JsonNode flattenJson, String nestedName) {
+        if (root.isObject()) {
+            List<String> jsonAttributes = new ArrayList<>();
+            root.fieldNames().forEachRemaining(jsonAttributes::add);
+
+            for (String attribute : jsonAttributes) {
+                JsonNode fieldValue = root.get(attribute);
+                if (fieldValue.isObject() || fieldValue.isArray()) {
+                    if (nestedName.equals(""))
+                        flattenNodes(fieldValue, flattenJson, nestedName + attribute);
+                    else
+                        flattenNodes(fieldValue, flattenJson, nestedName + "." + attribute);
+                } else {
+                    if (nestedName.equals(""))
+                        ((ObjectNode) flattenJson).set(nestedName + attribute, fieldValue);
+                    else
+                        ((ObjectNode) flattenJson).set(nestedName + "." + attribute, fieldValue);
+
+                }
+            }
+        } else if (root.isArray()) {
+            Integer i = 0;
+            for (JsonNode fieldValue : root) {
+                if (fieldValue.isObject() || fieldValue.isArray()) {
+                    flattenNodes(fieldValue, flattenJson, nestedName + (++i).toString());
+                } else {
+                    ((ObjectNode) flattenJson).set(nestedName + (++i).toString(), fieldValue);
+                }
+            }
+
+        }
+
+    }
+}
+
+
+

src/main/java/pl/poznan/put/jsontools/logic/JsonTransformFormat.java

@@ -3,29 +3,43 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import pl.poznan.put.jsontools.error.JsonToolsInvalidJsonError;
 
 /**
  * Class enables to transform minified JSON file into JSON full form
  */
 public class JsonTransformFormat extends JsonTransformer {
+
+    /**
+     * Class-level logger instance.
+     */
+    private static final Logger _logger = LoggerFactory.getLogger(JsonTransformFormat.class);
+
+    /**
+     * @param transform to be executed before JSON formatting.
+     */
     public JsonTransformFormat(JsonTransform transform) {
         super(transform);
+        _logger.info("Format transform created.");
     }
+
     /**
      * ObjectMapper to apply formatting to the JSON file
      */
     private static final ObjectMapper mapper = new ObjectMapper();
 
     /**
-     *
      * @return String prettified file (with proper formatting, e.g. spaces, tabs, newlines)
      */
     @Override
     public String execute() {
+        _logger.debug("Executing formatting.");
         try {
             return mapper.readTree(super.execute()).toPrettyString();
         } catch (JsonProcessingException e) {
+            _logger.error("Invalid JSON:\n" + super.execute());
             throw new JsonToolsInvalidJsonError(e.getMessage());
         }
     }

src/main/java/pl/poznan/put/jsontools/logic/JsonTransformMinify.java

@@ -3,18 +3,38 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.LoggerFactory;
 import pl.poznan.put.jsontools.error.JsonToolsInvalidJsonError;
+import org.slf4j.Logger;
 
-
+/**
+ * Class enables to get minified JSON.
+ */
 public class JsonTransformMinify extends JsonTransformer {
+
+    private static final Logger _logger = LoggerFactory.getLogger(JsonTransformMinify.class);
+
+    /**
+     * Object mapper to retrieve JSON structure from string.
+     */
     private static final ObjectMapper mapper = new ObjectMapper();
 
+    /**
+     * @param transform transform to be executed before minification.
+     */
     public JsonTransformMinify(JsonTransform transform) {
         super(transform);
+        _logger.debug("Minify transform created.");
     }
 
+    /**
+     * Removes line breaks, whitespaces, tabs from JSON.
+     *
+     * @return Transformed JSON.
+     */
     @Override
     public String execute() {
+        _logger.debug("Executing JSON minification.");
         try {
             return mapper.readTree(super.execute()).toString();
         } catch (JsonProcessingException e) {

src/main/java/pl/poznan/put/jsontools/logic/JsonTransformRemoveAttributes.java

@@ -13,7 +13,7 @@
 
 /**
  * RemoveAttributes decorator.
- *
+ * <p>
  * Removes plain attributes given in constructor from JSON retrieved from `transform`.
  * Does not remove nested attributes.
  */
@@ -44,6 +44,7 @@ public JsonTransformRemoveAttributes(JsonTransform transform, List<String> attri
 
     /**
      * Removes given attributes from JSON.
+     *
      * @return Transformed JSON.
      */
     @Override