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;

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

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

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

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

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

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

  220.         boolean richiestaDuplicata = false;
  221.         ProfiloDiCollaborazione profiloCollaborazioneBustaTracciaRichiesta = null;
  222.         String profiloCollaborazioneValueBustaTracciaRichiesta = null;
  223.         if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null){
  224.             richiestaDuplicata = transaction.containsIdProtocolloDuplicato(tracciaRichiesta.getBusta().getID());
  225.             if(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()!=null){
  226.                 profiloCollaborazioneBustaTracciaRichiesta = tracciaRichiesta.getBusta().getProfiloDiCollaborazione();
  227.                 profiloCollaborazioneValueBustaTracciaRichiesta = tracciaRichiesta.getBusta().getProfiloDiCollaborazioneValue();
  228.             }
  229.         }
  230.         boolean rispostaDuplicata = false;
  231.         if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null){
  232.             rispostaDuplicata = transaction.containsIdProtocolloDuplicato(tracciaRisposta.getBusta().getID());
  233.         }

  234.         boolean schedulaNotificheDopoConsegnaSincrona = false;
  235.         boolean consegnaMultiplaProfiloSincrono = false;
  236.         MsgDiagnostico msgDiag = null;
  237.         String idTransazione = null;
  238.         String nomePorta = null;
  239.        
  240.         String identificativoSaveTransactionContext = null;
  241.        
  242.         long timeStart = -1;
  243.         try {

  244.             if(times!=null) {
  245.                 times.fillTransactionDetails = new ArrayList<>();
  246.                 timeStart = DateManager.getTimeMillis();
  247.             }
  248.            
  249.             IProtocolFactory<?> protocolFactory = info.getProtocolFactory();

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

  251.             RequestInfo requestInfo = null;
  252.             if(info.getContext()!=null && info.getContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  253.                 requestInfo = (RequestInfo) info.getContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  254.             }

  255.             if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase) &&
  256.                     info.getContext()!=null && info.getContext().containsKey(CostantiPdD.SALVA_CONTESTO_IDENTIFICATIVO_MESSAGGIO_NOTIFICA)) {
  257.                 identificativoSaveTransactionContext = (String) info.getContext().getObject(CostantiPdD.SALVA_CONTESTO_IDENTIFICATIVO_MESSAGGIO_NOTIFICA);
  258.             }
  259.            
  260.             Transazione transactionDTO = transazioneDaAggiornare!=null ? transazioneDaAggiornare : new Transazione();

  261.             EsitiProperties esitiProperties = EsitiProperties.getInstance(this.logger, protocolFactory);
  262.                        
  263.             // ** Consegna Multipla **
  264.             // 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
  265.             int connettoriMultipli = getNumeroConnettoriMultipli(info.getContext());
  266.             boolean consegnaMultipla = isConsegnaMultipla(connettoriMultipli);
  267.            
  268.             ConfigurazioneMultiDeliver configurazioneConsegnaMultiplaProfiloSincrono = null;
  269.             if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase) && consegnaMultipla) {
  270.                 Object oConnettoreSync = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA );
  271.                 if (oConnettoreSync instanceof Boolean){
  272.                     consegnaMultiplaProfiloSincrono = (Boolean) oConnettoreSync;
  273.                 }
  274.                 else if (oConnettoreSync instanceof String){
  275.                     consegnaMultiplaProfiloSincrono = Boolean.valueOf( (String) oConnettoreSync );
  276.                 }
  277.                
  278.                 if(consegnaMultiplaProfiloSincrono) {
  279.                     Object oConnettoreSyncConfig = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA_CONFIGURAZIONE );
  280.                     if (oConnettoreSyncConfig instanceof ConfigurazioneMultiDeliver){
  281.                         configurazioneConsegnaMultiplaProfiloSincrono = (ConfigurazioneMultiDeliver) oConnettoreSyncConfig;
  282.                     }
  283.                 }
  284.             }

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

  328.             if(times!=null) {
  329.                 long timeEnd =  DateManager.getTimeMillis();
  330.                 long timeProcess = timeEnd-timeStart;
  331.                 times.fillTransactionDetails.add("connettoreMultipli:"+timeProcess);
  332.                
  333.                 timeStart = DateManager.getTimeMillis();
  334.             }
  335.            
  336.            
  337.             // ** Identificativo di transazione **
  338.             if (info.getContext().getObject(Costanti.ID_TRANSAZIONE)!=null){
  339.                 idTransazione = ((String)info.getContext().getObject(Costanti.ID_TRANSAZIONE));
  340.                 transactionDTO.setIdTransazione(idTransazione);
  341.             }else
  342.                 throw new HandlerException("ID Transazione Assente");


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

  440.            
  441.             // ***** NOTA: tutte le informazioni sopra devono essere "gestite in UPDATE" nel metodo TracciamentoManager.registraTransazione
  442.            
  443.             /*** ESCO SE SONO IN FASE POST OUT DI AGGIORNAMENTO DEI DATI */
  444.            
  445.             if(transazioneDaAggiornare!=null) {
  446.                 return transactionDTO; // nell'oggetto ci sono già tutti i dati eccetto l'esito corretto
  447.             }
  448.            
  449.            
  450.            
  451.            
  452.            

  453.             // ** stato **
  454.             // Stato di una transazione (marca la transazione con uno stato tramite la configurazione plugin)
  455.             if(transaction.getStato()!=null) {
  456.                 transactionDTO.setStato(transaction.getStato());    
  457.             }

  458.             // ** Ruolo transazione **
  459.             // invocazioneOneway (1)
  460.             // invocazioneSincrona (2)
  461.             // invocazioneAsincronaSimmetrica (3)
  462.             // rispostaAsincronaSimmetrica (4)
  463.             // invocazioneAsincronaAsimmetrica (5)
  464.             // richiestaStatoAsincronaAsimmetrica (6)
  465.             // integrationManager (7)
  466.             /**System.out.println("SCENARIO DI COOPERAZIONE ["+transaction.getScenarioCooperazione()+"]");*/
  467.             RuoloTransazione ruolo = RuoloTransazione.getEnumConstantFromOpenSPCoopValue(transaction.getScenarioCooperazione());
  468.             if(ruolo!=null)
  469.                 transactionDTO.setRuoloTransazione(ruolo.getValoreAsInt());
  470.             else
  471.                 transactionDTO.setRuoloTransazione(-1);


  472.             // ** protocollo **
  473.             transactionDTO.setProtocollo(info.getProtocolFactory().getProtocol());

  474.            
  475.             // ** header HTTP **
  476.             if(transaction.getRequestInfo()!=null &&
  477.                     transaction.getRequestInfo().getProtocolContext()!=null &&
  478.                     transaction.getRequestInfo().getProtocolContext().getRequestType()!=null) {
  479.                 transactionDTO.setTipoRichiesta(transaction.getRequestInfo().getProtocolContext().getRequestType());
  480.             }
  481.             // ** Codice Risposta Ingresso **
  482.             transactionDTO.setCodiceRispostaIngresso(transaction.getCodiceTrasportoRichiesta());
  483.             // ** Codice Risposta Uscita **
  484.             // Gestite prima per la doppia fase, come per l'esito

  485.             // ** Tempi di latenza **

  486.             // Se data_accettazione_richiesta è null viene impostata a CURRENT_TIMESTAMP
  487.             TransazioneUtilities.setDataAccettazioneRichiesta(transactionDTO, info, transaction);
  488.            
  489.             // Se data_ingresso_richiesta è null viene impostata a CURRENT_TIMESTAMP
  490.             TransazioneUtilities.setDataIngressoRichiesta(op2Properties, transactionDTO, info, transaction);
  491.            
  492.             // data_ingresso_richiesta_stream
  493.             TransazioneUtilities.setDataIngressoRichiestaStream(transactionDTO, info);
  494.            
  495.             // data_uscita_richiesta si imposta se e' diversa da null
  496.             TransazioneUtilities.setDataUscitaRichiesta(transactionDTO, fase, transaction);

  497.             // data_accettazione_risposta
  498.             TransazioneUtilities.setDataAccettazioneRisposta(transactionDTO, fase, transaction);
  499.                
  500.             // data_ingresso_risposta
  501.             TransazioneUtilities.setDataIngressoRisposta(op2Properties, transactionDTO, fase, transaction);
  502.                
  503.             // data_ingresso_risposta_stream
  504.             TransazioneUtilities.setDataIngressoRispostaStream(transactionDTO, info, fase);
  505.            
  506.             // data_uscita_risposta
  507.             // data_uscita_risposta_stream
  508.             // Gestite prima per la doppia fase, come per l'esito


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

  511.             // dimensione_ingresso_richiesta
  512.             TransazioneUtilities.setRichiestaIngressoBytes(transactionDTO, info, transaction, fase);

  513.             // dimensione_uscita_richiesta
  514.             TransazioneUtilities.setRichiestaUscitaBytes(transactionDTO, info, transaction, fase);

  515.             // dimensione_ingresso_risposta
  516.             // dimensione_uscita_risposta
  517.             // Gestite prima per la doppia fase, come per l'esito: faccio una ulteriore verifica se siamo nell'ultima fase e sono null
  518.             if(transactionDTO.getRispostaIngressoBytes()==null &&
  519.                     FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  520.                 transactionDTO.setRispostaIngressoBytes(readDimensioneFromDumpBinario(TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO, transaction));
  521.             }
  522.             if(transactionDTO.getRispostaUscitaBytes()==null &&
  523.                     FaseTracciamento.POST_OUT_RESPONSE.equals(fase)) {
  524.                 transactionDTO.setRispostaUscitaBytes(readDimensioneFromDumpBinario(TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO, transaction));
  525.             }


  526.             // ** Dati Pdd **
  527.             transactionDTO.setPddCodice(idDominio.getCodicePorta());
  528.             transactionDTO.setPddTipoSoggetto(idDominio.getTipo());
  529.             transactionDTO.setPddNomeSoggetto(idDominio.getNome());
  530.             if(info.getTipoPorta()!=null){
  531.                 transactionDTO.setPddRuolo(PddRuolo.toEnumConstant(info.getTipoPorta().getTipo()));
  532.             }

  533.            
  534.             if(times!=null) {
  535.                 long timeEnd =  DateManager.getTimeMillis();
  536.                 long timeProcess = timeEnd-timeStart;
  537.                 times.fillTransactionDetails.add("baseContext:"+timeProcess);
  538.                
  539.                 timeStart = DateManager.getTimeMillis();
  540.             }
  541.            

  542.             // ** FAULT **
  543.             // Gestite prima per la doppia fase, come per l'esito
  544.            
  545.            
  546.             if(times!=null) {
  547.                 long timeEnd =  DateManager.getTimeMillis();
  548.                 long timeProcess = timeEnd-timeStart;
  549.                 times.fillTransactionDetails.add("fault:"+timeProcess);
  550.                
  551.                 timeStart = DateManager.getTimeMillis();
  552.             }


  553.             // ** Soggetto Fruitore **
  554.             if (info.getProtocollo()!=null && info.getProtocollo().getFruitore()!=null) {
  555.                 transactionDTO.setTipoSoggettoFruitore(info.getProtocollo().getFruitore().getTipo());
  556.                 transactionDTO.setNomeSoggettoFruitore(info.getProtocollo().getFruitore().getNome());
  557.                 transactionDTO.setIdportaSoggettoFruitore(info.getProtocollo().getFruitore().getCodicePorta());
  558.                 transactionDTO.setIndirizzoSoggettoFruitore(info.getProtocollo().getIndirizzoFruitore());
  559.             }
  560.             else if(transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getFruitore()!=null) {
  561.                 transactionDTO.setTipoSoggettoFruitore(transaction.getRequestInfo().getFruitore().getTipo());
  562.                 transactionDTO.setNomeSoggettoFruitore(transaction.getRequestInfo().getFruitore().getNome());
  563.                 transactionDTO.setIdportaSoggettoFruitore(transaction.getRequestInfo().getFruitore().getCodicePorta());
  564.             }


  565.             // ** Soggetto Erogatore **
  566.             if (info.getProtocollo()!=null && info.getProtocollo().getErogatore()!=null) {
  567.                 transactionDTO.setTipoSoggettoErogatore(info.getProtocollo().getErogatore().getTipo());
  568.                 transactionDTO.setNomeSoggettoErogatore(info.getProtocollo().getErogatore().getNome());
  569.                 transactionDTO.setIdportaSoggettoErogatore(info.getProtocollo().getErogatore().getCodicePorta());
  570.                 transactionDTO.setIndirizzoSoggettoErogatore(info.getProtocollo().getIndirizzoErogatore());
  571.             }
  572.             else if(transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null &&
  573.                     transaction.getRequestInfo().getIdServizio().getSoggettoErogatore()!=null) {
  574.                 transactionDTO.setTipoSoggettoErogatore(transaction.getRequestInfo().getIdServizio().getSoggettoErogatore().getTipo());
  575.                 transactionDTO.setNomeSoggettoErogatore(transaction.getRequestInfo().getIdServizio().getSoggettoErogatore().getNome());
  576.                 transactionDTO.setIdportaSoggettoErogatore(transaction.getRequestInfo().getIdServizio().getSoggettoErogatore().getCodicePorta());
  577.             }


  578.             // ** Identificativi Messaggi **
  579.             if (info.getProtocollo()!=null) {

  580.                 // Richiesta
  581.                 String idMessaggioRichiesta = info.getProtocollo().getIdRichiesta();
  582.                 if(
  583.                         //TipoPdD.APPLICATIVA.equals(context.getTipoPorta()) &&
  584.                         CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol()) &&
  585.                         tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getID()!=null &&
  586.                         !tracciaRichiesta.getBusta().getID().equals(idMessaggioRichiesta)) {
  587.                     // modificato durante la gestione della validazione semantica
  588.                     idMessaggioRichiesta = tracciaRichiesta.getBusta().getID();
  589.                 }
  590.                 Timestamp dateInternaIdProtocolloRichiesta = null;
  591.                 if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory) &&
  592.                     idMessaggioRichiesta!=null){
  593.                     dateInternaIdProtocolloRichiesta = DateUtility.getTimestampIntoIdProtocollo(this.logger,protocolBustaBuilder,idMessaggioRichiesta);
  594.                 }

  595.                 // Risposta
  596.                 String idMessaggioRisposta = null;
  597.                 Timestamp dateInternaIdProtocolloRisposta = null;
  598.                 // Nel contesto l'id di riposta puo' essere null o un valore generato per la confermaPresa in carico.
  599.                 // Se e' presenta una busta di risposta nella transazione deve pero' finire l'id di protocollo della busta.
  600.                 if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null && tracciaRisposta.getBusta().getID()!=null){
  601.                     idMessaggioRisposta = tracciaRisposta.getBusta().getID();
  602.                     if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  603.                         dateInternaIdProtocolloRisposta = DateUtility.getTimestampIntoIdProtocollo(this.logger,protocolBustaBuilder,idMessaggioRisposta);
  604.                     }
  605.                 }
  606.                 else if(info.getProtocollo().getIdRisposta()!=null){
  607.                     idMessaggioRisposta = info.getProtocollo().getIdRisposta();
  608.                     if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  609.                         dateInternaIdProtocolloRisposta =  DateUtility.getTimestampIntoIdProtocollo(this.logger,protocolBustaBuilder,idMessaggioRisposta);
  610.                     }
  611.                 }

  612.                 // Set
  613.                 transactionDTO.setIdMessaggioRichiesta(idMessaggioRichiesta);
  614.                 transactionDTO.setIdMessaggioRisposta(idMessaggioRisposta);
  615.                 if(op2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  616.                     transactionDTO.setDataIdMsgRichiesta(dateInternaIdProtocolloRichiesta);
  617.                     transactionDTO.setDataIdMsgRisposta(dateInternaIdProtocolloRisposta);
  618.                 }

  619.             }


  620.             // ** altre informazioni **
  621.             if (info.getProtocollo()!=null && info.getProtocollo().getProfiloCollaborazione()!=null) {
  622.                 transactionDTO.setProfiloCollaborazioneOp2(info.getProtocollo().getProfiloCollaborazione().getEngineValue());      
  623.             }
  624.             else if(profiloCollaborazioneBustaTracciaRichiesta!=null){
  625.                 transactionDTO.setProfiloCollaborazioneOp2(profiloCollaborazioneBustaTracciaRichiesta.getEngineValue());
  626.             }
  627.             if (info.getProtocollo()!=null && info.getProtocollo().getProfiloCollaborazioneValue()!=null) {
  628.                 transactionDTO.setProfiloCollaborazioneProt(info.getProtocollo().getProfiloCollaborazioneValue());
  629.             }
  630.             else if(profiloCollaborazioneValueBustaTracciaRichiesta!=null){
  631.                 transactionDTO.setProfiloCollaborazioneProt(profiloCollaborazioneValueBustaTracciaRichiesta);
  632.             }
  633.             IDAccordo idAccordo = null;
  634.             if (info.getProtocollo()!=null){

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

  636.                 idAccordo = info.getProtocollo().getIdAccordo();
  637.                 if(idAccordo!=null){
  638.                     transactionDTO.setUriAccordoServizio(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  639.                 }

  640.                 transactionDTO.setTipoServizio(info.getProtocollo().getTipoServizio());
  641.                 transactionDTO.setNomeServizio(info.getProtocollo().getServizio());
  642.                 if(info.getProtocollo().getVersioneServizio()!=null && info.getProtocollo().getVersioneServizio().intValue()>0) {
  643.                     transactionDTO.setVersioneServizio(info.getProtocollo().getVersioneServizio());
  644.                 }
  645.                 transactionDTO.setAzione(info.getProtocollo().getAzione());
  646.             }
  647.             if(transactionDTO.getTipoServizio()==null &&
  648.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null)
  649.                 ){
  650.                 transactionDTO.setTipoServizio(transaction.getRequestInfo().getIdServizio().getTipo());
  651.             }
  652.             if(transactionDTO.getNomeServizio()==null &&
  653.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null)
  654.                 ){
  655.                 transactionDTO.setNomeServizio(transaction.getRequestInfo().getIdServizio().getNome());
  656.             }
  657.             if(
  658.                 (info.getProtocollo()==null || info.getProtocollo().getVersioneServizio()==null || info.getProtocollo().getVersioneServizio().intValue()<=0)
  659.                 &&
  660.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null)
  661.                 ){
  662.                 transactionDTO.setVersioneServizio(transaction.getRequestInfo().getIdServizio().getVersione());
  663.             }
  664.             if(transactionDTO.getAzione()==null &&
  665.                 (transaction!=null && transaction.getRequestInfo()!=null && transaction.getRequestInfo().getIdServizio()!=null)
  666.                 ){
  667.                 transactionDTO.setAzione(transaction.getRequestInfo().getIdServizio().getAzione());
  668.             }
  669.            
  670.             if(times!=null) {
  671.                 long timeEnd =  DateManager.getTimeMillis();
  672.                 long timeProcess = timeEnd-timeStart;
  673.                 times.fillTransactionDetails.add("identificativi:"+timeProcess);
  674.                
  675.                 timeStart = DateManager.getTimeMillis();
  676.             }
  677.            
  678.             RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(info.getStato());
  679.             if(idAccordo==null &&
  680.                 (transactionDTO.getNomeServizio()!=null && transactionDTO.getTipoServizio()!=null &&
  681.                 transactionDTO.getNomeSoggettoErogatore()!=null && transactionDTO.getTipoSoggettoErogatore()!=null)
  682.                 ) {
  683.                 idAccordo = getIdAccordo(transactionDTO, registroServiziManager, requestInfo);
  684.             }
  685.            
  686.             if(times!=null) {
  687.                 long timeEnd =  DateManager.getTimeMillis();
  688.                 long timeProcess = timeEnd-timeStart;
  689.                 times.fillTransactionDetails.add("id-api:"+timeProcess);
  690.                
  691.                 timeStart = DateManager.getTimeMillis();
  692.             }
  693.            
  694.             if(idAccordo!=null) {
  695.                 setAccordoInfo(idAccordo, transactionDTO,
  696.                         op2Properties, registroServiziManager, requestInfo,
  697.                         idDominio, info, idTransazione,
  698.                         times, timeStart, fase);
  699.                 if(times!=null) {
  700.                     timeStart = DateManager.getTimeMillis();
  701.                 }
  702.             }


  703.             // ** Identificativo asincrono se utilizzato come riferimento messaggio nella richiesta (2 fase asincrona) **
  704.                
  705.             if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null &&
  706.                     (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) ) ){
  707.                 Busta busta = tracciaRichiesta.getBusta();
  708.                 if(busta.getRiferimentoMessaggio()!=null){
  709.                     // Seconda fase dei profili asincroni
  710.                     transactionDTO.setIdAsincrono(busta.getRiferimentoMessaggio());
  711.                 }
  712.                 else{
  713.                     transactionDTO.setIdAsincrono(busta.getCollaborazione());
  714.                 }
  715.             }
  716.             if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null &&
  717.                     ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) ){
  718.                 Busta busta = tracciaRichiesta.getBusta();
  719.                 if(busta!=null){
  720.                     transactionDTO.setTipoServizioCorrelato(busta.getTipoServizioCorrelato());
  721.                     transactionDTO.setNomeServizioCorrelato(busta.getServizioCorrelato());
  722.                 }
  723.             }
  724.             else if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null &&
  725.                     ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(tracciaRisposta.getBusta().getProfiloDiCollaborazione()) ){
  726.                 Busta busta = tracciaRisposta.getBusta();
  727.                 if(busta!=null){
  728.                     transactionDTO.setTipoServizioCorrelato(busta.getTipoServizioCorrelato());
  729.                     transactionDTO.setNomeServizioCorrelato(busta.getServizioCorrelato());
  730.                 }
  731.             }
  732.            
  733.             if(transactionDTO.getIdCollaborazione()==null) {
  734.                 if(tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getCollaborazione()!=null) {
  735.                     transactionDTO.setIdCollaborazione(tracciaRichiesta.getBusta().getCollaborazione());
  736.                 }
  737.                 else if(tracciaRisposta!=null && tracciaRisposta.getBusta()!=null && tracciaRisposta.getBusta().getCollaborazione()!=null) {
  738.                     transactionDTO.setIdCollaborazione(tracciaRisposta.getBusta().getCollaborazione());
  739.                 }
  740.             }
  741.            
  742.             boolean asincrono = tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null &&
  743.                     (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(tracciaRichiesta.getBusta().getProfiloDiCollaborazione()) );
  744.             if(!asincrono) {
  745.                 if(transactionDTO.getIdAsincrono()==null &&
  746.                     (tracciaRichiesta!=null && tracciaRichiesta.getBusta()!=null && tracciaRichiesta.getBusta().getRiferimentoMessaggio()!=null)
  747.                     ){
  748.                     transactionDTO.setIdAsincrono(tracciaRichiesta.getBusta().getRiferimentoMessaggio());
  749.                 }
  750.                 if(transactionDTO.getIdAsincrono()==null &&
  751.                     (info.getProtocollo()!=null)
  752.                     ){
  753.                     transactionDTO.setIdAsincrono(info.getProtocollo().getRiferimentoAsincrono());
  754.                 }
  755.             }
  756.            
  757.             if(times!=null) {
  758.                 long timeEnd =  DateManager.getTimeMillis();
  759.                 long timeProcess = timeEnd-timeStart;
  760.                 times.fillTransactionDetails.add("async:"+timeProcess);
  761.                
  762.                 timeStart = DateManager.getTimeMillis();
  763.             }

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


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

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

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