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



  23. package org.openspcoop2.core.tracciamento.utils;

  25. import java.io.ByteArrayInputStream;
  26. import java.io.ByteArrayOutputStream;
  27. import java.io.File;
  28. import java.io.FileInputStream;
  29. import java.io.InputStream;
  30. import java.io.OutputStream;

  32. import org.slf4j.Logger;
  33. import org.openspcoop2.core.tracciamento.Allegati;
  34. import org.openspcoop2.core.tracciamento.Allegato;
  35. import org.openspcoop2.core.tracciamento.Busta;
  36. import org.openspcoop2.core.tracciamento.Data;
  37. import org.openspcoop2.core.tracciamento.Dominio;
  38. import org.openspcoop2.core.tracciamento.Eccezione;
  39. import org.openspcoop2.core.tracciamento.Eccezioni;
  40. import org.openspcoop2.core.tracciamento.ProfiloCollaborazione;
  41. import org.openspcoop2.core.tracciamento.ProfiloTrasmissione;
  42. import org.openspcoop2.core.tracciamento.Proprieta;
  43. import org.openspcoop2.core.tracciamento.Protocollo;
  44. import org.openspcoop2.core.tracciamento.Riscontri;
  45. import org.openspcoop2.core.tracciamento.Riscontro;
  46. import org.openspcoop2.core.tracciamento.Servizio;
  47. import org.openspcoop2.core.tracciamento.Soggetto;
  48. import org.openspcoop2.core.tracciamento.Traccia;
  49. import org.openspcoop2.core.tracciamento.Trasmissione;
  50. import org.openspcoop2.core.tracciamento.Trasmissioni;
  51. import org.openspcoop2.core.tracciamento.constants.CostantiTracciamento;
  52. import org.openspcoop2.core.tracciamento.utils.serializer.JsonJacksonDeserializer;
  53. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  54. import org.openspcoop2.message.xml.ValidatoreXSD;
  55. import org.openspcoop2.utils.beans.WriteToSerializerType;
  56. import org.w3c.dom.Document;
  57. import org.w3c.dom.Element;
  58. import org.w3c.dom.Node;


  61. /**
  62.  * Classe utilizzata per la generazione delle tracce generati dalla PdD
  63.  *
  64.  *
  65.  * @author Poli Andrea (apoli@link.it)
  66.  * @author $Author$
  67.  * @version $Rev$, $Date$
  68.  */

  70. public class XMLUtils  {
  71.     
  72.     private XMLUtils() {}

  74.     /** Validatore XSD */
  75.     static ValidatoreXSD validatoreXSD = null;
  76.     private static synchronized void initValidatoreXSD(Logger log) throws Exception{
  77.         if(XMLUtils.validatoreXSD==null){
  78.             XMLUtils.validatoreXSD = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), log,XMLUtils.class.getResourceAsStream("/openspcoopTracciamento.xsd"));
  79.         }
  80.     }
  81.     public static ValidatoreXSD getValidatoreXSD(Logger log) throws Exception{
  82.         if(XMLUtils.validatoreXSD==null){
  83.             initValidatoreXSD(log);
  84.         }
  85.         return XMLUtils.validatoreXSD;
  86.     }
  87.     private static final String BUSTA_PREFIX = "Busta.";
  88.     public static boolean validate(Traccia traccia,StringBuilder motivoErroreValidazione){
  89.         
  90.         int size = motivoErroreValidazione.length();
  91.         
  92.         if(traccia.getTipo()==null){
  93.             motivoErroreValidazione.append("Tipo non definito\n");
  94.         }
  95.         
  96.         if(traccia.getDominio()==null){
  97.             motivoErroreValidazione.append("Dominio non definito\n");
  98.         }
  99.         else{
  100.             validate(traccia.getDominio(), motivoErroreValidazione);
  101.         }
  102.         
  103.         if(traccia.getOraRegistrazione()==null){
  104.             motivoErroreValidazione.append("OraRegistrazione non definita\n");
  105.         }
  106.         
  107.         if(traccia.getEsitoElaborazione()==null){
  108.             motivoErroreValidazione.append("EsitoElaborazione non definito\n");
  109.         }
  110.         else{
  111.             if(traccia.getEsitoElaborazione().getTipo()==null){
  112.                 motivoErroreValidazione.append("EsitoElaborazione.tipo non definito\n");
  113.             }
  114.         }
  115.         
  116.         if(traccia.getLocation()==null){
  117.             motivoErroreValidazione.append("Location non definito\n");
  118.         }
  119.         
  120.         if(traccia.getBusta()==null){
  121.             motivoErroreValidazione.append("Busta non definita\n");
  122.         }
  123.         else{
  124.             validate(traccia.getBusta(), motivoErroreValidazione);
  125.         }
  126.         
  127.         if(traccia.getAllegati()!=null){
  128.             validate(traccia.getAllegati(), motivoErroreValidazione);
  129.         }
  130.         
  131.         return motivoErroreValidazione.length()==size;

  133.     }
  134.     private static void validate(Dominio dominio,StringBuilder motivoErroreValidazione){
  135.         if(dominio.getIdentificativoPorta()==null){
  136.             motivoErroreValidazione.append("Dominio.identificativoPorta non definito\n");
  137.         }
  138.         if(dominio.getFunzione()==null){
  139.             motivoErroreValidazione.append("Dominio.funzione non definito\n");
  140.         }
  141.         if(dominio.getSoggetto()==null){
  142.             motivoErroreValidazione.append("Dominio.soggetto non definita\n");
  143.         }
  144.         else{
  145.             if(dominio.getSoggetto().getTipo()==null){
  146.                 motivoErroreValidazione.append("Dominio.soggetto.tipo non definita\n");
  147.             }
  148.             if(dominio.getSoggetto().getBase()==null){
  149.                 motivoErroreValidazione.append("Dominio.soggetto.nome non definita\n");
  150.             }
  151.         }
  152.     }
  153.     private static void validate(Busta busta,StringBuilder motivoErroreValidazione){
  154.         if(busta.getMittente()!=null){
  155.             validate(busta.getMittente(), motivoErroreValidazione, "mittente");
  156.         }
  157.         if(busta.getDestinatario()!=null){
  158.             validate(busta.getDestinatario(), motivoErroreValidazione , "destinatario");
  159.         }
  160.         if(busta.getProfiloCollaborazione()!=null){
  161.             validate(busta.getProfiloCollaborazione(), motivoErroreValidazione);
  162.         }
  163.         if(busta.getServizio()!=null){
  164.             validate(busta.getServizio(), motivoErroreValidazione,"servizio");
  165.         }
  166.         if(busta.getServizioCorrelato()!=null){
  167.             validate(busta.getServizio(), motivoErroreValidazione,"servizio-correlato");
  168.         }
  169.         if(busta.getOraRegistrazione()!=null){
  170.             validate(busta.getOraRegistrazione(), motivoErroreValidazione,"ora-registrazione");
  171.         }
  172.         if(busta.getProfiloTrasmissione()!=null){
  173.             validate(busta.getProfiloTrasmissione(), motivoErroreValidazione);
  174.         }
  175.         if(busta.getTrasmissioni()!=null){
  176.             validate(busta.getTrasmissioni(), motivoErroreValidazione);
  177.         }
  178.         if(busta.getRiscontri()!=null){
  179.             validate(busta.getRiscontri(), motivoErroreValidazione);
  180.         }
  181.         if(busta.getEccezioni()!=null){
  182.             validate(busta.getEccezioni(), motivoErroreValidazione);
  183.         }
  184.         if(busta.getProtocollo()==null){
  185.             motivoErroreValidazione.append("Busta.protocollo non definita\n");
  186.         }
  187.         else{
  188.             validate(busta.getProtocollo(), motivoErroreValidazione);
  189.         }
  190.     }
  191.     private static void validate(Soggetto soggetto,StringBuilder motivoErroreValidazione,String tipo){
  192.         String prefix = BUSTA_PREFIX+tipo+".identificativo";
  193.         if(soggetto.getIdentificativo()==null){
  194.             motivoErroreValidazione.append(prefix+" non definita\n");
  195.         }
  196.         else{
  197.             if(soggetto.getIdentificativo().getTipo()==null){
  198.                 motivoErroreValidazione.append(prefix+".tipo non definita\n");
  199.             }
  200.             if(soggetto.getIdentificativo().getBase()==null){
  201.                 motivoErroreValidazione.append(prefix+".base non definita\n");
  202.             }
  203.         }
  204.     }
  205.     private static void validate(ProfiloCollaborazione profilo,StringBuilder motivoErroreValidazione){
  206.         if(profilo.getTipo()==null){
  207.             motivoErroreValidazione.append("Busta.profiloCollaborazione.identificativo.tipo non definita\n");
  208.         }
  209.         if(profilo.getBase()==null){
  210.             motivoErroreValidazione.append("Busta.profiloCollaborazione.identificativo.base non definita\n");
  211.         }
  212.     }
  213.     private static void validate(Servizio servizio,StringBuilder motivoErroreValidazione,String tipo){
  214.         if(servizio.getBase()==null){
  215.             motivoErroreValidazione.append(BUSTA_PREFIX+tipo+".base non definita\n");
  216.         }
  217.     }
  218.     private static void validate(Data data,StringBuilder motivoErroreValidazione,String tipo){
  219.         if(data.getSorgente()!=null){
  220.             if(data.getSorgente().getBase()==null){
  221.                 motivoErroreValidazione.append(BUSTA_PREFIX+tipo+".sorgente.base non definita\n");
  222.             }
  223.             if(data.getSorgente().getTipo()==null){
  224.                 motivoErroreValidazione.append(BUSTA_PREFIX+tipo+".sorgente.tipo non definita\n");
  225.             }
  226.         }
  227.     }
  228.     private static void validate(ProfiloTrasmissione profiloTrasmissione,StringBuilder motivoErroreValidazione){
  229.         if(profiloTrasmissione.getInoltro()!=null){
  230.             if(profiloTrasmissione.getInoltro().getBase()==null){
  231.                 motivoErroreValidazione.append("Busta.profiloTrasmissione.base non definita\n");
  232.             }
  233.             if(profiloTrasmissione.getInoltro().getTipo()==null){
  234.                 motivoErroreValidazione.append("Busta.profiloTrasmissione.tipo non definita\n");
  235.             }
  236.         }
  237.     }
  238.     private static void validate(Trasmissioni trasmissioni,StringBuilder motivoErroreValidazione){
  239.         for (int i = 0; i < trasmissioni.sizeTrasmissioneList(); i++) {
  240.             Trasmissione tr = trasmissioni.getTrasmissione(i);
  241.             if(tr==null){
  242.                 motivoErroreValidazione.append("Busta.tramissione["+i+"] non definita\n");
  243.             }
  244.             else{
  245.                 String prefix = "tramissione["+i+"]";
  246.                 if(tr.getOrigine()!=null){
  247.                     validate(tr.getOrigine(), motivoErroreValidazione, prefix+".origine");
  248.                 }
  249.                 if(tr.getDestinazione()!=null){
  250.                     validate(tr.getDestinazione(), motivoErroreValidazione, prefix+".destinazione");
  251.                 }
  252.                 if(tr.getOraRegistrazione()!=null){
  253.                     validate(tr.getOraRegistrazione(), motivoErroreValidazione, prefix+".ora-registrazione");
  254.                 }
  255.             }
  256.         }
  257.     }
  258.     private static void validate(Riscontri riscontri,StringBuilder motivoErroreValidazione){
  259.         for (int i = 0; i < riscontri.sizeRiscontroList(); i++) {
  260.             Riscontro r = riscontri.getRiscontro(i);
  261.             if(r==null){
  262.                 motivoErroreValidazione.append("Busta.riscontro["+i+"] non definito\n");
  263.             }
  264.             else{
  265.                 if(r.getOraRegistrazione()!=null){
  266.                     validate(r.getOraRegistrazione(), motivoErroreValidazione, "riscontro["+i+"].ora-registrazione");
  267.                 }
  268.             }
  269.         }
  270.     }
  271.     private static void validate(Eccezioni eccezioni,StringBuilder motivoErroreValidazione){
  272.         for (int i = 0; i < eccezioni.sizeEccezioneList(); i++) {
  273.             String prefix = "Busta.eccezione["+i+"]";
  274.             Eccezione e = eccezioni.getEccezione(i);
  275.             if(e==null){
  276.                 motivoErroreValidazione.append(prefix+" non definita\n");
  277.             }
  278.             else{
  279.                 validate(prefix, e, motivoErroreValidazione);
  280.             }
  281.         }
  282.     }
  283.     private static void validate(String prefix, Eccezione e,StringBuilder motivoErroreValidazione){
  284.         if(e.getCodice()!=null){
  285.             if(e.getCodice().getBase()==null){
  286.                 motivoErroreValidazione.append(prefix+".codice.base non definita\n");
  287.             }
  288.             if(e.getCodice().getTipo()==null){
  289.                 motivoErroreValidazione.append(prefix+".codice.tipo non definita\n");
  290.             }
  291.         }
  292.         if(e.getContestoCodifica()!=null){
  293.             if(e.getContestoCodifica().getBase()==null){
  294.                 motivoErroreValidazione.append(prefix+".contesto-codifica.base non definita\n");
  295.             }
  296.             if(e.getContestoCodifica().getTipo()==null){
  297.                 motivoErroreValidazione.append(prefix+".contesto-codifica.tipo non definita\n");
  298.             }
  299.         }
  300.         if(e.getRilevanza()!=null){
  301.             if(e.getRilevanza().getBase()==null){
  302.                 motivoErroreValidazione.append(prefix+".rilevanza.base non definita\n");
  303.             }
  304.             if(e.getRilevanza().getTipo()==null){
  305.                 motivoErroreValidazione.append(prefix+".rilevanza.tipo non definita\n");
  306.             }
  307.         }
  308.     }
  309.     private static void validate(Allegati allegati,StringBuilder motivoErroreValidazione){
  310.         for (int i = 0; i < allegati.sizeAllegatoList(); i++) {
  311.             Allegato a = allegati.getAllegato(i);
  312.             if(a==null){
  313.                 motivoErroreValidazione.append("Busta.allegato["+i+"] non definita\n");
  314.             }
  315.         }
  316.     }
  317.     private static void validate(Protocollo protocollo,StringBuilder motivoErroreValidazione){
  318.         if(protocollo.getIdentificativo()==null){
  319.             motivoErroreValidazione.append("Busta.protocollo.identificativo non definito\n");
  320.         }
  321.         for (int i = 0; i < protocollo.sizeProprietaList(); i++) {
  322.             String prefix = "Busta.protocollo.proprieta["+i+"]";
  323.             Proprieta pp = protocollo.getProprieta(i);
  324.             if(pp==null){
  325.                 motivoErroreValidazione.append(prefix+" non definito\n");
  326.             }
  327.             else{
  328.                 if(pp.getNome()==null){
  329.                     motivoErroreValidazione.append(prefix+".nome non definito\n");
  330.                 }
  331.                 if(pp.getValore()==null){
  332.                     motivoErroreValidazione.append(prefix+"["+pp.getNome()+"].valore non definito\n");
  333.                 }
  334.             }
  335.         }
  336.     }
  337.     
  338.     
  339.     
  340.     /* ----- Unmarshall ----- */
  341.     
  342.     /**
  343.      * Ritorna la rappresentazione java
  344.      * 
  345.      * @param m byte[]
  346.      * @return DettaglioEccezione
  347.      * @throws XMLUtilsException
  348.      */
  349.     public static Traccia getTraccia(Logger log,byte[] m) throws XMLUtilsException{
  350.         try (ByteArrayInputStream bin = new ByteArrayInputStream(m);){
  351.             return XMLUtils.getTraccia(log,bin);
  352.         }catch(Exception e){
  353.             throw new XMLUtilsException(e.getMessage(),e);
  354.         }
  355.     }
  356.     
  357.     /**
  358.      * Ritorna la rappresentazione java
  359.      * 
  360.      * @param m File
  361.      * @return DettaglioEccezione
  362.      * @throws XMLUtilsException
  363.      */
  364.     public static Traccia getTraccia(Logger log,File m) throws XMLUtilsException{
  365.         try (FileInputStream fin = new FileInputStream(m);){
  366.             return XMLUtils.getTraccia(log,fin);
  367.         }catch(Exception e){
  368.             throw new XMLUtilsException(e.getMessage(),e);
  369.         }
  370.     }
  371.     
  372.     /**
  373.      * Ritorna la rappresentazione java
  374.      * 
  375.      * @param m String
  376.      * @return DettaglioEccezione
  377.      * @throws XMLUtilsException
  378.      */
  379.     public static Traccia getTraccia(Logger log,String m) throws XMLUtilsException{
  380.         return XMLUtils.getTraccia(log,m.getBytes());
  381.     }
  382.     
  383.     /**
  384.      * Ritorna la rappresentazione java
  385.      * 
  386.      * @param m InputStream
  387.      * @return DettaglioEccezione
  388.      * @throws XMLUtilsException
  389.      */
  390.     public static Traccia getTraccia(Logger log,InputStream m) throws XMLUtilsException{
  391.         try{
  392.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  393.             byte[]reads = new byte[1024];
  394.             int letti = 0;
  395.             while( (letti=m.read(reads)) != -1){
  396.                 bout.write(reads, 0, letti);
  397.             }
  398.             bout.flush();
  399.             bout.close();
  400.             byte [] xml = bout.toByteArray();
  401.             
  402.             // Validazione XSD
  403.             ByteArrayInputStream binValidazione = new ByteArrayInputStream(xml);
  404.             ValidatoreXSD validatoreXSD = XMLUtils.getValidatoreXSD(log);
  405.             validatoreXSD.valida(binValidazione);
  406.             
  407.             // trasformazione in oggetto DettaglioEccezione
  408.             ByteArrayInputStream binTrasformazione = new ByteArrayInputStream(xml);
  409.             return (Traccia) org.openspcoop2.utils.xml.JaxbUtils.xmlToObj(binTrasformazione, Traccia.class);
  410.             
  411.         }catch(Exception e){
  412.             throw new XMLUtilsException(e.getMessage(),e);
  413.         }
  414.     }


  417.     public static Traccia getTracciaFromJson(Logger log,InputStream is) throws XMLUtilsException{
  418.         try{            
  419.             if(log!=null) {
  420.                 // ignore
  421.             }
  422.             JsonJacksonDeserializer deserializer = new JsonJacksonDeserializer();
  423.             return deserializer.readTraccia(is);
  424.         }catch(Exception e){
  425.             throw new XMLUtilsException(e.getMessage(),e);
  426.         }
  427.     }
  428.     
  429.     
  430.     
  431.     /* ----- Marshall ----- */
  432.     public static void generateTraccia(Traccia traccia,File out) throws XMLUtilsException{
  433.         generateTraccia(traccia, out, false, false);
  434.     }
  435.     public static void generateTraccia(Traccia traccia,File out,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  436.         try{
  437.             StringBuilder risultatoValidazione = new StringBuilder();
  438.             if(!XMLUtils.validate(traccia, risultatoValidazione)){
  439.                 throw new XMLUtilsException(risultatoValidazione.toString());
  440.             }
  441.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(out.getName(),XMLUtils.generateTracciaEngine(traccia, prettyDocument, omitXmlDeclaration));
  442.         }catch(Exception e){
  443.             throw new XMLUtilsException(e.getMessage(),e);
  444.         }
  445.     }
  446.     
  447.     public static void generateTraccia(Traccia traccia,String fileName) throws XMLUtilsException{
  448.         generateTraccia(traccia, fileName, false, false);
  449.     }
  450.     public static void generateTraccia(Traccia traccia,String fileName,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  451.         try{
  452.             StringBuilder risultatoValidazione = new StringBuilder();
  453.             if(!XMLUtils.validate(traccia, risultatoValidazione)){
  454.                 throw new XMLUtilsException(risultatoValidazione.toString());
  455.             }
  456.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(fileName,XMLUtils.generateTracciaEngine(traccia, prettyDocument, omitXmlDeclaration));
  457.         }catch(Exception e){
  458.             throw new XMLUtilsException(e.getMessage(),e);
  459.         }
  460.     }
  461.     
  462.     public static byte[] generateTraccia(Traccia traccia) throws XMLUtilsException{
  463.         return generateTraccia(traccia, false, false);
  464.     }
  465.     public static byte[] generateTraccia(Traccia traccia,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  466.         try{
  467.             StringBuilder risultatoValidazione = new StringBuilder();
  468.             if(!XMLUtils.validate(traccia, risultatoValidazione)){
  469.                 throw new XMLUtilsException(risultatoValidazione.toString());
  470.             }
  471.             return XMLUtils.generateTracciaEngine(traccia, prettyDocument, omitXmlDeclaration);
  472.         }catch(Exception e){
  473.             throw new XMLUtilsException(e.getMessage(),e);
  474.         }
  475.     }

  477.     public static void generateTraccia(Traccia traccia,OutputStream out) throws XMLUtilsException{
  478.         generateTraccia(traccia, out, false, false);
  479.     }
  480.     public static void generateTraccia(Traccia traccia,OutputStream out, boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  481.         try{
  482.             StringBuilder risultatoValidazione = new StringBuilder();
  483.             if(!XMLUtils.validate(traccia, risultatoValidazione)){
  484.                 throw new XMLUtilsException(risultatoValidazione.toString());
  485.             }
  486.             out.write(XMLUtils.generateTracciaEngine(traccia, prettyDocument, omitXmlDeclaration));
  487.             out.flush();
  488.             out.close();
  489.         }catch(Exception e){
  490.             throw new XMLUtilsException(e.getMessage(),e);
  491.         }
  492.     }
  493.     
  494.     public static String generateTracciaAsJson(Traccia traccia) throws XMLUtilsException{
  495.         return generateTracciaAsJson(traccia, false);
  496.     }
  497.     public static String generateTracciaAsJson(Traccia traccia, boolean prettyDocument) throws XMLUtilsException{
  498.         try{
  499.             StringBuilder risultatoValidazione = new StringBuilder();
  500.             if(!XMLUtils.validate(traccia, risultatoValidazione)){
  501.                 throw new XMLUtilsException(risultatoValidazione.toString());
  502.             }
  503.             return XMLUtils.generateTracciaAsJsonEngine(traccia, prettyDocument);
  504.         }catch(Exception e){
  505.             throw new XMLUtilsException(e.getMessage(),e);
  506.         }
  507.     }
  508.     
  509.     private static byte[] generateTracciaEngine(Traccia traccia,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  510.         try{
  511.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  512.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(bout, Traccia.class, traccia, prettyDocument, omitXmlDeclaration);
  513.             return bout.toByteArray();
  514.         }catch(Exception e){
  515.             throw new XMLUtilsException(e.getMessage(),e);
  516.         }
  517.     }
  518.     
  519.     private static String generateTracciaAsJsonEngine(Traccia traccia,boolean prettyDocument) throws XMLUtilsException{
  520.         try{
  521.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  522.             traccia.writeTo(bout, WriteToSerializerType.JSON_JACKSON,prettyDocument);
  523.             bout.flush();
  524.             bout.close();
  525.             return bout.toString();
  526.         }catch(Exception e){
  527.             throw new XMLUtilsException(e.getMessage(),e);
  528.         }
  529.     }
  530.     
  531.     
  532.     
  533.     public static boolean isTraccia(byte [] doc){
  534.         try{
  535.             org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  536.             Document docXML = xmlUtils.newDocument(doc);
  537.             Element elemXML = docXML.getDocumentElement();
  538.             return XMLUtils.isTracciaEngine(elemXML);
  539.         }catch(Exception e){
  540.             /**System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());*/
  541.             return false;
  542.         }
  543.     }
  544.     public static boolean isTraccia(Document docXML){
  545.         try{
  546.             Element elemXML = docXML.getDocumentElement();
  547.             return XMLUtils.isTracciaEngine(elemXML);
  548.         }catch(Exception e){
  549.             /**System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());*/
  550.             return false;
  551.         }
  552.     }
  553.     public static boolean isTraccia(Element elemXML){
  554.         return isTracciaEngine(elemXML);
  555.     }
  556.     public static boolean isTraccia(Node nodeXml){
  557.         return isTracciaEngine(nodeXml);
  558.     }
  559.     private static boolean isTracciaEngine(Node nodeXml){
  560.         try{
  561.             /**System.out.println("LOCAL["+Costanti.ROOT_LOCAL_NAME_DETTAGLIO_ECCEZIONE+"]vs["+elemXML.getLocalName()+"]  NAMESPACE["+Costanti.TARGET_NAMESPACE+"]vs["+elemXML.getNamespaceURI()+"]");*/
  562.             return CostantiTracciamento.ROOT_LOCAL_NAME_TRACCIA.equals(nodeXml.getLocalName()) && 
  563.                     CostantiTracciamento.TARGET_NAMESPACE.equals(nodeXml.getNamespaceURI() ) ;
  564.         }catch(Exception e){
  565.             /** System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage()); */
  566.             return false;
  567.         }
  568.     }
  569.     
  570. }
Created with JaCoCo 0.8.8.202204050719