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

  21. package org.openspcoop2.pdd.logger;

  23. import java.sql.Connection;
  24. import java.sql.DriverManager;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Properties;

  31. import javax.naming.InitialContext;
  32. import javax.sql.DataSource;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.core.commons.dao.DAOFactory;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.core.transazioni.CredenzialeMittente;
  38. import org.openspcoop2.core.transazioni.Transazione;
  39. import org.openspcoop2.core.transazioni.dao.IDBCredenzialeMittenteServiceSearch;
  40. import org.openspcoop2.core.transazioni.dao.ITransazioneServiceSearch;
  41. import org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager;
  42. import org.openspcoop2.core.transazioni.utils.CredenzialiMittente;
  43. import org.openspcoop2.core.transazioni.utils.ProjectInfo;
  44. import org.openspcoop2.generic_project.beans.IField;
  45. import org.openspcoop2.generic_project.exception.MultipleResultException;
  46. import org.openspcoop2.generic_project.exception.NotFoundException;
  47. import org.openspcoop2.generic_project.exception.NotImplementedException;
  48. import org.openspcoop2.generic_project.exception.ServiceException;
  49. import org.openspcoop2.generic_project.expression.IPaginatedExpression;
  50. import org.openspcoop2.pdd.logger.diagnostica.ConvertitoreCodiceDiagnostici;
  51. import org.openspcoop2.pdd.logger.diagnostica.InformazioniRecordDiagnostici;
  52. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  53. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  54. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  55. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  56. import org.openspcoop2.protocol.sdk.diagnostica.DriverMsgDiagnosticiException;
  57. import org.openspcoop2.protocol.sdk.diagnostica.DriverMsgDiagnosticiNotFoundException;
  58. import org.openspcoop2.protocol.sdk.diagnostica.FiltroRicercaDiagnostici;
  59. import org.openspcoop2.protocol.sdk.diagnostica.FiltroRicercaDiagnosticiConPaginazione;
  60. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticDriver;
  61. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico;
  62. import org.openspcoop2.protocol.sdk.tracciamento.DriverTracciamentoException;
  63. import org.openspcoop2.protocol.sdk.tracciamento.DriverTracciamentoNotFoundException;
  64. import org.openspcoop2.protocol.sdk.tracciamento.Traccia;
  65. import org.openspcoop2.protocol.utils.EsitiProperties;
  66. import org.openspcoop2.utils.LoggerWrapperFactory;
  67. import org.openspcoop2.utils.TipiDatabase;
  68. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  69. import org.slf4j.Logger;

  71. /**     
  72.  * TransactionDriverMsgDiagnostici
  73.  *
  74.  * @author Poli Andrea (poli@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */
  78. public class TransactionDriverMsgDiagnostici implements IDiagnosticDriver {


  81.     @Override
  82.     public IProtocolFactory<?> getProtocolFactory() {
  83.         return null;
  84.     }

  86.     private static final String TIPO_DB_NON_GESTITO = "Tipo database non gestito";

  88.     /** 
  89.      * DataSource
  90.      */
  91.     DataSource datasource = null;

  93.     /** 
  94.      * Connection
  95.      */
  96.     Connection connection = null;
  97.     boolean connectionOpenViaJDBCInCostructor = false;

  99.     /**
  100.      * SQLQueryObject
  101.      */
  102.     String tipoDatabase = null;

  104.     /** DriverMsgDiagnostici originale */
  105.     DriverMsgDiagnostici driverMsgDiagnostici = null;

  107.     /** DAO Factory */
  108.     DAOFactory daoFactory = null;

  110.     /** Logger utilizzato per info. */
  111.     private Logger log = null;

  113.     public TransactionDriverMsgDiagnostici(String nomeDataSource, String tipoDatabase, Properties prop) throws DriverMsgDiagnosticiException {
  114.         this(nomeDataSource,tipoDatabase,prop,null);
  115.     }

  117.     public TransactionDriverMsgDiagnostici(String nomeDataSource, String tipoDatabase, Properties prop, Logger log) throws DriverMsgDiagnosticiException {
  118.         // Logger
  119.         try {
  120.             if(log==null)
  121.                 this.log = LoggerWrapperFactory.getLogger(org.openspcoop2.protocol.basic.Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  122.             else
  123.                 this.log = log;
  124.         } catch (Exception e) {
  125.             throw new DriverMsgDiagnosticiException("(ds jndiName) Errore durante l'inizializzazione del logger: "+e.getMessage(),e);
  126.         }

  128.         // Datasource
  129.         try {
  130.             InitialContext initCtx = new InitialContext(prop);
  131.             this.datasource = (DataSource) initCtx.lookup(nomeDataSource);
  132.             if (this.datasource == null)
  133.                 throw new DriverMsgDiagnosticiException ("datasource is null");

  135.             initCtx.close();
  136.         } catch (Exception e) {
  137.             throw new DriverMsgDiagnosticiException("(ds jndiName) Errore durante la ricerca del datasource: "+e.getMessage(),e);
  138.         }

  140.         // ISQLQueryObject
  141.         try {
  142.             if (TipiDatabase.isAMember(tipoDatabase)) {
  143.                 this.tipoDatabase = tipoDatabase;               
  144.             } else {
  145.                 throw new DriverMsgDiagnosticiException(TIPO_DB_NON_GESTITO);
  146.             }
  147.         } catch (Exception e) {
  148.             throw new DriverMsgDiagnosticiException("(ds jndiName) Errore durante la ricerca del SQLQueryObject: "+e.getMessage(),e);
  149.         }

  151.         // Driver msg diagnostici
  152.         try{
  153.             this.driverMsgDiagnostici = new DriverMsgDiagnostici(nomeDataSource, tipoDatabase, prop, log);
  154.         } catch (Exception e) {
  155.             throw new DriverMsgDiagnosticiException("(ds jndiName) Errore durante l'inizializzazione del driver dei messaggi diagnostici: "+e.getMessage(),e);
  156.         }   

  158.         // DAO Factory
  159.         try{
  160.             this.daoFactory = DAOFactory.getInstance(log);
  161.         }catch (Exception e) {
  162.             throw new DriverMsgDiagnosticiException("(ds jndiName) Errore durante l'inizializzazione del dao factory: "+e.getMessage(),e);
  163.         }

  165.     }

  167.     public TransactionDriverMsgDiagnostici(DataSource dataSourceObject, String tipoDatabase) throws DriverMsgDiagnosticiException {
  168.         this(dataSourceObject,tipoDatabase,null);
  169.     }

  171.     public TransactionDriverMsgDiagnostici(DataSource dataSourceObject, String tipoDatabase, Logger log) throws DriverMsgDiagnosticiException {
  172.         // Logger
  173.         try {
  174.             if(log==null)
  175.                 this.log = LoggerWrapperFactory.getLogger(org.openspcoop2.protocol.basic.Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  176.             else
  177.                 this.log = log;
  178.         } catch (Exception e) {
  179.             throw new DriverMsgDiagnosticiException("(ds) Errore durante l'inizializzazione del logger: "+e.getMessage(),e);
  180.         }

  182.         // Datasource
  183.         try {
  184.             this.datasource = dataSourceObject;
  185.             if (this.datasource == null)
  186.                 throw new DriverMsgDiagnosticiException ("datasource is null");
  187.         } catch (Exception e) {
  188.             throw new DriverMsgDiagnosticiException("(ds) Errore durante la ricerca del datasource: "+e.getMessage(),e);
  189.         }

  191.         // ISQLQueryObject
  192.         try {
  193.             if (TipiDatabase.isAMember(tipoDatabase)) {
  194.                 this.tipoDatabase = tipoDatabase;               
  195.             } else {
  196.                 throw new DriverMsgDiagnosticiException(TIPO_DB_NON_GESTITO);
  197.             }
  198.         } catch (Exception e) {
  199.             throw new DriverMsgDiagnosticiException("(ds) Errore durante la ricerca del SQLQueryObject: "+e.getMessage(),e);
  200.         }

  202.         // Driver msg diagnostici
  203.         try{
  204.             this.driverMsgDiagnostici = new DriverMsgDiagnostici(this.datasource, tipoDatabase, log);
  205.         } catch (Exception e) {
  206.             throw new DriverMsgDiagnosticiException("(ds) Errore durante l'inizializzazione del driver dei messaggi diagnostici: "+e.getMessage(),e);
  207.         }   

  209.         // DAO Factory
  210.         try{
  211.             this.daoFactory = DAOFactory.getInstance(log);
  212.         }catch (Exception e) {
  213.             throw new DriverMsgDiagnosticiException("(ds) Errore durante l'inizializzazione del dao factory: "+e.getMessage(),e);
  214.         }
  215.     }

  217.     public TransactionDriverMsgDiagnostici(Connection connection, String tipoDatabase) throws DriverMsgDiagnosticiException {
  218.         this(connection,tipoDatabase,null);
  219.     }
  220.     public TransactionDriverMsgDiagnostici(Connection connection, String tipoDatabase, Logger log) throws DriverMsgDiagnosticiException {

  222.         // Logger
  223.         try {
  224.             if(log==null)
  225.                 this.log = LoggerWrapperFactory.getLogger(org.openspcoop2.protocol.basic.Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  226.             else
  227.                 this.log = log;
  228.         } catch (Exception e) {
  229.             throw new DriverMsgDiagnosticiException("(connection) Errore durante l'inizializzazione del logger: "+e.getMessage(),e);
  230.         }

  232.         // connection
  233.         this.connection = connection;

  235.         // ISQLQueryObject
  236.         try {
  237.             if (TipiDatabase.isAMember(tipoDatabase)) {
  238.                 this.tipoDatabase = tipoDatabase;               
  239.             } else {
  240.                 throw new DriverMsgDiagnosticiException(TIPO_DB_NON_GESTITO);
  241.             }
  242.         } catch (Exception e) {
  243.             throw new DriverMsgDiagnosticiException("(connection) Errore durante la ricerca del SQLQueryObject: "+e.getMessage(),e);
  244.         }

  246.         // Driver msg diagnostici
  247.         try{
  248.             this.driverMsgDiagnostici = new DriverMsgDiagnostici(this.connection, tipoDatabase, log);
  249.         } catch (Exception e) {
  250.             throw new DriverMsgDiagnosticiException("(connection) Errore durante l'inizializzazione del driver dei messaggi diagnostici: "+e.getMessage(),e);
  251.         }   

  253.         // DAO Factory
  254.         try{
  255.             this.daoFactory = DAOFactory.getInstance(log);
  256.         }catch (Exception e) {
  257.             throw new DriverMsgDiagnosticiException("(connection) Errore durante l'inizializzazione del dao factory: "+e.getMessage(),e);
  258.         }
  259.     }


  262.     public TransactionDriverMsgDiagnostici(String urlJDBC,String driverJDBC,
  263.             String username,String password, String tipoDatabase) throws DriverMsgDiagnosticiException {
  264.         this(urlJDBC,driverJDBC,username,password,tipoDatabase,null);
  265.     }
  266.     public TransactionDriverMsgDiagnostici(String urlJDBC,String driverJDBC,
  267.             String username,String password, String tipoDatabase, Logger log) throws DriverMsgDiagnosticiException {

  269.         // Logger
  270.         try {
  271.             if(log==null)
  272.                 this.log = LoggerWrapperFactory.getLogger(org.openspcoop2.protocol.basic.Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  273.             else
  274.                 this.log = log;
  275.         } catch (Exception e) {
  276.             throw new DriverMsgDiagnosticiException("(connection url) Errore durante l'inizializzazione del logger: "+e.getMessage(),e);
  277.         }

  279.         // connection
  280.         try {
  281.             Class.forName(driverJDBC);

  283.             if(username!=null){
  284.                 this.connection = DriverManager.getConnection(urlJDBC,username,password);
  285.             }else{
  286.                 this.connection = DriverManager.getConnection(urlJDBC);
  287.             }
  288.             this.connectionOpenViaJDBCInCostructor = true;

  290.         } catch (Exception e) {
  291.             throw new DriverMsgDiagnosticiException("(connection url) Errore durante l'inizializzazione della connessione...",e);
  292.         }

  294.         // ISQLQueryObject
  295.         try {
  296.             if (TipiDatabase.isAMember(tipoDatabase)) {
  297.                 this.tipoDatabase = tipoDatabase;               
  298.             } else {
  299.                 throw new DriverMsgDiagnosticiException(TIPO_DB_NON_GESTITO);
  300.             }
  301.         } catch (Exception e) {
  302.             throw new DriverMsgDiagnosticiException("(connection url) Errore durante la ricerca del SQLQueryObject: "+e.getMessage(),e);
  303.         }

  305.         // Driver msg diagnostici
  306.         try{
  307.             this.driverMsgDiagnostici = new DriverMsgDiagnostici(this.connection, tipoDatabase, log);
  308.         } catch (Exception e) {
  309.             throw new DriverMsgDiagnosticiException("(connection url) Errore durante l'inizializzazione del driver dei messaggi diagnostici: "+e.getMessage(),e);
  310.         }   

  312.         // DAO Factory
  313.         try{
  314.             this.daoFactory = DAOFactory.getInstance(log);
  315.         }catch (Exception e) {
  316.             throw new DriverMsgDiagnosticiException("(connection url) Errore durante l'inizializzazione del dao factory: "+e.getMessage(),e);
  317.         }
  318.     }






  325.     /* *********** ACCESSI TRAMITE RICERCHE (DIAGNOSTICI) ******* */

  327.     /**
  328.      * Si occupa di ritornare il numero di diagnostici che rispettano il filtro di ricerca
  329.      *
  330.      * @param filtro Filtro di ricerca
  331.      * @return numero di diagnostici che rispettano il filtro di ricerca
  332.      * 
  333.      */
  334.     @Override
  335.     public int countMessaggiDiagnostici(FiltroRicercaDiagnostici filtro) throws DriverMsgDiagnosticiException{
  336.         
  337.         String idTransazione = filtro.getIdTransazione();
  338.         if(idTransazione==null) {
  339.             idTransazione = filtro.getProperty(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE);
  340.         }
  341.         if(idTransazione==null){
  342.             throw new DriverMsgDiagnosticiException("Metodo non implementato in questa versione (Identificativo di transazione non fornito)");
  343.         }
  344.         return this.countListaLog(filtro);
  345.         
  346.     }

  348.     /**
  349.      * Si occupa di ritornare i diagnostici che rispettano il filtro di ricerca
  350.      *
  351.      * @param filtro Filtro di ricerca
  352.      * @return diagnostici che rispettano il filtro di ricerca
  353.      * 
  354.      */
  355.     @Override
  356.     public List<MsgDiagnostico> getMessaggiDiagnostici(FiltroRicercaDiagnosticiConPaginazione filtro)  
  357.             throws DriverMsgDiagnosticiException, DriverMsgDiagnosticiNotFoundException{

  359.         String idTransazione = filtro.getIdTransazione();
  360.         if(idTransazione==null) {
  361.             idTransazione = filtro.getProperty(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE);
  362.         }
  363.         if(idTransazione==null){
  364.             throw new DriverMsgDiagnosticiException("Metodo non implementato in questa versione (Identificativo di transazione non fornito)");
  365.         }
  366.         List<MsgDiagnostico> list = null;
  367.         try{
  368.             list = this.getListaLog(filtro);
  369.         }catch(DriverMsgDiagnosticiNotFoundException notFound){
  370.             // ignore
  371.         }
  372.         if(list==null || list.isEmpty()){
  373.             throw new DriverMsgDiagnosticiNotFoundException("Diagnostici non trovati che rispettano il filtro di ricerca (Filtro:"+filtro.toString()+")");
  374.         }
  375.         return list;

  377.     }


  380.     /**
  381.      * Si occupa di eliminare i diagnostici che rispettano il filtro di ricerca
  382.      * 
  383.      * @param filter Filtro di ricerca
  384.      * @return numero di diagnostici eliminati
  385.      * @throws DriverTracciamentoException
  386.      */
  387.     @Override
  388.     public int deleteMessaggiDiagnostici(FiltroRicercaDiagnostici filter) throws DriverMsgDiagnosticiException{
  389.         throw new DriverMsgDiagnosticiException("Metodo non implementato in questa versione");
  390.     }
  391.     
  392.     private void setPropertiesEngine(List<MsgDiagnostico> listDiagnostici, String idTransazione){
  393.         int index = 1;
  394.         for (MsgDiagnostico msgDiagnostico : listDiagnostici) {
  395.             // set Properties
  396.             if(msgDiagnostico.getProperty(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE)==null){
  397.                 msgDiagnostico.addProperty(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE, idTransazione);
  398.             }
  399.             
  400.             // viene usato un valore negativo per indicare che si tratta di un diagnostico ricostruito (per funzionare dove viene usato org.openspcoop2.protocol.basic.diagnostico.DriverDiagnostico.IDDIAGNOSTICO)
  401.             int id = index * -1;
  402.             int code = 0;
  403.             try{
  404.                 code = Integer.parseInt(msgDiagnostico.getCodice());
  405.                 code = code * -1;
  406.             }catch(Exception e){
  407.                 // ignore
  408.             }
  409.             if(msgDiagnostico.getProperty(org.openspcoop2.protocol.basic.diagnostica.DiagnosticDriver.IDDIAGNOSTICI)==null){
  410.                 if(code<0){
  411.                     msgDiagnostico.addProperty(org.openspcoop2.protocol.basic.diagnostica.DiagnosticDriver.IDDIAGNOSTICI, code+"");
  412.                 }
  413.                 else{
  414.                     msgDiagnostico.addProperty(org.openspcoop2.protocol.basic.diagnostica.DiagnosticDriver.IDDIAGNOSTICI, id+"");
  415.                 }
  416.             }
  417.             index++;
  418.         }
  419.     }










  430.     /* ******* RISORSE INTERNE ********** */

  432.     @Override
  433.     public void close() throws DriverMsgDiagnosticiException {
  434.         try{
  435.             if(this.driverMsgDiagnostici!=null){
  436.                 this.driverMsgDiagnostici.close();
  437.             }
  438.         }finally{
  439.             try{
  440.                 if(this.connectionOpenViaJDBCInCostructor &&
  441.                     this.connection!=null && !this.connection.isClosed()){
  442.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), this.connection, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  443.                 }
  444.             }catch(Exception e){
  445.                 if(this.log!=null) {
  446.                     this.log.error("Close connection failure: "+e.getMessage(),e);
  447.                 }
  448.             }
  449.         }
  450.     }   





  456.     /* **** INTERNAL **** */

  458.     private Connection close(Connection con) {
  459.         try{
  460.             if(con!=null) {
  461.                 JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), con, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  462.                 con = null;
  463.             }
  464.         }catch(Exception e){
  465.             // close
  466.         }
  467.         return con;
  468.     }
  469.     private JDBCServiceManager close(JDBCServiceManager transazioniServiceManager) {
  470.         try{
  471.             if(transazioniServiceManager!=null) {
  472.                 transazioniServiceManager.close();
  473.                 transazioniServiceManager = null;
  474.             }
  475.         }catch(Exception e){
  476.             // ignore
  477.         }
  478.         return transazioniServiceManager;
  479.     }
  480.     private List<Map<String,Object>> selectEsitoProtocollo(ITransazioneServiceSearch transazioneServiceSearch, IPaginatedExpression expression) throws ServiceException, NotImplementedException {
  481.         List<Map<String,Object>> l = null;
  482.         try {
  483.             l = transazioneServiceSearch.select(expression, Transazione.model().ESITO, Transazione.model().PROTOCOLLO);
  484.         }catch(NotFoundException notFound) {
  485.             // ignore
  486.         }
  487.         return l;
  488.     }
  489.     
  490.     public int countListaLog(FiltroRicercaDiagnostici filtro) throws DriverMsgDiagnosticiException{

  492.         String idTransazione = filtro.getIdTransazione();
  493.         if(idTransazione==null) {
  494.             idTransazione = filtro.getProperty(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE);
  495.         }
  496.         if(idTransazione==null){
  497.             throw new DriverMsgDiagnosticiException("Identificativo di transazione non fornito");
  498.         }

  500.         Connection con = null;
  501.         boolean closeConnection = true;
  502.         JDBCServiceManager transazioniServiceManager = null;
  503.         try{
  504.             if(this.connection!=null){
  505.                 con = this.connection;
  506.                 closeConnection = false;
  507.             }else{
  508.                 con = this.datasource.getConnection();
  509.             }
  510.             if(con==null)
  511.                 throw new DriverMsgDiagnosticiException("Connection non ottenuta");

  513.             transazioniServiceManager = 
  514.                     (JDBCServiceManager) this.daoFactory.getServiceManager(new ProjectInfo(), con, true);
  515.             if(transazioniServiceManager==null) {
  516.                 throw new DriverMsgDiagnosticiException("transazioniServiceManager is null");
  517.             }

  519.             ITransazioneServiceSearch transazioneServiceSearch = null;
  520.             
  521.             
  522.             
  523.             if(filtro.getApplicativo()!=null && !"".equals(filtro.getApplicativo()) ){
  524.                 
  525.                 transazioneServiceSearch = transazioniServiceManager.getTransazioneServiceSearch();
  526.                 
  527.                 IPaginatedExpression expression = transazioneServiceSearch.newPaginatedExpression();
  528.                 expression.equals(Transazione.model().ID_TRANSAZIONE, idTransazione);
  529.                 expression.limit(1);
  530.                 List<Map<String,Object>> l = selectEsitoProtocollo(transazioneServiceSearch, expression);
  531.                 if(l!=null && !l.isEmpty()) {
  532.                     Map<String,Object> map = l.remove(0);
  533.                     if(map!=null && !map.isEmpty()) {
  534.                         
  535.                         Object protocolloObj = map.get(Transazione.model().PROTOCOLLO.getFieldName());
  536.                         if(protocolloObj instanceof String) {
  537.                             String protocollo = (String) protocolloObj;
  538.                             Object esitoObj = map.get(Transazione.model().ESITO.getFieldName());
  539.                             if(esitoObj instanceof Integer) {
  540.                                 int esito = (Integer) esitoObj;     
  541.                                 
  542.                                 EsitiProperties esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, protocollo);
  543.                                 EsitoTransazioneName esitoName = esitiProperties.getEsitoTransazioneName(esito);
  544.                                 
  545.                                 if(EsitoTransazioneName.isConsegnaMultipla(esitoName)) {
  546.                                 
  547.                                     // per evitare deadlock di connessioni
  548.                                     transazioniServiceManager = close(transazioniServiceManager);
  549.                                     if(closeConnection){
  550.                                         con = close(con);
  551.                                     }
  552.                                     
  553.                                     // Consegna Multipla: saranno diagnostici salvati sicuramente nella tabella, relativamente a consegne con presa in carico
  554.                                     return this.driverMsgDiagnostici.countMessaggiDiagnostici(filtro);
  555.                                 
  556.                                 }
  557.                             }
  558.                         }
  559.                         
  560.                     }
  561.                 }
  562.                             
  563.             }
  564.             

  566.             // Informazioni salvataggio diagnostici
  567.             InformazioniRecordDiagnostici informazioniSalvataggioDiagnostici = getInformazioniSalvataggioDiagnostici(transazioniServiceManager, idTransazione, null);

  569.             // per evitare deadlock di connessioni
  570.             transazioniServiceManager = close(transazioniServiceManager);
  571.             if(closeConnection){
  572.                 con = close(con);
  573.             }
  574.             
  575.             // Non vi sono informazioni eventuali sulla simulazione. Provo a recuperarla direttamente
  576.             if(informazioniSalvataggioDiagnostici==null){
  577.                 return this.driverMsgDiagnostici.countMessaggiDiagnostici(filtro);
  578.             }

  580.             // Non erano stata emessi diagnostici per la transazione
  581.             if(!informazioniSalvataggioDiagnostici.isPresenti()){
  582.                 return 0;
  583.             }

  585.             // La traccia era stata interamente salvata nel database delle tracce, poiche' non possedeva tutti i valori ricostruibili automaticamente
  586.             if(!informazioniSalvataggioDiagnostici.isRicostruibili()){
  587.                 return this.driverMsgDiagnostici.countMessaggiDiagnostici(filtro);
  588.             }

  590.             
  591.             int size = informazioniSalvataggioDiagnostici.getDiagnostici().size();
  592.             if(informazioniSalvataggioDiagnostici.getDiagnosticiExt()!=null){
  593.                 size+=informazioniSalvataggioDiagnostici.getDiagnosticiExt().size();
  594.             }
  595.             
  596.             // Vedo se esistono anche dei diagnostici salvati su database (es. gestione stateful).
  597.             // Se esistono, come ordine temporale saranno cmq successivi a quelli simulati.
  598.             int countSalvatiDatabase = this.driverMsgDiagnostici.countMessaggiDiagnostici(filtro);
  599.             if(countSalvatiDatabase>0) {
  600.                 return size+countSalvatiDatabase;
  601.             }
  602.             else {
  603.                 return size;
  604.             }


  607.         }catch(Exception e){
  608.             throw new DriverMsgDiagnosticiException("Riscontrato errore durante la lettura (count) dei dati (Transazione:"+idTransazione+"): "+e.getMessage(),e);
  609.         }finally{
  610.             close(transazioniServiceManager);
  611.             if(closeConnection){
  612.                 close(con);
  613.             }
  614.         }

  616.     }

  618.     private Traccia getTraccia(RuoloMessaggio ruolo, TransactionDriverTracciamento driverTracciamento, Map<String, String> propertiesRicerca) throws DriverTracciamentoException {
  619.         Traccia tr = null;
  620.         try{
  621.             tr = driverTracciamento.getTraccia(ruolo, propertiesRicerca);
  622.         }catch(DriverTracciamentoNotFoundException dNotFound){
  623.             // ignore
  624.         }
  625.         return tr;
  626.     }
  627.     
  628.     private void fillDiagnostici(FiltroRicercaDiagnosticiConPaginazione filter, List<MsgDiagnostico> list) throws DriverMsgDiagnosticiException {
  629.         int offsetOriginal = -1;
  630.         int limitOriginal = -1;
  631.         
  632.         offsetOriginal = filter.getOffset();
  633.         filter.setOffset(0);
  634.             
  635.         limitOriginal = filter.getLimit();
  636.         filter.setLimit(-1);
  637.         try{
  638.             
  639.             List<MsgDiagnostico> listDB = this.driverMsgDiagnostici.getMessaggiDiagnostici(filter);
  640.             if(listDB!=null && !listDB.isEmpty()){
  641.                 list.addAll(listDB);
  642.             }
  643.         }catch(DriverMsgDiagnosticiNotFoundException e){
  644.             // ignore
  645.         }
  646.         finally{
  647.             if(offsetOriginal>=0)
  648.                 filter.setOffset(offsetOriginal);
  649.             if(limitOriginal>0)
  650.                 filter.setLimit(limitOriginal);
  651.         }
  652.     }
  653.     
  654.     private int parseSafe(String v) {
  655.         int code = -1;
  656.         try{
  657.             code = Integer.parseInt(v);
  658.         }catch(Exception e){
  659.             // ignore
  660.         }   
  661.         return code;
  662.     }
  663.     
  664.     private List<MsgDiagnostico> getListaLog(FiltroRicercaDiagnosticiConPaginazione filter)
  665.             throws DriverMsgDiagnosticiNotFoundException,DriverMsgDiagnosticiException {

  667.         String idTransazione = filter.getIdTransazione();
  668.         if(idTransazione==null) {
  669.             idTransazione = filter.getProperty(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE);
  670.         }
  671.         if(idTransazione==null){
  672.             throw new DriverMsgDiagnosticiException("Identificativo di transazione non fornito");
  673.         }
  674.         
  675.         String idDiagnostico = filter.getProperty(org.openspcoop2.protocol.basic.diagnostica.DiagnosticDriver.IDDIAGNOSTICI);
  676.         int positionDiagnosticoRicostruito = -1;
  677.         boolean positionAsCode = false;
  678.         if(idDiagnostico!=null){
  679.             try{
  680.                 int value = Integer.parseInt(idDiagnostico);
  681.                 if(value<0){
  682.                     // diagnostico ricostruito
  683.                     positionDiagnosticoRicostruito = value * -1;
  684.                     positionAsCode = positionDiagnosticoRicostruito >= 1000; // le prime tre cifre 001 vengono tradotte in 1
  685.                 }
  686.             }catch(Exception e){
  687.                 // ignore
  688.             }
  689.         }

  691.         Connection con = null;
  692.         boolean closeConnection = true;
  693.         JDBCServiceManager transazioniServiceManager = null;
  694.         try{
  695.             if(this.connection!=null){
  696.                 con = this.connection;
  697.                 closeConnection = false;
  698.             }else{
  699.                 con = this.datasource.getConnection();
  700.             }
  701.             if(con==null)
  702.                 throw new DriverMsgDiagnosticiException("Connection non ottenuta");

  704.             transazioniServiceManager = 
  705.                     (JDBCServiceManager) this.daoFactory.getServiceManager(new ProjectInfo(), con, true);
  706.             if(transazioniServiceManager==null) {
  707.                 throw new DriverMsgDiagnosticiException("transazioniServiceManager is null");
  708.             }

  710.             ITransazioneServiceSearch transazioneServiceSearch = null;
  711.             Transazione transazione = null;
  712.             
  713.             if(filter.getApplicativo()!=null && !"".equals(filter.getApplicativo()) ){
  714.                 
  715.                 transazioneServiceSearch = transazioniServiceManager.getTransazioneServiceSearch();
  716.                 transazione = transazioneServiceSearch.get(idTransazione);
  717.                                 
  718.                 int esito = transazione.getEsito();
  719.                 EsitiProperties esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, transazione.getProtocollo());
  720.                 EsitoTransazioneName esitoName = esitiProperties.getEsitoTransazioneName(esito);
  721.                 
  722.                 if(EsitoTransazioneName.isConsegnaMultipla(esitoName)) {
  723.                     
  724.                     // per evitare deadlock di connessioni
  725.                     transazioniServiceManager = close(transazioniServiceManager);
  726.                     if(closeConnection){
  727.                         con = close(con);
  728.                     }
  729.                     
  730.                     // Consegna Multipla: saranno diagnostici salvati sicuramente nella tabella, relativamente a consegne con presa in carico
  731.                     List<MsgDiagnostico> list = this.driverMsgDiagnostici.getMessaggiDiagnostici(filter);
  732.                     // set Properties
  733.                     setPropertiesEngine(list, idTransazione);
  734.                     return list;
  735.                     
  736.                 }
  737.             }
  738.             
  739.             

  741.             // Informazioni salvataggio diagnostici
  742.             CredenzialiMittente credentialsFiller = new CredenzialiMittente();
  743.             InformazioniRecordDiagnostici informazioniSalvataggioDiagnostici = getInformazioniSalvataggioDiagnostici(transazioniServiceManager, idTransazione, credentialsFiller);

  745.             // Non vi sono informazioni eventuali sulla simulazione. Provo a recuperarla direttamente
  746.             if(informazioniSalvataggioDiagnostici==null){
  747.                 
  748.                 // per evitare deadlock di connessioni
  749.                 transazioniServiceManager = close(transazioniServiceManager);
  750.                 if(closeConnection){
  751.                     con = close(con);
  752.                 }
  753.                 
  754.                 List<MsgDiagnostico> list = this.driverMsgDiagnostici.getMessaggiDiagnostici(filter);
  755.                 // set Properties
  756.                 setPropertiesEngine(list, idTransazione);
  757.                 return list;
  758.             }

  760.             // Non erano stata emessi diagnostici per la transazione
  761.             if(!informazioniSalvataggioDiagnostici.isPresenti()){
  762.                 throw new DriverMsgDiagnosticiNotFoundException("non presente");
  763.             }

  765.             // I diagnostici sono stati interamente salvati nel database dei diagnostici, poiche' non possedeva tutti i valori ricostruibili automaticamente
  766.             if(!informazioniSalvataggioDiagnostici.isRicostruibili()){
  767.                 
  768.                 // per evitare deadlock di connessioni
  769.                 transazioniServiceManager = close(transazioniServiceManager);
  770.                 if(closeConnection){
  771.                     con = close(con);
  772.                 }
  773.                 
  774.                 List<MsgDiagnostico> list = this.driverMsgDiagnostici.getMessaggiDiagnostici(filter);
  775.                 // set Properties
  776.                 setPropertiesEngine(list, idTransazione);
  777.                 return list;
  778.             }

  780.             // Recupero transazione
  781.             if(transazioneServiceSearch==null) {
  782.                 transazioneServiceSearch = transazioniServiceManager.getTransazioneServiceSearch();
  783.             }
  784.             if(transazione==null) {
  785.                 transazione = transazioneServiceSearch.get(idTransazione);
  786.             }

  788.             // Recupero tracce
  789.             TransactionDriverTracciamento driverTracciamento = new TransactionDriverTracciamento(con, this.tipoDatabase, this.log);
  790.             Traccia tracciaRichiesta = null;
  791.             Traccia tracciaRisposta = null;
  792.             Map<String, String> propertiesRicerca = new HashMap<>();
  793.             propertiesRicerca.put(CostantiDB.MSG_DIAGNOSTICI_COLUMN_ID_TRANSAZIONE, idTransazione);
  794.             tracciaRichiesta = getTraccia(RuoloMessaggio.RICHIESTA, driverTracciamento, propertiesRicerca);
  795.             tracciaRisposta = getTraccia(RuoloMessaggio.RISPOSTA, driverTracciamento, propertiesRicerca);

  797.             // Costruzione diagnostici
  798.             ConvertitoreCodiceDiagnostici convertitore = new ConvertitoreCodiceDiagnostici(transazione, tracciaRichiesta, tracciaRisposta, informazioniSalvataggioDiagnostici, credentialsFiller.getTokenClientId());
  799.             List<MsgDiagnostico> listRicostruiti = convertitore.build(this.log);
  800.             
  801.             // Effettuo eventuali filtri
  802.             List<MsgDiagnostico> list = new ArrayList<>();
  803.             for (MsgDiagnostico msgDiagnostico : listRicostruiti) {
  804.                 boolean add = true;
  805.                 if(filter.getIdFunzione()!=null &&
  806.                     !filter.getIdFunzione().equals(msgDiagnostico.getIdFunzione())){
  807.                     add = false;
  808.                 }
  809.                 if(add && filter.getSeverita()!=null &&
  810.                     msgDiagnostico.getSeverita()>filter.getSeverita()){
  811.                     add = false;
  812.                 }
  813.                 if(add && filter.getCodice()!=null &&
  814.                     !filter.getCodice().equals(msgDiagnostico.getCodice())){
  815.                     add = false;
  816.                 }
  817.                 if(add && filter.getMessaggioCercatoInternamenteTestoDiagnostico()!=null &&
  818.                     !msgDiagnostico.getMessaggio().contains(filter.getMessaggioCercatoInternamenteTestoDiagnostico())){
  819.                     add = false;
  820.                 }
  821.                 if(add) {
  822.                     list.add(msgDiagnostico);
  823.                 }
  824.             }           

  826.             // per evitare deadlock di connessioni
  827.             transazioniServiceManager = close(transazioniServiceManager);
  828.             if(closeConnection){
  829.                 con = close(con);
  830.             }
  831.             
  832.             // Vedo se esistono anche dei diagnostici salvati su database (es. gestione stateful).
  833.             // Se esistono, come ordine temporale saranno cmq successivi a quelli simulati.
  834.             fillDiagnostici(filter, list);

  836.             List<MsgDiagnostico> listReturn = new ArrayList<>();
  837.             if(list!=null){
  838.                 for (int i = 0; i < list.size(); i++) {
  839.                     boolean add = true;
  840.                     if(filter.getOffset()>=0 && i<filter.getOffset()){
  841.                         add = false;
  842.                     }
  843.                     if(add) {
  844.                         listReturn.add(list.get(i));
  845.                         if(filter.getLimit()>0 && listReturn.size()>=filter.getLimit()){
  846.                             break;
  847.                         }
  848.                     }
  849.                 }
  850.             }

  852.             if(!listReturn.isEmpty()){
  853.                 // set Properties
  854.                 setPropertiesEngine(listReturn, idTransazione);
  855.                 if(positionDiagnosticoRicostruito>0){
  856.                     for (int i = 0; i < list.size(); i++) {
  857.                         boolean found = false;
  858.                         if(positionAsCode){
  859.                             int code = parseSafe(list.get(i).getCodice());
  860.                             if(positionDiagnosticoRicostruito == code){
  861.                                 found = true;
  862.                             }
  863.                         }
  864.                         else{
  865.                             if((i+1)==positionDiagnosticoRicostruito){
  866.                                 found = true;
  867.                             }
  868.                         }
  869.                         if(found){
  870.                             List<MsgDiagnostico> listDiag = new ArrayList<>();
  871.                             listDiag.add(list.get(i));
  872.                             return listDiag;
  873.                         }
  874.                     }
  875.                     throw new DriverMsgDiagnosticiException("Diagnostico con posizione ["+positionDiagnosticoRicostruito+"] non trovato");
  876.                 }
  877.                 else{
  878.                     return listReturn;
  879.                 }
  880.             }
  881.             
  882.             throw new DriverMsgDiagnosticiNotFoundException("diagnostici non trovati");

  884.         }catch(DriverMsgDiagnosticiNotFoundException e){
  885.             throw e;
  886.         }catch(Exception e){
  887.             throw new DriverMsgDiagnosticiException("Riscontrato errore durante la lettura dei dati (Transazione:"+idTransazione+"): "+e.getMessage(),e);
  888.         }finally{
  889.             close(transazioniServiceManager);
  890.             if(closeConnection){
  891.                 close(con);
  892.             }
  893.         }


  896.     }

  898.     private CredenzialeMittente getCredenzialeMittente(JDBCServiceManager transazioniServiceManager, String dbValueTokenClientId, String idTransazione) throws ServiceException, MultipleResultException, NotImplementedException{
  899.         CredenzialeMittente credenzialeClientId = null;
  900.         long id = -1;
  901.         try {
  902.             IDBCredenzialeMittenteServiceSearch credenzialeMittenteServiceSearch = (IDBCredenzialeMittenteServiceSearch) transazioniServiceManager.getCredenzialeMittenteServiceSearch();
  903.             id = Long.parseLong(dbValueTokenClientId);
  904.             credenzialeClientId = credenzialeMittenteServiceSearch.get(id);
  905.             String msgDebug = "RECUPERATO CLIENT ID ["+credenzialeClientId+"] per id ["+idTransazione+"]";
  906.             this.log.debug(msgDebug);
  907.         }catch(NotFoundException notFound) {
  908.             credenzialeClientId = new CredenzialeMittente();
  909.             credenzialeClientId.setId(id);
  910.             credenzialeClientId.setCredenziale("Informazione non disponibile");
  911.         }
  912.         return credenzialeClientId;
  913.     }
  914.     
  915.     private InformazioniRecordDiagnostici getInformazioniSalvataggioDiagnostici(
  916.             JDBCServiceManager transazioniServiceManager,
  917.             String idTransazione,
  918.             CredenzialiMittente credentialsFiller) throws DriverMsgDiagnosticiException{

  920.         try{

  922.             ITransazioneServiceSearch transazioneServiceSearch = transazioniServiceManager.getTransazioneServiceSearch();

  924.             IPaginatedExpression pagExpr = transazioneServiceSearch.newPaginatedExpression();
  925.             pagExpr.equals(Transazione.model().ID_TRANSAZIONE,idTransazione);

  927.             List<Map<String,Object>> selectField = transazioneServiceSearch.select(pagExpr, Transazione.model().DIAGNOSTICI, 
  928.                     Transazione.model().DIAGNOSTICI_LIST_1, Transazione.model().DIAGNOSTICI_LIST_2,
  929.                     Transazione.model().DIAGNOSTICI_LIST_EXT, Transazione.model().DIAGNOSTICI_EXT,
  930.                     Transazione.model().TOKEN_CLIENT_ID);

  932.             if(selectField==null || selectField.isEmpty()){
  933.                 throw new DriverMsgDiagnosticiException("Recupero informazioni per ricostruire i diagnostici non riuscito. Transazione con ID["+
  934.                         idTransazione+"] non presente?");
  935.             }
  936.             if(selectField.size()>1){
  937.                 throw new DriverMsgDiagnosticiException("Recupero informazioni per ricostruire i diagnostici non riuscito] non riuscito. Trovata piu' di una Transazione con ID["+
  938.                         idTransazione+"]?");
  939.             }

  941.             Map<String,Object> dbValue = selectField.get(0);

  943.             String dbValueMetaInf = this.readValue(dbValue, Transazione.model().DIAGNOSTICI, idTransazione);
  944.             if(dbValueMetaInf==null){
  945.                 // non sono presenti informazioni sulla simulazione
  946.                 return null;
  947.             }

  949.             String dbValueList1 = this.readValue(dbValue, Transazione.model().DIAGNOSTICI_LIST_1, idTransazione);
  950.             String dbValueList2 = this.readValue(dbValue, Transazione.model().DIAGNOSTICI_LIST_2, idTransazione);
  951.             String dbValueListExt = this.readValue(dbValue, Transazione.model().DIAGNOSTICI_LIST_EXT, idTransazione);
  952.             String dbValueDatiExt = this.readValue(dbValue, Transazione.model().DIAGNOSTICI_EXT, idTransazione);


  955.             InformazioniRecordDiagnostici info = InformazioniRecordDiagnostici.convertoFromDBColumnValue(dbValueMetaInf, 
  956.                     dbValueList1, dbValueList2,
  957.                     dbValueListExt, dbValueDatiExt
  958.                     );
  959.             String msgDebug = "RECUPERO ["+info.toString()+"]";
  960.             this.log.debug(msgDebug);
  961.             
  962.             
  963.             if(credentialsFiller!=null) {
  964.                 String dbValueTokenClientId = this.readValue(dbValue, Transazione.model().TOKEN_CLIENT_ID, idTransazione);
  965.                 if(dbValueTokenClientId!=null && StringUtils.isNotEmpty(dbValueTokenClientId)) {
  966.                     CredenzialeMittente credenzialeClientId = getCredenzialeMittente(transazioniServiceManager, dbValueTokenClientId, idTransazione);
  967.                     credentialsFiller.setTokenClientId(credenzialeClientId);
  968.                 }
  969.             }
  970.             
  971.             return info;

  973.         }catch(Exception e){
  974.             throw new DriverMsgDiagnosticiException("Riscontrato errore durante la lettura dei dati (Transazione:"+idTransazione+"): "+e.getMessage(),e);
  975.         }
  976.     }

  978.     private String readValue(Map<String,Object> dbValue, IField field, String idTransazione) throws DriverMsgDiagnosticiException{
  979.         Object objectDBValue = dbValue.get(field.getFieldName());
  980.         String dbValueAsString = null;
  981.         if((objectDBValue instanceof org.apache.commons.lang.ObjectUtils.Null)){
  982.             objectDBValue = null;
  983.         }
  984.         if(objectDBValue!=null){
  985.             if( ! (objectDBValue instanceof String)){
  986.                 throw new DriverMsgDiagnosticiException("Recupero informazioni per ricostruire i diagnostici non riuscito. Trovato campo '"+field.getFieldName()
  987.                 +"' di tipo ["+objectDBValue.getClass().getName()
  988.                 +"] differente da quello atteso ["+String.class.getName()+"] per la Transazione con ID["+
  989.                 idTransazione+"]?");
  990.             }
  991.             else{
  992.                 dbValueAsString = (String) objectDBValue;
  993.             }
  994.         }
  995.         return dbValueAsString;
  996.     }

  998. }
Created with JaCoCo 0.8.8.202204050719