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.diagnostica.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.diagnostica.DominioDiagnostico;
  34. import org.openspcoop2.core.diagnostica.MessaggioDiagnostico;
  35. import org.openspcoop2.core.diagnostica.Protocollo;
  36. import org.openspcoop2.core.diagnostica.constants.CostantiDiagnostica;
  37. import org.openspcoop2.core.diagnostica.utils.serializer.JsonJacksonDeserializer;
  38. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  39. import org.openspcoop2.message.xml.ValidatoreXSD;
  40. import org.openspcoop2.utils.beans.WriteToSerializerType;
  41. import org.w3c.dom.Document;
  42. import org.w3c.dom.Element;
  43. import org.w3c.dom.Node;


  46. /**
  47.  * Classe utilizzata per la generazione dei diagnostici generati dalla PdD
  48.  *
  49.  *
  50.  * @author Poli Andrea (apoli@link.it)
  51.  * @author $Author$
  52.  * @version $Rev$, $Date$
  53.  */

  55. public class XMLUtils  {
  56.     
  57.     private XMLUtils() {}

  59.     /** Validatore XSD */
  60.     static ValidatoreXSD validatoreXSD = null;
  61.     private static synchronized void initValidatoreXSD(Logger log) throws Exception{
  62.         if(XMLUtils.validatoreXSD==null){
  63.             XMLUtils.validatoreXSD = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), log,XMLUtils.class.getResourceAsStream("/openspcoopDiagnostica.xsd"));
  64.         }
  65.     }
  66.     public static ValidatoreXSD getValidatoreXSD(Logger log) throws Exception{
  67.         if(XMLUtils.validatoreXSD==null){
  68.             initValidatoreXSD(log);
  69.         }
  70.         return XMLUtils.validatoreXSD;
  71.     }
  72.     public static boolean validate(MessaggioDiagnostico messaggioDiagnostico,StringBuilder motivoErroreValidazione){
  73.         
  74.         int size = motivoErroreValidazione.length();
  75.         
  76.         if(messaggioDiagnostico.getDominio()==null){
  77.             motivoErroreValidazione.append("Dominio non definito\n");
  78.         }
  79.         else{
  80.             validate(messaggioDiagnostico.getDominio(), motivoErroreValidazione);
  81.         }
  82.         
  83.         if(messaggioDiagnostico.getOraRegistrazione()==null){
  84.             motivoErroreValidazione.append("OraRegistrazione non definita\n");
  85.         }
  86.         
  87.         if(messaggioDiagnostico.getCodice()==null){
  88.             motivoErroreValidazione.append("Codice non definito\n");
  89.         }
  90.         
  91.         if(messaggioDiagnostico.getMessaggio()==null){
  92.             motivoErroreValidazione.append("Messaggio non definito\n");
  93.         }
  94.         
  95.         if(messaggioDiagnostico.getSeverita()==null){
  96.             motivoErroreValidazione.append("Severita non definito\n");
  97.         }
  98.         
  99.         if(messaggioDiagnostico.getProtocollo()!=null){ // sara' null per i messaggi di servizio emessi dalla PdD
  100.             validate(messaggioDiagnostico.getProtocollo(), motivoErroreValidazione);
  101.         }
  102.         
  103.         return motivoErroreValidazione.length()==size;

  105.     }
  106.     private static void validate(DominioDiagnostico dominio,StringBuilder motivoErroreValidazione){
  107.         if(dominio.getIdentificativoPorta()==null){
  108.             motivoErroreValidazione.append("Dominio.identificativoPorta non definito\n");
  109.         }
  110.         if(dominio.getModulo()==null){
  111.             motivoErroreValidazione.append("Dominio.modulo non definito\n");
  112.         }
  113.         if(dominio.getSoggetto()==null){
  114.             motivoErroreValidazione.append("Dominio.soggetto non definita\n");
  115.         }
  116.         else{
  117.             if(dominio.getSoggetto().getTipo()==null){
  118.                 motivoErroreValidazione.append("Dominio.soggetto.tipo non definita\n");
  119.             }
  120.             if(dominio.getSoggetto().getBase()==null){
  121.                 motivoErroreValidazione.append("Dominio.soggetto.nome non definita\n");
  122.             }
  123.         }
  124.     }
  125.     private static void validate(Protocollo protocollo,StringBuilder motivoErroreValidazione){
  126.         if(protocollo.getIdentificativo()==null){
  127.             motivoErroreValidazione.append("Protocollo.identificativo non definito\n");
  128.         }
  129.     }
  130.     
  131.     
  132.     
  133.     /* ----- Unmarshall ----- */
  134.     
  135.     /**
  136.      * Ritorna la rappresentazione java
  137.      * 
  138.      * @param m byte[]
  139.      * @return DettaglioEccezione
  140.      * @throws XMLUtilsException
  141.      */
  142.     public static MessaggioDiagnostico getMessaggioDiagnostico(Logger log,byte[] m) throws XMLUtilsException{
  143.         try (ByteArrayInputStream bin = new ByteArrayInputStream(m);){
  144.             return XMLUtils.getMessaggioDiagnostico(log,bin);
  145.         }catch(Exception e){
  146.             throw new XMLUtilsException(e.getMessage(),e);
  147.         }
  148.     }
  149.     
  150.     /**
  151.      * Ritorna la rappresentazione java
  152.      * 
  153.      * @param m File
  154.      * @return DettaglioEccezione
  155.      * @throws XMLUtilsException
  156.      */
  157.     public static MessaggioDiagnostico getMessaggioDiagnostico(Logger log,File m) throws XMLUtilsException{
  158.         try (FileInputStream fin = new FileInputStream(m);){
  159.             return XMLUtils.getMessaggioDiagnostico(log,fin);
  160.         }catch(Exception e){
  161.             throw new XMLUtilsException(e.getMessage(),e);
  162.         }
  163.     }
  164.     
  165.     /**
  166.      * Ritorna la rappresentazione java
  167.      * 
  168.      * @param m String
  169.      * @return DettaglioEccezione
  170.      * @throws XMLUtilsException
  171.      */
  172.     public static MessaggioDiagnostico getMessaggioDiagnostico(Logger log,String m) throws XMLUtilsException{
  173.         return XMLUtils.getMessaggioDiagnostico(log,m.getBytes());
  174.     }
  175.     
  176.     /**
  177.      * Ritorna la rappresentazione java
  178.      * 
  179.      * @param m InputStream
  180.      * @return DettaglioEccezione
  181.      * @throws XMLUtilsException
  182.      */
  183.     public static MessaggioDiagnostico getMessaggioDiagnostico(Logger log,InputStream m) throws XMLUtilsException{
  184.         try{
  185.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  186.             byte[]reads = new byte[1024];
  187.             int letti = 0;
  188.             while( (letti=m.read(reads)) != -1){
  189.                 bout.write(reads, 0, letti);
  190.             }
  191.             bout.flush();
  192.             bout.close();
  193.             byte [] xml = bout.toByteArray();
  194.             
  195.             // Validazione XSD
  196.             ByteArrayInputStream binValidazione = new ByteArrayInputStream(xml);
  197.             ValidatoreXSD validatoreXSD = XMLUtils.getValidatoreXSD(log);
  198.             validatoreXSD.valida(binValidazione);
  199.             
  200.             // trasformazione in oggetto DettaglioEccezione
  201.             ByteArrayInputStream binTrasformazione = new ByteArrayInputStream(xml);
  202.             return (MessaggioDiagnostico) org.openspcoop2.utils.xml.JaxbUtils.xmlToObj(binTrasformazione, MessaggioDiagnostico.class);
  203.             
  204.         }catch(Exception e){
  205.             throw new XMLUtilsException(e.getMessage(),e);
  206.         }
  207.     }

  209.     public static MessaggioDiagnostico getMessaggioDiagnosticoFromJson(Logger log,InputStream is) throws XMLUtilsException{
  210.         try{            
  211.             if(log!=null) {
  212.                 //nop
  213.             }
  214.             JsonJacksonDeserializer deserializer = new JsonJacksonDeserializer();
  215.             return deserializer.readMessaggioDiagnostico(is);
  216.         }catch(Exception e){
  217.             throw new XMLUtilsException(e.getMessage(),e);
  218.         }
  219.     }
  220.     
  221.     
  222.     
  223.     
  224.     /* ----- Marshall ----- */
  225.     public static void generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,File out) throws XMLUtilsException{
  226.         generateMessaggioDiagnostico(messaggioDiagnostico, out, false, false);
  227.     }
  228.     public static void generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,File out,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  229.         try{
  230.             StringBuilder risultatoValidazione = new StringBuilder();
  231.             if(!XMLUtils.validate(messaggioDiagnostico, risultatoValidazione)){
  232.                 throw new XMLUtilsException(risultatoValidazione.toString());
  233.             }
  234.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(out.getName(),XMLUtils.generateMessaggioDiagnosticoEngine(messaggioDiagnostico, prettyDocument, omitXmlDeclaration));
  235.         }catch(Exception e){
  236.             throw new XMLUtilsException(e.getMessage(),e);
  237.         }
  238.     }
  239.     
  240.     public static void generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,String fileName) throws XMLUtilsException{
  241.         generateMessaggioDiagnostico(messaggioDiagnostico, fileName, false, false);
  242.     }
  243.     public static void generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,String fileName,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  244.         try{
  245.             StringBuilder risultatoValidazione = new StringBuilder();
  246.             if(!XMLUtils.validate(messaggioDiagnostico, risultatoValidazione)){
  247.                 throw new XMLUtilsException(risultatoValidazione.toString());
  248.             }
  249.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(fileName,XMLUtils.generateMessaggioDiagnosticoEngine(messaggioDiagnostico, prettyDocument, omitXmlDeclaration));
  250.         }catch(Exception e){
  251.             throw new XMLUtilsException(e.getMessage(),e);
  252.         }
  253.     }
  254.     
  255.     public static byte[] generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico) throws XMLUtilsException{
  256.         return generateMessaggioDiagnostico(messaggioDiagnostico,false, false);
  257.     }
  258.     public static byte[] generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  259.         try{
  260.             StringBuilder risultatoValidazione = new StringBuilder();
  261.             if(!XMLUtils.validate(messaggioDiagnostico, risultatoValidazione)){
  262.                 throw new XMLUtilsException(risultatoValidazione.toString());
  263.             }
  264.             return XMLUtils.generateMessaggioDiagnosticoEngine(messaggioDiagnostico, prettyDocument, omitXmlDeclaration);
  265.         }catch(Exception e){
  266.             throw new XMLUtilsException(e.getMessage(),e);
  267.         }
  268.     }

  270.     public static void generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,OutputStream out) throws XMLUtilsException{
  271.         generateMessaggioDiagnostico(messaggioDiagnostico, out, false, false);
  272.     }
  273.     public static void generateMessaggioDiagnostico(MessaggioDiagnostico messaggioDiagnostico,OutputStream out,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  274.         try{
  275.             StringBuilder risultatoValidazione = new StringBuilder();
  276.             if(!XMLUtils.validate(messaggioDiagnostico, risultatoValidazione)){
  277.                 throw new XMLUtilsException(risultatoValidazione.toString());
  278.             }
  279.             out.write(XMLUtils.generateMessaggioDiagnosticoEngine(messaggioDiagnostico, prettyDocument, omitXmlDeclaration));
  280.             out.flush();
  281.             out.close();
  282.         }catch(Exception e){
  283.             throw new XMLUtilsException(e.getMessage(),e);
  284.         }
  285.     }
  286.     
  287.     public static String generateMessaggioDiagnosticoAsJson(MessaggioDiagnostico messaggioDiagnostico) throws XMLUtilsException{
  288.         return generateMessaggioDiagnosticoAsJson(messaggioDiagnostico, false);
  289.     }
  290.     public static String generateMessaggioDiagnosticoAsJson(MessaggioDiagnostico messaggioDiagnostico,boolean prettyDocument) throws XMLUtilsException{
  291.         try{
  292.             StringBuilder risultatoValidazione = new StringBuilder();
  293.             if(!XMLUtils.validate(messaggioDiagnostico, risultatoValidazione)){
  294.                 throw new XMLUtilsException(risultatoValidazione.toString());
  295.             }
  296.             return XMLUtils.generateMessaggioDiagnosticoAsJsonEngine(messaggioDiagnostico, prettyDocument);
  297.         }catch(Exception e){
  298.             throw new XMLUtilsException(e.getMessage(),e);
  299.         }
  300.     }
  301.     
  302.     private static byte[] generateMessaggioDiagnosticoEngine(MessaggioDiagnostico messaggioDiagnostico,boolean prettyDocument, boolean omitXmlDeclaration) throws XMLUtilsException{
  303.         try{
  304.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  305.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(bout, MessaggioDiagnostico.class, messaggioDiagnostico, prettyDocument, omitXmlDeclaration);
  306.             return bout.toByteArray();
  307.         }catch(Exception e){
  308.             throw new XMLUtilsException(e.getMessage(),e);
  309.         }
  310.     }
  311.     
  312.     private static String generateMessaggioDiagnosticoAsJsonEngine(MessaggioDiagnostico messaggioDiagnostico,boolean prettyDocument) throws XMLUtilsException{
  313.         try{
  314.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  315.             messaggioDiagnostico.writeTo(bout, WriteToSerializerType.JSON_JACKSON, prettyDocument);
  316.             bout.flush();
  317.             bout.close();
  318.             return bout.toString();
  319.         }catch(Exception e){
  320.             throw new XMLUtilsException(e.getMessage(),e);
  321.         }
  322.     }
  323.     
  324.     
  325.     
  326.     
  327.     public static boolean isMessaggioDiagnostico(byte [] doc){
  328.         try{
  329.             org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  330.             Document docXML = xmlUtils.newDocument(doc);
  331.             Element elemXML = docXML.getDocumentElement();
  332.             return XMLUtils.isMessaggioDiagnostico_engine(elemXML);
  333.         }catch(Exception e){
  334.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  335.             return false;
  336.         }
  337.     }
  338.     public static boolean isMessaggioDiagnostico(Document docXML){
  339.         try{
  340.             Element elemXML = docXML.getDocumentElement();
  341.             return XMLUtils.isMessaggioDiagnostico_engine(elemXML);
  342.         }catch(Exception e){
  343.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  344.             return false;
  345.         }
  346.     }
  347.     public static boolean isMessaggioDiagnostico(Element elemXML){
  348.         return isMessaggioDiagnostico_engine(elemXML);
  349.     }
  350.     public static boolean isMessaggioDiagnostico(Node nodeXml){
  351.         return isMessaggioDiagnostico_engine(nodeXml);
  352.     }
  353.     private static boolean isMessaggioDiagnostico_engine(Node nodeXml){
  354.         try{
  355.             //System.out.println("LOCAL["+Costanti.ROOT_LOCAL_NAME_DETTAGLIO_ECCEZIONE+"]vs["+elemXML.getLocalName()+"]  NAMESPACE["+Costanti.TARGET_NAMESPACE+"]vs["+elemXML.getNamespaceURI()+"]");
  356.             if(CostantiDiagnostica.ROOT_LOCAL_NAME_MESSAGGIO_DIAGNOSTICO.equals(nodeXml.getLocalName()) && 
  357.                     CostantiDiagnostica.TARGET_NAMESPACE.equals(nodeXml.getNamespaceURI() ) 
  358.                 ){
  359.                 return true;
  360.             }
  361.             else{
  362.                 return false;
  363.             }
  364.         }catch(Exception e){
  365.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  366.             return false;
  367.         }
  368.     }
  369.     
  370. }
Created with JaCoCo 0.8.8.202204050719