AbstractXPathExpressionEngine.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.  */


  22. package org.openspcoop2.utils.xml;

  24. import java.io.Reader;
  25. import java.io.StringReader;
  26. import java.util.ArrayList;
  27. import java.util.Enumeration;
  28. import java.util.List;

  30. import javax.xml.soap.SOAPElement;

  32. import org.openspcoop2.utils.LoggerWrapperFactory;
  33. import org.openspcoop2.utils.SemaphoreLock;
  34. import org.openspcoop2.utils.Utilities;
  35. import org.openspcoop2.utils.UtilsException;
  36. import org.openspcoop2.utils.UtilsMultiException;
  37. import org.slf4j.Logger;
  38. import org.w3c.dom.Attr;
  39. import org.w3c.dom.CharacterData;
  40. import org.w3c.dom.Comment;
  41. import org.w3c.dom.Document;
  42. import org.w3c.dom.Element;
  43. import org.w3c.dom.EntityReference;
  44. import org.w3c.dom.NamedNodeMap;
  45. import org.w3c.dom.Node;
  46. import org.w3c.dom.NodeList;

  48. /**
  49.  * Classe utilizzabile per ricerche effettuate tramite espressioni XPath
  50.  *
  51.  * @author Andrea Poli (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */

  56. public abstract class AbstractXPathExpressionEngine {

  58.     
  59.     
  60.     private static Logger logger = LoggerWrapperFactory.getLogger(AbstractXPathExpressionEngine.class);
  61.     public static void setLogger(Logger logger) {
  62.         AbstractXPathExpressionEngine.logger = logger;
  63.     }
  64.     
  65.     
  66.     /*
  67.    
  68.     Per la sintassi vedi: http://www.w3.org/TR/xpath

  70.     Esempio1: /rubrica/persone/nome/text()
  71.     restituisce il valore del tag nome partendo dalla radice del xml (path assoluto)

  73.     Esempio2:
  74.     //nome/text()
  75.     restituisce il valore del tag nome (path relativo)

  77.     Esempio3
  78.     /rubrica/persone/* /text() 
  79.     restituisce il valore di tutti i nodi figli del tag persone

  81.     Esempio4
  82.     //citta/@targa
  83.     restituisce per ogni tag citta il valore dell'attributo targa

  85.     Esempio5
  86.     //persona[position()=3]/text()
  87.     restituisce il terzo nodo persona

  89.     Esempio6
  90.     //citta[@targa='mi']/text()
  91.     restituisce il valore della citta che ha come valore dell'attributo targa, mi
  92.     
  93.     Esempio7
  94.     http://saxon.sourceforge.net/saxon6.5.3/expressions.html
  95.     Ci sono le funzioni per content based
  96.       substring-after(name(//soap:Body/*),":")
  97.     Prende il nome dell'elemento dopo il Body. Sbustring per non prendere il namespace
  98.     Devono essere usati per il nome di un elemento.
  99.     
  100.     Altri esempi per avere il nome del primo child.
  101.     Il piu' corretto e' il seguente, il quale non richiede di conoscere ne namespace del soap envelope, ne namespace del primo child, e funziona sia che il child possiede che non possieda un prefix:*/
  102.     // Viene preso il local name del primo elemento figlio dell'ultimo figlio dell'envelope. L'ultimo figlio dell'envelope e' chiaramente il Body (per evitare casi in cui nel messaggio vi sia l'header)
  103.     //ESPRESSIONE:  local-name(/*/*[last()]/*)
  104.     
  105.     // Anche la seguente funziona per trovare il child pero' funziona SOLO se il child possiede un prefix.
  106.     // substring-after(name(/*/*[last()]/*),&#34;:&#34;)
  107.     
  108.     /*
  109.     Esempio8
  110.     Per concatenare piu' risultati
  111.     concat(//citta[@targa='mi']/text(),//citta[@targa='bo']/text())
  112.     */
  113.     
  114.     // Altri esempi:
  115.     // http://msdn.microsoft.com/en-us/library/ms256086.aspx
  116.     
  117.     
  118.     /* ---------- METODI RITORNANO STRINGHE -------------- */
  119.     
  120.     /**
  121.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  122.      * 
  123.      * @param element Elemento SOAP da cui estrarre l'oggetto
  124.      * @param dnc DynamicNamespaceContext 
  125.      * @param pattern Pattern che identifica l'oggetto
  126.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  127.      * @throws XPathException
  128.      * @throws XPathNotFoundException
  129.      */
  130.     public String getStringMatchPattern(SOAPElement element, DynamicNamespaceContext dnc,String pattern) 
  131.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  132.         return (String) this.getMatchPattern(element, dnc, pattern, XPathReturnType.STRING);
  133.     }
  134.     
  135.     /**
  136.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  137.      * 
  138.      * @param document Document da cui estrarre l'oggetto
  139.      * @param dnc DynamicNamespaceContext 
  140.      * @param pattern Pattern che identifica l'oggetto
  141.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  142.      * @throws XPathException
  143.      * @throws XPathNotFoundException
  144.      */
  145.     public String getStringMatchPattern(Document document, DynamicNamespaceContext dnc,String pattern) 
  146.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  147.         return (String) this.getMatchPattern(document.getDocumentElement(), dnc, pattern, XPathReturnType.STRING);
  148.     }
  149.     
  150.     /**
  151.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  152.      * 
  153.      * @param element Elemento da cui estrarre l'oggetto
  154.      * @param dnc DynamicNamespaceContext 
  155.      * @param pattern Pattern che identifica l'oggetto
  156.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  157.      * @throws XPathException
  158.      * @throws XPathNotFoundException
  159.      */
  160.     public String getStringMatchPattern(Element element, DynamicNamespaceContext dnc,String pattern) 
  161.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  162.         return (String) this.getMatchPattern(element, dnc, pattern, XPathReturnType.STRING);
  163.     }
  164.     
  165.     /**
  166.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  167.      * 
  168.      * @param contenuto Contenuto da cui estrarre l'oggetto
  169.      * @param dnc DynamicNamespaceContext 
  170.      * @param pattern Pattern che identifica l'oggetto
  171.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  172.      * @throws XPathException
  173.      * @throws XPathNotFoundException
  174.      */
  175.     public String getStringMatchPattern(String contenuto, DynamicNamespaceContext dnc,String pattern) 
  176.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  177.         return (String) this.getMatchPattern(contenuto, dnc, pattern, XPathReturnType.STRING);
  178.     }
  179.     
  180.     
  181.     
  182.     /* ---------- METODI GENERICI -------------- */
  183.     
  184.     public abstract String getAsString(SOAPElement element);
  185.     public abstract AbstractXMLUtils getXMLUtils();
  186.     
  187.     /**
  188.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  189.      * 
  190.      * @param element Elemento SOAP da cui estrarre l'oggetto
  191.      * @param dnc DynamicNamespaceContext 
  192.      * @param pattern Pattern che identifica l'oggetto
  193.      * @param returnType Tipo dell'oggetto ritornato
  194.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  195.      * @throws XPathException
  196.      * @throws XPathNotFoundException
  197.      */
  198.     public Object getMatchPattern(SOAPElement element, DynamicNamespaceContext dnc,String pattern, XPathReturnType returnType) 
  199.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  200.         
  201.         if(element==null)
  202.             throw new XPathException("element xml undefined");
  203.         
  204.         return this._engine_getMatchPattern(element, null, dnc, pattern, returnType);
  205.     }
  206.     
  207.     /**
  208.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  209.      * 
  210.      * @param document Document da cui estrarre l'oggetto
  211.      * @param dnc DynamicNamespaceContext 
  212.      * @param pattern Pattern che identifica l'oggetto
  213.      * @param returnType Tipo dell'oggetto ritornato
  214.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  215.      * @throws XPathException
  216.      * @throws XPathNotFoundException
  217.      */
  218.     public Object getMatchPattern(Document document, DynamicNamespaceContext dnc,String pattern, XPathReturnType returnType) 
  219.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  220.         
  221.         if(document==null)
  222.             throw new XPathException("document xml undefined");
  223.         if(document.getDocumentElement()==null)
  224.             throw new XPathException("document.element xml undefined");
  225.         
  226.         return this._engine_getMatchPattern(document.getDocumentElement(), null, dnc, pattern, returnType);
  227.         
  228.     }
  229.     
  230.     /**
  231.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  232.      * 
  233.      * @param element Elemento da cui estrarre l'oggetto
  234.      * @param dnc DynamicNamespaceContext 
  235.      * @param pattern Pattern che identifica l'oggetto
  236.      * @param returnType Tipo dell'oggetto ritornato
  237.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  238.      * @throws XPathException
  239.      * @throws XPathNotFoundException
  240.      */
  241.     public Object getMatchPattern(Element element, DynamicNamespaceContext dnc,String pattern, XPathReturnType returnType) 
  242.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  243.         
  244.         if(element==null)
  245.             throw new XPathException("element xml undefined");
  246.         
  247.         return this._engine_getMatchPattern(element, null, dnc, pattern, returnType);
  248.     }
  249.     
  250.     /**
  251.      * Estrae dal contenuto passato come parametro, l'oggetto identificato dal parametro pattern e dal tipo returnType
  252.      * 
  253.      * @param content Contenuto da cui estrarre l'oggetto
  254.      * @param dnc DynamicNamespaceContext 
  255.      * @param pattern Pattern che identifica l'oggetto
  256.      * @param returnType Tipo dell'oggetto ritornato
  257.      * @return Oggetto identificato dal parametro pattern e dal tipo returnType
  258.      * @throws XPathException
  259.      * @throws XPathNotFoundException
  260.      */
  261.     public Object getMatchPattern(String content, DynamicNamespaceContext dnc,String pattern, XPathReturnType returnType) 
  262.         throws XPathException,XPathNotFoundException,XPathNotValidException{
  263.         
  264.         if(content==null)
  265.             throw new XPathException("content undefined");
  266.         
  267.         return this._engine_getMatchPattern(null, content, dnc, pattern, returnType);
  268.         
  269.     }
  270.     
  271.     
  272.     
  273.     /* ---------- ENGINE -------------- */
  274.     
  275.     public abstract Element readXPathElement(Element contenutoAsElement);
  276.     
  277.     //private static Integer synchronizedObjectForBugFWK005ParseXerces = Integer.valueOf(1); // vedi test TestBugFWK005ParseXerces 
  278.     private static final org.openspcoop2.utils.Semaphore lockObjectForBugFWK005ParseXerces = new org.openspcoop2.utils.Semaphore("BugFWK005ParseXerces");
  279.     private Object _engine_getMatchPattern(
  280.             Element contenutoAsElement, String contenutoAsString, 
  281.             DynamicNamespaceContext dncPrivate,String pattern, XPathReturnType returnType) 
  282.             throws XPathException,XPathNotFoundException,XPathNotValidException{

  284.         if( (pattern == null) || (pattern.length() == 0))
  285.             throw new XPathNotFoundException("Pattern di ricerca non fornito");
  286.         if(contenutoAsElement == null && contenutoAsString==null)
  287.             throw new XPathNotFoundException("Contenuto su cui effettuare la ricerca non fornito");
  288.         if(contenutoAsElement != null && contenutoAsString!=null)
  289.             throw new XPathNotFoundException("Contenuto su cui effettuare la ricerca ambiguo");

  291.         
  292.         // Validazione espressione XPAth fornita
  293.         pattern = pattern.trim();
  294.         this.validate(pattern); 
  295.         
  296.         
  297.         try{
  298.             
  299.             // 1. Instantiate an XPathFactory.
  300.             javax.xml.xpath.XPathFactory factory = this.getXMLUtils().getXPathFactory();
  301.     
  302.             // 2. Use the XPathFactory to create a new XPath object
  303.             javax.xml.xpath.XPath xpath = factory.newXPath();
  304.             if(xpath==null){
  305.                 throw new Exception("Costruzione xpath non riuscita");
  306.             }
  307.             
  308.             // 3. Set the Namespaces
  309.             
  310.             // 3.1. Clone dnc, verra' modificato in convertNamespaces
  311.             DynamicNamespaceContext dnc = null;
  312.             if(dncPrivate!=null){
  313.                 dnc = (DynamicNamespaceContext) dncPrivate.clone();
  314.             }
  315.             
  316.             // 3.2 // Risoluzione namespace {http:///}
  317.             // NOTA: da utilizzare con {http://namespace}localName 
  318.             // BugFix: se per errore viene utilizzato {http://namespace}:localName prima di effettuare la risoluzione del namespace viene eliminato il ':'
  319.             if(dnc!=null){
  320.                 pattern = pattern.replaceAll("}:", "}");
  321.                 pattern = this.convertNamespaces(pattern, dnc);
  322.             }
  323.             //System.out.println("PATTERN: ["+pattern+"]");

  325.             // 3.3 set dnc in xpath
  326.             if(dnc!=null)
  327.                 xpath.setNamespaceContext(dnc);
  328.             
  329.             // 3.4
  330.             // Bug fix: se il contenuto possiede una namespace associato al prefix di default, poi l'xpath engine non trova l'elemento.
  331.             // es. <prova xmlns="www.namespace">TEST</prova> con xpath /prova/text() non funziona.
  332. //          if(dnc.getNamespaceURI(javax.xml.XMLConstants.DEFAULT_NS_PREFIX).equals(javax.xml.XMLConstants.NULL_NS_URI) == false ){
  333. //              //System.out.println("PATCH CONTENUTO PER NAMESPACE DEFAULT: "+dnc.getNamespaceURI(javax.xml.XMLConstants.DEFAULT_NS_PREFIX));
  334. //              contenuto = contenuto.replace("xmlns=\""+dnc.getNamespaceURI(javax.xml.XMLConstants.DEFAULT_NS_PREFIX)+"\"", "");
  335. //          }   
  336.             // !!!! NOTA Il fix sopra indicato non era corretto.
  337.             // e' giusto che non lo trova se viene fornito un xpath senza prefisso, poiche' si sta cercando un elemento che non appartiene a nessun namespace.
  338.             // L'xpath sopra funzionera' su un xml definito come <prova>TEST</prova>
  339.             //
  340.             // Ulteriore spiegazione:
  341.             // But since the nodes you are trying to get use a default namespace, without a prefix, using plain XPath, 
  342.             // you can only access them by the local-name() and namespace-uri() attributes. Examples:
  343.             // *[local-name()="HelloWorldResult"]/text()
  344.             // Or:
  345.             // *[local-name()="HelloWorldResult" and namespace-uri()='http://tempuri.org/']/text()
  346.             // Or:
  347.             //*[local-name()="HelloWorldResponse" and namespace-uri()='http://tempuri.org/']/*[
  348.             //
  349.             // Siccome la modalita' di utilizzare il local-name e il namespace-uri in un xpath e' elaborioso, abbiamo aggiunto in openspcoop2
  350.             // la possibilita' di indicare il namespace {namespace} che verra' convertito in un prefix interno utile al funzionamento dell'xpath.
  351.             // Il pattern da fornire  che funziona sull'xml indicato sopra e' /{www.namespace}prova/text()
  352.             // Per ulteriori dettagli vedi metodo convertNamespaces utilizzato in 3.2, all'interno del metodo viene fornita una descrizione dettagliata.
  353.             
  354.                 
  355.             // Concatenazione openspcoop.
  356.             if(pattern.startsWith("concat_openspcoop") && pattern.endsWith(")")){
  357.                 
  358.                 // Check compatibilita' concat_openspcoop
  359.                 if(returnType.equals(XPathReturnType.STRING)==false){
  360.                     throw new XPathException("Funzione concat_openspcoop non compatibile con un tipo di ritorno: "+returnType.toString());
  361.                 }
  362.                 
  363.                 // Fix , la funzione concat non ritorna eccezione se non riesce a risolvere qualche espressione, e contiene cmq delle costanti.
  364.                 // La concatenazione openspcoop, invece ritornera' errore.
  365.                 String param = pattern.substring("concat_openspcoop(".length(),pattern.length()-1);
  366.                 String [] params =param.split(",");
  367.                 StringBuilder bfResult = new StringBuilder();
  368.                 for(int i=0; i<params.length;i++){
  369.                     
  370.                     // Check se abbiamo una costante od una espressione da valutare
  371.                     if(params[i].startsWith("\"") && params[i].endsWith("\"")){
  372.                     
  373.                         // COSTANTE
  374.                         bfResult.append(params[i].substring(1,(params[i].length()-1)));
  375.                     
  376.                     }else{
  377.                         
  378.                         // 4. Reader
  379.                         Reader reader = null;
  380.                         if(contenutoAsString!=null){
  381.                             try{
  382.                                 reader = new StringReader(contenutoAsString);
  383.                             }catch(Exception e){
  384.                                 try{
  385.                                     if( reader != null )
  386.                                         reader.close();
  387.                                 } catch(Exception er) {
  388.                                     // close
  389.                                 }
  390.                                 throw e;
  391.                             }       
  392.                         }
  393.                         
  394.                         // ESPRESSIONE
  395.                         // 5. Compile an XPath string into an XPathExpression
  396.                         javax.xml.xpath.XPathExpression expression = null;
  397.                         try{
  398.                             expression = xpath.compile(params[i]);
  399.                         }catch(Exception e){
  400.                             if(Utilities.existsInnerMessageException(e, "Prefix must resolve to a namespace", true)){
  401.                                 // e' stato usato un prefisso nell'espressione XPath che non e' risolvibile accedendo ai namespaces del messaggio (dnc)
  402.                                 throw new XPathNotFoundException("Espressione XPATH contenuta in concat_openspcoop ("+params[i]+") non applicabile al messaggio: "+Utilities.getInnerMessageException(e, "Prefix must resolve to a namespace", true));
  403.                             }
  404.                             else if(Utilities.existsInnerException(e,javax.xml.transform.TransformerException.class)){
  405.                                 throw new Exception("Compilazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+Utilities.getInnerException(e, javax.xml.transform.TransformerException.class).getMessage()+")",e);
  406.                             }else{
  407.                                 if(e.getCause()!=null){
  408.                                     throw new Exception("Compilazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+(Utilities.getLastInnerException(e.getCause())).getMessage()+")",e);
  409.                                 }else{
  410.                                     throw new Exception("Compilazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+e.getMessage()+")",e);
  411.                                 }
  412.                             }   
  413.                         }
  414.                         if(expression==null){
  415.                             throw new Exception("Costruzione XPathExpression non riuscita per espressione contenuta in concat_openspcoop ("+params[i]+")");
  416.                         }
  417.                 
  418.                                                 
  419.                         // 6. Evaluate the XPath expression on an input document
  420.                         String result = null;
  421.                         try{
  422.                             if(reader!=null) {
  423.                                 //synchronized (AbstractXPathExpressionEngine.synchronizedObjectForBugFWK005ParseXerces) { // vedi test TestBugFWK005ParseXerces
  424.                                 SemaphoreLock lock = lockObjectForBugFWK005ParseXerces.acquire("concat_openspcoopEvaluate");
  425.                                 try {
  426.                                     result = expression.evaluate(new org.xml.sax.InputSource(reader));
  427.                                 }finally {
  428.                                     lockObjectForBugFWK005ParseXerces.release(lock, "concat_openspcoopEvaluate");
  429.                                 }
  430.                             }
  431.                             else { 
  432.                                 result = expression.evaluate(this.readXPathElement(contenutoAsElement));
  433.                             }
  434.                         }catch(Exception e){
  435.                             if(Utilities.existsInnerException(e,"com.sun.org.apache.xpath.internal.XPathException")){
  436.                                 throw new Exception("Valutazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+Utilities.getInnerException(e, "com.sun.org.apache.xpath.internal.XPathException").getMessage()+")",e);
  437.                             }
  438.                             else if(Utilities.existsInnerException(e,org.apache.xpath.XPathException.class)){
  439.                                 throw new Exception("Valutazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+Utilities.getInnerException(e, org.apache.xpath.XPathException.class).getMessage()+")",e);
  440.                             }
  441.                             else{
  442.                                 if(e.getCause()!=null){
  443.                                     throw new Exception("Valutazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+(Utilities.getLastInnerException(e.getCause())).getMessage()+")",e);
  444.                                 }else{
  445.                                     throw new Exception("Valutazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+e.getMessage()+")",e);
  446.                                 }
  447.                             }
  448.                         }
  449.                         if(reader!=null)
  450.                             reader.close();
  451.                 
  452.                         if(result == null || "".equals(result)){
  453.                             // DEVE ESSERE LANCIATA ECCEZIONE, E' PROPRIO LA FUNZIONALITA DI OPENSPCOOP!
  454.                             // Il Concat normale non lancia eccezione e ritorna stringa vuota.
  455.                             // Verificato con cxf soap engine
  456.                             AbstractXPathExpressionEngine.logger.debug("nessun match trovato per l'espressione xpath contenuta in concat_openspcoop ("+params[i]+")");
  457.                             throw new XPathNotFoundException("nessun match trovato per l'espressione xpath contenuta in concat_openspcoop ("+params[i]+")");
  458.                         }
  459.                         else{
  460.                             bfResult.append(result);
  461.                         }
  462.                     }
  463.                 }
  464.                 
  465.                 if(bfResult.length()<=0){
  466.                     StringBuilder bfDNC = new StringBuilder();
  467.                     Enumeration<?> en = dnc.getPrefixes();
  468.                     while (en.hasMoreElements()) {
  469.                         String prefix = (String) en.nextElement();
  470.                         bfDNC.append("\n\t- ");
  471.                         bfDNC.append("[").append(prefix).append("]=[").append(dnc.getNamespaceURI(prefix)).append("]");
  472.                     }
  473.                     throw new XPathNotFoundException("nessun match trovato per l'espressione xpath (concat_openspcoop) ["+pattern+"] DynamicNamespaceContext:"+bfDNC.toString());
  474.                     
  475.                 }else{
  476.                     return bfResult.toString();
  477.                 }

  479.             }else{
  480.                 
  481.                 // 4. Reader
  482.                 Reader reader = null;
  483.                 if(contenutoAsString!=null){
  484.                     try{
  485.                         reader = new StringReader(contenutoAsString);
  486.                     }catch(Exception e){
  487.                         try{
  488.                             if( reader != null )
  489.                                 reader.close();
  490.                         } catch(Exception er) {
  491.                             // close
  492.                         }
  493.                         throw e;
  494.                     }       
  495.                 }
  496.                 
  497.                 
  498.                 // 5. Compile an XPath string into an XPathExpression
  499.                 javax.xml.xpath.XPathExpression expression = null;
  500.                 try{
  501.                     expression = xpath.compile(pattern);
  502.                 }catch(Exception e){
  503.                     if(Utilities.existsInnerMessageException(e, "Prefix must resolve to a namespace", true)){
  504.                         // e' stato usato un prefisso nell'espressione XPath che non e' risolvibile accedendo ai namespaces del messaggio (dnc)
  505.                         throw new XPathNotFoundException("Espressione XPATH non applicabile al messaggio: "+Utilities.getInnerMessageException(e, "Prefix must resolve to a namespace", true));
  506.                     }
  507.                     else if(Utilities.existsInnerException(e,javax.xml.transform.TransformerException.class)){
  508.                         throw new Exception("Compilazione dell'espressione XPATH ha causato un errore ("+Utilities.getInnerException(e, javax.xml.transform.TransformerException.class).getMessage()+")",e);
  509.                     }else{
  510.                         if(e.getCause()!=null){
  511.                             throw new Exception("Compilazione dell'espressione XPATH ha causato un errore ("+(Utilities.getLastInnerException(e.getCause())).getMessage()+")",e);
  512.                         }else{
  513.                             throw new Exception("Compilazione dell'espressione XPATH ha causato un errore ("+e.getMessage()+")",e);
  514.                         }
  515.                     }
  516.                 }
  517.                 if(expression==null){
  518.                     throw new Exception("Costruzione XPathExpression non riuscita");
  519.                 }
  520.         
  521.                 // 6. Evaluate the XPath expression on an input document
  522.                 Object result = null;
  523.                 try{
  524.                     if(reader!=null) {
  525.                         //synchronized (AbstractXPathExpressionEngine.synchronizedObjectForBugFWK005ParseXerces) { // vedi test TestBugFWK005ParseXerces
  526.                         SemaphoreLock lock = lockObjectForBugFWK005ParseXerces.acquire("standardEvaluate");
  527.                         try {
  528.                             result = expression.evaluate(new org.xml.sax.InputSource(reader),returnType.getValore());
  529.                         }finally {
  530.                             lockObjectForBugFWK005ParseXerces.release(lock, "standardEvaluate");
  531.                         }
  532.                     }else{
  533.                         result = expression.evaluate(this.readXPathElement(contenutoAsElement),returnType.getValore());
  534.                     }
  535.                 }catch(Exception e){
  536.                     if(Utilities.existsInnerException(e,"com.sun.org.apache.xpath.internal.XPathException")){
  537.                         throw new Exception("Valutazione dell'espressione XPATH ha causato un errore ("+Utilities.getInnerException(e, "com.sun.org.apache.xpath.internal.XPathException").getMessage()+")",e);
  538.                     }
  539.                     else if(Utilities.existsInnerException(e,org.apache.xpath.XPathException.class)){
  540.                         throw new Exception("Valutazione dell'espressione XPATH ha causato un errore ("+Utilities.getInnerException(e, org.apache.xpath.XPathException.class).getMessage()+")",e);
  541.                     }
  542.                     else{
  543.                         if(e.getCause()!=null){
  544.                             throw new Exception("Valutazione dell'espressione XPATH ha causato un errore ("+(Utilities.getLastInnerException(e.getCause())).getMessage()+")",e);
  545.                         }else{
  546.                             throw new Exception("Valutazione dell'espressione XPATH ha causato un errore ("+e.getMessage()+")",e);
  547.                         }
  548.                     }
  549.                 }
  550.                 if(reader!=null)
  551.                     reader.close();
  552.         
  553.                 boolean notFound = false;
  554.                 if(result == null){
  555.                     notFound = true;
  556.                 }
  557.                 else if(result instanceof String){
  558.                     if("".equals(result)){
  559.                         notFound = true;
  560.                     }
  561.                 }
  562.                 else if( (XPathReturnType.NODESET.equals(returnType)) && (result instanceof NodeList)){
  563.                     if(((NodeList)result).getLength()<=0){
  564.                         notFound=true;
  565.                     }
  566.                 }
  567.                 
  568.                 if(notFound){
  569.                     //log.info("ContentBased, nessun match trovato");
  570.                     StringBuilder bfDNC = new StringBuilder();
  571.                     Enumeration<?> en = dnc.getPrefixes();
  572.                     while (en.hasMoreElements()) {
  573.                         String prefix = (String) en.nextElement();
  574.                         bfDNC.append("\n\t- ");
  575.                         bfDNC.append("[").append(prefix).append("]=[").append(dnc.getNamespaceURI(prefix)).append("]");
  576.                     }
  577.                     throw new XPathNotFoundException("nessun match trovato per l'espressione xpath ["+pattern+"] DynamicNamespaceContext:"+bfDNC.toString());
  578.                 }
  579.                 
  580.                 return result; 
  581.             
  582.             }
  583.         
  584.         }catch(XPathNotFoundException ex){
  585.             throw ex;
  586.         }catch(Exception e){
  587.             throw new XPathException("getMatchPattern pattern["+pattern+"] error: "+e.getMessage(),e);
  588.         }
  589.     } 
  590.     
  591.     
  592.     
  593.     
  594.     
  595.     /* ---------- VALIDATORE -------------- */
  596.     
  597.     public void validate(String path) throws XPathNotValidException{
  598.         try{
  599.             
  600.             path = path.trim();
  601.                 
  602.             // Instantiate an XPathFactory.
  603.             javax.xml.xpath.XPathFactory factory = this.getXMLUtils().getXPathFactory();
  604.     
  605.             // Use the XPathFactory to create a new XPath object
  606.             javax.xml.xpath.XPath xpath = factory.newXPath();
  607.             if(xpath==null){
  608.                 throw new Exception("Costruzione xpath non riuscita");
  609.             }
  610.             
  611.             // 3. Repleace the Namespaces:
  612.             path = path.replaceAll("}:", "}");
  613.             int index = 0;
  614.             while (path.indexOf("{")!=-1){
  615.                 int indexStart = path.indexOf("{");
  616.                 int indexEnd = path.indexOf("}");
  617.                 if(indexEnd==-1){
  618.                     throw new Exception("{ utilizzato senza la rispettiva chiusura }");
  619.                 }
  620.                 String namespace = path.substring(indexStart+"{".length(),indexEnd);
  621.                 if(namespace==null || namespace.equals("")){
  622.                     throw new Exception("Namespace non indicato tra {}");
  623.                 }
  624.                 String prefix = "a"+index+":";
  625.                 index++;
  626.                 path = path.replace("{"+namespace+"}", prefix);
  627.             }
  628.             //System.out.println("PATTERN PER VALIDAZIONE: ["+path+"]");
  629.             
  630.             if(path.startsWith("concat_openspcoop")){
  631.                 // funzione concat
  632.                 String param = path.substring("concat_openspcoop(".length(),path.length()-1);
  633.                 String [] params =param.split(",");
  634.                 for(int i=0; i<params.length;i++){
  635.                     
  636.                     // Check se abbiamo una costante od una espressione da valutare
  637.                     if(params[i].startsWith("\"") && params[i].endsWith("\"")){
  638.                     
  639.                         // COSTANTE
  640.                     
  641.                     }else{
  642.                         
  643.                         javax.xml.xpath.XPathExpression expression = null;
  644.                         try{
  645.                             expression = xpath.compile(params[i]);
  646.                         }catch(Exception e){
  647.                             if(Utilities.existsInnerException(e,javax.xml.transform.TransformerException.class)){
  648.                                 throw new Exception("Compilazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+Utilities.getInnerException(e, javax.xml.transform.TransformerException.class).getMessage()+")",e);
  649.                             }else{
  650.                                 if(e.getCause()!=null){
  651.                                     throw new Exception("Compilazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+(Utilities.getLastInnerException(e.getCause())).getMessage()+")",e);
  652.                                 }else{
  653.                                     throw new Exception("Compilazione dell'espressione XPATH contenuta in concat_openspcoop ("+params[i]+") ha causato un errore ("+e.getMessage()+")",e);
  654.                                 }
  655.                             }           
  656.                         }
  657.                         if(expression==null){
  658.                             throw new Exception("Costruzione XPathExpression non riuscita per espressione contenuta in concat_openspcoop ("+params[i]+")");
  659.                         }
  660.                         
  661.                     }
  662.                 }
  663.             }
  664.             else{
  665.                 // Compile an XPath string into an XPathExpression
  666.                 javax.xml.xpath.XPathExpression expression = null;
  667.                 try{
  668.                     expression = xpath.compile(path);
  669.                 }catch(Exception e){
  670.                     if(Utilities.existsInnerException(e,javax.xml.transform.TransformerException.class)){
  671.                         throw new Exception("Compilazione dell'espressione XPATH ha causato un errore ("+Utilities.getInnerException(e, javax.xml.transform.TransformerException.class).getMessage()+")",e);
  672.                     }else{
  673.                         if(e.getCause()!=null){
  674.                             throw new Exception("Compilazione dell'espressione XPATH ha causato un errore ("+(Utilities.getLastInnerException(e.getCause())).getMessage()+")",e);
  675.                         }else{
  676.                             throw new Exception("Compilazione dell'espressione XPATH ha causato un errore ("+e.getMessage()+")",e);
  677.                         }
  678.                     }   
  679.                 }
  680.                 if(expression==null){
  681.                     throw new Exception("Costruzione XPathExpression non riuscita");
  682.                 }
  683.             }
  684.         }catch(Exception e){
  685.             throw new XPathNotValidException("Validazione dell'xpath indicato ["+path+"] fallita: "+e.getMessage(),e);
  686.         }
  687.     }
  688.     
  689.     
  690.     
  691.     
  692.     
  693.     
  694.     
  695.     
  696.     
  697.     /* -------------- UTILITIES PUBBLICHE ------------------- */
  698.     
  699.     /**
  700.      * Ritorna la rappresentazione testuale di una lista di nodi
  701.      * 
  702.      * @param rootNode
  703.      * @return rappresentazione testuale di una lista di nodi
  704.      */
  705.     public String toString(NodeList rootNode){
  706.         
  707.         StringBuilder resultBuffer = new StringBuilder();
  708.         this.toString(rootNode,resultBuffer,1);
  709.         return resultBuffer.toString();
  710.         
  711.     }
  712.     public List<String> toList(NodeList rootNode){
  713.         
  714.         return this.toList(rootNode,1);
  715.         
  716.     }
  717.     

  719.     
  720.     /* -------------- UTILITIES PRIVATE ------------------- */
  721.     private int _prefixIndex = 0;
  722.     private synchronized int _getNextPrefixIndex(){
  723.         this._prefixIndex++;
  724.         return this._prefixIndex;
  725.     }
  726.     private static final String AUTO_PREFIX = "_op2PrefixAutoGeneratedIndex";
  727.     private String convertNamespaces(String path,DynamicNamespaceContext dnc)throws UtilsException{
  728.         while (path.indexOf("{")!=-1){
  729.             int indexStart = path.indexOf("{");
  730.             int indexEnd = path.indexOf("}");
  731.             if(indexEnd==-1){
  732.                 throw new UtilsException("Errore durante l'interpretazione del valore ["+path+"]: { utilizzato senza la rispettiva chiusura }");
  733.             }
  734.             String namespace = path.substring(indexStart+"{".length(),indexEnd);
  735.             String prefix = dnc.getPrefix(namespace);
  736.             //System.out.println("PREFIX["+prefix+"]->NS["+namespace+"]");
  737.             if(prefix!=null && !javax.xml.XMLConstants.NULL_NS_URI.equals(prefix)){
  738.                 prefix = prefix+":";
  739.             }
  740.             else{
  741.                 // aggiungo un prefisso nuovo anche nel caso di prefix "" per gestire la problematica che si presente in questo caso:
  742.                 // String xmlCampione = "<prova xmlns=\"www.namespace\">TEST</prova>";
  743.                 // NON FUNZIONA con un pattern = "/prova/text()"; (poiche' l'elemento prova ha un namespace, quello di default, mentre nell'xpath non viene indicato)
  744.                 //              Questo pattern sarebbe quello generato anche dopo la conversione dei namespace se il prefisso e' javax.xml.XMLConstants.NULL_NS_URI
  745.                 // FUNZIONA con un pattern = "*[local-name()='prova' and namespace-uri()='www.namespace']/text()"; ma e' piu' elaborato
  746.                 // FUNZIONA se registriamo un nuovo prefix da utilizzare solo nel pattern, ad esempio con un pattern = "/_op2PrefixAutoGeneratedIndexNUMBER:prova/text()"
  747.                 //          dove il prefisso auto-generato _op2PrefixAutoGeneratedIndexNUMBER e' associato al namespace www.namespace nel dnc.
  748.                 prefix = AbstractXPathExpressionEngine.AUTO_PREFIX + this._getNextPrefixIndex();
  749.                 dnc.addNamespace(prefix, namespace);
  750.                 prefix = prefix+":";
  751.                 //System.out.println("CASO SPECIALEEEEEEEEEEEEEEEE");
  752.             }
  753.             path = path.replace("{"+namespace+"}", prefix);
  754.         }
  755.         return path;
  756.     }
  757.     
  758.     private void toString(NodeList rootNode,StringBuilder resultBuffer, int livello){
  759.         
  760. //      for(int index = 0; index < rootNode.getLength();index ++){
  761. //          Node aNode = rootNode.item(index);
  762. //          try {
  763. //              System.out.println("DEBUG (livello:"+livello+"): "+getXMLUtils().toString(aNode));
  764. //          }catch(Exception e) {}
  765. //      }
  766.         
  767.         if (rootNode.getLength()==1 && 
  768.                 (rootNode.item(0).getNodeType()==Node.TEXT_NODE || rootNode.item(0).getNodeType()==Node.ATTRIBUTE_NODE) && 
  769.                 resultBuffer.length()==0){
  770.             //System.out.println("TEXT ["+rootNode.item(0).getNodeType()+"] confronto con ["+Node.TEXT_NODE+"] or ["+Node.ATTRIBUTE_NODE+"]");
  771.             // BugEntityReferences: il metodo getTextContent e anche getNodeValue risolve le entity references
  772.             //String textNodeValue = rootNode.item(0).getTextContent();
  773.             String textNodeValue = null;
  774.             try {
  775.                 textNodeValue = _getTextValue_fixEntityReferencies(rootNode.item(0));
  776.             }catch(Throwable t) {
  777.                 textNodeValue = rootNode.item(0).getTextContent();
  778.             }
  779.             resultBuffer.append(textNodeValue);
  780.             return;
  781.         }
  782.         boolean findElementoRisultatoMultiplo = false;
  783.         for(int index = 0; index < rootNode.getLength();index ++){
  784.             Node aNode = rootNode.item(index);
  785.             //System.out.println("NODE["+index+"] ["+aNode.getNodeType()+"] confronto con  ["+Node.ELEMENT_NODE+"]");
  786.             if (aNode.getNodeType() == Node.ELEMENT_NODE){
  787.                 NodeList childNodes = aNode.getChildNodes(); 
  788.                 
  789.                 if (childNodes.getLength() > 0){
  790.                     
  791.                     boolean hasChildNodes = false;
  792.                     for(int i=0;i<childNodes.getLength();i++){
  793.                         // elimino i text node che possono contenere "\n" con axiom
  794.                         Node n = childNodes.item(i);
  795.                         if(n.hasChildNodes()){
  796.                             hasChildNodes = true;
  797.                             break;
  798.                         }
  799.                     }
  800.                     
  801.                     if (hasChildNodes){
  802.                         resultBuffer.append("<"+aNode.getNodeName());

  804.                         this.printAttributes(aNode,resultBuffer);

  806.                         resultBuffer.append(">");
  807.                         
  808.                         this.toString(aNode.getChildNodes(), resultBuffer, (livello+1));
  809.                         resultBuffer.append("</"+aNode.getNodeName()+">");
  810.                     }
  811.                     else {
  812.                         resultBuffer.append("<"+aNode.getNodeName());
  813.                         
  814.                         this.printAttributes(aNode,resultBuffer);
  815.                                             
  816.                         // BugEntityReferences: il metodo getTextContent e anche getNodeValue risolve le entity references
  817.                         // String textNodeValue = aNode.getTextContent();
  818.                         String textNodeValue = null;
  819.                         try {
  820.                             textNodeValue = _getTextValue_fixEntityReferencies(aNode);
  821.                         }catch(Throwable t) {
  822.                             textNodeValue = aNode.getTextContent();
  823.                         }
  824.                         
  825.                         resultBuffer.append(">")
  826.                             .append(textNodeValue) 
  827.                             .append("</").append(aNode.getNodeName()).append(">");
  828.                     }
  829.                 }
  830.             }
  831.             // Risultati multipli per uno stesso elemento
  832.             else if ( (livello==1) && (aNode.getNodeType() == Node.TEXT_NODE || aNode.getNodeType() == Node.ATTRIBUTE_NODE) ){
  833.                 if(findElementoRisultatoMultiplo){
  834.                     resultBuffer.append(", ");
  835.                 }
  836.                 else {
  837.                     findElementoRisultatoMultiplo = true;
  838.                 }
  839.                 // BugEntityReferences: il metodo getTextContent e anche getNodeValue risolve le entity references
  840.                 //String textNodeValue = aNode.getTextContent();
  841.                 String textNodeValue = null;
  842.                 try {
  843.                     textNodeValue = _getTextValue_fixEntityReferencies(aNode);
  844.                 }catch(Throwable t) {
  845.                     textNodeValue = aNode.getTextContent();
  846.                 }
  847.                 resultBuffer.append("["+index+"]="+textNodeValue);
  848.             }
  849.         }
  850.     }
  851.     
  852.     private String _getTextValue_fixEntityReferencies(Node valueEle) throws Exception {
  853.         
  854.         StringBuilder sb = new StringBuilder();
  855.         
  856.         if(valueEle.getNodeType()==Node.TEXT_NODE || valueEle.getNodeType()==Node.ATTRIBUTE_NODE) {
  857.             //sb.append(valueEle.getTextContent());
  858.             // FIX:
  859.             sb.append(getXMLUtils().toString(valueEle,true));
  860.         }
  861.         else {
  862.             NodeList nl = valueEle.getChildNodes();
  863.             for (int i = 0; i < nl.getLength(); i++) {
  864.                 Node item = nl.item(i);
  865.                 if ((item instanceof CharacterData && !(item instanceof Comment)) || item instanceof EntityReference) {
  866.                     //sb.append(item.getNodeValue());
  867.                     // FIX:
  868.                     sb.append(getXMLUtils().toString(item,true));
  869.                 }
  870.             }
  871.         }
  872.         return sb.toString();
  873.     }
  874.     
  875.     private List<String> toList(NodeList rootNode,int livello){
  876.         
  877.         List<String> l = new ArrayList<>();
  878.         
  879.         if (rootNode.getLength()==1 && rootNode.item(0).getNodeType()==Node.TEXT_NODE){
  880.             //System.out.println("TEXT ["+rootNode.item(0).getNodeType()+"] confronto con ["+Node.TEXT_NODE+"]");
  881.             l.add(rootNode.item(0).getTextContent());
  882.             return l;
  883.         }
  884.         for(int index = 0; index < rootNode.getLength();index ++){
  885.             Node aNode = rootNode.item(index);
  886.             //System.out.println("NODE["+index+"] ["+aNode.getNodeType()+"] confronto con  ["+Node.ELEMENT_NODE+"]");
  887.             if (aNode.getNodeType() == Node.ELEMENT_NODE){
  888.                 NodeList childNodes = aNode.getChildNodes(); 
  889.                 
  890.                 if (childNodes.getLength() > 0){
  891.                     
  892.                     StringBuilder resultBuffer = new StringBuilder();
  893.                     
  894.                     boolean hasChildNodes = false;
  895.                     for(int i=0;i<childNodes.getLength();i++){
  896.                         // elimino i text node che possono contenere "\n" con axiom
  897.                         Node n = childNodes.item(i);
  898.                         if(n.hasChildNodes()){
  899.                             hasChildNodes = true;
  900.                             break;
  901.                         }
  902.                     }
  903.                     
  904.                     if (hasChildNodes){
  905.                         resultBuffer.append("<"+aNode.getNodeName());

  907.                         this.printAttributes(aNode,resultBuffer);

  909.                         resultBuffer.append(">");
  910.                         
  911.                         this.toString(aNode.getChildNodes(), resultBuffer, (livello+1));
  912.                         resultBuffer.append("</"+aNode.getNodeName()+">");
  913.                     }
  914.                     else {
  915.                         resultBuffer.append("<"+aNode.getNodeName());
  916.                         
  917.                         this.printAttributes(aNode,resultBuffer);
  918.                         
  919.                         resultBuffer.append(">"+aNode.getTextContent()+ "</"+aNode.getNodeName()+">");
  920.                     }
  921.                     
  922.                     l.add(resultBuffer.toString());
  923.                 }
  924.             }
  925.             // Risultati multipli per uno stesso elemento
  926.             else if ( (livello==1) && (aNode.getNodeType() == Node.TEXT_NODE) ){
  927.                 l.add(aNode.getTextContent());
  928.             }
  929.         }
  930.         
  931.         return l;
  932.     }
  933.     
  934.     private void printAttributes(Node aNode,StringBuilder resultBuffer){
  935.         NamedNodeMap attr = aNode.getAttributes();
  936.         for (int i=0;i<attr.getLength();i++){
  937.             Node item = attr.item(i);
  938.             if(item instanceof Attr){
  939.                 Attr attribute = (Attr) item;
  940.                 //System.out.println("PREFIX["+attribute.getPrefix()+"] LOCALNAME=["+attribute.getLocalName()+"] NAMESPACE["+attribute.getNodeValue()+"]");
  941.                 String prefix = attribute.getPrefix();
  942.                 if(prefix!=null && !"".equals(prefix)){
  943.                     prefix = prefix + ":";
  944.                 }else{
  945.                     prefix = "";
  946.                 }
  947.                 // BugEntityReferences: il metodo getTextContent e anche getNodeValue risolve le entity references
  948.                 //String value = attribute.getNodeValue();
  949.                 String value = null;
  950.                 try {
  951.                     value = _getTextValue_fixEntityReferencies(attribute);
  952.                 }catch(Throwable t) {
  953.                     value = attribute.getNodeValue();
  954.                 }
  955.                 resultBuffer.append(" "+prefix+attribute.getLocalName()+"=\""+value+"\"");
  956.             }else{
  957.                 resultBuffer.append(" "+item.toString());
  958.             }
  959.         }
  960.     }
  961.     
  962.     
  963.     public static String extractAndConvertResultAsString(String contentAsString,DynamicNamespaceContext dnc,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  964.         return AbstractXPathExpressionEngine._extractAndConvertResultAsString(null, contentAsString,
  965.                 dnc, xPathEngine, pattern, log);
  966.     }
  967.     public static String extractAndConvertResultAsString(Element element,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  968.         DynamicNamespaceContext dnc = new DynamicNamespaceContext();
  969.         dnc.findPrefixNamespace(element);
  970.         return AbstractXPathExpressionEngine._extractAndConvertResultAsString(element, null,
  971.                 dnc, xPathEngine, pattern, log);
  972.     }
  973.     public static String extractAndConvertResultAsString(Element element,DynamicNamespaceContext dnc,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  974.         return AbstractXPathExpressionEngine._extractAndConvertResultAsString(element, null,
  975.                 dnc, xPathEngine, pattern, log);
  976.     }
  977.     private static String _extractAndConvertResultAsString(Element element,String contentAsString,
  978.             DynamicNamespaceContext dnc,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  979.         
  980.         // Provo a cercarlo prima come Node
  981.         NodeList nodeList = null;
  982.         Exception exceptionNodeSet = null;
  983.         String risultato = null;
  984.         try{
  985.             if(element!=null) {
  986.                 nodeList = (NodeList) xPathEngine.getMatchPattern(element, dnc, pattern,XPathReturnType.NODESET);
  987.             }
  988.             else {
  989.                 nodeList = (NodeList) xPathEngine.getMatchPattern(contentAsString, dnc, pattern,XPathReturnType.NODESET);
  990.             }
  991.             if(nodeList!=null){
  992.                 risultato = xPathEngine.toString(nodeList);
  993.             }
  994.         }catch(Exception e){
  995.             exceptionNodeSet = e;
  996.         }
  997.         
  998.         // Se non l'ho trovato provo a cercarlo come string (es. il metodo sopra serve per avere l'xml, ma fallisce in caso di concat, in caso di errori di concat_openspcoop....)
  999.         // Insomma il caso dell'xml sopra e' quello speciale, che pero' deve essere eseguito prima, perche' altrimenti il caso string sotto funziona sempre, e quindi non si ottiene mai l'xml.
  1000.         if(risultato==null || "".equals(risultato)){
  1001.             try{
  1002.                 if(element!=null) {
  1003.                     risultato = xPathEngine.getStringMatchPattern(element, dnc, pattern);
  1004.                 }
  1005.                 else {
  1006.                     risultato = xPathEngine.getStringMatchPattern(contentAsString, dnc, pattern);
  1007.                 }
  1008.             }catch(Exception e){
  1009.                 if(exceptionNodeSet!=null){
  1010.                     log.debug("Errore avvenuto durante la getStringMatchPattern("+pattern
  1011.                             +") ("+e.getMessage()+") invocata in seguito all'errore dell'invocazione getMatchPattern("+
  1012.                             pattern+",NODESET): "+exceptionNodeSet.getMessage(),exceptionNodeSet);
  1013.                 }
  1014.                 // lancio questo errore e se presente anche quello con la ricerca notset nodoset.
  1015.                 if(exceptionNodeSet!=null) {
  1016.                     throw new UtilsMultiException(e,exceptionNodeSet);
  1017.                 }
  1018.                 else {
  1019.                     throw e;
  1020.                 }
  1021.             }
  1022.         }
  1023.         
  1024.         if(risultato == null || "".equals(risultato)){
  1025.             if(exceptionNodeSet!=null){
  1026.                 log.debug("Non sono stati trovati risultati tramite l'invocazione del metodo getStringMatchPattern("+pattern
  1027.                         +") invocato in seguito all'errore dell'invocazione getMatchPattern("+
  1028.                         pattern+",NODESET): "+exceptionNodeSet.getMessage(),exceptionNodeSet);
  1029.                 // lancio questo errore.
  1030.                 // Questo errore puo' avvenire perche' ho provato a fare xpath con nodeset
  1031.                 //throw exceptionNodeSet;
  1032.             }
  1033.         }
  1034.         
  1035.         return risultato;
  1036.     }
  1037.     
  1038.     
  1039.     
  1040.     public static List<String> extractAndConvertResultAsList(String contentAsString,DynamicNamespaceContext dnc,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  1041.         return AbstractXPathExpressionEngine._extractAndConvertResultAsList(null, contentAsString,
  1042.                 dnc, xPathEngine, pattern, log);
  1043.     }
  1044.     public static List<String> extractAndConvertResultAsList(Element element,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  1045.         DynamicNamespaceContext dnc = new DynamicNamespaceContext();
  1046.         dnc.findPrefixNamespace(element);
  1047.         return AbstractXPathExpressionEngine._extractAndConvertResultAsList(element, null,
  1048.                 dnc, xPathEngine, pattern, log);
  1049.     }
  1050.     public static List<String> extractAndConvertResultAsList(Element element,DynamicNamespaceContext dnc,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  1051.         return AbstractXPathExpressionEngine._extractAndConvertResultAsList(element, null,
  1052.                 dnc, xPathEngine, pattern, log);
  1053.     }
  1054.     private static List<String> _extractAndConvertResultAsList(Element element,String contentAsString,
  1055.             DynamicNamespaceContext dnc,AbstractXPathExpressionEngine xPathEngine, String pattern, Logger log) throws Exception {
  1056.         
  1057.         
  1058.         // Provo a cercarlo prima come Node
  1059.         NodeList nodeList = null;
  1060.         Exception exceptionNodeSet = null;
  1061.         List<String> risultato = new ArrayList<>();
  1062.         try{
  1063.             if(element!=null) {
  1064.                 nodeList = (NodeList) xPathEngine.getMatchPattern(element, dnc, pattern,XPathReturnType.NODESET);
  1065.             }
  1066.             else {
  1067.                 nodeList = (NodeList) xPathEngine.getMatchPattern(contentAsString, dnc, pattern,XPathReturnType.NODESET);
  1068.             }
  1069.             if(nodeList!=null){
  1070.                 risultato = xPathEngine.toList(nodeList);
  1071.             }
  1072.         }catch(Exception e){
  1073.             exceptionNodeSet = e;
  1074.         }
  1075.         
  1076.         // Se non l'ho trovato provo a cercarlo come string (es. il metodo sopra serve per avere l'xml, ma fallisce in caso di concat, in caso di errori di concat_openspcoop....)
  1077.         // Insomma il caso dell'xml sopra e' quello speciale, che pero' deve essere eseguito prima, perche' altrimenti il caso string sotto funziona sempre, e quindi non si ottiene mai l'xml.
  1078.         if(risultato==null || risultato.isEmpty()){
  1079.             try{
  1080.                 String s = null;
  1081.                 if(element!=null) {
  1082.                     s = xPathEngine.getStringMatchPattern(element, dnc, pattern);
  1083.                 }
  1084.                 else {
  1085.                     s = xPathEngine.getStringMatchPattern(contentAsString, dnc, pattern);
  1086.                 }
  1087.                 if(risultato==null) {
  1088.                     risultato = new ArrayList<>();
  1089.                 }
  1090.                 risultato.add(s);
  1091.             }catch(Exception e){
  1092.                 if(exceptionNodeSet!=null){
  1093.                     log.debug("Errore avvenuto durante la getStringMatchPattern("+pattern
  1094.                             +") ("+e.getMessage()+") invocata in seguito all'errore dell'invocazione getMatchPattern("+
  1095.                             pattern+",NODESET): "+exceptionNodeSet.getMessage(),exceptionNodeSet);
  1096.                 }
  1097.                 // lancio questo errore e se presente anche quello con la ricerca notset nodoset.
  1098.                 if(exceptionNodeSet!=null) {
  1099.                     throw new UtilsMultiException(e,exceptionNodeSet);
  1100.                 }
  1101.                 else {
  1102.                     throw e;
  1103.                 }
  1104.             }
  1105.         }
  1106.         
  1107.         if(risultato == null || risultato.isEmpty()){
  1108.             if(exceptionNodeSet!=null){
  1109.                 log.debug("Non sono stati trovati risultati tramite l'invocazione del metodo getStringMatchPattern("+pattern
  1110.                         +") invocato in seguito all'errore dell'invocazione getMatchPattern("+
  1111.                         pattern+",NODESET): "+exceptionNodeSet.getMessage(),exceptionNodeSet);
  1112.                 // lancio questo errore.
  1113.                 // Questo errore puo' avvenire perche' ho provato a fare xpath con nodeset
  1114.                 //throw exceptionNodeSet;
  1115.             }
  1116.         }
  1117.         
  1118.         return risultato;
  1119.     }
  1120. }
Created with JaCoCo 0.8.8.202204050719