TransazioneUtilities.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.logger.transazioni;

  22. import java.io.ByteArrayOutputStream;
  23. import java.sql.Timestamp;
  24. import java.util.ArrayList;
  25. import java.util.Date;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.commons.CoreException;
  32. import org.openspcoop2.core.config.Transazioni;
  33. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  34. import org.openspcoop2.core.constants.Costanti;
  35. import org.openspcoop2.core.constants.CostantiLabel;
  36. import org.openspcoop2.core.constants.TipoPdD;
  37. import org.openspcoop2.core.controllo_traffico.beans.MisurazioniTransazione;
  38. import org.openspcoop2.core.id.IDAccordo;
  39. import org.openspcoop2.core.id.IDServizio;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  42. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  43. import org.openspcoop2.core.registry.GruppoAccordo;
  44. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  45. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  46. import org.openspcoop2.core.transazioni.CredenzialeMittente;
  47. import org.openspcoop2.core.transazioni.Transazione;
  48. import org.openspcoop2.core.transazioni.TransazioneExtendedInfo;
  49. import org.openspcoop2.core.transazioni.constants.PddRuolo;
  50. import org.openspcoop2.core.transazioni.constants.RuoloTransazione;
  51. import org.openspcoop2.core.transazioni.constants.TipoAPI;
  52. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  53. import org.openspcoop2.core.transazioni.utils.PropertiesSerializator;
  54. import org.openspcoop2.core.transazioni.utils.TempiElaborazioneUtils;
  55. import org.openspcoop2.core.transazioni.utils.credenziali.AbstractCredenzialeList;
  56. import org.openspcoop2.message.OpenSPCoop2RestMessage;
  57. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  58. import org.openspcoop2.message.constants.MessageRole;
  59. import org.openspcoop2.message.constants.ServiceBinding;
  60. import org.openspcoop2.message.xml.MessageXMLUtils;
  61. import org.openspcoop2.monitor.engine.condition.EsitoUtils;
  62. import org.openspcoop2.monitor.sdk.transaction.FaseTracciamento;
  63. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  64. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  65. import org.openspcoop2.pdd.core.CostantiPdD;
  66. import org.openspcoop2.pdd.core.EJBUtils;
  67. import org.openspcoop2.pdd.core.EJBUtilsMessaggioInConsegna;
  68. import org.openspcoop2.pdd.core.GestoreMessaggi;
  69. import org.openspcoop2.pdd.core.PdDContext;
  70. import org.openspcoop2.pdd.core.autenticazione.GestoreAutenticazione;
  71. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.ConfigurazioneMultiDeliver;
  72. import org.openspcoop2.pdd.core.controllo_traffico.CostantiControlloTraffico;
  73. import org.openspcoop2.pdd.core.handlers.ExtendedTransactionInfo;
  74. import org.openspcoop2.pdd.core.handlers.HandlerException;
  75. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  76. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  77. import org.openspcoop2.pdd.core.token.InformazioniNegoziazioneToken;
  78. import org.openspcoop2.pdd.core.token.InformazioniToken;
  79. import org.openspcoop2.pdd.core.token.TokenUtilities;
  80. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  81. import org.openspcoop2.pdd.core.transazioni.DateUtility;
  82. import org.openspcoop2.pdd.core.transazioni.Transaction;
  83. import org.openspcoop2.pdd.logger.DiagnosticInputStream;
  84. import org.openspcoop2.pdd.logger.DumpUtility;
  85. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  86. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  87. import org.openspcoop2.pdd.logger.info.InfoEsitoTransazioneFormatUtils;
  88. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  89. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  90. import org.openspcoop2.protocol.sdk.Busta;
  91. import org.openspcoop2.protocol.sdk.Context;
  92. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  93. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  94. import org.openspcoop2.protocol.sdk.builder.IBustaBuilder;
  95. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  96. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  97. import org.openspcoop2.protocol.sdk.constants.TipoSerializzazione;
  98. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  99. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  100. import org.openspcoop2.protocol.sdk.tracciamento.Traccia;
  101. import org.openspcoop2.protocol.utils.EsitiProperties;
  102. import org.openspcoop2.utils.MapKey;
  103. import org.openspcoop2.utils.date.DateManager;
  104. import org.openspcoop2.utils.json.JSONUtils;
  105. import org.openspcoop2.utils.transport.TransportUtils;
  106. import org.slf4j.Logger;

  108. import com.fasterxml.jackson.databind.JsonNode;

  110. /**     
  111.  * TransazioneUtilities
  112.  *
  113.  * @author Poli Andrea (poli@link.it)
  114.  * @author $Author$
  115.  * @version $Rev$, $Date$
  116.  */
  117. public class TransazioneUtilities {

  119.     private Logger logger;
  120.     private boolean transazioniRegistrazioneTracceHeaderRawEnabled;
  121.     private boolean transazioniRegistrazioneTracceDigestEnabled;
  122.     private boolean transazioniRegistrazioneTracceProtocolPropertiesEnabled;
  123.     private boolean transazioniRegistrazioneTokenInformazioniNormalizzate;
  124.     private boolean transazioniRegistrazioneAttributiInformazioniNormalizzate;
  125.     private boolean transazioniRegistrazioneTempiElaborazione;
  126.     private boolean transazioniRegistrazioneRetrieveTokenSaveAsTokenInfo;
  127.     
  128.     public TransazioneUtilities(Logger log, OpenSPCoop2Properties openspcoopProperties,
  129.             boolean transazioniRegistrazioneTracceHeaderRawEnabled,
  130.             boolean transazioniRegistrazioneTracceDigestEnabled,
  131.             boolean transazioniRegistrazioneTracceProtocolPropertiesEnabled,
  132.             Transazioni configTransazioni){
  133.         this.logger = log;
  134.         this.transazioniRegistrazioneTracceHeaderRawEnabled = transazioniRegistrazioneTracceHeaderRawEnabled;
  135.         this.transazioniRegistrazioneTracceDigestEnabled = transazioniRegistrazioneTracceDigestEnabled;
  136.         this.transazioniRegistrazioneTracceProtocolPropertiesEnabled = transazioniRegistrazioneTracceProtocolPropertiesEnabled;
  137.         
  138.         this.transazioniRegistrazioneTempiElaborazione = configTransazioni!=null && StatoFunzionalita.ABILITATO.equals(configTransazioni.getTempiElaborazione());
  139.         this.transazioniRegistrazioneTokenInformazioniNormalizzate = configTransazioni!=null && StatoFunzionalita.ABILITATO.equals(configTransazioni.getToken());
  140.         this.transazioniRegistrazioneAttributiInformazioniNormalizzate = configTransazioni!=null && StatoFunzionalita.ABILITATO.equals(configTransazioni.getToken()) &&
  141.                 openspcoopProperties.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate(); // per adesso la configurazione avviene via govway.properties
  142.         this.transazioniRegistrazioneRetrieveTokenSaveAsTokenInfo = configTransazioni!=null && StatoFunzionalita.ABILITATO.equals(configTransazioni.getToken()) &&
  143.                 openspcoopProperties.isGestioneRetrieveTokenSaveAsTokenInfo(); // per adesso la configurazione avviene via govway.properties
  144.     }
  145.     
  146.     public static boolean isConsegnaMultipla(Context context) {
  147.         int connettoriMultipli = getNumeroConnettoriMultipli(context);
  148.         return ConfigurazioneTracciamentoUtils.isConsegnaMultipla(connettoriMultipli);
  149.     }
  150.     public static boolean isConsegnaMultipla(int connettoriMultipli) {
  151.         return ConfigurazioneTracciamentoUtils.isConsegnaMultipla(connettoriMultipli);
  152.     }
  153.     public static int getNumeroConnettoriMultipli(Context context) {
  154.         return ConfigurazioneTracciamentoUtils.getNumeroConnettoriMultipli(context);
  155.     }
  156.     public static String getConnettoriMultipli(Context context) {
  157.         return ConfigurazioneTracciamentoUtils.getConnettoriMultipli(context);
  158.     }
  159.     
  160.     public static MisurazioniTransazione fillMisurazioniTransazione(InformazioniTransazione info, FaseTracciamento fase,  Transaction transaction, EsitoTransazione esito, Transazione transactionDTOparam) {
  161.         MisurazioniTransazione misurazioniTransazione = new MisurazioniTransazione();
  162.         misurazioniTransazione.setTipoPdD(info.getTipoPorta());
  163.         misurazioniTransazione.setProtocollo( info.getProtocolFactory().getProtocol());
  164.         misurazioniTransazione.setEsitoTransazione(esito.getCode());
  165.         
  166.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  167.         
  168.         boolean fillTransaction = transactionDTOparam==null;
  169.         Transazione transactionDTO = fillTransaction ? new Transazione() : transactionDTOparam;
  170.         
  171.         if(fillTransaction)
  172.             TransazioneUtilities.setDataIngressoRichiesta(op2Properties, transactionDTO, info, transaction); 
  173.         misurazioniTransazione.setDataIngressoRichiesta(transactionDTO.getDataIngressoRichiesta());
  174.         
  175.         if(fillTransaction)
  176.             TransazioneUtilities.setDataUscitaRichiesta(transactionDTO, fase, transaction);
  177.         misurazioniTransazione.setDataUscitaRichiesta(transactionDTO.getDataUscitaRichiesta());
  178.         
  179.         if(fillTransaction)
  180.             TransazioneUtilities.setDataIngressoRisposta(op2Properties, transactionDTO, fase, transaction);
  181.         misurazioniTransazione.setDataIngressoRisposta(transactionDTO.getDataIngressoRisposta());
  182.         
  183.         if(fillTransaction)
  184.             TransazioneUtilities.setDataUscitaRisposta(op2Properties, transactionDTO, info, fase, transaction);
  185.         misurazioniTransazione.setDataUscitaRisposta(transactionDTO.getDataUscitaRisposta());
  186.         
  187.         if(fillTransaction)
  188.             TransazioneUtilities.setRichiestaIngressoBytes(transactionDTO, info, transaction, fase);
  189.         misurazioniTransazione.setRichiestaIngressoBytes(transactionDTO.getRichiestaIngressoBytes());
  190.         
  191.         if(fillTransaction)
  192.             TransazioneUtilities.setRichiestaUscitaBytes(transactionDTO, info, transaction, fase);
  193.         misurazioniTransazione.setRichiestaUscitaBytes(transactionDTO.getRichiestaUscitaBytes());
  194.         
  195.         if(fillTransaction)
  196.             TransazioneUtilities.setRispostaIngressoBytes(transactionDTO, info, transaction, fase);
  197.         misurazioniTransazione.setRispostaIngressoBytes(transactionDTO.getRispostaIngressoBytes());
  198.         
  199.         if(fillTransaction)
  200.             TransazioneUtilities.setRispostaUscitaBytes(transactionDTO, info, fase);
  201.         misurazioniTransazione.setRispostaUscitaBytes(transactionDTO.getRispostaUscitaBytes());
  202.         
  203.         return misurazioniTransazione;
  204.     }
  205.     
  206.     
  207.     public Transazione fillTransaction(InformazioniTransazione info, Transaction transaction, IDSoggetto idDominio,
  208.             TransazioniProcessTimes times, FaseTracciamento fase, 
  209.             EsitoTransazione esito, String esitoContext,
  210.             Transazione transazioneDaAggiornare ) throws HandlerException{

  212.         // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  213.         
  214.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  215.         
  216.         if(transaction==null) {
  217.             throw new HandlerException("Transaction is null");
  218.         }
  219.         if(info==null) {
  220.             throw new HandlerException("Informazioni sulla richiesta is null");
  221.         }
  222.         
  223.         Traccia tracciaRichiesta = transaction.getTracciaRichiesta();
  224.         Traccia tracciaRisposta = transaction.getTracciaRisposta();

  226.         boolean richiestaDuplicata = false;
  227.         ProfiloDiCollaborazione profiloCollaborazioneBustaTracciaRichiesta = null;
  228.         String profiloCollaborazioneValueBustaTracciaRichiesta = null;
  229.         if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null){
  230.             richiestaDuplicata = transaction.containsIdProtocolloDuplicato(tracciaRichiesta.getBusta().getID());
  231.             if(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()!=null){
  232.                 profiloCollaborazioneBustaTracciaRichiesta = tracciaRichiesta.getBusta().getProfiloDiCollaborazione();
  233.                 profiloCollaborazioneValueBustaTracciaRichiesta = tracciaRichiesta.getBusta().getProfiloDiCollaborazioneValue(); 
  234.             }
  235.         }
  236.         boolean rispostaDuplicata = false;
  237.         if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null){
  238.             rispostaDuplicata = transaction.containsIdProtocolloDuplicato(tracciaRisposta.getBusta().getID());
  239.         }

  241.         boolean schedulaNotificheDopoConsegnaSincrona = false;
  242.         boolean consegnaMultiplaProfiloSincrono = false;
  243.         MsgDiagnostico msgDiag = null;
  244.         String idTransazione = null;
  245.         String nomePorta = null;
  246.         
  247.         String identificativoSaveTransactionContext = null;
  248.         
  249.         long timeStart = -1;
  250.         try {

  252.             if(times!=null) {
  253.                 times.fillTransactionDetails = new ArrayList<>();
  254.                 timeStart = DateManager.getTimeMillis();
  255.             }
  256.             
  257.             IProtocolFactory<?> protocolFactory = info.getProtocolFactory();

  259.             IBustaBuilder<?> protocolBustaBuilder = protocolFactory.createBustaBuilder(info.getStato());

  261.             RequestInfo requestInfo = null;
  262.             if(info.getContext()!=null && info.getContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  263.                 requestInfo = (RequestInfo) info.getContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  264.             }

  266.             if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase) && 
  267.                     info.getContext()!=null && info.getContext().containsKey(CostantiPdD.SALVA_CONTESTO_IDENTIFICATIVO_MESSAGGIO_NOTIFICA)) {
  268.                 identificativoSaveTransactionContext = (String) info.getContext().getObject(CostantiPdD.SALVA_CONTESTO_IDENTIFICATIVO_MESSAGGIO_NOTIFICA);
  269.             }
  270.             
  271.             Transazione transactionDTO = transazioneDaAggiornare!=null ? transazioneDaAggiornare : new Transazione();

  273.             EsitiProperties esitiProperties = EsitiProperties.getInstance(this.logger, protocolFactory);
  274.                         
  275.             // ** Consegna Multipla **
  276.             // NOTA: l'esito deve essere compreso solo dopo aver capito se le notifiche devono essere consegna o meno poichè le notifiche stesse si basano sullo stato di come è terminata la transazione sincrona
  277.             int connettoriMultipli = getNumeroConnettoriMultipli(info.getContext());
  278.             boolean consegnaMultipla = isConsegnaMultipla(connettoriMultipli);
  279.             
  280.             ConfigurazioneMultiDeliver configurazioneConsegnaMultiplaProfiloSincrono = null;
  281.             if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase) && consegnaMultipla) {
  282.                 Object oConnettoreSync = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA );
  283.                 if (oConnettoreSync instanceof Boolean){
  284.                     consegnaMultiplaProfiloSincrono = (Boolean) oConnettoreSync;
  285.                 }
  286.                 else if (oConnettoreSync instanceof String){
  287.                     consegnaMultiplaProfiloSincrono = Boolean.valueOf( (String) oConnettoreSync );
  288.                 }
  289.                 
  290.                 if(consegnaMultiplaProfiloSincrono) {
  291.                     Object oConnettoreSyncConfig = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA_CONFIGURAZIONE );
  292.                     if (oConnettoreSyncConfig instanceof ConfigurazioneMultiDeliver){
  293.                         configurazioneConsegnaMultiplaProfiloSincrono = (ConfigurazioneMultiDeliver) oConnettoreSyncConfig;
  294.                     }
  295.                 }
  296.             }

  298.             if(consegnaMultiplaProfiloSincrono) {
  299.                 if(transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getProtocolContext()!=null){
  300.                     nomePorta = transaction.getRequestInfo().getProtocolContext().getInterfaceName();
  301.                 }
  302.                 msgDiag = MsgDiagnostico.newInstance(info.getTipoPorta(),idDominio, info.getIdModulo(), nomePorta, requestInfo, info.getStato());
  303.             }
  304.             if(consegnaMultiplaProfiloSincrono && configurazioneConsegnaMultiplaProfiloSincrono!=null &&
  305.                     esito!=null && esito.getCode()!=null) {
  306.                 if(configurazioneConsegnaMultiplaProfiloSincrono.isNotificheByEsito()) {
  307.                     int esitoSincrono = esito.getCode();
  308.                     if(isEsito(esitiProperties.getEsitiCodeOk_senzaFaultApplicativo(), esitoSincrono)) {
  309.                         schedulaNotificheDopoConsegnaSincrona = configurazioneConsegnaMultiplaProfiloSincrono.isNotificheByEsito_ok();
  310.                     }
  311.                     else if(isEsito(esitiProperties.getEsitiCodeFaultApplicativo(), esitoSincrono)) {
  312.                         schedulaNotificheDopoConsegnaSincrona = configurazioneConsegnaMultiplaProfiloSincrono.isNotificheByEsito_fault();
  313.                     }
  314.                     else if(isEsito(esitiProperties.getEsitiCodeErroriConsegna(), esitoSincrono)) {
  315.                         schedulaNotificheDopoConsegnaSincrona = configurazioneConsegnaMultiplaProfiloSincrono.isNotificheByEsito_erroriConsegna();
  316.                     }
  317.                     // le richieste scartate non arrivano alla gestione della consegna in smistatore e quindi non potranno nemmeno essere notifiate
  318.                     /**else if(isEsito(esitiProperties.getEsitiCodeRichiestaScartate(), esitoSincrono)) {
  319.                     //  schedulaNotificheDopoConsegnaSincrona = configurazione_consegnaMultipla_profiloSincrono.isNotificheByEsito_richiesteScartate();
  320.                     //}*/
  321.                     else {
  322.                         schedulaNotificheDopoConsegnaSincrona = configurazioneConsegnaMultiplaProfiloSincrono.isNotificheByEsito_erroriProcessamento();
  323.                     }
  324.                 }
  325.                 else {
  326.                     schedulaNotificheDopoConsegnaSincrona = true;
  327.                 }
  328.             }
  329.             if(schedulaNotificheDopoConsegnaSincrona && info.getContext()!=null) {
  330.                 Exception e = null;
  331.                 Object oException = info.getContext().getObject(CostantiPdD.CONNETTORE_MULTIPLO_CONSEGNA_NOTIFICA_DISABILITATA );
  332.                 if (oException instanceof Exception){
  333.                     e = (Exception) oException;
  334.                 }
  335.                 if(e!=null) {
  336.                     // log effettuato in consegna contenuti
  337.                     schedulaNotificheDopoConsegnaSincrona = false;
  338.                 }
  339.             }
  340.             

  342.             if(times!=null) {
  343.                 long timeEnd =  DateManager.getTimeMillis();
  344.                 long timeProcess = timeEnd-timeStart;
  345.                 times.fillTransactionDetails.add("connettoreMultipli:"+timeProcess);
  346.                 
  347.                 timeStart = DateManager.getTimeMillis();
  348.             }
  349.             
  350.             
  351.             // ** Identificativo di transazione **
  352.             if (info.getContext().getObject(Costanti.ID_TRANSAZIONE)!=null){
  353.                 idTransazione = ((String)info.getContext().getObject(Costanti.ID_TRANSAZIONE));
  354.                 transactionDTO.setIdTransazione(idTransazione);
  355.             }else
  356.                 throw new HandlerException("ID Transazione Assente");


  359.             // ** Esito Transazione **
  360.             if (esito!=null){
  361.                 if(consegnaMultipla) {
  362.                     if(consegnaMultiplaProfiloSincrono) {
  363.                         if(schedulaNotificheDopoConsegnaSincrona) {
  364.                             transactionDTO.setEsito(esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA));
  365.                             if(esito.getCode()!=null){
  366.                                 transactionDTO.setEsitoSincrono(esito.getCode());
  367.                             }
  368.                             transactionDTO.setConsegneMultipleInCorso(connettoriMultipli);
  369.                         }
  370.                         else {
  371.                             if(esito.getCode()!=null){
  372.                                 transactionDTO.setEsito(esito.getCode());
  373.                             }
  374.                         }
  375.                     }
  376.                     else {
  377.                         transactionDTO.setEsito(esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA));
  378.                         transactionDTO.setConsegneMultipleInCorso(connettoriMultipli);  
  379.                     }
  380.                 }
  381.                 else {
  382.                     if(esito.getCode()!=null){
  383.                         transactionDTO.setEsito(esito.getCode());
  384.                     }
  385.                 }
  386.                 transactionDTO.setEsitoContesto(esito.getContextType());
  387.             }
  388.             else {
  389.                 transactionDTO.setEsitoContesto(esitoContext);
  390.             }
  391.             // aggiungo fase all'esito
  392.             transactionDTO.setEsitoContesto(EsitoUtils.buildEsitoContext(transactionDTO.getEsitoContesto(), fase));
  393.                         
  394.             
  395.             // ** Codice Risposta Uscita **
  396.             if(info.getReturnCode()>0)
  397.                 transactionDTO.setCodiceRispostaUscita(info.getReturnCode()+"");
  398.             
  399.             // ** eventi di gestione **
  400.             if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase)){
  401.                 setEventi(transactionDTO, transaction,
  402.                         op2Properties,
  403.                         requestInfo,
  404.                         idDominio, info, idTransazione,
  405.                         times, timeStart, fase);
  406.             }
  407.             if(times!=null) {
  408.                 timeStart = DateManager.getTimeMillis();
  409.             }
  410.             
  411.             // ** data_uscita_risposta **
  412.             TransazioneUtilities.setDataUscitaRisposta(op2Properties, transactionDTO, info, fase, transaction);
  413.                 
  414.             // ** data_uscita_risposta_stream **
  415.             TransazioneUtilities.setDataUscitaRispostaStream(op2Properties, transactionDTO, info, fase);
  416.             
  417.             // ** dimensione_ingresso_risposta **
  418.             TransazioneUtilities.setRispostaIngressoBytes(transactionDTO, info, transaction, fase);
  419.     
  420.             // ** dimensione_uscita_risposta **
  421.             TransazioneUtilities.setRispostaUscitaBytes(transactionDTO, info, fase);
  422.             
  423.             // ** FAULT **
  424.             if(FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  425.                 transactionDTO.setFaultIntegrazione(transaction.getFaultIntegrazione());
  426.                 transactionDTO.setFormatoFaultIntegrazione(transaction.getFormatoFaultIntegrazione());
  427.                 transactionDTO.setFaultCooperazione(transaction.getFaultCooperazione());
  428.                 transactionDTO.setFormatoFaultCooperazione(transaction.getFormatoFaultCooperazione());
  429.             }
  430. /**         boolean readFault = false;
  431. //          if(TipoPdD.DELEGATA.equals(context.getTipoPorta())){
  432. //              if(transactionDTO.getFaultIntegrazione()==null){
  433. //                  readFault = true;
  434. //              }
  435. //          }
  436. //          else{
  437. //              if(transactionDTO.getFaultCooperazione()==null){
  438. //                  readFault = true;
  439. //              }
  440. //          }*/
  441.             // Il fault potrebbe essere cambiato durante la fase di gestione dalla consegna della risposta
  442.             boolean readFault = true;
  443.             if(readFault && FaseTracciamento.POST_OUT_RESPONSE.equals(fase)){
  444.                 setFaultInfo(transactionDTO, 
  445.                         op2Properties, 
  446.                         info);
  447.             }
  448.             
  449.             // ** diagnostici **
  450.             if(esito!=null) {
  451.                 String errore = InfoEsitoTransazioneFormatUtils.getMessaggioDiagnosticoErroreRilevante(this.logger, transactionDTO.getEsito(), protocolFactory, transaction.getMsgDiagnostici(), true);         
  452.                 String warning = InfoEsitoTransazioneFormatUtils.getMessaggioDiagnosticoWarning(this.logger, transactionDTO.getEsito(), protocolFactory, transaction.getMsgDiagnostici());          
  453.                 transactionDTO.setErrorLog(errore);
  454.                 transactionDTO.setWarningLog(warning);
  455.             }

  457.             
  458.             // ***** NOTA: tutte le informazioni sopra devono essere "gestite in UPDATE" nel metodo TracciamentoManager.registraTransazione
  459.             
  460.             /*** ESCO SE SONO IN FASE POST OUT DI AGGIORNAMENTO DEI DATI */
  461.             
  462.             if(transazioneDaAggiornare!=null) {
  463.                 return transactionDTO; // nell'oggetto ci sono già tutti i dati eccetto l'esito corretto
  464.             }
  465.             
  466.             
  467.             
  468.             
  469.             

  471.             // ** stato **
  472.             // Stato di una transazione (marca la transazione con uno stato tramite la configurazione plugin)
  473.             if(transaction.getStato()!=null) {
  474.                 transactionDTO.setStato(transaction.getStato());    
  475.             }

  477.             // ** Ruolo transazione **
  478.             // invocazioneOneway (1)
  479.             // invocazioneSincrona (2)
  480.             // invocazioneAsincronaSimmetrica (3)
  481.             // rispostaAsincronaSimmetrica (4)
  482.             // invocazioneAsincronaAsimmetrica (5)
  483.             // richiestaStatoAsincronaAsimmetrica (6)
  484.             // integrationManager (7)
  485.             /**System.out.println("SCENARIO DI COOPERAZIONE ["+transaction.getScenarioCooperazione()+"]");*/
  486.             RuoloTransazione ruolo = RuoloTransazione.getEnumConstantFromOpenSPCoopValue(transaction.getScenarioCooperazione());
  487.             if(ruolo!=null)
  488.                 transactionDTO.setRuoloTransazione(ruolo.getValoreAsInt());
  489.             else
  490.                 transactionDTO.setRuoloTransazione(-1);


  493.             // ** protocollo **
  494.             transactionDTO.setProtocollo(info.getProtocolFactory().getProtocol());

  496.             
  497.             // ** header HTTP **
  498.             if(transaction.getRequestInfo()!=null && 
  499.                     transaction.getRequestInfo().getProtocolContext()!=null &&
  500.                     transaction.getRequestInfo().getProtocolContext().getRequestType()!=null) {
  501.                 transactionDTO.setTipoRichiesta(transaction.getRequestInfo().getProtocolContext().getRequestType());
  502.             }
  503.             // ** Codice Risposta Ingresso **
  504.             transactionDTO.setCodiceRispostaIngresso(transaction.getCodiceTrasportoRichiesta());
  505.             // ** Codice Risposta Uscita **
  506.             // Gestite prima per la doppia fase, come per l'esito

  508.             // ** Tempi di latenza **

  510.             // Se data_accettazione_richiesta è null viene impostata a CURRENT_TIMESTAMP
  511.             TransazioneUtilities.setDataAccettazioneRichiesta(transactionDTO, info, transaction);
  512.             
  513.             // Se data_ingresso_richiesta è null viene impostata a CURRENT_TIMESTAMP
  514.             TransazioneUtilities.setDataIngressoRichiesta(op2Properties, transactionDTO, info, transaction); 
  515.             
  516.             // data_ingresso_richiesta_stream
  517.             TransazioneUtilities.setDataIngressoRichiestaStream(transactionDTO, info);
  518.             
  519.             // data_uscita_richiesta si imposta se e' diversa da null
  520.             TransazioneUtilities.setDataUscitaRichiesta(transactionDTO, fase, transaction);

  522.             // data_accettazione_risposta
  523.             TransazioneUtilities.setDataAccettazioneRisposta(transactionDTO, fase, transaction);
  524.                 
  525.             // data_ingresso_risposta
  526.             TransazioneUtilities.setDataIngressoRisposta(op2Properties, transactionDTO, fase, transaction);
  527.                 
  528.             // data_ingresso_risposta_stream
  529.             TransazioneUtilities.setDataIngressoRispostaStream(transactionDTO, info, fase);
  530.             
  531.             // data_uscita_risposta
  532.             // data_uscita_risposta_stream
  533.             // Gestite prima per la doppia fase, come per l'esito


  536.             // ** Dimensione messaggi gestiti **
  537.             // Se le dimensioni (BIGINT) sono null occorre impostarle a zero

  539.             // dimensione_ingresso_richiesta
  540.             TransazioneUtilities.setRichiestaIngressoBytes(transactionDTO, info, transaction, fase);

  542.             // dimensione_uscita_richiesta
  543.             TransazioneUtilities.setRichiestaUscitaBytes(transactionDTO, info, transaction, fase);

  545.             // dimensione_ingresso_risposta
  546.             // dimensione_uscita_risposta
  547.             // Gestite prima per la doppia fase, come per l'esito: faccio una ulteriore verifica se siamo nell'ultima fase e sono null
  548.             if(transactionDTO.getRispostaIngressoBytes()==null &&
  549.                     FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  550.                 transactionDTO.setRispostaIngressoBytes(readDimensioneFromDumpBinario(TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO, transaction));
  551.             }
  552.             if(transactionDTO.getRispostaUscitaBytes()==null &&
  553.                     FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  554.                 transactionDTO.setRispostaUscitaBytes(readDimensioneFromDumpBinario(TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO, transaction));
  555.             }


  558.             // ** Dati Pdd **
  559.             transactionDTO.setPddCodice(idDominio.getCodicePorta());
  560.             transactionDTO.setPddTipoSoggetto(idDominio.getTipo());
  561.             transactionDTO.setPddNomeSoggetto(idDominio.getNome());
  562.             if(info.getTipoPorta()!=null){
  563.                 transactionDTO.setPddRuolo(PddRuolo.toEnumConstant(info.getTipoPorta().getTipo()));
  564.             }

  566.             
  567.             if(times!=null) {
  568.                 long timeEnd =  DateManager.getTimeMillis();
  569.                 long timeProcess = timeEnd-timeStart;
  570.                 times.fillTransactionDetails.add("baseContext:"+timeProcess);
  571.                 
  572.                 timeStart = DateManager.getTimeMillis();
  573.             }
  574.             

  576.             // ** FAULT **
  577.             // Gestite prima per la doppia fase, come per l'esito
  578.             
  579.             
  580.             if(times!=null) {
  581.                 long timeEnd =  DateManager.getTimeMillis();
  582.                 long timeProcess = timeEnd-timeStart;
  583.                 times.fillTransactionDetails.add("fault:"+timeProcess);
  584.                 
  585.                 timeStart = DateManager.getTimeMillis();
  586.             }


  589.             // ** Soggetto Fruitore **
  590.             if (info.getProtocollo()!=null && info.getProtocollo().getFruitore()!=null) {
  591.                 transactionDTO.setTipoSoggettoFruitore(info.getProtocollo().getFruitore().getTipo());
  592.                 transactionDTO.setNomeSoggettoFruitore(info.getProtocollo().getFruitore().getNome());
  593.                 transactionDTO.setIdportaSoggettoFruitore(info.getProtocollo().getFruitore().getCodicePorta());
  594.                 transactionDTO.setIndirizzoSoggettoFruitore(info.getProtocollo().getIndirizzoFruitore());
  595.             }
  596.             else if(transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getFruitore()!=null) {
  597.                 transactionDTO.setTipoSoggettoFruitore(transaction.getRequestInfo().getFruitore().getTipo());
  598.                 transactionDTO.setNomeSoggettoFruitore(transaction.getRequestInfo().getFruitore().getNome());
  599.                 transactionDTO.setIdportaSoggettoFruitore(transaction.getRequestInfo().getFruitore().getCodicePorta());
  600.             }


  603.             // ** Soggetto Erogatore **
  604.             if (info.getProtocollo()!=null && info.getProtocollo().getErogatore()!=null) {
  605.                 transactionDTO.setTipoSoggettoErogatore(info.getProtocollo().getErogatore().getTipo());
  606.                 transactionDTO.setNomeSoggettoErogatore(info.getProtocollo().getErogatore().getNome());
  607.                 transactionDTO.setIdportaSoggettoErogatore(info.getProtocollo().getErogatore().getCodicePorta());
  608.                 transactionDTO.setIndirizzoSoggettoErogatore(info.getProtocollo().getIndirizzoErogatore());
  609.             }
  610.             else if(transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null &&
  611.                     transaction.getRequestInfo().getIdServizio().getSoggettoErogatore()!=null) {
  612.                 transactionDTO.setTipoSoggettoErogatore(transaction.getRequestInfo().getIdServizio().getSoggettoErogatore().getTipo());
  613.                 transactionDTO.setNomeSoggettoErogatore(transaction.getRequestInfo().getIdServizio().getSoggettoErogatore().getNome());
  614.                 transactionDTO.setIdportaSoggettoErogatore(transaction.getRequestInfo().getIdServizio().getSoggettoErogatore().getCodicePorta());
  615.             }


  618.             // ** Identificativi Messaggi **
  619.             if (info.getProtocollo()!=null) {

  621.                 // Richiesta
  622.                 String idMessaggioRichiesta = info.getProtocollo().getIdRichiesta();
  623.                 if(
  624.                         //TipoPdD.APPLICATIVA.equals(context.getTipoPorta()) &&
  625.                         CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol()) &&
  626.                         tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getID()!=null &&
  627.                         !tracciaRichiesta.getBusta().getID().equals(idMessaggioRichiesta)) {
  628.                     // modificato durante la gestione della validazione semantica
  629.                     idMessaggioRichiesta = tracciaRichiesta.getBusta().getID();
  630.                 }
  631.                 Timestamp dateInternaIdProtocolloRichiesta = null;
  632.                 if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory) &&
  633.                     idMessaggioRichiesta!=null){
  634.                     dateInternaIdProtocolloRichiesta = DateUtility.getTimestampIntoIdProtocollo(this.logger,protocolBustaBuilder,idMessaggioRichiesta);
  635.                 }

  637.                 // Risposta
  638.                 String idMessaggioRisposta = null;
  639.                 Timestamp dateInternaIdProtocolloRisposta = null;
  640.                 // Nel contesto l'id di riposta puo' essere null o un valore generato per la confermaPresa in carico.
  641.                 // Se e' presenta una busta di risposta nella transazione deve pero' finire l'id di protocollo della busta.
  642.                 if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null && tracciaRisposta.getBusta().getID()!=null){
  643.                     idMessaggioRisposta = tracciaRisposta.getBusta().getID();
  644.                     if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  645.                         dateInternaIdProtocolloRisposta = DateUtility.getTimestampIntoIdProtocollo(this.logger,protocolBustaBuilder,idMessaggioRisposta);
  646.                     }
  647.                 }
  648.                 else if(info.getProtocollo().getIdRisposta()!=null){
  649.                     idMessaggioRisposta = info.getProtocollo().getIdRisposta();
  650.                     if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  651.                         dateInternaIdProtocolloRisposta =  DateUtility.getTimestampIntoIdProtocollo(this.logger,protocolBustaBuilder,idMessaggioRisposta);
  652.                     }
  653.                 }

  655.                 // Set
  656.                 transactionDTO.setIdMessaggioRichiesta(idMessaggioRichiesta);
  657.                 transactionDTO.setIdMessaggioRisposta(idMessaggioRisposta);
  658.                 if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  659.                     transactionDTO.setDataIdMsgRichiesta(dateInternaIdProtocolloRichiesta);
  660.                     transactionDTO.setDataIdMsgRisposta(dateInternaIdProtocolloRisposta);
  661.                 }

  663.             }


  666.             // ** altre informazioni **
  667.             if (info.getProtocollo()!=null && info.getProtocollo().getProfiloCollaborazione()!=null) {
  668.                 transactionDTO.setProfiloCollaborazioneOp2(info.getProtocollo().getProfiloCollaborazione().getEngineValue());       
  669.             }
  670.             else if(profiloCollaborazioneBustaTracciaRichiesta!=null){
  671.                 transactionDTO.setProfiloCollaborazioneOp2(profiloCollaborazioneBustaTracciaRichiesta.getEngineValue());
  672.             }
  673.             if (info.getProtocollo()!=null && info.getProtocollo().getProfiloCollaborazioneValue()!=null) {
  674.                 transactionDTO.setProfiloCollaborazioneProt(info.getProtocollo().getProfiloCollaborazioneValue());
  675.             }
  676.             else if(profiloCollaborazioneValueBustaTracciaRichiesta!=null){
  677.                 transactionDTO.setProfiloCollaborazioneProt(profiloCollaborazioneValueBustaTracciaRichiesta);
  678.             }
  679.             IDAccordo idAccordo = null;
  680.             if (info.getProtocollo()!=null){

  682.                 transactionDTO.setIdCollaborazione(info.getProtocollo().getCollaborazione());

  684.                 idAccordo = info.getProtocollo().getIdAccordo();
  685.                 if(idAccordo!=null){
  686.                     transactionDTO.setUriAccordoServizio(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  687.                 }

  689.                 transactionDTO.setTipoServizio(info.getProtocollo().getTipoServizio());
  690.                 transactionDTO.setNomeServizio(info.getProtocollo().getServizio());
  691.                 if(info.getProtocollo().getVersioneServizio()!=null && info.getProtocollo().getVersioneServizio().intValue()>0) {
  692.                     transactionDTO.setVersioneServizio(info.getProtocollo().getVersioneServizio());
  693.                 }
  694.                 transactionDTO.setAzione(info.getProtocollo().getAzione());
  695.             }
  696.             if(transactionDTO.getTipoServizio()==null &&
  697.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null) 
  698.                 ){
  699.                 transactionDTO.setTipoServizio(transaction.getRequestInfo().getIdServizio().getTipo());
  700.             }
  701.             if(transactionDTO.getNomeServizio()==null &&
  702.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null) 
  703.                 ){
  704.                 transactionDTO.setNomeServizio(transaction.getRequestInfo().getIdServizio().getNome());
  705.             }
  706.             if(
  707.                 (info.getProtocollo()==null || info.getProtocollo().getVersioneServizio()==null || info.getProtocollo().getVersioneServizio().intValue()<=0) 
  708.                 &&
  709.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null) 
  710.                 ){
  711.                 transactionDTO.setVersioneServizio(transaction.getRequestInfo().getIdServizio().getVersione());
  712.             }
  713.             if(transactionDTO.getAzione()==null &&
  714.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null) 
  715.                 ){
  716.                 transactionDTO.setAzione(transaction.getRequestInfo().getIdServizio().getAzione());
  717.             }
  718.             
  719.             if(times!=null) {
  720.                 long timeEnd =  DateManager.getTimeMillis();
  721.                 long timeProcess = timeEnd-timeStart;
  722.                 times.fillTransactionDetails.add("identificativi:"+timeProcess);
  723.                 
  724.                 timeStart = DateManager.getTimeMillis();
  725.             }
  726.             
  727.             RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(info.getStato());
  728.             if(idAccordo==null &&
  729.                 (transactionDTO.getNomeServizio()!=null && transactionDTO.getTipoServizio()!=null && 
  730.                 transactionDTO.getNomeSoggettoErogatore()!=null && transactionDTO.getTipoSoggettoErogatore()!=null) 
  731.                 ) {
  732.                 idAccordo = getIdAccordo(transactionDTO, registroServiziManager, requestInfo);
  733.             }
  734.             
  735.             if(times!=null) {
  736.                 long timeEnd =  DateManager.getTimeMillis();
  737.                 long timeProcess = timeEnd-timeStart;
  738.                 times.fillTransactionDetails.add("id-api:"+timeProcess);
  739.                 
  740.                 timeStart = DateManager.getTimeMillis();
  741.             }
  742.             
  743.             if(idAccordo!=null) {
  744.                 setAccordoInfo(idAccordo, transactionDTO, 
  745.                         op2Properties, registroServiziManager, requestInfo,
  746.                         idDominio, info, idTransazione,
  747.                         times, timeStart, fase);
  748.                 if(times!=null) {
  749.                     timeStart = DateManager.getTimeMillis();
  750.                 }
  751.             }


  754.             // ** Identificativo asincrono se utilizzato come riferimento messaggio nella richiesta (2 fase asincrona) **
  755.                 
  756.             if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null &&
  757.                     (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) ) ){
  758.                 Busta busta = tracciaRichiesta.getBusta();
  759.                 if(busta.getRiferimentoMessaggio()!=null){
  760.                     // Seconda fase dei profili asincroni
  761.                     transactionDTO.setIdAsincrono(busta.getRiferimentoMessaggio());
  762.                 }
  763.                 else{
  764.                     transactionDTO.setIdAsincrono(busta.getCollaborazione());
  765.                 }
  766.             }
  767.             if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null &&
  768.                     ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) ){
  769.                 Busta busta = tracciaRichiesta.getBusta();
  770.                 if(busta!=null){
  771.                     transactionDTO.setTipoServizioCorrelato(busta.getTipoServizioCorrelato());
  772.                     transactionDTO.setNomeServizioCorrelato(busta.getServizioCorrelato());
  773.                 }
  774.             }
  775.             else if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null &&
  776.                     ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(tracciaRisposta.getBusta().getProfiloDiCollaborazione()) ){
  777.                 Busta busta = tracciaRisposta.getBusta();
  778.                 if(busta!=null){
  779.                     transactionDTO.setTipoServizioCorrelato(busta.getTipoServizioCorrelato());
  780.                     transactionDTO.setNomeServizioCorrelato(busta.getServizioCorrelato());
  781.                 }
  782.             }
  783.             
  784.             if(transactionDTO.getIdCollaborazione()==null) {
  785.                 if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getCollaborazione()!=null) {
  786.                     transactionDTO.setIdCollaborazione(tracciaRichiesta.getBusta().getCollaborazione());
  787.                 }
  788.                 else if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null && tracciaRisposta.getBusta().getCollaborazione()!=null) {
  789.                     transactionDTO.setIdCollaborazione(tracciaRisposta.getBusta().getCollaborazione());
  790.                 }
  791.             }
  792.             
  793.             boolean asincrono = tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null &&
  794.                     (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) );
  795.             if(!asincrono) {
  796.                 if(transactionDTO.getIdAsincrono()==null &&
  797.                     (tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getRiferimentoMessaggio()!=null) 
  798.                     ){
  799.                     transactionDTO.setIdAsincrono(tracciaRichiesta.getBusta().getRiferimentoMessaggio());
  800.                 }
  801.                 if(transactionDTO.getIdAsincrono()==null &&
  802.                     (info.getProtocollo()!=null)
  803.                     ){
  804.                     transactionDTO.setIdAsincrono(info.getProtocollo().getRiferimentoAsincrono());
  805.                 }
  806.             }
  807.             
  808.             if(times!=null) {
  809.                 long timeEnd =  DateManager.getTimeMillis();
  810.                 long timeProcess = timeEnd-timeStart;
  811.                 times.fillTransactionDetails.add("async:"+timeProcess);
  812.                 
  813.                 timeStart = DateManager.getTimeMillis();
  814.             }

  816.             // ** info protocollo **
  817.             if(tracciaRichiesta!=null){
  818.                 if(this.transazioniRegistrazioneTracceHeaderRawEnabled){
  819.                     if(tracciaRichiesta.getBustaAsString()!=null){
  820.                         transactionDTO.setHeaderProtocolloRichiesta(tracciaRichiesta.getBustaAsString());
  821.                     }
  822.                     else if(tracciaRichiesta.getBustaAsByteArray()!=null){
  823.                         transactionDTO.setHeaderProtocolloRichiesta(new String(tracciaRichiesta.getBustaAsByteArray()));
  824.                     }
  825.                     else if(tracciaRichiesta.getBustaAsRawContent()!=null){
  826.                         setHeaderProtocolloRichiesta(transactionDTO, tracciaRichiesta);
  827.                     }
  828.                 }
  829.                 if(tracciaRichiesta.getBusta()!=null){
  830.                     if(this.transazioniRegistrazioneTracceDigestEnabled){
  831.                         transactionDTO.setDigestRichiesta(tracciaRichiesta.getBusta().getDigest());
  832.                     }
  833.                     if(this.transazioniRegistrazioneTracceProtocolPropertiesEnabled &&
  834.                         tracciaRichiesta.getBusta().sizeProperties()>0){
  835.                         Map<String, List<String>> propertiesBusta = new HashMap<>();
  836.                         String [] pNames = tracciaRichiesta.getBusta().getPropertiesNames();
  837.                         if(pNames!=null){
  838.                             for (int i = 0; i < pNames.length; i++) {
  839.                                 String key = pNames[i];
  840.                                 String value = tracciaRichiesta.getBusta().getProperty(key);
  841.                                 if(key!=null && value!=null){
  842.                                     TransportUtils.put(propertiesBusta, key, value, false);
  843.                                 }
  844.                             }
  845.                         }
  846.                         PropertiesSerializator ps = new PropertiesSerializator(propertiesBusta);
  847.                         setProtocolloExtInfoRichiesta(transactionDTO, ps);
  848.                     }
  849.                 }
  850.                 if(times!=null) {
  851.                     long timeEnd =  DateManager.getTimeMillis();
  852.                     long timeProcess = timeEnd-timeStart;
  853.                     times.fillTransactionDetails.add("traccia-richiesta:"+timeProcess);
  854.                     
  855.                     timeStart = DateManager.getTimeMillis();
  856.                 }
  857.             }
  858.             if(tracciaRisposta!=null){              
  859.                 if(this.transazioniRegistrazioneTracceHeaderRawEnabled){
  860.                     if(tracciaRisposta.getBustaAsString()!=null){
  861.                         transactionDTO.setHeaderProtocolloRisposta(tracciaRisposta.getBustaAsString());
  862.                     }
  863.                     else if(tracciaRisposta.getBustaAsByteArray()!=null){
  864.                         transactionDTO.setHeaderProtocolloRisposta(new String(tracciaRisposta.getBustaAsByteArray()));
  865.                     }
  866.                     else if(tracciaRisposta.getBustaAsRawContent()!=null){
  867.                         setHeaderProtocolloRisposta(transactionDTO, tracciaRisposta);
  868.                     }
  869.                 }
  870.                 if(tracciaRisposta.getBusta()!=null){
  871.                     if(this.transazioniRegistrazioneTracceDigestEnabled){
  872.                         transactionDTO.setDigestRisposta(tracciaRisposta.getBusta().getDigest());
  873.                     }
  874.                     if(this.transazioniRegistrazioneTracceProtocolPropertiesEnabled &&
  875.                         tracciaRisposta.getBusta().sizeProperties()>0){
  876.                         Map<String, List<String>> propertiesBusta = new HashMap<>();
  877.                         String [] pNames = tracciaRisposta.getBusta().getPropertiesNames();
  878.                         if(pNames!=null){
  879.                             for (int i = 0; i < pNames.length; i++) {
  880.                                 String key = pNames[i];
  881.                                 String value = tracciaRisposta.getBusta().getProperty(key);
  882.                                 if(key!=null && value!=null){
  883.                                     TransportUtils.put(propertiesBusta, key, value, false);
  884.                                 }
  885.                             }
  886.                         }
  887.                         PropertiesSerializator ps = new PropertiesSerializator(propertiesBusta);
  888.                         setProtocolloExtInfoRisposta(transactionDTO, ps);
  889.                     }
  890.                 }
  891.                 if(times!=null) {
  892.                     long timeEnd =  DateManager.getTimeMillis();
  893.                     long timeProcess = timeEnd-timeStart;
  894.                     times.fillTransactionDetails.add("traccia-risposta:"+timeProcess);
  895.                     
  896.                     timeStart = DateManager.getTimeMillis();
  897.                 }
  898.             }
  899.             
  900.             // ** diagnostici **
  901.             // Gestite prima per la doppia fase, come per l'esito
  902.             
  903.             // ** informazioni di integrazione **
  904.             if(info.getIntegrazione()!=null){
  905.                 transactionDTO.setIdCorrelazioneApplicativa(info.getIntegrazione().getIdCorrelazioneApplicativa());
  906.                 transactionDTO.setIdCorrelazioneApplicativaRisposta(transaction.getCorrelazioneApplicativaRisposta());
  907.                 transactionDTO.setServizioApplicativoFruitore(info.getIntegrazione().getServizioApplicativoFruitore());
  908.                 if(info!=null && info.getContext()!=null &&
  909.                         info.getContext().containsKey(CostantiPdD.CONNETTORE_MULTIPLO_SELEZIONATO)) {
  910.                     Object o = info.getContext().getObject(CostantiPdD.CONNETTORE_MULTIPLO_SELEZIONATO);
  911.                     if(o instanceof String) {
  912.                         String sa = (String) o;
  913.                         if(sa!=null && !"".equals(sa)) {
  914.                             transactionDTO.setServizioApplicativoErogatore(sa);
  915.                         }
  916.                     }
  917.                 }
  918.                 if(transactionDTO.getServizioApplicativoErogatore()==null) {
  919.                     // in caso di porta applicativa si salva l'elenco dei servizi applicativi erogatori
  920.                     if(info.getIntegrazione().sizeServiziApplicativiErogatori()>0){
  921.                         StringBuilder saErogatori = new StringBuilder();
  922.                         for (int i=0; i<info.getIntegrazione().sizeServiziApplicativiErogatori(); i++) {
  923.                             if (i>0){
  924.                                 saErogatori.append(",");
  925.                             }
  926.                             saErogatori.append( info.getIntegrazione().getServizioApplicativoErogatore(i) );
  927.                         }
  928.                         transactionDTO.setServizioApplicativoErogatore(saErogatori.toString().length()>2000 ? saErogatori.toString().substring(0, 1999) : saErogatori.toString());
  929.                     }
  930.                     else if(transaction.getServiziApplicativiErogatore()!=null && !transaction.getServiziApplicativiErogatore().isEmpty()){
  931.                         StringBuilder saErogatori = new StringBuilder();
  932.                         for (int i=0; i<transaction.getServiziApplicativiErogatore().size(); i++) {
  933.                             if (i>0){
  934.                                 saErogatori.append(",");
  935.                             }
  936.                             saErogatori.append( transaction.getServiziApplicativiErogatore().get(i) );
  937.                         }
  938.                         transactionDTO.setServizioApplicativoErogatore(saErogatori.toString().length()>2000 ? saErogatori.toString().substring(0, 1999) : saErogatori.toString());
  939.                     }
  940.                 }
  941.             }
  942.             
  943.             if(info.getContext()!=null){
  944.                 Object operazioneIM = info.getContext().getObject(CostantiPdD.TIPO_OPERAZIONE_IM);
  945.                 if(operazioneIM instanceof String){
  946.                     String op = (String) operazioneIM;
  947.                     transactionDTO.setOperazioneIm(op);
  948.                 }
  949.             }
  950.             
  951.             if(transactionDTO.getServizioApplicativoFruitore()==null &&
  952.                 // provo a vedere se fosse nella traccia di richiesta
  953.                 (tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getServizioApplicativoFruitore()!=null)
  954.                 ){
  955.                 transactionDTO.setServizioApplicativoFruitore(tracciaRichiesta.getBusta().getServizioApplicativoFruitore());
  956.             }
  957.             if(transactionDTO.getServizioApplicativoFruitore()==null &&
  958.                 // provo a vedere se fosse nella traccia di risposta
  959.                 (tracciaRisposta!=null && tracciaRisposta.getBusta()!=null && tracciaRisposta.getBusta().getServizioApplicativoFruitore()!=null)
  960.                 ){
  961.                 transactionDTO.setServizioApplicativoFruitore(tracciaRisposta.getBusta().getServizioApplicativoFruitore());
  962.             }
  963.             // correggo anonimo
  964.             if(transactionDTO.getServizioApplicativoFruitore()!=null && CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(transactionDTO.getServizioApplicativoFruitore())){
  965.                 transactionDTO.setServizioApplicativoFruitore(null);
  966.             }
  967.             
  968.             if(transactionDTO.getServizioApplicativoErogatore()==null &&
  969.                 // provo a vedere se fosse nella traccia di richiesta
  970.                 (tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getServizioApplicativoErogatore()!=null)
  971.                 ){
  972.                 transactionDTO.setServizioApplicativoErogatore(tracciaRichiesta.getBusta().getServizioApplicativoErogatore());
  973.             }
  974.             if(transactionDTO.getServizioApplicativoErogatore()==null &&
  975.                 // provo a vedere se fosse nella traccia di risposta
  976.                 (tracciaRisposta!=null && tracciaRisposta.getBusta()!=null && tracciaRisposta.getBusta().getServizioApplicativoErogatore()!=null)
  977.                 ){
  978.                 transactionDTO.setServizioApplicativoErogatore(tracciaRisposta.getBusta().getServizioApplicativoErogatore());
  979.             }
  980.             
  981.             transactionDTO.setLocationRichiesta(tracciaRichiesta!=null ? tracciaRichiesta.getLocation() : null);
  982.             transactionDTO.setLocationRisposta(tracciaRisposta!=null ? tracciaRisposta.getLocation() : null);
  983.             
  984.             if(transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getProtocolContext()!=null){
  985.                 transactionDTO.setNomePorta(transaction.getRequestInfo().getProtocolContext().getInterfaceName());
  986.             }
  987.             
  988.             if(transaction.getCredenziali()!=null){
  989.                 transactionDTO.setCredenziali(transaction.getCredenziali());
  990.             }else{
  991.                 Object o = info.getContext().getObject(CostantiControlloTraffico.PDD_CONTEXT_MAX_REQUEST_VIOLATED_CREDENZIALI);
  992.                 if(o instanceof String){
  993.                     transactionDTO.setCredenziali((String)o);
  994.                 }
  995.                 else{
  996.                     o = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CREDENZIALI_INVOCAZIONE);
  997.                     if(o instanceof String){
  998.                         transactionDTO.setCredenziali((String)o);
  999.                     }
  1000.                 }
  1001.             }
  1002.             
  1003.             transactionDTO.setLocationConnettore(transaction.getLocation());
  1004.             
  1005.             if(transaction.getUrlInvocazione()!=null){
  1006.                 transactionDTO.setUrlInvocazione(transaction.getUrlInvocazione());
  1007.             }else{
  1008.                 Object o = info.getContext().getObject(CostantiControlloTraffico.PDD_CONTEXT_MAX_REQUEST_VIOLATED_URL_INVOCAZIONE);
  1009.                 if(o instanceof String){
  1010.                     transactionDTO.setUrlInvocazione((String)o);
  1011.                 }
  1012.                 else{
  1013.                     o = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.URL_INVOCAZIONE);
  1014.                     if(o instanceof String){
  1015.                         transactionDTO.setUrlInvocazione((String)o);
  1016.                     }
  1017.                 }
  1018.             }
  1019.             
  1020.             // ** cluster-id **
  1021.             transactionDTO.setClusterId(op2Properties.getClusterId(false));
  1022.             
  1023.             if(times!=null) {
  1024.                 long timeEnd =  DateManager.getTimeMillis();
  1025.                 long timeProcess = timeEnd-timeStart;
  1026.                 times.fillTransactionDetails.add("integration:"+timeProcess);
  1027.                 
  1028.                 timeStart = DateManager.getTimeMillis();
  1029.             }
  1030.             
  1031.             // credenziali
  1032.             if(transaction.getCredenzialiMittente()!=null) {
  1033.                 
  1034.                 // trasporto
  1035.                 if(transaction.getCredenzialiMittente().getTrasporto()!=null) {
  1036.                     transactionDTO.setTrasportoMittente(transaction.getCredenzialiMittente().getTrasporto().getId()+"");
  1037.                 }
  1038.                 
  1039.                 // token
  1040.                 if(transaction.getCredenzialiMittente().getTokenIssuer()!=null) {
  1041.                     transactionDTO.setTokenIssuer(transaction.getCredenzialiMittente().getTokenIssuer().getId()+"");
  1042.                 }
  1043.                 if(transaction.getCredenzialiMittente().getTokenClientId()!=null) {
  1044.                     transactionDTO.setTokenClientId(transaction.getCredenzialiMittente().getTokenClientId().getId()+"");
  1045.                 }
  1046.                 if(transaction.getCredenzialiMittente().getTokenSubject()!=null) {
  1047.                     transactionDTO.setTokenSubject(transaction.getCredenzialiMittente().getTokenSubject().getId()+"");
  1048.                 }
  1049.                 if(transaction.getCredenzialiMittente().getTokenUsername()!=null) {
  1050.                     transactionDTO.setTokenUsername(transaction.getCredenzialiMittente().getTokenUsername().getId()+"");
  1051.                 }
  1052.                 if(transaction.getCredenzialiMittente().getTokenEMail()!=null) {
  1053.                     transactionDTO.setTokenMail(transaction.getCredenzialiMittente().getTokenEMail().getId()+"");
  1054.                 }
  1055.             }
  1056.             
  1057.             // token negoziazione
  1058.             InformazioniNegoziazioneToken informazioniNegoziazioneToken = null;
  1059.             if(this.transazioniRegistrazioneRetrieveTokenSaveAsTokenInfo) {
  1060.                 if(transaction.getInformazioniNegoziazioneToken()!=null) {
  1061.                     informazioniNegoziazioneToken = transaction.getInformazioniNegoziazioneToken();
  1062.                     if(
  1063.                             (
  1064.                                     op2Properties.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature() &&
  1065.                                     (informazioniNegoziazioneToken.getAccessToken()!=null || informazioniNegoziazioneToken.getRefreshToken()!=null)
  1066.                             )
  1067.                             ||
  1068.                             (
  1069.                                     op2Properties.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature() &&
  1070.                                     informazioniNegoziazioneToken.getRequest()!=null
  1071.                             )
  1072.                     ) {
  1073.                         // clone for fix 'Caused by: java.util.ConcurrentModificationException' e non modificare informazione in cache dovuto alla deleteSignature e alla sostituzione del token
  1074.                         informazioniNegoziazioneToken = (InformazioniNegoziazioneToken) informazioniNegoziazioneToken.clone();
  1075.                     }
  1076.                 }
  1077.                 
  1078.                 if(informazioniNegoziazioneToken!=null) {
  1079.                     if(op2Properties.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature()) {
  1080.                         if(informazioniNegoziazioneToken.getAccessToken()!=null) {
  1081.                             String originale = informazioniNegoziazioneToken.getAccessToken();
  1082.                             String senzaSignature = TokenUtilities.deleteSignature(informazioniNegoziazioneToken.getAccessToken());
  1083.                             informazioniNegoziazioneToken.setAccessToken(senzaSignature);
  1084.                             informazioniNegoziazioneToken.setClaims(TokenUtilities.replaceTokenInMapByValue(informazioniNegoziazioneToken.getClaims(), originale, senzaSignature));
  1085.                             informazioniNegoziazioneToken.replaceInRawResponse(originale, senzaSignature);
  1086.                         }
  1087.                         if(informazioniNegoziazioneToken.getRefreshToken()!=null) {
  1088.                             String originale = informazioniNegoziazioneToken.getRefreshToken();
  1089.                             String senzaSignature = TokenUtilities.deleteSignature(informazioniNegoziazioneToken.getRefreshToken());
  1090.                             informazioniNegoziazioneToken.setRefreshToken(senzaSignature);
  1091.                             informazioniNegoziazioneToken.setClaims(TokenUtilities.replaceTokenInMapByValue(informazioniNegoziazioneToken.getClaims(), originale, senzaSignature));
  1092.                             informazioniNegoziazioneToken.replaceInRawResponse(originale, senzaSignature);
  1093.                         }
  1094.                     }
  1095.                     
  1096.                     if(informazioniNegoziazioneToken.getRequest()!=null &&
  1097.                         informazioniNegoziazioneToken.getRequest().getJwtClientAssertion()!=null && 
  1098.                         informazioniNegoziazioneToken.getRequest().getJwtClientAssertion().getToken()!=null &&
  1099.                         op2Properties.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature()) {
  1100.                         informazioniNegoziazioneToken.getRequest().getJwtClientAssertion().setToken(TokenUtilities.deleteSignature(informazioniNegoziazioneToken.getRequest().getJwtClientAssertion().getToken()));
  1101.                     }
  1102.                 }
  1103.             }
  1104.                                     
  1105.             // token info
  1106.             if(this.transazioniRegistrazioneTokenInformazioniNormalizzate && transaction.getInformazioniToken()!=null) {
  1107.                 
  1108.                 InformazioniToken informazioniToken = transaction.getInformazioniToken();
  1109.                 if(informazioniToken.getToken()!=null && op2Properties.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature()) {
  1110.                     // clone for fix 'Caused by: java.util.ConcurrentModificationException' e non modificare informazione in cache dovuto alla deleteSignature e alla sostituzione del token
  1111.                     informazioniToken = (InformazioniToken) informazioniToken.clone();
  1112.                 }
  1113.                 
  1114.                 // token validazione
  1115.                 if(informazioniToken.getToken()!=null && op2Properties.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature()) {
  1116.                     informazioniToken.setToken(TokenUtilities.deleteSignature(informazioniToken.getToken()));
  1117.                 }
  1118.                 
  1119.                 // token negoziazione
  1120.                 if(informazioniNegoziazioneToken!=null) {
  1121.                     informazioniToken.setRetrievedToken(informazioniNegoziazioneToken);
  1122.                 }
  1123.                 
  1124.                 // attributi
  1125.                 InformazioniAttributi informazioniAttributi = null;
  1126.                 if(!this.transazioniRegistrazioneAttributiInformazioniNormalizzate) {
  1127.                     informazioniAttributi = informazioniToken.getAa();
  1128.                     informazioniToken.setAa(null);
  1129.                 }
  1130.                 setTokenInfo(transactionDTO, informazioniToken);
  1131.                 if(informazioniAttributi!=null) {
  1132.                     informazioniToken.setAa(informazioniAttributi);
  1133.                 }
  1134.                                 
  1135.             }
  1136.             if(transactionDTO.getTokenInfo()==null && this.transazioniRegistrazioneAttributiInformazioniNormalizzate &&
  1137.                     transaction.getInformazioniAttributi()!=null) {
  1138.                 if(informazioniNegoziazioneToken!=null) {
  1139.                     setTokenInfo(transactionDTO, informazioniNegoziazioneToken, transaction);
  1140.                 }
  1141.                 else {
  1142.                     setTokenInfo(transactionDTO, transaction);
  1143.                 }
  1144.             }
  1145.             if(transactionDTO.getTokenInfo()==null && informazioniNegoziazioneToken!=null) {
  1146.                 setTokenInfo(transactionDTO, informazioniNegoziazioneToken);
  1147.             }
  1148.             
  1149.             if(times!=null) {
  1150.                 long timeEnd =  DateManager.getTimeMillis();
  1151.                 long timeProcess = timeEnd-timeStart;
  1152.                 times.fillTransactionDetails.add("token:"+timeProcess);
  1153.                 
  1154.                 timeStart = DateManager.getTimeMillis();
  1155.             }
  1156.             
  1157.             // tempi elaborazione
  1158.             if(this.transazioniRegistrazioneTempiElaborazione && transaction.getTempiElaborazione()!=null) {
  1159.                 setTempiElaborazione(transactionDTO, transaction);
  1160.             }
  1161.             
  1162.             if(times!=null) {
  1163.                 long timeEnd =  DateManager.getTimeMillis();
  1164.                 long timeProcess = timeEnd-timeStart;
  1165.                 times.fillTransactionDetails.add("times:"+timeProcess);
  1166.                 
  1167.                 timeStart = DateManager.getTimeMillis();
  1168.             }
  1169.             
  1170.             // ** Indirizzo IP **
  1171.             setAccordoInfoClientAddress(transactionDTO,
  1172.                     requestInfo,
  1173.                     idDominio, info, idTransazione,
  1174.                     times, timeStart, fase);
  1175.             if(times!=null) {
  1176.                 timeStart = DateManager.getTimeMillis();
  1177.             }
  1178.             
  1179.             // ** eventi di gestione **
  1180.             if(!FaseTracciamento.POST_OUT_RESPONSE.equals(fase)){ // altrimenti gestito prima come per l'esito
  1181.                 setEventi(transactionDTO, transaction,
  1182.                         op2Properties,
  1183.                         requestInfo,
  1184.                         idDominio, info, idTransazione,
  1185.                         times, timeStart, fase);
  1186.             }
  1187.             if(times!=null) {
  1188.                 timeStart = DateManager.getTimeMillis();
  1189.             }
  1190.             
  1191.             // ** filtro duplicati **
  1192.             if(richiestaDuplicata){
  1193.                 transactionDTO.setDuplicatiRichiesta(-1);
  1194.             }
  1195.             else{
  1196.                 transactionDTO.setDuplicatiRichiesta(0);
  1197.             }
  1198.             if(rispostaDuplicata){
  1199.                 transactionDTO.setDuplicatiRisposta(-1);
  1200.             }
  1201.             else{
  1202.                 transactionDTO.setDuplicatiRisposta(0);
  1203.             }
  1204.             
  1205.             
  1206.             // ** Extended Info **
  1207.             ExtendedTransactionInfo transactionExtendedInfo = null;
  1208.             if (info.getContext().getObject(Costanti.EXTENDED_INFO_TRANSAZIONE)!=null){
  1209.                 transactionExtendedInfo = ((ExtendedTransactionInfo)info.getContext().getObject(Costanti.EXTENDED_INFO_TRANSAZIONE));
  1210.                 List<String> keys = transactionExtendedInfo.keys();
  1211.                 if(keys!=null && !keys.isEmpty()){
  1212.                     for (String key : keys) {
  1213.                         String value = transactionExtendedInfo.getValue(key);
  1214.                         TransazioneExtendedInfo transazioneExtendedInfo = new TransazioneExtendedInfo();
  1215.                         transazioneExtendedInfo.setNome(key);
  1216.                         transazioneExtendedInfo.setValore(value);
  1217.                         transactionDTO.addTransazioneExtendedInfo(transazioneExtendedInfo);
  1218.                     }
  1219.                 }
  1220.             }
  1221.             
  1222.             if(times!=null) {
  1223.                 long timeEnd =  DateManager.getTimeMillis();
  1224.                 long timeProcess = timeEnd-timeStart;
  1225.                 times.fillTransactionDetails.add("ext-info:"+timeProcess);
  1226.                 
  1227.                 timeStart = DateManager.getTimeMillis();
  1228.             }
  1229.             
  1230.             
  1231.             return transactionDTO;


  1234.         } catch (Exception e) {
  1235.             throw new HandlerException("Errore durante il popolamento della transazione da salvare su database: " + e.getLocalizedMessage(), e);
  1236.         } 
  1237.         finally{
  1238.         
  1239.             if(consegnaMultiplaProfiloSincrono) {
  1240.                 timeStart = consegnaMultiplaProfiloSincrono(info, idDominio, idTransazione,
  1241.                         times, timeStart,
  1242.                         schedulaNotificheDopoConsegnaSincrona, msgDiag, nomePorta);
  1243.             }
  1244.             
  1245.             if(identificativoSaveTransactionContext!=null) {
  1246.                 timeStart = saveTransactionContext(identificativoSaveTransactionContext, info, idDominio, idTransazione,
  1247.                         times, timeStart,
  1248.                         msgDiag);
  1249.             }
  1250.         }
  1251.     }
  1252.     
  1253.     private static void setDataAccettazioneRichiesta(Transazione transactionDTO, InformazioniTransazione info, Transaction transaction) {
  1254.         // Se data_accettazione_richiesta è null viene impostata a CURRENT_TIMESTAMP
  1255.         if (transaction.getDataAccettazioneRichiesta()!=null){
  1256.             transactionDTO.setDataAccettazioneRichiesta(transaction.getDataAccettazioneRichiesta());
  1257.         }else{
  1258.             Object o = info.getContext().getObject(CostantiPdD.DATA_ACCETTAZIONE_RICHIESTA);
  1259.             if(o instanceof Date){
  1260.                 transactionDTO.setDataAccettazioneRichiesta((Date) o);
  1261.             }
  1262.             else{
  1263.                 transactionDTO.setDataAccettazioneRichiesta(DateManager.getDate());
  1264.             }
  1265.         }
  1266.     }
  1267.     private static void setDataIngressoRichiesta(OpenSPCoop2Properties op2Properties, Transazione transactionDTO, InformazioniTransazione info, Transaction transaction) {
  1268.         // Se data_ingresso_richiesta è null viene impostata a CURRENT_TIMESTAMP
  1269.         boolean valorizzataDataIngressoConDataAccettazione = op2Properties.isTransazioniValorizzaDataIngressoConDataAccettazione();
  1270.         if(valorizzataDataIngressoConDataAccettazione) {
  1271.             transactionDTO.setDataIngressoRichiesta(transactionDTO.getDataAccettazioneRichiesta());
  1272.         }
  1273.         else {
  1274.             if (transaction.getDataIngressoRichiesta()!=null){
  1275.                 transactionDTO.setDataIngressoRichiesta(transaction.getDataIngressoRichiesta());
  1276.             }else{
  1277.                 Object o = info.getContext().getObject(CostantiPdD.DATA_INGRESSO_RICHIESTA);
  1278.                 if(o instanceof Date){
  1279.                     transactionDTO.setDataIngressoRichiesta((Date) o);
  1280.                 }
  1281.                 else{
  1282.                     transactionDTO.setDataIngressoRichiesta(DateManager.getDate());
  1283.                 }
  1284.             }
  1285.         }
  1286.     }
  1287.     private static void setDataIngressoRichiestaStream(Transazione transactionDTO, InformazioniTransazione info) {
  1288.         if(info.getContext()!=null) {
  1289.             Object o = info.getContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_REQUEST_COMPLETE_DATE);
  1290.             if(o==null) {
  1291.                 o = info.getContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_REQUEST_ERROR_DATE);
  1292.             }
  1293.             if(o instanceof Date) {
  1294.                 Date d = (Date) o;
  1295.                 transactionDTO.setDataIngressoRichiestaStream(d);
  1296.             }
  1297.         }
  1298.     }
  1299.     
  1300.     private static void setDataUscitaRichiesta(Transazione transactionDTO, FaseTracciamento fase, Transaction transaction) {
  1301.         // data_uscita_richiesta si imposta se e' diversa da null
  1302.         if(FaseTracciamento.OUT_REQUEST.equals(fase) || FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1303.             if (transaction.getDataUscitaRichiesta()!=null) {
  1304.                 transactionDTO.setDataUscitaRichiesta(transaction.getDataUscitaRichiesta());
  1305.             }
  1306.             
  1307.             // data_uscita_richiesta_stream
  1308.             if(transaction.getDataRichiestaInoltrata()!=null) {
  1309.                 transactionDTO.setDataUscitaRichiestaStream(transaction.getDataRichiestaInoltrata());
  1310.             }
  1311.         }
  1312.     }
  1313.     
  1314.     private static void setDataAccettazioneRisposta(Transazione transactionDTO, FaseTracciamento fase, Transaction transaction) {
  1315.         if(
  1316.                 (FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase))
  1317.                 &&
  1318.             // data_accettazione_risposta
  1319.             // La porta di dominio mi passa sempre questa informazione.
  1320.             // Nel PddMonitor, invece, la data deve essere visualizzata solo se la dimensione e' diverso da 0 e cioe' se c'e' un messaggio di risposta.
  1321.             /**if (transaction.getDimensioneIngressoRispostaBytes()!=null && transaction.getDimensioneIngressoRispostaBytes()>0){*/
  1322.             // L'INFORMAZIONE DEVE INVECE ESSERE SALVATA PER LA SIMULAZIONE DEI MESSAGGI DIAGNOSTICI
  1323.             transaction.getDataAccettazioneRisposta()!=null){
  1324.             transactionDTO.setDataAccettazioneRisposta(transaction.getDataAccettazioneRisposta());
  1325.         }
  1326.     }
  1327.     private static void setDataIngressoRisposta(OpenSPCoop2Properties op2Properties, Transazione transactionDTO, FaseTracciamento fase, Transaction transaction) {
  1328.         if(FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1329.             // data_ingresso_risposta
  1330.             
  1331.             boolean valorizzataDataIngressoConDataAccettazione = op2Properties.isTransazioniValorizzaDataIngressoConDataAccettazione();
  1332.             
  1333.             // La porta di dominio mi passa sempre questa informazione.
  1334.             // Nel PddMonitor, invece, la data deve essere visualizzata solo se la dimensione e' diverso da 0 e cioe' se c'e' un messaggio di risposta.
  1335.             /**if (transaction.getDimensioneIngressoRispostaBytes()!=null && transaction.getDimensioneIngressoRispostaBytes()>0){*/
  1336.             // L'INFORMAZIONE DEVE INVECE ESSERE SALVATA PER LA SIMULAZIONE DEI MESSAGGI DIAGNOSTICI
  1337.             if(valorizzataDataIngressoConDataAccettazione && transactionDTO.getDataAccettazioneRisposta()!=null) {
  1338.                 transactionDTO.setDataIngressoRisposta(transactionDTO.getDataAccettazioneRisposta());
  1339.             }
  1340.             else {
  1341.                 if (transaction.getDataIngressoRisposta()!=null){
  1342.                     transactionDTO.setDataIngressoRisposta(transaction.getDataIngressoRisposta());
  1343.                 }
  1344.             }
  1345.         }
  1346.     }
  1347.     private static void setDataIngressoRispostaStream(Transazione transactionDTO, InformazioniTransazione info, FaseTracciamento fase) {
  1348.         if(
  1349.             (FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase))
  1350.                 &&
  1351.             // data_ingresso_risposta_stream
  1352.             info.getContext()!=null) {
  1353.             Object o = info.getContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_RESPONSE_COMPLETE_DATE);
  1354.             if(o==null) {
  1355.                 o = info.getContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_RESPONSE_ERROR_DATE);
  1356.             }
  1357.             if(o instanceof Date) {
  1358.                 Date d = (Date) o;
  1359.                 transactionDTO.setDataIngressoRispostaStream(d);
  1360.             }
  1361.         }
  1362.     }
  1363.     
  1364.     private static void setDataUscitaRisposta(OpenSPCoop2Properties op2Properties, Transazione transactionDTO, InformazioniTransazione info, FaseTracciamento fase, Transaction transaction) {
  1365.         // ** data_uscita_risposta **
  1366.         if(FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1367.             boolean calcolaDataUscitaRispostaConDateAfterResponseSent = op2Properties.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent();
  1368.             if(calcolaDataUscitaRispostaConDateAfterResponseSent && info.getDataRispostaSpedita()!=null) {
  1369.                 if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1370.                     transactionDTO.setDataUscitaRisposta(info.getDataRispostaSpedita());
  1371.                 }
  1372.             }
  1373.             else if(!calcolaDataUscitaRispostaConDateAfterResponseSent && info.getDataPrimaSpedizioneRisposta()!=null) {
  1374.                 transactionDTO.setDataUscitaRisposta(info.getDataPrimaSpedizioneRisposta());
  1375.             }
  1376.             else if (transaction.getDataUscitaRisposta()!=null){
  1377.                 transactionDTO.setDataUscitaRisposta(transaction.getDataUscitaRisposta());
  1378.             }
  1379.             else{
  1380.                 // creo sempre una data di risposta.
  1381.                 transactionDTO.setDataUscitaRisposta(DateManager.getDate());
  1382.             }
  1383.         }
  1384.     }
  1385.     private static void setDataUscitaRispostaStream(OpenSPCoop2Properties op2Properties, Transazione transactionDTO, InformazioniTransazione info, FaseTracciamento fase) {
  1386.         // ** data_uscita_risposta_stream **
  1387.         if(FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1388.             boolean calcolaDataUscitaRispostaConDateAfterResponseSent = op2Properties.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent();
  1389.             if(calcolaDataUscitaRispostaConDateAfterResponseSent && info.getDataPrimaSpedizioneRisposta()!=null) {
  1390.                 transactionDTO.setDataUscitaRispostaStream(info.getDataPrimaSpedizioneRisposta());
  1391.             }
  1392.             else if(!calcolaDataUscitaRispostaConDateAfterResponseSent && info.getDataRispostaSpedita()!=null &&
  1393.                 FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1394.                 transactionDTO.setDataUscitaRispostaStream(info.getDataRispostaSpedita());
  1395.             }
  1396.             
  1397.             if(calcolaDataUscitaRispostaConDateAfterResponseSent && transactionDTO.getDataUscitaRispostaStream()==null) {
  1398.                 transactionDTO.setDataUscitaRispostaStream(transactionDTO.getDataUscitaRisposta()); // uso la stessa
  1399.             }
  1400.         }
  1401.     }
  1402.     
  1403.     private static void setRichiestaIngressoBytes(Transazione transactionDTO, InformazioniTransazione info, Transaction transaction, FaseTracciamento fase) {
  1404.         // dimensione_ingresso_richiesta
  1405.         if (info.getInputRequestMessageSize()!=null && info.getInputRequestMessageSize()>0){
  1406.             transactionDTO.setRichiestaIngressoBytes(info.getInputRequestMessageSize());
  1407.         }
  1408.         if(transactionDTO.getRichiestaIngressoBytes()==null &&
  1409.                 FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1410.             transactionDTO.setRichiestaIngressoBytes(readDimensioneFromDumpBinario(TipoMessaggio.RICHIESTA_INGRESSO_DUMP_BINARIO, transaction));
  1411.         }
  1412.     }
  1413.     
  1414.     private static void setRichiestaUscitaBytes(Transazione transactionDTO, InformazioniTransazione info, Transaction transaction, FaseTracciamento fase) {
  1415.         if( 
  1416.                 (FaseTracciamento.OUT_REQUEST.equals(fase) || FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase))
  1417.                 && 
  1418.                 (info.getOutputRequestMessageSize()!=null && info.getOutputRequestMessageSize()>0 &&
  1419.                     transactionDTO.getDataUscitaRichiesta()!=null) // altrimenti non ha senso, poichè non c'è stato un vero inoltro verso il backend
  1420.             ) {
  1421.             transactionDTO.setRichiestaUscitaBytes(info.getOutputRequestMessageSize());
  1422.         }
  1423.         if(transactionDTO.getRichiestaUscitaBytes()==null &&
  1424.                 FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  1425.             transactionDTO.setRichiestaUscitaBytes(readDimensioneFromDumpBinario(TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO, transaction));
  1426.         }
  1427.     }
  1428.     
  1429.     private static void setRispostaIngressoBytes(Transazione transactionDTO, InformazioniTransazione info, Transaction transaction, FaseTracciamento fase) {
  1430.         // ** dimensione_ingresso_risposta **
  1431.         if(
  1432.                 (FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase))
  1433.                 &&
  1434.                 (info.getInputResponseMessageSize()!=null && info.getInputResponseMessageSize()>0 &&
  1435.                     transaction!=null && transaction.getDataIngressoRisposta()!=null)
  1436.             ) { // altrimenti non ha senso, poichè non c'è stato un vero inoltro verso il backend
  1437.                 
  1438.             boolean add = false;
  1439.             if(info.getContext()!=null) {
  1440.                 Object o = info.getContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_RESPONSE_START_DATE);
  1441.                 if(o instanceof Date) {
  1442.                     add = true;
  1443.                 }
  1444.             }
  1445.             
  1446.             if(add) {
  1447.                 transactionDTO.setRispostaIngressoBytes(info.getInputResponseMessageSize());
  1448.             }
  1449.             
  1450.         }
  1451.     }
  1452.     
  1453.     private static void setRispostaUscitaBytes(Transazione transactionDTO, InformazioniTransazione info, FaseTracciamento fase) {
  1454.         if(
  1455.                 (FaseTracciamento.OUT_RESPONSE.equals(fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(fase))
  1456.                 &&
  1457.                 (info.getOutputResponseMessageSize()!=null && info.getOutputResponseMessageSize()>0)
  1458.             ){
  1459.             transactionDTO.setRispostaUscitaBytes(info.getOutputResponseMessageSize());
  1460.         }
  1461.     }
  1462.     
  1463.     private static Long readDimensioneFromDumpBinario(TipoMessaggio tipoMessaggio, Transaction transaction) {
  1464.         if(transaction!=null && !transaction.getMessaggi().isEmpty()) {
  1465.             for (Messaggio msg : transaction.getMessaggi()) {
  1466.                 if(tipoMessaggio.equals(msg.getTipoMessaggio()) && msg.getBody()!=null){
  1467.                     return Long.valueOf(msg.getBody().size());
  1468.                 }
  1469.             }
  1470.         }
  1471.         return null;
  1472.     }
  1473.     
  1474.     private void setFaultInfo(Transazione transactionDTO, 
  1475.             OpenSPCoop2Properties op2Properties, 
  1476.             InformazioniTransazione info) {
  1477.         String fault = null;
  1478.         String formatoFault = null;
  1479.         try{
  1480.             if(info.getResponse()!=null){
  1481.                 if(ServiceBinding.SOAP.equals(info.getResponse().getServiceBinding())) {
  1482.                     OpenSPCoop2SoapMessage soapMsg = info.getResponse().castAsSoap();
  1483.                     if(soapMsg.hasSOAPFault()){
  1484.                         
  1485.                         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1486.                         bout.write(info.getResponse().getAsByte(soapMsg.getSOAPPart().getEnvelope(), false));
  1487.                         bout.flush();
  1488.                         bout.close();
  1489.                         
  1490.                         Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioni(op2Properties.isTransazioniDebug());
  1491.                         if(op2Properties.isTransazioniFaultPrettyPrint()){
  1492.                             // Faccio una pretty-print: potevo fare anche direttamente passando il fault a metodo prettyPrint,
  1493.                             // Pero' non veniva stampato correttamente il SOAPFault. Mi appoggio allora a SoapUtils.
  1494.                             /**byte [] content = org.openspcoop2.message.soap.TunnelSoapUtils.sbustamentoMessaggio(context.getMessaggio());*/
  1495.                             byte [] content = bout.toByteArray();
  1496.                             fault = DumpUtility.toString(MessageXMLUtils.getInstance(soapMsg.getFactory()).newDocument(content), log, info.getResponse());
  1497.                             /**System.out.println("IMPOSTATO FAULT IN TRANSACTION ["+fault+"]");*/
  1498.                         }
  1499.                         else{
  1500.                             
  1501.                             fault = bout.toString();
  1502.                         }
  1503.                         
  1504.                         formatoFault = soapMsg.getMessageType().name();
  1505.                     }

  1507.                 }
  1508.                 else {
  1509.                     OpenSPCoop2RestMessage<?> restMsg = info.getResponse().castAsRest();
  1510.                     if(restMsg.isProblemDetailsForHttpApis_RFC7807() || MessageRole.FAULT.equals(restMsg.getMessageRole())) {
  1511.                         switch (restMsg.getMessageType()) {
  1512.                         case XML:
  1513.                             
  1514.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1515.                             restMsg.writeTo(bout, false);
  1516.                             bout.flush();
  1517.                             bout.close();
  1518.                             
  1519.                             Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioni(op2Properties.isTransazioniDebug());
  1520.                             if(op2Properties.isTransazioniFaultPrettyPrint()){
  1521.                                 // Faccio una pretty-print: potevo fare anche direttamente passando il fault a metodo prettyPrint,
  1522.                                 // Pero' non veniva stampato correttamente il SOAPFault. Mi appoggio allora a SoapUtils.
  1523.                                 /**byte [] content = org.openspcoop2.message.soap.TunnelSoapUtils.sbustamentoMessaggio(context.getMessaggio());*/
  1524.                                 byte [] content = bout.toByteArray();
  1525.                                 fault = DumpUtility.toString(MessageXMLUtils.getInstance(restMsg.getFactory()).newDocument(content), log, info.getResponse());
  1526.                                 /**System.out.println("IMPOSTATO FAULT IN TRANSACTION ["+fault+"]");*/
  1527.                             }
  1528.                             else{
  1529.                                 
  1530.                                 fault = bout.toString();
  1531.                             }
  1532.                             
  1533.                             formatoFault = restMsg.getMessageType().name();
  1534.                             
  1535.                             break;
  1536.                             
  1537.                         case JSON:
  1538.                             
  1539.                             bout = new ByteArrayOutputStream();
  1540.                             restMsg.writeTo(bout, false);
  1541.                             bout.flush();
  1542.                             bout.close();
  1543.                             
  1544.                             if(op2Properties.isTransazioniFaultPrettyPrint()){
  1545.                                 
  1546.                                 JSONUtils jsonUtils = JSONUtils.getInstance(true);
  1547.                                 byte [] content = bout.toByteArray();
  1548.                                 JsonNode jsonNode = jsonUtils.getAsNode(content);
  1549.                                 fault = jsonUtils.toString(jsonNode);
  1550.                                 
  1551.                             }
  1552.                             else{
  1553.                                 
  1554.                                 fault = bout.toString();
  1555.                             }
  1556.                             
  1557.                             formatoFault = restMsg.getMessageType().name();
  1558.                             
  1559.                             break;

  1561.                         default:
  1562.                             break;
  1563.                         }
  1564.                     }
  1565.                 }
  1566.             }
  1567.         }catch(Exception e){
  1568.             this.logger.error("Errore durante il dump del soap fault",e);
  1569.         }
  1570.         if(TipoPdD.DELEGATA.equals(info.getTipoPorta())){
  1571.             transactionDTO.setFaultIntegrazione(fault);
  1572.             transactionDTO.setFormatoFaultIntegrazione(formatoFault);
  1573.         }
  1574.         else{
  1575.             transactionDTO.setFaultCooperazione(fault);
  1576.             transactionDTO.setFormatoFaultCooperazione(formatoFault);
  1577.         }
  1578.     }
  1579.     
  1580.     private IDAccordo getIdAccordo(Transazione transactionDTO, RegistroServiziManager registroServiziManager, RequestInfo requestInfo) {
  1581.         try {
  1582.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(transactionDTO.getTipoServizio(), transactionDTO.getNomeServizio(), 
  1583.                 transactionDTO.getTipoSoggettoErogatore(), transactionDTO.getNomeSoggettoErogatore(), transactionDTO.getVersioneServizio());
  1584.             AccordoServizioParteSpecifica asps = registroServiziManager.getAccordoServizioParteSpecifica(idServizio, null, false, requestInfo);
  1585.             return  IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  1586.         }catch(Exception e) {
  1587.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1588.             this.logger.error("Errore durante l'identificazione delle caratteristiche dell'API (Accesso servizio): "+e.getMessage(),e);
  1589.             return null;
  1590.         }
  1591.     }
  1592.         
  1593.     private void setAccordoInfo(IDAccordo idAccordo, Transazione transactionDTO, 
  1594.             OpenSPCoop2Properties op2Properties, RegistroServiziManager registroServiziManager, RequestInfo requestInfo,
  1595.             IDSoggetto idDominio, InformazioniTransazione info, String idTransazione,
  1596.             TransazioniProcessTimes times, long timeStart, FaseTracciamento fase) {
  1597.         try {
  1598.             AccordoServizioParteComune aspc = registroServiziManager.getAccordoServizioParteComune(idAccordo, null, false, false, requestInfo);
  1599.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(aspc.getServiceBinding())) {
  1600.                 transactionDTO.setTipoApi(TipoAPI.REST.getValoreAsInt());
  1601.             }
  1602.             else {
  1603.                 transactionDTO.setTipoApi(TipoAPI.SOAP.getValoreAsInt());
  1604.             }
  1605.                 
  1606.             if(times!=null) {
  1607.                 long timeEnd =  DateManager.getTimeMillis();
  1608.                 long timeProcess = timeEnd-timeStart;
  1609.                 times.fillTransactionDetails.add("api:"+timeProcess);
  1610.                 
  1611.                 timeStart = DateManager.getTimeMillis();
  1612.             }
  1613.             
  1614.             String conflict = setAccordoInfoGruppi(aspc, transactionDTO,
  1615.                     op2Properties,
  1616.                     requestInfo,
  1617.                     idDominio, info, idTransazione,
  1618.                     times, fase);
  1619.             
  1620.             if(times!=null) {
  1621.                 long timeEnd =  DateManager.getTimeMillis();
  1622.                 long timeProcess = timeEnd-timeStart;
  1623.                 times.fillTransactionDetails.add("tags:"+timeProcess+"/c"+conflict);
  1624.                 
  1625.                 timeStart = DateManager.getTimeMillis();
  1626.             }
  1627.             
  1628.         }catch(Exception e) {
  1629.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1630.             this.logger.error("Errore durante l'identificazione delle caratteristiche dell'API (Accesso servizio): "+e.getMessage(),e);
  1631.         }
  1632.         
  1633.         String conflict = setAccordoInfoUriAPC(idAccordo, transactionDTO,
  1634.                 requestInfo,
  1635.                 idDominio, info, idTransazione,
  1636.                 times, fase);
  1637.         
  1638.         if(times!=null) {
  1639.             long timeEnd =  DateManager.getTimeMillis();
  1640.             long timeProcess = timeEnd-timeStart;
  1641.             times.fillTransactionDetails.add("uri-api:"+timeProcess+"/c"+conflict);
  1642.         }
  1643.     }
  1644.     
  1645.     private static final MapKey<String> CREDENZIALI_MITTENTE_GRUPPI_RESOLVED = org.openspcoop2.utils.Map.newMapKey("CREDENZIALI_MITTENTE_GRUPPI_RESOLVED");
  1646.     private String getCredenzialiMittenteGruppi(InformazioniTransazione info) {
  1647.         return (info!=null && info.getContext()!=null) ? (String) info.getContext().get(CREDENZIALI_MITTENTE_GRUPPI_RESOLVED) : null;
  1648.     }
  1649.     private void addCredenzialiMittenteGruppi(InformazioniTransazione info, String cred) {
  1650.         if(info!=null && info.getContext()!=null) {
  1651.             info.getContext().put(CREDENZIALI_MITTENTE_GRUPPI_RESOLVED, cred);
  1652.         }
  1653.     }
  1654.     private String setAccordoInfoGruppi(AccordoServizioParteComune aspc, Transazione transactionDTO,
  1655.             OpenSPCoop2Properties op2Properties,
  1656.             RequestInfo requestInfo,
  1657.             IDSoggetto idDominio, InformazioniTransazione info, String idTransazione,
  1658.             TransazioniProcessTimes times, FaseTracciamento fase) throws CoreException {
  1659.         String conflict = "0";
  1660.         if(aspc.getGruppi()!=null && aspc.getGruppi().sizeGruppoList()>0) {
  1661.             
  1662.             String cred = getCredenzialiMittenteGruppi(info);
  1663.             if(cred!=null && StringUtils.isNotEmpty(cred)) {
  1664.                 transactionDTO.setGruppi(cred);
  1665.             }
  1666.             else {
  1667.                 List<String> gruppi = new ArrayList<>();
  1668.                 int count = 0;
  1669.                 int maxLengthCredenziali = op2Properties.getTransazioniCredenzialiMittenteMaxLength()-AbstractCredenzialeList.PREFIX.length();
  1670.                 for (int i=0; i<aspc.getGruppi().sizeGruppoList(); i++) {
  1671.                     GruppoAccordo gruppoAccordo = aspc.getGruppi().getGruppo(i);
  1672.                     String dbValue = AbstractCredenzialeList.getDBValue(gruppoAccordo.getNome());
  1673.                     if(count+dbValue.length()<maxLengthCredenziali) {
  1674.                         gruppi.add( gruppoAccordo.getNome() );
  1675.                         count = count+dbValue.length();
  1676.                     }
  1677.                     else {
  1678.                         // tronco i gruppi ai primi trovati. Sono troppi eventi gruppi associati alla api
  1679.                     }
  1680.                 }
  1681.                 if(!gruppi.isEmpty()){
  1682.                     StringBuilder sbConflict = null;
  1683.                     if(times!=null) {
  1684.                         sbConflict = new StringBuilder();
  1685.                     }
  1686.                     CredenzialeMittente credGruppi = null;
  1687.                     try {
  1688.                         credGruppi = GestoreAutenticazione.convertGruppiToCredenzialiMittenti(idDominio, info.getIdModulo(), idTransazione, gruppi, 
  1689.                             null, fase.name()+".gruppi",
  1690.                             sbConflict, requestInfo);
  1691.                     }catch(Exception e) {
  1692.                         throw new CoreException(e.getMessage(),e);
  1693.                     }
  1694.                     if(sbConflict!=null && sbConflict.length()>0) {
  1695.                         conflict = sbConflict.toString();
  1696.                     }
  1697.                     if(credGruppi!=null) {
  1698.                         cred = credGruppi.getId()+"";
  1699.                         transactionDTO.setGruppi(cred);
  1700.                         addCredenzialiMittenteGruppi(info, cred);
  1701.                     }
  1702.                 }
  1703.             }
  1704.         }
  1705.         return conflict;
  1706.     }
  1707.     
  1708.     
  1709.     private static final MapKey<String> CREDENZIALI_MITTENTE_URI_APC_RESOLVED = org.openspcoop2.utils.Map.newMapKey("CREDENZIALI_MITTENTE_URI_APC_RESOLVED");
  1710.     private String getCredenzialiMittenteUriAPC(InformazioniTransazione info) {
  1711.         return (info!=null && info.getContext()!=null) ? (String) info.getContext().get(CREDENZIALI_MITTENTE_URI_APC_RESOLVED) : null;
  1712.     }
  1713.     private void addCredenzialiMittenteUriAPC(InformazioniTransazione info, String cred) {
  1714.         if(info!=null && info.getContext()!=null) {
  1715.             info.getContext().put(CREDENZIALI_MITTENTE_URI_APC_RESOLVED, cred);
  1716.         }
  1717.     }
  1718.     private String setAccordoInfoUriAPC(IDAccordo idAccordo, Transazione transactionDTO,
  1719.             RequestInfo requestInfo,
  1720.             IDSoggetto idDominio, InformazioniTransazione info, String idTransazione,
  1721.             TransazioniProcessTimes times, FaseTracciamento fase) {
  1722.         String conflict = "0";
  1723.         try {
  1724.             String cred = getCredenzialiMittenteUriAPC(info);
  1725.             if(cred!=null && StringUtils.isNotEmpty(cred)) {
  1726.                 transactionDTO.setUriApi(cred);
  1727.             }
  1728.             else {
  1729.                 if(transactionDTO.getUriAccordoServizio()==null){
  1730.                     transactionDTO.setUriAccordoServizio(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  1731.                 }
  1732.                 StringBuilder sbConflict = null;
  1733.                 if(times!=null) {
  1734.                     sbConflict = new StringBuilder();
  1735.                 }
  1736.                 CredenzialeMittente credAPI = GestoreAutenticazione.convertAPIToCredenzialiMittenti(idDominio, info.getIdModulo(), idTransazione, transactionDTO.getUriAccordoServizio(), 
  1737.                         null, fase.name()+".api",
  1738.                         sbConflict, requestInfo);
  1739.                 if(sbConflict!=null && sbConflict.length()>0) {
  1740.                     conflict = sbConflict.toString();
  1741.                 }
  1742.                 if(credAPI!=null) {
  1743.                     cred = credAPI.getId()+"";
  1744.                     transactionDTO.setUriApi(cred);
  1745.                     addCredenzialiMittenteUriAPC(info, cred);
  1746.                 }
  1747.             }
  1748.         }catch(Exception e) {
  1749.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1750.             this.logger.error("Errore durante l'identificazione dell'identificativo dell'API (Accesso servizio parte comune): "+e.getMessage(),e);
  1751.         }
  1752.         return conflict;
  1753.     }
  1754.     
  1755.     private void setHeaderProtocolloRichiesta(Transazione transactionDTO, Traccia tracciaRichiesta) {
  1756.         try{
  1757.             transactionDTO.setHeaderProtocolloRichiesta(tracciaRichiesta.getBustaAsRawContent().toString(TipoSerializzazione.DEFAULT));
  1758.         }catch(Exception e){
  1759.             /// NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1760.             String msg = "Errore durante la conversione dell'oggetto Busta di richiesta ["+tracciaRichiesta.getBustaAsRawContent().getClass().getName()+"] in stringa";
  1761.             this.logger.error(msg);
  1762.         }
  1763.     }
  1764.     
  1765.     private void setProtocolloExtInfoRichiesta(Transazione transactionDTO, PropertiesSerializator ps) {
  1766.         try{
  1767.             transactionDTO.setProtocolloExtInfoRichiesta(ps.convertToDBColumnValue());
  1768.         }catch(Exception e){
  1769.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1770.             this.logger.error("Errore durante la conversione delle proprieta della Busta di richiesta: "+e.getMessage(),e);
  1771.         }
  1772.     }
  1773.     
  1774.     private void setHeaderProtocolloRisposta(Transazione transactionDTO, Traccia tracciaRisposta) {
  1775.         try{
  1776.             transactionDTO.setHeaderProtocolloRisposta(tracciaRisposta.getBustaAsRawContent().toString(TipoSerializzazione.DEFAULT));
  1777.         }catch(Exception e){
  1778.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1779.             String msg = "Errore durante la conversione dell'oggetto Busta di risposta ["+tracciaRisposta.getBustaAsRawContent().getClass().getName()+"] in stringa";
  1780.             this.logger.error(msg);
  1781.         }
  1782.     }
  1783.     
  1784.     private void setProtocolloExtInfoRisposta(Transazione transactionDTO, PropertiesSerializator ps) {
  1785.         try{
  1786.             transactionDTO.setProtocolloExtInfoRisposta(ps.convertToDBColumnValue());
  1787.         }catch(Exception e){
  1788.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1789.             this.logger.error("Errore durante la conversione delle proprieta della Busta di risposta: "+e.getMessage(),e);
  1790.         }
  1791.     }
  1792.     
  1793.     private void setTokenInfo(Transazione transactionDTO, InformazioniToken informazioniToken) {
  1794.         try {
  1795.             transactionDTO.setTokenInfo(informazioniToken.toJson());
  1796.         }catch(Exception t) {
  1797.             this.logger.error("Serializzazione informazioni token non riuscita: "+t.getMessage(),t);
  1798.         }
  1799.     }
  1800.     private void setTokenInfo(Transazione transactionDTO, InformazioniNegoziazioneToken informazioniNegoziazioneToken, Transaction transaction) {
  1801.         try {
  1802.             InformazioniToken infoToken = new InformazioniToken(); // uso come aggregatore
  1803.             infoToken.setRetrievedToken(informazioniNegoziazioneToken);
  1804.             infoToken.setAa(transaction.getInformazioniAttributi());
  1805.             transactionDTO.setTokenInfo(infoToken.toJson());
  1806.         }catch(Exception t) {
  1807.             this.logger.error("Serializzazione informazioni attributi (aggregato insieme a client assertion) non riuscita: "+t.getMessage(),t);
  1808.         }
  1809.     }
  1810.     private void setTokenInfo(Transazione transactionDTO, Transaction transaction) {
  1811.         try {
  1812.             transactionDTO.setTokenInfo(transaction.getInformazioniAttributi().toJson());
  1813.         }catch(Exception t) {
  1814.             this.logger.error("Serializzazione informazioni attributi non riuscita: "+t.getMessage(),t);
  1815.         }
  1816.     }
  1817.     private void setTokenInfo(Transazione transactionDTO, InformazioniNegoziazioneToken informazioniNegoziazioneToken) {
  1818.         try {
  1819.             transactionDTO.setTokenInfo(informazioniNegoziazioneToken.toJson());
  1820.         }catch(Exception t) {
  1821.             this.logger.error("Serializzazione informazioni client assertion non riuscita: "+t.getMessage(),t);
  1822.         }
  1823.     }
  1824.     
  1825.     private void setTempiElaborazione(Transazione transactionDTO, Transaction transaction) {
  1826.         try {
  1827.             transactionDTO.setTempiElaborazione(TempiElaborazioneUtils.convertToDBValue(transaction.getTempiElaborazione()));
  1828.         }catch(Exception e) {
  1829.             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1830.             this.logger.error("TempiElaborazioneUtils.convertToDBValue failed: "+e.getMessage(),e);
  1831.         }
  1832.     }
  1833.     
  1834.     private static final MapKey<String> CREDENZIALI_MITTENTE_CLIENT_ADDRESS_RESOLVED = org.openspcoop2.utils.Map.newMapKey("CREDENZIALI_MITTENTE_CLIENT_ADDRESS_RESOLVED");
  1835.     private String getCredenzialiMittenteClientAddress(InformazioniTransazione info) {
  1836.         return (info!=null && info.getContext()!=null) ? (String) info.getContext().get(CREDENZIALI_MITTENTE_CLIENT_ADDRESS_RESOLVED) : null;
  1837.     }
  1838.     private void addCredenzialiMittenteClientAddress(InformazioniTransazione info, String cred) {
  1839.         if(info!=null && info.getContext()!=null) {
  1840.             info.getContext().put(CREDENZIALI_MITTENTE_CLIENT_ADDRESS_RESOLVED, cred);
  1841.         }
  1842.     }
  1843.     private void setAccordoInfoClientAddress(Transazione transactionDTO,
  1844.             RequestInfo requestInfo,
  1845.             IDSoggetto idDominio, InformazioniTransazione info, String idTransazione,
  1846.             TransazioniProcessTimes times, long timeStart, FaseTracciamento fase) {
  1847.         Object oIpAddressRemote = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CLIENT_IP_REMOTE_ADDRESS);
  1848.         if(oIpAddressRemote instanceof String){
  1849.             String ipAddress = (String)oIpAddressRemote;
  1850.             if(ipAddress.length()<=255){
  1851.                 transactionDTO.setSocketClientAddress(ipAddress);
  1852.             }
  1853.             else{
  1854.                 transactionDTO.setSocketClientAddress(ipAddress.substring(0, 250)+"...");
  1855.             }
  1856.         }
  1857.         Object oIpAddressTransport = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CLIENT_IP_TRANSPORT_ADDRESS);
  1858.         if(oIpAddressTransport instanceof String){
  1859.             String ipAddress = (String)oIpAddressTransport;
  1860.             if(ipAddress.length()<=255){
  1861.                 transactionDTO.setTransportClientAddress(ipAddress);
  1862.             }
  1863.             else{
  1864.                 transactionDTO.setTransportClientAddress(ipAddress.substring(0, 250)+"...");
  1865.             }
  1866.         }
  1867.         setAccordoInfoClientAddressCredenzialiMittente(transactionDTO,
  1868.                 requestInfo,
  1869.                 idDominio, info, idTransazione,
  1870.                 times, timeStart, fase);
  1871.     }
  1872.     private void setAccordoInfoClientAddressCredenzialiMittente(Transazione transactionDTO,
  1873.             RequestInfo requestInfo,
  1874.             IDSoggetto idDominio, InformazioniTransazione info, String idTransazione,
  1875.             TransazioniProcessTimes times, long timeStart, FaseTracciamento fase) {
  1876.         String conflict = "0";
  1877.         if(transactionDTO.getSocketClientAddress()!=null || transactionDTO.getTransportClientAddress()!=null) {
  1878.             String cred = getCredenzialiMittenteClientAddress(info);
  1879.             if(cred!=null && StringUtils.isNotEmpty(cred)) {
  1880.                 transactionDTO.setClientAddress(cred);
  1881.             }
  1882.             else {
  1883.                 try {
  1884.                     StringBuilder sbConflict = null;
  1885.                     if(times!=null) {
  1886.                         sbConflict = new StringBuilder();
  1887.                     }
  1888.                     CredenzialeMittente credClientAddress =GestoreAutenticazione.convertClientCredentialToCredenzialiMittenti(idDominio, info.getIdModulo(), idTransazione, 
  1889.                             transactionDTO.getSocketClientAddress(), transactionDTO.getTransportClientAddress(), 
  1890.                             null, fase.name()+".clientAddress",
  1891.                             sbConflict, requestInfo); 
  1892.                     if(sbConflict!=null && sbConflict.length()>0) {
  1893.                         conflict = sbConflict.toString();
  1894.                     }
  1895.                     if(credClientAddress!=null) {
  1896.                         cred = credClientAddress.getId()+"";
  1897.                         transactionDTO.setClientAddress(cred);
  1898.                         addCredenzialiMittenteClientAddress(info, cred);
  1899.                     }
  1900.                 }catch(Exception e) {
  1901.                     // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  1902.                     this.logger.error("Errore durante la scrittura dell'indice per la ricerca del client address: "+e.getMessage(),e);
  1903.                 }
  1904.             }
  1905.         }
  1906.         
  1907.         if(times!=null) {
  1908.             long timeEnd =  DateManager.getTimeMillis();
  1909.             long timeProcess = timeEnd-timeStart;
  1910.             times.fillTransactionDetails.add("ip-address:"+timeProcess+"/c"+conflict);
  1911.         }
  1912.         
  1913.     }
  1914.     
  1915.     private void setEventi(Transazione transactionDTO, Transaction transaction,
  1916.             OpenSPCoop2Properties op2Properties,
  1917.             RequestInfo requestInfo,
  1918.             IDSoggetto idDominio, InformazioniTransazione info, String idTransazione,
  1919.             TransazioniProcessTimes times, long timeStart, FaseTracciamento fase) throws CoreException {
  1920.         List<String> eventiGestione = new ArrayList<>();
  1921.         int count = 0;
  1922.         int maxLengthCredenziali = op2Properties.getTransazioniCredenzialiMittenteMaxLength()-AbstractCredenzialeList.PREFIX.length();
  1923.         
  1924.         if(op2Properties.isTransazioniHttpStatusAsEvent_outResponseCode() && transactionDTO.getCodiceRispostaUscita()!=null && 
  1925.                 !"".equals(transactionDTO.getCodiceRispostaUscita())) {
  1926.             String evento = CostantiPdD.PREFIX_HTTP_STATUS_CODE_OUT+transactionDTO.getCodiceRispostaUscita();
  1927.             String dbValue = AbstractCredenzialeList.getDBValue(evento);
  1928.             if(count+dbValue.length()<maxLengthCredenziali) {
  1929.                 eventiGestione.add( evento );
  1930.                 count = count+dbValue.length();
  1931.             }
  1932.             else {
  1933.                 // tronco gli eventi ai primi trovati. Sono troppi eventi successi sulla transazione.
  1934.             }
  1935.         }
  1936.         if(op2Properties.isTransazioniHttpStatusAsEvent_inResponseCode() && transactionDTO.getCodiceRispostaIngresso()!=null && 
  1937.                 !"".equals(transactionDTO.getCodiceRispostaIngresso())) {
  1938.             String evento = CostantiPdD.PREFIX_HTTP_STATUS_CODE_IN+transactionDTO.getCodiceRispostaIngresso();
  1939.             String dbValue = AbstractCredenzialeList.getDBValue(evento);
  1940.             if(count+dbValue.length()<maxLengthCredenziali) {
  1941.                 eventiGestione.add( evento );
  1942.                 count = count+dbValue.length();
  1943.             }
  1944.             else {
  1945.                 // tronco gli eventi ai primi trovati. Sono troppi eventi successi sulla transazione.
  1946.             }
  1947.         }
  1948.         if(op2Properties.isTransazioniTipoApiAsEvent() && transactionDTO.getTipoApi()>0) {
  1949.             String evento = CostantiPdD.PREFIX_API+transactionDTO.getTipoApi();
  1950.             String dbValue = AbstractCredenzialeList.getDBValue(evento);
  1951.             if(count+dbValue.length()<maxLengthCredenziali) {
  1952.                 eventiGestione.add( evento );
  1953.                 count = count+dbValue.length();
  1954.             }
  1955.             else {
  1956.                 // tronco gli eventi ai primi trovati. Sono troppi eventi successi sulla transazione.
  1957.             }
  1958.         }
  1959.         String consegneMultipleById = getConnettoriMultipli(info.getContext());
  1960.         if(op2Properties.isTransazioniConnettoriMultipliAsEvent() && consegneMultipleById!=null) {
  1961.             String evento = CostantiPdD.PREFIX_CONNETTORI_MULTIPLI+consegneMultipleById;
  1962.             String dbValue = AbstractCredenzialeList.getDBValue(evento);
  1963.             if(count+dbValue.length()<maxLengthCredenziali) {
  1964.                 eventiGestione.add( evento );
  1965.                 count = count+dbValue.length();
  1966.             }
  1967.             else {
  1968.                 // tronco gli eventi ai primi trovati. Sono troppi eventi successi sulla transazione.
  1969.             }
  1970.         }
  1971.         
  1972.         if(transaction.getEventiGestione()!=null && !transaction.getEventiGestione().isEmpty()){
  1973.             for (int i=0; i<transaction.getEventiGestione().size(); i++) {
  1974.                 String dbValue = AbstractCredenzialeList.getDBValue(transaction.getEventiGestione().get(i));
  1975.                 if(count+dbValue.length()<maxLengthCredenziali) {
  1976.                     eventiGestione.add( transaction.getEventiGestione().get(i) );
  1977.                     count = count+dbValue.length();
  1978.                 }
  1979.                 else {
  1980.                     // tronco gli eventi ai primi trovati. Sono troppi eventi successi sulla transazione.
  1981.                 }
  1982.             }
  1983.         }
  1984.         Object oEventoMax = info.getContext().getObject(CostantiControlloTraffico.PDD_CONTEXT_MAX_REQUEST_VIOLATED_EVENTO);
  1985.         if(oEventoMax instanceof String){
  1986.             String max = (String)oEventoMax;
  1987.             String dbValue = AbstractCredenzialeList.getDBValue(max);
  1988.             if(count+dbValue.length()<maxLengthCredenziali) {
  1989.                 eventiGestione.add( max );
  1990.                 /**count = count+dbValue.length();*/
  1991.             }
  1992.             else {
  1993.                 // tronco gli eventi ai primi trovati. Sono troppi eventi successi sulla transazione.
  1994.             }
  1995.         }
  1996.         String conflict = "0";
  1997.         if(!eventiGestione.isEmpty()){
  1998.             try {
  1999.                 StringBuilder sbConflict = null;
  2000.                 if(times!=null) {
  2001.                     sbConflict = new StringBuilder();
  2002.                 }
  2003.                 CredenzialeMittente credEventi = GestoreAutenticazione.convertEventiToCredenzialiMittenti(idDominio, info.getIdModulo(), idTransazione, eventiGestione, 
  2004.                         null, fase.name()+".eventi",
  2005.                         sbConflict, requestInfo);
  2006.                 if(sbConflict!=null && sbConflict.length()>0) {
  2007.                     conflict = sbConflict.toString();
  2008.                 }
  2009.                 if(credEventi!=null) {
  2010.                     transactionDTO.setEventiGestione(credEventi.getId()+"");
  2011.                 }
  2012.             }catch(Exception e) {
  2013.                 // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  2014.                 this.logger.error("Errore durante la definizione dell'indice per la ricerca degli eventi: "+e.getMessage(),e);
  2015.             }
  2016.         }
  2017.         if(times!=null) {
  2018.             long timeEnd =  DateManager.getTimeMillis();
  2019.             long timeProcess = timeEnd-timeStart;
  2020.             times.fillTransactionDetails.add("eventi:"+timeProcess+"/c"+conflict);
  2021.         }
  2022.     }
  2023.     
  2024.     
  2025.     private boolean isEsito(List<Integer> esiti, int esitoCheck) {
  2026.         for (int esito : esiti) {
  2027.             if(esitoCheck == esito){
  2028.                 return true;
  2029.             }
  2030.         }
  2031.         return false;
  2032.     }
  2033.     
  2034.     private long consegnaMultiplaProfiloSincrono(InformazioniTransazione info, IDSoggetto idDominio, String idTransazione,
  2035.             TransazioniProcessTimes times, long timeStart,
  2036.             boolean schedulaNotificheDopoConsegnaSincrona, MsgDiagnostico msgDiag, String nomePorta) {
  2037.         IOpenSPCoopState openspcoopState = null;
  2038.         try {
  2039.             OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  2040.             
  2041.             EJBUtilsMessaggioInConsegna messaggiInConsegna = null;
  2042.             Object oConnettoreConfig = info.getContext().getObject(CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_MESSAGGI_SPEDIRE );
  2043.             if (oConnettoreConfig instanceof EJBUtilsMessaggioInConsegna){
  2044.                 messaggiInConsegna = (EJBUtilsMessaggioInConsegna) oConnettoreConfig;
  2045.             }
  2046.             if(messaggiInConsegna==null) {
  2047.                 this.logger.error("Non è stato possibile gestire lo scheduling delle notifiche (connettori multipli): configurazione non disponibile");
  2048.             }
  2049.             else {
  2050.                 openspcoopState = new OpenSPCoopStateful();
  2051.                 openspcoopState.initResource(idDominio, info.getIdModulo(), idTransazione);
  2052.                 
  2053.                 if(times!=null) {
  2054.                     long timeEnd =  DateManager.getTimeMillis();
  2055.                     long timeProcess = timeEnd-timeStart;
  2056.                     times.fillTransactionDetails.add("async-send-getConnection:"+timeProcess);
  2057.                     
  2058.                     timeStart = DateManager.getTimeMillis();
  2059.                 }
  2060.                 
  2061.                 GestoreMessaggi msgRequest = new GestoreMessaggi(openspcoopState,true, messaggiInConsegna.getBusta().getID(),
  2062.                         org.openspcoop2.protocol.engine.constants.Costanti.INBOX,msgDiag,(PdDContext) info.getContext());
  2063.                 
  2064.                 if(schedulaNotificheDopoConsegnaSincrona) {
  2065.                     
  2066.                     RepositoryBuste repositoryBuste = null;
  2067.                     boolean spedizioneConsegnaContenuti = false; // sarà il timer a far partire effettivamente la spedizione
  2068.                     /**
  2069.                         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(), true, context.getProtocolFactory());
  2070.                      */
  2071.                         
  2072.                     // Devo rilasciare l'attendi esito
  2073.                     Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSql(op2Properties.isTransazioniDebug());
  2074.                     msgRequest.releaseAttesaEsiti(op2Properties.isTransazioniDebug(), log);
  2075.                     
  2076.                     EJBUtils.sendMessages(this.logger, msgDiag, openspcoopState, idTransazione, 
  2077.                             repositoryBuste, msgRequest, null, 
  2078.                             info.getProtocolFactory(), idDominio, nomePorta, messaggiInConsegna,
  2079.                             spedizioneConsegnaContenuti,
  2080.                             (PdDContext) info.getContext(),
  2081.                             ConfigurazionePdDManager.getInstance());
  2082.                     
  2083.                     if(times!=null) {
  2084.                         long timeEnd =  DateManager.getTimeMillis();
  2085.                         long timeProcess = timeEnd-timeStart;
  2086.                         times.fillTransactionDetails.add("async-send:"+timeProcess);
  2087.                         
  2088.                         timeStart = DateManager.getTimeMillis();
  2089.                     }
  2090.                     
  2091.                 }
  2092.                 else {
  2093.                     
  2094.                     for (String servizioApplicativo : messaggiInConsegna.getServiziApplicativi()) {
  2095.                         msgRequest.eliminaDestinatarioMessaggio(servizioApplicativo, null, messaggiInConsegna.getOraRegistrazioneMessaggio());
  2096.                     }
  2097.                 
  2098.                     if(times!=null) {
  2099.                         long timeEnd =  DateManager.getTimeMillis();
  2100.                         long timeProcess = timeEnd-timeStart;
  2101.                         times.fillTransactionDetails.add("async-send-del:"+timeProcess);
  2102.                         
  2103.                         timeStart = DateManager.getTimeMillis();
  2104.                     }
  2105.                 }
  2106.             }
  2107.             
  2108.         }catch(Exception e) {
  2109.             this.logger.error("Non è stato possibile gestire lo scheduling delle notifiche (connettori multipli): "+e.getMessage(), e);
  2110.         }
  2111.         finally {
  2112.             try{
  2113.                 if(openspcoopState!=null && !openspcoopState.resourceReleased()){
  2114.                     openspcoopState.commit();
  2115.                     
  2116.                     if(times!=null) {
  2117.                         long timeEnd =  DateManager.getTimeMillis();
  2118.                         long timeProcess = timeEnd-timeStart;
  2119.                         times.fillTransactionDetails.add("async-send-commit:"+timeProcess);
  2120.                         
  2121.                         timeStart = DateManager.getTimeMillis();
  2122.                     }
  2123.                     
  2124.                     openspcoopState.releaseResource();
  2125.                     
  2126.                     if(times!=null) {
  2127.                         long timeEnd =  DateManager.getTimeMillis();
  2128.                         long timeProcess = timeEnd-timeStart;
  2129.                         times.fillTransactionDetails.add("async-send-finish:"+timeProcess);
  2130.                         
  2131.                         timeStart = DateManager.getTimeMillis();
  2132.                     }
  2133.                 }
  2134.             }catch(Exception e){
  2135.                 // ignore
  2136.             }
  2137.         }
  2138.         
  2139.         return timeStart;
  2140.     }
  2141.     
  2142.     private long saveTransactionContext(String identificativoSaveTransactionContext, InformazioniTransazione info, IDSoggetto idDominio, String idTransazione,
  2143.             TransazioniProcessTimes times, long timeStart,
  2144.             MsgDiagnostico msgDiag) {
  2145.         IOpenSPCoopState openspcoopState = null;
  2146.         try {
  2147.             openspcoopState = new OpenSPCoopStateful();
  2148.             openspcoopState.initResource(idDominio, info.getIdModulo(), idTransazione);
  2149.                 
  2150.             if(times!=null) {
  2151.                 long timeEnd =  DateManager.getTimeMillis();
  2152.                 long timeProcess = timeEnd-timeStart;
  2153.                 times.fillTransactionDetails.add("async-send-saveTransactionContext:"+timeProcess);
  2154.                     
  2155.                 timeStart = DateManager.getTimeMillis();
  2156.             }
  2157.                 
  2158.             GestoreMessaggi msgRequest = new GestoreMessaggi(openspcoopState,true, identificativoSaveTransactionContext,
  2159.                     org.openspcoop2.protocol.engine.constants.Costanti.INBOX,msgDiag,(PdDContext) info.getContext());
  2160.                 
  2161.             msgRequest.registraTransactionContext_statelessEngine(identificativoSaveTransactionContext, info.getContext());
  2162.                                 
  2163.             if(times!=null) {
  2164.                 long timeEnd =  DateManager.getTimeMillis();
  2165.                 long timeProcess = timeEnd-timeStart;
  2166.                 times.fillTransactionDetails.add("async-send-saveTransactionContext-saved:"+timeProcess);
  2167.                 
  2168.                 timeStart = DateManager.getTimeMillis();
  2169.             }
  2170.             
  2171.         }catch(Exception e) {
  2172.             this.logger.error("Non è stato possibile salvare il contesto della transazione per le notifiche (connettori multipli): "+e.getMessage(), e);
  2173.         }
  2174.         finally {
  2175.             try{
  2176.                 if(openspcoopState!=null && !openspcoopState.resourceReleased()){
  2177.                     openspcoopState.commit();
  2178.                     
  2179.                     if(times!=null) {
  2180.                         long timeEnd =  DateManager.getTimeMillis();
  2181.                         long timeProcess = timeEnd-timeStart;
  2182.                         times.fillTransactionDetails.add("async-send-saveTransactionContext-commit:"+timeProcess);
  2183.                         
  2184.                         timeStart = DateManager.getTimeMillis();
  2185.                     }
  2186.                     
  2187.                     openspcoopState.releaseResource();
  2188.                     
  2189.                     if(times!=null) {
  2190.                         long timeEnd =  DateManager.getTimeMillis();
  2191.                         long timeProcess = timeEnd-timeStart;
  2192.                         times.fillTransactionDetails.add("async-send-saveTransactionContext-finish:"+timeProcess);
  2193.                         
  2194.                         timeStart = DateManager.getTimeMillis();
  2195.                     }
  2196.                 }
  2197.             }catch(Exception e){
  2198.                 // ignore
  2199.             }
  2200.         }
  2201.         
  2202.         return timeStart;
  2203.     }
  2204.     
  2205.     
  2206.     
  2207.     public static Busta convertToBusta(Transazione transazioneDTO) {
  2208.         Busta busta = new Busta(transazioneDTO.getProtocollo());
  2209.         
  2210.         busta.setTipoMittente(transazioneDTO.getTipoSoggettoFruitore());
  2211.         busta.setMittente(transazioneDTO.getNomeSoggettoFruitore());
  2212.         busta.setIdentificativoPortaMittente(transazioneDTO.getIdportaSoggettoFruitore());
  2213.         busta.setIndirizzoMittente(transazioneDTO.getIndirizzoSoggettoFruitore());
  2214.         
  2215.         busta.setTipoDestinatario(transazioneDTO.getTipoSoggettoErogatore());
  2216.         busta.setDestinatario(transazioneDTO.getNomeSoggettoErogatore());
  2217.         busta.setIdentificativoPortaDestinatario(transazioneDTO.getIdportaSoggettoErogatore());
  2218.         busta.setIndirizzoDestinatario(transazioneDTO.getIndirizzoSoggettoErogatore());
  2219.         
  2220.         busta.setTipoServizio(transazioneDTO.getTipoServizio());
  2221.         busta.setServizio(transazioneDTO.getNomeServizio());
  2222.         busta.setVersioneServizio(transazioneDTO.getVersioneServizio());
  2223.         busta.setAzione(transazioneDTO.getAzione());
  2224.         
  2225.         busta.setID(transazioneDTO.getIdMessaggioRichiesta());
  2226.         busta.setRiferimentoMessaggio(transazioneDTO.getIdMessaggioRisposta());
  2227.         
  2228.         busta.setCollaborazione(transazioneDTO.getIdCollaborazione());
  2229.         
  2230.         busta.setServizioApplicativoFruitore(transazioneDTO.getServizioApplicativoFruitore());
  2231.         busta.setServizioApplicativoErogatore(transazioneDTO.getServizioApplicativoErogatore());
  2232.         
  2233.         return busta;
  2234.     }
  2235. }
Created with JaCoCo 0.8.8.202204050719