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 it.cnipa.schemas._2003.egovit.exception1_0.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.message.OpenSPCoop2SoapMessage;
  39. import org.openspcoop2.utils.beans.WriteToSerializerType;
  40. import org.openspcoop2.utils.xml.AbstractValidatoreXSD;
  41. import org.slf4j.Logger;
  42. import org.w3c.dom.Document;
  43. import org.w3c.dom.Element;
  44. import org.w3c.dom.Node;

  46. import it.cnipa.schemas._2003.egovit.exception1_0.Eccezione;
  47. import it.cnipa.schemas._2003.egovit.exception1_0.EccezioneBusta;
  48. import it.cnipa.schemas._2003.egovit.exception1_0.EccezioneProcessamento;
  49. import it.cnipa.schemas._2003.egovit.exception1_0.MessaggioDiErroreApplicativo;
  50. import it.cnipa.schemas._2003.egovit.exception1_0.utils.serializer.JsonJacksonDeserializer;


  53. /**
  54.  * Classe utilizzata per la generazione MessaggioDiErroreApplicativo
  55.  *
  56.  *
  57.  * @author Poli Andrea (apoli@link.it)
  58.  * @author $Author$
  59.  * @version $Rev$, $Date$
  60.  */

  62. public class XMLUtils  {


  65.     public static boolean validate(MessaggioDiErroreApplicativo erroreApplicativo,StringBuilder motivoErroreValidazione){
  66.         
  67.         int size = motivoErroreValidazione.length();
  68.         
  69.         if(erroreApplicativo.getOraRegistrazione()==null){
  70.             motivoErroreValidazione.append("OraRegistrazione non definita\n");
  71.         }
  72.         
  73.         if(erroreApplicativo.getIdentificativoPorta()==null){
  74.             motivoErroreValidazione.append("IdentificativoPorta non definito\n");
  75.         }
  76.         
  77.         if(erroreApplicativo.getIdentificativoFunzione()==null){
  78.             motivoErroreValidazione.append("IdentificativoFunzione non definito\n");
  79.         }

  81.         
  82.         validate(erroreApplicativo.getEccezione(),motivoErroreValidazione); 
  83.         
  84.         if(motivoErroreValidazione.length()!=size)
  85.             return false;
  86.         else
  87.             return true;

  89.     }

  91.     private static void validate(Eccezione eccezione,StringBuilder motivoErroreValidazione){
  92.         if(eccezione==null){
  93.             motivoErroreValidazione.append("Eccezione non definita\n");
  94.         }
  95.         else{
  96.             if(eccezione.getEccezioneBusta()==null && eccezione.getEccezioneProcessamento()==null){
  97.                 motivoErroreValidazione.append("Nessuna eccezione (busta o processamento) definita\n");
  98.             }
  99.             else if(eccezione.getEccezioneBusta()!=null && eccezione.getEccezioneProcessamento()!=null){
  100.                 motivoErroreValidazione.append("Entrambe le eccezioni (busta o processamento) sono definite\n");
  101.             }
  102.             else{
  103.                 if(eccezione.getEccezioneBusta()!=null){
  104.                     validate(eccezione.getEccezioneBusta(),motivoErroreValidazione);
  105.                 }
  106.                 else{
  107.                     validate(eccezione.getEccezioneProcessamento(),motivoErroreValidazione);
  108.                 }
  109.             }
  110.         }
  111.     }
  112.     
  113.     private static void validate(EccezioneBusta eccezione,StringBuilder motivoErroreValidazione){
  114.         if(eccezione==null){
  115.             motivoErroreValidazione.append("EccezioneBusta non definita\n");
  116.         }
  117.         else{
  118.             if(eccezione.getCodiceEccezione()==null){
  119.                 motivoErroreValidazione.append("EccezioneBusta.codiceEccezione non definito\n");
  120.             }
  121.             if(eccezione.getDescrizioneEccezione()==null){
  122.                 motivoErroreValidazione.append("EccezioneBusta.descrizioneEccezione non definito\n");
  123.             }
  124.         }
  125.     }
  126.     
  127.     private static void validate(EccezioneProcessamento eccezione,StringBuilder motivoErroreValidazione){
  128.         if(eccezione==null){
  129.             motivoErroreValidazione.append("EccezioneProcessamento non definita\n");
  130.         }
  131.         else{
  132.             if(eccezione.getCodiceEccezione()==null){
  133.                 motivoErroreValidazione.append("EccezioneProcessamento.codiceEccezione non definito\n");
  134.             }
  135.             if(eccezione.getDescrizioneEccezione()==null){
  136.                 motivoErroreValidazione.append("EccezioneProcessamento.descrizioneEccezione non definito\n");
  137.             }
  138.         }
  139.     }
  140.     
  141.     
  142.     
  143.     /* ----- Unmarshall ----- */
  144.     
  145.     /**
  146.      * Ritorna la rappresentazione java
  147.      * 
  148.      * @param m byte[]
  149.      * @return ErroreApplicativo
  150.      * @throws XMLUtilsException
  151.      */
  152.     public static MessaggioDiErroreApplicativo getErroreApplicativo(Logger log,byte[] m) throws XMLUtilsException{
  153.         ByteArrayInputStream bin = null;
  154.         try{
  155.             bin = new ByteArrayInputStream(m);
  156.             return XMLUtils.getErroreApplicativo(log,bin);
  157.         }catch(Exception e){
  158.             throw new XMLUtilsException(e.getMessage(),e);
  159.         }finally{
  160.             try{
  161.                 if(bin!=null)
  162.                     bin.close();
  163.             }catch(Exception eClose){
  164.                 // close
  165.             }
  166.         }
  167.     }
  168.     
  169.     /**
  170.      * Ritorna la rappresentazione java
  171.      * 
  172.      * @param m File
  173.      * @return ErroreApplicativo
  174.      * @throws XMLUtilsException
  175.      */
  176.     public static MessaggioDiErroreApplicativo getErroreApplicativo(Logger log,File m) throws XMLUtilsException{
  177.         FileInputStream fin = null;
  178.         try{
  179.             fin = new FileInputStream(m);
  180.             return XMLUtils.getErroreApplicativo(log,fin);
  181.         }catch(Exception e){
  182.             throw new XMLUtilsException(e.getMessage(),e);
  183.         }finally{
  184.             try{
  185.                 if(fin!=null)
  186.                     fin.close();
  187.             }catch(Exception eClose){
  188.                 // close
  189.             }
  190.         }
  191.     }
  192.     
  193.     /**
  194.      * Ritorna la rappresentazione java
  195.      * 
  196.      * @param m String
  197.      * @return ErroreApplicativo
  198.      * @throws XMLUtilsException
  199.      */
  200.     public static MessaggioDiErroreApplicativo getErroreApplicativo(Logger log,String m) throws XMLUtilsException{
  201.         return XMLUtils.getErroreApplicativo(log,m.getBytes());
  202.     }
  203.     
  204.     /**
  205.      * Ritorna la rappresentazione java
  206.      * 
  207.      * @param m InputStream
  208.      * @return ErroreApplicativo
  209.      * @throws XMLUtilsException
  210.      */
  211.     public static MessaggioDiErroreApplicativo getErroreApplicativo(Logger log,InputStream m) throws XMLUtilsException{
  212.         try{
  213.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  214.             byte[]reads = new byte[1024];
  215.             int letti = 0;
  216.             while( (letti=m.read(reads)) != -1){
  217.                 bout.write(reads, 0, letti);
  218.             }
  219.             bout.flush();
  220.             bout.close();
  221.             byte [] xml = bout.toByteArray();
  222.             
  223.             // Validazione XSD
  224.             ByteArrayInputStream binValidazione = new ByteArrayInputStream(xml);
  225.             AbstractValidatoreXSD validatoreXSD = XSDValidator.getXSDValidator(log);
  226.             validatoreXSD.valida(binValidazione);
  227.             
  228.             // trasformazione in oggetto ErroreApplicativo
  229.             ByteArrayInputStream binTrasformazione = new ByteArrayInputStream(xml);
  230.             return (MessaggioDiErroreApplicativo) org.openspcoop2.utils.xml.JaxbUtils.xmlToObj(binTrasformazione, MessaggioDiErroreApplicativo.class);
  231.             
  232.         }catch(Exception e){
  233.             throw new XMLUtilsException(e.getMessage(),e);
  234.         }
  235.     }
  236.     
  237.     public static MessaggioDiErroreApplicativo getErroreApplicativoFromJson(Logger log,InputStream is) throws XMLUtilsException{
  238.         try{            
  239.             JsonJacksonDeserializer deserializer = new JsonJacksonDeserializer();
  240.             return deserializer.readMessaggioDiErroreApplicativo(is);
  241.         }catch(Exception e){
  242.             throw new XMLUtilsException(e.getMessage(),e);
  243.         }
  244.     }

  246.     
  247.     
  248.     
  249.     
  250.     /* ----- Marshall ----- */
  251.     public static void generateErroreApplicativo(MessaggioDiErroreApplicativo eccezione,File out) throws XMLUtilsException{
  252.         try{
  253.             StringBuilder risultatoValidazione = new StringBuilder();
  254.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  255.                 throw new Exception(risultatoValidazione.toString());
  256.             }
  257.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(out.getName(),XMLUtils.generateErroreApplicativo_engine(eccezione));
  258.         }catch(Exception e){
  259.             throw new XMLUtilsException(e.getMessage(),e);
  260.         }
  261.     }
  262.     
  263.     public static void generateErroreApplicativo(MessaggioDiErroreApplicativo eccezione,String fileName) throws XMLUtilsException{
  264.         try{
  265.             StringBuilder risultatoValidazione = new StringBuilder();
  266.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  267.                 throw new Exception(risultatoValidazione.toString());
  268.             }
  269.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(fileName,XMLUtils.generateErroreApplicativo_engine(eccezione));
  270.         }catch(Exception e){
  271.             throw new XMLUtilsException(e.getMessage(),e);
  272.         }
  273.     }
  274.     
  275.     public static byte[] generateErroreApplicativo(MessaggioDiErroreApplicativo eccezione) throws XMLUtilsException{
  276.         try{
  277.             StringBuilder risultatoValidazione = new StringBuilder();
  278.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  279.                 throw new Exception(risultatoValidazione.toString());
  280.             }
  281.             return XMLUtils.generateErroreApplicativo_engine(eccezione);
  282.         }catch(Exception e){
  283.             throw new XMLUtilsException(e.getMessage(),e);
  284.         }
  285.     }
  286.     
  287.     public static String generateErroreApplicativoAsJson(MessaggioDiErroreApplicativo eccezione) throws XMLUtilsException{
  288.         try{
  289.             StringBuilder risultatoValidazione = new StringBuilder();
  290.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  291.                 throw new Exception(risultatoValidazione.toString());
  292.             }
  293.             return XMLUtils.generateErroreApplicativoAsJson_engine(eccezione);
  294.         }catch(Exception e){
  295.             throw new XMLUtilsException(e.getMessage(),e);
  296.         }
  297.     }

  299.     public static void generateErroreApplicativo(MessaggioDiErroreApplicativo eccezione,OutputStream out) throws XMLUtilsException{
  300.         try{
  301.             StringBuilder risultatoValidazione = new StringBuilder();
  302.             if(XMLUtils.validate(eccezione, risultatoValidazione)==false){
  303.                 throw new Exception(risultatoValidazione.toString());
  304.             }
  305.             out.write(XMLUtils.generateErroreApplicativo_engine(eccezione));
  306.             out.flush();
  307.             out.close();
  308.         }catch(Exception e){
  309.             throw new XMLUtilsException(e.getMessage(),e);
  310.         }
  311.     }
  312.     
  313.     private static byte[] generateErroreApplicativo_engine(MessaggioDiErroreApplicativo eccezione) throws XMLUtilsException{
  314.         try{
  315.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  316.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(bout, MessaggioDiErroreApplicativo.class, eccezione);
  317.             bout.flush();
  318.             bout.close();
  319.             return bout.toByteArray();
  320.         }catch(Exception e){
  321.             throw new XMLUtilsException(e.getMessage(),e);
  322.         }
  323.     }
  324.     
  325.     private static String generateErroreApplicativoAsJson_engine(MessaggioDiErroreApplicativo eccezione) throws XMLUtilsException{
  326.         try{
  327.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  328.             eccezione.writeTo(bout, WriteToSerializerType.JSON_JACKSON);
  329.             bout.flush();
  330.             bout.close();
  331.             return bout.toString();
  332.         }catch(Exception e){
  333.             throw new XMLUtilsException(e.getMessage(),e);
  334.         }
  335.     }
  336.     
  337.     
  338.     
  339.     
  340.     public static MessaggioDiErroreApplicativo getErroreApplicativo(Logger log,OpenSPCoop2SoapMessage msg)throws XMLUtilsException{
  341.         try{
  342.             if(msg==null)
  343.                 throw new XMLUtilsException("Messaggio non presente");
  344.             SOAPBody soapBody = msg.getSOAPBody();
  345.             if(soapBody==null)
  346.                 throw new XMLUtilsException("SOAPBody non presente");
  347.             SOAPFault faultOriginale = null;
  348.             if(soapBody.hasFault()==false)
  349.                 return null; // casi di buste mal formate, verranno segnalate dal validatore
  350.             else
  351.                 faultOriginale = soapBody.getFault();
  352.             if(faultOriginale==null)
  353.                 throw new XMLUtilsException("SOAPFault is null");
  354.             
  355.             QName nameDetail = new QName("detail");
  356.             Iterator<?> itSF = faultOriginale.getChildElements(nameDetail);
  357.             SOAPElement detailsFaultOriginale = null;
  358.             if(itSF.hasNext()){
  359.                 detailsFaultOriginale = (SOAPElement) itSF.next();
  360.             }
  361.                 
  362.             msg.saveChanges();
  363.                 
  364.             if(detailsFaultOriginale!=null){
  365.                 Iterator<?> it = detailsFaultOriginale.getChildElements();
  366.                 while (it.hasNext()) {
  367.                     Object o = it.next();
  368.                     if(o instanceof SOAPElement){
  369.                         SOAPElement elem = (SOAPElement) o;
  370.                         try{
  371.                             if(XMLUtils.isErroreApplicativo(elem)){
  372.                                 //System.out.println("ITEM ["+elem.getLocalName()+"] TROVATO");
  373.                                 org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  374.                                 byte [] xml = xmlUtils.toByteArray(elem);
  375.                                 //System.out.println("XML S: "+new String(xml));
  376.                                 MessaggioDiErroreApplicativo de = XMLUtils.getErroreApplicativo(log,xml);
  377.                                 return de;
  378.                             }
  379.                         }catch(Exception e){
  380.                             e.printStackTrace(System.out);
  381.                         }
  382.                     }
  383.                 }
  384.             }
  385.                 
  386.             return null;
  387.         }catch(Exception e){
  388.             throw new XMLUtilsException(e.getMessage(),e);
  389.         }
  390.     }
  391.     
  392.     public static boolean isErroreApplicativo(byte [] doc){
  393.         try{
  394.             org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  395.             Document docXML = xmlUtils.newDocument(doc);
  396.             Element elemXML = docXML.getDocumentElement();
  397.             return XMLUtils.isErroreApplicativo_engine(elemXML);
  398.         }catch(Exception e){
  399.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  400.             return false;
  401.         }
  402.     }
  403.     public static boolean isErroreApplicativo(Document docXML){
  404.         try{
  405.             Element elemXML = docXML.getDocumentElement();
  406.             return XMLUtils.isErroreApplicativo_engine(elemXML);
  407.         }catch(Exception e){
  408.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  409.             return false;
  410.         }
  411.     }
  412.     public static boolean isErroreApplicativo(Element elemXML){
  413.         return isErroreApplicativo_engine(elemXML);
  414.     }
  415.     public static boolean isErroreApplicativo(Node nodeXml){
  416.         return isErroreApplicativo_engine(nodeXml);
  417.     }
  418.     private static boolean isErroreApplicativo_engine(Node nodeXml){
  419.         try{
  420.             //System.out.println("LOCAL["+Costanti.ROOT_LOCAL_NAME_DETTAGLIO_ECCEZIONE+"]vs["+elemXML.getLocalName()+"]  NAMESPACE["+Costanti.TARGET_NAMESPACE+"]vs["+elemXML.getNamespaceURI()+"]");
  421.             if("MessaggioDiErroreApplicativo".equals(nodeXml.getLocalName()) && 
  422.                     ProjectInfo.getInstance().getProjectNamespace().equals(nodeXml.getNamespaceURI() ) 
  423.                 ){
  424.                 return true;
  425.             }
  426.             else{
  427.                 return false;
  428.             }
  429.         }catch(Exception e){
  430.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  431.             return false;
  432.         }
  433.     }
  434.     
  435. }
Created with JaCoCo 0.8.8.202204050719