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



  23. package org.openspcoop2.protocol.basic.tracciamento;

  25. import java.sql.Connection;
  26. import java.sql.DriverManager;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.util.ArrayList;
  31. import java.util.List;
  32. import java.util.Map;
  33. import java.util.Properties;

  35. import javax.sql.DataSource;

  37. import org.openspcoop2.core.constants.CostantiDB;
  38. import org.openspcoop2.core.id.IDSoggetto;
  39. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  40. import org.openspcoop2.protocol.basic.Costanti;
  41. import org.openspcoop2.protocol.basic.ProtocolliRegistrati;
  42. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  43. import org.openspcoop2.protocol.sdk.ProtocolException;
  44. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  45. import org.openspcoop2.protocol.sdk.diagnostica.DriverMsgDiagnosticiException;
  46. import org.openspcoop2.protocol.sdk.tracciamento.DriverTracciamentoException;
  47. import org.openspcoop2.protocol.sdk.tracciamento.DriverTracciamentoNotFoundException;
  48. import org.openspcoop2.protocol.sdk.tracciamento.FiltroRicercaTracce;
  49. import org.openspcoop2.protocol.sdk.tracciamento.FiltroRicercaTracceConPaginazione;
  50. import org.openspcoop2.protocol.sdk.tracciamento.ITracciaDriver;
  51. import org.openspcoop2.protocol.sdk.tracciamento.Traccia;
  52. import org.openspcoop2.utils.LoggerWrapperFactory;
  53. import org.openspcoop2.utils.StringWrapper;
  54. import org.openspcoop2.utils.TipiDatabase;
  55. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  56. import org.openspcoop2.utils.resources.GestoreJNDI;
  57. import org.openspcoop2.utils.sql.ISQLQueryObject;
  58. import org.slf4j.Logger;



  62. /**
  63.  * Interfaccia Tracciamento
  64.  *
  65.  * @author Stefano Corallo (corallo@link.it)
  66.  * @author $Author$
  67.  * @version $Rev$, $Date$
  68.  */
  69. public class TracciaDriver extends BasicComponentFactory implements ITracciaDriver {

  71.     /** 
  72.      * DataSource
  73.      */
  74.     DataSource datasource = null;
  75.     /** 
  76.      * Connessione
  77.      */
  78.     Connection connection = null;
  79.     boolean connectionOpenViaJDBCInCostructor = false;
  80.     /**
  81.      * SQLQueryObject
  82.      */
  83.     String tipoDatabase = null;



  87.     public static final String IDTRACCIA = "@@@@@-----@@@@-----IDTRACCIA-DB----@@@@@-----@@@@";
  88.     
  89.     private static final String TRACCIA_EXCEPTION_PREFIX = "Tracciamento exception: ";
  90.     
  91.     /**
  92.      * Properties
  93.      */
  94.     private List<String> properties;
  95.     public void setProperties(List<String> properties) {
  96.         this.properties = properties;
  97.     }
  98.     
  99.     private ProtocolliRegistrati protocolliRegistrati;
  100.     
  101.     public TracciaDriver(IProtocolFactory<?> factory) throws ProtocolException{
  102.         super(factory);
  103.     }
  104.     
  105.     
  106.     @Override
  107.     public IProtocolFactory<?> getProtocolFactory() {
  108.         return this.protocolFactory;
  109.     }
  110.     
  111.     public void init(ProtocolliRegistrati protocolliRegistrati,String nomeDataSource, String tipoDatabase, Properties jndiContext) throws DriverTracciamentoException {
  112.         init(protocolliRegistrati,nomeDataSource,tipoDatabase,jndiContext,null);
  113.     }
  114.     
  115.     public void init(ProtocolliRegistrati protocolliRegistrati,String nomeDataSource, String tipoDatabase, Properties jndiContext, Logger log) throws DriverTracciamentoException {
  116.     
  117.         this.protocolliRegistrati = protocolliRegistrati;
  118.         
  119.         // Logger
  120.         try {
  121.             if(log==null)
  122.                 this.log = LoggerWrapperFactory.getLogger(Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  123.             else
  124.                 this.log = log;
  125.         } catch (Exception e) {
  126.             throw new DriverTracciamentoException("Errore durante l'inizializzazione del logger (datasource params): "+e.getMessage(),e);
  127.         }

  129.         // Datasource
  130.         try {
  131.             this.log.info("Inizializzo DriverLogAnalyzer (datasource params)");
  132.             GestoreJNDI gestoreJNDI = new GestoreJNDI(jndiContext);
  133.             this.datasource = (DataSource) gestoreJNDI.lookup(nomeDataSource);
  134.             if (this.datasource == null)
  135.                 throw new ProtocolException ("datasource is null");

  137.             this.log.info("Inizializzo DriverLogAnalyzer terminata.");
  138.         } catch (Exception e) {
  139.             this.logError("Errore durante la ricerca del datasource(datasource params): "+e.getMessage(),e);
  140.             throw new DriverTracciamentoException("Errore durante la ricerca del datasource (datasource params): "+e.getMessage(),e);
  141.         }

  143.         // ISQLQueryObject
  144.         try {
  145.             this.log.info("Inizializzo ISQLQueryObject (datasource params)");
  146.             if (TipiDatabase.isAMember(tipoDatabase)) {
  147.                 this.tipoDatabase = tipoDatabase;               
  148.             } else {
  149.                 throw new ProtocolException("Tipo database non gestito (datasource params)");
  150.             }
  151.             this.log.info("Inizializzo ISQLQueryObject terminata (datasource params)");

  153.         } catch (Exception e) {
  154.             this.logError("Errore durante la ricerca del SQLQueryObject(datasource params): "+e.getMessage(),e);
  155.             throw new DriverTracciamentoException("Errore durante la ricerca del SQLQueryObject (datasource params): "+e.getMessage(),e);
  156.         }
  157.         
  158.     }
  159.     
  160.     public void init(ProtocolliRegistrati protocolliRegistrati,DataSource dataSourceObject, String tipoDatabase) throws DriverTracciamentoException {
  161.         init(protocolliRegistrati,dataSourceObject,tipoDatabase,null);
  162.     }
  163.     
  164.     public void init(ProtocolliRegistrati protocolliRegistrati,DataSource dataSourceObject, String tipoDatabase, Logger log) throws DriverTracciamentoException {
  165.         
  166.         this.protocolliRegistrati = protocolliRegistrati;
  167.         
  168.         // Logger
  169.         try {
  170.             if(log==null)
  171.                 this.log = LoggerWrapperFactory.getLogger(Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  172.             else
  173.                 this.log = log;
  174.         } catch (Exception e) {
  175.             throw new DriverTracciamentoException("Errore durante l'inizializzazione del logger (datasource): "+e.getMessage(),e);
  176.         }

  178.         // Datasource
  179.         try {
  180.             this.datasource = dataSourceObject;
  181.             if (this.datasource == null)
  182.                 throw new ProtocolException ("datasource is null");
  183.         } catch (Exception e) {
  184.             this.logError("Errore durante la ricerca del datasource...",e);
  185.             throw new DriverTracciamentoException("Errore durante la ricerca del datasource (datasource): "+e.getMessage(),e);
  186.         }

  188.         // ISQLQueryObject
  189.         try {
  190.             this.log.info("Inizializzo ISQLQueryObject (datasource)");
  191.             if (TipiDatabase.isAMember(tipoDatabase)) {
  192.                 this.tipoDatabase = tipoDatabase;               
  193.             } else {
  194.                 throw new ProtocolException("Tipo database non gestito (datasource)");
  195.             }
  196.             this.log.info("Inizializzo ISQLQueryObject terminata (datasource)");

  198.         } catch (Exception e) {
  199.             this.logError("Errore durante la ricerca del SQLQueryObject (datasource): "+e.getMessage(),e);
  200.             throw new DriverTracciamentoException("Errore durante la ricerca del SQLQueryObject (datasource): "+e.getMessage(),e);
  201.         }
  202.     }
  203.     
  204.     public void init(ProtocolliRegistrati protocolliRegistrati,Connection connection, String tipoDatabase, Logger log) throws DriverTracciamentoException {
  205.         
  206.         this.protocolliRegistrati = protocolliRegistrati;
  207.         
  208.         // Logger
  209.         try {
  210.             this.log = log;
  211.         } catch (Exception e) {
  212.             throw new DriverTracciamentoException("Errore durante l'inizializzazione del logger (connection): "+e.getMessage(),e);
  213.         }

  215.         // connection
  216.         this.connection = connection;
  217.         
  218.         // ISQLQueryObject
  219.         try {
  220.             this.log.info("Inizializzo ISQLQueryObject (connection)");
  221.             if (TipiDatabase.isAMember(tipoDatabase)) {
  222.                 this.tipoDatabase = tipoDatabase;               
  223.             } else {
  224.                 throw new ProtocolException("Tipo database non gestito (connection)");
  225.             }
  226.             this.log.info("Inizializzo ISQLQueryObject terminata (connection)");

  228.         } catch (Exception e) {
  229.             this.logError("Errore durante la ricerca del SQLQueryObject (connection): "+e.getMessage(),e);
  230.             throw new DriverTracciamentoException("Errore durante la ricerca del SQLQueryObject (connection): "+e.getMessage(),e);
  231.         }

  233.     }
  234.     
  235.     public void init(ProtocolliRegistrati protocolliRegistrati,String urlJDBC,String driverJDBC,
  236.             String username,String password, 
  237.             String tipoDatabase, Logger log) throws DriverTracciamentoException {
  238.         
  239.         this.protocolliRegistrati = protocolliRegistrati;
  240.         
  241.         // Logger
  242.         try {
  243.             this.log = log;
  244.         } catch (Exception e) {
  245.             throw new DriverTracciamentoException("Errore durante l'inizializzazione del logger (connectionUrl params): "+e.getMessage(),e);
  246.         }

  248.         // connection
  249.         try {
  250.             Class.forName(driverJDBC);
  251.             
  252.             if(username!=null){
  253.                 this.connection = DriverManager.getConnection(urlJDBC,username,password);
  254.             }else{
  255.                 this.connection = DriverManager.getConnection(urlJDBC);
  256.             }
  257.             this.connectionOpenViaJDBCInCostructor = true;
  258.             
  259.         } catch (Exception e) {
  260.             this.logError("Errore durante l'inizializzazione della connessione (connectionUrl params): "+e.getMessage(),e);
  261.             throw new DriverTracciamentoException("Errore durante l'inizializzazione della connessione (connectionUrl params): "+e.getMessage(),e);
  262.         }
  263.         
  264.         // ISQLQueryObject
  265.         try {
  266.             this.log.info("Inizializzo ISQLQueryObject (connectionUrl params)");
  267.             if (TipiDatabase.isAMember(tipoDatabase)) {
  268.                 this.tipoDatabase = tipoDatabase;               
  269.             } else {
  270.                 throw new ProtocolException("Tipo database non gestito (connectionUrl params)");
  271.             }
  272.             this.log.info("Inizializzo ISQLQueryObject terminata (connectionUrl params)");

  274.         } catch (Exception e) {
  275.             this.logError("Errore durante la ricerca del SQLQueryObject (connectionUrl params): "+e.getMessage(),e);
  276.             throw new DriverTracciamentoException("Errore durante la ricerca del SQLQueryObject (connectionUrl params): "+e.getMessage(),e);
  277.         }

  279.     }
  280.     

  282.     
  283.     
  284.     
  285.     
  286.     
  287.     
  288.     
  289.     /* *********** ACCESSI TRAMITE RICERCHE ******* */
  290.     
  291.     /**
  292.      * Si occupa di ritornare il numero di tracce che rispettano il filtro di ricerca
  293.      *
  294.      * @param filtro Filtro di ricerca
  295.      * @return numero di tracce che rispettano il filtro di ricerca
  296.      * 
  297.      */
  298.     @Override
  299.     public int countTracce(FiltroRicercaTracce filtro) throws DriverTracciamentoException{
  300.         Connection connectionDB = null;
  301.         PreparedStatement pstmt = null;
  302.         ResultSet rs = null;
  303.         int contatore = 0;
  304.         
  305.         try{
  306.             
  307.             // Get Connection
  308.             if(this.connection!=null)
  309.                 connectionDB = this.connection;
  310.             else{
  311.                 connectionDB = this.datasource.getConnection();
  312.             }
  313.             
  314.             checkConnection(connectionDB);
  315.         
  316.             ISQLQueryObject sqlQueryObject = 
  317.                 TracciaDriverUtilities.createSQLQueryObj_countTracce(filtro, this.tipoDatabase);
  318.             String sql = sqlQueryObject.createSQLQuery();
  319.             
  320.             StringWrapper sqlDebug = new StringWrapper(sqlQueryObject.createSQLQuery());
  321.             TracciaDriverUtilities.setValuesSearch(sqlDebug, filtro, 1);
  322.             this.logDebug("Query: "+sqlDebug);
  323.             
  324.             pstmt = connectionDB.prepareStatement(sql);
  325.             TracciaDriverUtilities.setValuesSearch(pstmt, filtro, 1);
  326.             rs = pstmt.executeQuery();
  327.             
  328.             if(rs.next()){
  329.                 contatore = rs.getInt("countTracce");   
  330.             }
  331.             rs.close();
  332.             pstmt.close();
  333.             
  334.             this.logDebug("Query found "+contatore+" rows ");
  335.             
  336.             return contatore;
  337.             
  338.         }catch(Exception e){
  339.             throw new DriverTracciamentoException(TRACCIA_EXCEPTION_PREFIX+e.getMessage(),e);
  340.         }finally{
  341.             JDBCUtilities.closeResources(rs, pstmt);
  342.             try{
  343.                 if(this.connection==null &&
  344.                     connectionDB!=null) {
  345.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  346.                 }
  347.             }catch(Exception eClose){
  348.                 // close
  349.             }
  350.         }
  351.     }
  352.     
  353.     
  354.     /**
  355.      * Si occupa di ritornare le tracce che rispettano il filtro di ricerca
  356.      *
  357.      * @param filtro Filtro di ricerca
  358.      * @return tracce che rispettano il filtro di ricerca
  359.      * 
  360.      */
  361.     @Override
  362.     public List<Traccia> getTracce(FiltroRicercaTracceConPaginazione filtro)  throws DriverTracciamentoException, DriverTracciamentoNotFoundException{
  363.         Connection connectionDB = null;
  364.         PreparedStatement pstmt = null;
  365.         ResultSet rs = null;
  366.         List<Traccia> tracce = new ArrayList<>();
  367.         
  368.         try{
  369.             
  370.             // Get Connection
  371.             if(this.connection!=null)
  372.                 connectionDB = this.connection;
  373.             else{
  374.                 connectionDB = this.datasource.getConnection();
  375.             }
  376.             
  377.             checkConnection(connectionDB);
  378.             
  379.             ISQLQueryObject sqlQueryObject = 
  380.                 TracciaDriverUtilities.createSQLQueryObj_searchTracce(filtro, this.tipoDatabase);
  381.             String sql = sqlQueryObject.createSQLQuery();
  382.             
  383.             StringWrapper sqlDebug = new StringWrapper(sqlQueryObject.createSQLQuery());
  384.             TracciaDriverUtilities.setValuesSearch(sqlDebug, filtro, 1);
  385.             this.logDebug("Query: "+sqlDebug);
  386.             
  387.             pstmt = connectionDB.prepareStatement(sql);
  388.             TracciaDriverUtilities.setValuesSearch(pstmt, filtro, 1);
  389.             rs = pstmt.executeQuery();
  390.             
  391.             while(rs.next()){
  392.                 
  393.                 Long idTraccia = rs.getLong("idTraccia");
  394.                 Traccia traccia = 
  395.                     TracciaDriverUtilities.getTraccia(connectionDB, this.tipoDatabase, 
  396.                             this.log, idTraccia, this.properties,
  397.                             this.protocolliRegistrati);
  398.                 tracce.add(traccia);
  399.             }
  400.             rs.close();
  401.             pstmt.close();
  402.             
  403.             this.logDebug("Query found "+tracce.size()+" rows");
  404.             
  405.             if(!tracce.isEmpty())
  406.                 return tracce;
  407.             else
  408.                 throw new DriverTracciamentoNotFoundException("Non sono state trovate tracce che rispettano i criteri di ricerca impostati");
  409.             
  410.         }catch(DriverTracciamentoNotFoundException e){
  411.             throw e;
  412.         }catch(Exception e){
  413.             throw new DriverTracciamentoException(TRACCIA_EXCEPTION_PREFIX+e.getMessage(),e);
  414.         }finally{
  415.             JDBCUtilities.closeResources(rs, pstmt);
  416.             try{
  417.                 if(this.connection==null &&
  418.                     connectionDB!=null) {
  419.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  420.                 }
  421.             }catch(Exception eClose){
  422.                 // close
  423.             }
  424.         }
  425.     }
  426.     
  427.     /**
  428.      * Si occupa di eliminare le tracce che rispettano il filtro di ricerca
  429.      * 
  430.      * @param filtro Filtro di ricerca
  431.      * @return numero di tracce eliminate
  432.      * @throws DriverTracciamentoException
  433.      */
  434.     @Override
  435.     public int deleteTracce(FiltroRicercaTracce filtro) throws DriverTracciamentoException{
  436.         int deleted = 0; 
  437.         Connection con = getConnection();
  438.         PreparedStatement stmt = null;
  439.         
  440.         try {
  441.             
  442.             ISQLQueryObject sqlQueryObject = 
  443.                 TracciaDriverUtilities.createSQLQueryObj_deleteTracce(filtro, this.tipoDatabase);
  444.             String sql = sqlQueryObject.createSQLDelete();
  445.             
  446.             StringWrapper sqlDebug = new StringWrapper(sqlQueryObject.createSQLDelete());
  447.             TracciaDriverUtilities.setValuesSearch(sqlDebug, filtro, 1);
  448.             this.logDebug("Delete: "+sqlDebug);
  449.             
  450.             stmt = con.prepareStatement(sql);
  451.             TracciaDriverUtilities.setValuesSearch(stmt, filtro, 1);
  452.             deleted = stmt.executeUpdate(); 
  453.             this.logDebug("Deleted "+deleted+" rows");
  454.             
  455.             return deleted;
  456.             
  457.         } catch (Exception e) {
  458.             throw new DriverTracciamentoException(e);
  459.         } finally {
  460.             if(stmt!=null) 
  461.                 try{ stmt.close(); } catch (SQLException e) {
  462.                     // close
  463.                 }
  464.             releaseConnection(con);
  465.             this.logDebug("Tracce Eliminate: " + deleted );
  466.         }
  467.     }
  468.     
  469.     
  470.     
  471.     
  472.     
  473.     
  474.     

  476.     
  477.     /* ******* ACCESSI PUNTUALI ********** */
  478.     
  479.     /**
  480.      * Recupera la traccia
  481.      * 
  482.      * @return Traccia
  483.      * @throws DriverMsgDiagnosticiException
  484.      */
  485.     @Override
  486.     public Traccia getTraccia(String idBusta,IDSoggetto codicePorta) throws DriverTracciamentoException, DriverTracciamentoNotFoundException{
  487.         return getTracciaEngine(idBusta,codicePorta,false);
  488.     } 
  489.     
  490.     /**
  491.      * Recupera la traccia
  492.      * 
  493.      * @return Traccia
  494.      * @throws DriverMsgDiagnosticiException
  495.      */
  496.     @Override
  497.     public Traccia getTraccia(String idBusta,IDSoggetto codicePorta,boolean ricercaIdBustaComeRiferimentoMessaggio) throws DriverTracciamentoException, DriverTracciamentoNotFoundException{
  498.         return getTracciaEngine(idBusta,codicePorta,ricercaIdBustaComeRiferimentoMessaggio);
  499.     } 
  500.     
  501.     private Traccia getTracciaEngine(String idBusta,IDSoggetto codicePorta,boolean rifMsg) throws DriverTracciamentoException, DriverTracciamentoNotFoundException{
  502.         
  503.         Connection connectionDB = null;
  504.         PreparedStatement pstmt = null;
  505.         ResultSet rs = null;
  506.         Traccia tr = null;
  507.         
  508.         try{
  509.             
  510.             // Get Connection
  511.             if(this.connection!=null)
  512.                 connectionDB = this.connection;
  513.             else{
  514.                 connectionDB = this.datasource.getConnection();
  515.             }
  516.             
  517.             checkConnection(connectionDB);
  518.             
  519.             ISQLQueryObject sqlQueryObject = TracciaDriverUtilities.getSQLQueryObject(this.tipoDatabase);
  520.             sqlQueryObject.addFromTable(CostantiDB.TRACCE);
  521.             sqlQueryObject.addSelectField(CostantiDB.TRACCE_COLUMN_ID);
  522.             if(rifMsg){
  523.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_RIFERIMENTO_MESSAGGIO+"=?");
  524.             }else{
  525.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_ID_MESSAGGIO+"=?");
  526.             }
  527.             if(TracciaDriverUtilities.isDefined(codicePorta)){
  528.                 if(TracciaDriverUtilities.isDefined(codicePorta.getCodicePorta())){
  529.                     sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_PDD_CODICE+"=?");
  530.                 }
  531.                 if(TracciaDriverUtilities.isDefined(codicePorta.getTipo())){
  532.                     sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_PDD_TIPO_SOGGETTO+"=?");
  533.                 }
  534.                 if(TracciaDriverUtilities.isDefined(codicePorta.getNome())){
  535.                     sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_PDD_NOME_SOGGETTO+"=?");
  536.                 }
  537.             }
  538.             sqlQueryObject.setANDLogicOperator(true);
  539.             
  540.             pstmt = connectionDB.prepareStatement(sqlQueryObject.toString());
  541.             int index = 1;
  542.             pstmt.setString(index++, idBusta);
  543.             if(TracciaDriverUtilities.isDefined(codicePorta)){
  544.                 if(TracciaDriverUtilities.isDefined(codicePorta.getCodicePorta())){
  545.                     pstmt.setString(index++, codicePorta.getCodicePorta());
  546.                 }
  547.                 if(TracciaDriverUtilities.isDefined(codicePorta.getTipo())){
  548.                     pstmt.setString(index++, codicePorta.getTipo());
  549.                 }
  550.                 if(TracciaDriverUtilities.isDefined(codicePorta.getNome())){
  551.                     pstmt.setString(index++, codicePorta.getNome());
  552.                 }
  553.             }
  554.             
  555.             rs = pstmt.executeQuery();
  556.             if(rs.next()){
  557.                 
  558.                 Long idTraccia = rs.getLong(CostantiDB.TRACCE_COLUMN_ID);
  559.                 tr =  TracciaDriverUtilities.getTraccia(connectionDB, this.tipoDatabase, 
  560.                         this.log, idTraccia, this.properties, this.protocolliRegistrati);
  561.                 
  562.             }
  563.             rs.close();
  564.             pstmt.close();
  565.             
  566.             if(tr==null){
  567.                 throw new DriverTracciamentoNotFoundException("Traccia non trovata (idBusta:"+idBusta+") (dominio-porta:"+codicePorta+") (rifmsg:"+rifMsg+")");
  568.             }
  569.             return tr;
  570.             
  571.         }catch(DriverTracciamentoNotFoundException d){
  572.             throw d;
  573.         }catch(Exception e){
  574.             throw new DriverTracciamentoException(TRACCIA_EXCEPTION_PREFIX+e.getMessage(),e);
  575.         }finally{
  576.             JDBCUtilities.closeResources(rs, pstmt);
  577.             try{
  578.                 if(this.connection==null &&
  579.                     connectionDB!=null) {
  580.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  581.                 }
  582.             }catch(Exception eClose){
  583.                 // close
  584.             }
  585.         }
  586.     } 
  587.     
  588.     /**
  589.      * Recupera la traccia in base all'id di transazione
  590.      * 
  591.      * @return Traccia
  592.      * @throws DriverMsgDiagnosticiException
  593.      */
  594.     @Override
  595.     public Traccia getTraccia(String idTransazione, RuoloMessaggio tipoTraccia) throws DriverTracciamentoException, DriverTracciamentoNotFoundException{
  596.         
  597.         Connection connectionDB = null;
  598.         PreparedStatement pstmt = null;
  599.         ResultSet rs = null;
  600.         Traccia tr = null;
  601.         
  602.         try{
  603.             
  604.             // Get Connection
  605.             if(this.connection!=null)
  606.                 connectionDB = this.connection;
  607.             else{
  608.                 connectionDB = this.datasource.getConnection();
  609.             }
  610.             checkConnection(connectionDB);
  611.             
  612.             ISQLQueryObject sqlQueryObject = TracciaDriverUtilities.getSQLQueryObject(this.tipoDatabase);
  613.             sqlQueryObject.addFromTable(CostantiDB.TRACCE);
  614.             sqlQueryObject.addSelectField(CostantiDB.TRACCE_COLUMN_ID);
  615.             sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_ID_TRANSAZIONE+"=?");
  616.             sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_TIPO_MESSAGGIO+"=?");
  617.             sqlQueryObject.setANDLogicOperator(true);
  618.             
  619.             pstmt = connectionDB.prepareStatement(sqlQueryObject.toString());
  620.             int index = 1;
  621.             pstmt.setString(index++, idTransazione);
  622.             pstmt.setString(index++, tipoTraccia.toString());
  623.             rs = pstmt.executeQuery();
  624.             if(rs.next()){
  625.                 
  626.                 Long idTraccia = rs.getLong(CostantiDB.TRACCE_COLUMN_ID);
  627.                 tr =  TracciaDriverUtilities.getTraccia(connectionDB, this.tipoDatabase, 
  628.                         this.log, idTraccia, this.properties, this.protocolliRegistrati);

  630.             }
  631.             rs.close();
  632.             pstmt.close();
  633.             
  634.             if(tr==null){
  635.                 throw new DriverTracciamentoNotFoundException("Traccia non trovata (idTransazione:"+idTransazione+") (tipo:"+tipoTraccia+")");
  636.             }
  637.             return tr;
  638.             
  639.         }catch(DriverTracciamentoNotFoundException d){
  640.             throw d;
  641.         }catch(Exception e){
  642.             throw new DriverTracciamentoException(TRACCIA_EXCEPTION_PREFIX+e.getMessage(),e);
  643.         }finally{
  644.             JDBCUtilities.closeResources(rs, pstmt);
  645.             try{
  646.                 if(this.connection==null &&
  647.                     connectionDB!=null) {
  648.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  649.                 }
  650.             }catch(Exception eClose){
  651.                 // close
  652.             }
  653.         }   
  654.     }
  655.     
  656.     /**
  657.      * Recupera la traccia in base ad una serie di properties
  658.      * 
  659.      * @return Traccia
  660.      * @throws DriverMsgDiagnosticiException
  661.      */
  662.     @Override
  663.     public Traccia getTraccia(RuoloMessaggio tipoTraccia,Map<String, String> propertiesRicerca) throws DriverTracciamentoException, DriverTracciamentoNotFoundException{
  664.         
  665.         Connection connectionDB = null;
  666.         PreparedStatement pstmt = null;
  667.         ResultSet rs = null;
  668.         Traccia tr = null;
  669.         
  670.         try{
  671.             
  672.             // Get Connection
  673.             if(this.connection!=null)
  674.                 connectionDB = this.connection;
  675.             else{
  676.                 connectionDB = this.datasource.getConnection();
  677.             }
  678.             checkConnection(connectionDB);
  679.             
  680.             ISQLQueryObject sqlQueryObject = TracciaDriverUtilities.getSQLQueryObject(this.tipoDatabase);
  681.             sqlQueryObject.addFromTable(CostantiDB.TRACCE);
  682.             sqlQueryObject.addSelectField(CostantiDB.TRACCE_COLUMN_ID);
  683.             if(propertiesRicerca!=null && propertiesRicerca.size()>0){
  684.                 for (String key : propertiesRicerca.keySet()) {
  685.                     if(TracciaDriver.IDTRACCIA.equals(key)){
  686.                         // Caso particolare dell'id long della traccia
  687.                         sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_ID+"=?");
  688.                     }else{
  689.                         sqlQueryObject.addWhereCondition(key+"=?");
  690.                     }
  691.                 }
  692.             }else{
  693.                 throw new ProtocolException("Properties di ricerca non fornite");
  694.             }
  695.             sqlQueryObject.addWhereCondition(CostantiDB.TRACCE_COLUMN_TIPO_MESSAGGIO+"=?");
  696.             sqlQueryObject.setANDLogicOperator(true);
  697.             
  698.             pstmt = connectionDB.prepareStatement(sqlQueryObject.toString());
  699.             int index = 1;
  700.             for (String key : propertiesRicerca.keySet()) {
  701.                 String value = propertiesRicerca.get(key);
  702.                 if(TracciaDriver.IDTRACCIA.equals(key)){
  703.                     // Caso particolare dell'id long della traccia
  704.                     pstmt.setLong(index, Long.parseLong(value));
  705.                 }else{
  706.                     pstmt.setString(index, value);
  707.                 }
  708.                 index++;
  709.             }
  710.             pstmt.setString(index, tipoTraccia.toString());
  711.             rs = pstmt.executeQuery();
  712.             if(rs.next()){
  713.                 
  714.                 Long idTraccia = rs.getLong(CostantiDB.TRACCE_COLUMN_ID);
  715.                 tr =  TracciaDriverUtilities.getTraccia(connectionDB, this.tipoDatabase, 
  716.                         this.log, idTraccia, this.properties, this.protocolliRegistrati);

  718.             }
  719.             rs.close();
  720.             pstmt.close();
  721.             
  722.             if(tr==null){
  723.                 throw new DriverTracciamentoNotFoundException("Traccia non trovata (sizeProperties:"+propertiesRicerca.size()+") (tipo:"+tipoTraccia+")");
  724.             }
  725.             return tr;
  726.             
  727.         }catch(DriverTracciamentoNotFoundException d){
  728.             throw d;
  729.         }catch(Exception e){
  730.             throw new DriverTracciamentoException(TRACCIA_EXCEPTION_PREFIX+e.getMessage(),e);
  731.         }finally{
  732.             JDBCUtilities.closeResources(rs, pstmt);
  733.             try{
  734.                 if(this.connection==null &&
  735.                     connectionDB!=null) {
  736.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  737.                 }
  738.             }catch(Exception eClose){
  739.                 // close
  740.             }
  741.         }
  742.     }
  743.     
  744.     
  745.     
  746.     
  747.     
  748.     /* ******* RISORSE INTERNE ********** */
  749.     
  750.     @Override
  751.     public void close() throws DriverTracciamentoException {
  752.         try{
  753.             if(this.connectionOpenViaJDBCInCostructor &&
  754.                 this.connection!=null && !this.connection.isClosed()){
  755.                 JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), this.connection, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  756.             }
  757.         }catch(Exception e){
  758.             throw new DriverTracciamentoException(e.getMessage(),e);
  759.         }
  760.     }
  761.     
  762.     
  763.     
  764.     
  765.     
  766.     
  767.     
  768.     /* ------------- UTILITY INTERNE -------------------------- */
  769.     
  770.     
  771.     private void checkConnection(Connection connectionDB) throws ProtocolException {
  772.         if(connectionDB==null &&
  773.             this.connection==null) {
  774.             throw new ProtocolException("Connection non ottenuta dal datasource["+this.datasource+"]");
  775.         }
  776.     }

  778.     /**
  779.      * Viene chiamato in causa per ottenere una connessione al DB
  780.      */
  781.     public java.sql.Connection getConnection() {
  782.         if (this.datasource == null) {
  783.             return null;
  784.         }

  786.         Connection connectionDB = null;
  787.         try {
  788.             connectionDB = this.datasource.getConnection();
  789.         } catch (Exception e) {
  790.             return null;
  791.         }

  793.         return connectionDB;
  794.     }

  796.     /**
  797.      * Viene chiamato in causa per rilasciare una connessione al DB, effettuando
  798.      * precedentemente un commit
  799.      * 
  800.      * @param connectionDB
  801.      *            Connessione da rilasciare.
  802.      */
  803.     public void releaseConnection(java.sql.Connection connectionDB) {
  804.         try {
  805.             JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  806.         } catch (SQLException e) {
  807.             // ignore
  808.         }
  809.     }

  811.     /**
  812.      * Viene chiamato in causa per ottenere il tipoDatabase
  813.      */
  814.     public String getTipoDatabase() {
  815.         return this.tipoDatabase;
  816.     }

  818.     
  819. }

Created with JaCoCo 0.8.8.202204050719