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.eccezione.errore_applicativo.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;
  31. import java.util.Iterator;

  33. import javax.xml.namespace.QName;
  34. import javax.xml.soap.SOAPBody;
  35. import javax.xml.soap.SOAPElement;
  36. import javax.xml.soap.SOAPFault;

  38. import org.openspcoop2.core.eccezione.errore_applicativo.DatiCooperazione;
  39. import org.openspcoop2.core.eccezione.errore_applicativo.Dominio;
  40. import org.openspcoop2.core.eccezione.errore_applicativo.Eccezione;
  41. import org.openspcoop2.core.eccezione.errore_applicativo.ErroreApplicativo;
  42. import org.openspcoop2.core.eccezione.errore_applicativo.Servizio;
  43. import org.openspcoop2.core.eccezione.errore_applicativo.Soggetto;
  44. import org.openspcoop2.core.eccezione.errore_applicativo.constants.Costanti;
  45. import org.openspcoop2.core.eccezione.errore_applicativo.utils.serializer.JsonJacksonDeserializer;
  46. import org.openspcoop2.message.OpenSPCoop2Message;
  47. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  48. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  49. import org.openspcoop2.message.OpenSPCoop2RestXmlMessage;
  50. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  51. import org.openspcoop2.message.xml.ValidatoreXSD;
  52. import org.openspcoop2.utils.beans.WriteToSerializerType;
  53. import org.slf4j.Logger;
  54. import org.w3c.dom.Document;
  55. import org.w3c.dom.Element;
  56. import org.w3c.dom.Node;


  59. /**
  60.  * Classe utilizzata per la generazione il detail errore-applicativo inseriti in un SOAPFault generato dalla PdD in caso di errore di processamento
  61.  *
  62.  *
  63.  * @author Poli Andrea (apoli@link.it)
  64.  * @author $Author$
  65.  * @version $Rev$, $Date$
  66.  */

  68. public class XMLUtils  {

  70.     /** Validatore XSD */
  71.     static ValidatoreXSD validatoreXSD = null;
  72.     private static synchronized void initValidatoreXSD(Logger log) throws Exception{
  73.         if(XMLUtils.validatoreXSD==null){
  74.             XMLUtils.validatoreXSD = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), log,XMLUtils.class.getResourceAsStream("/openspcoopErroreApplicativo.xsd"));
  75.         }
  76.     }
  77.     public static ValidatoreXSD getValidatoreXSD(Logger log) throws Exception{
  78.         if(XMLUtils.validatoreXSD==null){
  79.             initValidatoreXSD(log);
  80.         }
  81.         return XMLUtils.validatoreXSD;
  82.     }
  83.     public static boolean validate(ErroreApplicativo erroreApplicativo,StringBuilder motivoErroreValidazione){
  84.         
  85.         int size = motivoErroreValidazione.length();
  86.         
  87.         if(erroreApplicativo.getDomain()==null){
  88.             motivoErroreValidazione.append("Dominio non definito\n");
  89.         }
  90.         else{
  91.             validate(erroreApplicativo.getDomain(), motivoErroreValidazione);
  92.         }
  93.         
  94.         if(erroreApplicativo.getTimestamp()==null){
  95.             motivoErroreValidazione.append("OraRegistrazione non definita\n");
  96.         }
  97.         
  98.         if(erroreApplicativo.getService()!=null){
  99.             validate(erroreApplicativo.getService(), motivoErroreValidazione);
  100.         }
  101.         
  102.         validate(erroreApplicativo.getException(),motivoErroreValidazione); 
  103.         
  104.         if(motivoErroreValidazione.length()!=size)
  105.             return false;
  106.         else
  107.             return true;

  109.     }
  110.     private static void validate(Dominio dominio,StringBuilder motivoErroreValidazione){
  111.         if(dominio.getId()==null){
  112.             motivoErroreValidazione.append("Dominio.id non definito\n");
  113.         }
  114.         if(dominio.getRole()==null){
  115.             motivoErroreValidazione.append("Dominio.funzione non definito\n");
  116.         }
  117.         if(dominio.getModule()==null){
  118.             motivoErroreValidazione.append("Dominio.modulo non definito\n");
  119.         }
  120.         if(dominio.getOrganization()==null){
  121.             motivoErroreValidazione.append("Dominio.soggetto non definita\n");
  122.         }
  123.         else{
  124.             if(dominio.getOrganization().getType()==null){
  125.                 motivoErroreValidazione.append("Dominio.soggetto.tipo non definita\n");
  126.             }
  127.             if(dominio.getOrganization().getBase()==null){
  128.                 motivoErroreValidazione.append("Dominio.soggetto.nome non definita\n");
  129.             }
  130.         }
  131.     }
  132.     private static void validate(DatiCooperazione datiCooperazione,StringBuilder motivoErroreValidazione){
  133.         if(datiCooperazione.getSender()!=null){
  134.             validate(datiCooperazione.getSender(), motivoErroreValidazione, "mittente");
  135.         }
  136.         if(datiCooperazione.getProvider()!=null){
  137.             validate(datiCooperazione.getProvider(), motivoErroreValidazione , "destinatario");
  138.         }
  139.         if(datiCooperazione.getService()!=null){
  140.             validate(datiCooperazione.getService(), motivoErroreValidazione);
  141.         }
  142.     }
  143.     private static void validate(Soggetto soggetto,StringBuilder motivoErroreValidazione,String tipo){
  144.         if(soggetto.getId()==null){
  145.             motivoErroreValidazione.append("DatiCooperazione."+tipo+".identificativo non definita\n");
  146.         }
  147.         else{
  148.             if(soggetto.getId().getType()==null){
  149.                 motivoErroreValidazione.append("DatiCooperazione."+tipo+".identificativo.tipo non definita\n");
  150.             }
  151.             if(soggetto.getId().getBase()==null){
  152.                 motivoErroreValidazione.append("DatiCooperazione."+tipo+".identificativo.base non definita\n");
  153.             }
  154.         }
  155.         if(soggetto.getDomainId()==null){
  156.             motivoErroreValidazione.append("DatiCooperazione."+tipo+".identificativoPorta non definita\n");
  157.         }
  158.     }
  159.     private static void validate(Servizio servizio,StringBuilder motivoErroreValidazione){
  160.         if(servizio.getBase()==null){
  161.             motivoErroreValidazione.append("DatiCooperazione.servizio.base non definita\n");
  162.         }
  163.         if(servizio.getType()==null){
  164.             motivoErroreValidazione.append("DatiCooperazione.servizio.tipo non definita\n");
  165.         }
  166.     }
  167.     private static void validate(Eccezione eccezione,StringBuilder motivoErroreValidazione){
  168.         if(eccezione==null){
  169.             motivoErroreValidazione.append("Eccezione non definita\n");
  170.         }
  171.         else{
  172.             if(eccezione.getCode()==null){
  173.                 motivoErroreValidazione.append("Eccezione.codice non definito\n");
  174.             }
  175.             else{
  176.                 if(eccezione.getCode().getBase()==null){
  177.                     motivoErroreValidazione.append("Eccezione.codice.base non definito\n");
  178.                 }
  179.                 if(eccezione.getCode().getType()==null){
  180.                     motivoErroreValidazione.append("Eccezione.codice.tipo non definito\n");
  181.                 }
  182.             }
  183.             if(eccezione.getDescription()==null){
  184.                 motivoErroreValidazione.append("Eccezione.descrizione non definito\n");
  185.             }
  186.             if(eccezione.getType()==null){
  187.                 motivoErroreValidazione.append("Eccezione.tipo non definito\n");
  188.             }
  189.         }
  190.     }
  191.     
  192.     
  193.     /* ----- Unmarshall ----- */
  194.     
  195.     /**
  196.      * Ritorna la rappresentazione java
  197.      * 
  198.      * @param m byte[]
  199.      * @return ErroreApplicativo
  200.      * @throws XMLUtilsException
  201.      */
  202.     public static ErroreApplicativo getErroreApplicativo(Logger log,byte[] m) throws XMLUtilsException{
  203.         ByteArrayInputStream bin = null;
  204.         try{
  205.             bin = new ByteArrayInputStream(m);
  206.             return XMLUtils.getErroreApplicativo(log,bin);
  207.         }catch(Exception e){
  208.             throw new XMLUtilsException(e.getMessage(),e);
  209.         }finally{
  210.             try{
  211.                 if(bin!=null)
  212.                     bin.close();
  213.             }catch(Exception eClose){
  214.                 // close
  215.             }
  216.         }
  217.     }
  218.     
  219.     /**
  220.      * Ritorna la rappresentazione java
  221.      * 
  222.      * @param m File
  223.      * @return ErroreApplicativo
  224.      * @throws XMLUtilsException
  225.      */
  226.     public static ErroreApplicativo getErroreApplicativo(Logger log,File m) throws XMLUtilsException{
  227.         FileInputStream fin = null;
  228.         try{
  229.             fin = new FileInputStream(m);
  230.             return XMLUtils.getErroreApplicativo(log,fin);
  231.         }catch(Exception e){
  232.             throw new XMLUtilsException(e.getMessage(),e);
  233.         }finally{
  234.             try{
  235.                 if(fin!=null)
  236.                     fin.close();
  237.             }catch(Exception eClose){
  238.                 // close
  239.             }
  240.         }
  241.     }
  242.     
  243.     /**
  244.      * Ritorna la rappresentazione java
  245.      * 
  246.      * @param m String
  247.      * @return ErroreApplicativo
  248.      * @throws XMLUtilsException
  249.      */
  250.     public static ErroreApplicativo getErroreApplicativo(Logger log,String m) throws XMLUtilsException{
  251.         return XMLUtils.getErroreApplicativo(log,m.getBytes());
  252.     }
  253.     
  254.     /**
  255.      * Ritorna la rappresentazione java
  256.      * 
  257.      * @param m InputStream
  258.      * @return ErroreApplicativo
  259.      * @throws XMLUtilsException
  260.      */
  261.     public static ErroreApplicativo getErroreApplicativo(Logger log,InputStream m) throws XMLUtilsException{
  262.         try{
  263.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  264.             byte[]reads = new byte[1024];
  265.             int letti = 0;
  266.             while( (letti=m.read(reads)) != -1){
  267.                 bout.write(reads, 0, letti);
  268.             }
  269.             bout.flush();
  270.             bout.close();
  271.             byte [] xml = bout.toByteArray();
  272.             
  273.             // Validazione XSD
  274.             ByteArrayInputStream binValidazione = new ByteArrayInputStream(xml);
  275.             ValidatoreXSD validatoreXSD = XMLUtils.getValidatoreXSD(log);
  276.             validatoreXSD.valida(binValidazione);
  277.             
  278.             // trasformazione in oggetto ErroreApplicativo
  279.             ByteArrayInputStream binTrasformazione = new ByteArrayInputStream(xml);
  280.             return (ErroreApplicativo) org.openspcoop2.utils.xml.JaxbUtils.xmlToObj(binTrasformazione, ErroreApplicativo.class);
  281.             
  282.         }catch(Exception e){
  283.             throw new XMLUtilsException(e.getMessage(),e);
  284.         }
  285.     }
  286.     
  287.     public static ErroreApplicativo getErroreApplicativoFromJson(Logger log,InputStream is) throws XMLUtilsException{
  288.         try{            
  289.             JsonJacksonDeserializer deserializer = new JsonJacksonDeserializer();
  290.             return deserializer.readErroreApplicativo(is);
  291.         }catch(Exception e){
  292.             throw new XMLUtilsException(e.getMessage(),e);
  293.         }
  294.     }

  296.     
  297.     
  298.     
  299.     
  300.     /* ----- Marshall ----- */
  301.     public static void generateErroreApplicativo(ErroreApplicativo eccezione,File out) throws XMLUtilsException{
  302.         try{
  303.             StringBuilder risultatoValidazione = new StringBuilder();
  304.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  305.                 throw new Exception(risultatoValidazione.toString());
  306.             }
  307.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(out.getName(),XMLUtils.generateErroreApplicativo_engine(eccezione));
  308.         }catch(Exception e){
  309.             throw new XMLUtilsException(e.getMessage(),e);
  310.         }
  311.     }
  312.     
  313.     public static void generateErroreApplicativo(ErroreApplicativo eccezione,String fileName) throws XMLUtilsException{
  314.         try{
  315.             StringBuilder risultatoValidazione = new StringBuilder();
  316.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  317.                 throw new Exception(risultatoValidazione.toString());
  318.             }
  319.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(fileName,XMLUtils.generateErroreApplicativo_engine(eccezione));
  320.         }catch(Exception e){
  321.             throw new XMLUtilsException(e.getMessage(),e);
  322.         }
  323.     }
  324.     
  325.     public static byte[] generateErroreApplicativo(ErroreApplicativo eccezione) throws XMLUtilsException{
  326.         try{
  327.             StringBuilder risultatoValidazione = new StringBuilder();
  328.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  329.                 throw new Exception(risultatoValidazione.toString());
  330.             }
  331.             return XMLUtils.generateErroreApplicativo_engine(eccezione);
  332.         }catch(Exception e){
  333.             throw new XMLUtilsException(e.getMessage(),e);
  334.         }
  335.     }
  336.     
  337.     public static String generateErroreApplicativoAsJson(ErroreApplicativo eccezione) throws XMLUtilsException{
  338.         try{
  339.             StringBuilder risultatoValidazione = new StringBuilder();
  340.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  341.                 throw new Exception(risultatoValidazione.toString());
  342.             }
  343.             return XMLUtils.generateErroreApplicativoAsJson_engine(eccezione);
  344.         }catch(Exception e){
  345.             throw new XMLUtilsException(e.getMessage(),e);
  346.         }
  347.     }

  349.     public static void generateErroreApplicativo(ErroreApplicativo eccezione,OutputStream out) throws XMLUtilsException{
  350.         try{
  351.             StringBuilder risultatoValidazione = new StringBuilder();
  352.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  353.                 throw new Exception(risultatoValidazione.toString());
  354.             }
  355.             out.write(XMLUtils.generateErroreApplicativo_engine(eccezione));
  356.             out.flush();
  357.             out.close();
  358.         }catch(Exception e){
  359.             throw new XMLUtilsException(e.getMessage(),e);
  360.         }
  361.     }
  362.     
  363.     private static byte[] generateErroreApplicativo_engine(ErroreApplicativo eccezione) throws XMLUtilsException{
  364.         try{
  365.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  366.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(bout, ErroreApplicativo.class, eccezione);
  367.             bout.flush();
  368.             bout.close();
  369.             return bout.toByteArray();
  370.         }catch(Exception e){
  371.             throw new XMLUtilsException(e.getMessage(),e);
  372.         }
  373.     }
  374.     
  375.     private static String generateErroreApplicativoAsJson_engine(ErroreApplicativo eccezione) throws XMLUtilsException{
  376.         try{
  377.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  378.             eccezione.writeTo(bout, WriteToSerializerType.JSON_JACKSON);
  379.             bout.flush();
  380.             bout.close();
  381.             return bout.toString();
  382.         }catch(Exception e){
  383.             throw new XMLUtilsException(e.getMessage(),e);
  384.         }
  385.     }
  386.     
  387.     
  388.     
  389.     public static ErroreApplicativo getErroreApplicativo(Logger log,OpenSPCoop2Message msg)throws XMLUtilsException{
  390.         switch (msg.getMessageType()) {
  391.         case SOAP_11:
  392.         case SOAP_12:
  393.             try{
  394.                 return getErroreApplicativo(log, msg.castAsSoap());
  395.             }catch(XMLUtilsException e){
  396.                 throw e;
  397.             }catch(Exception e){
  398.                 throw new XMLUtilsException(e.getMessage(),e);
  399.             }
  400.         case XML:
  401.             try{
  402.                 OpenSPCoop2RestXmlMessage rest = msg.castAsRestXml();
  403.                 if(rest.hasContent()){
  404.                     Element element = rest.getContent();
  405.                     if(XMLUtils.isErroreApplicativo(element)){
  406.                         org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  407.                         byte [] xml = xmlUtils.toByteArray(element);
  408.                         //System.out.println("XML S: "+new String(xml));
  409.                         ErroreApplicativo errore = XMLUtils.getErroreApplicativo(log,xml);
  410.                         return errore;
  411.                     }
  412.                 }
  413.                 return null;
  414.             }catch(XMLUtilsException e){
  415.                 throw e;
  416.             }catch(Exception e){
  417.                 throw new XMLUtilsException(e.getMessage(),e);
  418.             }
  419.         case JSON:
  420.             try{
  421.                 OpenSPCoop2RestJsonMessage rest = msg.castAsRestJson();
  422.                 if(rest.hasContent()){
  423.                     String json = rest.getContent();
  424.                     try{
  425.                         ErroreApplicativo errore = XMLUtils.getErroreApplicativoFromJson(log, new ByteArrayInputStream(json.getBytes()));
  426.                         return errore;
  427.                     }catch(Exception e){}
  428.                 }
  429.                 return null;
  430.             }catch(Exception e){
  431.                 throw new XMLUtilsException(e.getMessage(),e);
  432.             }
  433.         default:
  434.             return null;
  435.         }
  436.     }
  437.     public static ErroreApplicativo getErroreApplicativo(Logger log,OpenSPCoop2SoapMessage msg)throws XMLUtilsException{
  438.         try{
  439.             if(msg==null)
  440.                 throw new XMLUtilsException("Messaggio non presente");
  441.             SOAPBody soapBody = msg.getSOAPBody();
  442.             if(soapBody==null)
  443.                 throw new XMLUtilsException("SOAPBody non presente");
  444.             SOAPFault faultOriginale = null;
  445.             if(soapBody.hasFault()==false)
  446.                 return null; // casi di buste mal formate, verranno segnalate dal validatore
  447.             else
  448.                 faultOriginale = soapBody.getFault();
  449.             if(faultOriginale==null)
  450.                 throw new XMLUtilsException("SOAPFault is null");
  451.             
  452.             QName nameDetail = new QName("detail");
  453.             Iterator<?> itSF = faultOriginale.getChildElements(nameDetail);
  454.             SOAPElement detailsFaultOriginale = null;
  455.             if(itSF.hasNext()){
  456.                 detailsFaultOriginale = (SOAPElement) itSF.next();
  457.             }
  458.                 
  459.             msg.saveChanges();
  460.                 
  461.             if(detailsFaultOriginale!=null){
  462.                 Iterator<?> it = detailsFaultOriginale.getChildElements();
  463.                 while (it.hasNext()) {
  464.                     Object o = it.next();
  465.                     if(o instanceof SOAPElement){
  466.                         SOAPElement elem = (SOAPElement) o;
  467.                         try{
  468.                             if(XMLUtils.isErroreApplicativo(elem)){
  469.                                 //System.out.println("ITEM ["+elem.getLocalName()+"] TROVATO");
  470.                                 org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  471.                                 byte [] xml = xmlUtils.toByteArray(elem);
  472.                                 //System.out.println("XML S: "+new String(xml));
  473.                                 ErroreApplicativo de = XMLUtils.getErroreApplicativo(log,xml);
  474.                                 return de;
  475.                             }
  476.                         }catch(Exception e){
  477.                             e.printStackTrace(System.out);
  478.                         }
  479.                     }
  480.                 }
  481.             }
  482.                 
  483.             return null;
  484.         }catch(Exception e){
  485.             throw new XMLUtilsException(e.getMessage(),e);
  486.         }
  487.     }
  488.     
  489.     public static boolean isErroreApplicativo(byte [] doc){
  490.         try{
  491.             org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  492.             Document docXML = xmlUtils.newDocument(doc);
  493.             Element elemXML = docXML.getDocumentElement();
  494.             return XMLUtils.isErroreApplicativo_engine(elemXML);
  495.         }catch(Exception e){
  496.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  497.             return false;
  498.         }
  499.     }
  500.     public static boolean isErroreApplicativo(Document docXML){
  501.         try{
  502.             Element elemXML = docXML.getDocumentElement();
  503.             return XMLUtils.isErroreApplicativo_engine(elemXML);
  504.         }catch(Exception e){
  505.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  506.             return false;
  507.         }
  508.     }
  509.     public static boolean isErroreApplicativo(Element elemXML){
  510.         return isErroreApplicativo_engine(elemXML);
  511.     }
  512.     public static boolean isErroreApplicativo(Node nodeXml){
  513.         return isErroreApplicativo_engine(nodeXml);
  514.     }
  515.     private static boolean isErroreApplicativo_engine(Node nodeXml){
  516.         try{
  517.             //System.out.println("LOCAL["+Costanti.ROOT_LOCAL_NAME_ERRORE_APPLICATIVO+"]vs["+nodeXml.getLocalName()+"]  NAMESPACE["+Costanti.TARGET_NAMESPACE+"]vs["+nodeXml.getNamespaceURI()+"]");
  518.             if(Costanti.ROOT_LOCAL_NAME_ERRORE_APPLICATIVO.equals(nodeXml.getLocalName()) && 
  519.                     Costanti.TARGET_NAMESPACE.equals(nodeXml.getNamespaceURI() ) 
  520.                 ){
  521.                 return true;
  522.             }
  523.             else{
  524.                 return false;
  525.             }
  526.         }catch(Exception e){
  527.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  528.             return false;
  529.         }
  530.     }
  531.     
  532. }
Created with JaCoCo 0.8.8.202204050719