AbstractUtils.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.json;

  23. import java.io.InputStream;
  24. import java.io.OutputStream;
  25. import java.io.Reader;
  26. import java.io.Serializable;
  27. import java.text.DateFormat;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Map;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.utils.SortedMap;
  36. import org.openspcoop2.utils.UtilsException;
  37. import org.slf4j.Logger;

  39. import com.fasterxml.jackson.databind.JsonNode;
  40. import com.fasterxml.jackson.databind.ObjectMapper;
  41. import com.fasterxml.jackson.databind.ObjectWriter;
  42. import com.fasterxml.jackson.databind.node.ArrayNode;
  43. import com.fasterxml.jackson.databind.node.ObjectNode;
  44. import com.fasterxml.jackson.databind.node.ValueNode;

  46. /** 
  47.  * AbstractUtils
  48.  *
  49.  * @author Poli Andrea (apoli@link.it)
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52.  */
  53. public abstract class AbstractUtils {
  54.     
  55.     protected abstract void _initMapper();
  56.     protected abstract void _initWriter(boolean prettyPrint);
  57.     
  58.     protected abstract ObjectMapper _getObjectMapper();
  59.     protected abstract ObjectWriter _getObjectWriter(boolean prettyPrint);
  60.     
  61.     private boolean prettyPrint;
  62.     protected AbstractUtils(boolean prettyPrint) {
  63.         _initMapper();
  64.         this.prettyPrint = prettyPrint;
  65.         _initWriter(this.prettyPrint);
  66.     }
  67.     
  68.     // GET AS
  69.     
  70.     public JsonNode getAsNode(String jsonString) throws UtilsException {
  71.         try {
  72.             return _getObjectMapper().readTree(jsonString);
  73.         }catch(Exception e) {
  74.             throw new UtilsException(e.getMessage(),e);
  75.         }
  76.     }
  77.     public JsonNode getAsNode(byte[] jsonBytes) throws UtilsException {
  78.         try {
  79.             return _getObjectMapper().readTree(jsonBytes);
  80.         }catch(Exception e) {
  81.             throw new UtilsException(e.getMessage(),e);
  82.         }
  83.     }
  84.     public JsonNode getAsNode(InputStream jsonStream) throws UtilsException {
  85.         try {
  86.             return _getObjectMapper().readTree(jsonStream);
  87.         }catch(Exception e) {
  88.             throw new UtilsException(e.getMessage(),e);
  89.         }
  90.     }
  91.     public JsonNode getAsNode(Reader jsonReader) throws UtilsException {
  92.         try {
  93.             return _getObjectMapper().readTree(jsonReader);
  94.         }catch(Exception e) {
  95.             throw new UtilsException(e.getMessage(),e);
  96.         }
  97.     }
  98.     public JsonNode getAsNode(Map<?,?> map) throws UtilsException {
  99.         try {
  100.             return _getObjectMapper().valueToTree(map);
  101.         }catch(Exception e) {
  102.             throw new UtilsException(e.getMessage(),e);
  103.         }
  104.     }
  105.     
  106.     // GET AS OBJECT
  107.     
  108.     public <T> T getAsObject(String jsonString, Class<T> c) throws UtilsException {
  109.         try {
  110.             return _getObjectMapper().readValue(jsonString, c);
  111.         }catch(Exception e) {
  112.             throw new UtilsException(e.getMessage(),e);
  113.         }
  114.     }
  115.     public <T> T getAsObject(byte[] jsonBytes, Class<T> c) throws UtilsException {
  116.         try {
  117.             return _getObjectMapper().readValue(jsonBytes, c);
  118.         }catch(Exception e) {
  119.             throw new UtilsException(e.getMessage(),e);
  120.         }
  121.     }
  122.     public <T> T getAsObject(InputStream jsonStream, Class<T> c) throws UtilsException {
  123.         try {
  124.             return _getObjectMapper().readValue(jsonStream, c);
  125.         }catch(Exception e) {
  126.             throw new UtilsException(e.getMessage(),e);
  127.         }
  128.     }
  129.     public <T> T getAsObject(Reader jsonReader, Class<T> c) throws UtilsException {
  130.         try {
  131.             return _getObjectMapper().readValue(jsonReader, c);
  132.         }catch(Exception e) {
  133.             throw new UtilsException(e.getMessage(),e);
  134.         }
  135.     }

  137.     // NEW DOCUMENT

  139.     public ObjectNode newObjectNode() throws UtilsException {
  140.         try {
  141.             return _getObjectMapper().createObjectNode();
  142.         }catch(Exception e) {
  143.             throw new UtilsException(e.getMessage(),e);
  144.         }
  145.     }
  146.     
  147.     public ArrayNode newArrayNode() throws UtilsException {
  148.         try {
  149.             return _getObjectMapper().createArrayNode();
  150.         }catch(Exception e) {
  151.             throw new UtilsException(e.getMessage(),e);
  152.         }
  153.     }
  154.     
  155.     public DateFormat getDateFormat() throws UtilsException {
  156.         try {
  157.             return _getObjectMapper().getDateFormat();
  158.         }catch(Exception e) {
  159.             throw new UtilsException(e.getMessage(),e);
  160.         }
  161.     }


  164.     // TO BYTE ARRAY

  166.     public byte[] toByteArray(JsonNode doc) throws UtilsException {
  167.         try {
  168.             return _getObjectWriter(this.prettyPrint).writeValueAsBytes(doc);
  169.         }catch(Exception e) {
  170.             throw new UtilsException(e.getMessage(),e);
  171.         }
  172.     }
  173.     
  174.     public byte[] toByteArray(Map<String, Object> doc) throws UtilsException {
  175.         try {
  176.             return _getObjectWriter(this.prettyPrint).writeValueAsBytes(doc);
  177.         }catch(Exception e) {
  178.             throw new UtilsException(e.getMessage(),e);
  179.         }
  180.     }

  182.     // TO STRING

  184.     public String toString(JsonNode doc) throws UtilsException {
  185.         try {
  186.             return _getObjectWriter(this.prettyPrint).writeValueAsString(doc);
  187.         }catch(Exception e) {
  188.             throw new UtilsException(e.getMessage(),e);
  189.         }
  190.     }
  191.     
  192.     public String toString(Map<String, Object> doc) throws UtilsException {
  193.         try {
  194.             return _getObjectWriter(this.prettyPrint).writeValueAsString(doc);
  195.         }catch(Exception e) {
  196.             throw new UtilsException(e.getMessage(),e);
  197.         }
  198.     }

  200.     // WRITE TO

  202.     public void writeTo(JsonNode doc, OutputStream os) throws UtilsException {
  203.         try {
  204.             _getObjectWriter(this.prettyPrint).writeValue(os, doc);
  205.         }catch(Exception e) {
  206.             throw new UtilsException(e.getMessage(),e);
  207.         }
  208.     }
  209.     
  210.     public void writeTo(Object object, OutputStream os) throws UtilsException {
  211.         try {
  212.             _getObjectWriter(this.prettyPrint).writeValue(os, object);
  213.         }catch(Exception e) {
  214.             throw new UtilsException(e.getMessage(),e);
  215.         }
  216.     }
  217.     
  218.     // IS
  219.     
  220.     protected boolean isValid(byte[]jsonBytes){
  221.         try {
  222.             getAsNode(jsonBytes);
  223.             return true;
  224.         } catch(Throwable e) {
  225.             return false;
  226.         }
  227.     }
  228.     
  229.     protected boolean isValid(String jsonString){
  230.         try {
  231.             getAsNode(jsonString);
  232.             return true;
  233.         } catch(Throwable e) {
  234.             return false;
  235.         }
  236.     }
  237.     
  238.     // UTILITIES
  239.     
  240.     public Map<String, Serializable> convertToSimpleMap(JsonNode node){
  241.         return this.convertToSimpleMap(node, true, false, true, false, ".");
  242.     }
  243.     public Map<String, Serializable> convertToSimpleMap(JsonNode node, String separator){
  244.         return this.convertToSimpleMap(node, true, false, true, false, separator);
  245.     }
  246.     public Map<String, Serializable> convertToSimpleMap(JsonNode node, 
  247.             boolean analyzeArrayNode, boolean analyzeAsStringArrayNode,
  248.             boolean analyzeObjectNode, boolean analyzeAsStringObjectNode,
  249.             String separator){
  250.         Map<String, Serializable> map = new HashMap<>();
  251.         _convertToSimpleMap(null, node, null, map,
  252.                 analyzeArrayNode, analyzeAsStringArrayNode,
  253.                 analyzeObjectNode, analyzeAsStringObjectNode,
  254.                 separator);
  255.         return map;
  256.     }
  257.     private void _convertToSimpleMap(String name, JsonNode node, String prefix, Map<String, Serializable> map,
  258.             boolean analyzeArrayNode, boolean analyzeAsStringArrayNode,
  259.             boolean analyzeObjectNode, boolean analyzeAsStringObjectNode,
  260.             String separator){
  261.         
  262.         String newPrefix = "";
  263.         if(prefix!=null) {
  264.             newPrefix = prefix+separator;
  265.         }
  266.         
  267.         if(node instanceof ObjectNode) {
  268.         
  269.             Iterator<String> iterator = node.fieldNames();
  270.             while(iterator.hasNext()) {
  271.                 String field = iterator.next();
  272.                 JsonNode child = node.get(field);
  273.                 if(child instanceof ArrayNode) {
  274.                     if(analyzeArrayNode) {
  275.                         ArrayNode array = (ArrayNode) child;
  276.                         if(array.size()>0) {
  277.                             ArrayList<String> lString = new ArrayList<>();
  278.                             for (int i = 0; i < array.size(); i++) {
  279.                                 JsonNode arrayChildNode = array.get(i);
  280.                                 if(arrayChildNode instanceof ArrayNode || arrayChildNode instanceof ObjectNode) {
  281.                                     String prefixRecursive = newPrefix+normalizeKey(field)+"["+i+"]";
  282.                                     _convertToSimpleMap(field, arrayChildNode, prefixRecursive, map,
  283.                                             analyzeArrayNode, analyzeAsStringArrayNode,
  284.                                             analyzeObjectNode, analyzeAsStringObjectNode,
  285.                                             separator);
  286.                                 }
  287.                                 else {
  288.                                     String text = arrayChildNode.asText();
  289.                                     if(text != null && !text.isEmpty())
  290.                                         lString.add(text);
  291.                                 }
  292.                             }
  293.                             if(!lString.isEmpty()) {
  294.                                 map.put(newPrefix+field, lString);
  295.                             }
  296.                         }
  297.                     }
  298.                     else if(analyzeAsStringArrayNode){
  299.                         String text = child.asText();
  300.                         if(text != null && !text.isEmpty())
  301.                             map.put(newPrefix+field, text);
  302.                     }
  303.                 }
  304.                 else if(child instanceof ObjectNode) {
  305.                     if(analyzeObjectNode) {
  306.                         ObjectNode object = (ObjectNode) child;
  307.                         String prefixRecursive = newPrefix+normalizeKey(field);
  308.                         _convertToSimpleMap(field, object, prefixRecursive, map,
  309.                                 analyzeArrayNode, analyzeAsStringArrayNode,
  310.                                 analyzeObjectNode, analyzeAsStringObjectNode,
  311.                                 separator);
  312.                     }
  313.                     else if(analyzeAsStringObjectNode){
  314.                         String text = child.asText();
  315.                         if(text != null && !text.isEmpty())
  316.                             map.put(newPrefix+field, text);
  317.                     }
  318.                 }
  319.                 else {
  320.                     String text = child.asText();
  321.                     if(text != null && !text.isEmpty())
  322.                         map.put(newPrefix+field, text);
  323.                 }
  324.             }
  325.             
  326.         }
  327.         else if(node instanceof ArrayNode) {
  328.             ArrayNode array = (ArrayNode) node;
  329.             if(array.size()>0) {
  330.                 ArrayList<String> lString = new ArrayList<>();
  331.                 for (int i = 0; i < array.size(); i++) {
  332.                     JsonNode arrayChildNode = array.get(i);
  333.                     if(arrayChildNode instanceof ArrayNode || arrayChildNode instanceof ObjectNode) {
  334.                         String prefixRecursive = newPrefix+normalizeKey(name)+"["+i+"]";
  335.                         _convertToSimpleMap(name, arrayChildNode, prefixRecursive, map,
  336.                                 analyzeArrayNode, analyzeAsStringArrayNode,
  337.                                 analyzeObjectNode, analyzeAsStringObjectNode,
  338.                                 separator);
  339.                     }
  340.                     else {
  341.                         String text = arrayChildNode.asText();
  342.                         if(text != null && !text.isEmpty())
  343.                             lString.add(text);
  344.                     }
  345.                 }
  346.                 if(!lString.isEmpty()) {
  347.                     map.put(name, lString);
  348.                 }
  349.             }
  350.         }
  351.         else {
  352.             String text = node.asText();
  353.             if(text != null && !text.isEmpty()) {
  354.                 map.put(name, text);
  355.             }
  356.         }
  357.     }
  358.     private static String normalizeKey(String keyParam) {
  359.         String key = keyParam.trim();
  360.         while(key.contains(" ")) {
  361.             key = key.replace(" ", "_");
  362.         }
  363.         return key;
  364.     }
  365.     
  366.     
  367.     // CONVERT TO MAP 
  368.     
  369.     protected Map<String, Serializable> convertToMapEngine(Logger log, String source, String raw, List<String> claimsToConvert) {
  370.         JsonNode jsonResponse = null;
  371.         try {
  372.             jsonResponse = this.getAsNode(raw);
  373.         }catch(Exception t) {
  374.             // ignore
  375.         }
  376.         return convertToMapEngine(log, source, jsonResponse, claimsToConvert);
  377.     }
  378.     protected Map<String, Serializable> convertToMapEngine(Logger log, String source, byte[]raw, List<String> claimsToConvert) {
  379.         JsonNode jsonResponse = null;
  380.         try {
  381.             jsonResponse = this.getAsNode(raw);
  382.         }catch(Exception t) {
  383.             // ignore
  384.         }
  385.         return convertToMapEngine(log, source, jsonResponse, claimsToConvert);
  386.     }
  387.     private Map<String, Serializable> convertToMapEngine(Logger log, String source, JsonNode jsonResponse, List<String> claimsToConvert) {
  388.         Map<String, Serializable> returnMap = new HashMap<>();
  389.             
  390.         try {
  391.             if(jsonResponse instanceof ObjectNode) {
  392.                         
  393.                 Iterator<String> iterator = jsonResponse.fieldNames();
  394.                 while(iterator.hasNext()) {
  395.                     String field = iterator.next();
  396.                     if(claimsToConvert==null || claimsToConvert.contains(field)) {
  397.                         try {
  398.                             JsonNode selectedClaim = jsonResponse.get(field);
  399.                             if(selectedClaim instanceof ValueNode) {
  400.                                 returnMap.put(field, selectedClaim.asText());
  401.                             }
  402.                             else if(selectedClaim instanceof ArrayNode) {
  403.                                 ArrayNode array = (ArrayNode) selectedClaim;
  404.                                 if(array.size()>0) {
  405.                                     JsonNode arrayFirstChildNode = array.get(0);
  406.                                     if(arrayFirstChildNode instanceof ValueNode) {
  407.                                         ArrayList<Serializable> l = new ArrayList<>();
  408.                                         for (int i = 0; i < array.size(); i++) {
  409.                                             JsonNode arrayChildNode = array.get(i);
  410.                                             Map<String, Serializable> readClaims = this.convertToSimpleMap(arrayChildNode);
  411.                                             if(readClaims!=null && readClaims.size()>0) {
  412.                                                 if(readClaims.size()==1) {
  413.                                                     for (String claim : readClaims.keySet()) {
  414.                                                         Serializable value = readClaims.get(claim);
  415.                                                         l.add(value);
  416.                                                     }
  417.                                                 }
  418.                                                 else {
  419.                                                     for (String claim : readClaims.keySet()) {
  420.                                                         Serializable value = readClaims.get(claim);
  421.                                                         addAttributeEngine(returnMap, claim==null ? field : claim, value);
  422.                                                     }
  423.                                                 }
  424.                                             }
  425.                                         }
  426.                                         if(!l.isEmpty()) {
  427.                                             addAttributeEngine(returnMap, field, l);
  428.                                         }
  429.                                     }
  430.                                     else {
  431.                                         for (int i = 0; i < array.size(); i++) {
  432.                                             JsonNode arrayChildNode = array.get(i);
  433.                                             Map<String, Serializable> readClaims = this.convertToSimpleMap(arrayChildNode);
  434.                                             if(readClaims!=null && readClaims.size()>0) {
  435.                                                 for (String claim : readClaims.keySet()) {
  436.                                                     Serializable value = readClaims.get(claim);
  437.                                                     addAttributeEngine(returnMap, claim, value);
  438.                                                 }
  439.                                             }
  440.                                         }
  441.                                     }
  442.                                 }
  443.                             }
  444.                             else {
  445.                                 Map<String, Serializable> readClaims = this.convertToSimpleMap(selectedClaim);
  446.                                 if(readClaims!=null && readClaims.size()>0) {
  447.                                     for (String claim : readClaims.keySet()) {
  448.                                         Serializable value = readClaims.get(claim);
  449.                                         addAttributeEngine(returnMap, claim, value);
  450.                                     }
  451.                                 }
  452.                             }
  453.                         }catch(Throwable e) {
  454.                             log.error("Convert claim '"+field+"' to map failed ("+source+"): "+e.getMessage(),e);
  455.                         }
  456.                     }
  457.                 }
  458.             }
  459.         }catch(Throwable e) {
  460.             // ignore
  461.         }

  463.         return returnMap;
  464.     }
  465.     private void addAttributeEngine(Map<String, Serializable> attributes, String claim, Serializable value) {
  466.         if(attributes.containsKey(claim)) {
  467.             for (int j = 1; j < 100; j++) {
  468.                 String newKeyClaim = "_"+claim+"_"+j;
  469.                 if(!attributes.containsKey(newKeyClaim)) {
  470.                     attributes.put(newKeyClaim, attributes.get(claim));
  471.                     break;
  472.                 }
  473.             }
  474.         }
  475.         attributes.put(claim,value); // sovrascrive claim gia' esistente (e' stato salvato con un nome speciale)
  476.     }   
  477.     
  478.     
  479.     
  480.     // INSERT VALUE
  481.     
  482.     public static final String CAST_PREFIX = "cast(";
  483.     public static final String CAST_SUFFIX_AS_INT = " as int)";
  484.     public static final String CAST_SUFFIX_AS_LONG = " as long)";
  485.     public static final String CAST_SUFFIX_AS_FLOAT = " as float)";
  486.     public static final String CAST_SUFFIX_AS_DOUBLE = " as double)";
  487.     public static final String CAST_SUFFIX_AS_BOOLEAN = " as boolean)";
  488.     
  489.     private static final String CAST_ARRAY_OPTIONAL_EMPTY_RESULT = "cast( as string array)";
  490.     public static final String CAST_PREFIX_ARRAY = "cast([";
  491.     public static final String CAST_SUFFIX_AS_STRING_ARRAY = "] as string array)";
  492.     
  493.     public void putValue(ObjectNode objectNode, String key, String value) throws UtilsException {
  494.         if(value!=null) {
  495.             String checkValue = value.trim();
  496.             if(CAST_ARRAY_OPTIONAL_EMPTY_RESULT.equals(checkValue)) {
  497.                 // nop
  498.             }
  499.             else if(checkValue.startsWith(CAST_PREFIX_ARRAY) && checkValue.endsWith(CAST_SUFFIX_AS_STRING_ARRAY)) {
  500.                 String raw = value.trim();
  501.                 try {
  502.                     raw = value.substring(CAST_PREFIX_ARRAY.length(), (value.length()-CAST_SUFFIX_AS_STRING_ARRAY.length()));
  503.                     String [] tmp = raw.split(",");
  504.                     StringBuilder sb = new StringBuilder();
  505.                     if(tmp!=null && tmp.length>0) {
  506.                         for (int i = 0; i < tmp.length; i++) {
  507.                             String check = tmp[i];
  508.                             if(check!=null) {
  509.                                 check = check.trim();   
  510.                             }
  511.                             if(StringUtils.isNotEmpty(check)) {
  512.                                 if(sb.length()>0) {
  513.                                     sb.append(",");
  514.                                 }
  515.                                 sb.append("\"").append(check).append("\"");
  516.                             }
  517.                         }
  518.                     }
  519.                     if(sb.length()>0) {
  520.                         String newValue = "["+sb.toString()+"]";
  521.                         JsonNode node = this.getAsNode(newValue);
  522.                         objectNode.set(key, node);
  523.                     }
  524.                     else {
  525.                         throw new Exception("empty value after parsing");
  526.                     }
  527.                 }catch(Throwable t) {
  528.                     throw new UtilsException("Cast value '"+raw+"' as string array failed: "+t.getMessage(),t);
  529.                 }
  530.             }
  531.             else if(checkValue.startsWith("[") && checkValue.endsWith("]")) {
  532.                 try {
  533.                     JsonNode node = this.getAsNode(value);
  534.                     objectNode.set(key, node);
  535.                 }catch(Throwable t) {
  536.                     boolean throwException = true;
  537.                     // provo ad aggiungere le stringhe
  538.                     String s = checkValue.substring(1, checkValue.length()-1);
  539.                     if(s!=null && StringUtils.isNotEmpty(s)) {
  540.                         String [] tmp = s.split(",");
  541.                         StringBuilder sb = new StringBuilder();
  542.                         if(tmp!=null && tmp.length>0) {
  543.                             for (int i = 0; i < tmp.length; i++) {
  544.                                 String check = tmp[i];
  545.                                 if(check!=null) {
  546.                                     check = check.trim();   
  547.                                 }
  548.                                 if(StringUtils.isNotEmpty(check)) {
  549.                                     if(sb.length()>0) {
  550.                                         sb.append(",");
  551.                                     }
  552.                                     sb.append("\"").append(check).append("\"");
  553.                                 }
  554.                             }
  555.                         }
  556.                         if(sb.length()>0) {
  557.                             try {
  558.                                 String newValue = "["+sb.toString()+"]";
  559.                                 JsonNode node = this.getAsNode(newValue);
  560.                                 objectNode.set(key, node);
  561.                                 throwException = false;
  562.                             }catch(Throwable t2) {
  563.                                 // rilancio prima eccezione
  564.                             }
  565.                         }
  566.                     }
  567.                     if(throwException) {
  568.                         throw new UtilsException("Process value '"+value+"' as array node failed: "+t.getMessage(),t);
  569.                     }
  570.                 }
  571.             }
  572.             else if(checkValue.startsWith("{") && checkValue.endsWith("}")) {
  573.                 JsonNode node = this.getAsNode(value);
  574.                 objectNode.set(key, node);
  575.             }
  576.             else {
  577.                 String checkValueLowerCase = checkValue.toLowerCase();
  578.                 if(checkValueLowerCase.startsWith(CAST_PREFIX) && checkValueLowerCase.endsWith(CAST_SUFFIX_AS_INT)) {
  579.                     String raw = value.trim();
  580.                     try {
  581.                         raw = value.substring(CAST_PREFIX.length(), (value.length()-CAST_SUFFIX_AS_INT.length()));
  582.                         if(raw!=null) {
  583.                             raw = raw.trim();
  584.                             if(StringUtils.isNotEmpty(raw)) {
  585.                                 int v = Integer.valueOf(raw);
  586.                                 objectNode.put(key, v);
  587.                             }
  588.                         }
  589.                     }catch(Throwable t) {
  590.                         throw new UtilsException("Cast value '"+raw+"' as int failed: "+t.getMessage(),t);
  591.                     }
  592.                 }
  593.                 else if(checkValueLowerCase.startsWith(CAST_PREFIX) && checkValueLowerCase.endsWith(CAST_SUFFIX_AS_LONG)) {
  594.                     String raw = value.trim();
  595.                     try {
  596.                         raw = value.substring(CAST_PREFIX.length(), (value.length()-CAST_SUFFIX_AS_LONG.length()));
  597.                         if(raw!=null) {
  598.                             raw = raw.trim();
  599.                             if(StringUtils.isNotEmpty(raw)) {
  600.                                 long v = Long.valueOf(raw);
  601.                                 objectNode.put(key, v);
  602.                             }
  603.                         }
  604.                     }catch(Throwable t) {
  605.                         throw new UtilsException("Cast value '"+raw+"' as long failed: "+t.getMessage(),t);
  606.                     }
  607.                 }
  608.                 else if(checkValueLowerCase.startsWith(CAST_PREFIX) && checkValueLowerCase.endsWith(CAST_SUFFIX_AS_FLOAT)) {
  609.                     String raw = value.trim();
  610.                     try {
  611.                         raw = value.substring(CAST_PREFIX.length(), (value.length()-CAST_SUFFIX_AS_FLOAT.length()));
  612.                         if(raw!=null) {
  613.                             raw = raw.trim();
  614.                             if(StringUtils.isNotEmpty(raw)) {
  615.                                 float v = Float.valueOf(raw);
  616.                                 objectNode.put(key, v);
  617.                             }
  618.                         }
  619.                     }catch(Throwable t) {
  620.                         throw new UtilsException("Cast value '"+raw+"' as float failed: "+t.getMessage(),t);
  621.                     }
  622.                 }
  623.                 else if(checkValueLowerCase.startsWith(CAST_PREFIX) && checkValueLowerCase.endsWith(CAST_SUFFIX_AS_DOUBLE)) {
  624.                     String raw = value.trim();
  625.                     try {
  626.                         raw = value.substring(CAST_PREFIX.length(), (value.length()-CAST_SUFFIX_AS_DOUBLE.length()));
  627.                         if(raw!=null) {
  628.                             raw = raw.trim();
  629.                             if(StringUtils.isNotEmpty(raw)) {
  630.                                 double v = Double.valueOf(raw);
  631.                                 objectNode.put(key, v);
  632.                             }
  633.                         }
  634.                     }catch(Throwable t) {
  635.                         throw new UtilsException("Cast value '"+raw+"' as double failed: "+t.getMessage(),t);
  636.                     }
  637.                 }
  638.                 else if(checkValueLowerCase.startsWith(CAST_PREFIX) && checkValueLowerCase.endsWith(CAST_SUFFIX_AS_BOOLEAN)) {
  639.                     String raw = value.trim();
  640.                     try {
  641.                         raw = value.substring(CAST_PREFIX.length(), (value.length()-CAST_SUFFIX_AS_BOOLEAN.length()));
  642.                         if(raw!=null) {
  643.                             raw = raw.trim();
  644.                             if(StringUtils.isNotEmpty(raw)) {
  645.                                 boolean v = Boolean.valueOf(raw);
  646.                                 objectNode.put(key, v);
  647.                             }
  648.                         }
  649.                     }catch(Throwable t) {
  650.                         throw new UtilsException("Cast value '"+raw+"' as boolean failed: "+t.getMessage(),t);
  651.                     }
  652.                 }
  653.                 else {
  654.                     objectNode.put(key, value);
  655.                 }
  656.             }
  657.         }
  658.     }
  659.     
  660.     
  661.     
  662.     // RENAME
  663.     
  664.     public void renameFieldByPath(JsonNode oNode, Map<String, String> pathToNewName) throws UtilsException {
  665.         renameFieldByPath(oNode, pathToNewName, true);
  666.     }
  667.     public void renameFieldByPath(JsonNode oNode, Map<String, String> pathToNewName, boolean throwNotFound) throws UtilsException {
  668.         renameFieldByPath(oNode, pathToNewName, false, throwNotFound);
  669.     }
  670.     public void renameFieldByPath(JsonNode oNode, Map<String, String> pathToNewName, boolean forceReorder, boolean throwNotFound) throws UtilsException {
  671.         if(pathToNewName==null || pathToNewName.isEmpty()) {
  672.             throw new UtilsException("Conversion map undefined");
  673.         }
  674.         for (String path : pathToNewName.keySet()) {
  675.             String newName = pathToNewName.get(path);
  676.             renameFieldByPath(oNode, path, newName, forceReorder, throwNotFound);
  677.         }
  678.     }
  679.     public void renameFieldByPath(JsonNode oNode, SortedMap<String> pathToNewName) throws UtilsException {
  680.         renameFieldByPath(oNode, pathToNewName, true);
  681.     }
  682.     public void renameFieldByPath(JsonNode oNode, SortedMap<String> pathToNewName, boolean throwNotFound) throws UtilsException {
  683.         renameFieldByPath(oNode, pathToNewName, false, throwNotFound);
  684.     }
  685.     public void renameFieldByPath(JsonNode oNode, SortedMap<String> pathToNewName, boolean forceReorder, boolean throwNotFound) throws UtilsException {
  686.         if(pathToNewName==null || pathToNewName.isEmpty()) {
  687.             throw new UtilsException("Conversion map undefined");
  688.         }
  689.         for (String path : pathToNewName.keys()) {
  690.             String newName = pathToNewName.get(path);
  691.             renameFieldByPath(oNode, path, newName, forceReorder, throwNotFound);
  692.         }
  693.     }
  694.     public void renameFieldByPath(JsonNode oNode, String path, String newName) throws UtilsException {
  695.         renameFieldByPath(oNode, path, newName, true);
  696.     }
  697.     public void renameFieldByPath(JsonNode oNode, String path, String newName, boolean throwNotFound) throws UtilsException {
  698.         renameFieldByPath(oNode, path, newName, false, throwNotFound);
  699.     }
  700.     public void renameFieldByPath(JsonNode oNode, String path, String newName, boolean forceReorder, boolean throwNotFound) throws UtilsException {
  701.             
  702.         boolean esito = true;
  703.         int i = 0;
  704.         while(esito == true && i < 1000000) { // per avere un limite
  705.             try {
  706.                 _renameFieldByPath(oNode, path, newName, forceReorder, true); // lasciare true
  707.                 esito = true;
  708.                 if(SPECIAL_KEY_CONVERT_TO_ARRAY.equals(newName) || newName.startsWith(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX)) {
  709.                     break; // serve un solo giro
  710.                 }
  711.             }catch(UtilsException e) {
  712.                 if(i==0){
  713.                     if(SPECIAL_KEY_CONVERT_TO_ARRAY.equals(newName)) {
  714.                         if(! (e.getMessage()!=null && e.getMessage().contains(ALREADY_ARRAY_TYPE_ERROR)) ) {
  715.                             if(throwNotFound) {
  716.                                 throw e;
  717.                             }
  718.                         }
  719.                     }
  720.                     else if(newName.startsWith(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX)) {
  721.                         if(throwNotFound || (e.getMessage()!=null && !e.getMessage().contains("not found")) ) {
  722.                             throw e;
  723.                         }
  724.                     }
  725.                     else {
  726.                         if(throwNotFound) {
  727.                             throw e;
  728.                         }
  729.                     }
  730.                 }
  731.                 if(i>0) {
  732.                     // almeno 1 occorrenza gestita
  733.                     return;
  734.                 }
  735.                 esito = false;
  736.             }
  737.             i++;
  738.         }
  739.         
  740.     }
  741.     public void _renameFieldByPath(JsonNode oNode, String path, String newName, boolean forceReorder, boolean throwNotFound) throws UtilsException {

  743.         String [] pathFragment = path.split("\\.");
  744.         if(pathFragment==null || pathFragment.length<=0) {
  745.             throw new UtilsException("Path undefined");
  746.         }
  747.         if(newName==null) {
  748.             throw new UtilsException("New name undefined");
  749.         }
  750.         if(!oNode.isObject()) {
  751.             throw new UtilsException("Node isn't object");
  752.         }
  753.         
  754.         _StructureNode s = new _StructureNode();
  755.         s.parentNode = oNode;
  756.         s.nodeForRename = oNode;
  757.         
  758.         _renameFieldByPath(s, 
  759.                 path, pathFragment, 0,
  760.                 newName, forceReorder, throwNotFound);
  761.     }
  762.     
  763.     private void _renameFieldByPath(_StructureNode structure, 
  764.             String path, String [] pathFragment, int position,
  765.             String newName, boolean forceReorder, boolean throwNotFound) throws UtilsException {
  766.         
  767.         //System.out.println("PROCESS ["+structure.parent+"]");
  768.                 
  769.         boolean foglia = position==pathFragment.length-1;
  770.         String name = pathFragment[position];
  771.         
  772.         JsonNode parentNode = structure.parentNode;
  773.         JsonNode nodeForRename = structure.nodeForRename;
  774.         /*String parent = structure.parent;
  775.         System.out.println("navigo ["+name+"] (padre:"+parent+")");
  776.         if(nodeForRename.get(name)==null) {
  777.             System.out.println("isObject:"+nodeForRename.isObject());
  778.             System.out.println("isArray:"+nodeForRename.isArray());
  779.         }*/
  780.         
  781.         
  782.         parentNode = nodeForRename;
  783.         nodeForRename = nodeForRename.get(name);
  784.         if(nodeForRename==null || nodeForRename instanceof com.fasterxml.jackson.databind.node.MissingNode) {
  785.             if(throwNotFound && 
  786.                     !"".equals(path) // "" rappresenta il root element json
  787.                 ) {
  788.                 throw new UtilsException("Element '"+name+"' not found (path '"+path+"')");
  789.             }
  790.         }
  791.         if(foglia) {
  792.             //System.out.println("padre:"+parent+")");
  793.             //System.out.println("  newName:"+newName+")");
  794.             //System.out.println("  nodeForRename:"+nodeForRename+")");
  795.             //System.out.println("  parentNode:"+parentNode+")");
  796.             
  797.             if(forceReorder) {
  798.                 List<String> nomi = new ArrayList<>();
  799.                 Iterator<String> it = ((ObjectNode)parentNode).fieldNames();
  800.                 if(it!=null) {
  801.                     while (it.hasNext()) {
  802.                         String fieldName = (String) it.next();
  803.                         nomi.add(fieldName);
  804.                     }
  805.                 }
  806.                 for (String fieldName : nomi) {
  807.                     JsonNode n = ((ObjectNode)parentNode).get(fieldName);
  808.                     if(fieldName.equals(name)) {
  809.                         
  810.                         // caso in gestione
  811.                         
  812.                         if(SPECIAL_KEY_CONVERT_TO_ARRAY.equals(newName)) {
  813.                             if(!n.isArray()) {
  814.                                 //System.out.println("CONVERT TO ARRAY ["+path+"] ["+fieldName+"]");
  815.                                 ((ObjectNode)parentNode).remove(fieldName);
  816.                                 ArrayNode arrayNode = ((ObjectNode)parentNode).arrayNode();
  817.                                 arrayNode.add(n);
  818.                                 ((ObjectNode)parentNode).set(fieldName,arrayNode);
  819.                             }
  820.                             else {
  821.                                 //System.out.println("GIA TROVATO COME ARRAY ["+path+"] ["+fieldName+"]");
  822.                                 if(throwNotFound) {
  823.                                     throw new UtilsException("Element '"+name+"' "+ALREADY_ARRAY_TYPE_ERROR+" (path '"+path+"')");
  824.                                 }
  825.                             }
  826.                         }
  827.                         else {
  828.                             ((ObjectNode)parentNode).remove(fieldName);
  829.                             ((ObjectNode)parentNode).set(newName,n);
  830.                         }
  831.                     }
  832.                     else {
  833.                         
  834.                         // elementi da preservarne l'ordine
  835.                         
  836.                         ((ObjectNode)parentNode).remove(fieldName);
  837.                         ((ObjectNode)parentNode).set(fieldName,n);
  838.                     }
  839.                 }
  840.             }
  841.             else {
  842.                 if(newName.startsWith(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX)) {
  843.                 
  844.                     // non supporta forceReorder, per quello non e' presente prima
  845.                     List<String> l = convertReorderFieldChildrenByPathKeyToList(newName);
  846.                     
  847.                     //System.out.println("REORDER--- "+l);
  848.                     
  849.                     JsonNode attuale = null;
  850.                     if("".equals(path)) {
  851.                         attuale = ((ObjectNode)parentNode);
  852.                     }
  853.                     else {
  854.                         attuale = ((ObjectNode)parentNode).get(name);
  855.                     }
  856.                     if(attuale.isArray()) {
  857.                         //throw new UtilsException("Cannot execute reorder in array object (path '"+path+"')");
  858.                         ArrayNode array = (ArrayNode) nodeForRename;
  859.                         if(array!=null && array.size()>0) {
  860.                             for (int i = 0; i < array.size(); i++) {
  861.                                 JsonNode arrayChildNode = array.get(i);
  862.                                 if(arrayChildNode.isObject()) {
  863.                                     // aggiungo elementi in ordine
  864.                                     for (String nameReorder : l) {
  865.                                         JsonNode n = arrayChildNode.get(nameReorder);
  866.                                         if(n==null || n instanceof com.fasterxml.jackson.databind.node.MissingNode) {
  867.                                             //System.out.println("REORDERN NOT FOUND PARENT throwNotFound["+throwNotFound+"] ["+(attuale)+"]");
  868.                                             //throw new UtilsException("Element '"+nameReorder+"' for reorder not found (path '"+path+"')");
  869.                                         }
  870.                                         else {
  871.                                             //System.out.println("REORDER["+nameReorder+"]");
  872.                                             ((ObjectNode)arrayChildNode).remove(nameReorder);
  873.                                             ((ObjectNode)arrayChildNode).set(nameReorder, n);
  874.                                         }
  875.                                     }
  876.                                 }
  877.                                 else {
  878.                                     throw new UtilsException("Cannot execute reorder in simple object (path '"+path+"') (array position i="+i+")");
  879.                                 }
  880.                             }
  881.                         }
  882.                     }
  883.                     else if(attuale.isObject()) {
  884.                         // aggiungo elementi in ordine
  885.                         for (String nameReorder : l) {
  886.                             JsonNode n = attuale.get(nameReorder);
  887.                             if(n==null || n instanceof com.fasterxml.jackson.databind.node.MissingNode) {
  888.                                 //System.out.println("REORDERN NOT FOUND PARENT throwNotFound["+throwNotFound+"] ["+(attuale)+"]");
  889.                                 //throw new UtilsException("Element '"+nameReorder+"' for reorder not found (path '"+path+"')");
  890.                             }
  891.                             else {
  892.                                 //System.out.println("REORDER["+nameReorder+"]");
  893.                                 ((ObjectNode)attuale).remove(nameReorder);
  894.                                 ((ObjectNode)attuale).set(nameReorder, n);
  895.                             }
  896.                         }
  897.                     }
  898.                     else {
  899.                         throw new UtilsException("Cannot execute reorder in simple object (path '"+path+"')");
  900.                     }
  901.                     
  902.                 }
  903.                 else if(SPECIAL_KEY_CONVERT_TO_ARRAY.equals(newName)) {
  904.                     if(nodeForRename!=null && !nodeForRename.isArray()) {
  905.                         //System.out.println("CONVERT TO ARRAY ["+path+"] ["+name+"]");
  906.                         ((ObjectNode)parentNode).remove(name);
  907.                         ArrayNode arrayNode = ((ObjectNode)parentNode).arrayNode();
  908.                         arrayNode.add(nodeForRename);
  909.                         ((ObjectNode)parentNode).set(name,arrayNode);
  910.                     }
  911.                     else {
  912.                         //System.out.println("GIA TROVATO COME ARRAY ["+path+"] ["+name+"]");
  913.                         if(throwNotFound) {
  914.                             throw new UtilsException("Element '"+name+"' "+ALREADY_ARRAY_TYPE_ERROR+" (path '"+path+"')");
  915.                         }
  916.                     }
  917.                 }
  918.                 else {
  919.                     ((ObjectNode)parentNode).remove(name);
  920.                     ((ObjectNode)parentNode).set(newName,nodeForRename);
  921.                 }
  922.                 
  923.             }
  924.         }
  925.         else {          
  926.             if(nodeForRename!=null && nodeForRename.isObject() && nodeForRename instanceof ObjectNode) {
  927.                 _StructureNode s = new _StructureNode();
  928.                 s.parentNode = parentNode;
  929.                 s.nodeForRename = nodeForRename;
  930.                 s.parent = name;
  931.                 //System.out.println("CHIAMO PER OBJECT s.parent["+s.parent+"]");
  932.                 try {
  933.                     _renameFieldByPath(s, 
  934.                             path, pathFragment, position+1,
  935.                             newName, forceReorder, throwNotFound);
  936.                 }catch(UtilsException e) {
  937.                     if(SPECIAL_KEY_CONVERT_TO_ARRAY.equals(newName)) {
  938.                         if(! (e.getMessage()!=null && e.getMessage().contains(ALREADY_ARRAY_TYPE_ERROR)) ) {
  939.                             throw e;
  940.                         }
  941.                     }
  942.                     else if(newName.startsWith(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX)) {
  943.                         if(e.getMessage()!=null && !e.getMessage().contains("not found")) {
  944.                             throw e;
  945.                         }
  946.                     }
  947.                     else {
  948.                         throw e;
  949.                     }
  950.                 }
  951.             }
  952.             else if(nodeForRename!=null && nodeForRename.isArray() && nodeForRename instanceof ArrayNode) {
  953.                 ArrayNode array = (ArrayNode) nodeForRename;
  954.                 if(array.size()>0) {
  955.                     for (int i = 0; i < array.size(); i++) {
  956.                         JsonNode arrayChildNode = array.get(i);
  957.                         _StructureNode s = new _StructureNode();
  958.                         s.parentNode = nodeForRename;
  959.                         s.nodeForRename = arrayChildNode;
  960.                         s.parent = name+"["+i+"]";
  961.                         //System.out.println("CHIAMO PER ARRAY s.parent["+s.parent+"]");
  962.                         try {
  963.                             _renameFieldByPath(s, 
  964.                                     path, pathFragment, position+1,
  965.                                     newName, forceReorder, throwNotFound);
  966.                         }catch(UtilsException e) {
  967.                             if(SPECIAL_KEY_CONVERT_TO_ARRAY.equals(newName)) {
  968.                                 if(! (e.getMessage()!=null && e.getMessage().contains(ALREADY_ARRAY_TYPE_ERROR)) ) {
  969.                                     throw e;
  970.                                 }
  971.                             }
  972.                             else if(newName.startsWith(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX)) {
  973.                                 if(e.getMessage()!=null && !e.getMessage().contains("not found")) {
  974.                                     throw e;
  975.                                 }
  976.                             }
  977.                             else {
  978.                                 throw e;
  979.                             }
  980.                         }
  981.                     }
  982.                 }
  983.             }
  984.             else {
  985.                 throw new UtilsException("Element '"+name+"' not found as object/array (path '"+path+"')");
  986.             }
  987.         }
  988.         
  989.     }
  990.     
  991.     public void renameFieldInCamelCase(JsonNode oNode, boolean firstLowerCase) throws UtilsException {
  992.         renameFieldInCamelCase(oNode, firstLowerCase, false);
  993.     }
  994.     public void renameFieldInCamelCase(JsonNode oNode, boolean firstLowerCase, boolean forceReorder) throws UtilsException {
  995.         SortedMap<String> mapForRename = new SortedMap<String>();
  996.         if(!oNode.isObject()) {
  997.             throw new UtilsException("Node isn't object");
  998.         }
  999.         renameFieldInCamelCase((ObjectNode)oNode, "", mapForRename, firstLowerCase, forceReorder);
  1000.         if(!mapForRename.isEmpty()) {
  1001.             /*for (String path : mapForRename.keys()) {
  1002.                 System.out.println("MAP ["+path+"] -> ["+mapForRename.get(path)+"]");
  1003.             }*/
  1004.             renameFieldByPath(oNode, mapForRename);
  1005.         }
  1006.     }
  1007.     private static void renameFieldInCamelCase(ObjectNode oNode, String prefix, SortedMap<String> mapForRename,
  1008.             boolean firstLowerCase, boolean forceReorder) throws UtilsException {
  1009.         Iterator<String> it = oNode.fieldNames();
  1010.         if(it!=null) {
  1011.             while (it.hasNext()) {
  1012.                 String fieldName = (String) it.next();
  1013.                 JsonNode node = oNode.get(fieldName);
  1014.                 
  1015.                 if(node!=null){
  1016.                     if(node.isObject() && node instanceof ObjectNode) {
  1017.                         if(StringUtils.isNotEmpty(prefix) && !prefix.endsWith(".")){
  1018.                             prefix = prefix + ".";
  1019.                         }
  1020.                         renameFieldInCamelCase((ObjectNode)node , prefix+fieldName, mapForRename, firstLowerCase, forceReorder);
  1021.                     }
  1022.                     else if(node.isArray() && node instanceof ArrayNode) {
  1023.                         ArrayNode array = (ArrayNode) node;
  1024.                         if(array.size()>0) {
  1025.                             for (int i = 0; i < array.size(); i++) {
  1026.                                 JsonNode arrayChildNode = array.get(i);
  1027.                                 if(arrayChildNode.isObject() && arrayChildNode instanceof ObjectNode) {
  1028.                                     if(StringUtils.isNotEmpty(prefix) && !prefix.endsWith(".")){
  1029.                                         prefix = prefix + ".";
  1030.                                     }
  1031.                                     renameFieldInCamelCase((ObjectNode)arrayChildNode , prefix+fieldName, mapForRename, firstLowerCase, forceReorder);
  1032.                                 }
  1033.                             }
  1034.                         }
  1035.                     }
  1036.                 }
  1037.                 
  1038.                 String camelCaseName = camelCase(fieldName, firstLowerCase);
  1039.                 if(!camelCaseName.equals(fieldName) || forceReorder) {
  1040.                     
  1041.                     if(StringUtils.isNotEmpty(prefix) && !prefix.endsWith(".")){
  1042.                         prefix = prefix + ".";
  1043.                     }
  1044.                     String key = prefix+fieldName;
  1045.                     if(!mapForRename.containsKey(key)) {
  1046.                         mapForRename.add(key, camelCaseName);
  1047.                     }
  1048.                 }
  1049.             }
  1050.         }
  1051.     }
  1052.     
  1053.     public static String camelCase(String fieldName, boolean firstLowerCase) {
  1054.         
  1055.         boolean firstCase = firstLowerCase ? Character.isUpperCase(fieldName.charAt(0)) : Character.isLowerCase(fieldName.charAt(0));
  1056.         boolean charSpecial = fieldName.contains("-") || fieldName.contains("_");
  1057.         if (firstCase || charSpecial) {
  1058.         
  1059.             String newName = fieldName;
  1060.             //System.out.println("ANALIZZO ["+newName+"]");
  1061.             if(firstCase) {
  1062.                 if(firstLowerCase) {
  1063.                     newName = (fieldName.length()>1) ? 
  1064.                             (((fieldName.charAt(0)+"").toLowerCase()) + fieldName.substring(1)) 
  1065.                             : 
  1066.                             (fieldName.toLowerCase());
  1067.                 }
  1068.                 else {
  1069.                     newName = (fieldName.length()>1) ? 
  1070.                             (((fieldName.charAt(0)+"").toUpperCase()) + fieldName.substring(1)) 
  1071.                             : 
  1072.                             (fieldName.toUpperCase());
  1073.                 }
  1074.                 //System.out.println("DOPO UPPER ["+newName+"]");
  1075.             }
  1076.             
  1077.             if(charSpecial) {
  1078.                 int indexOf = newName.indexOf("_");
  1079.                 while(indexOf>=0){
  1080.                     if((indexOf+1)<newName.length()){
  1081.                         if((indexOf+2)<newName.length()){
  1082.                             newName = newName.substring(0, indexOf) + (newName.charAt(indexOf+1)+"").toUpperCase() + newName.substring(indexOf+2,newName.length());
  1083.                         }else{
  1084.                             newName = newName.substring(0, indexOf) + (newName.charAt(indexOf+1)+"").toUpperCase();
  1085.                         }
  1086.                         indexOf = newName.indexOf("_");
  1087.                     }else{
  1088.                         break;
  1089.                     }
  1090.                 }
  1091.     
  1092.                 indexOf = newName.indexOf("-");
  1093.                 while(indexOf>=0){
  1094.                     if((indexOf+1)<newName.length()){
  1095.                         if((indexOf+2)<newName.length()){
  1096.                             newName = newName.substring(0, indexOf) + (newName.charAt(indexOf+1)+"").toUpperCase() + newName.substring(indexOf+2,newName.length());
  1097.                         }else{
  1098.                             newName = newName.substring(0, indexOf) + (newName.charAt(indexOf+1)+"").toUpperCase();
  1099.                         }
  1100.                         indexOf = newName.indexOf("-");
  1101.                     }else{
  1102.                         break;
  1103.                     }
  1104.                 }
  1105.                 //System.out.println("DOPO CHAR ["+newName+"]");
  1106.             }
  1107.             
  1108.             return newName;
  1109.         }
  1110.         else {
  1111.             return fieldName;
  1112.         }
  1113.             
  1114.     }
  1115.     
  1116.     
  1117.     
  1118.     // CONVERT TYPE
  1119.     
  1120.     private static final String SPECIAL_KEY_CONVERT_TO_ARRAY = "___CONVERT_TO_ARRAY__";
  1121.     private static final String ALREADY_ARRAY_TYPE_ERROR = "already array type";
  1122.     
  1123.     public void convertFieldToArrayByPath(JsonNode oNode, List<String> listPath) throws UtilsException {
  1124.         SortedMap<String> pathToNewName = new SortedMap<String>();
  1125.         if(listPath!=null) {
  1126.             for (String path : listPath) {
  1127.                 pathToNewName.add(path, SPECIAL_KEY_CONVERT_TO_ARRAY);
  1128.             }
  1129.         }
  1130.         renameFieldByPath(oNode, pathToNewName, true);
  1131.     }
  1132.     public void convertFieldToArrayByPath(JsonNode oNode, List<String> listPath, boolean throwNotFound) throws UtilsException {
  1133.         SortedMap<String> pathToNewName = new SortedMap<String>();
  1134.         if(listPath!=null) {
  1135.             for (String path : listPath) {
  1136.                 pathToNewName.add(path, SPECIAL_KEY_CONVERT_TO_ARRAY);
  1137.             }
  1138.         }
  1139.         renameFieldByPath(oNode, pathToNewName, throwNotFound);
  1140.     }
  1141.     public void convertFieldToArrayByPath(JsonNode oNode, List<String> listPath, boolean forceReorder, boolean throwNotFound) throws UtilsException {
  1142.         SortedMap<String> pathToNewName = new SortedMap<String>();
  1143.         if(listPath!=null) {
  1144.             for (String path : listPath) {
  1145.                 pathToNewName.add(path, SPECIAL_KEY_CONVERT_TO_ARRAY);
  1146.             }
  1147.         }
  1148.         renameFieldByPath(oNode, pathToNewName, forceReorder, throwNotFound);
  1149.     }
  1150.     public void convertFieldToArrayByPath(JsonNode oNode, String path) throws UtilsException {
  1151.         renameFieldByPath(oNode, path, SPECIAL_KEY_CONVERT_TO_ARRAY, true);
  1152.     }
  1153.     public void convertFieldToArrayByPath(JsonNode oNode, String path, boolean throwNotFound) throws UtilsException {
  1154.         renameFieldByPath(oNode, path, SPECIAL_KEY_CONVERT_TO_ARRAY, throwNotFound);
  1155.     }
  1156.     public void convertFieldToArrayByPath(JsonNode oNode, String path, boolean forceReorder, boolean throwNotFound) throws UtilsException {
  1157.         renameFieldByPath(oNode, path, SPECIAL_KEY_CONVERT_TO_ARRAY, forceReorder, throwNotFound);
  1158.     }
  1159.  
  1160.     
  1161.     // ORDER ELEMENTS TYPE
  1162.     
  1163.     private static final String SPECIAL_KEY_ORDER_ELEMENTS_PREFIX = "___REORDER__";
  1164.     private static final String SPECIAL_KEY_ORDER_ELEMENTS_SEPARATOR = ",";
  1165.     
  1166.     public void reorderFieldChildrenByPath(JsonNode oNode, String path, String ... child) throws UtilsException {
  1167.         renameFieldByPath(oNode, path, SPECIAL_KEY_ORDER_ELEMENTS_PREFIX+toReorderFieldChildrenByPathSuffix(child), true);
  1168.     }
  1169.     public void reorderFieldChildrenByPath(JsonNode oNode, String path, boolean throwNotFound, String ... child) throws UtilsException {
  1170.         String key = SPECIAL_KEY_ORDER_ELEMENTS_PREFIX+toReorderFieldChildrenByPathSuffix(child);
  1171.         //System.out.println("KEY ["+key+"]");
  1172.         renameFieldByPath(oNode, path, key, throwNotFound);
  1173.     }
  1174.     private String toReorderFieldChildrenByPathSuffix(String ... child) throws UtilsException {
  1175.         if(child==null || child.length<=0) {
  1176.             throw new UtilsException("Children undefined");
  1177.         }
  1178.         StringBuilder sb = new StringBuilder();
  1179.         for (String c : child) {
  1180.             if(sb.length()>0) {
  1181.                 sb.append(SPECIAL_KEY_ORDER_ELEMENTS_SEPARATOR);
  1182.             }
  1183.             if(c.contains(SPECIAL_KEY_ORDER_ELEMENTS_SEPARATOR)) {
  1184.                 throw new UtilsException("Invalid child name ["+c+"] (contains '"+SPECIAL_KEY_ORDER_ELEMENTS_SEPARATOR+"')");
  1185.             }
  1186.             sb.append(c);
  1187.         }
  1188.         return sb.toString();
  1189.     }
  1190.     private List<String> convertReorderFieldChildrenByPathKeyToList(String v) throws UtilsException{
  1191.         String parsV = v;
  1192.         if(parsV.startsWith(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX)) {
  1193.             parsV = parsV.substring(SPECIAL_KEY_ORDER_ELEMENTS_PREFIX.length());
  1194.         }
  1195.         List<String> l = new ArrayList<>();
  1196.         if(parsV.contains(SPECIAL_KEY_ORDER_ELEMENTS_SEPARATOR)) {
  1197.             String [] tmp = parsV.split(SPECIAL_KEY_ORDER_ELEMENTS_SEPARATOR);
  1198.             if(tmp!=null && tmp.length>0) {
  1199.                 for (String c : tmp) {
  1200.                     l.add(c);
  1201.                 }
  1202.             }
  1203.         }
  1204.         else {
  1205.             l.add(parsV);
  1206.         }
  1207.         if(l.isEmpty()) {
  1208.             throw new UtilsException("Children not found");
  1209.         }
  1210.         return l;
  1211.     }
  1212.     
  1213. }

  1215. class _StructureNode {
  1216.     
  1217.     JsonNode parentNode;
  1218.     JsonNode nodeForRename;
  1219.     String parent;
  1220.     
  1221. }
Created with JaCoCo 0.8.8.202204050719