JsonXmlPathExpressionEngine.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.xml2json;

  23. import java.util.List;

  25. import org.codehaus.jettison.mapped.Configuration;
  26. import org.openspcoop2.utils.json.JsonPathNotValidException;
  27. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  28. import org.openspcoop2.utils.xml.DynamicNamespaceContext;
  29. import org.openspcoop2.utils.xml.XPathExpressionEngine;
  30. import org.slf4j.Logger;

  32. import com.jayway.jsonpath.JsonPath;

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

  43.     private static final String PREFIX = "xpath ";
  44.     private static final String NAMESPACE_PREFIX = "namespace("; // namespace
  45.     private static final String NAMESPACE_END = ")";
  46.     
  47.     public static void validate(String patternParam, Logger log) throws JsonPathNotValidException {
  48.         
  49.         boolean json2Xml = false;
  50.         String pattern = patternParam;
  51.         String tipo = "Mapped";
  52.         if(patternParam!=null && patternParam.toLowerCase().startsWith(PREFIX.toLowerCase())) {
  53.             // default
  54.             json2Xml = true;
  55.             pattern = patternParam.substring(PREFIX.length());
  56.             tipo = "Mapped";
  57.         }
  58.         if(pattern==null || "".equals(pattern)) {
  59.             throw new JsonPathNotValidException("Espressione da utilizzare non fornita");
  60.         }
  61.                 
  62.         if(!json2Xml) {
  63.             try {
  64.                 JsonPath.compile(pattern);
  65.             } catch(Exception e) {
  66.                 throw new JsonPathNotValidException("Validazione del jsonPath indicato ["+pattern+"] fallita: "+e.getMessage(),e);
  67.             }
  68.         }
  69.         
  70.         else {
  71.             try {
  72.                 // Wrappo in un unico elemento radice, altrimenti la conversione xml non riesce
  73.                 
  74.                 pattern = pattern.trim();
  75.                 
  76.                 if(pattern.toLowerCase().startsWith(NAMESPACE_PREFIX)) {
  77.                     pattern = pattern.substring(NAMESPACE_PREFIX.length());
  78.                     if(!pattern.contains(NAMESPACE_END)) {
  79.                         throw new JsonPathNotValidException("Espressione '"+patternParam+"' in un formato non corretto; non è stata riscontrata la chiusura della definizione dei namespace");
  80.                     }
  81.                     int offSet = pattern.indexOf(NAMESPACE_END);
  82.                     String namespaces = pattern.substring(0, offSet);
  83.                     if(offSet<(pattern.length()-1)) {
  84.                         pattern = pattern.substring(offSet+1, pattern.length());
  85.                         pattern = pattern.trim();
  86.                     }
  87.                     else {
  88.                         pattern = null;
  89.                     }
  90.                     
  91.                     if(pattern==null || "".equals(pattern)) {
  92.                         throw new JsonPathNotValidException("Espressione '"+patternParam+"' da utilizzare non fornita dopo la dichiarazione dei namespace");
  93.                     }
  94.                     //System.out.println("NAMESPACE ["+namespaces+"]");
  95.                     //System.out.println("PATTERN ["+pattern+"]");

  97.                     if(namespaces!=null && !"".equals(namespaces)) {
  98.                         
  99.                         String [] tmp = namespaces.split(",");
  100.                         if(tmp!=null && tmp.length>0) {
  101.                             for (String namespaceDeclaration : tmp) {
  102.                                 if(namespaceDeclaration!=null && !"".equals(namespaceDeclaration)) {
  103.                                     if(!namespaceDeclaration.contains(":")) {
  104.                                         throw new JsonPathNotValidException("Espressione '"+patternParam+"' da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: atteso ':' separator. ("+namespaces+") ("+namespaceDeclaration+")");
  105.                                     }
  106.                                     else {
  107.                                         int indexOfPrefix = namespaceDeclaration.indexOf(":");
  108.                                         String prefix = namespaceDeclaration.substring(0, indexOfPrefix);
  109.                                         String uri = null;
  110.                                         if(indexOfPrefix<(namespaceDeclaration.length()-1)) {
  111.                                             uri = namespaceDeclaration.substring(indexOfPrefix+1, namespaceDeclaration.length());
  112.                                         }
  113.                                         else {
  114.                                             throw new JsonPathNotValidException("Espressione '"+patternParam+"' da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: attesa dichiarazione namespace. ("+namespaces+") ("+namespaceDeclaration+")");
  115.                                         }
  116.                                         prefix = prefix.trim();
  117.                                         uri = uri.trim();
  118.                                         if(prefix==null || "".equals(prefix)) {
  119.                                             throw new JsonPathNotValidException("Espressione '"+patternParam+"' da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: prefisso non presente. ("+namespaces+") ("+namespaceDeclaration+")");
  120.                                         }
  121.                                         if(uri==null || "".equals(uri)) {
  122.                                             throw new JsonPathNotValidException("Espressione '"+patternParam+"' da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: dichiarazione namespace non presente. ("+namespaces+") ("+namespaceDeclaration+")");
  123.                                         }
  124.                                         //System.out.println("prefix ["+prefix+"] uri["+uri+"]");
  125.                                     }
  126.                                 }
  127.                             }
  128.                         }
  129.                     }
  130.                     
  131.                 }
  132.                 
  133.                 AbstractXPathExpressionEngine engine = new XPathExpressionEngine();
  134.                 engine.validate(pattern);
  135.                 
  136.             }
  137.             catch(JsonPathNotValidException e) {
  138.                 throw e;
  139.             }
  140.             catch(Exception e) {
  141.                 throw new JsonPathNotValidException("Trasformazione json2xml '"+tipo+"' fallita: "+e.getMessage(),e);
  142.             }
  143.         }
  144.         
  145.     }
  146.     
  147.     
  148.     public static String extractAndConvertResultAsString(String elementJson, String pattern, Logger log) throws Exception {
  149.         Object o = _extractAndConvertResultAsString(elementJson, pattern, log, false);
  150.         if(o!=null) {
  151.             return (String) o;
  152.         }
  153.         return null;
  154.     }
  155.     @SuppressWarnings("unchecked")
  156.     public static List<String> extractAndConvertResultAsList(String elementJson, String pattern, Logger log) throws Exception {
  157.         Object o = _extractAndConvertResultAsString(elementJson, pattern, log, true);
  158.         if(o!=null) {
  159.             return (List<String>) o;
  160.         }
  161.         return null;
  162.     }
  163.     private static Object _extractAndConvertResultAsString(String elementJson, String patternParam, Logger log, boolean returnAsList) throws Exception {
  164.             
  165.         IJson2Xml json2Xml = null;
  166.         String pattern = patternParam;
  167.         String tipo = "Mapped";
  168.         if(patternParam!=null && patternParam.toLowerCase().startsWith(PREFIX.toLowerCase())) {
  169.             // default
  170.             json2Xml = Xml2JsonFactory.getJson2XmlMapped(new Configuration()); // gli altri tipi, jsonML e badgerFished richiedono una struttura json specifica.
  171.             pattern = patternParam.substring(PREFIX.length());
  172.             tipo = "Mapped";
  173.         }
  174.         if(pattern==null || "".equals(pattern)) {
  175.             throw new Exception("Espressione da utilizzare non fornita");
  176.         }
  177.                 
  178.         if(json2Xml!=null) {
  179.             String node = null;
  180.             DynamicNamespaceContext dnc = new DynamicNamespaceContext();        
  181.             try {
  182.                 // Wrappo in un unico elemento radice, altrimenti la conversione xml non riesce
  183.                 String elementJsonWrapped = "{ \"json2xml\" : "+elementJson+" }";               
  184.                 node = json2Xml.json2xml(elementJsonWrapped);
  185.                 if(node==null || "".equals(node)) {
  186.                     throw new Exception("xml element ottenuto è vuoto");
  187.                 }
  188.                 pattern = pattern.trim();
  189.                 String namespaces = null;
  190.                 StringBuilder sbNamespaceDeclarations = new StringBuilder("");
  191.                 if(pattern.toLowerCase().startsWith(NAMESPACE_PREFIX)) {
  192.                     pattern = pattern.substring(NAMESPACE_PREFIX.length());
  193.                     if(!pattern.contains(NAMESPACE_END)) {
  194.                         throw new Exception("Espressione in un formato non corretto; non è stata riscontrata la chiusura della definizione dei namespace");
  195.                     }
  196.                     int offSet = pattern.indexOf(NAMESPACE_END);
  197.                     namespaces = pattern.substring(0, offSet);
  198.                     if(offSet<(pattern.length()-1)) {
  199.                         pattern = pattern.substring(offSet+1, pattern.length());
  200.                         pattern = pattern.trim();
  201.                     }
  202.                     else {
  203.                         pattern = null;
  204.                     }
  205.                     
  206.                     if(pattern==null || "".equals(pattern)) {
  207.                         throw new Exception("Espressione da utilizzare non fornita dopo la dichiarazione dei namespace");
  208.                     }
  209.                     //System.out.println("NAMESPACE ["+namespaces+"]");
  210.                     //System.out.println("PATTERN ["+pattern+"]");
  211.                     
  212.                     String newNameXmlns = "___xmlns";
  213.                     boolean foundXmlns = false;
  214.                     boolean foundDeclXmlns = false;
  215.                     if(node.contains("<xmlns:")) {
  216.                         foundXmlns = true;
  217.                         node = node.replaceAll("<xmlns:", "<"+newNameXmlns+":");
  218.                         node = node.replaceAll("</xmlns:", "</"+newNameXmlns+":");
  219.                     }
  220.                     
  221.                     if(namespaces!=null && !"".equals(namespaces)) {
  222.                         
  223.                         String [] tmp = namespaces.split(",");
  224.                         if(tmp!=null && tmp.length>0) {
  225.                             for (String namespaceDeclaration : tmp) {
  226.                                 if(namespaceDeclaration!=null && !"".equals(namespaceDeclaration)) {
  227.                                     if(!namespaceDeclaration.contains(":")) {
  228.                                         throw new Exception("Espressione da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: atteso ':' separator. ("+namespaces+") ("+namespaceDeclaration+")");
  229.                                     }
  230.                                     else {
  231.                                         int indexOfPrefix = namespaceDeclaration.indexOf(":");
  232.                                         String prefix = namespaceDeclaration.substring(0, indexOfPrefix);
  233.                                         String uri = null;
  234.                                         if(indexOfPrefix<(namespaceDeclaration.length()-1)) {
  235.                                             uri = namespaceDeclaration.substring(indexOfPrefix+1, namespaceDeclaration.length());
  236.                                         }
  237.                                         else {
  238.                                             throw new Exception("Espressione da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: attesa dichiarazione namespace. ("+namespaces+") ("+namespaceDeclaration+")");
  239.                                         }
  240.                                         prefix = prefix.trim();
  241.                                         uri = uri.trim();
  242.                                         if(prefix==null || "".equals(prefix)) {
  243.                                             throw new Exception("Espressione da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: prefisso non presente. ("+namespaces+") ("+namespaceDeclaration+")");
  244.                                         }
  245.                                         if(uri==null || "".equals(uri)) {
  246.                                             throw new Exception("Espressione da utilizzare non corretta; dichiarazione dei namespace in un formato non corretto: dichiarazione namespace non presente. ("+namespaces+") ("+namespaceDeclaration+")");
  247.                                         }
  248.                                         //System.out.println("prefix ["+prefix+"] uri["+uri+"]");
  249.                                         if(prefix.equals("xmlns")) {
  250.                                             prefix = newNameXmlns;
  251.                                             foundDeclXmlns = true;
  252.                                         }
  253.                                         dnc.addNamespace(prefix, uri);
  254.                                         sbNamespaceDeclarations.append(" xmlns:").append(prefix).append("=\"").append(uri).append("\" ");
  255.                                     }
  256.                                 }
  257.                             }
  258.                         }
  259.                     }
  260.                     
  261.                     if(foundXmlns && !foundDeclXmlns) {
  262.                         String prefix = newNameXmlns;
  263.                         String uri = "http://govway.org/utils/json2xml/xmlns";
  264.                         dnc.addNamespace(prefix, uri);
  265.                         sbNamespaceDeclarations.append(" xmlns:").append(prefix).append("=\"").append(uri).append("\" ");
  266.                     }
  267.                     
  268.                 }
  269.                 
  270.                 if(sbNamespaceDeclarations!=null && sbNamespaceDeclarations.length()>0) {
  271.                     node = node.replaceFirst("<json2xml>", ("<json2xml"+sbNamespaceDeclarations+">"));
  272.                 }
  273.                 
  274.             }catch(Exception e) {
  275.                 throw new Exception("Trasformazione json2xml '"+tipo+"' fallita: "+e.getMessage(),e);
  276.             }
  277.             try {       
  278.                 // NOTA: e' importante invocarlo con il corretto metodo
  279.                 XPathExpressionEngine xPathEngine = new XPathExpressionEngine();
  280.                 if(returnAsList) {
  281.                     return AbstractXPathExpressionEngine.extractAndConvertResultAsList(node, dnc, xPathEngine, pattern, log);
  282.                 }
  283.                 else {
  284.                     return AbstractXPathExpressionEngine.extractAndConvertResultAsString(node, dnc, xPathEngine, pattern, log);
  285.                 }
  286.             }catch(Exception e) {
  287.                 throw new Exception("Trasformazione json2xml '"+tipo+"' fallita: "+e.getMessage()+"\nXml: \n"+node,e);
  288.             }
  289.         }
  290.         
  291.         if(returnAsList) {
  292.             return org.openspcoop2.utils.json.JsonPathExpressionEngine.extractAndConvertResultAsList(elementJson, pattern, log);
  293.         }
  294.         else {
  295.             return org.openspcoop2.utils.json.JsonPathExpressionEngine.extractAndConvertResultAsString(elementJson, pattern, log);
  296.         }
  297.     }
  298. }
Created with JaCoCo 0.8.8.202204050719