JsonPathExpressionEngine.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.UnsupportedEncodingException;
  25. import java.util.ArrayList;
  26. import java.util.List;
  27. import java.util.Map;

  29. import org.openspcoop2.utils.UtilsException;
  30. import org.slf4j.Logger;

  32. import com.fasterxml.jackson.databind.JsonNode;
  33. import com.fasterxml.jackson.databind.node.TextNode;
  34. import com.jayway.jsonpath.JsonPath;
  35. import com.jayway.jsonpath.spi.cache.CacheProvider;
  36. import com.jayway.jsonpath.spi.cache.NOOPCache;

  38. import net.minidev.json.JSONArray;
  39. import net.minidev.json.JSONObject;
  40. import net.minidev.json.parser.JSONParser;
  41. import net.minidev.json.parser.ParseException;

  43. /** 
  44.  * PathExpressionEngine
  45.  *
  46.  * @author Poli Andrea (apoli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class JsonPathExpressionEngine {

  52.     public static void disableCacheJsonPathEngine() {
  53.         CacheProvider.setCache(new NOOPCache());
  54.     }
  55.     
  56.     public static String getAsString(JsonNode element) {
  57.         try{
  58.             return getJsonUtils().toString(element);
  59.         }catch(Exception e){
  60.             return null;
  61.         }
  62.     }

  64.     private static JSONUtils jsonUtils;
  65.     public static synchronized void initJsonUtils() throws UtilsException {
  66.         if(jsonUtils == null) {
  67.             jsonUtils = JSONUtils.getInstance();
  68.         }
  69.     }
  70.     public static JSONUtils getJsonUtils() throws UtilsException {
  71.         if(jsonUtils == null) { 
  72.             initJsonUtils();
  73.         }
  74.         return jsonUtils;
  75.     }
  76.     
  77.     
  78.     public static JSONObject getJSONObject(InputStream is) throws JsonPathException {
  79.         if(is == null)
  80.             throw new JsonPathException("Document (InputStream) is null");

  82.         try {
  83.             return getJSONParser().parse(is, JSONObject.class);
  84.         } catch (UnsupportedEncodingException e) {
  85.             throw new JsonPathException(e.getMessage(), e);
  86.         } catch (ParseException e) {
  87.             throw new JsonPathException(e.getMessage(), e);
  88.         }
  89.     }
  90.     public static JSONArray getJSONArray(InputStream is) throws JsonPathException {
  91.         if(is == null)
  92.             throw new JsonPathException("Document (InputStream) is null");

  94.         try {
  95.             return getJSONParser().parse(is, JSONArray.class);
  96.         } catch (UnsupportedEncodingException e) {
  97.             throw new JsonPathException(e.getMessage(), e);
  98.         } catch (ParseException e) {
  99.             throw new JsonPathException(e.getMessage(), e);
  100.         }
  101.     }

  103.     public static JSONObject getJSONObject(String contenuto) throws JsonPathException {
  104.         if(contenuto == null)
  105.             throw new JsonPathException("Document (String) is null");

  107.         try {
  108.             return getJSONParser().parse(contenuto, JSONObject.class);
  109.         } catch (ParseException e) {
  110.             throw new JsonPathException(e.getMessage(), e);
  111.         }
  112.     }
  113.     public static JSONArray getJSONArray(String contenuto) throws JsonPathException {
  114.         if(contenuto == null)
  115.             throw new JsonPathException("Document (String) is null");

  117.         try {
  118.             return getJSONParser().parse(contenuto, JSONArray.class);
  119.         } catch (ParseException e) {
  120.             throw new JsonPathException(e.getMessage(), e);
  121.         }
  122.     }

  124.     public static JSONObject getJSONObject(JsonNode document) throws JsonPathException {
  125.         if(document == null)
  126.             throw new JsonPathException("Document (JsonNode) is null");

  128.         try {
  129.             return getJSONParser().parse(getAsString(document), JSONObject.class);
  130.         } catch (ParseException e) {
  131.             throw new JsonPathException(e.getMessage(), e);
  132.         }
  133.     }
  134.     public static JSONArray getJSONArray(JsonNode document) throws JsonPathException {
  135.         if(document == null)
  136.             throw new JsonPathException("Document (JsonNode) is null");

  138.         try {
  139.             return getJSONParser().parse(getAsString(document), JSONArray.class);
  140.         } catch (ParseException e) {
  141.             throw new JsonPathException(e.getMessage(), e);
  142.         }
  143.     }


  146.     // Bug: JSONParser is not thread safe!
  147. //  private static JSONParser jsonParser;
  148. //  public static synchronized void initJSONParser() {
  149. //      if(jsonParser == null) {
  150. //          jsonParser = new JSONParser(JSONParser.MODE_PERMISSIVE); 
  151. //      }
  152. //  }
  153.     public static JSONParser getJSONParser() {
  154. //      if(jsonParser == null) {
  155. //          initJSONParser();
  156. //      }
  157. //      return jsonParser;
  158.         return new JSONParser(JSONParser.MODE_PERMISSIVE); 
  159.     }

  161.     /* ---------- METODI RITORNANO STRINGHE -------------- */
  162.     
  163.     public List<String> getStringMatchPattern(JSONObject input, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  164.         if(input == null)
  165.             throw new JsonPathException("Document (JSONObject) is null");

  167.         if(pattern == null)
  168.             throw new JsonPathException("Pattern is null");

  170.         this.validate(pattern);
  171.         
  172.         try {
  173.             List<String> l = new ArrayList<>();
  174.             Object o = JsonPath.read(input, pattern);
  175.             _parseStringMatchPatternResult(o, l);
  176.             if(l==null || l.size()<=0) {
  177.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  178.             }
  179.             return l;
  180.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  181.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  182.         } catch(Exception e) {
  183.             throw new JsonPathException(e.getMessage(), e);
  184.         }
  185.     }

  187.     public List<String> getStringMatchPattern(JsonNode document, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  188.         
  189.         if(document == null)
  190.                 throw new JsonPathException("Document (JsonNode) is null");

  192.         if(pattern == null)
  193.             throw new JsonPathException("Pattern is null");

  195.         this.validate(pattern);
  196.         
  197.         try {
  198.             List<String> l = new ArrayList<>();
  199.             Object o = JsonPath.read(getAsString(document), pattern);
  200.             _parseStringMatchPatternResult(o, l);
  201.             if(l==null || l.size()<=0) {
  202.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  203.             }
  204.             return l;
  205.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  206.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  207.         } catch(Exception e) {
  208.             throw new JsonPathException(e.getMessage(), e);
  209.         }
  210.     }
  211.     
  212.     public List<String> getStringMatchPattern(InputStream is, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  213.         if(is == null)
  214.             throw new JsonPathException("Document (InputStream) is null");

  216.         if(pattern == null)
  217.             throw new JsonPathException("Pattern is null");

  219.         this.validate(pattern);
  220.         
  221.         try {
  222.             List<String> l = new ArrayList<>();
  223.             Object o = JsonPath.read(is, pattern);
  224.             _parseStringMatchPatternResult(o, l);
  225.             if(l==null || l.size()<=0) {
  226.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  227.             }
  228.             return l;
  229.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  230.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  231.         } catch(Exception e) {
  232.             throw new JsonPathException(e.getMessage(), e);
  233.         }
  234.     }
  235.     
  236.     public List<String> getStringMatchPattern(String contenuto, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  237.         if(contenuto == null)
  238.             throw new JsonPathException("Document (String) is null");

  240.         if(pattern == null)
  241.             throw new JsonPathException("Pattern is null");

  243.         this.validate(pattern);
  244.         
  245.         try {
  246.             List<String> l = new ArrayList<>();
  247.             Object o = JsonPath.read(contenuto, pattern);
  248.             _parseStringMatchPatternResult(o, l);
  249.             if(l==null || l.size()<=0) {
  250.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  251.             }
  252.             return l;
  253.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  254.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  255.         } catch(Exception e) {
  256.             throw new JsonPathException(e.getMessage(), e);
  257.         }
  258.     }
  259.     private void _parseStringMatchPatternResult(Object o, List<String> l) throws Exception {
  260.         if(o!=null) {
  261.             if(o instanceof Map<?, ?>) {
  262.                 // Lasciare questo if per formattare correttamente i nomi degli elementi tramite le utility (vedi test org.openspcoop2.pdd.core.trasformazioni.Test)
  263.                 throw new Exception("Unexpected type '"+o.getClass().getName()+"' (is instanceof Map)");
  264.             }
  265.             else if(o instanceof List) {
  266.                 List<?> lO = (List<?>) o;
  267.                 if(!lO.isEmpty()) {
  268.                     int position = 0;
  269.                     for (Object object : lO) {
  270.                         if(object!=null) {
  271.                             if(object instanceof String) {
  272.                                 l.add((String)object);
  273.                             }
  274.                             else if(object instanceof Number) {
  275.                                 l.add(object.toString());
  276.                             }
  277.                             else if(object instanceof Boolean) {
  278.                                 l.add(object.toString());
  279.                             }
  280.                             else{
  281.                                 throw new Exception("Unexpected type '"+object.getClass().getName()+"' at position "+position);
  282.                             }
  283.                         }
  284.                         position++;
  285.                     }
  286.                 }
  287.             }
  288.             else if(o instanceof String) {
  289.                 l.add((String)o);
  290.             }
  291.             else if(o instanceof Number) {
  292.                 l.add(o.toString());
  293.             }
  294.             else if(o instanceof Boolean) {
  295.                 l.add(o.toString());
  296.             }
  297.             else {
  298.                 throw new Exception("Unexpected type '"+o.getClass().getName()+"'");
  299.             }
  300.         }
  301.     }
  302.     
  303.     
  304.     /* ---------- METODI RITORNANO NUMBER -------------- */

  306.     public List<Number> getNumberMatchPattern(JSONObject input, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  307.         if(input == null)
  308.             throw new JsonPathException("Document (JSONObject) is null");

  310.         if(pattern == null)
  311.             throw new JsonPathException("Pattern is null");

  313.         this.validate(pattern);
  314.         
  315.         try {
  316.             List<Number> l = new ArrayList<Number>();
  317.             Object o = JsonPath.read(input, pattern);
  318.             _parseNumberMatchPatternResult(o, l);
  319.             if(l==null || l.size()<=0) {
  320.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  321.             }
  322.             return l;
  323.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  324.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  325.         } catch(Exception e) {
  326.             throw new JsonPathException(e.getMessage(), e);
  327.         }
  328.     }

  330.     public List<Number> getNumberMatchPattern(JsonNode document, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  331.         if(document == null)
  332.             throw new JsonPathException("Document (JsonNode) is null");

  334.         if(pattern == null)
  335.             throw new JsonPathException("Pattern is null");

  337.         this.validate(pattern);
  338.         
  339.         try {
  340.             List<Number> l = new ArrayList<Number>();
  341.             Object o = JsonPath.read(getAsString(document), pattern);
  342.             _parseNumberMatchPatternResult(o, l);
  343.             if(l==null || l.size()<=0) {
  344.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  345.             }
  346.             return l;
  347.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  348.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  349.         } catch(Exception e) {
  350.             throw new JsonPathException(e.getMessage(), e);
  351.         }
  352.     }
  353.     
  354.     public List<Number> getNumberMatchPattern(InputStream is, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  355.         if(is == null)
  356.             throw new JsonPathException("Document (InputStream) is null");

  358.         if(pattern == null)
  359.             throw new JsonPathException("Pattern is null");

  361.         this.validate(pattern);
  362.         
  363.         try {
  364.             List<Number> l = new ArrayList<Number>();
  365.             Object o = JsonPath.read(is, pattern);
  366.             _parseNumberMatchPatternResult(o, l);
  367.             if(l==null || l.size()<=0) {
  368.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  369.             }
  370.             return l;
  371.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  372.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  373.         } catch(Exception e) {
  374.             throw new JsonPathException(e.getMessage(), e);
  375.         }
  376.     }
  377.     
  378.     public List<Number> getNumberMatchPattern(String contenuto, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  379.         if(contenuto == null)
  380.             throw new JsonPathException("Document (String) is null");

  382.         if(pattern == null)
  383.             throw new JsonPathException("Pattern is null");

  385.         this.validate(pattern);
  386.         
  387.         try {
  388.             List<Number> l = new ArrayList<Number>();
  389.             Object o = JsonPath.read(contenuto, pattern);
  390.             _parseNumberMatchPatternResult(o, l);
  391.             if(l==null || l.size()<=0) {
  392.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  393.             }
  394.             return l;
  395.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  396.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  397.         }catch(Exception e) {
  398.             throw new JsonPathException(e.getMessage(), e);
  399.         }
  400.     }
  401.     
  402.     private void _parseNumberMatchPatternResult(Object o, List<Number> l) throws Exception {
  403.         if(o!=null) {
  404.             if(o instanceof List) {
  405.                 List<?> lO = (List<?>) o;
  406.                 if(!lO.isEmpty()) {
  407.                     int position = 0;
  408.                     for (Object object : lO) {
  409.                         if(object!=null) {
  410.                             if(object instanceof Number) {
  411.                                 l.add((Number)object);
  412.                             }
  413.                             else{
  414.                                 throw new Exception("Unexpected type '"+object.getClass().getName()+"' at position "+position);
  415.                             }
  416.                         }
  417.                         position++;
  418.                     }
  419.                 }
  420.             }
  421.             else if(o instanceof Number) {
  422.                 l.add((Number)o);
  423.             }
  424.             else {
  425.                 throw new Exception("Unexpected type '"+o.getClass().getName()+"'");
  426.             }
  427.         }
  428.     }
  429.     

  431.     /* ---------- METODI RITORNANO BOOLEAN -------------- */

  433.     public List<Boolean> getBooleanMatchPattern(JSONObject input, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  434.         if(input == null)
  435.             throw new JsonPathException("Document (JSONObject) is null");

  437.         if(pattern == null)
  438.             throw new JsonPathException("Pattern is null");

  440.         this.validate(pattern);
  441.         
  442.         try {
  443.             List<Boolean> l = new ArrayList<Boolean>();
  444.             Object o = JsonPath.read(input, pattern);
  445.             _parseBooleanMatchPatternResult(o, l);
  446.             if(l==null || l.size()<=0) {
  447.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  448.             }
  449.             return l;
  450.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  451.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  452.         }catch(Exception e) {
  453.             throw new JsonPathException(e.getMessage(), e);
  454.         }
  455.         
  456.     }

  458.     public List<Boolean> getBooleanMatchPattern(JsonNode document, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  459.         if(document == null)
  460.             throw new JsonPathException("Document (JsonNode) is null");

  462.         if(pattern == null)
  463.             throw new JsonPathException("Pattern is null");

  465.         this.validate(pattern);
  466.         
  467.         try {
  468.             List<Boolean> l = new ArrayList<Boolean>();
  469.             Object o = JsonPath.read(getAsString(document), pattern);
  470.             _parseBooleanMatchPatternResult(o, l);
  471.             if(l==null || l.size()<=0) {
  472.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  473.             }
  474.             return l;
  475.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  476.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  477.         }catch(Exception e) {
  478.             throw new JsonPathException(e.getMessage(), e);
  479.         }
  480.     }
  481.     
  482.     public List<Boolean> getBooleanMatchPattern(InputStream is, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  483.         if(is == null)
  484.             throw new JsonPathException("Document (InputStream) is null");

  486.         if(pattern == null)
  487.             throw new JsonPathException("Pattern is null");

  489.         this.validate(pattern);
  490.         
  491.         try {
  492.             List<Boolean> l = new ArrayList<Boolean>();
  493.             Object o = JsonPath.read(is, pattern);
  494.             _parseBooleanMatchPatternResult(o, l);
  495.             if(l==null || l.size()<=0) {
  496.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  497.             }
  498.             return l;
  499.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  500.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  501.         } catch(Exception e) {
  502.             throw new JsonPathException(e.getMessage(), e);
  503.         }
  504.     }
  505.     
  506.     public List<Boolean> getBooleanMatchPattern(String contenuto, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  507.         if(contenuto == null)
  508.             throw new JsonPathException("Document (String) is null");

  510.         if(pattern == null)
  511.             throw new JsonPathException("Pattern is null");

  513.         this.validate(pattern);
  514.         
  515.         try {
  516.             List<Boolean> l = new ArrayList<Boolean>();
  517.             Object o = JsonPath.read(contenuto, pattern);
  518.             _parseBooleanMatchPatternResult(o, l);
  519.             if(l==null || l.size()<=0) {
  520.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  521.             }
  522.             return l;
  523.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  524.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  525.         }catch(Exception e) {
  526.             throw new JsonPathException(e.getMessage(), e);
  527.         }
  528.     }
  529.     
  530.     private void _parseBooleanMatchPatternResult(Object o, List<Boolean> l) throws Exception {
  531.         if(o!=null) {
  532.             if(o instanceof List) {
  533.                 List<?> lO = (List<?>) o;
  534.                 if(!lO.isEmpty()) {
  535.                     int position = 0;
  536.                     for (Object object : lO) {
  537.                         if(object!=null) {
  538.                             if(object instanceof Boolean) {
  539.                                 l.add((Boolean)object);
  540.                             }
  541.                             else{
  542.                                 throw new Exception("Unexpected type '"+object.getClass().getName()+"' at position "+position);
  543.                             }
  544.                         }
  545.                         position++;
  546.                     }
  547.                 }
  548.             }
  549.             else if(o instanceof Boolean) {
  550.                 l.add((Boolean)o);
  551.             }
  552.             else {
  553.                 throw new Exception("Unexpected type '"+o.getClass().getName()+"'");
  554.             }
  555.         }
  556.     }
  557.     

  559.     /* ---------- METODI RITORNANO JSON NODE -------------- */

  561.     public JsonNode getJsonNodeMatchPattern(JSONObject input, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  562.         if(input == null)
  563.             throw new JsonPathException("Document (JSONObject) is null");

  565.         if(pattern == null)
  566.             throw new JsonPathException("Pattern is null");

  568.         this.validate(pattern);
  569.         
  570.         try {
  571.             Object object = JsonPath.read(input, pattern);
  572.             if(object==null) {
  573.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  574.             }
  575.             return this.convertToJsonNode(object);
  576.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  577.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  578.         }catch(Exception e) {
  579.             throw new JsonPathException(e.getMessage(), e);
  580.         }
  581.     }

  583.     public JsonNode getJsonNodeMatchPattern(JsonNode document, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  584.         if(document == null)
  585.             throw new JsonPathException("Document (JsonNode) is null");

  587.         if(pattern == null)
  588.             throw new JsonPathException("Pattern is null");
  589.         
  590.         this.validate(pattern);
  591.         
  592.         try {
  593.             String inputString = getAsString(document);
  594.             Object object = JsonPath.read(inputString, pattern);
  595.             if(object==null) {
  596.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  597.             }
  598.             return this.convertToJsonNode(object);
  599.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  600.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  601.         }catch(Exception e) {
  602.             throw new JsonPathException(e.getMessage(), e);
  603.         }
  604.     }
  605.     
  606.     public JsonNode getJsonNodeMatchPattern(InputStream is, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  607.         if(is == null)
  608.             throw new JsonPathException("Document (InputStream) is null");

  610.         if(pattern == null)
  611.             throw new JsonPathException("Pattern is null");
  612.         
  613.         this.validate(pattern);
  614.         
  615.         try {
  616.             Object object = JsonPath.read(is, pattern);
  617.             if(object==null) {
  618.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  619.             }
  620.             return this.convertToJsonNode(object);
  621.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  622.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  623.         }catch(Exception e) {
  624.             throw new JsonPathException(e.getMessage(), e);
  625.         }
  626.     }
  627.     
  628.     public JsonNode getJsonNodeMatchPattern(String contenuto, String pattern) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  629.         if(contenuto == null)
  630.             throw new JsonPathException("Document (String) is null");

  632.         if(pattern == null)
  633.             throw new JsonPathException("Pattern is null");

  635.         this.validate(pattern);
  636.         
  637.         try {
  638.             Object object = JsonPath.read(contenuto, pattern);
  639.             if(object==null) {
  640.                 throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  641.             }
  642.             return this.convertToJsonNode(object);
  643.         }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  644.             throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  645.         }catch(Exception e) {
  646.             throw new JsonPathException(e.getMessage(), e);
  647.         }

  649.     }
  650.     private JsonNode convertToJsonNode(Object object) throws UtilsException {
  651.         if(object instanceof String) {
  652.             return getJsonUtils().getAsNode("\""+((String) object)+"\"");
  653.         }
  654.         else  if(object instanceof JSONArray) {
  655.             JSONArray jsonObject = (JSONArray) object;
  656.             return getJsonUtils().getAsNode(jsonObject.toString());
  657.         }
  658.         else if(object instanceof JSONObject) {
  659.             JSONObject jsonObject = (JSONObject) object;
  660.             return getJsonUtils().getAsNode(jsonObject.toString());
  661.         }
  662.         else if(object instanceof Map<?, ?>) {
  663.             Map<?, ?> map = (Map<?, ?>) object;
  664.             return getJsonUtils().getAsNode(map);
  665.         }
  666.         else {
  667.             return getJsonUtils().getAsNode(object.toString());
  668.         }
  669.     }
  670.     

  672.     /* ---------- METODI RITORNANO OGGETTI -------------- */

  674.     public Object getMatchPattern(JSONObject input, String pattern, JsonPathReturnType returnType) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  675.         if(input == null)
  676.             throw new JsonPathException("Document (JSONObject)is null");

  678.         if(pattern == null)
  679.             throw new JsonPathException("Pattern is null");

  681.         this.validate(pattern);
  682.         
  683.         if(returnType == null)
  684.             throw new JsonPathException("JsonPathReturnType is null");

  686.         Object risposta = null;
  687.         switch(returnType) {
  688.         case STRING: 
  689.             risposta = getStringMatchPattern(input, pattern); 
  690.             break;
  691.         case NUMBER: 
  692.             risposta = getNumberMatchPattern(input, pattern);
  693.             break;
  694.         case BOOLEAN: 
  695.             risposta = getBooleanMatchPattern(input, pattern);
  696.             break;
  697.         case NODE: 
  698.             risposta = getJsonNodeMatchPattern(input, pattern);
  699.             break;
  700.         default:
  701.             try {
  702.                 risposta = JsonPath.read(input, pattern);
  703.             }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  704.                 throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  705.             }
  706.             break;
  707.         }
  708.         if(risposta==null) {
  709.             throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  710.         }
  711.         return risposta;
  712.     }
  713.     

  715.     public Object getMatchPattern(JsonNode input, String pattern, JsonPathReturnType returnType) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  716.         if(input == null)
  717.             throw new JsonPathException("Document (JsonNode)is null");

  719.         if(pattern == null)
  720.             throw new JsonPathException("Pattern is null");

  722.         this.validate(pattern);
  723.         
  724.         if(returnType == null)
  725.             throw new JsonPathException("JsonPathReturnType is null");

  727.         Object risposta = null;
  728.         String inputString = getAsString(input);
  729.         switch(returnType) {
  730.         case STRING: 
  731.             risposta = getStringMatchPattern(inputString, pattern);
  732.             break;
  733.         case NUMBER: 
  734.             risposta = getNumberMatchPattern(inputString, pattern);
  735.             break;
  736.         case BOOLEAN: 
  737.             risposta = getBooleanMatchPattern(inputString, pattern);
  738.             break;
  739.         case NODE: 
  740.             risposta = getJsonNodeMatchPattern(inputString, pattern);
  741.             break;
  742.         default:
  743.             try {
  744.                 risposta = JsonPath.read(input, pattern);
  745.             }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  746.                 throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  747.             }
  748.             break;
  749.         }
  750.         if(risposta==null) {
  751.             throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  752.         }
  753.         return risposta;
  754.     }
  755.     
  756.     public Object getMatchPattern(InputStream input, String pattern, JsonPathReturnType returnType)throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  757.         if(input == null)
  758.             throw new JsonPathException("Document (InputStream) is null");

  760.         if(pattern == null)
  761.             throw new JsonPathException("Pattern is null");

  763.         this.validate(pattern);
  764.         
  765.         if(returnType == null)
  766.             throw new JsonPathException("JsonPathReturnType is null");

  768.         Object risposta = null;
  769.         switch(returnType) {
  770.         case STRING: 
  771.             risposta = getStringMatchPattern(input, pattern);
  772.             break;
  773.         case NUMBER: 
  774.             risposta = getNumberMatchPattern(input, pattern);
  775.             break;
  776.         case BOOLEAN: 
  777.             risposta = getBooleanMatchPattern(input, pattern);
  778.             break;
  779.         case NODE: 
  780.             risposta = getJsonNodeMatchPattern(input, pattern);
  781.             break;
  782.         default:
  783.             try {
  784.                 risposta = JsonPath.read(input, pattern);
  785.             }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  786.                 throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  787.             }catch(Exception e) {
  788.                 throw new JsonPathException(e.getMessage(), e);
  789.             }
  790.             break;
  791.         }
  792.         if(risposta==null) {
  793.             throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  794.         }
  795.         return risposta;
  796.     }
  797.     
  798.     public Object getMatchPattern(String input, String pattern, JsonPathReturnType returnType) throws JsonPathException, JsonPathNotFoundException, JsonPathNotValidException {
  799.         if(input == null)
  800.             throw new JsonPathException("Document (String) is null");
  801.         
  802.         if(pattern == null)
  803.             throw new JsonPathException("Pattern is null");

  805.         this.validate(pattern);
  806.         
  807.         if(returnType == null)
  808.             throw new JsonPathException("JsonPathReturnType is null");

  810.         Object risposta = null;
  811.         switch(returnType) {
  812.         case STRING: 
  813.             risposta = getStringMatchPattern(input, pattern);
  814.             break;
  815.         case NUMBER: 
  816.             risposta = getNumberMatchPattern(input, pattern);
  817.             break;
  818.         case BOOLEAN: 
  819.             risposta = getBooleanMatchPattern(input, pattern);
  820.             break;
  821.         case NODE: 
  822.             risposta = getJsonNodeMatchPattern(input, pattern);
  823.             break;
  824.         default:
  825.             try {
  826.                 risposta = JsonPath.read(input, pattern);
  827.             }catch(com.jayway.jsonpath.PathNotFoundException notFound) {
  828.                 throw new JsonPathNotFoundException(notFound.getMessage(),notFound);
  829.             }
  830.             break;
  831.         }
  832.         if(risposta==null) {
  833.             throw new com.jayway.jsonpath.PathNotFoundException("Nessun match trovato per l'espressione jsonPath ["+pattern+"]");
  834.         }
  835.         return risposta; 
  836.     }
  837.     
  838.     
  839.     /* ---------- VALIDATORE -------------- */
  840.     
  841.     public void validate(String path) throws JsonPathNotValidException{
  842.         try {
  843.             JsonPath.compile(path);
  844.         } catch(Exception e) {
  845.             throw new JsonPathNotValidException("Validazione del jsonPath indicato ["+path+"] fallita: "+e.getMessage(),e);
  846.         }
  847.     }

  849.     
  850.     public static String extractAndConvertResultAsString(String elementJson, String pattern, Logger log) throws Exception {
  851.         List<String> l = _extractAndConvertResultAsString(elementJson, pattern, log, false);
  852.         if(l!=null && !l.isEmpty()) {
  853.             return l.get(0);
  854.         }
  855.         else {
  856.             return null;
  857.         }
  858.     }
  859.     public static List<String> extractAndConvertResultAsList(String elementJson, String pattern, Logger log) throws Exception {
  860.         return  _extractAndConvertResultAsString(elementJson, pattern, log, true);
  861.     }
  862.     private static List<String> _extractAndConvertResultAsString(String elementJson, String pattern, Logger log, boolean returnAsList) throws Exception {
  863.         
  864.         List<String> lReturn = new ArrayList<>();
  865.         
  866.         JsonPathExpressionEngine engine = new JsonPathExpressionEngine();
  867.         
  868.         Exception exceptionNodeSet = null;
  869.         try{
  870.             List<?> l = engine.getStringMatchPattern(elementJson, pattern);
  871.             if(l!=null && l.size()>0) {
  872.                 if(returnAsList) {
  873.                     for (Object s : l) {
  874.                         if(s instanceof String) {
  875.                             lReturn.add((String)s);
  876.                         }
  877.                         else if(s instanceof Map<?, ?>) {
  878.                             try {
  879.                                 Map<?,?> map = (Map<?,?>) s;
  880.                                 if(!map.isEmpty()) {
  881.                                     StringBuilder sb = new StringBuilder("{");
  882.                                     for (Object keyO : map.keySet()) {
  883.                                         if(sb.length()>1) {
  884.                                             sb.append(",");
  885.                                         }
  886.                                         //System.out.println("KEY '"+keyO+"' ("+keyO.getClass().getName()+")");
  887.                                         String key = (String) keyO;
  888.                                         sb.append("\"").append(key).append("\": ");
  889.                                         Object valueO = map.get(keyO);
  890.                                         if(valueO instanceof Boolean || 
  891.                                                 valueO instanceof Short ||
  892.                                                 valueO instanceof Integer ||
  893.                                                 valueO instanceof Long ||
  894.                                                 valueO instanceof Double ||
  895.                                                 valueO instanceof Float) {
  896.                                             sb.append(valueO);
  897.                                         }
  898.                                         else {
  899.                                             sb.append("\"").append(valueO).append("\"");
  900.                                         }
  901.                                     }
  902.                                     sb.append("}");
  903.                                     lReturn.add(sb.toString());
  904.                                 }
  905.                             }catch(Throwable t) {
  906.                                 lReturn.add(s.toString());
  907.                             }
  908.                         }
  909.                         else {
  910.                             lReturn.add(s.toString());
  911.                         }
  912.                     }
  913.                 }
  914.                 else {
  915.                     StringBuilder sbReturn = new StringBuilder();
  916. //                  if(l instanceof net.minidev.json.JSONArray) {
  917. //                      sbReturn.append("[");
  918. //                  }
  919.                     
  920.                     boolean first = true;
  921.                     for (Object s : l) {
  922.                         if(!first) {
  923.                             sbReturn.append(",");   
  924.                         }
  925.                         if(s instanceof String) {
  926.                             sbReturn.append((String)s);
  927.                         }
  928.                         else if(s instanceof Map<?, ?>) {
  929.                             try {
  930.                                 Map<?,?> map = (Map<?,?>) s;
  931.                                 if(!map.isEmpty()) {
  932.                                     StringBuilder sb = new StringBuilder("{");
  933.                                     for (Object keyO : map.keySet()) {
  934.                                         if(sb.length()>1) {
  935.                                             sb.append(",");
  936.                                         }
  937.                                         //System.out.println("KEY '"+keyO+"' ("+keyO.getClass().getName()+")");
  938.                                         String key = (String) keyO;
  939.                                         sb.append("\"").append(key).append("\": ");
  940.                                         Object valueO = map.get(keyO);
  941.                                         if(valueO instanceof Boolean || 
  942.                                                 valueO instanceof Short ||
  943.                                                 valueO instanceof Integer ||
  944.                                                 valueO instanceof Long ||
  945.                                                 valueO instanceof Double ||
  946.                                                 valueO instanceof Float) {
  947.                                             sb.append(valueO);
  948.                                         }
  949.                                         else {
  950.                                             sb.append("\"").append(valueO).append("\"");
  951.                                         }
  952.                                     }
  953.                                     sb.append("}");
  954.                                     sbReturn.append(sb.toString());
  955.                                 }
  956.                             }catch(Throwable t) {
  957.                                 sbReturn.append(s.toString());
  958.                             }
  959.                         }
  960.                         else {
  961.                             sbReturn.append(s.toString());
  962.                         }
  963.                         first=false;
  964.                     }
  965.                     
  966. //                  if(l instanceof net.minidev.json.JSONArray) {
  967. //                      sbReturn.append("]");
  968. //                  }
  969.                     lReturn.add(sbReturn.toString());
  970.                 }
  971.             }
  972.                         
  973.         }catch(Exception e){
  974.             exceptionNodeSet = e;
  975.         }
  976.             
  977.         if(lReturn.isEmpty()){
  978.             
  979.             JsonNode obj = engine.getJsonNodeMatchPattern(elementJson, pattern);
  980.             String risultato = null;
  981.             if(obj!=null) {
  982.                 if(obj instanceof TextNode) {
  983.                     TextNode text = (TextNode) obj;
  984.                     risultato = text.asText();
  985.                 }
  986.                 else {
  987.                     risultato = obj.toString();
  988.                 }
  989.             }
  990.             if(risultato!=null && risultato.startsWith("[") && risultato.endsWith("]")) {
  991.                 risultato = risultato.substring(1, risultato.length()-1);
  992.             }
  993.             if(risultato!=null && !"".equals(risultato)) {
  994.                 lReturn.add(risultato);
  995.             }
  996.             
  997.             if(exceptionNodeSet!=null){
  998.                 log.debug("Non sono stati trovati risultati tramite l'invocazione del metodo getStringMatchPattern("+pattern
  999.                         +") invocato in seguito all'errore dell'invocazione getJsonNodeMatchPattern("+
  1000.                         pattern+",NODESET): "+exceptionNodeSet.getMessage(),exceptionNodeSet);
  1001.                 // lancio questo errore.
  1002.                 // Questo errore puo' avvenire perche' ho provato a fare xpath con nodeset
  1003.                 //throw exceptionNodeSet;
  1004.             }
  1005.             
  1006.         }
  1007.         
  1008.         return lReturn;
  1009.     }
  1010. }
Created with JaCoCo 0.8.8.202204050719