SPCoopValidazioneConSchema.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.protocol.spcoop.validator;

  25. import java.io.File;
  26. import java.io.FileInputStream;
  27. import java.io.InputStream;
  28. import java.util.HashMap;
  29. import java.util.Iterator;

  31. import javax.xml.soap.SOAPBody;
  32. import javax.xml.soap.SOAPElement;

  34. import org.openspcoop2.message.OpenSPCoop2Message;
  35. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  36. import org.openspcoop2.message.constants.MessageType;
  37. import org.openspcoop2.message.xml.ValidatoreXSD;
  38. import org.openspcoop2.message.xml.MessageXMLUtils;
  39. import org.openspcoop2.protocol.basic.BasicStateComponentFactory;
  40. import org.openspcoop2.protocol.sdk.Eccezione;
  41. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  42. import org.openspcoop2.protocol.sdk.ProtocolException;
  43. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  44. import org.openspcoop2.protocol.sdk.constants.ContestoCodificaEccezione;
  45. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  46. import org.openspcoop2.protocol.sdk.state.IState;
  47. import org.openspcoop2.protocol.sdk.validator.IValidazioneConSchema;
  48. import org.openspcoop2.protocol.spcoop.SPCoopBustaRawContent;
  49. import org.openspcoop2.protocol.spcoop.config.SPCoopProperties;
  50. import org.openspcoop2.utils.LoggerWrapperFactory;
  51. import org.openspcoop2.utils.xml.XSDResourceResolver;
  52. import org.slf4j.Logger;
  53. import org.w3c.dom.Element;
  54. import org.xml.sax.SAXException;

  56. /**
  57.  * Classe che implementa, in base al protocollo SPCoop, l'interfaccia {@link org.openspcoop2.protocol.sdk.validator.IValidazioneConSchema}
  58.  * Utilizzata per effettuare una validazione con schema xsd di SPCoop. 
  59.  *
  60.  * @author Poli Andrea (apoli@link.it)
  61.  * @author $Author$
  62.  * @version $Rev$, $Date$
  63.  */
  64. public class SPCoopValidazioneConSchema extends BasicStateComponentFactory implements IValidazioneConSchema {

  66.     /** Validatore della busta SPCoop */
  67.     private static HashMap<String, ValidatoreXSD> validatoreBustaSPCoop_map = new HashMap<String, ValidatoreXSD>();

  69.     
  70.     
  71.     /** Errori di validazione riscontrati sulla busta */
  72.     private java.util.List<Eccezione> erroriValidazione;
  73.     /** Errori di processamento riscontrati sulla busta */
  74.     private java.util.List<Eccezione> erroriProcessamento;

  76.     
  77.     
  78.     
  79.     /**
  80.      * Costruttore.
  81.      *
  82.      * @param protocolFactory ProtocolFactory
  83.      * @throws ProtocolException 
  84.      * 
  85.      */
  86.     public SPCoopValidazioneConSchema(IProtocolFactory<?> protocolFactory,IState state) throws ProtocolException{
  87.         super(protocolFactory, state);      
  88.     }


  91.     /**
  92.      * Ritorna un List contenente eventuali eccezioni di validazione riscontrate nella busta SPCoop.   
  93.      *
  94.      * @return Eccezioni riscontrate nella busta SPCoop.
  95.      * 
  96.      */
  97.     @Override
  98.     public java.util.List<Eccezione> getEccezioniValidazione(){
  99.         return this.erroriValidazione;
  100.     }
  101.     /**
  102.      * Ritorna un List contenente eventuali eccezioni di processamento riscontrate nella busta SPCoop.   
  103.      *
  104.      * @return Eccezioni riscontrate nella busta SPCoop.
  105.      * 
  106.      */
  107.     @Override
  108.     public java.util.List<Eccezione> getEccezioniProcessamento(){
  109.         return this.erroriProcessamento;
  110.     }

  112.     /**
  113.      * Metodo che si occupa di inizializzare lo schema della busta SPCoop utilizzato per la validazione.
  114.      *
  115.      * 
  116.      */
  117.     public static synchronized boolean initializeSchema(OpenSPCoop2MessageFactory messageFactory, Logger log) {
  118.         String key = messageFactory.getClass().getName();
  119.             
  120.         if(!validatoreBustaSPCoop_map.containsKey(key)) {
  121.             
  122.             if(log==null)
  123.                 log = LoggerWrapperFactory.getLogger("ValidazioneConSchemaSPCoop");
  124.             
  125.             try{
  126.                 SPCoopProperties spcoopProperties = SPCoopProperties.getInstance(log);
  127.                 
  128.                 log.info("Inizializzazione dello schema per il protocollo spcoop (possono essere necessari alcuni minuti...)");
  129.                 String[] schemiXSDDaImportare = spcoopProperties.getSchemiXSDImportatiValidazioneXSDBusta();
  130.                 String schemaXSD = spcoopProperties.getSchemaXSDValidazioneXSDBusta();
  131.                 ValidatoreXSD val = SPCoopValidazioneConSchema.createSchemaValidator(messageFactory, log,schemiXSDDaImportare, schemaXSD);
  132.                 validatoreBustaSPCoop_map.put(key, val);
  133.                 log.info("Inizializzazione dello schema per il protocollo spcoop terminata.");
  134.                 return true;
  135.             }catch (Exception e) {
  136.                 log.error("Riscontrato errore durante l'inizializzazione dello schema per il protocollo spcoop: "+e.getMessage(),e);
  137.                 return false;
  138.             }
  139.             
  140.         }
  141.         
  142.         return true; // gia' inizializzato
  143.     }

  145.     private static ValidatoreXSD getValidatoreXSD(OpenSPCoop2MessageFactory messageFactory, Logger log) {

  147.         String key = messageFactory.getClass().getName();
  148.         
  149.         if(!validatoreBustaSPCoop_map.containsKey(key)) {
  150.             initializeSchema(messageFactory, log);
  151.         }
  152.         
  153.         return validatoreBustaSPCoop_map.get(key);
  154.         
  155.     }
  156.     
  157.     private static ValidatoreXSD createSchemaValidator(OpenSPCoop2MessageFactory messageFactory,Logger log,String[] schemiXSDDaImportare,String schemaXSD) throws Exception{
  158.         // ** Schemi importati **
  159.         XSDResourceResolver xsdResourceResolver = new XSDResourceResolver();
  160.         if(schemiXSDDaImportare!=null){
  161.             for(int i=0;i<schemiXSDDaImportare.length;i++){
  162.                 File fXsd = new File(schemiXSDDaImportare[i]);
  163.                 InputStream is = null;
  164.                 try{
  165.                     if(fXsd.exists()){
  166.                         is = new FileInputStream(fXsd);
  167.                     }else{
  168.                         is = SPCoopValidazioneConSchema.class.getResourceAsStream("/"+schemiXSDDaImportare[i]);
  169.                     }
  170.                     xsdResourceResolver.addResource(fXsd.getName(), is);
  171.                 }finally{
  172.                     try{
  173.                         if(is!=null){
  174.                             is.close();
  175.                         }
  176.                     }catch(Exception e){
  177.                         // close
  178.                     } //?????? Close effettuato dentro xsdResolver ??? : riabilitato il close.
  179.                 }
  180.             }
  181.         }
  182.         
  183.         // ** Schema principale **
  184.         File fXsd = new File(schemaXSD);
  185.         InputStream is = null;
  186.         try{
  187.             if(fXsd.exists()){
  188.                 is = new FileInputStream(fXsd);
  189.             }else{
  190.                 is = SPCoopValidazioneConSchema.class.getResourceAsStream("/"+schemaXSD);
  191.             }
  192.             // ** Creo Validatore **
  193.             return new ValidatoreXSD(messageFactory,log,xsdResourceResolver,is);
  194.         }finally{
  195.             try{
  196.                 if(is!=null){
  197.                     is.close();
  198.                 }
  199.             }catch(Exception e){
  200.                 // close
  201.             } //?????? Close effettuato dentro xsdResolver ???? : riabilitato il close.
  202.         }
  203.         
  204.     }
  205.     
  206.     /**
  207.      * Metodo che effettua la validazione dei soggetti di una busta, controllando la loro registrazione nel registro dei servizi. 
  208.      *
  209.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  210.      *   {@link Eccezione}, e viene inserito nel List <var>errors</var>.
  211.      *
  212.      * 
  213.      */
  214.     @Override
  215.     public void valida(OpenSPCoop2Message message, boolean isSPCoopErroreProcessamento, boolean isSPCoopErroreIntestazione,
  216.             boolean isMessaggioConAttachments, boolean validazioneManifestAttachments) throws ProtocolException{

  218.         this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  219.         this.erroriProcessamento = new java.util.ArrayList<Eccezione>();

  221.         MessageXMLUtils xmlUtils = MessageXMLUtils.getInstance(message.getFactory());
  222.         ValidatoreXSD validatoreBustaSPCoop = getValidatoreXSD(message.getFactory(), this.log);
  223.         
  224.         if(validatoreBustaSPCoop == null){
  225.             throw new ProtocolException("Validatore con schema XSD non inizializzato");
  226.         }     
  227.         
  228.         // Validazione eGov
  229.         try {

  231.             SPCoopBustaRawContent bustaElement = (SPCoopBustaRawContent) this.protocolFactory.createValidazioneSintattica(this.state).getBustaRawContent_senzaControlli(message);
  232.             SOAPElement header = bustaElement.getElement();
  233.             
  234.             if(isSPCoopErroreProcessamento==false && isSPCoopErroreIntestazione==false){
  235.                 
  236.                 // VALIDAZIONE
  237.                 validatoreBustaSPCoop.valida(
  238.                         xmlUtils.newDocument(OpenSPCoop2MessageFactory.getAsByte(message.getFactory(), header,false)));
  239.                 
  240.             }
  241.             else{
  242.                 
  243.                 // Validazione Lista Eccezioni.
  244.                 Iterator<?> itChilds = header.getChildElements();
  245.                 SOAPElement listaEccezioni = null;
  246.                 while(itChilds.hasNext()){
  247.                     Object element = itChilds.next();
  248.                     if(!(element instanceof SOAPElement)){
  249.                         continue;
  250.                     }
  251.                     
  252.                     SOAPElement elemInterno = (SOAPElement) element;
  253.                     if("ListaEccezioni".equals(elemInterno.getLocalName())){
  254.                         listaEccezioni = elemInterno;
  255.                         break;
  256.                     }
  257.                 }
  258.                 if(listaEccezioni==null){
  259.                     if(isSPCoopErroreIntestazione)
  260.                         throw new SAXException("ListaEccezioni non presente in un messaggio SPCoopErrore");
  261.                 }
  262.                 
  263.                 // VALIDAZIONE
  264.                 if(listaEccezioni!=null){
  265.                     validatoreBustaSPCoop.valida(
  266.                             xmlUtils.newDocument(OpenSPCoop2MessageFactory.getAsByte(message.getFactory(), listaEccezioni,false)));
  267.                 }
  268.             }
  269.                     
  270.         } catch (SAXException e) {
  271.             // instance document is invalid!
  272.             Eccezione ecc = new Eccezione();
  273.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  274.             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  275.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  276.             ecc.setDescrizione(e.getMessage());
  277.             this.erroriValidazione.add(ecc);
  278.         }catch (Exception e) {
  279.             Eccezione ecc = new Eccezione();
  280.             ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  281.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  282.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  283.             ecc.setDescrizione("Validazione con schema xsd dell'header egov non riuscita: errore di processamento");
  284.             this.log.error("Validazione con schema xsd dell'header egov non riuscita non riuscita",e);
  285.             this.erroriProcessamento.add(ecc);
  286.         }

  288.         // Validazione ManifestAttachments
  289.         SOAPBody soapBody = null;
  290.         if(validazioneManifestAttachments && isMessaggioConAttachments) {
  291.             try{
  292.                 soapBody = message.castAsSoap().getSOAPBody();
  293.             }catch(Exception e){
  294.                 throw new ProtocolException(e.getMessage(),e);
  295.             }
  296.         }
  297.         if(soapBody!=null){
  298.             try {   
  299.                 // Validazione
  300.                 
  301.                 Element firstElement = OpenSPCoop2MessageFactory.getFirstChildElement(message.getFactory(), MessageType.SOAP_11, soapBody);
  302.                 //validatoreBustaSPCoop.valida(xmlUtils.newDocument(OpenSPCoop2MessageFactory.getAsByte(message.getFactory(), firstElement, false))); 
  303.                 validatoreBustaSPCoop.valida(firstElement); 
  304.             } catch (SAXException e) {
  305.                 // instance document is invalid!
  306.                 Eccezione ecc = new Eccezione();
  307.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  308.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  309.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  310.                 ecc.setDescrizione("ManifestAttachments: "+e.getMessage());
  311.                 this.log.error("Validazione con schema xsd del manifest degli attachments fallita",e);
  312.                 this.erroriValidazione.add(ecc);
  313.             }catch (Exception e) {
  314.                 Eccezione ecc = new Eccezione();
  315.                 ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  316.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  317.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  318.                 ecc.setDescrizione("Validazione con schema xsd del manifest degli attachments non riuscita: errore di processamento");
  319.                 this.log.error("Validazione con schema xsd del manifest degli attachments non riuscita",e);
  320.                 this.erroriProcessamento.add(ecc);
  321.             }
  322.         }

  324.     }

  326.     @Override
  327.     public boolean initialize(OpenSPCoop2MessageFactory messageFactory) {
  328.         return SPCoopValidazioneConSchema.initializeSchema(messageFactory, this.log);
  329.     }

  331. }
Created with JaCoCo 0.8.8.202204050719