EsitoRichiestaXMLUtils.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.integrazione.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.integrazione.EsitoRichiesta;
  34. import org.openspcoop2.core.integrazione.constants.Costanti;
  35. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  36. import org.openspcoop2.message.xml.ValidatoreXSD;
  37. import org.openspcoop2.utils.beans.WriteToSerializerType;
  38. import org.openspcoop2.utils.xml.XSDResourceResolver;
  39. import org.w3c.dom.Document;
  40. import org.w3c.dom.Element;
  41. import org.w3c.dom.Node;


  44. /**
  45.  * Classe utilizzata per la generazione dei dati di esitoRichiesta
  46.  *
  47.  *
  48.  * @author Poli Andrea (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */

  53. public class EsitoRichiestaXMLUtils  {

  55.     /** Validatore XSD */
  56.     static ValidatoreXSD validatoreXSD = null;
  57.     private static synchronized void initValidatoreXSD(Logger log) throws Exception{
  58.         if(EsitoRichiestaXMLUtils.validatoreXSD==null){
  59.             XSDResourceResolver xsdResourceResolver = new XSDResourceResolver();
  60.             xsdResourceResolver.addResource("soapEnvelope.xsd", EsitoRichiestaXMLUtils.class.getResourceAsStream("/soapEnvelope.xsd"));
  61.             EsitoRichiestaXMLUtils.validatoreXSD = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), log,xsdResourceResolver,EsitoRichiestaXMLUtils.class.getResourceAsStream("/openspcoopPresaInCarico.xsd"));
  62.         }
  63.     }
  64.     public static ValidatoreXSD getValidatoreXSD(Logger log) throws Exception{
  65.         if(EsitoRichiestaXMLUtils.validatoreXSD==null){
  66.             initValidatoreXSD(log);
  67.         }
  68.         return EsitoRichiestaXMLUtils.validatoreXSD;
  69.     }
  70.     
  71.     public static boolean validate(EsitoRichiesta esito,StringBuilder motivoErroreValidazione){
  72.         int size = motivoErroreValidazione.length();
  73.         
  74.         if(esito.getMessageId()==null){
  75.             motivoErroreValidazione.append("Identificativo Messaggio non definito\n");
  76.         }
  77.         if(esito.getState()==null){
  78.             motivoErroreValidazione.append("Stato non definito\n");
  79.         }
  80.         
  81.         if(motivoErroreValidazione.length()!=size)
  82.             return false;
  83.         else
  84.             return true;
  85.     }
  86.     
  87.     
  88.     
  89.     /* ----- Unmarshall ----- */
  90.     
  91.     /**
  92.      * Ritorna la rappresentazione java
  93.      * 
  94.      * @param m byte[]
  95.      * @return DettaglioEccezione
  96.      * @throws XMLUtilsException
  97.      */
  98.     public static EsitoRichiesta getEsitoRichiesta(Logger log,byte[] m) throws XMLUtilsException{
  99.         ByteArrayInputStream bin = null;
  100.         try{
  101.             bin = new ByteArrayInputStream(m);
  102.             return EsitoRichiestaXMLUtils.getEsitoRichiesta(log,bin);
  103.         }catch(Exception e){
  104.             throw new XMLUtilsException(e.getMessage(),e);
  105.         }finally{
  106.             try{
  107.                 if(bin!=null)
  108.                     bin.close();
  109.             }catch(Exception eClose){
  110.                 // close
  111.             }
  112.         }
  113.     }
  114.     
  115.     /**
  116.      * Ritorna la rappresentazione java
  117.      * 
  118.      * @param m File
  119.      * @return DettaglioEccezione
  120.      * @throws XMLUtilsException
  121.      */
  122.     public static EsitoRichiesta getEsitoRichiesta(Logger log,File m) throws XMLUtilsException{
  123.         FileInputStream fin = null;
  124.         try{
  125.             fin = new FileInputStream(m);
  126.             return EsitoRichiestaXMLUtils.getEsitoRichiesta(log,fin);
  127.         }catch(Exception e){
  128.             throw new XMLUtilsException(e.getMessage(),e);
  129.         }finally{
  130.             try{
  131.                 if(fin!=null)
  132.                     fin.close();
  133.             }catch(Exception eClose){
  134.                 // close
  135.             }
  136.         }
  137.     }
  138.     
  139.     /**
  140.      * Ritorna la rappresentazione java
  141.      * 
  142.      * @param m String
  143.      * @return DettaglioEccezione
  144.      * @throws XMLUtilsException
  145.      */
  146.     public static EsitoRichiesta getEsitoRichiesta(Logger log,String m) throws XMLUtilsException{
  147.         return EsitoRichiestaXMLUtils.getEsitoRichiesta(log,m.getBytes());
  148.     }
  149.     
  150.     /**
  151.      * Ritorna la rappresentazione java
  152.      * 
  153.      * @param m InputStream
  154.      * @return DettaglioEccezione
  155.      * @throws XMLUtilsException
  156.      */
  157.     public static EsitoRichiesta getEsitoRichiesta(Logger log,InputStream m) throws XMLUtilsException{
  158.         try{
  159.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  160.             byte[]reads = new byte[1024];
  161.             int letti = 0;
  162.             while( (letti=m.read(reads)) != -1){
  163.                 bout.write(reads, 0, letti);
  164.             }
  165.             bout.flush();
  166.             bout.close();
  167.             byte [] xml = bout.toByteArray();
  168.             
  169.             // Validazione XSD
  170.             ByteArrayInputStream binValidazione = new ByteArrayInputStream(xml);
  171.             ValidatoreXSD validatoreXSD = EsitoRichiestaXMLUtils.getValidatoreXSD(log);
  172.             validatoreXSD.valida(binValidazione);
  173.             
  174.             // trasformazione in oggetto DettaglioEccezione
  175.             ByteArrayInputStream binTrasformazione = new ByteArrayInputStream(xml);
  176.             return (EsitoRichiesta) org.openspcoop2.utils.xml.JaxbUtils.xmlToObj(binTrasformazione, EsitoRichiesta.class);
  177.             
  178.         }catch(Exception e){
  179.             throw new XMLUtilsException(e.getMessage(),e);
  180.         }
  181.     }

  183.     
  184.     
  185.     
  186.     
  187.     /* ----- Marshall ----- */
  188.     public static void generateEsitoRichiesta(EsitoRichiesta esitoRichiesta,File out) throws XMLUtilsException{
  189.         try{
  190.             StringBuilder risultatoValidazione = new StringBuilder();
  191.             if(EsitoRichiestaXMLUtils.validate(esitoRichiesta, risultatoValidazione)==false){
  192.                 throw new Exception(risultatoValidazione.toString());
  193.             }
  194.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(out.getName(),EsitoRichiestaXMLUtils.generateEsitoRichiesta_engine(esitoRichiesta));
  195.         }catch(Exception e){
  196.             throw new XMLUtilsException(e.getMessage(),e);
  197.         }
  198.     }
  199.     
  200.     public static void generateEsitoRichiesta(EsitoRichiesta esitoRichiesta,String fileName) throws XMLUtilsException{
  201.         try{
  202.             StringBuilder risultatoValidazione = new StringBuilder();
  203.             if(EsitoRichiestaXMLUtils.validate(esitoRichiesta, risultatoValidazione)==false){
  204.                 throw new Exception(risultatoValidazione.toString());
  205.             }
  206.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(fileName,EsitoRichiestaXMLUtils.generateEsitoRichiesta_engine(esitoRichiesta));
  207.         }catch(Exception e){
  208.             throw new XMLUtilsException(e.getMessage(),e);
  209.         }
  210.     }
  211.     
  212.     public static byte[] generateEsitoRichiesta(EsitoRichiesta esitoRichiesta) throws XMLUtilsException{
  213.         try{
  214.             StringBuilder risultatoValidazione = new StringBuilder();
  215.             if(EsitoRichiestaXMLUtils.validate(esitoRichiesta, risultatoValidazione)==false){
  216.                 throw new Exception(risultatoValidazione.toString());
  217.             }
  218.             return EsitoRichiestaXMLUtils.generateEsitoRichiesta_engine(esitoRichiesta);
  219.         }catch(Exception e){
  220.             throw new XMLUtilsException(e.getMessage(),e);
  221.         }
  222.     }

  224.     public static void generateEsitoRichiesta(EsitoRichiesta esitoRichiesta,OutputStream out) throws XMLUtilsException{
  225.         try{
  226.             StringBuilder risultatoValidazione = new StringBuilder();
  227.             if(EsitoRichiestaXMLUtils.validate(esitoRichiesta, risultatoValidazione)==false){
  228.                 throw new Exception(risultatoValidazione.toString());
  229.             }
  230.             out.write(EsitoRichiestaXMLUtils.generateEsitoRichiesta_engine(esitoRichiesta));
  231.             out.flush();
  232.             out.close();
  233.         }catch(Exception e){
  234.             throw new XMLUtilsException(e.getMessage(),e);
  235.         }
  236.     }
  237.     
  238.     public static String generateEsitoRichiestaAsJson(EsitoRichiesta esitoRichiesta) throws XMLUtilsException{
  239.         try{
  240.             StringBuilder risultatoValidazione = new StringBuilder();
  241.             if(EsitoRichiestaXMLUtils.validate(esitoRichiesta, risultatoValidazione)==false){
  242.                 throw new Exception(risultatoValidazione.toString());
  243.             }
  244.             return EsitoRichiestaXMLUtils.generateEsitoRichiestaAsJson_engine(esitoRichiesta);
  245.         }catch(Exception e){
  246.             throw new XMLUtilsException(e.getMessage(),e);
  247.         }
  248.     }
  249.     
  250.     private static byte[] generateEsitoRichiesta_engine(EsitoRichiesta esitoRichiesta) throws XMLUtilsException{
  251.         try{
  252.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  253.             org.openspcoop2.utils.xml.JaxbUtils.objToXml(bout, EsitoRichiesta.class, esitoRichiesta);
  254.             byte[] dichiarazione = bout.toByteArray();
  255.             return dichiarazione;
  256.         }catch(Exception e){
  257.             throw new XMLUtilsException(e.getMessage(),e);
  258.         }
  259.     }
  260.     
  261.     private static String generateEsitoRichiestaAsJson_engine(EsitoRichiesta esitoRichiesta) throws XMLUtilsException{
  262.         try{
  263.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  264.             esitoRichiesta.writeTo(bout, WriteToSerializerType.JSON_JACKSON);
  265.             bout.flush();
  266.             bout.close();
  267.             return bout.toString();
  268.         }catch(Exception e){
  269.             throw new XMLUtilsException(e.getMessage(),e);
  270.         }
  271.     }
  272.     
  273.     
  274.     
  275.     
  276.     
  277.     public static boolean isEsitoRichiesta(byte [] doc){
  278.         try{
  279.             org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  280.             Document docXML = xmlUtils.newDocument(doc);
  281.             Element elemXML = docXML.getDocumentElement();
  282.             return EsitoRichiestaXMLUtils.isEsitoRichiesta_engine(elemXML);
  283.         }catch(Exception e){
  284.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  285.             return false;
  286.         }
  287.     }
  288.     public static boolean isEsitoRichiesta(Document docXML){
  289.         try{
  290.             Element elemXML = docXML.getDocumentElement();
  291.             return EsitoRichiestaXMLUtils.isEsitoRichiesta_engine(elemXML);
  292.         }catch(Exception e){
  293.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  294.             return false;
  295.         }
  296.     }
  297.     public static boolean isEsitoRichiesta(Element elemXML){
  298.         return isEsitoRichiesta_engine(elemXML);
  299.     }
  300.     public static boolean isEsitoRichiesta(Node nodeXml){
  301.         return isEsitoRichiesta_engine(nodeXml);
  302.     }
  303.     private static boolean isEsitoRichiesta_engine(Node nodeXml){
  304.         try{
  305.             //System.out.println("LOCAL["+Costanti.ROOT_LOCAL_NAME_DETTAGLIO_ECCEZIONE+"]vs["+elemXML.getLocalName()+"]  NAMESPACE["+Costanti.TARGET_NAMESPACE+"]vs["+elemXML.getNamespaceURI()+"]");
  306.             if(Costanti.ROOT_LOCAL_NAME_ESITO_RICHIESTA.equals(nodeXml.getLocalName()) && 
  307.                     Costanti.TARGET_NAMESPACE.equals(nodeXml.getNamespaceURI() ) 
  308.                 ){
  309.                 return true;
  310.             }
  311.             else{
  312.                 return false;
  313.             }
  314.         }catch(Exception e){
  315.             //System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());
  316.             return false;
  317.         }
  318.     }
  319. }
Created with JaCoCo 0.8.8.202204050719