RicezioneBusteGeneratoreBustaErrore.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.  */
  20. package org.openspcoop2.pdd.services.core;

  22. import java.util.ArrayList;
  23. import java.util.List;

  25. import org.openspcoop2.core.commons.CoreException;
  26. import org.openspcoop2.core.id.IDSoggetto;
  27. import org.openspcoop2.message.OpenSPCoop2Message;
  28. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  29. import org.openspcoop2.message.constants.MessageRole;
  30. import org.openspcoop2.message.utils.MessageUtilities;
  31. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  32. import org.openspcoop2.pdd.core.CostantiPdD;
  33. import org.openspcoop2.pdd.core.EJBUtils;
  34. import org.openspcoop2.pdd.core.GestoreMessaggi;
  35. import org.openspcoop2.pdd.core.PdDContext;
  36. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  37. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  38. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  39. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  40. import org.openspcoop2.pdd.logger.Tracciamento;
  41. import org.openspcoop2.pdd.mdb.InoltroRisposte;
  42. import org.openspcoop2.pdd.mdb.Sbustamento;
  43. import org.openspcoop2.pdd.services.error.AbstractErrorGenerator;
  44. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  45. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  46. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  47. import org.openspcoop2.protocol.engine.builder.Imbustamento;
  48. import org.openspcoop2.protocol.engine.constants.Costanti;
  49. import org.openspcoop2.protocol.engine.driver.History;
  50. import org.openspcoop2.protocol.engine.driver.IFiltroDuplicati;
  51. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  52. import org.openspcoop2.protocol.engine.validator.Validatore;
  53. import org.openspcoop2.protocol.sdk.Busta;
  54. import org.openspcoop2.protocol.sdk.Eccezione;
  55. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  56. import org.openspcoop2.protocol.sdk.Integrazione;
  57. import org.openspcoop2.protocol.sdk.ProtocolException;
  58. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  59. import org.openspcoop2.protocol.sdk.Riscontro;
  60. import org.openspcoop2.protocol.sdk.SecurityInfo;
  61. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  62. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  63. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  64. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  65. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  66. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  67. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  68. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  69. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  70. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  71. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  72. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  73. import org.openspcoop2.protocol.sdk.tracciamento.EsitoElaborazioneMessaggioTracciato;
  74. import org.openspcoop2.protocol.sdk.tracciamento.TracciamentoException;
  75. import org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica;
  76. import org.openspcoop2.security.message.MessageSecurityContext;
  77. import org.openspcoop2.utils.date.DateManager;
  78. import org.openspcoop2.utils.resources.Loader;
  79. import org.slf4j.Logger;

  81. /**
  82.  * RicezioneBusteGeneratoreBustaErrore
  83.  * 
  84.  * @author Poli Andrea (apoli@link.it)
  85.  * @author $Author$
  86.  * @version $Rev$, $Date$
  87.  */
  88. public class RicezioneBusteGeneratoreBustaErrore {

  90.     private RicezioneBusteContext msgContext;
  91.     private RicezioneBusteExternalErrorGenerator generatoreErrore; 
  92.     
  93.     public RicezioneBusteGeneratoreBustaErrore(RicezioneBusteContext msgContext, RicezioneBusteExternalErrorGenerator generatoreErrore) {
  94.         this.msgContext = msgContext;
  95.         this.generatoreErrore = generatoreErrore;
  96.     }
  97.     
  98.     public OpenSPCoop2Message generaBustaErroreProcessamento(RicezioneBusteParametriGenerazioneBustaErrore parametriGenerazioneBustaErrore,Exception e){
  99.         parametriGenerazioneBustaErrore.setErroreProcessamento(true);
  100.         parametriGenerazioneBustaErrore.setEccezioneProcessamento(e);
  101.         return generaBustaErrore(parametriGenerazioneBustaErrore, false);
  102.     }

  104.     public OpenSPCoop2Message generaBustaErroreValidazione(RicezioneBusteParametriGenerazioneBustaErrore parametriGenerazioneBustaErrore){
  105.         parametriGenerazioneBustaErrore.setErroreProcessamento(false);
  106.         return generaBustaErrore(parametriGenerazioneBustaErrore, true);
  107.     }

  109.     public OpenSPCoop2Message generaBustaErrore(RicezioneBusteParametriGenerazioneBustaErrore parametriGenerazioneBustaErrore, boolean erroreValidazione){
  110.         PdDContext pddContext = this.msgContext.getPddContext();
  111.         String idTransazione = (String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  112.         
  113.         try{
  114.             IntegrationFunctionError integrationFunctionError = parametriGenerazioneBustaErrore.getIntegrationFunctionError(pddContext, erroreValidazione);
  115.             
  116.             OpenSPCoop2Message responseErrorMessage = null;
  117.         
  118.             ErroreCooperazione erroreCooperazione = parametriGenerazioneBustaErrore.getErroreCooperazione();
  119.             ErroreIntegrazione erroreIntegrazione = parametriGenerazioneBustaErrore.getErroreIntegrazione();
  120.             
  121.             List<Eccezione> error = parametriGenerazioneBustaErrore.getError();
  122.             
  123.             
  124.             java.util.Map<String,Object> securityPropertiesResponse = null;
  125.             if(parametriGenerazioneBustaErrore.getFlowPropertiesResponse()!=null && parametriGenerazioneBustaErrore.getFlowPropertiesResponse().messageSecurity!=null)
  126.                 securityPropertiesResponse = parametriGenerazioneBustaErrore.getFlowPropertiesResponse().messageSecurity.getFlowParameters();
  127.             MessageSecurityContext messageSecurityContext = parametriGenerazioneBustaErrore.getMessageSecurityContext();
  128.             OpenSPCoop2Properties propertiesReader = parametriGenerazioneBustaErrore.getPropertiesReader();
  129.             String profiloGestione = parametriGenerazioneBustaErrore.getProfiloGestione();
  130.             String implementazionePdDMittente = parametriGenerazioneBustaErrore.getImplementazionePdDMittente();
  131.             
  132.             Tracciamento tracciamento = parametriGenerazioneBustaErrore.getTracciamento();
  133.             MsgDiagnostico msgDiag = parametriGenerazioneBustaErrore.getMsgDiag();
  134.             
  135.             Integrazione integrazione = parametriGenerazioneBustaErrore.getIntegrazione();
  136.             if(integrazione==null){
  137.                 integrazione = new Integrazione();
  138.                 integrazione.setIdModuloInAttesa(this.msgContext.getIdModulo());
  139.             }
  140.             
  141.             IOpenSPCoopState openspcoopState = parametriGenerazioneBustaErrore.getOpenspcoop();
  142.             

  144.             // Genero messaggio di errore
  145.             this.generatoreErrore.updateState(openspcoopState.getStatoRichiesta());
  146.             if(parametriGenerazioneBustaErrore.isErroreProcessamento()){
  147.                 if(erroreCooperazione!=null){
  148.                     responseErrorMessage = this.generatoreErrore.buildErroreProtocollo_Processamento(
  149.                             integrationFunctionError,
  150.                             parametriGenerazioneBustaErrore.getBusta(),integrazione, idTransazione, erroreCooperazione,
  151.                             securityPropertiesResponse,messageSecurityContext,
  152.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  153.                             propertiesReader.getGestioneSerializableDBCheckInterval(),profiloGestione,
  154.                             propertiesReader.getTipoTempoBusta(implementazionePdDMittente),
  155.                             propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente),
  156.                             parametriGenerazioneBustaErrore.getEccezioneProcessamento(),
  157.                             this.msgContext.getPddContext());
  158.                 }
  159.                 else if(erroreIntegrazione!=null){
  160.                     responseErrorMessage = this.generatoreErrore.buildErroreProtocollo_Processamento(
  161.                             integrationFunctionError,
  162.                             parametriGenerazioneBustaErrore.getBusta(),integrazione, idTransazione, erroreIntegrazione,
  163.                             securityPropertiesResponse,messageSecurityContext,
  164.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  165.                             propertiesReader.getGestioneSerializableDBCheckInterval(),profiloGestione,
  166.                             propertiesReader.getTipoTempoBusta(implementazionePdDMittente),
  167.                             propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente),
  168.                             parametriGenerazioneBustaErrore.getEccezioneProcessamento(),
  169.                             this.msgContext.getPddContext());
  170.                 }else{
  171.                     responseErrorMessage = this.generatoreErrore.buildErroreProtocollo_Processamento(
  172.                             integrationFunctionError,
  173.                             parametriGenerazioneBustaErrore.getBusta(),integrazione, idTransazione, error,
  174.                             securityPropertiesResponse,messageSecurityContext,
  175.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  176.                             propertiesReader.getGestioneSerializableDBCheckInterval(),profiloGestione,
  177.                             propertiesReader.getTipoTempoBusta(implementazionePdDMittente),
  178.                             propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente),
  179.                             parametriGenerazioneBustaErrore.getEccezioneProcessamento(),
  180.                             this.msgContext.getPddContext());
  181.                 }
  182.             }else{
  183.                 if(erroreCooperazione!=null){
  184.                     responseErrorMessage = this.generatoreErrore.buildErroreProtocollo_Intestazione(
  185.                             integrationFunctionError,
  186.                             parametriGenerazioneBustaErrore.getBusta(),integrazione, idTransazione,erroreCooperazione,
  187.                             securityPropertiesResponse,messageSecurityContext,
  188.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  189.                             propertiesReader.getGestioneSerializableDBCheckInterval(),profiloGestione,
  190.                             propertiesReader.getTipoTempoBusta(implementazionePdDMittente),
  191.                             propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente),
  192.                             this.msgContext.getPddContext());
  193.                 }
  194.                 else if(erroreIntegrazione!=null){
  195.                     throw new CoreException("Method 'generaBustaErroreValidazione' not supported for MessaggioErroreIntegrazione");
  196.                 }
  197.                 else {
  198.                     responseErrorMessage = this.generatoreErrore.buildErroreProtocollo_Intestazione(
  199.                             integrationFunctionError,
  200.                             parametriGenerazioneBustaErrore.getBusta(),integrazione, idTransazione,error,
  201.                             securityPropertiesResponse,messageSecurityContext,
  202.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  203.                             propertiesReader.getGestioneSerializableDBCheckInterval(),profiloGestione,
  204.                             propertiesReader.getTipoTempoBusta(implementazionePdDMittente),
  205.                             propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente),
  206.                             this.msgContext.getPddContext());
  207.                 }
  208.             }

  210.             // ProtocolFactory
  211.             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) this.msgContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  212.                         
  213.             //  Tracciamento Busta Ritornata: cambiata nel metodo msgErroreProcessamento
  214.             if(this.msgContext.isTracciamentoAbilitato()){
  215.                 EsitoElaborazioneMessaggioTracciato esitoTraccia = 
  216.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioInviato();
  217.                 SecurityInfo securityInfoResponse  = null;
  218.                 boolean functionAsRouter = false; // In questo caso dovrebbe essere sempre false?
  219.                 if(functionAsRouter && messageSecurityContext!=null && messageSecurityContext.getDigestReader(responseErrorMessage.getFactory())!=null){
  220.                     IValidazioneSemantica validazioneSemantica = protocolFactory.createValidazioneSemantica(openspcoopState.getStatoRichiesta());
  221.                     securityInfoResponse = validazioneSemantica.readSecurityInformation(messageSecurityContext.getDigestReader(responseErrorMessage.getFactory()),responseErrorMessage);
  222.                 }
  223.                 Validatore v = new Validatore(responseErrorMessage,this.msgContext.getPddContext(),openspcoopState.getStatoRichiesta(),
  224.                         parametriGenerazioneBustaErrore.getLogCore(), protocolFactory);
  225.                 tracciamento.registraRisposta(responseErrorMessage,securityInfoResponse,
  226.                         v.getHeaderProtocollo_senzaControlli(), parametriGenerazioneBustaErrore.getBusta(),esitoTraccia,
  227.                         Tracciamento.createLocationString(false,this.msgContext.getSourceLocation()),
  228.                         parametriGenerazioneBustaErrore.getCorrelazioneApplicativa(),
  229.                         parametriGenerazioneBustaErrore.getCorrelazioneApplicativaRisposta());
  230.             }

  232.             // Messaggio diagnostico
  233.             msgDiag.addKeywords(parametriGenerazioneBustaErrore.getBusta(),false);
  234.             IProtocolManager protocolManager = protocolFactory.createProtocolManager();
  235.             if( (!protocolManager.getKeywordMittenteSconosciuto().equals(parametriGenerazioneBustaErrore.getBusta().getDestinatario())) &&
  236.                     (!protocolManager.getKeywordTipoMittenteSconosciuto().equals(parametriGenerazioneBustaErrore.getBusta().getTipoDestinatario())) ){
  237.                 if(parametriGenerazioneBustaErrore.getBusta().getDestinatario()==null && parametriGenerazioneBustaErrore.getBusta().getTipoDestinatario()==null){
  238.                     msgDiag.logPersonalizzato("generazioneMessaggioErroreRisposta.mittenteAnonimo");
  239.                 }
  240.                 else{
  241.                     msgDiag.logPersonalizzato("generazioneMessaggioErroreRisposta");
  242.                 }
  243.             } 
  244.             else{
  245.                 msgDiag.logPersonalizzato("generazioneMessaggioErroreRisposta.destinatarioSconosciuto");
  246.             }
  247.             
  248.             // Imposto Identificativo Risposta
  249.             // Nota: la bustaRichiesta e' stata trasformata (invertita)
  250.             msgDiag.setIdMessaggioRisposta(parametriGenerazioneBustaErrore.getBusta().getID());
  251.             this.msgContext.getProtocol().setIdRisposta(parametriGenerazioneBustaErrore.getBusta().getID());
  252.             
  253.             if(parametriGenerazioneBustaErrore.getParseException()!=null){
  254.                 responseErrorMessage.setParseException(parametriGenerazioneBustaErrore.getParseException());
  255.             }
  256.             
  257.             return responseErrorMessage;

  259.         }catch(Exception e){
  260.             return this.generatoreErrore.buildFault(e,pddContext);
  261.         }
  262.     }


  265.     public void sendRispostaBustaErrore(RicezioneBusteParametriInvioBustaErrore parametriInvioBustaErrore){
  266.         sendRispostaBustaErrore(parametriInvioBustaErrore, true);
  267.     }
  268.     public void sendRispostaBustaErrore(RicezioneBusteParametriInvioBustaErrore parametriInvioBustaErrore,boolean eliminaMessaggioRicevuto){


  271.         GestoreMessaggi msgResponse = null;
  272.         RepositoryBuste repositoryBuste = null;
  273.         boolean httpReply = true;
  274.         
  275.         IOpenSPCoopState openspcoop = parametriInvioBustaErrore.getOpenspcoop();
  276.         Busta bustaRisposta = parametriInvioBustaErrore.getBusta();
  277.         MsgDiagnostico msgDiag = parametriInvioBustaErrore.getMsgDiag();
  278.         Logger logCore = parametriInvioBustaErrore.getLogCore();
  279.         PdDContext pddContext = parametriInvioBustaErrore.getPddContext();
  280.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  281.         
  282.         try{
  283.             
  284.             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  285.                         

  287.             /* ------- Gestione messaggi di richiesta per stateless --------*/
  288.             if(eliminaMessaggioRicevuto && parametriInvioBustaErrore.isOnewayVersione11()){
  289.                 GestoreMessaggi msgRichiesta = new GestoreMessaggi(openspcoop,true,
  290.                         bustaRisposta.getRiferimentoMessaggio(),Costanti.INBOX,logCore,msgDiag,pddContext);
  291.                 msgRichiesta.setReadyForDrop(true);
  292.                 msgRichiesta.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  293.                 RepositoryBuste repositoryBustaRichiesta = new RepositoryBuste(openspcoop.getStatoRichiesta(),true,protocolFactory);
  294.                 repositoryBustaRichiesta.eliminaBustaStatelessFromInBox(bustaRisposta.getRiferimentoMessaggio());
  295.             }
  296.             
  297.             
  298.             /* ------- Gestione MsgRisposta --------------- */

  300.             // Esamina tipo di risposta (indirizzo di spedizione)
  301.             if( parametriInvioBustaErrore.isNewConnectionForResponse() )
  302.                 httpReply = false;
  303.             if( bustaRisposta.getIndirizzoDestinatario()!=null &&
  304.                     parametriInvioBustaErrore.isUtilizzoIndirizzoTelematico() )
  305.                 httpReply = false;

  307.             // --- Genero una risposta se devo spedirla su di una nuova connessione.
  308.             if(!httpReply){

  310.                 // Salvataggio busta da inviare
  311.                 repositoryBuste = new RepositoryBuste(openspcoop.getStatoRisposta(), false, protocolFactory);
  312.                 repositoryBuste.registraBustaIntoOutBox(bustaRisposta, parametriInvioBustaErrore.getPropertiesReader().getRepositoryIntervalloScadenzaMessaggi());
  313.                 Integrazione infoIntegrazione = new Integrazione();
  314.                 repositoryBuste.aggiornaInfoIntegrazioneIntoOutBox(bustaRisposta.getID(),infoIntegrazione);

  316.                 msgResponse = new GestoreMessaggi(openspcoop, true, bustaRisposta.getID(),Costanti.OUTBOX,msgDiag,pddContext);
  317.                 msgResponse.setOneWayVersione11(parametriInvioBustaErrore.isOnewayVersione11());
  318.                 // --- creazione nuovo stato
  319.                 msgResponse.registraMessaggio(parametriInvioBustaErrore.getOpenspcoopMsg(),parametriInvioBustaErrore.getCorrelazioneApplicativa(),parametriInvioBustaErrore.getCorrelazioneApplicativaRisposta());
  320.                 // ---- aggiorno riferimentoMessaggio
  321.                 msgResponse.aggiornaRiferimentoMessaggio(bustaRisposta.getRiferimentoMessaggio());
  322.                 // --- Aggiornamento Proprietario messaggio
  323.                 // Aggiorno proprietario Messaggio: INOLTRO RISPOSTE    
  324.                 msgResponse.aggiornaProprietarioMessaggio(InoltroRisposte.ID_MODULO);

  326.                 // --- Spedizione al successivo modulo

  328.                 // spedizione al modulo InoltroRisposte
  329.                 EJBUtils ejb = new EJBUtils(parametriInvioBustaErrore.getIdentitaPdD(),this.msgContext.getTipoPorta(),this.msgContext.getIdModulo(),
  330.                         bustaRisposta.getRiferimentoMessaggio(),bustaRisposta.getID(),
  331.                         Costanti.OUTBOX,openspcoop,msgDiag,parametriInvioBustaErrore.isFunctionAsRouter(),
  332.                         parametriInvioBustaErrore.getImplementazionePdDMittente(),
  333.                         parametriInvioBustaErrore.getImplementazionePdDDestinatario(),
  334.                         parametriInvioBustaErrore.getProfiloGestione(),
  335.                         parametriInvioBustaErrore.getPddContext());

  337.                 // Il messaggio gia' possiede la busta, non deve essere effettuato imbustamento da InoltroRisposte
  338.                 ejb.sendToInoltroRisposte(bustaRisposta,false,null, msgResponse,
  339.                         parametriInvioBustaErrore.getCorrelazioneApplicativa(),parametriInvioBustaErrore.getCorrelazioneApplicativaRisposta(),
  340.                         parametriInvioBustaErrore.getServizioApplicativoFruitore(),false);      


  343.                 // Imposto messaggio ritornato nella connection-reply
  344.                 OpenSPCoop2Message soapBodyEmpty = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  345.                         requestInfo.getProtocolRequestMessageType(), MessageRole.RESPONSE);
  346.                 this.msgContext.setMessageResponse(soapBodyEmpty);
  347.                 
  348.             }else{
  349.                 // Imposto messaggio ritornato nella connection-reply
  350.                 OpenSPCoop2Message risposta = parametriInvioBustaErrore.getOpenspcoopMsg();
  351.                 this.msgContext.setMessageResponse(risposta);
  352.                 
  353.             }

  355.             /* ------- Commit/Close Connessione DB --------------- */
  356.             openspcoop.commit();

  358.             // Aggiornamento cache messaggio
  359.             if(msgResponse!=null)
  360.                 msgResponse.addMessaggiIntoCache_readFromTable(RicezioneBuste.ID_MODULO, "risposta verso nuova connessione");

  362.             // Aggiornamento cache proprietario messaggio
  363.             if(msgResponse!=null)
  364.                 msgResponse.addProprietariIntoCache_readFromTable(RicezioneBuste.ID_MODULO, "risposta verso nuova connessione",
  365.                         bustaRisposta.getRiferimentoMessaggio(),parametriInvioBustaErrore.isFunctionAsRouter());


  368.         }catch (Exception e) {
  369.             IntegrationFunctionError integrationFunctionError = AbstractErrorGenerator.getIntegrationInternalError(pddContext); // default
  370.             msgDiag.logErroreGenerico(e, "sendRispostaBustaErrore");
  371.             this.msgContext.setMessageResponse(this.generatoreErrore.buildErroreProcessamento(pddContext,
  372.                     integrationFunctionError,
  373.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(), e));
  374.         }   

  376.     }

  378.     
  379.     public OpenSPCoop2Message generaRispostaMsgGiaRicevuto(boolean printMsg,Busta bustaRichiesta,Integrazione integrazione,MsgDiagnostico msgDiag,
  380.             OpenSPCoopState openspcoopstate,Logger log,OpenSPCoop2Properties properties, String profiloGestione,
  381.             RuoloBusta ruoloBustaRicevuta,String implementazionePdDMittente,IProtocolFactory<?> protocolFactory,
  382.             IDSoggetto identitaPdD,String idTransazione,Loader loader, boolean oneWayVersione11,
  383.             String implementazionePdDSoggettoMittente,
  384.             Tracciamento tracciamento,
  385.             String idCorrelazioneApplicativa,
  386.             PdDContext pddContext, IntegrationFunctionError integrationFunctionError) throws ProtocolException, TracciamentoException{

  388.         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true,protocolFactory);
  389.         History historyBuste = new History(openspcoopstate.getStatoRichiesta(), log);
  390.         Busta bustaHTTPReply = null;
  391.         
  392.         IProtocolVersionManager protocolManager = 
  393.                 ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) this.msgContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME)).createProtocolVersionManager(profiloGestione);
  394.         
  395.         RequestInfo requestInfo = (RequestInfo) this.msgContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  396.         
  397.         boolean consegnaAffidabile = false;
  398.         switch (protocolManager.getConsegnaAffidabile(bustaRichiesta)) {
  399.         case ABILITATA:
  400.             consegnaAffidabile = true;
  401.             break;
  402.         case DISABILITATA:
  403.             consegnaAffidabile = false;
  404.             break;
  405.         default:
  406.             consegnaAffidabile = properties.isGestioneRiscontri(implementazionePdDMittente) && bustaRichiesta.isConfermaRicezione();
  407.             break;
  408.         }
  409.         
  410.         // Aggiorno duplicati
  411.         try{
  412.             IFiltroDuplicati gestoreFiltroDuplicati = Sbustamento.getGestoreFiltroDuplicati(properties, loader, 
  413.                     openspcoopstate, this.msgContext.getPddContext(), historyBuste, repositoryBuste, oneWayVersione11);
  414.             
  415.             boolean oldGestioneConnessione = false;
  416.             boolean rinegozia = false;
  417.             if(gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && !openspcoopstate.resourceReleased()) {
  418.                 rinegozia = true;
  419.                 msgDiag.mediumDebug("Rilascio connessione al database prima di verificare se la richiesta è duplicata ...");
  420.                 oldGestioneConnessione = openspcoopstate.isUseConnection();
  421.                 openspcoopstate.setUseConnection(true);
  422.                 openspcoopstate.commit();
  423.                 openspcoopstate.releaseResource();
  424.             }
  425.             
  426.             gestoreFiltroDuplicati.isDuplicata(protocolFactory, bustaRichiesta.getID()); // lo invoco lo stesso per eventuali implementazioni che utilzzano il worflow
  427.             // Aggiorno duplicati
  428.             if(printMsg){
  429.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"ricezioneBustaDuplicata.count");
  430.             }
  431.             gestoreFiltroDuplicati.incrementaNumeroDuplicati(protocolFactory,bustaRichiesta.getID());
  432.             
  433.             if(gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && rinegozia) {
  434.                 msgDiag.mediumDebug("Rinegozio connessione dopo la verifica di richiesta duplicata ...");
  435.                 rinegoziazioneConnessione(openspcoopstate, idTransazione, oldGestioneConnessione);
  436.             }
  437.             
  438.             openspcoopstate.commit();
  439.         }catch(Exception e){
  440.             log.error("Aggiornamento numero duplicati per busta ["+bustaRichiesta.getID()+"] non riuscito: "+e.getMessage(),e);
  441.         }
  442.         if(printMsg){
  443.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"ricezioneBustaDuplicata");
  444.         }
  445.         
  446.         Imbustamento imbustatore = new Imbustamento(log, protocolFactory, openspcoopstate.getStatoRichiesta());
  447.         
  448.         /* 
  449.          * 1) duplicato in caso di oneWay: se confermaRicezione=true e la gestione dei riscontri e' attiva, re-invio un riscontro
  450.          * 1b) duplicato in caso di oneWay: se confermaRicezione=false o cmq la gestione dei riscontri non è attiva, genero Errore se indicato da file property, altrimenti ritorno http 202
  451.          * 2) duplicati in caso sincrono: genero un msg Errore
  452.          * 3) duplicati in caso asincrono: rigenero la ricevuta
  453.          */
  454.         
  455.         boolean http200 = true;
  456.         
  457.         // 1) 
  458.         if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  459.                 consegnaAffidabile){
  460.             msgDiag.logPersonalizzato("generazioneRiscontro");

  462.             // Costruisco riscontro da re-inviare
  463.             TipoOraRegistrazione tipoOraRegistrazione = properties.getTipoTempoBusta(implementazionePdDMittente);
  464.             bustaHTTPReply = bustaRichiesta.invertiBusta(tipoOraRegistrazione,protocolFactory.createTraduttore().toString(tipoOraRegistrazione));

  466.             String idBustaRisposta = 
  467.                     imbustatore.buildID(identitaPdD, idTransazione, 
  468.                             properties.getGestioneSerializableDBAttesaAttiva(),
  469.                             properties.getGestioneSerializableDBCheckInterval(),
  470.                             RuoloMessaggio.RISPOSTA);
  471.             bustaHTTPReply.setID(idBustaRisposta);
  472.             
  473.             Riscontro r = new Riscontro();
  474.             r.setID(bustaRichiesta.getID());
  475.             r.setOraRegistrazione(DateManager.getDate());
  476.             r.setTipoOraRegistrazione(properties.getTipoTempoBusta(implementazionePdDMittente));
  477.             bustaHTTPReply.addRiscontro(r);

  479.         }
  480.         // 1b) 
  481.         else if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  482.                 ( (!properties.isGestioneRiscontri(implementazionePdDMittente)) || (!bustaRichiesta.isConfermaRicezione()) )  && 
  483.                 ( protocolManager.isGenerazioneErroreMessaggioOnewayDuplicato() || properties.isGenerazioneErroreProtocolloFiltroDuplicati(implementazionePdDMittente))){
  484.             http200 = false;
  485.             
  486.             String idBustaRisposta = 
  487.                     imbustatore.buildID(identitaPdD, idTransazione, 
  488.                             properties.getGestioneSerializableDBAttesaAttiva(),
  489.                             properties.getGestioneSerializableDBCheckInterval(),
  490.                             RuoloMessaggio.RISPOSTA);
  491.             List<Eccezione> v = new ArrayList<>();
  492.             v.add(Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory));
  493.             bustaHTTPReply = this.generatoreErrore.getImbustamentoErrore().buildMessaggioErroreProtocollo_Validazione(v,bustaRichiesta,idBustaRisposta,
  494.                     properties.getTipoTempoBusta(implementazionePdDSoggettoMittente));  
  495.             if( !( identitaPdD.getNome().equals(bustaHTTPReply.getMittente()) && 
  496.                     identitaPdD.getTipo().equals(bustaHTTPReply.getTipoMittente()) ) ){
  497.                 // Il mittente della busta che sara' spedita e' il router
  498.                 bustaHTTPReply.setMittente(identitaPdD.getNome());
  499.                 bustaHTTPReply.setTipoMittente(identitaPdD.getTipo());
  500.                 bustaHTTPReply.setIdentificativoPortaMittente(identitaPdD.getCodicePorta());
  501.                 bustaHTTPReply.setIndirizzoMittente(null);
  502.             }       
  503.             
  504.         }
  505.         // 2)
  506.         /** else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  507.          non ci si entra mai in questo caso. Il metodo non viene mai chiamato nel caso di sincrono
  508.         }*/
  509.         
  510.         // 3
  511.         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  512.                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){

  514.             String ricevuta = null;
  515.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  516.                 // Asincrono Simmetrico
  517.                 if(bustaRichiesta.getRiferimentoMessaggio()==null)
  518.                     ricevuta = "ricevuta di una richiesta asincrona simmetrica";
  519.                 else if(ruoloBustaRicevuta!=null && RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  520.                     ricevuta = "ricevuta di una risposta asincrona simmetrica";
  521.                 }
  522.             }else{
  523.                 //  Asincrono Asimmetrico
  524.                 if(bustaRichiesta.getRiferimentoMessaggio()==null){
  525.                     ricevuta = "ricevuta di una richiesta asincrona asimmetrica";
  526.                     // ServizioCorrelato da impostare nella ricevuta asincrona
  527.                 }else if(ruoloBustaRicevuta!=null && RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  528.                     ricevuta = "ricevuta di una risposta asincrona asimmetrica";
  529.                 }
  530.             }

  532.             if(ricevuta!=null){
  533.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_RICEVUTA_ASINCRONA, ricevuta);
  534.                 msgDiag.logPersonalizzato("generazioneRicevutaAsincrona");

  536.                 // Costruisco ricevuta da re-inviare
  537.                 TipoOraRegistrazione tipoOraRegistrazione = properties.getTipoTempoBusta(implementazionePdDMittente);
  538.                 bustaHTTPReply = bustaRichiesta.invertiBusta(tipoOraRegistrazione,protocolFactory.createTraduttore().toString(tipoOraRegistrazione));
  539.                 bustaHTTPReply.setVersioneServizio(bustaRichiesta.getVersioneServizio());
  540.                 bustaHTTPReply.setServizio(bustaRichiesta.getServizio());
  541.                 bustaHTTPReply.setTipoServizio(bustaRichiesta.getTipoServizio());
  542.                 bustaHTTPReply.setAzione(bustaRichiesta.getAzione());
  543.                 bustaHTTPReply.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  544.                 bustaHTTPReply.setRiferimentoMessaggio(bustaRichiesta.getID());
  545.                 // (per gli asincroni devono sempre essere presenti)
  546.                 if( properties.isGestioneElementoCollaborazione(implementazionePdDMittente))
  547.                     bustaHTTPReply.setCollaborazione(bustaRichiesta.getCollaborazione());       
  548.                 
  549.                 String idBustaRisposta = 
  550.                         imbustatore.buildID(identitaPdD, idTransazione, 
  551.                                 properties.getGestioneSerializableDBAttesaAttiva(),
  552.                                 properties.getGestioneSerializableDBCheckInterval(),
  553.                                 RuoloMessaggio.RISPOSTA);
  554.                 bustaHTTPReply.setID(idBustaRisposta);
  555.             }
  556.         }
  557.         // 4
  558.         else{
  559.             if( protocolManager.isGenerazioneErroreMessaggioOnewayDuplicato() || properties.isGenerazioneErroreProtocolloFiltroDuplicati(implementazionePdDMittente)){
  560.                 http200 = false;
  561.                 
  562.                 String idBustaRisposta = 
  563.                         imbustatore.buildID(identitaPdD, idTransazione, 
  564.                                 properties.getGestioneSerializableDBAttesaAttiva(),
  565.                                 properties.getGestioneSerializableDBCheckInterval(),
  566.                                 RuoloMessaggio.RISPOSTA);
  567.                 List<Eccezione> v = new ArrayList<>();
  568.                 v.add(Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory));
  569.                 bustaHTTPReply = this.generatoreErrore.getImbustamentoErrore().buildMessaggioErroreProtocollo_Validazione(v,bustaRichiesta,idBustaRisposta,
  570.                         properties.getTipoTempoBusta(implementazionePdDSoggettoMittente));  
  571.                 if( !( identitaPdD.getNome().equals(bustaHTTPReply.getMittente()) && 
  572.                         identitaPdD.getTipo().equals(bustaHTTPReply.getTipoMittente()) ) ){
  573.                     // Il mittente della busta che sara' spedita e' il router
  574.                     bustaHTTPReply.setMittente(identitaPdD.getNome());
  575.                     bustaHTTPReply.setTipoMittente(identitaPdD.getTipo());
  576.                     bustaHTTPReply.setIdentificativoPortaMittente(identitaPdD.getCodicePorta());
  577.                     bustaHTTPReply.setIndirizzoMittente(null);
  578.                 }       
  579.             }
  580.         }

  582.         if(bustaHTTPReply==null){
  583.             return MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  584.                     requestInfo.getProtocolRequestMessageType(), MessageRole.RESPONSE);
  585.         }else{
  586.                         
  587.             OpenSPCoop2Message msg = null;
  588.             if(http200){
  589.                 msg = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  590.                         requestInfo.getProtocolRequestMessageType(), MessageRole.RESPONSE);
  591.             }
  592.             else{
  593.                 msg = this.generatoreErrore.buildErroreIntestazione(pddContext,integrationFunctionError);
  594.             }
  595.             
  596.             
  597.             ProtocolMessage protocolMessage = imbustatore.imbustamentoRisposta(msg,pddContext,
  598.                     bustaHTTPReply,bustaRichiesta,
  599.                     integrazione,false,false,null,
  600.                     FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  601.             if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  602.                 msg = protocolMessage.getMessage(); // updated
  603.             }
  604.             
  605.             protocolMessage = imbustatore.imbustamentoRisposta(msg,pddContext,
  606.                     bustaHTTPReply,bustaRichiesta,
  607.                     integrazione,false,false,null,
  608.                     FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  609.             if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  610.                 msg = protocolMessage.getMessage(); // updated
  611.             }
  612.             
  613.             
  614.             //          Tracciamento Busta Ritornata: cambiata nel metodo msgErroreProcessamento
  615.             if(this.msgContext.isTracciamentoAbilitato()){
  616.                 EsitoElaborazioneMessaggioTracciato esitoTraccia = 
  617.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioInviato();
  618.                 SecurityInfo securityInfoResponse  = null;
  619.                 /**boolean functionAsRouter = false; // In questo caso dovrebbe essere sempre false?
  620.                 if(functionAsRouter){
  621.                     if(messageSecurityContext!=null && messageSecurityContext.getDigestReader()!=null){
  622.                         IValidazioneSemantica validazioneSemantica = protocolFactory.createValidazioneSemantica();
  623.                         securityInfoResponse = validazioneSemantica.readSecurityInformation(messageSecurityContext.getDigestReader(),msg);
  624.                     }
  625.                 }*/
  626.                 Validatore v = new Validatore(msg,this.msgContext.getPddContext(),openspcoopstate.getStatoRichiesta(),
  627.                         log, protocolFactory);
  628.                 tracciamento.registraRisposta(msg,securityInfoResponse,
  629.                         v.getHeaderProtocollo_senzaControlli(), bustaHTTPReply,esitoTraccia,
  630.                         Tracciamento.createLocationString(false,this.msgContext.getSourceLocation()),
  631.                         idCorrelazioneApplicativa,
  632.                         null);
  633.             }
  634.             
  635.             return msg;
  636.         }
  637.     }
  638.     
  639.     private void rinegoziazioneConnessione(OpenSPCoopState openspcoopstate, String idTransazione, boolean oldGestioneConnessione) throws ProtocolException {
  640.         try{
  641.             openspcoopstate.updateResource(idTransazione);
  642.             openspcoopstate.setUseConnection(oldGestioneConnessione);
  643.         }catch(Exception e){
  644.             throw new ProtocolException("Rinegoziazione connessione dopo la verifica di richiesta duplicata fallita: "+e.getMessage(),e);
  645.         } 
  646.     }
  647. }
Created with JaCoCo 0.8.8.202204050719