ValidazioneSintattica.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.engine.validator;

  25. import javax.xml.soap.SOAPHeader;

  27. import org.openspcoop2.core.constants.TipoPdD;
  28. import org.openspcoop2.message.OpenSPCoop2Message;
  29. import org.openspcoop2.protocol.engine.Configurazione;
  30. import org.openspcoop2.protocol.sdk.Busta;
  31. import org.openspcoop2.protocol.sdk.BustaRawContent;
  32. import org.openspcoop2.protocol.sdk.Context;
  33. import org.openspcoop2.protocol.sdk.Eccezione;
  34. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  35. import org.openspcoop2.protocol.sdk.ProtocolException;
  36. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  37. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  38. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  39. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  40. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  41. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  42. import org.openspcoop2.protocol.sdk.state.IState;
  43. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  44. import org.openspcoop2.protocol.sdk.validator.ValidazioneSintatticaResult;
  45. import org.openspcoop2.utils.LoggerWrapperFactory;
  46. import org.slf4j.Logger;

  48. /**
  49.  * Classe utilizzata per la validazione sintattica di una busta.
  50.  *
  51.  *
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author Lorenzo Nardi (nardi@link.it)
  54.  * @author $Author$
  55.  * @version $Rev$, $Date$
  56.  */

  58. public class ValidazioneSintattica {

  60.     /** Messaggio. */
  61.     protected OpenSPCoop2Message msg;
  62.     /** HeaderSOAP */
  63.     protected SOAPHeader headerSOAP = null;
  64.     /** Header */
  65.     protected BustaRawContent<?> headerProtocollo;
  66.     
  67.     public BustaRawContent<?> getProtocolHeader(){
  68.         return this.headerProtocollo;
  69.     }
  70.     
  71.     public void setHeaderSOAP(SOAPHeader headerSOAP) {
  72.         this.headerSOAP = headerSOAP;
  73.     }
  74.     /** Errori di validazione riscontrati sulla busta */
  75.     protected java.util.List<Eccezione> erroriValidazione;
  76.     /** Errori di processamento riscontrati sulla busta */
  77.     protected java.util.List<Eccezione> erroriProcessamento;
  78.     private String erroreProcessamento_internalMessage; 
  79.     /** Errors riscontrati sulla lista eccezioni */
  80.     protected java.util.List<Eccezione> errorsTrovatiSullaListaEccezioni;
  81.     /** Busta */
  82.     protected Busta busta;
  83.     protected Boolean isRichiesta;
  84.     /** Eventuale errore avvenuto durante il processo di validazione */
  85.     protected ErroreCooperazione errore;
  86.     protected IntegrationFunctionError errore_integrationFunctionError;
  87.     /** Indicazione se leggere gli attributi qualificati */
  88.     protected boolean readQualifiedAttribute;

  90.     /** Logger utilizzato per debug. */
  91.     protected org.slf4j.Logger log = null;

  93.     protected boolean segnalazioneElementoPresentePiuVolte = false;
  94.     private IProtocolFactory<?> protocolFactory;
  95.     private IProtocolManager protocolManager;
  96.     /** Indicazione se la busta risulta scaduta */
  97.     protected boolean messaggioScaduto = false;
  98.     
  99.     /** bustaErroreHeaderIntestazione: generata solo quando la busta arrivata non contiene gli elementi principali */
  100.     protected Busta bustaErroreHeaderIntestazione = null;
  101.     public Busta getBustaErroreHeaderIntestazione() {
  102.         return this.bustaErroreHeaderIntestazione;
  103.     }
  104.     
  105.     /** Stato */
  106.     private IState state;
  107.     
  108.     /** Context */
  109.     private Context context;
  110.     
  111.     /**
  112.      * Costruttore
  113.      *
  114.      * @param aMsg Messaggio da validare.
  115.      * @throws ProtocolException 
  116.      * 
  117.      */
  118.     public ValidazioneSintattica(Context context, IState state,OpenSPCoop2Message aMsg,boolean readQualifiedAttribute, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  119.         this(context,state,aMsg,Configurazione.getLibraryLog(),readQualifiedAttribute, protocolFactory);
  120.     }
  121.     public ValidazioneSintattica(Context context, IState state,OpenSPCoop2Message aMsg, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  122.         this(context,state,aMsg,Configurazione.getLibraryLog(),false, protocolFactory);
  123.     }
  124.     public ValidazioneSintattica(Context context, IState state,OpenSPCoop2Message aMsg,Logger alog, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  125.         this(context, state,aMsg,alog,false, protocolFactory);
  126.     }
  127.     
  128.     /**
  129.      * Costruttore
  130.      *
  131.      * @param aMsg Messaggio da validare.
  132.      * @throws ProtocolException 
  133.      * 
  134.      */
  135.     public ValidazioneSintattica(Context context, IState state,OpenSPCoop2Message aMsg, Busta busta, Boolean isRichiesta, Logger alog, boolean readQualifiedAttribute, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  136.         this(context, state,aMsg, alog, readQualifiedAttribute, protocolFactory);
  137.         this.busta = busta;
  138.         this.isRichiesta = isRichiesta;
  139.     }
  140.     
  141.     public ValidazioneSintattica(Context context, IState state,OpenSPCoop2Message aMsg,Logger alog,boolean readQualifiedAttribute, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  142.         this.state = state;
  143.         this.context = context;
  144.         this.msg = aMsg;
  145.         if(alog!=null){
  146.             this.log = alog;
  147.         }else{
  148.             this.log = LoggerWrapperFactory.getLogger(ValidazioneSintattica.class.getName());
  149.         }
  150.         this.readQualifiedAttribute = readQualifiedAttribute;
  151.         this.protocolFactory = protocolFactory;
  152.         this.protocolManager = this.protocolFactory.createProtocolManager();
  153.     }


  156.     public void updateMsg(OpenSPCoop2Message msg) throws ProtocolException {
  157.         String msgClassName = msg.getClass().getName()+ "";
  158.         boolean update = !msgClassName.equals(this.msg.getClass().getName());
  159.         if(update){
  160.             this.msg = msg;
  161.             if(this.headerProtocollo!=null){
  162.                 org.openspcoop2.protocol.sdk.validator.IValidazioneSintattica<?> validazioneSintattica = this.protocolFactory.createValidazioneSintattica(this.state);
  163.                 this.headerProtocollo = validazioneSintattica.getBustaRawContent_senzaControlli(this.msg);
  164.             }
  165.         }
  166.     }

  168.     public IProtocolFactory<?> getProtocolFactory(){
  169.         return this.protocolFactory;
  170.     }
  171.     
  172.     /**
  173.      * Oggetto Busta contenente i valori della busta ricevuta.
  174.      *
  175.      * @return busta.
  176.      * 
  177.      */
  178.     public Busta getBusta(){
  179.         return this.busta;
  180.     }

  182.     /**
  183.      * Ritorna un List contenente eventuali eccezioni di validazione riscontrate nella busta.   
  184.      *
  185.      * @return Eccezioni riscontrate nella busta.
  186.      * 
  187.      */
  188.     public java.util.List<Eccezione> getEccezioniValidazione(){
  189.         return this.erroriValidazione;
  190.     }
  191.     /**
  192.      * Ritorna un List contenente eventuali eccezioni di processamento riscontrate nella busta.   
  193.      *
  194.      * @return Eccezioni riscontrate nella busta.
  195.      * 
  196.      */
  197.     public java.util.List<Eccezione> getEccezioniProcessamento(){
  198.         return this.erroriProcessamento;
  199.     }
  200.     public String getErroreProcessamento_internalMessage() {
  201.         return this.erroreProcessamento_internalMessage;
  202.     }
  203.     
  204.     /**
  205.      * Ritorna un List contenente eventuali eccezioni riscontrate nella busta durante il processo di validazione.   
  206.      *
  207.      * @return Eccezioni riscontrate nella busta.
  208.      * 
  209.      */
  210.     public java.util.List<Eccezione> getErroriTrovatiSullaListaEccezioni(){
  211.         return this.errorsTrovatiSullaListaEccezioni;
  212.     }

  214.     /**
  215.      * In caso di avvenuto errore durante il processo di validazione, 
  216.      * questo metodo ritorna il motivo dell'errore.
  217.      *
  218.      * @return motivo dell'errore (se avvenuto).
  219.      * 
  220.      */
  221.     public ErroreCooperazione getErrore(){
  222.         return this.errore;
  223.     }
  224.     public IntegrationFunctionError getErrore_integrationFunctionError() {
  225.         return this.errore_integrationFunctionError;
  226.     }


  229.     /**
  230.      * Metodo che effettua una validazione sintattica di una busta. 
  231.      * Il metodo, oltre ad effettuare la validazione della busta, si occupa anche di leggerne il contenuto e 
  232.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  233.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  234.      *   {@link Eccezione}, e viene inserito nel List <var>errors</var>.
  235.      *
  236.      * @return return true in caso di validazione sintattica riuscita (con o senza anomalie), false in caso di errori di processamento.
  237.      * 
  238.      */
  239.     public boolean valida(){
  240.         // Recupero l'oggetto Busta
  241.         
  242.         
  243.         ValidazioneSintatticaResult<?> result = null;
  244.         org.openspcoop2.protocol.sdk.validator.IValidazioneSintattica<?> validazioneSintattica = null;
  245.         boolean protocolException = false;
  246.         try {
  247.             validazioneSintattica = this.protocolFactory.createValidazioneSintattica(this.state);
  248.             validazioneSintattica.setContext(this.context);
  249.             ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  250.             pValidazioneErrori.setIgnoraEccezioniNonGravi(this.protocolManager.isIgnoraEccezioniNonGravi());
  251.             if(this.isRichiesta==null || this.isRichiesta){
  252.                 result = validazioneSintattica.validaRichiesta(this.msg, this.busta, pValidazioneErrori);
  253.             }
  254.             else{
  255.                 result = validazioneSintattica.validaRisposta(this.msg, this.busta, pValidazioneErrori);
  256.             }
  257.             
  258.         } catch (ProtocolException e) {
  259.             protocolException = true;
  260.         } 
  261.         
  262.         if(result != null){
  263.             if(result.getBusta() != null)
  264.                 this.busta = result.getBusta();
  265.             
  266.             if(result.getBustaErrore()!= null)
  267.                 this.bustaErroreHeaderIntestazione = result.getBustaErrore();
  268.             
  269.             this.errore = result.getErrore();
  270.             this.errore_integrationFunctionError = result.getErrore_integrationFunctionError();
  271.             
  272.             this.erroriProcessamento = result.getErroriProcessamento();
  273.             if(this.erroriProcessamento == null) 
  274.                 this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  275.             this.erroreProcessamento_internalMessage = result.getErroreProcessamento_internalMessage();
  276.             
  277.             this.erroriValidazione = result.getErroriValidazione();
  278.             if(this.erroriValidazione == null) 
  279.                 this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  280.             
  281.             this.errorsTrovatiSullaListaEccezioni = result.getErrorsTrovatiSullaListaEccezioni();
  282.             if(this.errorsTrovatiSullaListaEccezioni == null) 
  283.                 this.errorsTrovatiSullaListaEccezioni = new java.util.ArrayList<Eccezione>();
  284.             
  285.             if(result.getBustaRawContent() != null)
  286.                 this.headerProtocollo = result.getBustaRawContent();
  287.             
  288.             return result.isValido();
  289.         }
  290.         else {
  291.             if(protocolException) {
  292.                 if(this.isRichiesta==null || this.isRichiesta){
  293.                     this.errore_integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  294.                 }
  295.                 else {
  296.                     this.errore_integrationFunctionError = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  297.                 }
  298.             }
  299.         }
  300.         
  301.         return false;
  302.         
  303.     }

  305.     
  306.     
  307.     
  308.     /**
  309.      * Controlla che esista una busta nell'header
  310.      * 
  311.      * @return true se esiste un protocollo, false altrimenti
  312.      */
  313.     public boolean verifyProtocolPresence(TipoPdD tipoPdD, ProfiloDiCollaborazione profilo, RuoloMessaggio ruoloMessaggio) throws Exception{
  314.         return this.protocolFactory.createValidazioneSintattica(this.state).verifyProtocolPresence(tipoPdD, profilo, ruoloMessaggio, this.msg);
  315.     }
  316.     

  318.     /**
  319.      * Metodo che si occupa di validare il Fault presente in un Messaggio Errore.
  320.      *
  321.      * @param msg Messaggio contenente il Fault.
  322.      * @throws ProtocolException 
  323.      * 
  324.      */
  325.     public void validazioneFault(OpenSPCoop2Message msg) throws ProtocolException{
  326.         ValidazioneSintatticaResult<?> result = this.protocolFactory.createValidazioneSintattica(this.state).validazioneFault(msg);
  327.         if(result != null){
  328.             if(result.getBusta() != null)
  329.                 this.busta = result.getBusta();
  330.             if(result.getBustaErrore()!= null)
  331.                 this.bustaErroreHeaderIntestazione = result.getBustaErrore();
  332.             
  333.             this.errore = result.getErrore();
  334.             
  335.             this.erroriProcessamento = result.getErroriProcessamento();
  336.             if(this.erroriProcessamento == null) 
  337.                 this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  338.             this.erroreProcessamento_internalMessage = result.getErroreProcessamento_internalMessage();
  339.             
  340.             this.erroriValidazione = result.getErroriValidazione();
  341.             if(this.erroriValidazione == null) 
  342.                 this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  343.             
  344.             this.errorsTrovatiSullaListaEccezioni = result.getErrorsTrovatiSullaListaEccezioni();
  345.             if(this.errorsTrovatiSullaListaEccezioni == null) 
  346.                 this.errorsTrovatiSullaListaEccezioni = new java.util.ArrayList<Eccezione>();

  348.             if(result.getBustaRawContent() != null)
  349.                 this.headerProtocollo = result.getBustaRawContent();
  350.         }
  351.     }

  353.     /**
  354.      * Metodo che si occupa di validare il Manifest di un SoapBody.
  355.      *
  356.      * @param msg SOAPMessage contenente il Manifest.
  357.      * @throws ProtocolException 
  358.      * 
  359.      */
  360.     public void validazioneManifestAttachments(OpenSPCoop2Message msg,ProprietaManifestAttachments proprietaManifestAttachments) throws ProtocolException{
  361.         ValidazioneSintatticaResult<?> result = this.protocolFactory.createValidazioneSintattica(this.state).validazioneManifestAttachments(msg, proprietaManifestAttachments);
  362.         if(result != null){
  363.             if(result.getBusta() != null)
  364.                 this.busta = result.getBusta();
  365.             if(result.getBustaErrore()!= null)
  366.                 this.bustaErroreHeaderIntestazione = result.getBustaErrore();
  367.             
  368.             this.errore = result.getErrore();
  369.             
  370.             this.erroriProcessamento = result.getErroriProcessamento();
  371.             if(this.erroriProcessamento == null) 
  372.                 this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  373.             this.erroreProcessamento_internalMessage = result.getErroreProcessamento_internalMessage();
  374.             
  375.             this.erroriValidazione = result.getErroriValidazione();
  376.             if(this.erroriValidazione == null) 
  377.                 this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  378.             
  379.             this.errorsTrovatiSullaListaEccezioni = result.getErrorsTrovatiSullaListaEccezioni();
  380.             if(this.errorsTrovatiSullaListaEccezioni == null) 
  381.                 this.errorsTrovatiSullaListaEccezioni = new java.util.ArrayList<Eccezione>();
  382.     
  383.             if(result.getBustaRawContent() != null)
  384.                 this.headerProtocollo = result.getBustaRawContent();
  385.         }
  386.     }
  387.     
  388.     public BustaRawContent<?> getHeaderProtocollo_senzaControlli() throws ProtocolException{
  389.         return this.protocolFactory.createValidazioneSintattica(this.state).getBustaRawContent_senzaControlli(this.msg);
  390.     }

  392. }
Created with JaCoCo 0.8.8.202204050719