MsgDiagnostico.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.  */




  24. package org.openspcoop2.pdd.logger;

  26. import java.sql.Connection;
  27. import java.util.Date;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.apache.logging.log4j.Level;
  33. import org.openspcoop2.core.config.PortaApplicativa;
  34. import org.openspcoop2.core.config.PortaDelegata;
  35. import org.openspcoop2.core.config.constants.Severita;
  36. import org.openspcoop2.core.constants.Costanti;
  37. import org.openspcoop2.core.constants.TipoPdD;
  38. import org.openspcoop2.core.id.IDPortaApplicativa;
  39. import org.openspcoop2.core.id.IDPortaDelegata;
  40. import org.openspcoop2.core.id.IDServizio;
  41. import org.openspcoop2.core.id.IDSoggetto;
  42. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  43. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  44. import org.openspcoop2.message.constants.ServiceBinding;
  45. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  46. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  47. import org.openspcoop2.pdd.core.CostantiPdD;
  48. import org.openspcoop2.pdd.core.PdDContext;
  49. import org.openspcoop2.pdd.core.handlers.GeneratoreCasualeDate;
  50. import org.openspcoop2.pdd.core.transazioni.GestoreConsegnaMultipla;
  51. import org.openspcoop2.pdd.core.transazioni.RepositoryGestioneStateful;
  52. import org.openspcoop2.pdd.core.transazioni.Transaction;
  53. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  54. import org.openspcoop2.pdd.core.transazioni.TransactionDeletedException;
  55. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  56. import org.openspcoop2.pdd.services.skeleton.IntegrationManager;
  57. import org.openspcoop2.protocol.engine.BasicProtocolFactory;
  58. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  59. import org.openspcoop2.protocol.engine.builder.DiagnosticoBuilder;
  60. import org.openspcoop2.protocol.sdk.Busta;
  61. import org.openspcoop2.protocol.sdk.Context;
  62. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  63. import org.openspcoop2.protocol.sdk.ProtocolException;
  64. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  65. import org.openspcoop2.protocol.sdk.constants.TipoSerializzazione;
  66. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticProducer;
  67. import org.openspcoop2.protocol.sdk.state.IState;
  68. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  69. import org.openspcoop2.protocol.sdk.state.StateMessage;
  70. import org.openspcoop2.utils.MapKey;
  71. import org.openspcoop2.utils.Utilities;
  72. import org.openspcoop2.utils.date.DateManager;
  73. import org.slf4j.Logger;



  77. /**
  78.  * Contiene la definizione un Logger utilizzato dai nodi dell'infrastruttura di OpenSPCoop2
  79.  * per la registrazione di messaggi diagnostici.
  80.  *
  81.  * @author Poli Andrea (apoli@link.it)
  82.  * @author $Author$
  83.  * @version $Rev$, $Date$
  84.  */

  86. public class MsgDiagnostico {

  88.     
  89.     /** Indicazione di un gestore di msg diagnostici funzionante */
  90.     public static boolean gestoreDiagnosticaDisponibile = true;
  91.     /** Primo errore avvenuto nel momento in cui è stato rilevato un malfunzionamento nel sistema di diagnostica */
  92.     public static Throwable motivoMalfunzionamentoDiagnostici = null;
  93.     

  95.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici */
  96.     private org.apache.logging.log4j.Logger loggerMsgDiagnostico = null;
  97.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici HumanReadable */
  98.     private org.apache.logging.log4j.Logger loggerOpenSPCoop2 = null;
  99.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici HumanReadable del servìzio di IntegrationManager */
  100.     private org.apache.logging.log4j.Logger loggerIntegrationManager = null;
  101.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici da passare agli appender che non possiedono un id di transazione */
  102.     private org.apache.logging.log4j.Logger loggerResource = null;
  103.     /**  Logger log4j utilizzato per segnalare a video errori gravi (FATAL) */
  104.     private Logger loggerOpenSPCoop2Fatal = null;
  105.     /**  Logger log4j utilizzato per scrivere lo stack trace degli errore nel core logger di openspcoop */
  106.     private Logger loggerOpenSPCoop2Core = null;
  107.     /** Appender personalizzati per i messaggi diagnostici di OpenSPCoop2 */
  108.     private List<IDiagnosticProducer> loggerMsgDiagnosticoOpenSPCoopAppender = null; 
  109.     private List<String> tipoMsgDiagnosticoOpenSPCoopAppender = null;

  111.     /** Soggetto che richiede il logger */
  112.     private IDSoggetto idSoggettoDominio;
  113.     /** Modulo Funzionale */
  114.     private String idModulo;
  115.     /** Identificativo della richiesta */
  116.     private String idMessaggioRichiesta;
  117.     /** Identificativo della risposta */
  118.     private String idMessaggioRisposta;
  119.     /** PdDContext */
  120.     private Context pddContext;
  121.     /** XMLBuilder */
  122.     private DiagnosticoBuilder diagnosticoBuilder;
  123.     
  124.     /** Protocol Factory */
  125.     private IProtocolFactory<?> protocolFactory;
  126.     private ITraduttore traduttore;
  127.     /** ConfigurazionePdDReader */
  128.     private ConfigurazionePdDManager _configurazionePdDReader;
  129.     /** MsgDiagnosticiProperties reader */
  130.     private MsgDiagnosticiProperties msgDiagPropertiesReader;
  131.     /** OpenSPCoopProperties */
  132.     private OpenSPCoop2Properties openspcoopProperties = null;
  133.     
  134.     /** Generatore di date casuali*/
  135.     private GeneratoreCasualeDate generatoreDateCasuali = null;
  136.     
  137.     /** Properties da aggiungere ai diagnostici (utili nelle implementazioni handler) */
  138.     private Map<String,String> properties = new HashMap<>();        
  139.     public Map<String, String> getProperties() {
  140.         return this.properties;
  141.     }

  143.     /** Keyword per i log personalizzati */
  144.     private Map<String,String> keywordLogPersonalizzati = new HashMap<>();  
  145.     public Map<String, String> getKeywordLogPersonalizzati() {
  146.         return this.keywordLogPersonalizzati;
  147.     }
  148.     
  149.     /** Informazioni sulla porta */
  150.     private String porta;
  151.     private boolean delegata;
  152.     @SuppressWarnings("unused")
  153.     private TipoPdD tipoPdD;
  154.     private Severita severitaPorta;

  156.     /** Stati */
  157.     private StateMessage state = null;
  158.     private StateMessage responseState = null;
  159.     
  160.     /** RequestInfo */
  161.     private RequestInfo requestInfo = null;
  162.     
  163.     
  164.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,IDSoggetto idSoggettoDominio, String modulo,String nomePorta, RequestInfo requestInfo, ConfigurazionePdDManager configurazionePdDManager) {
  165.         return new MsgDiagnostico(tipoPdD, idSoggettoDominio, modulo, nomePorta, requestInfo,
  166.                 configurazionePdDManager, null, null);
  167.     }
  168.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,IDSoggetto idSoggettoDominio, String modulo,String nomePorta, RequestInfo requestInfo, IState state) {
  169.         return new MsgDiagnostico(tipoPdD, idSoggettoDominio, modulo, nomePorta, requestInfo,
  170.                 null, state, null);
  171.     }
  172.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,IDSoggetto idSoggettoDominio, String modulo,String nomePorta, RequestInfo requestInfo, IState state, IState responseState) {
  173.         return new MsgDiagnostico(tipoPdD, idSoggettoDominio, modulo, nomePorta, requestInfo,
  174.                 null, state, responseState);
  175.     }
  176.     
  177.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,String modulo,String nomePorta, RequestInfo requestInfo, ConfigurazionePdDManager configurazionePdDManager) {
  178.         return new MsgDiagnostico(tipoPdD, OpenSPCoop2Properties.getInstance().getIdentitaPortaDefaultWithoutProtocol(), modulo, nomePorta, requestInfo,
  179.                 configurazionePdDManager, null, null);
  180.     }
  181.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,String modulo,String nomePorta, RequestInfo requestInfo) {
  182.         return new MsgDiagnostico(tipoPdD, OpenSPCoop2Properties.getInstance().getIdentitaPortaDefaultWithoutProtocol(), modulo, nomePorta, requestInfo,
  183.                 null, null, null);
  184.     }
  185.     
  186.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,String modulo,ConfigurazionePdDManager configurazionePdDManager) {
  187.         return new MsgDiagnostico(tipoPdD, OpenSPCoop2Properties.getInstance().getIdentitaPortaDefaultWithoutProtocol(), modulo, null, null,
  188.                 configurazionePdDManager, null, null);
  189.     }
  190.     public static MsgDiagnostico newInstance(TipoPdD tipoPdD,String modulo) {
  191.         return new MsgDiagnostico(tipoPdD, OpenSPCoop2Properties.getInstance().getIdentitaPortaDefaultWithoutProtocol(), modulo, null, null,
  192.                 null, null, null);
  193.     }
  194.     
  195.     public static MsgDiagnostico newInstance(IDSoggetto idSoggettoDominio, String modulo,ConfigurazionePdDManager configurazionePdDManager) {
  196.         return new MsgDiagnostico(null, idSoggettoDominio, modulo, null, null,
  197.                 configurazionePdDManager, null, null);
  198.     }
  199.     
  200.     public static MsgDiagnostico newInstance(String modulo,ConfigurazionePdDManager configurazionePdDManager) {
  201.         return new MsgDiagnostico(null, OpenSPCoop2Properties.getInstance().getIdentitaPortaDefaultWithoutProtocol(), modulo, null, null,
  202.                 configurazionePdDManager, null, null); 
  203.     }
  204.     public static MsgDiagnostico newInstance(String modulo) {
  205.         return new MsgDiagnostico(null, OpenSPCoop2Properties.getInstance().getIdentitaPortaDefaultWithoutProtocol(), modulo, null, null,
  206.                 null, null, null);
  207.     }
  208.     
  209.     public static MsgDiagnostico newInstance() {
  210.         return new MsgDiagnostico();
  211.     }
  212.     
  213.     /**
  214.      * Costruttore. 
  215.      *
  216.      * @param idSoggettoDominio Soggetto che richiede il logger
  217.      * @param modulo Funzione che richiede il logger
  218.      * @throws ProtocolException 
  219.      * 
  220.      */
  221.     private MsgDiagnostico(TipoPdD tipoPdD,IDSoggetto idSoggettoDominio, String modulo,String nomePorta, RequestInfo requestInfo,
  222.             ConfigurazionePdDManager configurazionePdDManagerParam,IState stateParam, IState responseStateParam) {
  223.         
  224.         this.idSoggettoDominio = idSoggettoDominio;
  225.         this.idModulo = modulo;
  226.         this.loggerMsgDiagnostico = OpenSPCoop2Logger.loggerMsgDiagnostico;
  227.         this.loggerOpenSPCoop2 = OpenSPCoop2Logger.loggerOpenSPCoop2;
  228.         this.loggerIntegrationManager = OpenSPCoop2Logger.loggerIntegrationManager;
  229.         this.loggerResource = OpenSPCoop2Logger.loggerOpenSPCoopResourcesAsLoggerImpl;
  230.         this.loggerOpenSPCoop2Fatal = OpenSPCoop2Logger.loggerOpenSPCoopConsole;
  231.         this.loggerMsgDiagnosticoOpenSPCoopAppender = OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender;
  232.         this.tipoMsgDiagnosticoOpenSPCoopAppender = OpenSPCoop2Logger.tipoMsgDiagnosticoOpenSPCoopAppender;
  233.         this.loggerOpenSPCoop2Core = OpenSPCoop2Logger.loggerOpenSPCoopCore;

  235.         if(configurazionePdDManagerParam!=null) {
  236.             this._configurazionePdDReader = configurazionePdDManagerParam;
  237.             this.state = this._configurazionePdDReader.getState();
  238.             this.responseState = this._configurazionePdDReader.getResponseState();
  239.         }
  240.         else {
  241.             if(stateParam!=null && stateParam instanceof StateMessage){
  242.                 this.state = (StateMessage) stateParam;
  243.             }
  244.             if(responseStateParam!=null && responseStateParam instanceof StateMessage){
  245.                 this.responseState = (StateMessage) responseStateParam;
  246.             }
  247.             this._configurazionePdDReader = ConfigurazionePdDManager.getInstance(this.state, this.responseState);
  248.         }
  249.         this.msgDiagPropertiesReader = MsgDiagnosticiProperties.getInstance();
  250.         
  251.         this.openspcoopProperties = OpenSPCoop2Properties.getInstance();
  252.         if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato()){
  253.             this.generatoreDateCasuali = GeneratoreCasualeDate.getGeneratoreCasualeDate();
  254.         }
  255.         try{
  256.             if(requestInfo!=null && requestInfo.getProtocolFactory()!=null) {
  257.                 this.protocolFactory = requestInfo.getProtocolFactory();
  258.             }
  259.             else {
  260.                 throw new Exception("ProtocolFactory unknow");
  261.             }
  262.             this.traduttore = this.protocolFactory.createTraduttore();
  263.         } catch(Throwable e){
  264.             // Succede quando non appartiene a nessun protocollo, ad esempio i diagnostici di startup
  265.             this.protocolFactory = new BasicProtocolFactory(this.loggerOpenSPCoop2Core);
  266.             try{
  267.                 this.traduttore = this.protocolFactory.createTraduttore();
  268.             } catch(Throwable eClose){}
  269.             //this.protocolFactory = null; 
  270.         }
  271.         this.diagnosticoBuilder = new DiagnosticoBuilder(this.protocolFactory); 
  272.         // Impostazione filtri
  273.         // Il filtro viene effettuato a livello di programma.
  274.         
  275.         this.requestInfo = requestInfo;
  276.         
  277.         this.porta = nomePorta;
  278.         this.tipoPdD = tipoPdD;
  279.         if(tipoPdD!=null) {
  280.             if(TipoPdD.DELEGATA.equals(tipoPdD)) {
  281.                 this.delegata = true;
  282.             }
  283.             else {
  284.                 this.delegata = false;
  285.             }
  286.         }
  287.         this.setPorta(this.requestInfo);
  288.             
  289.     }
  290.     
  291.     private ConfigurazionePdDManager getConfigurazionePdDManager() {
  292.         if(this._configurazionePdDReader!=null) {
  293.             return this._configurazionePdDReader;
  294.         }
  295.         if(this.state!=null || this.responseState!=null) {
  296.             return ConfigurazionePdDManager.getInstance(this.state, this.responseState);
  297.         }
  298.         return ConfigurazionePdDManager.getInstance();
  299.     }
  300.     
  301.     private MsgDiagnostico(){
  302.         this.msgDiagPropertiesReader = MsgDiagnosticiProperties.getInstance();
  303.     }
  304.     
  305.     private void setPorta(RequestInfo requestInfo) {
  306.         if(this.porta!=null) {
  307.             if(this.delegata) {
  308.                 try {
  309.                     IDPortaDelegata idPD = new IDPortaDelegata();
  310.                     idPD.setNome(this.porta);
  311.                     PortaDelegata pd = this.getConfigurazionePdDManager().getPortaDelegataSafeMethod(idPD, requestInfo);
  312.                     if(pd!=null && pd.getTracciamento()!=null) {
  313.                         this.severitaPorta = pd.getTracciamento().getSeverita();
  314.                     }
  315.                 }
  316.                 catch(Throwable e){}
  317.             }
  318.             else {
  319.                 try {
  320.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  321.                     idPA.setNome(this.porta);
  322.                     PortaApplicativa pa = this.getConfigurazionePdDManager().getPortaApplicativaSafeMethod(idPA, requestInfo);
  323.                     if(pa!=null && pa.getTracciamento()!=null) {
  324.                         this.severitaPorta = pa.getTracciamento().getSeverita();
  325.                     }
  326.                 }
  327.                 catch(Throwable e){}
  328.             }
  329.         }
  330.     }

  332.     public void updateRequestInfo(RequestInfo requestInfo) {
  333.         this.requestInfo = requestInfo;
  334.     }
  335.     
  336.     public void updatePorta(String porta, RequestInfo requestInfo) {
  337.         this.updatePorta(null, porta, requestInfo);
  338.     }
  339.     public void updatePorta(TipoPdD tipoPdD, String porta, RequestInfo requestInfo) {
  340.         if(tipoPdD!=null) {
  341.             this.tipoPdD = tipoPdD;
  342.             if(TipoPdD.DELEGATA.equals(tipoPdD)) {
  343.                 this.delegata = true;
  344.             }
  345.             else {
  346.                 this.delegata = false;
  347.             }
  348.         }
  349.         this.porta = porta;
  350.         this.setPorta(requestInfo);
  351.     }
  352.     public String getPorta() {
  353.         return this.porta;
  354.     }

  356.     public void updateState(IState requestStateParam, IState responseStateParam) {
  357.         StateMessage requestState = null;
  358.         StateMessage responseState = null;
  359.         if(requestStateParam!=null && requestStateParam instanceof StateMessage) {
  360.             requestState = (StateMessage) requestStateParam;
  361.         }
  362.         if(responseStateParam!=null && responseStateParam instanceof StateMessage) {
  363.             responseState = (StateMessage) responseStateParam;
  364.         }
  365.         updateState(requestState, responseState);
  366.     }
  367.     public void updateState(StateMessage requestState, StateMessage responseState){
  368.         this.state = requestState;
  369.         this.responseState = responseState;
  370.         if(this.state!=null || this.responseState!=null) {
  371.             if(this._configurazionePdDReader!=null) {
  372.                 this._configurazionePdDReader = this._configurazionePdDReader.refreshState(this.state, this.responseState);
  373.             }
  374.             else {
  375.                 this._configurazionePdDReader = ConfigurazionePdDManager.getInstance(this.state, this.responseState);
  376.             }
  377.         }
  378.         else {
  379.             this._configurazionePdDReader = ConfigurazionePdDManager.getInstance();
  380.         }
  381.     }
  382.     public void updateState(ConfigurazionePdDManager configurazionePdDManager){
  383.         this._configurazionePdDReader = configurazionePdDManager;
  384.         if(this._configurazionePdDReader!=null) {
  385.             this.state = this._configurazionePdDReader.getState();
  386.             this.responseState = this._configurazionePdDReader.getResponseState();
  387.         }
  388.         else {
  389.             this._configurazionePdDReader = ConfigurazionePdDManager.getInstance();
  390.         }
  391.     }
  392.     
  393.     private Connection getConnectionFromState(){
  394.         if(this.state!=null) {
  395.             Connection c = StateMessage.getConnection(this.state);
  396.             if(c!=null) {
  397.                 return c;
  398.             }
  399.         }
  400.         if(this.responseState!=null) {
  401.             Connection c = StateMessage.getConnection(this.responseState);
  402.             if(c!=null) {
  403.                 return c;
  404.             }
  405.         }
  406.         return null;
  407.     }
  408.     private IState getValidConnectionState(){
  409.         if(this.state!=null) {
  410.             Connection c = StateMessage.getConnection(this.state);
  411.             if(c!=null) {
  412.                 return this.state;
  413.             }
  414.         }
  415.         if(this.responseState!=null) {
  416.             Connection c = StateMessage.getConnection(this.responseState);
  417.             if(c!=null) {
  418.                 return this.responseState;
  419.             }
  420.         }
  421.         return null;
  422.     }
  423.     
  424.     /**
  425.      * Il Metodo si occupa di impostare il dominio del Soggetto che utilizza il logger. 
  426.      *
  427.      * @param idSoggettoDominio Soggetto che richiede il logger
  428.      * 
  429.      */
  430.     public void setDominio(IDSoggetto idSoggettoDominio){
  431.         this.idSoggettoDominio = idSoggettoDominio;
  432.     }
  433.     public IDSoggetto getDominio() {
  434.         return this.idSoggettoDominio;
  435.     }
  436.     
  437.     /**
  438.      * Il Metodo si occupa di impostare il contesto della PdD
  439.      *
  440.      * @param pddContext Contesto della PdD
  441.      * 
  442.      */
  443.     public void setPddContext(Context pddContext, IProtocolFactory<?> protocolFactory) {
  444.         this.pddContext = pddContext;
  445.         this.protocolFactory = protocolFactory;
  446.         try{
  447.             this.traduttore = this.protocolFactory.createTraduttore();
  448.         }catch(Exception e){
  449.             // ignore
  450.         }
  451.         this.diagnosticoBuilder = new DiagnosticoBuilder(protocolFactory); 
  452.         this.addKeywords(protocolFactory);
  453.     }


  456.     /**
  457.      * Il Metodo si occupa di impostare il modulo funzionale che che utilizza il logger. 
  458.      *
  459.      * @param modulo Funzione che richiede il logger
  460.      * 
  461.      */
  462.     public void setFunzione(String modulo){
  463.         this.idModulo = modulo;
  464.     }
  465.     public String getFunzione() {
  466.         return this.idModulo;
  467.     }

  469.     /**
  470.      * Il Metodo si occupa di impostare l'identificativo della richiesta in gestione. 
  471.      *
  472.      * @param id Identificativo
  473.      */
  474.     public void setIdMessaggioRichiesta(String id){
  475.         this.idMessaggioRichiesta = id;
  476.     }
  477.     /**
  478.      * Il Metodo si occupa di impostare l'identificativo della risposta in gestione. 
  479.      *
  480.      * @param id Identificativo
  481.      */
  482.     public void setIdMessaggioRisposta(String id){
  483.         this.idMessaggioRisposta = id;
  484.     }

  486.     /**
  487.      * Il Metodo si occupa di impostare i filtri sui logger. 
  488.      *
  489.      * 
  490.      */
  491.     public void aggiornaFiltri(){
  492.         
  493.         // Il filtro viene effettuato a livello di programma.

  495.     }

  497.     /**
  498.      * Filter. 
  499.      *
  500.      * 
  501.      * @deprecated  utility che elimina i caratteri XML codificati
  502.      */
  503.     @Deprecated  public String filter(String msg){
  504.         String xml = msg.replaceAll("&lt;","<");
  505.         xml = xml.replaceAll("&quot;","\"");
  506.         xml = xml.replaceAll("&gt;",">");
  507.         return xml;
  508.     }




  513.     
  514.     
  515.     /** -----------------Impostazione Identificatori nei messaggi ---------------- */
  516.     private IDSoggetto fruitore;
  517.     private IDServizio servizio;
  518.     private String servizioApplicativo;
  519.     private String idCorrelazioneApplicativa;
  520.     private String idCorrelazioneRisposta;
  521.     public void setFruitore(IDSoggetto fruitore) {
  522.         this.fruitore = fruitore;
  523.     }

  525.     public void setServizio(IDServizio servizio) {
  526.         this.servizio = servizio;
  527.     }

  529.     public void setServizioApplicativo(String servizioApplicativo) {
  530.         this.servizioApplicativo = servizioApplicativo;
  531.     }
  532.     public void setIdCorrelazioneApplicativa(String idCorrelazioneApplicativa) {
  533.         this.idCorrelazioneApplicativa = idCorrelazioneApplicativa;
  534.     }
  535.     public void setIdCorrelazioneRisposta(String idCorrelazioneRisposta) {
  536.         this.idCorrelazioneRisposta = idCorrelazioneRisposta;
  537.     }
  538.     
  539.     /** -----------------Impostazione TransazioneApplicativoServer ---------------- */
  540.     private TransazioneApplicativoServer transazioneApplicativoServer;
  541.     private IDPortaApplicativa idPortaApplicativa;
  542.     public void setTransazioneApplicativoServer(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPortaApplicativa) {
  543.         this.transazioneApplicativoServer = transazioneApplicativoServer;
  544.         this.idPortaApplicativa = idPortaApplicativa;
  545.     }
  546.     
  547.     
  548.     
  549.     
  550.     /*---------- Livelli/Messaggi personalizzati -------------*/
  551.     
  552.     /** Keyword replace per msg personalizzati */
  553.     public void addKeyword(String key,String value){
  554.         if(key!=null){
  555.             String tmpValue = value;
  556.             if(tmpValue == null)
  557.                 tmpValue = "";
  558.             this.keywordLogPersonalizzati.put(key, tmpValue);
  559.         }
  560.     }
  561.     public void addKeywordErroreProcessamento(Throwable t) {
  562.         this.addKeywordErroreProcessamento(t, null);
  563.     }
  564.     public void addKeywordErroreProcessamento(Throwable t,String prefix) {
  565.         String eccezione = t!=null ? Utilities.readFirstErrorValidMessageFromException(t) : "Internal Error";
  566.         if(prefix!=null) {
  567.             prefix = prefix.trim();
  568.             if(prefix.endsWith(":")==false) {
  569.                 prefix = prefix +":";
  570.             }
  571.             prefix = prefix +" ";
  572.             this.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO ,prefix +eccezione);
  573.         }
  574.         else {
  575.             this.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO ,eccezione);
  576.         }
  577.     }
  578.     public void addKeywords(IProtocolFactory<?> protocolFactory){
  579.         this.addKeyword(CostantiPdD.KEY_PROTOCOLLO, protocolFactory.getProtocol());
  580.         try{
  581.             this.addKeyword(CostantiPdD.KEY_PROTOCOLLO_TIPI_SOGGETTI, protocolFactory.createProtocolConfiguration().getTipiSoggetti().toString());
  582.         }catch(Exception e){
  583.             // ignore
  584.         }
  585.         try{
  586.             RequestInfo requestInfoParam = null;
  587.             if(this.pddContext!=null && this.pddContext.containsKey(Costanti.REQUEST_INFO)){
  588.                 requestInfoParam = (RequestInfo) this.pddContext.getObject(Costanti.REQUEST_INFO);
  589.             }
  590.             else{
  591.                 requestInfoParam = this.requestInfo;
  592.             }
  593.             ServiceBinding serviceBinding = null;
  594.             if(requestInfoParam!=null) {
  595.                 if(requestInfoParam.getProtocolContext().isPortaApplicativaService()) {
  596.                     serviceBinding = requestInfoParam.getProtocolServiceBinding();
  597.                 }
  598.                 else{
  599.                     serviceBinding = requestInfoParam.getIntegrationServiceBinding();
  600.                 }
  601.             }
  602.             this.addKeyword(CostantiPdD.KEY_PROTOCOLLO_TIPI_SERVIZI, protocolFactory.createProtocolConfiguration().getTipiServizi(serviceBinding).toString());
  603.         }catch(Exception e){
  604.             // ignore
  605.         }
  606.     }
  607.     public void addKeywords(Busta busta,boolean richiesta){
  608.         if(busta!=null){
  609.             if(richiesta){
  610.                 if(busta.getID()!=null)
  611.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, busta.getID());
  612.                 else
  613.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, "N.D.");
  614.                 if(busta.getProfiloDiCollaborazione()!=null){
  615.                     String profilo = null;
  616.                     if(this.traduttore!=null){
  617.                         profilo = this.traduttore.toString(busta.getProfiloDiCollaborazione());
  618.                     }
  619.                     else if(busta.getProtocollo()!=null){
  620.                         try{
  621.                             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(busta.getProtocollo());
  622.                             ITraduttore traduttore = protocolFactory.createTraduttore();
  623.                             profilo = traduttore.toString(busta.getProfiloDiCollaborazione());
  624.                         }catch(Exception e){
  625.                             profilo = busta.getProfiloDiCollaborazione().name();
  626.                         }
  627.                     }else{
  628.                         profilo = busta.getProfiloDiCollaborazione().name();
  629.                     }
  630.                     if(profilo==null){
  631.                         profilo = busta.getProfiloDiCollaborazione().getEngineValue();
  632.                     }
  633.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, profilo);
  634.                 }
  635.                 if(busta.getTipoMittente()!=null) {
  636.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_MITTENTE_BUSTA_RICHIESTA, busta.getTipoMittente());
  637.                 }
  638.                 else {
  639.                     try{
  640.                         this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_MITTENTE_BUSTA_RICHIESTA, ProtocolFactoryManager.getInstance().getDefaultOrganizationTypes().get(busta.getProtocollo()));
  641.                     }catch(Exception e){}
  642.                 }
  643.                 if(busta.getMittente()!=null) {
  644.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_MITTENTE_BUSTA_RICHIESTA, busta.getMittente());
  645.                 }else {
  646.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_MITTENTE_BUSTA_RICHIESTA, CostantiPdD.SOGGETTO_ANONIMO);
  647.                 }
  648.                 if(busta.getTipoDestinatario()!=null)
  649.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_DESTINATARIO_BUSTA_RICHIESTA, busta.getTipoDestinatario());
  650.                 if(busta.getDestinatario()!=null)
  651.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_DESTINATARIO_BUSTA_RICHIESTA, busta.getDestinatario());
  652.                 if(busta.getTipoServizio()!=null)
  653.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_SERVIZIO_BUSTA_RICHIESTA, busta.getTipoServizio());
  654.                 if(busta.getServizio()!=null)
  655.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SERVIZIO_BUSTA_RICHIESTA, busta.getServizio());
  656.                 if(busta.getVersioneServizio()!=null)
  657.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_VERSIONE_SERVIZIO_BUSTA_RICHIESTA, busta.getVersioneServizio().intValue()+"");
  658.                 if(busta.getAzione()!=null)
  659.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_AZIONE_BUSTA_RICHIESTA, busta.getAzione());
  660.                 else
  661.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_AZIONE_BUSTA_RICHIESTA, "");
  662.                 if(busta.getRiferimentoMessaggio()!=null)
  663.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_RIFERIMENTO_MESSAGGIO_RICHIESTA, busta.getRiferimentoMessaggio());
  664.                 if(busta.getSequenza()>0){
  665.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SEQUENZA, busta.getSequenza()+"");
  666.                 }
  667.                 if(busta.getIndirizzoMittente()!=null)
  668.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_INDIRIZZO_TELEMATICO_MITTENTE_RICHIESTA, busta.getIndirizzoMittente());
  669.                 if(busta.getIndirizzoDestinatario()!=null)
  670.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_INDIRIZZO_TELEMATICO_DESTINATARIO_RICHIESTA, busta.getIndirizzoDestinatario());
  671.                 if(busta.getScadenza()!=null)
  672.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SCADENZA_BUSTA_RICHIESTA, busta.getScadenza().toString());
  673.                 
  674.                 if(busta.getTipoDestinatario()!=null && busta.getDestinatario()!=null &&
  675.                         busta.getTipoServizio()!=null && busta.getServizio()!=null && busta.getVersioneServizio()!=null){
  676.                     try{
  677.                         this.keywordLogPersonalizzati.put(CostantiPdD.KEY_URI_ACCORDO_PARTE_SPECIFICA, 
  678.                                 IDServizioFactory.getInstance().getUriFromValues(busta.getTipoServizio(), busta.getServizio(), 
  679.                                         busta.getTipoDestinatario(), busta.getDestinatario(), busta.getVersioneServizio()));
  680.                     }catch(Exception e){
  681.                         throw new RuntimeException(e.getMessage(),e);
  682.                     }
  683.                 }
  684.             }
  685.             else{
  686.                 if(busta.getID()!=null)
  687.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, busta.getID());
  688.                 else
  689.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, "N.D.");
  690.                 if(busta.getProfiloDiCollaborazione()!=null){
  691.                     String profilo = null;
  692.                     if(this.traduttore!=null){
  693.                         profilo = this.traduttore.toString(busta.getProfiloDiCollaborazione());
  694.                     }
  695.                     else if(busta.getProtocollo()!=null){
  696.                         try{
  697.                             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(busta.getProtocollo());
  698.                             ITraduttore traduttore = protocolFactory.createTraduttore();
  699.                             profilo = traduttore.toString(busta.getProfiloDiCollaborazione());
  700.                         }catch(Exception e){
  701.                             profilo = busta.getProfiloDiCollaborazione().getEngineValue();
  702.                         }
  703.                     }else{
  704.                         profilo = busta.getProfiloDiCollaborazione().getEngineValue();
  705.                     }
  706.                     if(profilo==null){
  707.                         profilo = busta.getProfiloDiCollaborazione().getEngineValue();
  708.                     }
  709.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, profilo);
  710.                 }
  711.                 if(busta.getTipoMittente()!=null)
  712.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_MITTENTE_BUSTA_RISPOSTA, busta.getTipoMittente());
  713.                 if(busta.getMittente()!=null)
  714.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_MITTENTE_BUSTA_RISPOSTA, busta.getMittente());
  715.                 if(busta.getTipoDestinatario()!=null)
  716.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_DESTINATARIO_BUSTA_RISPOSTA, busta.getTipoDestinatario());
  717.                 if(busta.getDestinatario()!=null)
  718.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_DESTINATARIO_BUSTA_RISPOSTA, busta.getDestinatario());
  719.                 if(busta.getTipoServizio()!=null)
  720.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_SERVIZIO_BUSTA_RISPOSTA, busta.getTipoServizio());
  721.                 if(busta.getServizio()!=null)
  722.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SERVIZIO_BUSTA_RISPOSTA, busta.getServizio());
  723.                 if(busta.getVersioneServizio()!=null)
  724.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_VERSIONE_SERVIZIO_BUSTA_RISPOSTA, busta.getVersioneServizio().intValue()+"");
  725.                 if(busta.getAzione()!=null)
  726.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_AZIONE_BUSTA_RISPOSTA, busta.getAzione());
  727.                 else
  728.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_AZIONE_BUSTA_RISPOSTA, "");
  729.                 if(busta.getRiferimentoMessaggio()!=null)
  730.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_RIFERIMENTO_MESSAGGIO_RISPOSTA, busta.getRiferimentoMessaggio());
  731.                 if(busta.getSequenza()>0){
  732.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SEQUENZA, busta.getSequenza()+"");
  733.                 }
  734.                 if(busta.getIndirizzoMittente()!=null)
  735.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_INDIRIZZO_TELEMATICO_MITTENTE_RISPOSTA, busta.getIndirizzoMittente());
  736.                 if(busta.getIndirizzoDestinatario()!=null)
  737.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_INDIRIZZO_TELEMATICO_DESTINATARIO_RISPOSTA, busta.getIndirizzoDestinatario());
  738.                 if(busta.getScadenza()!=null)
  739.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SCADENZA_BUSTA_RISPOSTA, busta.getScadenza().toString());
  740.             }   
  741.         }
  742.     }
  743.     public void addKeywords(IDSoggetto soggettoFruitore){
  744.         this.addKeywords(soggettoFruitore,null,null);
  745.     }
  746.     public void addKeywords(IDServizio idServizio){
  747.         this.addKeywords(null,idServizio,null);
  748.     }
  749.     public void addKeywords(IDSoggetto soggettoFruitore,IDServizio idServizio,String idMessaggio){
  750.         if(idMessaggio!=null){
  751.             this.keywordLogPersonalizzati.put(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessaggio);
  752.         }
  753.         if(soggettoFruitore!=null){
  754.             this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_MITTENTE_BUSTA_RICHIESTA, soggettoFruitore.getTipo());
  755.             this.keywordLogPersonalizzati.put(CostantiPdD.KEY_MITTENTE_BUSTA_RICHIESTA, soggettoFruitore.getNome());
  756.         }
  757.         else {
  758.             if(idServizio!=null && idServizio.getTipo()!=null) {
  759.                 try{
  760.                     String protocollo = ProtocolFactoryManager.getInstance().getProtocolByServiceType(idServizio.getTipo());
  761.                     this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_MITTENTE_BUSTA_RICHIESTA, ProtocolFactoryManager.getInstance().getDefaultOrganizationTypes().get(protocollo));
  762.                 }catch(Exception e){
  763.                     // ignore
  764.                 }
  765.                 this.keywordLogPersonalizzati.put(CostantiPdD.KEY_MITTENTE_BUSTA_RICHIESTA, CostantiPdD.SOGGETTO_ANONIMO);
  766.             }
  767.         }
  768.         if(idServizio!=null){
  769.             if(idServizio.getSoggettoErogatore()!=null){
  770.                 this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_DESTINATARIO_BUSTA_RICHIESTA, idServizio.getSoggettoErogatore().getTipo());
  771.                 this.keywordLogPersonalizzati.put(CostantiPdD.KEY_DESTINATARIO_BUSTA_RICHIESTA, idServizio.getSoggettoErogatore().getNome());
  772.             }
  773.             this.keywordLogPersonalizzati.put(CostantiPdD.KEY_TIPO_SERVIZIO_BUSTA_RICHIESTA, idServizio.getTipo());
  774.             this.keywordLogPersonalizzati.put(CostantiPdD.KEY_SERVIZIO_BUSTA_RICHIESTA, idServizio.getNome());
  775.             if(idServizio.getVersione()!=null){
  776.                 this.keywordLogPersonalizzati.put(CostantiPdD.KEY_VERSIONE_SERVIZIO_BUSTA_RICHIESTA, idServizio.getVersione().intValue()+"");
  777.             }
  778.             if(idServizio.getAzione()!=null)
  779.                 this.keywordLogPersonalizzati.put(CostantiPdD.KEY_AZIONE_BUSTA_RICHIESTA, idServizio.getAzione());
  780.             try{
  781.                 this.keywordLogPersonalizzati.put(CostantiPdD.KEY_URI_ACCORDO_PARTE_SPECIFICA, IDServizioFactory.getInstance().getUriFromIDServizio(idServizio));
  782.             }catch(Exception e){
  783.                 throw new RuntimeException(e.getMessage(),e);
  784.             }
  785.         }
  786.     }
  787.     public void updateKeywordIdMessaggioRichiesta(String idMessaggio){
  788.         if(idMessaggio!=null){
  789.             this.keywordLogPersonalizzati.put(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessaggio);
  790.         }
  791.     }
  792.     public String replaceKeywords(String msg){
  793.                 
  794.         /* Potenzialmente N^2   
  795.         String tmp = msg;
  796.         Enumeration<String> keys = this.keywordLogPersonalizzati.keys();
  797.         while(keys.hasMoreElements()){
  798.             String key = keys.nextElement();
  799.             tmp = tmp.replace(key, this.keywordLogPersonalizzati.get(key));
  800.         }
  801.         return tmp;
  802.         */

  804.         /* Costoso e inutile per quasi tutti i diagnostici
  805.         // Check di esistenza di almeno 2 '@'
  806.         if(msg!=null && msg.length()>2){
  807.             int index1 = msg.indexOf("@");
  808.             int index2 = msg.indexOf("@",index1+1);
  809.             if(index1<0 || index2<0){
  810.                 return msg; // non serve il replace
  811.             }
  812.         }
  813.         */
  814.         
  815.         StringBuilder bf = new StringBuilder();
  816.         StringBuilder keyword = new StringBuilder();
  817.         boolean separator = false;
  818.         char separatorChar = '@';
  819.         for(int i=0; i<msg.length(); i++){
  820.             char ch = msg.charAt(i);
  821.             if(separatorChar == ch){
  822.                 if(separator==false){
  823.                     // inizio keyword
  824.                     keyword.append(separatorChar);
  825.                     separator = true;
  826.                 }
  827.                 else{
  828.                     // fine keyword
  829.                     keyword.append(separatorChar);
  830.                     String valoreRimpiazzato = this.keywordLogPersonalizzati.get(keyword.toString());
  831.                     if(valoreRimpiazzato==null){
  832.                         // keyword non esistente, devo utilizzare l'originale
  833.                         bf.append(keyword.toString());
  834.                     }else{
  835.                         bf.append(valoreRimpiazzato);
  836.                     }
  837.                     keyword.setLength(0);
  838.                     separator=false;
  839.                 }
  840.             }else{
  841.                 if(separator){
  842.                     // sto scrivendo la keyword
  843.                     keyword.append(ch);
  844.                 }else{
  845.                     bf.append(ch);
  846.                 }
  847.             }
  848.         }
  849.         if ( separator )
  850.             bf.append(keyword.toString());
  851.         return bf.toString();
  852.     }
  853.     
  854.     private String prefixMsgPersonalizzati = null;
  855.     public String getPrefixMsgPersonalizzati() {
  856.         return this.prefixMsgPersonalizzati;
  857.     }
  858.     public void setPrefixMsgPersonalizzati(String v){
  859.         this.prefixMsgPersonalizzati = v;
  860.     }
  861.     
  862.     public int getLivello(String keyLivelloPersonalizzato){
  863.         return getLivello(this.prefixMsgPersonalizzati, keyLivelloPersonalizzato);
  864.     }
  865.     public int getLivello(String prefix,String keyLivelloPersonalizzato){
  866.         if(this.msgDiagPropertiesReader==null){
  867.             return -1;
  868.         }
  869.         Integer livello = this.msgDiagPropertiesReader.getLivello(prefix,keyLivelloPersonalizzato);
  870.         if(livello!=null){
  871.             return livello;
  872.         } else{
  873.             return -1;
  874.         }
  875.     }
  876.     
  877.     public String getCodice(String keyCodicePersonalizzato){
  878.         return getCodice(this.prefixMsgPersonalizzati, keyCodicePersonalizzato);
  879.     }
  880.     public String getCodice(String prefix,String keyCodicePersonalizzato){
  881.         if(this.msgDiagPropertiesReader==null){
  882.             return "PropertiesReader dei Messaggi Diagnostici non inizializzato";
  883.         }
  884.         return this.msgDiagPropertiesReader.getCodice(prefix,keyCodicePersonalizzato);
  885.     }
  886.     
  887.     public String getMessaggio(String keyMsgPersonalizzato){
  888.         return this.getMessaggio(this.prefixMsgPersonalizzati, keyMsgPersonalizzato, false);
  889.     }
  890.     public String getMessaggio(String prefix,String keyMsgPersonalizzato){
  891.         return this.getMessaggio(prefix, keyMsgPersonalizzato, false);
  892.     }
  893.     public String getMessaggio_replaceKeywords(String keyMsgPersonalizzato){
  894.         return this.getMessaggio(this.prefixMsgPersonalizzati, keyMsgPersonalizzato, true);
  895.     }
  896.     public String getMessaggio_replaceKeywords(String prefix,String keyMsgPersonalizzato){
  897.         return this.getMessaggio(prefix, keyMsgPersonalizzato, true);
  898.     }
  899.     private String getMessaggio(String prefix,String keyMsgPersonalizzato,boolean replaceKeywords){
  900.         if(this.msgDiagPropertiesReader==null){
  901.             return "PropertiesReader dei Messaggi Diagnostici non inizializzato";
  902.         }
  903.         String msgTmp = this.msgDiagPropertiesReader.getMessaggio(prefix,keyMsgPersonalizzato);
  904.         if(msgTmp==null){
  905.             msgTmp = "Messaggio diagnostico ["+prefix+keyMsgPersonalizzato+"] non definito nella configurazione della porta di dominio??";
  906.         }
  907.         if(replaceKeywords){
  908.             String msgReplaceKey = this.replaceKeywords(msgTmp);
  909.             return msgReplaceKey;
  910.         }else{
  911.             return msgTmp;
  912.         }
  913.     }
  914.     
  915.     
  916.     
  917.     
  918.     

  920.     
  921.     
  922.     
  923.     
  924.     
  925.     




  930.     /** ----------------- METODI DI LOGGING (Messaggi Diagnostici) ---------------- */

  932.     private void setEmitErrorConditionInContext(int livelloLog){
  933.         if(this.pddContext!=null){
  934.             if(livelloLog<=LogLevels.SEVERITA_ERROR_INTEGRATION){
  935.                 if(this.pddContext.containsKey(Costanti.EMESSI_DIAGNOSTICI_ERRORE)==false){
  936.                     this.pddContext.addObject(Costanti.EMESSI_DIAGNOSTICI_ERRORE, "true");
  937.                 }
  938.             }
  939.         }
  940.     }
  941.     
  942.     public void emitRicezioneMessaggioModuloBuste(MsgDiagnostico msgDiag, PdDContext pddContext, boolean mittenteAnonimo) {
  943.         if(mittenteAnonimo) {
  944.             msgDiag.logPersonalizzato("ricezioneMessaggio.mittenteAnonimo");
  945.         }
  946.         else {
  947.             // verifico che l'identita sia stata definita nel contesto del diagnostico non come 'Anonimo'
  948.             if(this.keywordLogPersonalizzati!=null) {
  949.                 String v = this.keywordLogPersonalizzati.get(CostantiPdD.KEY_MITTENTE_BUSTA_RICHIESTA);
  950.                 if(v==null || "".equals(v) || CostantiPdD.SOGGETTO_ANONIMO.equals(v)) {
  951.                     mittenteAnonimo = true;
  952.                 }
  953.             }
  954.             if(mittenteAnonimo) {
  955.                 msgDiag.logPersonalizzato("ricezioneMessaggio.mittenteAnonimo");
  956.             }
  957.             else {
  958.                 msgDiag.logPersonalizzato("ricezioneMessaggio");
  959.             }
  960.         }
  961.    }
  962.     
  963.     /**
  964.      * Il Metodo si occupa di creare un messaggio di livello 'Personalizzato'. 
  965.      *
  966.      * 
  967.      */
  968.     public void logPersonalizzato_custom(String messaggio, int livelloLog, String codiceDiagnostico){
  969.         _logPersonalizzato(null, null, null,
  970.                 messaggio, livelloLog, codiceDiagnostico);
  971.     }
  972.     public void logPersonalizzato_custom(String prefix, String messaggio, int livelloLog, String codiceDiagnostico){
  973.         _logPersonalizzato(prefix, null, null,
  974.                 messaggio, livelloLog, codiceDiagnostico);
  975.     }
  976.     public void logPersonalizzato_prefix(String prefix, String idModuloFunzionale,String idDiagnostico){
  977.         _logPersonalizzato(prefix, idModuloFunzionale, idDiagnostico,
  978.                 null,null,null);
  979.     }
  980.     public void logPersonalizzato_prefix(String prefix, String idDiagnostico){
  981.         _logPersonalizzato(prefix, null, idDiagnostico,
  982.                 null,null,null);
  983.     }
  984.     public void logPersonalizzato(String idModuloFunzionale,String idDiagnostico){
  985.         _logPersonalizzato(null, idModuloFunzionale, idDiagnostico,
  986.                 null,null,null);
  987.     }
  988.     public void logPersonalizzato(String idDiagnostico){
  989.         _logPersonalizzato(null, null, idDiagnostico,
  990.                 null,null,null);
  991.     }
  992.     private void _logPersonalizzato(String prefix, String idModuloFunzionale,String idDiagnostico,
  993.             String messaggioFromParam, Integer livelloLogFromParam, String codiceDiagnosticoFromParam) {

  995.         if(this.msgDiagPropertiesReader==null){
  996.             logError("MsgDiagnostico.logPersonalizzato [Risorsa non inizializzata], messaggio per idModuloFunzionale["+idModuloFunzionale+"] idDiagnostico["+idDiagnostico+"]");
  997.             return;
  998.         }
  999.         
  1000.         int livelloLog = -1;
  1001.         if(livelloLogFromParam!=null) {
  1002.             livelloLog = livelloLogFromParam;
  1003.         }
  1004.         else {
  1005.             if(idModuloFunzionale!=null) {
  1006.                 livelloLog = this.getLivello(idModuloFunzionale,idDiagnostico);
  1007.             }
  1008.             else {
  1009.                 livelloLog = this.getLivello(idDiagnostico);
  1010.             }
  1011.         }
  1012.         
  1013.         int severitaLogEmessoPerFiltro = livelloLog;
  1014.         int severitaLivelloOpenSPCoop2 = LogLevels.toIntervalloOpenSPCoop2(livelloLog);
  1015.         if(severitaLivelloOpenSPCoop2<0 || severitaLivelloOpenSPCoop2>7){
  1016.             logError("MsgDiagnostico.logPersonalizzato error, conversione a livello OpenSPCoop non riuscita ["+severitaLivelloOpenSPCoop2+"]");
  1017.             return;
  1018.         }
  1019.         this.setEmitErrorConditionInContext(severitaLivelloOpenSPCoop2);
  1020.         Level logLevelseveritaLivelloLog4J = LogLevels.toLog4J(severitaLivelloOpenSPCoop2);
  1021.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1022.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1023.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1024.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1025.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1026.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  1027.         }
  1028.         if(this.severitaPorta!=null) {
  1029.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1030.         }
  1031.         
  1032.         try{
  1033.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  1034.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1035.             if(!emettiLogSuFile && !emettiLog) {
  1036.                 return;
  1037.             }
  1038.             
  1039.             String messaggio = null;
  1040.             String codiceDiagnostico = null;
  1041.             if(messaggioFromParam!=null) {
  1042.                 messaggio = messaggioFromParam;
  1043.                 codiceDiagnostico = codiceDiagnosticoFromParam;
  1044.             }
  1045.             else {
  1046.                 if(idModuloFunzionale!=null) {
  1047.                     messaggio = this.getMessaggio(idModuloFunzionale,idDiagnostico); 
  1048.                     codiceDiagnostico = this.getCodice(idModuloFunzionale,idDiagnostico);
  1049.                 }
  1050.                 else {
  1051.                     messaggio = this.getMessaggio(idDiagnostico); 
  1052.                     codiceDiagnostico = this.getCodice(idDiagnostico);
  1053.                 }
  1054.             }
  1055.             if(messaggio==null){
  1056.                 logError("MsgDiagnostico.logPersonalizzato error, messaggio non definito.");
  1057.                 return;
  1058.             }
  1059.                         
  1060.             // Data
  1061.             Date gdo = DateManager.getDate();
  1062.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1063.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1064.             }
  1065.             
  1066.             // Replace keyword
  1067.             String msgReplaceKey = this.replaceKeywords(messaggio); 
  1068.             if(prefix!=null) {
  1069.                 msgReplaceKey = prefix + msgReplaceKey;
  1070.             }
  1071.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = this.getMsgDiagnostico(gdo, severitaLivelloOpenSPCoop2, msgReplaceKey, codiceDiagnostico);
  1072.             
  1073.             
  1074.             // Messaggio diagnostici
  1075.             //System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1076.             if( emettiLogSuFile ){

  1078.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  1079.                     try{
  1080.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  1081.                         this.loggerMsgDiagnostico.log(logLevelseveritaLivelloLog4J,xml);
  1082.                     }catch(Exception e){
  1083.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  1084.                         gestioneErroreDiagnostica(e);
  1085.                     }
  1086.                 }
  1087.                 
  1088.             }
  1089.             
  1090.             // Messaggio diagnostici
  1091.             //System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1092.             if( emettiLog ){

  1094.                 if(msgDiag.getIdTransazione()!=null) {
  1095.                     
  1096.                     // TransazioneContext
  1097.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  1098.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  1099.                     }
  1100.                     
  1101.                     // Msg Diagnostico personalizzato
  1102.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  1103.                         try{
  1104.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  1105.                         }catch(Exception e){
  1106.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  1107.                             gestioneErroreDiagnostica(e);
  1108.                         }
  1109.                     }
  1110.                 }
  1111.                 else {
  1112.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  1113.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1114.                             this.porta,this.delegata,
  1115.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1116.                     try{
  1117.                         this.loggerResource.log(logLevelseveritaLivelloLog4J,message);

  1119.                     }catch(Exception e){
  1120.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  1121.                         gestioneErroreDiagnostica(e);
  1122.                     }
  1123.                 }
  1124.             }

  1126.             // Human Readable
  1127.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  1128.             boolean humanReadableAbilitato = false;
  1129.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1130.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  1131.             }else{
  1132.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  1133.             }
  1134.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  1135.                 
  1136.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  1137.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1138.                         this.porta,this.delegata,
  1139.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1140.                 try{
  1141.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1142.                         this.loggerIntegrationManager.log(logLevelseveritaLivelloLog4J,message);
  1143.                     }else{
  1144.                         this.loggerOpenSPCoop2.log(logLevelseveritaLivelloLog4J,message);
  1145.                     }
  1146.                 }catch(Exception e){
  1147.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  1148.                     gestioneErroreDiagnostica(e);
  1149.                 }
  1150.             }
  1151.             
  1152.             // Log fatal emesso su console jboss
  1153.             if(msgReplaceKey!=null && severitaLivelloOpenSPCoop2==0){
  1154.                 // dalla versione 2.3, essendo utilizzato slf4j, si converte fatal in error.
  1155.                 //this.loggerOpenSPCoop2Fatal.log(LogLevels.LOG_LEVEL_FATAL,msgReplaceKey);
  1156.                 this.loggerOpenSPCoop2Fatal.error(msgReplaceKey);
  1157.             }

  1159.         }catch(Exception e){
  1160.             logError("MsgDiagnostico.logPersonalizzato error "+e.getMessage(),e);
  1161.             gestioneErroreDiagnostica(e);
  1162.         }
  1163.     }
  1164.     
  1165.     
  1166.     public void addLogPersonalizzato(String idModuloFunzionale,String idDiagnostico, Transaction transaction, StringBuilder errorLog){

  1168.         if(this.msgDiagPropertiesReader==null){
  1169.             logError("MsgDiagnostico.logPersonalizzato [Risorsa non inizializzata], messaggio per idModuloFunzionale["+idModuloFunzionale+"] idDiagnostico["+idDiagnostico+"]");
  1170.             return;
  1171.         }
  1172.         
  1173.         int livelloLog = -1;
  1174.         if(idModuloFunzionale!=null) {
  1175.             livelloLog = this.getLivello(idModuloFunzionale,idDiagnostico);
  1176.         }
  1177.         else {
  1178.             livelloLog = this.getLivello(idDiagnostico);
  1179.         }
  1180.         
  1181.         int severitaLogEmessoPerFiltro = livelloLog;
  1182.         int severitaLivelloOpenSPCoop2 = LogLevels.toIntervalloOpenSPCoop2(livelloLog);
  1183.         if(severitaLivelloOpenSPCoop2<0 || severitaLivelloOpenSPCoop2>7){
  1184.             logError("MsgDiagnostico.logPersonalizzato error, conversione a livello OpenSPCoop non riuscita ["+severitaLivelloOpenSPCoop2+"]");
  1185.             return;
  1186.         }
  1187.         this.setEmitErrorConditionInContext(severitaLivelloOpenSPCoop2);
  1188.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1189.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1190.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1191.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1192.         }
  1193.         if(this.severitaPorta!=null) {
  1194.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1195.         }
  1196.         
  1197.         try{
  1198.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1199.             if(!emettiLog) {
  1200.                 return;
  1201.             }
  1202.             
  1203.             String messaggio = null;
  1204.             String codiceDiagnostico = null;
  1205.             if(idModuloFunzionale!=null) {
  1206.                 messaggio = this.getMessaggio(idModuloFunzionale,idDiagnostico); 
  1207.                 codiceDiagnostico = this.getCodice(idModuloFunzionale,idDiagnostico);
  1208.             }
  1209.             else {
  1210.                 messaggio = this.getMessaggio(idDiagnostico); 
  1211.                 codiceDiagnostico = this.getCodice(idDiagnostico);
  1212.             }
  1213.             if(messaggio==null){
  1214.                 logError("MsgDiagnostico.logPersonalizzato error, messaggio non definito.");
  1215.                 return;
  1216.             }
  1217.                         
  1218.             // Data
  1219.             Date gdo = DateManager.getDate();
  1220.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1221.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1222.             }
  1223.             
  1224.             // Replace keyword
  1225.             String msgReplaceKey = this.replaceKeywords(messaggio); 
  1226.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = this.getMsgDiagnostico(gdo, severitaLivelloOpenSPCoop2, msgReplaceKey, codiceDiagnostico);
  1227.             if(errorLog!=null) {
  1228.                 errorLog.append(msgDiag.getMessaggio());
  1229.             }
  1230.             transaction.addMsgDiagnostico(msgDiag);
  1231.         }catch(Exception e){
  1232.             logError("MsgDiagnostico.logPersonalizzato error "+e.getMessage(),e);
  1233.             // log su core solamente
  1234.             /**gestioneErroreDiagnostica(e);*/
  1235.         }
  1236.     }
  1237.     
  1238.     
  1239.     public void logErroreGenerico(Throwable e, String posizioneErrore) {
  1240.         String msg = e!=null ? Utilities.readFirstErrorValidMessageFromException(e) : "Internal Error";
  1241.         this.logErroreGenerico(msg,posizioneErrore);
  1242.         // inoltre registro l'errore nel logger_core di openspcoop
  1243.         if(this.loggerOpenSPCoop2Core!=null)
  1244.             this.loggerOpenSPCoop2Core.error(posizioneErrore+": "+msg,e);
  1245.     }
  1246.     public void logErroreGenerico(String message, String posizioneErrore) {
  1247.         this.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, message);
  1248.         this.addKeyword(CostantiPdD.KEY_POSIZIONE_ERRORE, posizioneErrore);
  1249.         this.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL,"erroreGenerico");
  1250.     }
  1251.     
  1252.     
  1253.     public void logFatalError(Throwable e, String posizioneErrore) {
  1254.         String msg = e!=null ? Utilities.readFirstErrorValidMessageFromException(e) : "Internal Error";
  1255.         this.logFatalError(msg,posizioneErrore);
  1256.         // inoltre registro l'errore nel logger_core di openspcoop
  1257.         if(this.loggerOpenSPCoop2Core!=null){
  1258.             // dalla versione 2.3, essendo utilizzato slf4j, si converte fatal in error.
  1259.             //this.loggerOpenSPCoop2Core.fatal(posizioneErrore+": "+msg,e);
  1260.             this.loggerOpenSPCoop2Core.error(posizioneErrore+": "+msg,e);
  1261.         }
  1262.     }
  1263.     public void logFatalError(String message, String posizioneErrore) {
  1264.         this.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, message);
  1265.         this.addKeyword(CostantiPdD.KEY_POSIZIONE_ERRORE, posizioneErrore);
  1266.         this.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL,"erroreGenericoMalfunzionamentoPdD");
  1267.     }
  1268.     
  1269.     
  1270.     public void logStartupError(Throwable e, String posizioneErrore) {
  1271.         String msg = null;
  1272.         if(e instanceof NullPointerException)
  1273.              msg = "NullPointerException";
  1274.         else
  1275.             msg = e.getMessage();
  1276.         this.logStartupError(msg,posizioneErrore);
  1277.         // inoltre registro l'errore nel logger_core di openspcoop
  1278.         if(this.loggerOpenSPCoop2Core!=null){
  1279.             // dalla versione 2.3, essendo utilizzato slf4j, si converte fatal in error.
  1280.             //this.loggerOpenSPCoop2Core.fatal(posizioneErrore+": "+msg,e);
  1281.             this.loggerOpenSPCoop2Core.error(posizioneErrore+": "+msg,e);
  1282.         }
  1283.     }
  1284.     public void logStartupError(String message, String posizioneErrore) {
  1285.         this.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, message);
  1286.         this.addKeyword(CostantiPdD.KEY_POSIZIONE_ERRORE, posizioneErrore);
  1287.         this.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_OPENSPCOOP_STARTUP,"erroreGenerico");
  1288.     }
  1289.     
  1290.     public void logDisconnectError(Throwable e, String url) {
  1291.         String msg = null;
  1292.         if(e instanceof NullPointerException)
  1293.              msg = "NullPointerException";
  1294.         else
  1295.             msg = e.getMessage();
  1296.         this.logDisconnectError(msg,url);
  1297.         // inoltre registro l'errore nel logger_core di openspcoop
  1298.         if(this.loggerOpenSPCoop2Core!=null)
  1299.             this.loggerOpenSPCoop2Core.error(url+": "+msg,e);
  1300.     }
  1301.     public void logDisconnectError(String message, String url) {
  1302.         this.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, message);
  1303.         this.addKeyword(CostantiPdD.KEY_POSIZIONE_ERRORE, url);
  1304.         this.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL,"connessioneUscita.disconnectError");
  1305.     }
  1306.     
  1307.     

  1309.     
  1310.     
  1311.     
  1312.     
  1313.     
  1314.     
  1315.     /**
  1316.      * Il Metodo si occupa di creare un messaggio di livello 'FATAL'. 
  1317.      * @deprecated in funzione del metodo logPersonalizzato
  1318.      *
  1319.      * @param msg Messaggio da registrare
  1320.      * 
  1321.      */
  1322.     @Deprecated
  1323.     public void fatal(String msg) {

  1325.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  1326.         
  1327.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_FATAL);
  1328.                 
  1329.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_FATAL);
  1330.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1331.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1332.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1333.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1334.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1335.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  1336.         }
  1337.         if(this.severitaPorta!=null) {
  1338.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1339.         }
  1340.         
  1341.         try{
  1342.             
  1343.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  1344.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1345.             if(!emettiLogSuFile && !emettiLog) {
  1346.                 return;
  1347.             }
  1348.             
  1349.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoFatal();
  1350.             
  1351.             // Data
  1352.             Date gdo = DateManager.getDate();
  1353.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1354.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1355.             }
  1356.             
  1357.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  1358.             
  1359.             // Messaggio diagnostici
  1360.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1361.             if( emettiLogSuFile ){

  1363.                 if(msgDiag==null){
  1364.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_FATAL, msg, codiceDiagnostico);
  1365.                 }
  1366.                 
  1367.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  1368.                     try{
  1369.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  1370.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_FATAL,xml);
  1371.                     }catch(Exception e){
  1372.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  1373.                         gestioneErroreDiagnostica(e);
  1374.                     }
  1375.                 }
  1376.                     
  1377.             }
  1378.             
  1379.             // Messaggio diagnostici
  1380.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1381.             if( emettiLog ){
  1382.                     
  1383.                 if(msgDiag==null){
  1384.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_FATAL, msg, codiceDiagnostico);
  1385.                 }
  1386.                 
  1387.                 if(msgDiag.getIdTransazione()!=null) {
  1388.                     
  1389.                     // TransazioneContext
  1390.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  1391.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  1392.                     }
  1393.                     
  1394.                     // Msg Diagnostico personalizzato
  1395.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  1396.                         try{
  1397.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  1398.                         }catch(Exception e){
  1399.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  1400.                             gestioneErroreDiagnostica(e);
  1401.                         }
  1402.                     }
  1403.                 }
  1404.                 else {
  1405.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  1406.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1407.                             this.porta,this.delegata,
  1408.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1409.                     try{
  1410.                         this.loggerResource.log(LogLevels.LOG_LEVEL_FATAL,message);

  1412.                     }catch(Exception e){
  1413.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  1414.                         gestioneErroreDiagnostica(e);
  1415.                     }
  1416.                 }
  1417.             }

  1419.             // Human Readable
  1420.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  1421.             boolean humanReadableAbilitato = false;
  1422.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1423.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  1424.             }else{
  1425.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  1426.             }
  1427.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  1428.                 
  1429.                 if(msgDiag==null){
  1430.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_FATAL, msg, codiceDiagnostico);
  1431.                 }
  1432.                 
  1433.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1434.                         this.porta,this.delegata,
  1435.                         this.fruitore,this.servizio,this.servizioApplicativo, this.protocolFactory);
  1436.                 try{
  1437.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1438.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_FATAL,message);
  1439.                     }else{
  1440.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_FATAL,message);
  1441.                     }
  1442.                 }catch(Exception e){
  1443.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  1444.                     gestioneErroreDiagnostica(e);
  1445.                 }
  1446.             }
  1447.             
  1448.             // Log emesso su console jboss
  1449.             // dalla versione 2.3, essendo utilizzato slf4j, si converte fatal in error.
  1450.             //this.loggerOpenSPCoop2Fatal.log(LogLevels.LOG_LEVEL_FATAL,msg);
  1451.             this.loggerOpenSPCoop2Fatal.error(msg);

  1453.         }catch(Exception e){
  1454.             logError("MsgDiagnostico.fatalOpenSPCoop error "+e.getMessage(),e);
  1455.             gestioneErroreDiagnostica(e);
  1456.         }
  1457.     }

  1459.     /**
  1460.      * Il Metodo si occupa di creare un messaggio di livello 'ERROR-PROTOCOL'.
  1461.      * @deprecated in funzione del metodo logPersonalizzato 
  1462.      *
  1463.      * @param msg Messaggio da registrare
  1464.      * 
  1465.      */
  1466.     @Deprecated
  1467.     public void errorProtocol(String msg) {
  1468.         
  1469.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  1470.         
  1471.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_ERROR_PROTOCOL);
  1472.         
  1473.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_ERROR_PROTOCOL);
  1474.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1475.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1476.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1477.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1478.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1479.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  1480.         }
  1481.         if(this.severitaPorta!=null) {
  1482.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1483.         }
  1484.         
  1485.         
  1486.         try{
  1487.             
  1488.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  1489.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1490.             if(!emettiLogSuFile && !emettiLog) {
  1491.                 return;
  1492.             }
  1493.             
  1494.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoErrorProtocol();
  1495.             
  1496.             // Data
  1497.             Date gdo = DateManager.getDate();
  1498.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1499.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1500.             }
  1501.             
  1502.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  1503.                         
  1504.             // Messaggio diagnostici
  1505.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1506.             if( emettiLogSuFile){

  1508.                 if(msgDiag==null){
  1509.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_ERROR_PROTOCOL, msg, codiceDiagnostico);
  1510.                 }
  1511.                 
  1512.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  1513.                     try{
  1514.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  1515.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_ERROR_PROTOCOL,xml);
  1516.                     }catch(Exception e){
  1517.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  1518.                         gestioneErroreDiagnostica(e);
  1519.                     }
  1520.                 }
  1521.                     
  1522.             }
  1523.             
  1524.             // Messaggio diagnostici
  1525.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1526.             if( emettiLog){
  1527.                     
  1528.                 if(msgDiag==null){
  1529.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_ERROR_PROTOCOL, msg, codiceDiagnostico);
  1530.                 }
  1531.                 
  1532.                 if(msgDiag.getIdTransazione()!=null) {
  1533.                     
  1534.                     // TransazioneContext
  1535.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  1536.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  1537.                     }
  1538.                     
  1539.                     // Msg Diagnostico personalizzato
  1540.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  1541.                         try{
  1542.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  1543.                         }catch(Exception e){
  1544.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  1545.                             gestioneErroreDiagnostica(e);
  1546.                         }
  1547.                     }
  1548.                 }
  1549.                 else {
  1550.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  1551.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1552.                             this.porta,this.delegata,
  1553.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1554.                     try{
  1555.                         this.loggerResource.log(LogLevels.LOG_LEVEL_ERROR_PROTOCOL,message);

  1557.                     }catch(Exception e){
  1558.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  1559.                         gestioneErroreDiagnostica(e);
  1560.                     }
  1561.                 }
  1562.             }

  1564.             // Human Readable
  1565.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  1566.             boolean humanReadableAbilitato = false;
  1567.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1568.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  1569.             }else{
  1570.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  1571.             }
  1572.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  1573.                 
  1574.                 if(msgDiag==null){
  1575.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_ERROR_PROTOCOL, msg, codiceDiagnostico);
  1576.                 }
  1577.                 
  1578.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  1579.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1580.                         this.porta,this.delegata,
  1581.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1582.                 try{
  1583.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1584.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_ERROR_PROTOCOL,message);
  1585.                     }else{
  1586.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_ERROR_PROTOCOL,message);
  1587.                     }
  1588.                 }catch(Exception e){
  1589.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  1590.                     gestioneErroreDiagnostica(e);
  1591.                 }
  1592.             }
  1593.         }catch(Exception e){
  1594.             logError("MsgDiagnostico.errorProtocol error "+e.getMessage(),e);
  1595.             gestioneErroreDiagnostica(e);
  1596.         }

  1598.     }

  1600.     /**
  1601.      * Il Metodo si occupa di creare un messaggio di livello 'ERROR-INTEGRATION'. 
  1602.      * @deprecated in funzione del metodo logPersonalizzato 
  1603.      *
  1604.      * @param msg Messaggio da registrare
  1605.      * 
  1606.      */
  1607.     @Deprecated
  1608.     public void errorIntegration(String msg) {
  1609.         
  1610.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  1611.         
  1612.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_ERROR_INTEGRATION);
  1613.         
  1614.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_ERROR_INTEGRATION);
  1615.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1616.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1617.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1618.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1619.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1620.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  1621.         }
  1622.         if(this.severitaPorta!=null) {
  1623.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1624.         }
  1625.         
  1626.         try{
  1627.             
  1628.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  1629.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1630.             if(!emettiLogSuFile && !emettiLog) {
  1631.                 return;
  1632.             }
  1633.             
  1634.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoErrorIntegration();
  1635.             
  1636.             // Data
  1637.             Date gdo = DateManager.getDate();
  1638.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1639.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1640.             }
  1641.             
  1642.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  1643.                         
  1644.             // Messaggio diagnostici
  1645.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1646.             if( emettiLogSuFile){

  1648.                 if(msgDiag==null){
  1649.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_ERROR_INTEGRATION, msg, codiceDiagnostico);
  1650.                 }
  1651.                 
  1652.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  1653.                     try{
  1654.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  1655.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_ERROR_INTEGRATION,xml);
  1656.                     }catch(Exception e){
  1657.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  1658.                         gestioneErroreDiagnostica(e);
  1659.                     }
  1660.                 }
  1661.                     
  1662.             }   
  1663.             
  1664.             // Messaggio diagnostici
  1665.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1666.             if( emettiLog){
  1667.                     
  1668.                 if(msgDiag==null){
  1669.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_ERROR_INTEGRATION, msg, codiceDiagnostico);
  1670.                 }
  1671.                 
  1672.                 if(msgDiag.getIdTransazione()!=null) {
  1673.                     
  1674.                     // TransazioneContext
  1675.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  1676.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  1677.                     }
  1678.                     
  1679.                     // Msg Diagnostico personalizzato
  1680.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  1681.                         try{
  1682.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  1683.                         }catch(Exception e){
  1684.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  1685.                             gestioneErroreDiagnostica(e);
  1686.                         }
  1687.                     }
  1688.                 }
  1689.                 else {
  1690.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  1691.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1692.                             this.porta,this.delegata,
  1693.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1694.                     try{
  1695.                         this.loggerResource.log(LogLevels.LOG_LEVEL_ERROR_INTEGRATION,message);

  1697.                     }catch(Exception e){
  1698.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  1699.                         gestioneErroreDiagnostica(e);
  1700.                     }
  1701.                 }
  1702.             }   

  1704.             // Human Readable
  1705.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  1706.             boolean humanReadableAbilitato = false;
  1707.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1708.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  1709.             }else{
  1710.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  1711.             }
  1712.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  1713.                 
  1714.                 if(msgDiag==null){
  1715.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_ERROR_INTEGRATION, msg, codiceDiagnostico);
  1716.                 }
  1717.                 
  1718.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  1719.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1720.                         this.porta,this.delegata,
  1721.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1722.                 try{
  1723.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1724.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_ERROR_INTEGRATION,message);
  1725.                     }else{
  1726.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_ERROR_INTEGRATION,message);
  1727.                     }
  1728.                 }catch(Exception e){
  1729.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  1730.                     gestioneErroreDiagnostica(e);
  1731.                 }
  1732.             }

  1734.         }catch(Exception e){
  1735.             logError("MsgDiagnostico.errorIntegration error "+e.getMessage(),e);
  1736.             gestioneErroreDiagnostica(e);
  1737.         }
  1738.     }
  1739.     
  1740.     /**
  1741.      * Il Metodo si occupa di creare un messaggio di livello 'INFO-PROTOCOL'. 
  1742.      * @deprecated in funzione del metodo logPersonalizzato 
  1743.      *
  1744.      * @param msg Messaggio da registrare
  1745.      * 
  1746.      */
  1747.     @Deprecated
  1748.     public void infoProtocol(String msg) {
  1749.         
  1750.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  1751.         
  1752.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_INFO_PROTOCOL);
  1753.         
  1754.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_INFO_PROTOCOL);
  1755.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1756.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1757.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1758.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1759.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1760.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  1761.         }
  1762.         if(this.severitaPorta!=null) {
  1763.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1764.         }
  1765.         
  1766.         try{
  1767.             
  1768.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  1769.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1770.             if(!emettiLogSuFile && !emettiLog) {
  1771.                 return;
  1772.             }
  1773.             
  1774.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoInfoProtocol();
  1775.             
  1776.             // Data
  1777.             Date gdo = DateManager.getDate();
  1778.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1779.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1780.             }
  1781.             
  1782.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  1783.                         
  1784.             // Messaggio diagnostici
  1785.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1786.             if( emettiLogSuFile){

  1788.                 if(msgDiag==null){
  1789.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_INFO_PROTOCOL, msg, codiceDiagnostico);
  1790.                 }
  1791.                 
  1792.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  1793.                     try{
  1794.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  1795.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_INFO_PROTOCOL,xml);
  1796.                     }catch(Exception e){
  1797.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  1798.                         gestioneErroreDiagnostica(e);
  1799.                     }
  1800.                 }
  1801.                     
  1802.             }
  1803.             
  1804.             // Messaggio diagnostici
  1805.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1806.             if( emettiLog){
  1807.                     
  1808.                 if(msgDiag==null){
  1809.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_INFO_PROTOCOL, msg, codiceDiagnostico);
  1810.                 }
  1811.                 
  1812.                 if(msgDiag.getIdTransazione()!=null) {
  1813.                     
  1814.                     // TransazioneContext
  1815.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  1816.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  1817.                     }
  1818.                     
  1819.                     // Msg Diagnostico personalizzato   
  1820.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  1821.                         try{
  1822.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  1823.                         }catch(Exception e){
  1824.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  1825.                             gestioneErroreDiagnostica(e);
  1826.                         }
  1827.                     }
  1828.                 }
  1829.                 else {
  1830.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  1831.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1832.                             this.porta,this.delegata,
  1833.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1834.                     try{
  1835.                         this.loggerResource.log(LogLevels.LOG_LEVEL_INFO_PROTOCOL,message);

  1837.                     }catch(Exception e){
  1838.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  1839.                         gestioneErroreDiagnostica(e);
  1840.                     }
  1841.                 }
  1842.             }

  1844.             // Human Readable
  1845.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  1846.             boolean humanReadableAbilitato = false;
  1847.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1848.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  1849.             }else{
  1850.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  1851.             }
  1852.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  1853.                 
  1854.                 if(msgDiag==null){
  1855.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_INFO_PROTOCOL, msg, codiceDiagnostico);
  1856.                 }
  1857.                 
  1858.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  1859.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1860.                         this.porta,this.delegata,
  1861.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1862.                 try{
  1863.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1864.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_INFO_PROTOCOL,message);
  1865.                     }else{
  1866.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_INFO_PROTOCOL,message);
  1867.                     }
  1868.                 }catch(Exception e){
  1869.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  1870.                     gestioneErroreDiagnostica(e);
  1871.                 }
  1872.             }

  1874.         }catch(Exception e){
  1875.             logError("MsgDiagnostico.infoProtocol error "+e.getMessage(),e);
  1876.             gestioneErroreDiagnostica(e);
  1877.         }

  1879.     }

  1881.     /**
  1882.      * Il Metodo si occupa di creare un messaggio di livello 'INFO-INTEGRATION'. 
  1883.      * @deprecated in funzione del metodo logPersonalizzato 
  1884.      *
  1885.      * @param msg Messaggio da registrare
  1886.      * 
  1887.      */
  1888.     @Deprecated
  1889.     public void infoIntegration(String msg) {
  1890.         
  1891.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  1892.         
  1893.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_INFO_INTEGRATION);
  1894.         
  1895.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_INFO_INTEGRATION);
  1896.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1897.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  1898.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  1899.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  1900.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  1901.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  1902.         }
  1903.         if(this.severitaPorta!=null) {
  1904.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  1905.         }
  1906.         
  1907.         try{
  1908.             
  1909.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  1910.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  1911.             if(!emettiLogSuFile && !emettiLog) {
  1912.                 return;
  1913.             }
  1914.             
  1915.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoInfoIntegration();
  1916.             
  1917.             // Data
  1918.             Date gdo = DateManager.getDate();
  1919.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1920.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1921.             }
  1922.             
  1923.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  1924.                         
  1925.             // Messaggio diagnostici
  1926.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1927.             if( emettiLogSuFile){

  1929.                 if(msgDiag==null){
  1930.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_INFO_INTEGRATION, msg, codiceDiagnostico);
  1931.                 }
  1932.                 
  1933.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  1934.                     try{
  1935.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  1936.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_INFO_INTEGRATION,xml);
  1937.                     }catch(Exception e){
  1938.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  1939.                         gestioneErroreDiagnostica(e);
  1940.                     }
  1941.                 }
  1942.                 
  1943.             }
  1944.             
  1945.             // Messaggio diagnostici
  1946.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  1947.             if( emettiLog){
  1948.                     
  1949.                 if(msgDiag==null){
  1950.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_INFO_INTEGRATION, msg, codiceDiagnostico);
  1951.                 }
  1952.                 
  1953.                 if(msgDiag.getIdTransazione()!=null) {
  1954.                     
  1955.                     // TransazioneContext
  1956.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  1957.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  1958.                     }
  1959.                     
  1960.                     // Msg Diagnostico personalizzato
  1961.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  1962.                         try{
  1963.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  1964.                         }catch(Exception e){
  1965.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  1966.                             gestioneErroreDiagnostica(e);
  1967.                         }
  1968.                     }
  1969.                 }
  1970.                 else {
  1971.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  1972.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  1973.                             this.porta,this.delegata,
  1974.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  1975.                     try{
  1976.                         this.loggerResource.log(LogLevels.LOG_LEVEL_INFO_INTEGRATION,message);

  1978.                     }catch(Exception e){
  1979.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  1980.                         gestioneErroreDiagnostica(e);
  1981.                     }
  1982.                 }
  1983.             }

  1985.             // Human Readable
  1986.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  1987.             boolean humanReadableAbilitato = false;
  1988.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  1989.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  1990.             }else{
  1991.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  1992.             }
  1993.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  1994.                 
  1995.                 if(msgDiag==null){
  1996.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_INFO_INTEGRATION, msg, codiceDiagnostico);
  1997.                 }
  1998.                 
  1999.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  2000.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2001.                         this.porta,this.delegata,
  2002.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2003.                 try{
  2004.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2005.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_INFO_INTEGRATION,message);
  2006.                     }else{
  2007.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_INFO_INTEGRATION,message);
  2008.                     }
  2009.                 }catch(Exception e){
  2010.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  2011.                     gestioneErroreDiagnostica(e);
  2012.                 }
  2013.             }

  2015.         }catch(Exception e){
  2016.             logError("MsgDiagnostico.infoIntegration error "+e.getMessage(),e);
  2017.             gestioneErroreDiagnostica(e);
  2018.         }

  2020.     }

  2022.     /**
  2023.      * Il Metodo si occupa di creare un messaggio di livello 'DEBUG-LOW'. 
  2024.      * @deprecated in funzione del metodo logPersonalizzato
  2025.      * @param msg Messaggio da registrare
  2026.      * 
  2027.      */
  2028.     @Deprecated
  2029.     public void lowDebug(String msg){
  2030.         
  2031.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  2032.         
  2033.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_DEBUG_LOW);
  2034.         
  2035.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_DEBUG_LOW);
  2036.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  2037.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  2038.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  2039.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  2040.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  2041.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  2042.         }
  2043.         if(this.severitaPorta!=null) {
  2044.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  2045.         }
  2046.         
  2047.         try{
  2048.             
  2049.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  2050.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  2051.             if(!emettiLogSuFile && !emettiLog) {
  2052.                 return;
  2053.             }
  2054.             
  2055.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoDebugLow();
  2056.             
  2057.             // Data
  2058.             Date gdo = DateManager.getDate();
  2059.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2060.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  2061.             }
  2062.             
  2063.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  2064.                         
  2065.             // Messaggio diagnostici
  2066.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  2067.             if( emettiLogSuFile){

  2069.                 if(msgDiag==null){
  2070.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_LOW, msg, codiceDiagnostico);
  2071.                 }
  2072.                 
  2073.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  2074.                     try{
  2075.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  2076.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_DEBUG_LOW,xml);
  2077.                     }catch(Exception e){
  2078.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  2079.                         gestioneErroreDiagnostica(e);
  2080.                     }
  2081.                 }

  2083.             }

  2085.             // Messaggio diagnostici
  2086.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  2087.             if( emettiLog){
  2088.                     
  2089.                 if(msgDiag==null){
  2090.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_LOW, msg, codiceDiagnostico);
  2091.                 }
  2092.                 
  2093.                 if(msgDiag.getIdTransazione()!=null) {
  2094.                     
  2095.                     // TransazioneContext
  2096.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  2097.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  2098.                     }
  2099.                     
  2100.                     // Msg Diagnostico personalizzato
  2101.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  2102.                         try{
  2103.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  2104.                         }catch(Exception e){
  2105.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  2106.                             gestioneErroreDiagnostica(e);
  2107.                         }
  2108.                     }
  2109.                 }
  2110.                 else {
  2111.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  2112.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2113.                             this.porta,this.delegata,
  2114.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2115.                     try{
  2116.                         this.loggerResource.log(LogLevels.LOG_LEVEL_DEBUG_LOW,message);

  2118.                     }catch(Exception e){
  2119.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  2120.                         gestioneErroreDiagnostica(e);
  2121.                     }
  2122.                 }
  2123.             }
  2124.             
  2125.             // Human Readable
  2126.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  2127.             boolean humanReadableAbilitato = false;
  2128.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2129.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  2130.             }else{
  2131.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  2132.             }
  2133.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  2134.                 
  2135.                 if(msgDiag==null){
  2136.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_LOW, msg, codiceDiagnostico);
  2137.                 }
  2138.                 
  2139.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  2140.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2141.                         this.porta,this.delegata,
  2142.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2143.                 try{
  2144.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2145.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_DEBUG_LOW,message);
  2146.                     }else{
  2147.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_DEBUG_LOW,message);
  2148.                     }
  2149.                 }catch(Exception e){
  2150.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  2151.                     gestioneErroreDiagnostica(e);
  2152.                 }
  2153.             }

  2155.         }catch(Exception e){
  2156.             logError("MsgDiagnostico.lowDebug error "+e.getMessage(),e);
  2157.             gestioneErroreDiagnostica(e);
  2158.         }
  2159.     }

  2161.     /**
  2162.      * Il Metodo si occupa di creare un messaggio di livello 'DEBUG-MEDIUM'. 
  2163.      *
  2164.      * @param msg Messaggio da registrare
  2165.      * 
  2166.      */
  2167.     public void mediumDebug(String msg) {
  2168.         
  2169.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  2170.         
  2171.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_DEBUG_MEDIUM);
  2172.         
  2173.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_DEBUG_MEDIUM);
  2174.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  2175.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  2176.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  2177.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  2178.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  2179.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  2180.         }
  2181.         if(this.severitaPorta!=null) {
  2182.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  2183.         }
  2184.         
  2185.         try{
  2186.             
  2187.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  2188.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  2189.             if(!emettiLogSuFile && !emettiLog) {
  2190.                 return;
  2191.             }
  2192.             
  2193.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoDebugMedium();
  2194.             
  2195.             // Data
  2196.             Date gdo = DateManager.getDate();
  2197.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2198.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  2199.             }
  2200.             
  2201.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  2202.                         
  2203.             // Messaggio diagnostici
  2204.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  2205.             if( emettiLogSuFile){

  2207.                 if(msgDiag==null){
  2208.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_MEDIUM, msg, codiceDiagnostico);
  2209.                 }
  2210.                 
  2211.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  2212.                     try{
  2213.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  2214.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_DEBUG_MEDIUM,xml);
  2215.                     }catch(Exception e){
  2216.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  2217.                         gestioneErroreDiagnostica(e);
  2218.                     }
  2219.                 }

  2221.             }
  2222.             
  2223.             // Messaggio diagnostici
  2224.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  2225.             if( emettiLog){
  2226.                     
  2227.                 if(msgDiag==null){
  2228.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_MEDIUM, msg, codiceDiagnostico);
  2229.                 }
  2230.                 
  2231.                 if(msgDiag.getIdTransazione()!=null) {
  2232.                     
  2233.                     // TransazioneContext
  2234.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  2235.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  2236.                     }
  2237.                     
  2238.                     //  Msg Diagnostico personalizzato
  2239.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  2240.                         try{
  2241.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  2242.                         }catch(Exception e){
  2243.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  2244.                             gestioneErroreDiagnostica(e);
  2245.                         }
  2246.                     }
  2247.                 }
  2248.                 else {
  2249.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  2250.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2251.                             this.porta,this.delegata,
  2252.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2253.                     try{
  2254.                         this.loggerResource.log(LogLevels.LOG_LEVEL_DEBUG_MEDIUM,message);

  2256.                     }catch(Exception e){
  2257.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  2258.                         gestioneErroreDiagnostica(e);
  2259.                     }
  2260.                 }
  2261.             }

  2263.             // Human Readable
  2264.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  2265.             boolean humanReadableAbilitato = false;
  2266.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2267.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  2268.             }else{
  2269.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  2270.             }
  2271.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  2272.                 
  2273.                 if(msgDiag==null){
  2274.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_MEDIUM, msg, codiceDiagnostico);
  2275.                 }
  2276.                 
  2277.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  2278.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2279.                         this.porta,this.delegata,
  2280.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2281.                 try{
  2282.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2283.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_DEBUG_MEDIUM,message);
  2284.                     }else{
  2285.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_DEBUG_MEDIUM,message);
  2286.                     }
  2287.                 }catch(Exception e){
  2288.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  2289.                     gestioneErroreDiagnostica(e);
  2290.                 }
  2291.             }

  2293.         }catch(Exception e){
  2294.             logError("MsgDiagnostico.mediumDebug error "+e.getMessage(),e);
  2295.             gestioneErroreDiagnostica(e);
  2296.         }

  2298.     }

  2300.     /**
  2301.      * Il Metodo si occupa di creare un messaggio di livello 'DEBUG-HIGH'. 
  2302.      *
  2303.      * @param msg Messaggio da registrare
  2304.      * 
  2305.      */
  2306.     public void highDebug(String msg){
  2307.         
  2308.         String codiceDiagnostico = null; // con questi metodi viene fornito un unico codice diagnostico associato ad ogni messaggio di questo livello
  2309.         
  2310.         this.setEmitErrorConditionInContext(LogLevels.SEVERITA_DEBUG_HIGH);
  2311.         
  2312.         int severitaLogEmessoPerFiltro = LogLevels.toIntervalloLog4J(LogLevels.SEVERITA_DEBUG_HIGH);
  2313.         int severitaRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  2314.         int severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getFiltroMsgDiagnosticoOpenSPCoop2level7();
  2315.         ConfigurazionePdDManager configurazionePdDReader = getConfigurazionePdDManager();
  2316.         if(configurazionePdDReader!=null && configurazionePdDReader.isInitializedConfigurazionePdDReader()){
  2317.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaMessaggiDiagnostici());
  2318.             severitaLog4JRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(configurazionePdDReader.getSeveritaLog4JMessaggiDiagnostici());
  2319.         }
  2320.         if(this.severitaPorta!=null) {
  2321.             severitaRichiestaPdD = this.msgDiagPropertiesReader.getValoreFiltroFromValoreOpenSPCoop2(LogLevels.toOpenSPCoop2(this.severitaPorta.getValue()));
  2322.         }
  2323.         
  2324.         try{
  2325.             
  2326.             boolean emettiLogSuFile = (severitaLogEmessoPerFiltro <= severitaLog4JRichiestaPdD);
  2327.             boolean emettiLog = (severitaLogEmessoPerFiltro <= severitaRichiestaPdD);
  2328.             if(!emettiLogSuFile && !emettiLog) {
  2329.                 return;
  2330.             }
  2331.             
  2332.             codiceDiagnostico = this.msgDiagPropertiesReader.getCodiceDiagnosticoDebugHigh();
  2333.             
  2334.             // Data
  2335.             Date gdo = DateManager.getDate();
  2336.             if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2337.                 gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  2338.             }
  2339.             
  2340.             org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = null;
  2341.                         
  2342.             // Messaggio diagnostici
  2343.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  2344.             if( emettiLogSuFile){

  2346.                 if(msgDiag==null){
  2347.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_HIGH, msg, codiceDiagnostico);
  2348.                 }
  2349.                 
  2350.                 if(OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato){
  2351.                     try{
  2352.                         String xml = this.diagnosticoBuilder.toString(msgDiag,TipoSerializzazione.DEFAULT);
  2353.                         this.loggerMsgDiagnostico.log(LogLevels.LOG_LEVEL_DEBUG_HIGH,xml);
  2354.                     }catch(Exception e){
  2355.                         logError("Errore durante l'emissione del msg diagnostico su log4j (struttura xml): "+e.getMessage(),e);
  2356.                         gestioneErroreDiagnostica(e);
  2357.                     }
  2358.                 }
  2359.                     
  2360.             }
  2361.             
  2362.             // Messaggio diagnostici
  2363.             // System.out.println("1. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaRichiestaPdD+"]");
  2364.             if( emettiLog){
  2365.                 
  2366.                 if(msgDiag==null){
  2367.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_HIGH, msg, codiceDiagnostico);
  2368.                 }
  2369.                 
  2370.                 if(msgDiag.getIdTransazione()!=null) {
  2371.                     
  2372.                     // TransazioneContext
  2373.                     if(this.openspcoopProperties.isTransazioniSaveDiagnosticiInUniqueTransaction()) {
  2374.                         this.logMsgDiagnosticoInTransactionContext(msgDiag);
  2375.                     }
  2376.                     
  2377.                     // Msg Diagnostico personalizzato
  2378.                     for(int i=0; i<this.loggerMsgDiagnosticoOpenSPCoopAppender.size();i++){
  2379.                         try{
  2380.                             this.loggerMsgDiagnosticoOpenSPCoopAppender.get(i).log(this.getConnectionFromState(),msgDiag);
  2381.                         }catch(Exception e){
  2382.                             logError("Errore durante l'emissione del msg diagnostico personalizzato ["+this.tipoMsgDiagnosticoOpenSPCoopAppender.get(i)+"]: "+e.getMessage(),e);
  2383.                             gestioneErroreDiagnostica(e);
  2384.                         }
  2385.                     }
  2386.                 }
  2387.                 else {
  2388.                     // i diagnostici di sistema comunque non li registro sugli appender personalizzati.
  2389.                     String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2390.                             this.porta,this.delegata,
  2391.                             this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2392.                     try{
  2393.                         this.loggerResource.log(LogLevels.LOG_LEVEL_DEBUG_HIGH,message);

  2395.                     }catch(Exception e){
  2396.                         logError("Errore durante l'emissione del msg diagnostico 'human readable' nel log delle risorse (id transazione non fornito): "+e.getMessage(),e);
  2397.                         gestioneErroreDiagnostica(e);
  2398.                     }
  2399.                 }
  2400.             }

  2402.             // Human Readable
  2403.             // System.out.println("2. ["+severitaLogEmessoPerFiltro+"] <= ["+severitaOpenSPCoopRichiestaPdD+"]");
  2404.             boolean humanReadableAbilitato = false;
  2405.             if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2406.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerIntegrationManagerAbilitato;
  2407.             }else{
  2408.                 humanReadableAbilitato = OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato;
  2409.             }
  2410.             if( humanReadableAbilitato &&  (emettiLogSuFile) ){
  2411.                 
  2412.                 if(msgDiag==null){
  2413.                     msgDiag = this.getMsgDiagnostico(gdo, LogLevels.SEVERITA_DEBUG_HIGH, msg, codiceDiagnostico);
  2414.                 }
  2415.                 
  2416.                 //ProtocolFactory protocolFactory = ProtocolFactoryManager.getInstance((String) this.pddContext.getObject(CostantiPdD.PROTOCOLLO));
  2417.                 String message = OpenSPCoop2Logger.humanReadable(msgDiag,this.idCorrelazioneApplicativa,this.idCorrelazioneRisposta,
  2418.                         this.porta,this.delegata,
  2419.                         this.fruitore,this.servizio,this.servizioApplicativo,this.protocolFactory);
  2420.                 try{
  2421.                     if( IntegrationManager.ID_MODULO.equals(this.idModulo)){ 
  2422.                         this.loggerIntegrationManager.log(LogLevels.LOG_LEVEL_DEBUG_HIGH,message);
  2423.                     }else{
  2424.                         this.loggerOpenSPCoop2.log(LogLevels.LOG_LEVEL_DEBUG_HIGH,message);
  2425.                     }
  2426.                 }catch(Exception e){
  2427.                     logError("Errore durante l'emissione del msg diagnostico 'human readable': "+e.getMessage(),e);
  2428.                     gestioneErroreDiagnostica(e);
  2429.                 }
  2430.             }

  2432.         }catch(Exception e){
  2433.             logError("MsgDiagnostico.highDebug error "+e.getMessage(),e);
  2434.             gestioneErroreDiagnostica(e);
  2435.         }
  2436.     }

  2438.     
  2439.     
  2440.     private void logMsgDiagnosticoInTransactionContext(org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag) {
  2441.         
  2442.         if(this.transazioneApplicativoServer!=null) {
  2443.             try {
  2444.                 // forzo
  2445.                 msgDiag.setIdTransazione(this.transazioneApplicativoServer.getIdTransazione());
  2446.                 msgDiag.setApplicativo(this.transazioneApplicativoServer.getServizioApplicativoErogatore());
  2447.                 GestoreConsegnaMultipla.getInstance().safeSave(msgDiag, this.idPortaApplicativa, this.getValidConnectionState(), this.requestInfo, this.pddContext);
  2448.             }catch(Throwable t) {
  2449.                 logError("Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  2450.                 gestioneErroreDiagnostica(t);
  2451.             }
  2452.         }
  2453.         else {
  2454.         
  2455.             Exception exc = null;
  2456.             boolean gestioneStateful = false;
  2457.             try {
  2458.                 Transaction tr = TransactionContext.getTransaction(msgDiag.getIdTransazione());
  2459.                 tr.addMsgDiagnostico(msgDiag);
  2460.             }catch(TransactionDeletedException e){
  2461.                 gestioneStateful = true;
  2462.             }catch(TransactionNotExistsException e){
  2463.                 gestioneStateful = true;
  2464.             }catch(Exception e){
  2465.                 exc = e;
  2466.             }
  2467.             if(gestioneStateful){
  2468.                 try{
  2469.                     //System.out.println("@@@@@REPOSITORY@@@@@ LOG MSG DIAG ID TRANSAZIONE ["+idTransazione+"] ADD");
  2470.                     RepositoryGestioneStateful.addMsgDiagnostico(msgDiag.getIdTransazione(), msgDiag);
  2471.                 }catch(Exception e){
  2472.                     if(!IntegrationManager.ID_MODULO.equals(this.idModulo) &&
  2473.                             !("["+org.openspcoop2.pdd.core.handlers.transazioni.PostOutResponseHandler.class.getName()+"] invocazione terminata").equals(msgDiag.getMessaggio())
  2474.                         ) { //
  2475.                         exc = e;
  2476.                     }
  2477.                 }
  2478.             }
  2479.             if(exc!=null) {
  2480.                 logError("Errore durante l'emissione del msg diagnostico nel contesto della transazione: "+exc.getMessage(),exc);
  2481.                 gestioneErroreDiagnostica(exc);
  2482.             }
  2483.         }
  2484.     }
  2485.     
  2486.     
  2487.     private org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico getMsgDiagnostico(Date gdo,int severitaLivelloOpenSPCoop2,String msg,String codiceDiagnostico){
  2488.         
  2489.         org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiagnostico = new org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico();
  2490.         
  2491.         if(this.pddContext!=null && this.pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  2492.             msgDiagnostico.setIdTransazione((String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  2493.         }
  2494.         
  2495.         msgDiagnostico.setGdo(gdo);
  2496.         
  2497.         msgDiagnostico.setIdSoggetto(this.idSoggettoDominio);
  2498.         msgDiagnostico.setIdFunzione(this.idModulo);
  2499.         msgDiagnostico.setSeverita(severitaLivelloOpenSPCoop2);
  2500.         msgDiagnostico.setMessaggio(msg);
  2501.         
  2502.         msgDiagnostico.setIdBusta(this.idMessaggioRichiesta);
  2503.         msgDiagnostico.setIdBustaRisposta(this.idMessaggioRisposta);
  2504.         msgDiagnostico.setCodice(codiceDiagnostico);
  2505.         
  2506.         msgDiagnostico.setApplicativo(this.servizioApplicativo);
  2507.         
  2508.         msgDiagnostico.setProtocollo(this.protocolFactory.getProtocol());
  2509.         
  2510.         if(this.pddContext!=null){
  2511.             List<MapKey<String>> keys = org.openspcoop2.core.constants.Costanti.CONTEXT_OBJECT;
  2512.             if(keys!=null){
  2513.                 for (int j = 0; j < keys.size(); j++) {
  2514.                     MapKey<String> mapKey = keys.get(j);
  2515.                     Object o = this.pddContext.getObject(mapKey);
  2516.                     if(o!=null && o instanceof String){
  2517.                         msgDiagnostico.addProperty(mapKey.getValue(), (String)o);
  2518.                     }
  2519.                 }
  2520.             }
  2521.         }
  2522.         
  2523.         if(this.properties!=null){
  2524.             this.properties.forEach( (k,v) -> msgDiagnostico.addProperty(k, v) );
  2525.         }
  2526.         
  2527.         return msgDiagnostico;
  2528.     }
  2529.     
  2530.     private void gestioneErroreDiagnostica(Throwable e) {
  2531.         
  2532.         if(this.openspcoopProperties.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD()){
  2533.             MsgDiagnostico.gestoreDiagnosticaDisponibile=false;
  2534.             MsgDiagnostico.motivoMalfunzionamentoDiagnostici=e;
  2535.             logError("Il Sistema di gestione della diagnostica ha rilevato un errore durante la registrazione di un messaggio diagnostico,"+
  2536.                     " tutti i servizi/moduli della porta di dominio sono sospesi. Si richiede un intervento sistemistico per la risoluzione del problema "+
  2537.                     "e il riavvio di GovWay. Errore rilevato: ",e);
  2538.         }
  2539.         
  2540.     }
  2541.     
  2542.     private void logError(String msgErrore,Throwable e){
  2543.         if(this.loggerOpenSPCoop2Core!=null){
  2544.             this.loggerOpenSPCoop2Core.error(msgErrore,e);
  2545.         }
  2546.         else if(OpenSPCoop2Logger.loggerOpenSPCoopCore!=null){
  2547.             OpenSPCoop2Logger.loggerOpenSPCoopCore.error(msgErrore,e);
  2548.         }
  2549.         
  2550.         // Registro l'errore anche in questo logger.
  2551.         if(OpenSPCoop2Logger.loggerOpenSPCoopResources!=null){
  2552.             OpenSPCoop2Logger.loggerOpenSPCoopResources.error(msgErrore,e);
  2553.         }
  2554.         
  2555.     }
  2556.     private void logError(String msgErrore){
  2557.         if(this.loggerOpenSPCoop2Core!=null){
  2558.             this.loggerOpenSPCoop2Core.error(msgErrore);
  2559.         }
  2560.         else if(OpenSPCoop2Logger.loggerOpenSPCoopCore!=null){
  2561.             OpenSPCoop2Logger.loggerOpenSPCoopCore.error(msgErrore);
  2562.         }
  2563.         
  2564.         // Registro l'errore anche in questo logger.
  2565.         if(OpenSPCoop2Logger.loggerOpenSPCoopResources!=null){
  2566.             OpenSPCoop2Logger.loggerOpenSPCoopResources.error(msgErrore);
  2567.         }
  2568.         
  2569.     }
  2570. }
Created with JaCoCo 0.8.8.202204050719