ValidazioneSemantica.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 org.openspcoop2.core.id.IDServizio;
  26. import org.openspcoop2.core.id.IDSoggetto;
  27. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  28. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  29. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  30. import org.openspcoop2.message.OpenSPCoop2Message;
  31. import org.openspcoop2.message.constants.ServiceBinding;
  32. import org.openspcoop2.protocol.engine.Configurazione;
  33. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  34. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  35. import org.openspcoop2.protocol.sdk.Busta;
  36. import org.openspcoop2.protocol.sdk.Context;
  37. import org.openspcoop2.protocol.sdk.Eccezione;
  38. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  39. import org.openspcoop2.protocol.sdk.ProtocolException;
  40. import org.openspcoop2.protocol.sdk.Servizio;
  41. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  42. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  43. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  44. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  45. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  46. import org.openspcoop2.protocol.sdk.constants.StatoFunzionalitaProtocollo;
  47. import org.openspcoop2.protocol.sdk.state.IState;
  48. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  49. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  50. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  51. import org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica;
  52. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  53. import org.openspcoop2.protocol.sdk.validator.ValidazioneSemanticaResult;
  54. import org.openspcoop2.utils.LoggerWrapperFactory;
  55. import org.slf4j.Logger;

  57. /**
  58.  * Classe utilizzata per effettuare un controllo di registrazione dei soggetti di una busta nel registro dei servizi.
  59.  *
  60.  * @author Poli Andrea (apoli@link.it)
  61.  * @author Tronci Fabio (tronci@link.it)
  62.  * @author $Author$
  63.  * @version $Rev$, $Date$
  64.  * 
  65.  */

  67. public class ValidazioneSemantica  {

  69.     /** Se IState e' un'istanza di StatefulMessage possiede una Connessione SQL in autoCommit mode su cui effettuare query 
  70.      *  Altrimenti, e' un'istanza di StatelessMessage e nn necessita di connessioni  */
  71.     protected IState state;
  72.     /** Context */
  73.     protected Context context;
  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.     /** Dettaglio errore */
  79.     protected IntegrationFunctionError errore_integrationFunctionError;
  80.     /** Busta */
  81.     protected Busta busta;
  82.     /** Validazione ID completa */
  83.     protected boolean validazioneIdentificativiCompleta = false;
  84.     /** ServizioCorrelato */
  85.     protected String servizioCorrelato;
  86.     /** Tipo ServizioCorrelato */
  87.     protected String tipoServizioCorrelato;
  88.     /** Versione ServizioCorrelato */
  89.     protected Integer versioneServizioCorrelato;
  90.     /** Azione Correlata */
  91.     protected String azioneCorrelata;
  92.     /** Reader Registro */
  93.     protected RegistroServiziManager registroServiziReader;
  94.     /** informazioni Servizio */
  95.     protected Servizio infoServizio = null;
  96.     /** Logger utilizzato per debug. */
  97.     protected Logger log = null;
  98.     private IProtocolFactory<?> protocolFactory;
  99.     public IProtocolFactory<?> getProtocolFactory(){
  100.         return this.protocolFactory;
  101.     }

  103.     /**
  104.      * Costruttore.
  105.      *
  106.      * @param aBusta Busta da validare.
  107.      * @param state Oggetto che rappresenta lo stato di una busta
  108.      * 
  109.      */
  110.      
  111.     public ValidazioneSemantica(Busta aBusta, Context context, IState state, boolean validazioneIdentificativiCompleta, IProtocolFactory<?> protocolFactory){
  112.         this(aBusta,context, state,validazioneIdentificativiCompleta,Configurazione.getLibraryLog(), protocolFactory);
  113.     }
  114.     
  115.     /**
  116.      * Costruttore.
  117.      *
  118.      * @param aBusta Busta da validare.
  119.      * @param state Oggetto che rappresenta lo stato di una busta
  120.      * 
  121.      */
  122.      
  123.     public ValidazioneSemantica(Busta aBusta, Context context, IState state, boolean validazioneIdentificativiCompleta, Logger alog, IProtocolFactory<?> protocolFactory){
  124.         this.busta = aBusta;
  125.         this.context = context;
  126.         this.state = state;
  127.         this.registroServiziReader = RegistroServiziManager.getInstance(state);
  128.         if(alog!=null){
  129.             this.log = alog;
  130.         }else{
  131.             this.log = LoggerWrapperFactory.getLogger(ValidazioneSemantica.class);
  132.         }
  133.         this.validazioneIdentificativiCompleta = validazioneIdentificativiCompleta;
  134.         this.protocolFactory = protocolFactory;
  135.     }


  138.     /**
  139.      * Ritorna un List contenente eventuali eccezioni di validazione riscontrate nella busta.   
  140.      *
  141.      * @return Eccezioni riscontrate nella busta.
  142.      * 
  143.      */
  144.     public java.util.List<Eccezione> getEccezioniValidazione(){
  145.         return this.erroriValidazione;
  146.     }
  147.     /**
  148.      * Ritorna un List contenente eventuali eccezioni di processamento riscontrate nella busta.   
  149.      *
  150.      * @return Eccezioni riscontrate nella busta.
  151.      * 
  152.      */
  153.     public java.util.List<Eccezione> getEccezioniProcessamento(){
  154.         return this.erroriProcessamento;
  155.     }
  156.     
  157.     public IntegrationFunctionError getErrore_integrationFunctionError() {
  158.         return this.errore_integrationFunctionError;
  159.     }
  160.     
  161.     /**
  162.      * Metodo che effettua la validazione dei soggetti di una busta, controllando la loro registrazione nel registro dei servizi. 
  163.      *
  164.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  165.      *   {@link Eccezione}, e viene inserito nel List <var>errors</var>.
  166.      *
  167.      * @param proprietaValidazione tipo di Validazione
  168.      * @throws ProtocolException 
  169.      * 
  170.      */
  171.     public void valida(OpenSPCoop2Message msg, ProprietaValidazione proprietaValidazione,RuoloBusta tipoBusta,String versioneProtocollo, RequestInfo requestInfo) throws ProtocolException{
  172.         try {
  173.             
  174.             proprietaValidazione.setValidazioneIDCompleta(this.validazioneIdentificativiCompleta);
  175.             proprietaValidazione.setVersioneProtocollo(versioneProtocollo);
  176.             IValidazioneSemantica validazioneSemantica = this.protocolFactory.createValidazioneSemantica(this.state);
  177.             validazioneSemantica.setContext(this.context);
  178.             ValidazioneSemanticaResult result = validazioneSemantica.valida(msg, this.busta, proprietaValidazione, tipoBusta);
  179.             this.infoServizio = result.getInfoServizio();
  180.             this.servizioCorrelato = result.getServizioCorrelato();
  181.             this.tipoServizioCorrelato = result.getTipoServizioCorrelato();
  182.             this.versioneServizioCorrelato = result.getVersioneServizioCorrelato();
  183.             this.erroriProcessamento = result.getErroriProcessamento();
  184.             if(this.erroriProcessamento == null) 
  185.                 this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  186.             this.erroriValidazione = result.getErroriValidazione();
  187.             if(this.erroriValidazione == null) 
  188.                 this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  189.             this.errore_integrationFunctionError = result.getErrore_integrationFunctionError();
  190.             
  191.             // Controllo correlazione alla richiesta per buste contenenti Risposte o ricevute 
  192.             //System.out.println("TIPO BUSTA ["+tipoBusta+"]");
  193.             if(this.erroriValidazione.size()==0 && this.erroriProcessamento.size()==0 && this.busta!=null ){
  194.                 if( RuoloBusta.BUSTA_DI_SERVIZIO.equals(tipoBusta.toString()) == false &&
  195.                         RuoloBusta.RICHIESTA.equals(tipoBusta.toString()) == false){ 
  196.                     //log.info("Validazione correlazione...");
  197.                     validazioneCorrelazione(tipoBusta);
  198.                 }
  199.             }
  200.             
  201.             // Controllo riferimentoMessaggio
  202.             if(this.erroriValidazione.size()==0 && this.erroriProcessamento.size()==0 && this.busta!=null && this.busta.getRiferimentoMessaggio()!=null){
  203.                 validazioneRiferimentoMessaggio(tipoBusta);
  204.             }
  205.             
  206.             // Riconoscimento collaborazione
  207.             if(this.erroriValidazione.size()==0 && this.erroriProcessamento.size()==0 && this.busta!=null && this.busta.getProfiloDiCollaborazione()!=null ){
  208.                 // Controllo Collaborazione (validazioneID e Riconoscimento)
  209.                 // Controllo che non deve essere effettuato se ho ricevuto un Fault
  210.                 if( RuoloBusta.BUSTA_DI_SERVIZIO.equals(tipoBusta.toString()) == false ){ 
  211.                     //log.info("Validazione Collaborazione...");
  212.                     IProtocolVersionManager protocolVersioneManager = this.protocolFactory.createProtocolVersionManager(versioneProtocollo);
  213.                     StatoFunzionalitaProtocollo modalitaGestioneCollaborazione = protocolVersioneManager.getCollaborazione(this.busta);
  214.                     if(StatoFunzionalitaProtocollo.ABILITATA.equals(modalitaGestioneCollaborazione) || 
  215.                             (StatoFunzionalitaProtocollo.REGISTRO.equals(modalitaGestioneCollaborazione) && (this.infoServizio!=null) && this.infoServizio.getCollaborazione() ) ){
  216.                         riconoscimentoCollaborazione(tipoBusta, requestInfo);       
  217.                     }
  218.                 }
  219.             }
  220.             
  221.         } catch (ProtocolException e) {
  222.             this.log.error("ProtocolException error",e);
  223.             throw e;
  224.         }
  225.     }

  227.     public static String riconoscimentoVersioneProtocolloServizioErogato(Busta busta, org.openspcoop2.protocol.sdk.config.ITraduttore costanti, RuoloBusta tipoBusta, IState state, RequestInfo requestInfo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  228.         // Normalmente prendo il soggetto destinatario come erogatore del servizio.
  229.         // Devono essere gestiti i seguenti casi particolari, in cui devo invece prendere il mittente
  230.         // - risposta sincrona
  231.         // - ricevute asincrone asimmetriche 
  232.         // 
  233.         // Caso speciale è il profilo asincrono simmetrico
  234.         // - richiesta l'erogatore è il destinatario 
  235.         // - ricevuta alla richiesta è il mittente
  236.         // - risposta è il destinatario, però se per il servizio non è definito un profilo, poi devo vedere il fruitore, ancora per il destinatario
  237.         // - ricevuta alla risposta è il mittente, però se per il servizio non è definito un profilo, poi devo vedere il fruitore, ancora per il mittente
  238.         //
  239.         // Inoltre deve essere gestito il caso in cui la busta arrivata non contiene un servizio.
  240.         // In tal caso mi base sul soggetto mittente, se questo ha profilo che supporta i riscontri, può darsi che mi sta inviando una busta di servizio.
  241.         // Altrimenti, questo non puo' succedere e verrà segnalato un errore

  243.         IDSoggetto idSoggettoFruitoreProfiloGestito = null;
  244.         if(busta.getTipoServizio()!=null && busta.getServizio()!=null){     
  245.             IDSoggetto idSoggettoErogatoreProfiloGestito = null;
  246.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(busta.getProfiloDiCollaborazione()) && RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){
  247.                 idSoggettoErogatoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  248.                 idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  249.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) && (RuoloBusta.RICHIESTA.equals(tipoBusta.toString())==false) ){
  250.                 if(RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString())){
  251.                     idSoggettoErogatoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  252.                     idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  253.                 }else if(RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){
  254.                     idSoggettoErogatoreProfiloGestito = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  255.                     idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  256.                 }else { // RICEVUTA_RISPOSTA
  257.                     idSoggettoErogatoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  258.                     idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  259.                 }
  260.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) &&
  261.                     (RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString()) || RuoloBusta.RICEVUTA_RISPOSTA.equals(tipoBusta.toString())) ){
  262.                 idSoggettoErogatoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  263.                 idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  264.             }else{
  265.                 idSoggettoErogatoreProfiloGestito = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  266.                 idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  267.             }
  268.             
  269.             IDServizio idServizioProfiloGestito = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(), 
  270.                     idSoggettoErogatoreProfiloGestito, 
  271.                     busta.getVersioneServizio());
  272.             idServizioProfiloGestito.setAzione(busta.getAzione());
  273.             
  274.             return RegistroServiziManager.getInstance(state).getProfiloGestioneErogazioneServizio(idSoggettoFruitoreProfiloGestito, idServizioProfiloGestito, null, requestInfo);
  275.         }
  276.         else{
  277.             idSoggettoFruitoreProfiloGestito = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  278.             return RegistroServiziManager.getInstance(state).getProfiloGestioneSoggetto(idSoggettoFruitoreProfiloGestito, null, requestInfo);
  279.         }
  280.     }


  283.     public static RuoloBusta getTipoBustaDaValidare(ServiceBinding serviceBinding, Busta busta, org.openspcoop2.protocol.sdk.IProtocolFactory<?> protocolFactory, 
  284.             boolean rispostaConnectionReply, IState state, Logger log) throws ProtocolException{

  286.         RuoloBusta tipo = RuoloBusta.BUSTA_DI_SERVIZIO;

  288.         if(busta.getProfiloDiCollaborazione()==null || 
  289.                 busta.getServizio()==null ||
  290.                 busta.getTipoServizio()==null){ 
  291.             tipo = RuoloBusta.BUSTA_DI_SERVIZIO;
  292.         } 

  294.         // OneWay
  295.         else if(busta.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY) &&
  296.                 busta.getRiferimentoMessaggio()!=null) {
  297.             // X Interoperabilita' spcoop
  298.             if(protocolFactory.createProtocolConfiguration().isSupportato(serviceBinding, FunzionalitaProtocollo.RIFERIMENTO_ID_RICHIESTA)) {
  299.                 tipo = RuoloBusta.RICHIESTA;
  300.             }
  301.             else {
  302.                 tipo = RuoloBusta.BUSTA_DI_SERVIZIO;
  303.             }
  304.         }else if(busta.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY))
  305.             tipo = RuoloBusta.RICHIESTA;

  307.         // Sincrono
  308.         else if(busta.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO)){
  309.             if(busta.getRiferimentoMessaggio() == null) {
  310.                 tipo = RuoloBusta.RICHIESTA;
  311.             }else {
  312.                 if(rispostaConnectionReply) {
  313.                     tipo = RuoloBusta.RISPOSTA;
  314.                 }
  315.                 else {
  316.                     if(protocolFactory.createProtocolConfiguration().isSupportato(serviceBinding, FunzionalitaProtocollo.RIFERIMENTO_ID_RICHIESTA)) {
  317.                         tipo = RuoloBusta.RICHIESTA;
  318.                     }
  319.                     else {
  320.                         tipo = RuoloBusta.RISPOSTA;
  321.                     }
  322.                 }
  323.             }
  324.         }
  325.         
  326.         // Asincrono Simmetrico e Asimmetrico
  327.         else if( (busta.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO)) ||
  328.                 (busta.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)) ){
  329.             // NOTA:
  330.             //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  331.         
  332.             if( (busta.getRiferimentoMessaggio() == null) && (busta.getCollaborazione()==null) ){
  333.                 tipo = RuoloBusta.RICHIESTA;
  334.             } else {
  335.                 ProfiloDiCollaborazione profilo = new ProfiloDiCollaborazione(state, log, protocolFactory);
  336.                 if(profilo.asincrono_isRicevutaRichiesta(busta.getRiferimentoMessaggio())){
  337.                     tipo = RuoloBusta.RICEVUTA_RICHIESTA;   
  338.                 }else if(profilo.asincrono_isRicevutaRisposta(busta.getRiferimentoMessaggio())){
  339.                     tipo = RuoloBusta.RICEVUTA_RISPOSTA;    
  340.                 }else if( (rispostaConnectionReply==false) && (profilo.asincrono_isRisposta(busta)) ){
  341.                     tipo = RuoloBusta.RISPOSTA;
  342.                 }else{
  343.                     tipo = RuoloBusta.RICHIESTA;
  344.                 }
  345.             }
  346.         } 
  347.         return tipo;
  348.     }

  350.  
  351.     /**
  352.      * Metodo che si occupa di validare l'identificativo <var>id</var> secondo la specifica.
  353.      *
  354.      * @param id identificativo da validare
  355.      * @return il valore boolean true se l'identificativo fornito e' conforme alla specifica. Altrimenti false.
  356.      * @throws ProtocolException 
  357.      * 
  358.      */
  359.     public boolean validazioneID(String id) throws ProtocolException{
  360.         return validazioneID(id,null,null,null);
  361.     }

  363.     /**
  364.      * Metodo che si occupa di validare l'identificativo <var>id</var> secondo la specifica.
  365.      * L'identificativo e' formato da :
  366.      * codAmministrazione_codPortaDominio_num.progressivo_data_ora
  367.      * <p>
  368.      * Il codice Amministrazione e' preso da <var>codAmm</var>. 
  369.      * Il codice Amministrazione deve contenere l'identificativo parte del mittente, quando deve essere validato
  370.      * un identificativo del messaggio od una collaborazione di una richiesta 
  371.      * (oneWay, richiestaSincrona , richiesta/ricevutaRisposta AsincronaSimmetrica , 
  372.      *  richiesta/richiestaStato AsincronaAsimmetrica), poiche' e' lui che lo ha spedito 
  373.      * e che ha quindi creato l'identificatore.
  374.      * Deve contenere invece il codice del destinatario, quando deve essere validato un RiferimentoMessaggio, od una
  375.      * collaborazione di una risposta (Sincrona , ricevutaRichiesta/Risposta AsincronaSimmetrica ,
  376.      * ricevutaRichiesta/ricevutaRichiestaStato AsincronaAsimmetrica),
  377.      * poiche' la creazione dell'identificatore venne fatta dal destinatario quando creo' la richiesta.
  378.      * <p>
  379.      * Il codice amministrativo <var>codAmm</var>,  sara' utilizzato anche per ottenere dal 
  380.      * registro dei servizi di openspcoop la validazione del codice della Porta di Dominio presente nell'identificativo.
  381.      * 
  382.      * Prima di invocare questo metodo deve essere stata effettuata l'inizializzazione 
  383.      * dell'engine utilizzato per leggere all'interno del registro dei servizi, 
  384.      * attraverso il metodo 'initialize' della classe {@link org.openspcoop2.protocol.registry.RegistroServiziReader}
  385.      *
  386.      * @param id identificativo da validare
  387.      * @param codAmm Identificativo Parte mittente o destinatario di una busta.
  388.      * @param codDominio Identificativo del dominio del codice di amministrazione
  389.      * @return il valore boolean true se l'identificativo fornito e' conforme alla specifica. Altrimenti false.
  390.      * @throws ProtocolException 
  391.      * 
  392.      */
  393.     private boolean validazioneID(String id, String tipoCodAmm, String codAmm, String codDominio) throws ProtocolException{
  394.         ProprietaValidazione proprietaValidazione = new ProprietaValidazione();
  395.         proprietaValidazione.setValidazioneIDCompleta(this.validazioneIdentificativiCompleta);
  396.         IDSoggetto dominio = new IDSoggetto(tipoCodAmm, codAmm, codDominio);
  397.         return this.protocolFactory.createValidazioneSemantica(this.state).validazioneID(id, dominio, proprietaValidazione);
  398.     }

  400.     
  401.     /**
  402.      * Metodo che si occupa di validare il riferimento del messaggio
  403.      *
  404.      * @param tipoBusta tipo di Busta da validare
  405.      * 
  406.      */
  407.     private void validazioneRiferimentoMessaggio(RuoloBusta tipoBusta)throws ProtocolException{
  408.         if(this.state==null &&
  409.                 RuoloBusta.RICHIESTA.equals(tipoBusta) &&
  410.                 this.busta!=null
  411.                 &&
  412.                 (
  413.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(this.busta.getProfiloDiCollaborazione())
  414.                         ||
  415.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(this.busta.getProfiloDiCollaborazione())
  416.                 )
  417.                 ) {
  418.             return; // per supportare il rilascio della connessione
  419.         }
  420.         
  421.         if(this.state instanceof StatefulMessage) {
  422.             StatefulMessage stateful = (StatefulMessage)this.state;

  424.             //OneWay: non importa il riferimentoMessaggio...

  426.             org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione profiloDiCollaborazione = 
  427.                 new org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione(stateful, this.log, this.protocolFactory);
  428.             boolean error = false;

  430.             // Sincrono
  431.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(this.busta.getProfiloDiCollaborazione())){
  432.                 if( RuoloBusta.RISPOSTA.equals(tipoBusta.toString()) ){
  433.                     if(profiloDiCollaborazione.sincrono_validazioneRiferimentoMessaggio(this.busta.getRiferimentoMessaggio())==false){
  434.                         error = true;
  435.                     }
  436.                 }
  437.             }   

  439.             // Asincrono Simmetrico
  440.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())){
  441.                 if(profiloDiCollaborazione.asincronoSimmetrico_validazioneRiferimentoMessaggio(this.busta.getRiferimentoMessaggio())==false){
  442.                     error = true;
  443.                 }
  444.             } 

  446.             //  Asincrono Asimmetrico
  447.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())){
  448.                 if(RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){
  449.                     // richiestaStato
  450.                     if(profiloDiCollaborazione.asincronoAsimmetrico_validazioneRiferimentoMessaggio_richiestaStato(this.busta.getRiferimentoMessaggio())==false){
  451.                         error = true;
  452.                     }
  453.                 }else {
  454.                     // ricevuta
  455.                     if(profiloDiCollaborazione.asincronoAsimmetrico_validazioneRiferimentoMessaggio_ricevuta(this.busta.getRiferimentoMessaggio())==false){
  456.                         error = true;
  457.                     }
  458.                 }
  459.             } 

  461.             if(error){
  462.                 Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(), this.protocolFactory);
  463.                 this.erroriValidazione.add(ecc);
  464.             }
  465.         }else if (this.state instanceof StatelessMessage){
  466.             // Lo stateless gestisce solo i profili oneway e sincrono
  467.             // Il oneway non ha una busta correlata
  468.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(this.busta.getProfiloDiCollaborazione())){
  469.                 StatelessMessage stateless = (StatelessMessage)this.state;
  470.                 Busta bustaCorrelata = stateless.getBustaCorrelata();
  471.                 if(bustaCorrelata!=null){
  472.                     if(this.busta.getRiferimentoMessaggio()!=null && !(this.busta.getRiferimentoMessaggio().equals(bustaCorrelata.getID())) ){
  473.                         Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(), this.protocolFactory);
  474.                         this.erroriValidazione.add(ecc);
  475.                     }
  476.                 }
  477.             }
  478.         }else{
  479.             throw new ProtocolException("Metodo invocato con IState non valido");
  480.         }
  481.     }
  482.     
  483.     private void riconoscimentoCollaborazione(RuoloBusta tipoBusta, RequestInfo requestInfo) throws ProtocolException{
  484.                 
  485.         //log.info("Validazione mittente...");
  486.         // Mittente: check registrazione nel Registro dei Servizi
  487.         IDSoggetto soggMitt = new IDSoggetto(this.busta.getTipoMittente(),this.busta.getMittente());
  488.         String dominioMittente = null;
  489.         try{
  490.             dominioMittente = this.registroServiziReader.getDominio(soggMitt,null,this.protocolFactory, requestInfo); //null=allRegistri 
  491.             if(dominioMittente==null)
  492.                 throw new Exception("Dominio non definito");
  493.         }catch(DriverRegistroServiziNotFound es){
  494.             Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.MITTENTE_SCONOSCIUTO.getErroreCooperazione(), this.protocolFactory);
  495.             this.log.debug("Identificazione mittente fallita:"+es.getMessage());
  496.             this.erroriValidazione.add(ecc);
  497.             return;
  498.         }catch(Exception es){
  499.             Eccezione ecc = Eccezione.getEccezioneProcessamento(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.
  500.                     getErroreProcessamento("Identificazione mittente non riuscita: errore di processamento"), this.protocolFactory);
  501.             this.log.error("Identificazione mittente non riuscita",es);
  502.             this.erroriProcessamento.add(ecc);
  503.             return;
  504.         }

  506.         //log.info("Validazione destinatario...");
  507.         // Destinatario: check registrazione nel Registro dei Servizi
  508.         IDSoggetto soggDest = new IDSoggetto(this.busta.getTipoDestinatario(),this.busta.getDestinatario());
  509.         String dominioDestinatario = null;
  510.         try{
  511.             dominioDestinatario = this.registroServiziReader.getDominio(soggDest,null,this.protocolFactory, requestInfo); // null=allRegistri
  512.             if(dominioDestinatario==null)
  513.                 throw new Exception("Dominio non definito");
  514.         }catch(DriverRegistroServiziNotFound es){
  515.             Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.DESTINATARIO_SCONOSCIUTO.getErroreCooperazione(), this.protocolFactory);
  516.             this.log.debug("Identificazione destinatario fallita: "+es.getMessage());
  517.             this.erroriValidazione.add(ecc);
  518.             return;
  519.         }catch(Exception es){
  520.             Eccezione ecc = Eccezione.getEccezioneProcessamento(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.
  521.                     getErroreProcessamento("Identificazione destinatario non riuscita: errore di processamento"), this.protocolFactory);
  522.             this.log.error("Identificazione destinatario non riuscita",es);
  523.             this.erroriProcessamento.add(ecc);
  524.             return;
  525.         }
  526.         
  527.         
  528.         // La collaborazione deve appartenere o al mittente, o al destinatario della busta.
  529.         if(this.busta.getCollaborazione()!=null){
  530.             if( (validazioneID(this.busta.getCollaborazione(),this.busta.getTipoMittente(),this.busta.getMittente(),dominioMittente) == false) &&
  531.                     (validazioneID(this.busta.getCollaborazione(),this.busta.getTipoDestinatario(),this.busta.getDestinatario(),dominioDestinatario) == false) ){
  532.                 Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.COLLABORAZIONE_NON_VALIDA.getErroreCooperazione(), this.protocolFactory);
  533.                 this.erroriValidazione.add(ecc);
  534.                 return;
  535.             }
  536.         }
  537.         
  538.         boolean validaIdCollaborazioneProfiliNonOneway = false;
  539.         boolean validaIdCollaborazioneConsegnaInOrdine = false;
  540.         if(!org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(this.busta.getProfiloDiCollaborazione())){
  541.             validaIdCollaborazioneProfiliNonOneway = (tipoBusta.equals(RuoloBusta.RICHIESTA) == false);
  542.         }
  543.         else {
  544.             if(this.busta.getSequenza()!=-1 && this.busta.getCollaborazione()!=null) {
  545.                 validaIdCollaborazioneConsegnaInOrdine = true;
  546.             }
  547.         }
  548.         
  549.         if(!validaIdCollaborazioneProfiliNonOneway && !validaIdCollaborazioneConsegnaInOrdine) {
  550.             return;
  551.         }
  552.         
  553.         if(this.state instanceof StatefulMessage) {
  554.             StatefulMessage stateful = (StatefulMessage)this.state;
  555.             if(this.busta.getCollaborazione()!=null){

  557.                 org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione profiloDiCollaborazione = 
  558.                     new org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione(stateful, this.log, this.protocolFactory);
  559.                 
  560.                 // Validazione Collaborazione.
  561.                 boolean error = false;

  563.                 // Check per profili non oneway
  564.                 if(!org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(this.busta.getProfiloDiCollaborazione())){

  566.                     //  Sulla busta di richiesta non posso effettuare alcun controllo.
  567.                     if(tipoBusta.equals(RuoloBusta.RICHIESTA) == false){

  569.                         // buste di risposta/ricevuta
  570.                         //  Sincrono
  571.                         if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(this.busta.getProfiloDiCollaborazione())){
  572.                             if(RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){ 
  573.                                 if(profiloDiCollaborazione.sincrono_validazioneCollaborazione(this.busta.getRiferimentoMessaggio(),this.busta.getCollaborazione())==false){
  574.                                     error = true;
  575.                                 }
  576.                             }
  577.                         }
  578.                         // Asincrono Simmetrico
  579.                         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())){
  580.                             // Risposta
  581.                             if(RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){
  582.                                 if(profiloDiCollaborazione.asincronoSimmetrico_validazioneCollaborazione_risposta(this.busta.getRiferimentoMessaggio(),this.busta.getCollaborazione())==false){
  583.                                     error = true;
  584.                                 }
  585.                             }else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString()) || RuoloBusta.RICEVUTA_RISPOSTA.equals(tipoBusta.toString())){
  586.                                 if(profiloDiCollaborazione.asincronoSimmetrico_validazioneCollaborazione_ricevuta(this.busta.getRiferimentoMessaggio(),this.busta.getCollaborazione())==false){
  587.                                     error = true;
  588.                                 }
  589.                             }
  590.                         }
  591.                         // Asincrono Asimmetrico
  592.                         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())){
  593.                             // richiestaStato
  594.                             if(RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){
  595.                                 if(profiloDiCollaborazione.asincronoAsimmetrico_validazioneCollaborazione_richiestaStato(this.busta.getRiferimentoMessaggio(),this.busta.getCollaborazione())==false){
  596.                                     error = true;
  597.                                 }
  598.                             }else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString()) || RuoloBusta.RICEVUTA_RISPOSTA.equals(tipoBusta.toString())){
  599.                                 if(profiloDiCollaborazione.asincronoAsimmetrico_validazioneCollaborazione_ricevuta(this.busta.getRiferimentoMessaggio(),this.busta.getCollaborazione())==false){
  600.                                     error = true;
  601.                                 }
  602.                             }
  603.                         }   
  604.                     }
  605.                 }

  607.                 // check per profilo oneway
  608.                 else{
  609.                     
  610.                     if(validaIdCollaborazioneConsegnaInOrdine) {
  611.                         org.openspcoop2.protocol.engine.driver.ConsegnaInOrdine consegna = new org.openspcoop2.protocol.engine.driver.ConsegnaInOrdine(stateful,this.log,this.protocolFactory);
  612.                         Eccezione ecc = consegna.validazioneDatiConsegnaInOrdine(this.busta, this.protocolFactory);
  613.                         if(ecc!=null){
  614.                             this.erroriValidazione.add(ecc);
  615.                             return;
  616.                         }
  617.                     }

  619.                 }

  621.                 // se errori sono stati riscontrati in un profilo non oneWay
  622.                 if(error){
  623.                     Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.COLLABORAZIONE_SCONOSCIUTA.getErroreCooperazione(), this.protocolFactory);
  624.                     this.erroriValidazione.add(ecc);
  625.                     return;
  626.                 }
  627.             }

  629.             return;
  630.         }else if (this.state instanceof StatelessMessage){
  631.             // Lo stateless gestisce solo i profili oneway e sincrono
  632.             
  633.             StatelessMessage stateless = (StatelessMessage)this.state;
  634.             
  635.             // Check per profili oneway
  636.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(this.busta.getProfiloDiCollaborazione())){
  637.             
  638.                 if(validaIdCollaborazioneConsegnaInOrdine) {
  639.                     org.openspcoop2.protocol.engine.driver.ConsegnaInOrdine consegna = new org.openspcoop2.protocol.engine.driver.ConsegnaInOrdine(stateless,this.log,this.protocolFactory);
  640.                     Eccezione ecc = consegna.validazioneDatiConsegnaInOrdine(this.busta, this.protocolFactory);
  641.                     if(ecc!=null){
  642.                         this.erroriValidazione.add(ecc);
  643.                         return;
  644.                     }
  645.                 }
  646.                 
  647.             }
  648.             
  649.             return;
  650.         }else{
  651.             throw new ProtocolException("Metodo invocato con IState non valido");
  652.         }
  653.     }
  654.     
  655.     /**
  656.      * Effettua la validazione della correlazione con la precedente richiesta
  657.      * 
  658.      * @param tipoBusta tipo di Busta da validare
  659.      * 
  660.      */
  661.     private void validazioneCorrelazione(RuoloBusta tipoBusta) throws ProtocolException{
  662.         if(this.state instanceof StatefulMessage) {
  663.             StatefulMessage stateful = (StatefulMessage)this.state;
  664.             org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione profiloDiCollaborazione = 
  665.                 new org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione(stateful, this.log, this.protocolFactory);
  666.             Eccezione ecc = null;
  667.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(this.busta.getProfiloDiCollaborazione())){
  668.                 if( RuoloBusta.RISPOSTA.equals(tipoBusta.toString()) ){
  669.                     ecc = profiloDiCollaborazione.sincrono_validazioneCorrelazione(this.busta, this.protocolFactory);
  670.                 }
  671.             }
  672.             else if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) ){
  673.                 if( RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString()) ){
  674.                     ecc = profiloDiCollaborazione.asincronoSimmetrico_validazioneCorrelazione_ricevutaRichiesta(this.busta, this.protocolFactory);
  675.                 }else if( RuoloBusta.RISPOSTA.equals(tipoBusta.toString()) ){
  676.                     ecc = profiloDiCollaborazione.asincronoSimmetrico_validazioneCorrelazione_risposta(this.busta, this.protocolFactory);
  677.                 }else if( RuoloBusta.RICEVUTA_RISPOSTA.equals(tipoBusta.toString()) ){
  678.                     ecc = profiloDiCollaborazione.asincronoSimmetrico_validazioneCorrelazione_ricevutaRisposta(this.busta, this.protocolFactory);
  679.                 }
  680.             }
  681.             else if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) ){
  682.                 if( RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString()) ){
  683.                     ecc = profiloDiCollaborazione.asincronoAsimmetrico_validazioneCorrelazione_ricevutaRichiesta(this.busta, this.protocolFactory);
  684.                 }else if( RuoloBusta.RISPOSTA.equals(tipoBusta.toString()) ){
  685.                     ecc = profiloDiCollaborazione.asincronoAsimmetrico_validazioneCorrelazione_richiestaStato(this.busta, this.protocolFactory);
  686.                 }else if( RuoloBusta.RICEVUTA_RISPOSTA.equals(tipoBusta.toString()) ){
  687.                     ecc = profiloDiCollaborazione.asincronoAsimmetrico_validazioneCorrelazione_ricevutaRichiestaStato(this.busta, this.protocolFactory);
  688.                 }
  689.             }   
  690.             if(ecc!=null){
  691.                 this.erroriValidazione.add(ecc);
  692.                 return;
  693.             }
  694.         }else if (this.state instanceof StatelessMessage){
  695.             // Lo stateless gestisce solo i profili oneway e sincrono
  696.             // Il oneway non ha una busta correlata
  697.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(this.busta.getProfiloDiCollaborazione())){
  698.                 StatelessMessage stateless = (StatelessMessage)this.state;
  699.                 Busta bustaCorrelata = stateless.getBustaCorrelata();
  700.                 if(bustaCorrelata!=null){
  701.                                         
  702.                     if (this.busta.getTipoDestinatario().equals(bustaCorrelata.getTipoMittente())==false){
  703.                         Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.
  704.                                 getErroreCooperazione("Tipo del mittente diverso da quello atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  705.                         this.erroriValidazione.add(ecc);
  706.                         return;
  707.                     }
  708.                     if (this.busta.getDestinatario().equals(bustaCorrelata.getMittente())==false){
  709.                         Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.MITTENTE_NON_VALIDO.
  710.                                 getErroreCooperazione("Mittente diverso da quello atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  711.                         this.erroriValidazione.add(ecc);
  712.                         return;
  713.                     }
  714.                     if (this.busta.getTipoMittente().equals(bustaCorrelata.getTipoDestinatario())==false){
  715.                         Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.TIPO_DESTINATARIO_NON_VALIDO.
  716.                                 getErroreCooperazione("Tipo del destinatario diverso da quello atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  717.                         this.erroriValidazione.add(ecc);
  718.                         return;
  719.                     }
  720.                     if (this.busta.getMittente().equals(bustaCorrelata.getDestinatario())==false){
  721.                         Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.DESTINATARIO_NON_VALIDO.
  722.                                 getErroreCooperazione("Destinatario diverso da quello atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  723.                         this.erroriValidazione.add(ecc);
  724.                         return;
  725.                     }

  727.                     if(this.busta.getServizio()!=null && bustaCorrelata.getTipoServizio()!=null){
  728.                         if (this.busta.getTipoServizio().equals(bustaCorrelata.getTipoServizio())==false){
  729.                             Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.
  730.                                     getErroreCooperazione("Tipo di servizio diverso da quello atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  731.                             this.erroriValidazione.add(ecc);
  732.                             return;
  733.                         }
  734.                         if (this.busta.getServizio().equals(bustaCorrelata.getServizio())==false){
  735.                             Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.SERVIZIO_NON_VALIDO.
  736.                                     getErroreCooperazione("Servizio diverso da quello atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  737.                             this.erroriValidazione.add(ecc);
  738.                             return;
  739.                         }
  740.                         if(this.busta.getAzione()!=null){
  741.                             if (this.busta.getAzione().equals(bustaCorrelata.getAzione()) == false){
  742.                                 Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.AZIONE_NON_VALIDA.
  743.                                         getErroreCooperazione("Azione diversa da quella atteso nella gestione del profilo di collaborazione Sincrono"), this.protocolFactory);
  744.                                 this.erroriValidazione.add(ecc);
  745.                                 return;
  746.                             }
  747.                         }
  748.                     }
  749.                 }
  750.             }
  751.         }else{
  752.             throw new ProtocolException("Metodo invocato con IState non valido");
  753.         }
  754.     }
  755.     
  756.     /**
  757.      * Metodo che si occupa di validare il riferimento del messaggio
  758.      *
  759.      * @param tipoBusta tipo di Busta da validare
  760.      * 
  761.      */
  762.     
  763.     /**
  764.      * Eventuale servizio correlato associato al servizio presente nella busta.
  765.      *
  766.      * @return Eventuale servizio correlato associato al servizio presente nella busta.
  767.      * 
  768.      */
  769.     public String getServizioCorrelato() {
  770.         return this.servizioCorrelato;
  771.     }

  773.     /**
  774.      * Eventuale tipo di servizio correlato associato al servizio presente nella busta.
  775.      *
  776.      * @return Eventuale tipo di servizio correlato associato al servizio presente nella busta.
  777.      * 
  778.      */
  779.     public String getTipoServizioCorrelato() {
  780.         return this.tipoServizioCorrelato;
  781.     }
  782.     public Integer getVersioneServizioCorrelato() {
  783.         return this.versioneServizioCorrelato;
  784.     }
  785.     public Servizio getInfoServizio() {
  786.         return this.infoServizio;
  787.     }
  788.     public String getAzioneCorrelata() {
  789.         return this.azioneCorrelata;
  790.     }
  791.     public void setAzioneCorrelata(String azioneCorrelata) {
  792.         this.azioneCorrelata = azioneCorrelata;
  793.     }
  794.     public void setValidazioneIdentificativiCompleta(boolean v) {
  795.         this.validazioneIdentificativiCompleta = v;
  796.     }

  798. }
Created with JaCoCo 0.8.8.202204050719