TransazioneUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.pdd.logger.transazioni;

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

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

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

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

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

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

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

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

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

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

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

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

  274.             EsitiProperties esitiProperties = EsitiProperties.getInstance(this.logger, protocolFactory);
  275.                         
  276.             // ** Consegna Multipla **
  277.             // 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
  278.             int connettoriMultipli = getNumeroConnettoriMultipli(info.getContext());
  279.             boolean consegnaMultipla = isConsegnaMultipla(connettoriMultipli);
  280.             
  281.             ConfigurazioneMultiDeliver configurazioneConsegnaMultiplaProfiloSincrono = null;
  282.             if(FaseTracciamento.POST_OUT_RESPONSE.equals(fase) && consegnaMultipla) {
  283.                 Object oConnettoreSync = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA );
  284.                 if (oConnettoreSync instanceof Boolean){
  285.                     consegnaMultiplaProfiloSincrono = (Boolean) oConnettoreSync;
  286.                 }
  287.                 else if (oConnettoreSync instanceof String){
  288.                     consegnaMultiplaProfiloSincrono = Boolean.valueOf( (String) oConnettoreSync );
  289.                 }
  290.                 
  291.                 if(consegnaMultiplaProfiloSincrono) {
  292.                     Object oConnettoreSyncConfig = info.getContext().getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA_CONFIGURAZIONE );
  293.                     if (oConnettoreSyncConfig instanceof ConfigurazioneMultiDeliver){
  294.                         configurazioneConsegnaMultiplaProfiloSincrono = (ConfigurazioneMultiDeliver) oConnettoreSyncConfig;
  295.                     }
  296.                 }
  297.             }

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

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


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

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

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

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


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

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

  509.             // ** Tempi di latenza **

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

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


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

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

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

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


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

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

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


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


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


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

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

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

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

  664.             }


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

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

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

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


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

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


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

  1543.                 }
  1544.                 else {
  1545.                     OpenSPCoop2RestMessage<?> restMsg = info.getResponse().castAsRest();
  1546.                     if(restMsg.isProblemDetailsForHttpApis_RFC7807() || MessageRole.FAULT.equals(restMsg.getMessageRole())) {
  1547.                         switch (restMsg.getMessageType()) {
  1548.                         case XML:
  1549.                             
  1550.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1551.                             restMsg.writeTo(bout, false);
  1552.                             bout.flush();
  1553.                             bout.close();
  1554.                             
  1555.                             Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioni(op2Properties.isTransazioniDebug());
  1556.                             if(op2Properties.isTransazioniFaultPrettyPrint()){
  1557.                                 // Faccio una pretty-print: potevo fare anche direttamente passando il fault a metodo prettyPrint,
  1558.                                 // Pero' non veniva stampato correttamente il SOAPFault. Mi appoggio allora a SoapUtils.
  1559.                                 /**byte [] content = org.openspcoop2.message.soap.TunnelSoapUtils.sbustamentoMessaggio(context.getMessaggio());*/
  1560.                                 byte [] content = bout.toByteArray();
  1561.                                 fault = DumpUtility.toString(MessageXMLUtils.getInstance(restMsg.getFactory()).newDocument(content), log, info.getResponse());
  1562.                                 /**System.out.println("IMPOSTATO FAULT IN TRANSACTION ["+fault+"]");*/
  1563.                             }
  1564.                             else{
  1565.                                 
  1566.                                 fault = bout.toString();
  1567.                             }
  1568.                             
  1569.                             formatoFault = restMsg.getMessageType().name();
  1570.                             
  1571.                             break;
  1572.                             
  1573.                         case JSON:
  1574.                             
  1575.                             bout = new ByteArrayOutputStream();
  1576.                             restMsg.writeTo(bout, false);
  1577.                             bout.flush();
  1578.                             bout.close();
  1579.                             
  1580.                             if(op2Properties.isTransazioniFaultPrettyPrint()){
  1581.                                 
  1582.                                 JSONUtils jsonUtils = JSONUtils.getInstance(true);
  1583.                                 byte [] content = bout.toByteArray();
  1584.                                 JsonNode jsonNode = jsonUtils.getAsNode(content);
  1585.                                 fault = jsonUtils.toString(jsonNode);
  1586.                                 
  1587.                             }
  1588.                             else{
  1589.                                 
  1590.                                 fault = bout.toString();
  1591.                             }
  1592.                             
  1593.                             formatoFault = restMsg.getMessageType().name();
  1594.                             
  1595.                             break;

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