DynamicStringReplace.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.  */
  20. package org.openspcoop2.utils;

  22. import java.lang.reflect.Method;
  23. import java.text.SimpleDateFormat;
  24. import java.util.ArrayList;
  25. import java.util.Calendar;
  26. import java.util.Date;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import org.apache.commons.lang.StringUtils;

  33. /**
  34.  * DynamicStringReplace
  35.  *
  36.  * @author Poli Andrea (apoli@link.it)
  37.  * @author $Author$
  38.  * @version $Rev$, $Date$
  39.  */
  40. public class DynamicStringReplace {

  42.     private static boolean containsKey(Map<?, ?> map, String key) {
  43.         // NOTA: prima volutamente viene cercata la stringa esatta per supportare più entry
  44.         boolean contains = map.containsKey(key) || map.containsKey(key.toLowerCase()) || map.containsKey(key.toUpperCase());
  45.         if(contains) {
  46.             return true;
  47.         }
  48.         else {
  49.             Iterator<?> keys = map.keySet().iterator();
  50.             while (keys.hasNext()) {
  51.                 Object oKey = keys.next();
  52.                 if(oKey!=null && oKey instanceof String) {
  53.                     String keyIterator = (String) oKey;
  54.                     String keyIteratorCaseInsensitive = keyIterator.toLowerCase();
  55.                     String keyCaseInsensitive = key.toLowerCase();
  56.                     if(keyCaseInsensitive.equals( keyIteratorCaseInsensitive )) {
  57.                         return true;
  58.                     }
  59.                 }
  60.             }
  61.         }
  62.         return false;
  63.     }
  64.     private static Object get(Map<?, ?> map, String key) {
  65.         // NOTA: prima volutamente viene cercata la stringa esatta per supportare più entry
  66.         if(map.containsKey(key)) {
  67.             return map.get(key);
  68.         }
  69.         else if(map.containsKey(key.toLowerCase())) {
  70.             return map.get(key.toLowerCase());
  71.         }
  72.         else if(map.containsKey(key.toUpperCase())) {
  73.             return map.get(key.toUpperCase());
  74.         }
  75.         else {
  76.             Iterator<?> keys = map.keySet().iterator();
  77.             while (keys.hasNext()) {
  78.                 Object oKey = keys.next();
  79.                 if(oKey!=null && oKey instanceof String) {
  80.                     String keyIterator = (String) oKey;
  81.                     String keyIteratorCaseInsensitive = keyIterator.toLowerCase();
  82.                     String keyCaseInsensitive = key.toLowerCase();
  83.                     if(keyCaseInsensitive.equals( keyIteratorCaseInsensitive )) {
  84.                         return map.get(oKey);
  85.                     }
  86.                 }
  87.             }
  88.         }
  89.         return null;
  90.     }
  91.     
  92.     public static void validate(String messaggioWithPlaceHolder, boolean startWithDollaro) throws UtilsException{
  93.         
  94.         String start = "{";
  95.         String startOptional = "{";
  96.         if(startWithDollaro) {
  97.             start = "${"; 
  98.             startOptional = "?{";
  99.         }
  100.         String end = "}";
  101.         int length = start.length()+end.length();

  103.         // Check di esistenza di almeno 1  '{' e '}'
  104.         if(messaggioWithPlaceHolder!=null && messaggioWithPlaceHolder.length()>length){
  105.             int index1 = messaggioWithPlaceHolder.indexOf(start);
  106.             if(index1<0) {
  107.                 index1 = messaggioWithPlaceHolder.indexOf(startOptional);
  108.             }
  109.             int index2 = messaggioWithPlaceHolder.indexOf(end,index1+start.length());
  110.             if(index1<0 || index2<0){
  111.                 return; // non serve il replace
  112.             }
  113.         }
  114.         
  115.         if(messaggioWithPlaceHolder==null) {
  116.             return;
  117.         }
  118.         
  119.         StringBuilder keyword = new StringBuilder();
  120.         //boolean required = true;
  121.         boolean keywordInCorso = false;
  122.         for(int i=0; i<messaggioWithPlaceHolder.length(); i++){
  123.             char ch = messaggioWithPlaceHolder.charAt(i);
  124.             boolean checkPossibleStart = false;
  125.             if(startWithDollaro) {
  126.                 if(ch == '$' || ch == '?') {
  127.                     //if(ch == '?') {
  128.                     //  required=false;
  129.                     //}
  130.                     checkPossibleStart = true;
  131.                     if(i+1 < messaggioWithPlaceHolder.length()) {
  132.                         i++;
  133.                         ch = messaggioWithPlaceHolder.charAt(i);
  134.                     }
  135.                 }
  136.             }
  137.             else {
  138.                 checkPossibleStart = true;
  139.             }
  140.             if( 
  141.                     ( (checkPossibleStart && '{' == ch) ) 
  142.                     || 
  143.                     ( (keywordInCorso && '}' == ch) ) 
  144.                 ){
  145.                 //char separatorChar = ch;
  146.                 if(keywordInCorso==false){
  147.                     // inizio keyword
  148.                     //keyword.append(separatorChar);
  149.                     keywordInCorso = true; // siamo nel caso di apertura, inizio keyword
  150.                 }
  151.                 else{
  152.                     // fine keyword
  153.                     //keyword.append(separatorChar);
  154.                     String key = keyword.toString();
  155.                     if(key.contains(":")==false){
  156.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: wrong format, required {key:value}");
  157.                     }
  158.                     if(key.startsWith(":") || key.endsWith(":") ){
  159.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: wrong format, required {key:value}");
  160.                     }
  161.                     String tipo = key.substring(0, key.indexOf(":"));
  162.                     String value = key.substring(key.indexOf(":")+1);
  163.                     if(tipo==null || "".equals(tipo.trim())){
  164.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: wrong format, required {key:value}");
  165.                     }
  166.                     if(value==null || "".equals(value.trim())){
  167.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: wrong format, required {key:value}");
  168.                     }
  169.                     
  170.                     keyword.delete(0, keyword.length());
  171.                     keywordInCorso=false;
  172.                     checkPossibleStart=false;
  173.                 }
  174.             }else{
  175.                 if(keywordInCorso){
  176.                     // sto scrivendo la keyword
  177.                     keyword.append(ch);
  178.                 }
  179.             }
  180.         }
  181.     }
  182.     
  183.     public static String replace(String messaggioWithPlaceHolder, Map<String, Object> map, boolean startWithDollaro) throws UtilsException{
  184.         return replace(messaggioWithPlaceHolder, map, startWithDollaro, true);
  185.     }
  186.     public static String replace(String messaggioWithPlaceHolder, Map<String, Object> map, boolean startWithDollaro, boolean complexField) throws UtilsException{
  187.         
  188.         validate(messaggioWithPlaceHolder, startWithDollaro);
  189.         
  190.         String start = "{";
  191.         String startOptional = "{";
  192.         if(startWithDollaro) {
  193.             start = "${"; 
  194.             startOptional = "?{";
  195.         }
  196.         String end = "}";
  197.         int length = start.length()+end.length();
  198.         
  199.         // Check di esistenza di almeno 1  '{' e '}'
  200.         if(messaggioWithPlaceHolder!=null && messaggioWithPlaceHolder.length()>length){
  201.             int index1 = messaggioWithPlaceHolder.indexOf(start);
  202.             if(index1<0) {
  203.                 index1 = messaggioWithPlaceHolder.indexOf(startOptional);
  204.             }
  205.             int index2 = messaggioWithPlaceHolder.indexOf(end,index1+start.length());
  206.             if(index1<0 || index2<0){
  207.                 return messaggioWithPlaceHolder; // non serve il replace
  208.             }
  209.         }
  210.         
  211.         if(messaggioWithPlaceHolder==null) {
  212.             return messaggioWithPlaceHolder;
  213.         }
  214.         
  215.         StringBuilder bf = new StringBuilder();
  216.         StringBuilder keyword = new StringBuilder();
  217.         boolean required = true;
  218.         int countOptionalNotFoundBehaviour = 0;
  219.         boolean keywordInCorso = false;
  220.         for(int i=0; i<messaggioWithPlaceHolder.length(); i++){
  221.             char ch = messaggioWithPlaceHolder.charAt(i);
  222.             Character chDollaro = null; 
  223.             boolean checkPossibleStart = false;
  224.             if(startWithDollaro) {
  225.                 if(ch == '$' || ch == '?') {
  226.                     // verifico che il prossimo carattere non sia un ulteriore carattere speciale
  227.                     boolean analize = true;
  228.                     if(i+1 < messaggioWithPlaceHolder.length()) {
  229.                         char chNext = messaggioWithPlaceHolder.charAt(i+1);
  230.                         if(chNext == '$' || chNext == '?') {
  231.                             analize = false;
  232.                         }
  233.                     }
  234.                     if(analize) {
  235.                         if(ch == '?') {
  236.                             required=false;
  237.                         }
  238.                         checkPossibleStart = true;
  239.                         if(i+1 < messaggioWithPlaceHolder.length()) {
  240.                             i++;
  241.                             chDollaro = ch;
  242.                             ch = messaggioWithPlaceHolder.charAt(i);
  243.                         }
  244.                     }
  245.                 }
  246.             }
  247.             else {
  248.                 checkPossibleStart = true;
  249.             }
  250.             if( 
  251.                     ( (checkPossibleStart && '{' == ch) ) 
  252.                     || 
  253.                     ( (keywordInCorso && '}' == ch) ) 
  254.                 ){
  255.                 //char separatorChar = ch;
  256.                 if(keywordInCorso==false){
  257.                     // inizio keyword
  258.                     //keyword.append(separatorChar);
  259.                     keywordInCorso = true;  // siamo nel caso di apertura, inizio keyword
  260.                 }
  261.                 else{
  262.                     // fine keyword
  263.                     //keyword.append(separatorChar);
  264.                     String key = keyword.toString();
  265.                     if(key.contains(":")==false){
  266.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: wrong format, required {key:value}");
  267.                     }
  268.                     if(key.startsWith(":") || key.endsWith(":") ){
  269.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: wrong format, required {key:value}");
  270.                     }
  271.                     String tipo = key.substring(0, key.indexOf(":"));
  272.                     String value = key.substring(key.indexOf(":")+1);
  273.                     //if(map.containsKey(tipo)==false){
  274.                     String valoreRimpiazzato = null;
  275.                     if(containsKey(map, tipo)==false) {
  276.                         if(required) {
  277.                             throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object with key '"+tipo+"' not found");
  278.                         }
  279.                         else {
  280.                             countOptionalNotFoundBehaviour++;
  281.                             valoreRimpiazzato = "";
  282.                         }
  283.                     }
  284.                     else {
  285.                         //Object object = map.get(tipo);
  286.                         Object object = get(map, tipo);
  287.                         if(object==null){
  288.                             if(required) {
  289.                                 throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object with key '"+tipo+"' is null");
  290.                             }
  291.                             else {
  292.                                 countOptionalNotFoundBehaviour++;
  293.                                 valoreRimpiazzato = "";
  294.                             }
  295.                         }
  296.                         else {
  297.                             valoreRimpiazzato = getValue(key, tipo, value, object, complexField, required);
  298.                             if(valoreRimpiazzato==null){
  299.                                 if(required) {
  300.                                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed");
  301.                                 }
  302.                                 else {
  303.                                     countOptionalNotFoundBehaviour++;
  304.                                     valoreRimpiazzato = "";
  305.                                 }
  306.                             }
  307.                         }
  308.                     }
  309.                     bf.append(valoreRimpiazzato);
  310.                     keyword.delete(0, keyword.length());
  311.                     keywordInCorso=false;
  312.                     checkPossibleStart=false;
  313.                 }
  314.             }else{
  315.                 if(keywordInCorso){
  316.                     // sto scrivendo la keyword
  317.                     keyword.append(ch);
  318.                 }else{
  319.                     if(chDollaro!=null) {
  320.                         bf.append(chDollaro);
  321.                     }
  322.                     bf.append(ch);
  323.                 }
  324.             }
  325.         }
  326.         String result = bf.toString();
  327.         if(result==null) {
  328.             return null;
  329.         }
  330.         if(countOptionalNotFoundBehaviour > 0 && StringUtils.isEmpty(result)) {
  331.             return null;
  332.         }
  333.         return result;
  334.     }
  335.     
  336.     private static String getValue(String key, String tipo, String value, Object object, boolean complexField, boolean required) throws UtilsException{
  337.         
  338.         // Se l'oggetto nella mappa è una data utilizzo il valore come format
  339.         Date d = null;
  340.         if(object instanceof Date){
  341.             d = (Date) object;
  342.         }
  343.         else if(object instanceof java.sql.Date){
  344.             d = (java.sql.Date) object;
  345.         }
  346.         else if(object instanceof Calendar){
  347.             Calendar c = (Calendar) object;
  348.             d = c.getTime();
  349.         }
  350.         if(d!=null){
  351.             SimpleDateFormat sdf = new SimpleDateFormat(value);
  352.             return sdf.format(d);
  353.         }
  354.         
  355.         // Se l'oggetto è una mappa provo ad estrarre l'oggetto indicato.
  356.         if(object instanceof List<?> || object instanceof Map<?,?> || object instanceof Object[]){
  357.                 
  358.             String position = value;
  359.             String newValue = value;
  360.             boolean existsUlterioreParametro = false;
  361.             boolean valueContainsPoint = value.contains(".");
  362.             if(valueContainsPoint && complexField){
  363.                 
  364.                 // Devo convertire i punti dentro le quadre che potrebbero far parte delle chiavi
  365.                 StringBuilder sbFormat = new StringBuilder();
  366.                 boolean start = false;
  367.                 int doppieVirgoletteIndex = -1;
  368.                 boolean startDoppieVirgolette = false;
  369.                 for (int i = 0; i < value.length(); i++) {
  370.                     char c = value.charAt(i);
  371.                     if((!start) && (c == '[')) {
  372.                         start = true;
  373.                         if((i+1 < value.length())) {
  374.                             char cc = value.charAt(i+1);
  375.                             if((cc == '"')) {
  376.                                 startDoppieVirgolette=true;
  377.                                 doppieVirgoletteIndex=i+1;
  378.                             }
  379.                         }
  380.                     }
  381.                     if((start) && (c == ']')) {
  382.                         if(!startDoppieVirgolette) {
  383.                             start = false;
  384.                         }
  385.                     }
  386.                     if((startDoppieVirgolette) && (c == '"') && doppieVirgoletteIndex!=i) {
  387.                         if((i+1 < value.length())) {
  388.                             char cc = value.charAt(i+1);
  389.                             if((cc == ']')) {
  390.                                 startDoppieVirgolette = false;
  391.                                 doppieVirgoletteIndex=i;
  392.                             }
  393.                         }
  394.                     }
  395.                     if(start && c == '.') {
  396.                         sbFormat.append('_');
  397.                     }
  398.                     else {
  399.                         sbFormat.append(c);
  400.                     }
  401.                 }
  402.                 String internalNewValue = sbFormat.toString();
  403.                 
  404.                 // Devo convertire i punti dentro le tonde che potrebbero far parte delle chiavi
  405.                 sbFormat = new StringBuilder();
  406.                 start = false;
  407.                 doppieVirgoletteIndex = -1;
  408.                 startDoppieVirgolette = false;
  409.                 for (int i = 0; i < internalNewValue.length(); i++) {
  410.                     char c = internalNewValue.charAt(i);
  411.                     if((!start) && (c == '(')) {
  412.                         start = true;
  413.                         if((i+1 < internalNewValue.length())) {
  414.                             char cc = internalNewValue.charAt(i+1);
  415.                             if((cc == '"')) {
  416.                                 startDoppieVirgolette=true;
  417.                                 doppieVirgoletteIndex=i+1;
  418.                             }
  419.                         }
  420.                     }
  421.                     if((start) && (c == ')')) {
  422.                         if(!startDoppieVirgolette) {
  423.                             start = false;
  424.                         }
  425.                     }
  426.                     if((startDoppieVirgolette) && (c == '"') && doppieVirgoletteIndex!=i) {
  427.                         if((i+1 < internalNewValue.length())) {
  428.                             char cc = internalNewValue.charAt(i+1);
  429.                             if((cc == ')')) {
  430.                                 startDoppieVirgolette = false;
  431.                                 doppieVirgoletteIndex=i;
  432.                             }
  433.                         }
  434.                     }
  435.                     if(start && c == '.') {
  436.                         sbFormat.append('_');
  437.                     }
  438.                     else {
  439.                         sbFormat.append(c);
  440.                     }
  441.                 }
  442.                 internalNewValue = sbFormat.toString();
  443.                 
  444.                 //System.out.println("OLD ["+value+"]");
  445.                 //System.out.println("NEW ["+internalNewValue+"]");
  446.                 
  447.                 int indexOfPoint = internalNewValue.indexOf(".");
  448.                 if(indexOfPoint>0) {
  449.                     position = value.substring(0, indexOfPoint);
  450.                     try{
  451.                         newValue = value.substring(indexOfPoint+1);
  452.                     }catch(Throwable e){
  453.                         // ignore
  454.                     }
  455.                 }
  456.                 else {
  457.                     position = value;
  458.                     newValue = null;
  459.                 }
  460.                 if(position!=null) {
  461.                     if( (position.startsWith("[") || position.startsWith("("))
  462.                             && 
  463.                             position.length()>1) {
  464.                         position = position.substring(1);
  465.                     }
  466.                     if( (position.endsWith("]") || position.endsWith(")"))
  467.                             && 
  468.                             position.length()>1) {
  469.                         position = position.substring(0,(position.length()-1));
  470.                     }
  471.                     //System.out.println("position ["+position+"]");
  472.                 }
  473.                 if(newValue!=null && StringUtils.isNotEmpty(newValue.trim())) {
  474.                     existsUlterioreParametro=true;
  475.                 }
  476.             }
  477.             
  478.             
  479.             
  480.             Object oInternal = null;
  481.             
  482.             // Provo ad utilizzare  il valore come indice
  483.             if(object instanceof List<?> || object instanceof Object[]){
  484.                 int index = -1;
  485.                 try{
  486.                     index = Integer.parseInt(position);
  487.                 }catch(Exception e){
  488.                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"] with wrong position '"+position+"' (not integer?): "+e.getMessage());
  489.                 }
  490.                 if(object instanceof List<?>){
  491.                     List<?> list = (List<?>) object;
  492.                     if(list.size()<=index){
  493.                         if(required) {
  494.                             throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"] with wrong position '"+index+"' (list size:"+list.size()+")");
  495.                         }
  496.                     }
  497.                     else {
  498.                         oInternal = list.get(index);
  499.                     }
  500.                 }
  501.                 else if(object instanceof Object[]){
  502.                     Object[] arrayObj = (Object[]) object;
  503.                     if(arrayObj.length<=index){
  504.                         if(required) {
  505.                             throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"] with wrong position '"+index+"' (array size:"+arrayObj.length+")");
  506.                         }
  507.                     }
  508.                     else {
  509.                         oInternal = arrayObj[index];
  510.                     }
  511.                 }
  512.             }
  513.             else if(object instanceof Map<?,?>){
  514.                 Map<?,?> map = (Map<?,?>) object;
  515.                 //if(map.containsKey(position)==false){
  516.                 if(containsKey(map, position)==false) {
  517.                     if(required) {
  518.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"] '"+position+"' not exists in map");
  519.                     }
  520.                 }
  521.                 else {
  522.                     //oInternal = map.get(position);
  523.                     oInternal = get(map, position);
  524.                 }
  525.             }   
  526.             
  527.             //if(newValue.contains(".") || (newValue.contains("[") && newValue.contains("]"))){
  528.             if(existsUlterioreParametro) { // se ho definito un parametro dopo la chiave della mappa devo usare il metodo 'readValueInObject'
  529.                 if(oInternal==null){
  530.                     if(required) {
  531.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"]["+position+"] return null object");
  532.                     }
  533.                     else {
  534.                         return null;
  535.                     }
  536.                 }
  537.                 else{
  538.                     return readValueInObject(key, oInternal, newValue, complexField, required);
  539.                 }
  540.             }
  541.             else{
  542.                 // finale
  543.                 if(oInternal!=null){
  544.                     String finalValue = null;
  545.                     if(oInternal instanceof Date){
  546.                         SimpleDateFormat dateformat = new SimpleDateFormat("yyyyMMdd_HHmmssSSS");
  547.                         finalValue = dateformat.format((Date)oInternal);
  548.                     }
  549.                     else if(oInternal instanceof byte[]){
  550. //                      // 1024 = 1K
  551. //                       // Visualizzo al massimo 1K
  552. //                       int max = 1 * 1024;
  553. //                       return org.openspcoop2.utils.Utilities.convertToPrintableText((byte[])ret, max);
  554.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"]["+position+"] return object with type ["+oInternal.getClass().getName()+"]");
  555.                     }
  556.                     else{
  557.                         finalValue = oInternal.toString();
  558.                     }
  559.                     return finalValue;
  560.                 }
  561.                 else{
  562.                     if(required) {
  563.                         throw new UtilsException("Placeholder [{"+key+"}] resolution failed: object ["+object.getClass().getName()+"]["+position+"] return null object");
  564.                     }
  565.                     else {
  566.                         return null;
  567.                     }
  568.                 }
  569.             }   
  570.             
  571.         }
  572.         else{
  573.             
  574.             // Altrimenti provo a navigarlo
  575.             return readValueInObject(key, object, value, complexField, required);
  576.         
  577.         }
  578.         
  579.     }
  580.     private static String readValueInObject(String key, Object o,String name, boolean complexField, boolean required) throws UtilsException{
  581.         //System.out.println("Invocato con oggetto["+o.getClass().getName()+"] nome["+name+"]");
  582.         String fieldName = name;
  583.         //String position = null;
  584.         List<String> arrayMapPosition = new ArrayList<>();
  585.         boolean nameContainsPoint = name.contains(".");
  586.         if(nameContainsPoint && complexField){
  587.             
  588.             // Devo convertire i punti dentro le quadre che potrebbero far parte delle chiavi
  589.             StringBuilder sbFormat = new StringBuilder();
  590.             boolean start = false;
  591.             int doppieVirgoletteIndex = -1;
  592.             boolean startDoppieVirgolette = false;
  593.             for (int i = 0; i < name.length(); i++) {
  594.                 char c = name.charAt(i);
  595.                 if((!start) && (c == '[')) {
  596.                     start = true;
  597.                     if((i+1 < name.length())) {
  598.                         char cc = name.charAt(i+1);
  599.                         if((cc == '"')) {
  600.                             startDoppieVirgolette=true;
  601.                             doppieVirgoletteIndex=i+1;
  602.                         }
  603.                     }
  604.                 }
  605.                 if((start) && (c == ']')) {
  606.                     if(!startDoppieVirgolette) {
  607.                         start = false;
  608.                     }
  609.                 }
  610.                 if((startDoppieVirgolette) && (c == '"') && doppieVirgoletteIndex!=i) {
  611.                     if((i+1 < name.length())) {
  612.                         char cc = name.charAt(i+1);
  613.                         if((cc == ']')) {
  614.                             startDoppieVirgolette = false;
  615.                             doppieVirgoletteIndex=i;
  616.                         }
  617.                     }
  618.                 }
  619.                 if(start && c == '.') {
  620.                     sbFormat.append('_');
  621.                 }
  622.                 else {
  623.                     sbFormat.append(c);
  624.                 }
  625.             }
  626.             String newName = sbFormat.toString();
  627.             
  628.             // Devo convertire i punti dentro le tonde che potrebbero far parte delle chiavi
  629.             sbFormat = new StringBuilder();
  630.             start = false;
  631.             doppieVirgoletteIndex = -1;
  632.             startDoppieVirgolette = false;
  633.             for (int i = 0; i < newName.length(); i++) {
  634.                 char c = newName.charAt(i);
  635.                 if((!start) && (c == '(')) {
  636.                     start = true;
  637.                     if((i+1 < newName.length())) {
  638.                         char cc = newName.charAt(i+1);
  639.                         if((cc == '"')) {
  640.                             startDoppieVirgolette=true;
  641.                             doppieVirgoletteIndex=i+1;
  642.                         }
  643.                     }
  644.                 }
  645.                 if((start) && (c == ')')) {
  646.                     if(!startDoppieVirgolette) {
  647.                         start = false;
  648.                     }
  649.                 }
  650.                 if((startDoppieVirgolette) && (c == '"') && doppieVirgoletteIndex!=i) {
  651.                     if((i+1 < newName.length())) {
  652.                         char cc = newName.charAt(i+1);
  653.                         if((cc == ')')) {
  654.                             startDoppieVirgolette = false;
  655.                             doppieVirgoletteIndex=i;
  656.                         }
  657.                     }
  658.                 }
  659.                 if(start && c == '.') {
  660.                     sbFormat.append('_');
  661.                 }
  662.                 else {
  663.                     sbFormat.append(c);
  664.                 }
  665.             }
  666.             newName = sbFormat.toString();
  667.             
  668.             //System.out.println("OLD ["+name+"]");
  669.             //System.out.println("NEW ["+newName+"]");
  670.             nameContainsPoint = newName.contains(".");
  671.             if(nameContainsPoint){
  672.                 fieldName = name.substring(0, newName.indexOf("."));
  673.             }
  674.             //System.out.println("fieldName ["+fieldName+"]");
  675.         }
  676.         String methodName = new String(fieldName);
  677.         //System.out.println("fieldName ["+fieldName+"]");
  678.         if(fieldName.endsWith("]") && fieldName.contains("[")){
  679.             try{
  680.                 // fix [][]
  681.                 //position = fieldName.substring(fieldName.indexOf("[")+1,fieldName.length()-1);
  682.                 String tmp = new String(fieldName);
  683.                 //System.out.println("DEBUG ["+tmp+"]");
  684.                 while(tmp.endsWith("]") && tmp.contains("[")){  
  685.                     int firstOpen = tmp.indexOf("[")+1;
  686.                     int lastOpen = tmp.indexOf("]", firstOpen);
  687.                     String position = tmp.substring(firstOpen, lastOpen);
  688.                     arrayMapPosition.add(position);
  689.                     //System.out.println("DEBUG ADD ["+position+"]");
  690.                     if(tmp.length()>(lastOpen+1)) {
  691.                         tmp = tmp.substring(lastOpen+1,tmp.length());
  692.                     }
  693.                     else {
  694.                         tmp="";
  695.                     }
  696.                     //System.out.println("DEBUG NUOVO VALORE ["+tmp+"]");
  697.                 }
  698.                 methodName = fieldName.substring(0, fieldName.indexOf("["));
  699.             }catch(Exception e){
  700.                 throw new UtilsException("Placeholder [{"+key+"}] resolution failed: position error in field ["+fieldName+"]: "+e.getMessage(),e);
  701.             }
  702.         }
  703.         //System.out.println("NAME ["+fieldName+"] position["+position+"]");
  704.         String getMethod = "get"+((methodName.charAt(0)+"").toUpperCase());
  705.         if(methodName.length()>1){
  706.             getMethod = getMethod + methodName.substring(1);
  707.         }
  708.         //System.out.println("getMethod ["+getMethod+"]");
  709.         List<String> parametersObject = null;
  710.         List<Class<?>> parametersClass = null;
  711.         try{
  712.             if(getMethod.contains("(") && getMethod.endsWith(")")) { // supporta 1 solo parametro stringa
  713.                 int startParams = getMethod.indexOf("(");
  714.                 
  715.                 String sP = getMethod.substring(startParams, getMethod.length());
  716.                 if(sP.length()>2) {
  717.                     sP = sP.substring(1, sP.length()-1);
  718.                 }
  719.                 //System.out.println("METODO getMethod["+getMethod+"] PARAMS["+sP+"] ");
  720.                 if(sP.contains(",")) {
  721.                     parametersObject = new ArrayList<>();
  722.                     parametersClass = new ArrayList<Class<?>>();
  723.                     StringBuilder sb = new StringBuilder();
  724.                     for (int i = 0; i < sP.length(); i++) {
  725.                         String sAt = sP.charAt(i)+"";
  726.                         if(sAt.equals(",")) {
  727.                             String paramString = sb.toString();
  728.                             //System.out.println("paramString '"+paramString+"'");
  729.                             if(paramString!=null && paramString.length()>=2 && paramString.startsWith("\"") && paramString.endsWith("\"")) {
  730.                                 if(paramString.length()==2) {
  731.                                     paramString = ""; // stringa vuota
  732.                                 }
  733.                                 else {
  734.                                     paramString = paramString.substring(1);
  735.                                     paramString = paramString.substring(0,paramString.length()-1);
  736.                                 }
  737.                                 //System.out.println("paramString DOPO '"+paramString+"'");
  738.                             }
  739.                             parametersObject.add(paramString); // gli spazi possono essere voluti (non fare trim)
  740.                             parametersClass.add(String.class);
  741.                             sb = new StringBuilder();
  742.                         }
  743.                         else {
  744.                             sb.append(sAt);
  745.                         }
  746.                     }
  747.                     parametersObject.add(sb.toString()); // gli spazi possono essere voluti (non fare trim)
  748.                     parametersClass.add(String.class);
  749.                 }
  750.                 else {
  751.                     parametersObject = new ArrayList<>();
  752.                     parametersClass = new ArrayList<Class<?>>();
  753.                     String paramString = sP;
  754.                     //System.out.println("paramString '"+paramString+"'");
  755.                     if(paramString!=null && paramString.length()>=2 && paramString.startsWith("\"") && paramString.endsWith("\"")) {
  756.                         if(paramString.length()==2) {
  757.                             paramString = ""; // stringa vuota
  758.                         }
  759.                         else {
  760.                             paramString = paramString.substring(1);
  761.                             paramString = paramString.substring(0,paramString.length()-1);
  762.                         }
  763.                         //System.out.println("paramString DOPO '"+paramString+"'");
  764.                     }
  765.                     parametersObject.add(paramString); // gli spazi possono essere voluti (non fare trim)
  766.                     parametersClass.add(String.class);
  767.                 }
  768.                 getMethod = getMethod.substring(0, startParams);
  769.             }
  770.         }catch(Throwable e){
  771.             throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"()] read parameter error; "+e.getMessage(),e);
  772.         }
  773.         Method m = null;
  774.         boolean withoutParams = false;
  775.         try{
  776.             if(parametersClass!=null && !parametersClass.isEmpty()) {
  777.                 m = o.getClass().getMethod(getMethod, parametersClass.toArray(new Class[1]));
  778.             }
  779.             else {
  780.                 withoutParams = true;
  781.                 m = o.getClass().getMethod(getMethod);
  782.             }
  783.         }catch(Throwable e){
  784.             
  785.             UtilsException utilsException = new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"()] not found; "+e.getMessage(),e);
  786.             
  787.             // Fix per metodi boolean 'is'
  788.             if(e instanceof java.lang.NoSuchMethodException && withoutParams) {
  789.                 try{
  790.                     String isMethod = getMethod.replaceFirst("get", "is");
  791.                     m = o.getClass().getMethod(isMethod);
  792.                     if(m!=null) {
  793.                         utilsException = null;
  794.                     }
  795.                 }catch(Throwable eIgnore){ 
  796.                     // rilancio eccezione originale
  797.                 }
  798.             }
  799.             
  800.             if(utilsException!=null && e instanceof java.lang.NoSuchMethodException && !withoutParams) {
  801.                 // Fix per metodi boolean senza 'get' o 'is' che contengono parametri
  802.                 try{
  803.                     String originalMethod = methodName;
  804.                     if(originalMethod.contains("(") && originalMethod.endsWith(")")) { // supporta 1 solo parametro stringa
  805.                         int startParams = originalMethod.indexOf("(");
  806.                         originalMethod = originalMethod.substring(0, startParams);
  807.                     }
  808.                     
  809.                     if(parametersClass!=null && !parametersClass.isEmpty()) {
  810.                         m = o.getClass().getMethod(originalMethod, parametersClass.toArray(new Class[1]));
  811.                     }
  812.                     // non si dovrebbe entrare in questo caso essendoci l'if sopra con !withoutParams
  813. //                  else {
  814. //                      m = o.getClass().getMethod(originalMethod);
  815. //                  }
  816.                     if(m!=null) {
  817.                         utilsException = null;
  818.                     }
  819.                 }catch(Throwable eIgnore){ 
  820.                     // rilancio eccezione originale
  821.                 }
  822.             }
  823.             
  824.             if(utilsException!=null) {
  825.                 throw utilsException;
  826.             }
  827.         }
  828.         String debugParameters = "";
  829.         Object ret = null;
  830.         try{
  831.             if(parametersObject!=null && !parametersObject.isEmpty()) {
  832.                 StringBuilder sb = new StringBuilder();
  833.                 for (String par : parametersObject) {
  834.                     if(sb.length()>0) {
  835.                         sb.append(",");
  836.                     }
  837.                     sb.append(par);
  838.                 }
  839.                 debugParameters=sb.toString();
  840.                 ret = m.invoke(o, parametersObject.toArray(new Object[1]));
  841.             }
  842.             else {
  843.                 ret = m.invoke(o);
  844.             }
  845.         }catch(Throwable e){
  846.             Throwable tInternal = Utilities.getInnerNotEmptyMessageException(e);
  847.             String msgErrore = tInternal!=null ? tInternal.getMessage() : e.getMessage();
  848.             throw new UtilsException("Placeholder [{"+key+"}] resolution failed: invocation method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] failed; "+msgErrore,e);
  849.         }
  850.         
  851.         if(ret!=null){
  852.             if(ret instanceof List<?> || ret instanceof Map<?,?> || ret instanceof Object[]){
  853.                 if(arrayMapPosition==null || arrayMapPosition.isEmpty()){
  854.                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return "+ret.getClass().getName()+" object without position");
  855.                 }
  856.                 while(!arrayMapPosition.isEmpty()) {
  857.                     String position = arrayMapPosition.remove(0);
  858.                     //System.out.println("ARRAY ["+ret.getClass().getName()+"]");
  859.                     if(ret instanceof List<?> || ret instanceof Object[]){
  860.                         int index = -1;
  861.                         try{
  862.                             index = Integer.parseInt(position);
  863.                         }catch(Exception e){
  864.                             throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return "+ret.getClass().getName()+" object, wrong position value (not integer?): "+e.getMessage());
  865.                         }
  866.                         if(ret instanceof List<?>){
  867.                             List<?> list = (List<?>) ret;
  868.                             if(list.size()<=index){
  869.                                 if(required) {
  870.                                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return "+ret.getClass().getName()+" object, wrong position '"+index+"' (list size:"+list.size()+")");
  871.                                 }
  872.                                 else {
  873.                                     ret = null;
  874.                                 }
  875.                             }
  876.                             else {
  877.                                 ret = list.get(index);
  878.                             }
  879.                         }
  880.                         else if(ret instanceof Object[]){
  881.                             Object[] arrayObj = (Object[]) ret;
  882.                             if(arrayObj.length<=index){
  883.                                 if(required) {
  884.                                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return "+ret.getClass().getName()+" object, wrong position '"+index+"' (array size:"+arrayObj.length+")");
  885.                                 }
  886.                                 else {
  887.                                     ret = null;
  888.                                 }
  889.                             }
  890.                             else {
  891.                                 ret = arrayObj[index];
  892.                             }
  893.                         }
  894.                     }
  895.                     else if(ret instanceof Map<?,?>){
  896.                         Map<?,?> map = (Map<?,?>) ret;
  897.                         //if(map.containsKey(position)==false){
  898.                         if(containsKey(map, position)==false) {
  899.                             if(required) {
  900.                                 throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return "+ret.getClass().getName()+" object, '"+position+"' not exists in map");
  901.                             }
  902.                             else {
  903.                                 ret = null;
  904.                             }
  905.                         }
  906.                         else {
  907.                             //ret = map.get(position);
  908.                             ret = get(map, position);
  909.                         }
  910.                     }       
  911.                 }
  912.             }
  913.         }
  914.         if(nameContainsPoint && complexField){
  915.             if(ret==null){
  916.                 if(required) {
  917.                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return null object");
  918.                 }
  919.                 else {
  920.                     return null;
  921.                 }
  922.             }
  923.             else{
  924.                 return readValueInObject(key, ret, name.substring((fieldName+".").length(), name.length()), complexField, required);
  925.             }
  926.         }
  927.         else{
  928.             // finale
  929.             if(ret!=null){
  930.                 String finalValue = null;
  931.                 if(ret instanceof Date){
  932.                     SimpleDateFormat dateformat = new SimpleDateFormat("yyyyMMdd_HHmmssSSS");
  933.                     finalValue = dateformat.format((Date)ret);
  934.                 }
  935.                 else if(ret instanceof byte[]){
  936. //                  // 1024 = 1K
  937. //                   // Visualizzo al massimo 1K
  938. //                   int max = 1 * 1024;
  939. //                   return org.openspcoop2.utils.Utilities.convertToPrintableText((byte[])ret, max);
  940.                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return object with type ["+ret.getClass().getName()+"]");
  941.                 }
  942.                 else{
  943.                     finalValue = ret.toString();
  944.                 }
  945.                 return finalValue;
  946.             }
  947.             else{
  948.                 if(required) {
  949.                     throw new UtilsException("Placeholder [{"+key+"}] resolution failed: method ["+o.getClass().getName()+"."+getMethod+"("+debugParameters+")] return null object");
  950.                 }
  951.                 else {
  952.                     return null;
  953.                 }
  954.             }
  955.         }
  956.     }
  957. }
Created with JaCoCo 0.8.8.202204050719