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


  22. package org.openspcoop2.web.lib.audit;

  24. import java.sql.Connection;
  25. import java.sql.PreparedStatement;
  26. import java.sql.ResultSet;
  27. import java.sql.SQLException;
  28. import java.util.ArrayList;
  29. import java.util.List;


  32. import org.openspcoop2.core.commons.ISearch;
  33. import org.openspcoop2.utils.sql.ISQLQueryObject;
  34. import org.openspcoop2.utils.sql.SQLObjectFactory;
  35. import org.openspcoop2.web.lib.audit.costanti.Costanti;
  36. import org.openspcoop2.web.lib.audit.dao.Appender;
  37. import org.openspcoop2.web.lib.audit.dao.AppenderProperty;
  38. import org.openspcoop2.web.lib.audit.dao.Configurazione;
  39. import org.openspcoop2.web.lib.audit.dao.Filtro;
  40. import org.openspcoop2.web.lib.audit.log.constants.Stato;
  41. import org.openspcoop2.web.lib.audit.log.constants.Tipologia;

  43. /**
  44.  * Sono forniti metodi per la lettura dei dati di Users
  45.  * 
  46.  * 
  47.  * @author Andrea Poli (apoli@link.it)
  48.  * @author Stefano Corallo (corallo@link.it)
  49.  * @author Sandra Giangrandi (sandra@link.it)
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52.  * 
  53.  */
  54. public class DriverAudit {

  56.     /** Connessione al Database */
  57.     private Connection connectionDB;

  59.     // Tipo database passato al momento della creazione dell'oggetto
  60.     private String tipoDB = null;

  62.     public DriverAudit(Connection con, String tipoDB) throws AuditException {
  63.         this.connectionDB = con;
  64.         if (con == null)
  65.             throw new AuditException("Connessione al Database non definita");

  67.         this.tipoDB = tipoDB;
  68.         if (tipoDB == null)
  69.             throw new AuditException("Il tipoDatabase non puo essere null.");
  70.     }

  72.     
  73.     
  74.     
  75.     public Configurazione getConfigurazione() throws AuditException {
  76.         
  77.         Configurazione configurazione = null;
  78.         PreparedStatement stm = null;
  79.         ResultSet rs = null;

  81.         try {
  82.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  83.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_CONFIGURAZIONE);
  84.             sqlQueryObject.addSelectField("*");
  85.             String sqlQuery = sqlQueryObject.createSQLQuery();
  86.             stm = this.connectionDB.prepareStatement(sqlQuery);
  87.             rs = stm.executeQuery();
  88.             if (rs.next()) {
  89.                 configurazione = new Configurazione();
  90.                 if(rs.getInt("audit_engine")==1)
  91.                     configurazione.setAuditEngineEnabled(true);
  92.                 else
  93.                     configurazione.setAuditEngineEnabled(false);
  94.                 if(rs.getInt("enabled")==1)
  95.                     configurazione.setAuditEnabled(true);
  96.                 else
  97.                     configurazione.setAuditEnabled(false);
  98.                 if(rs.getInt("dump")==1)
  99.                     configurazione.setDumpEnabled(true);
  100.                 else
  101.                     configurazione.setDumpEnabled(false);
  102.                 configurazione.setDumpFormat(rs.getString("dump_format"));

  104.                 configurazione.setAppender(this.getAppender());
  105.                 configurazione.setFiltri(this.getFiltri());     
  106.                 
  107.             }else{
  108.                 throw new AuditException("[DriverAudit::getConfigurazione] Configurazione non presente");
  109.             }
  110.             rs.close();
  111.             stm.close();
  112.         
  113.             return configurazione;
  114.         } catch (SQLException se) {
  115.             throw new AuditException("[DriverAudit::getConfigurazione] SqlException: " + se.getMessage(),se);
  116.         } catch (Exception ex) {
  117.             throw new AuditException("[DriverAudit::getConfigurazione] Exception: " + ex.getMessage(),ex);
  118.         } finally {
  119.             try {
  120.                 if(rs!=null)
  121.                     rs.close();
  122.             } catch (Exception e) {
  123.                 // ignore exception
  124.             }
  125.             try {
  126.                 if(stm!=null)
  127.                     stm.close();
  128.             } catch (Exception e) {
  129.                 // ignore exception
  130.             }
  131.         }
  132.     }
  133.     
  134.     public ArrayList<Filtro> getFiltri() throws AuditException {
  135.         
  136.         ArrayList<Filtro> filtri = new ArrayList<Filtro>();
  137.         PreparedStatement stm = null;
  138.         ResultSet rs = null;

  140.         try {
  141.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  142.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_FILTRI);
  143.             sqlQueryObject.addSelectField("id");
  144.             sqlQueryObject.addSelectField("ora_registrazione");
  145.             sqlQueryObject.addOrderBy("ora_registrazione");
  146.             sqlQueryObject.setSortType(true);
  147.             String sqlQuery = sqlQueryObject.createSQLQuery();
  148.             stm = this.connectionDB.prepareStatement(sqlQuery);
  149.             rs = stm.executeQuery();
  150.             while (rs.next()) {
  151.                 filtri.add(this.getFiltro(rs.getLong("id")));
  152.             }
  153.             rs.close();
  154.             stm.close();
  155.         
  156.             return filtri;
  157.         } catch (SQLException se) {
  158.             throw new AuditException("[DriverAudit::::getFiltri] SqlException: " + se.getMessage(),se);
  159.         } catch (Exception ex) {
  160.             throw new AuditException("[DriverAudit::::getFiltri] Exception: " + ex.getMessage(),ex);
  161.         } finally {
  162.             try {
  163.                 if(rs!=null)
  164.                     rs.close();
  165.             } catch (Exception e) {
  166.                 // ignore exception
  167.             }
  168.             try {
  169.                 if(stm!=null)
  170.                     stm.close();
  171.             } catch (Exception e) {
  172.                 // ignore exception
  173.             }
  174.         }
  175.     }

  177.     public List<Filtro> filtriList(ISearch ricerca, int idLista) throws AuditException {
  178.         String nomeMetodo = "filtriList";
  179.         int offset;
  180.         int limit;
  181.         String search;
  182.         String queryString;

  184.         limit = ricerca.getPageSize(idLista);
  185.         offset = ricerca.getIndexIniziale(idLista);
  186.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  188.         PreparedStatement stmt=null;
  189.         ResultSet risultato=null;
  190.         ArrayList<Filtro> lista = new ArrayList<Filtro>();

  192.         try {

  194.             if (!search.equals("")) {
  195.                 //query con search
  196.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  197.                 sqlQueryObject.addFromTable(Costanti.DB_AUDIT_FILTRI);
  198.                 sqlQueryObject.addSelectCountField("*", "cont");
  199.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("username",search,true,true),
  200.                         sqlQueryObject.getWhereLikeCondition("tipo_operazione",search,true,true),
  201.                         sqlQueryObject.getWhereLikeCondition("tipo",search,true,true),
  202.                         sqlQueryObject.getWhereLikeCondition("stato",search,true,true),
  203.                         sqlQueryObject.getWhereLikeCondition("dump_search",search,true,true));
  204.                 queryString = sqlQueryObject.createSQLQuery();
  205.             } else {
  206.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  207.                 sqlQueryObject.addFromTable(Costanti.DB_AUDIT_FILTRI);
  208.                 sqlQueryObject.addSelectCountField("*", "cont");
  209.                 queryString = sqlQueryObject.createSQLQuery();
  210.             }
  211.             stmt = this.connectionDB.prepareStatement(queryString);
  212.             risultato = stmt.executeQuery();
  213.             if (risultato.next())
  214.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  215.             risultato.close();
  216.             stmt.close();

  218.             // ricavo le entries
  219.             if (limit == 0) // con limit
  220.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  222.             if (!search.equals("")) { // con search
  223.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  224.                 sqlQueryObject.addFromTable(Costanti.DB_AUDIT_FILTRI);
  225.                 sqlQueryObject.addSelectField("id");
  226.                 sqlQueryObject.addSelectField("username");
  227.                 sqlQueryObject.addSelectField("tipo_operazione");
  228.                 sqlQueryObject.addSelectField("tipo");
  229.                 sqlQueryObject.addSelectField("stato");
  230.                 sqlQueryObject.addSelectField("dump_search");
  231.                 sqlQueryObject.addSelectField("ora_registrazione");
  232.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("username",search,true,true),
  233.                         sqlQueryObject.getWhereLikeCondition("tipo_operazione",search,true,true),
  234.                         sqlQueryObject.getWhereLikeCondition("tipo",search,true,true),
  235.                         sqlQueryObject.getWhereLikeCondition("stato",search,true,true),
  236.                         sqlQueryObject.getWhereLikeCondition("dump_search",search,true,true));
  237.                 sqlQueryObject.addOrderBy("ora_registrazione");
  238.                 sqlQueryObject.setSortType(true);
  239.                 sqlQueryObject.setLimit(limit);
  240.                 sqlQueryObject.setOffset(offset);
  241.                 queryString = sqlQueryObject.createSQLQuery();
  242.             } else {
  243.                 // senza search
  244.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  245.                 sqlQueryObject.addFromTable(Costanti.DB_AUDIT_FILTRI);
  246.                 sqlQueryObject.addSelectField("id");
  247.                 sqlQueryObject.addSelectField("username");
  248.                 sqlQueryObject.addSelectField("tipo_operazione");
  249.                 sqlQueryObject.addSelectField("tipo");
  250.                 sqlQueryObject.addSelectField("stato");
  251.                 sqlQueryObject.addSelectField("dump_search");
  252.                 sqlQueryObject.addSelectField("ora_registrazione");
  253.                 sqlQueryObject.addOrderBy("ora_registrazione");
  254.                 sqlQueryObject.setSortType(true);
  255.                 sqlQueryObject.setLimit(limit);
  256.                 sqlQueryObject.setOffset(offset);
  257.                 queryString = sqlQueryObject.createSQLQuery();
  258.             }
  259.             stmt = this.connectionDB.prepareStatement(queryString);
  260.             risultato = stmt.executeQuery();

  262.             while (risultato.next()) {
  263.                 lista.add(this.getFiltro(risultato.getLong("id")));
  264.             }

  266.             return lista;

  268.         } catch (Exception qe) {
  269.             throw new AuditException("[DriverAudit::" + nomeMetodo + "] Errore : " + qe.getMessage());
  270.         } finally {
  271.             try {
  272.                 if(risultato!=null)
  273.                     risultato.close();
  274.             } catch (Exception e) {
  275.                 // ignore exception
  276.             }
  277.             try {
  278.                 if(stmt!=null)
  279.                     stmt.close();
  280.             } catch (Exception e) {
  281.                 // ignore exception
  282.             }
  283.         }
  284.     }
  285.     
  286.     public Filtro getFiltro(long id) throws AuditException {
  287.         
  288.         Filtro filtro = null;
  289.         PreparedStatement stm = null;
  290.         ResultSet rs = null;

  292.         try {
  293.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  294.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_FILTRI);
  295.             sqlQueryObject.addSelectField("*");
  296.             sqlQueryObject.addWhereCondition("id=?");
  297.             String sqlQuery = sqlQueryObject.createSQLQuery();
  298.             stm = this.connectionDB.prepareStatement(sqlQuery);
  299.             stm.setLong(1, id);
  300.             rs = stm.executeQuery();
  301.             if (rs.next()) {
  302.                 filtro = new Filtro();
  303.                 filtro.setUsername(rs.getString("username"));
  304.                 filtro.setTipoOperazione(Tipologia.toEnumConstant(rs.getString("tipo_operazione")));
  305.                 filtro.setTipoOggettoInModifica(rs.getString("tipo"));
  306.                 filtro.setStatoOperazione(Stato.toEnumConstant(rs.getString("stato")));
  307.                 filtro.setDump(rs.getString("dump_search"));
  308.                 if(rs.getInt("dump_expr")==1)
  309.                     filtro.setDumpExprRegular(true);
  310.                 else
  311.                     filtro.setDumpExprRegular(false);
  312.                 
  313.                 if(rs.getInt("enabled")==1)
  314.                     filtro.setAuditEnabled(true);
  315.                 else
  316.                     filtro.setAuditEnabled(false);
  317.                 if(rs.getInt("dump")==1)
  318.                     filtro.setDumpEnabled(true);
  319.                 else
  320.                     filtro.setDumpEnabled(false);
  321.                 
  322.                 filtro.setId(rs.getLong("id"));
  323.             }else{
  324.                 throw new Exception("Filtro con id["+id+"] non trovato");
  325.             }
  326.             rs.close();
  327.             stm.close();
  328.         
  329.             return filtro;
  330.         } catch (SQLException se) {
  331.             throw new AuditException("[DriverAudit::::getFiltri] SqlException: " + se.getMessage(),se);
  332.         } catch (Exception ex) {
  333.             throw new AuditException("[DriverAudit::::getFiltri] Exception: " + ex.getMessage(),ex);
  334.         } finally {
  335.             try {
  336.                 if(rs!=null)
  337.                     rs.close();
  338.             } catch (Exception e) {
  339.                 // ignore exception
  340.             }
  341.             try {
  342.                 if(stm!=null)
  343.                     stm.close();
  344.             } catch (Exception e) {
  345.                 // ignore exception
  346.             }
  347.         }
  348.     }
  349.     
  350.     public ArrayList<Appender> getAppender() throws AuditException {
  351.         
  352.         ArrayList<Appender> appender = new ArrayList<Appender>();
  353.         PreparedStatement stm = null;
  354.         ResultSet rs = null;

  356.         try {
  357.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  358.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_APPENDER);
  359.             sqlQueryObject.addSelectField("id");
  360.             String sqlQuery = sqlQueryObject.createSQLQuery();
  361.             stm = this.connectionDB.prepareStatement(sqlQuery);
  362.             rs = stm.executeQuery();
  363.             while (rs.next()) {
  364.                 appender.add(this.getAppender(rs.getLong("id")));
  365.             }
  366.             rs.close();
  367.             stm.close();
  368.         
  369.             return appender;
  370.         } catch (SQLException se) {
  371.             throw new AuditException("[DriverAudit::getAppender] SqlException: " + se.getMessage(),se);
  372.         } catch (Exception ex) {
  373.             throw new AuditException("[DriverAudit::getAppender] Exception: " + ex.getMessage(),ex);
  374.         } finally {
  375.             try {
  376.                 if(rs!=null)
  377.                     rs.close();
  378.             } catch (Exception e) {
  379.                 // ignore exception
  380.             }
  381.             try {
  382.                 if(stm!=null)
  383.                     stm.close();
  384.             } catch (Exception e) {
  385.                 // ignore exception
  386.             }
  387.         }
  388.     }
  389.     
  390.     
  391.     public Appender getAppender(String nome) throws AuditException {
  392.         PreparedStatement stm = null;
  393.         ResultSet rs = null;
  394.         
  395.         try {
  396.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  397.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_APPENDER);
  398.             sqlQueryObject.addSelectField("id");
  399.             sqlQueryObject.addWhereCondition("name=?");
  400.             String sqlQuery = sqlQueryObject.createSQLQuery();
  401.             stm = this.connectionDB.prepareStatement(sqlQuery);
  402.             stm.setString(1, nome);
  403.             rs = stm.executeQuery();
  404.             if (rs.next()) {
  405.             
  406.                 return this.getAppender(rs.getLong("id"));
  407.                 
  408.             }else{
  409.                 throw new Exception("Appender con nome["+nome+"] non trovato");
  410.             }
  411.         
  412.         } catch (SQLException se) {
  413.             throw new AuditException("[DriverAudit::getAppender] SqlException: " + se.getMessage(),se);
  414.         } catch (Exception ex) {
  415.             throw new AuditException("[DriverAudit::getAppender] Exception: " + ex.getMessage(),ex);
  416.         } finally {
  417.             try {
  418.                 if(rs!=null)
  419.                     rs.close();
  420.             } catch (Exception e) {
  421.                 // ignore exception
  422.             }
  423.             try {
  424.                 if(stm!=null)
  425.                     stm.close();
  426.             } catch (Exception e) {
  427.                 // ignore exception
  428.             }
  429.         }
  430.     }
  431.     
  432.     public Appender getAppender(long id) throws AuditException {
  433.         
  434.         Appender appender = null;
  435.         PreparedStatement stm = null;
  436.         ResultSet rs = null;
  437.         PreparedStatement stmProperties = null;
  438.         ResultSet rsProperties = null;

  440.         try {
  441.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  442.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_APPENDER);
  443.             sqlQueryObject.addSelectField("*");
  444.             sqlQueryObject.addWhereCondition("id=?");
  445.             String sqlQuery = sqlQueryObject.createSQLQuery();
  446.             stm = this.connectionDB.prepareStatement(sqlQuery);
  447.             stm.setLong(1, id);
  448.             rs = stm.executeQuery();
  449.             if (rs.next()) {
  450.                 
  451.                 appender = new Appender();
  452.                 
  453.                 appender.setNome(rs.getString("name"));
  454.                 appender.setClassName(rs.getString("class"));
  455.                 appender.setId(rs.getLong("id"));
  456.                 
  457.                 ISQLQueryObject sqlQueryObjectProperties = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  458.                 sqlQueryObjectProperties.addFromTable(Costanti.DB_AUDIT_APPENDER_PROPERTIES);
  459.                 sqlQueryObjectProperties.addSelectField("*");
  460.                 sqlQueryObjectProperties.addWhereCondition("id_audit_appender=?");
  461.                 String sqlQueryProperties = sqlQueryObjectProperties.createSQLQuery();
  462.                 stmProperties = this.connectionDB.prepareStatement(sqlQueryProperties);
  463.                 stmProperties.setLong(1, appender.getId());
  464.                 rsProperties = stmProperties.executeQuery();
  465.                 while (rsProperties.next()) {
  466.                     
  467.                     AppenderProperty ap = new AppenderProperty();
  468.                     ap.setId(rsProperties.getLong("id"));
  469.                     ap.setIdAppender(appender.getId());
  470.                     ap.setName(rsProperties.getString("name"));
  471.                     ap.setValue(rsProperties.getString("value"));
  472.                     appender.addProperty(ap);
  473.                     
  474.                 }
  475.                 
  476.             }else{
  477.                 throw new Exception("Appender con id["+id+"] non trovato");
  478.             }
  479.             rs.close();
  480.             stm.close();
  481.         
  482.             return appender;
  483.         } catch (SQLException se) {
  484.             throw new AuditException("[DriverAudit::getAppender] SqlException: " + se.getMessage(),se);
  485.         } catch (Exception ex) {
  486.             throw new AuditException("[DriverAudit::getAppender] Exception: " + ex.getMessage(),ex);
  487.         } finally {
  488.             try {
  489.                 if(rsProperties!=null)
  490.                     rsProperties.close();
  491.             } catch (Exception e) {
  492.                 // ignore exception
  493.             }
  494.             try {
  495.                 if(stmProperties!=null)
  496.                     stmProperties.close();
  497.             } catch (Exception e) {
  498.                 // ignore exception
  499.             }
  500.             try {
  501.                 if(rs!=null)
  502.                     rs.close();
  503.             } catch (Exception e) {
  504.                 // ignore exception
  505.             }
  506.             try {
  507.                 if(stm!=null)
  508.                     stm.close();
  509.             } catch (Exception e) {
  510.                 // ignore exception
  511.             }
  512.         }
  513.     }
  514.     
  515.     

  517.     
  518.     
  519.     public void createConfigurazione(Configurazione configurazione) throws AuditException {
  520.         PreparedStatement stm = null;
  521.         String sqlQuery = "";

  523.         if (configurazione == null)
  524.             throw new AuditException("[DriverAudit::createConfigurazione] Parametro non valido.");

  526.         
  527.         try {
  528.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  529.             sqlQueryObject.addInsertTable(Costanti.DB_AUDIT_CONFIGURAZIONE);
  530.             sqlQueryObject.addInsertField("audit_engine", "?");
  531.             sqlQueryObject.addInsertField("enabled", "?");
  532.             sqlQueryObject.addInsertField("dump", "?");
  533.             sqlQueryObject.addInsertField("dump_format", "?");
  534.             sqlQuery = sqlQueryObject.createSQLInsert();
  535.             stm = this.connectionDB.prepareStatement(sqlQuery);
  536.             if(configurazione.isAuditEngineEnabled())
  537.                 stm.setInt(1, 1);
  538.             else
  539.                 stm.setInt(1, 0);
  540.             if(configurazione.isAuditEnabled())
  541.                 stm.setInt(2, 1);
  542.             else
  543.                 stm.setInt(2, 0);
  544.             if(configurazione.isDumpEnabled())
  545.                 stm.setInt(3, 1);
  546.             else
  547.                 stm.setInt(3, 0);
  548.             stm.setString(4, configurazione.getDumpFormat());
  549.             stm.executeUpdate();
  550.             stm.close();
  551.             
  552.             // Filtri
  553.             for(int i=0; i<configurazione.sizeFiltri(); i++){
  554.                 Filtro filtro = configurazione.getFiltro(i);
  555.                 this.createFiltro(filtro);
  556.             }
  557.             
  558.             // Appender
  559.             for(int i=0; i<configurazione.sizeAppender(); i++){
  560.                 Appender appender = configurazione.getAppender(i);
  561.                 this.createAppender(appender);
  562.             }
  563.             
  564.         } catch (Exception qe) {
  565.             throw new AuditException(qe.getMessage(),qe);
  566.         } finally {
  567.             try {
  568.                 if(stm!=null)
  569.                     stm.close();
  570.             } catch (Exception e) {
  571.                 // ignore exception
  572.             }
  573.         }
  574.     }
  575.     
  576.     public void createFiltro(Filtro filtro) throws AuditException {
  577.         PreparedStatement stm = null;
  578.         String sqlQuery = "";

  580.         if (filtro == null)
  581.             throw new AuditException("[DriverAudit::createFiltro] Parametro non valido.");

  583.         
  584.         try {
  585.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  586.             sqlQueryObject.addInsertTable(Costanti.DB_AUDIT_FILTRI);
  587.             sqlQueryObject.addInsertField("username", "?");
  588.             sqlQueryObject.addInsertField("tipo_operazione", "?");
  589.             sqlQueryObject.addInsertField("tipo", "?");
  590.             sqlQueryObject.addInsertField("stato", "?");
  591.             sqlQueryObject.addInsertField("dump_search", "?");
  592.             sqlQueryObject.addInsertField("dump_expr", "?");
  593.             sqlQueryObject.addInsertField("enabled", "?");
  594.             sqlQueryObject.addInsertField("dump", "?");
  595.                 
  596.             sqlQuery = sqlQueryObject.createSQLInsert();
  597.             stm = this.connectionDB.prepareStatement(sqlQuery);
  598.             stm.setString(1, filtro.getUsername());
  599.             stm.setString(2, filtro.getTipoOperazione() != null ?
  600.                     filtro.getTipoOperazione().toString() : null);
  601.             stm.setString(3, filtro.getTipoOggettoInModifica());
  602.             stm.setString(4, filtro.getStatoOperazione() != null ?
  603.                     filtro.getStatoOperazione().toString() : null);
  604.             stm.setString(5, filtro.getDump());
  605.             if(filtro.isDumpExprRegular())
  606.                 stm.setInt(6, 1);
  607.             else
  608.                 stm.setInt(6, 0);
  609.             if(filtro.isAuditEnabled())
  610.                 stm.setInt(7, 1);
  611.             else
  612.                 stm.setInt(7, 0);
  613.             if(filtro.isDumpEnabled())
  614.                 stm.setInt(8, 1);
  615.             else
  616.                 stm.setInt(8, 0);
  617.             stm.executeUpdate();
  618.             stm.close();
  619.             
  620.         } catch (Exception qe) {
  621.             throw new AuditException(qe.getMessage(),qe);
  622.         } finally {
  623.             try {
  624.                 if(stm!=null)
  625.                     stm.close();
  626.             } catch (Exception e) {
  627.                 // ignore exception
  628.             }
  629.         }
  630.     }
  631.     
  632.     public void createAppender(Appender appender) throws AuditException {
  633.         PreparedStatement stm = null;
  634.         String sqlQuery = "";

  636.         if (appender == null)
  637.             throw new AuditException("[DriverAudit::createAppender] Parametro non valido.");

  639.         
  640.         try {
  641.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  642.             sqlQueryObject.addInsertTable(Costanti.DB_AUDIT_APPENDER);
  643.             sqlQueryObject.addInsertField("name", "?");
  644.             sqlQueryObject.addInsertField("class", "?");
  645.                 
  646.             sqlQuery = sqlQueryObject.createSQLInsert();
  647.             stm = this.connectionDB.prepareStatement(sqlQuery);
  648.             stm.setString(1, appender.getNome());
  649.             stm.setString(2, appender.getClassName());
  650.             stm.executeUpdate();
  651.             stm.close();
  652.             
  653.             // Recupero id dell'appender appena inserito
  654.             long idAppender = this.getAppender(appender.getNome()).getId();
  655.             appender.setId(idAppender);
  656.             
  657.             // Inserisco proprieta
  658.             for(int i=0; i<appender.sizeProperties(); i++){
  659.                 
  660.                 AppenderProperty ap = appender.getProperty(i);
  661.                 ap.setIdAppender(idAppender);
  662.                 
  663.                 this.createAppenderProperty(ap);
  664.             }
  665.             
  666.         } catch (Exception qe) {
  667.             throw new AuditException(qe.getMessage(),qe);
  668.         } finally {
  669.             try {
  670.                 if(stm!=null)
  671.                     stm.close();
  672.             } catch (Exception e) {
  673.                 // ignore exception
  674.             }
  675.         }
  676.     }
  677.     
  678.     public void createAppenderProperty(AppenderProperty appender) throws AuditException {
  679.         PreparedStatement stm = null;
  680.         String sqlQuery = "";

  682.         if (appender == null)
  683.             throw new AuditException("[DriverAudit::createAppender] Parametro non valido.");
  684.         
  685.         if (appender.getIdAppender() <=0 )
  686.             throw new AuditException("[DriverAudit::createAppender] IdAppender ["+appender.getIdAppender()+"] non valido.");

  688.         
  689.         try {
  690.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  691.             sqlQueryObject.addInsertTable(Costanti.DB_AUDIT_APPENDER_PROPERTIES);
  692.             sqlQueryObject.addInsertField("name", "?");
  693.             sqlQueryObject.addInsertField("value", "?");
  694.             sqlQueryObject.addInsertField("id_audit_appender", "?");
  695.             
  696.             sqlQuery = sqlQueryObject.createSQLInsert();
  697.             stm = this.connectionDB.prepareStatement(sqlQuery);
  698.             stm.setString(1, appender.getName());
  699.             stm.setString(2, appender.getValue());
  700.             stm.setLong(3, appender.getIdAppender());
  701.             stm.executeUpdate();
  702.             stm.close();
  703.                         
  704.         } catch (Exception qe) {
  705.             throw new AuditException(qe.getMessage(),qe);
  706.         } finally {
  707.             try {
  708.                 if(stm!=null)
  709.                     stm.close();
  710.             } catch (Exception e) {
  711.                 // ignore exception
  712.             }
  713.         }
  714.     }
  715.     
  716.     

  718.     public void updateConfigurazione(Configurazione configurazione) throws AuditException {
  719.         PreparedStatement stm = null;
  720.         String sqlQuery = "";

  722.         if (configurazione == null)
  723.             throw new AuditException("[DriverAudit::updateConfigurazione] Parametro non valido.");

  725.         
  726.         try {
  727.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  728.             sqlQueryObject.addUpdateTable(Costanti.DB_AUDIT_CONFIGURAZIONE);
  729.             sqlQueryObject.addUpdateField("audit_engine", "?");
  730.             sqlQueryObject.addUpdateField("enabled", "?");
  731.             sqlQueryObject.addUpdateField("dump", "?");
  732.             sqlQueryObject.addUpdateField("dump_format", "?");
  733.             sqlQuery = sqlQueryObject.createSQLUpdate();
  734.             stm = this.connectionDB.prepareStatement(sqlQuery);
  735.             if(configurazione.isAuditEngineEnabled())
  736.                 stm.setInt(1, 1);
  737.             else
  738.                 stm.setInt(1, 0);
  739.             if(configurazione.isAuditEnabled())
  740.                 stm.setInt(2, 1);
  741.             else
  742.                 stm.setInt(2, 0);
  743.             if(configurazione.isDumpEnabled())
  744.                 stm.setInt(3, 1);
  745.             else
  746.                 stm.setInt(3, 0);
  747.             stm.setString(4, configurazione.getDumpFormat());
  748.             stm.executeUpdate();
  749.             stm.close();
  750.             
  751.             // Elimino tutti i filtri presenti
  752.             this.deleteFiltri();
  753.                         
  754.             // Aggiungo quelli presenti 
  755.             for(int i=0; i<configurazione.sizeFiltri(); i++){
  756.                 Filtro filtro = configurazione.getFiltro(i);
  757.                 this.createFiltro(filtro);
  758.             }
  759.             
  760.             // Elimino tutti gli appender presenti
  761.             this.deleteAppenders();
  762.             
  763.             // Appender
  764.             for(int i=0; i<configurazione.sizeAppender(); i++){
  765.                 Appender appender = configurazione.getAppender(i);
  766.                 this.createAppender(appender);
  767.             }
  768.             
  769.         } catch (Exception qe) {
  770.             throw new AuditException(qe.getMessage(),qe);
  771.         } finally {
  772.             try {
  773.                 if(stm!=null)
  774.                     stm.close();
  775.             } catch (Exception e) {
  776.                 // ignore exception
  777.             }
  778.         }
  779.     }
  780.     
  781.     
  782.     public void updateFiltro(Filtro filtro) throws AuditException {
  783.         PreparedStatement stm = null;
  784.         String sqlQuery = "";

  786.         if (filtro == null)
  787.             throw new AuditException("[DriverAudit::updateFiltro] Parametro non valido.");

  789.         if (filtro.getId()<=0)
  790.             throw new AuditException("[DriverAudit::updateFiltro] Id ["+filtro.getId()+"] non valido.");
  791.         
  792.         try {
  793.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  794.             sqlQueryObject.addUpdateTable(Costanti.DB_AUDIT_FILTRI);
  795.             sqlQueryObject.addUpdateField("username", "?");
  796.             sqlQueryObject.addUpdateField("tipo_operazione", "?");
  797.             sqlQueryObject.addUpdateField("tipo", "?");
  798.             sqlQueryObject.addUpdateField("stato", "?");
  799.             sqlQueryObject.addUpdateField("dump_search", "?");
  800.             sqlQueryObject.addUpdateField("dump_expr", "?");
  801.             sqlQueryObject.addUpdateField("enabled", "?");
  802.             sqlQueryObject.addUpdateField("dump", "?");
  803.             sqlQueryObject.addWhereCondition("id=?");
  804.                 
  805.             sqlQuery = sqlQueryObject.createSQLUpdate();
  806.             stm = this.connectionDB.prepareStatement(sqlQuery);
  807.             stm.setString(1, filtro.getUsername());
  808.             stm.setString(2, filtro.getTipoOperazione() != null ?
  809.                     filtro.getTipoOperazione().toString() : null);
  810.             stm.setString(3, filtro.getTipoOggettoInModifica());
  811.             stm.setString(4, filtro.getStatoOperazione() != null ?
  812.                     filtro.getStatoOperazione().toString() : null);
  813.             stm.setString(5, filtro.getDump());
  814.             if(filtro.isDumpExprRegular())
  815.                 stm.setInt(6, 1);
  816.             else
  817.                 stm.setInt(6, 0);
  818.             if(filtro.isAuditEnabled())
  819.                 stm.setInt(7, 1);
  820.             else
  821.                 stm.setInt(7, 0);
  822.             if(filtro.isDumpEnabled())
  823.                 stm.setInt(8, 1);
  824.             else
  825.                 stm.setInt(8, 0);
  826.             stm.setLong(9, filtro.getId());
  827.             stm.executeUpdate();
  828.             stm.close();
  829.             
  830.         } catch (Exception qe) {
  831.             throw new AuditException(qe.getMessage(),qe);
  832.         } finally {
  833.             try {
  834.                 if(stm!=null)
  835.                     stm.close();
  836.             } catch (Exception e) {
  837.                 // ignore exception
  838.             }
  839.         }
  840.     }
  841.     
  842.     public void updateAppender(Appender appender) throws AuditException {
  843.         PreparedStatement stm = null;
  844.         String sqlQuery = "";

  846.         if (appender == null)
  847.             throw new AuditException("[DriverAudit::updateAppender] Parametro non valido.");
  848.         
  849.         if (appender.getId()<=0)
  850.             throw new AuditException("[DriverAudit::updateAppender] Id ["+appender.getId()+"] non valido.");
  851.         
  852.         
  853.         try {
  854.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  855.             sqlQueryObject.addUpdateTable(Costanti.DB_AUDIT_APPENDER);
  856.             sqlQueryObject.addUpdateField("name", "?");
  857.             sqlQueryObject.addUpdateField("class", "?");
  858.             sqlQueryObject.addWhereCondition("id=?");
  859.                 
  860.             sqlQuery = sqlQueryObject.createSQLUpdate();
  861.             stm = this.connectionDB.prepareStatement(sqlQuery);
  862.             stm.setString(1, appender.getNome());
  863.             stm.setString(2, appender.getClassName());
  864.             stm.setLong(3, appender.getId());
  865.             stm.executeUpdate();
  866.             stm.close();
  867.             
  868.             // Delete appenderProperties
  869.             deleteAppenderProperties(appender);
  870.             
  871.             // Inserisco le proprieta
  872.             for(int i=0; i<appender.sizeProperties(); i++){
  873.                 
  874.                 AppenderProperty ap = appender.getProperty(i);
  875.                 ap.setIdAppender(appender.getId());
  876.                 
  877.                 this.createAppenderProperty(ap);
  878.             }
  879.             
  880.         } catch (Exception qe) {
  881.             throw new AuditException(qe.getMessage(),qe);
  882.         } finally {
  883.             try {
  884.                 if(stm!=null)
  885.                     stm.close();
  886.             } catch (Exception e) {
  887.                 // ignore exception
  888.             }
  889.         }
  890.     }
  891.     
  892.     
  893.     public void updateAppenderProperty(AppenderProperty appender) throws AuditException {
  894.         PreparedStatement stm = null;
  895.         String sqlQuery = "";

  897.         if (appender == null)
  898.             throw new AuditException("[DriverAudit::updateAppenderProperty] Parametro non valido.");
  899.         
  900.         if (appender.getIdAppender() <=0 )
  901.             throw new AuditException("[DriverAudit::updateAppenderProperty] IdAppender ["+appender.getIdAppender()+"] non valido.");

  903.         if (appender.getId() <=0 )
  904.             throw new AuditException("[DriverAudit::updateAppenderProperty] Id ["+appender.getId()+"] non valido.");

  906.         
  907.         try {
  908.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  909.             sqlQueryObject.addUpdateTable(Costanti.DB_AUDIT_APPENDER_PROPERTIES);
  910.             sqlQueryObject.addUpdateField("name", "?");
  911.             sqlQueryObject.addUpdateField("value", "?");
  912.             sqlQueryObject.addUpdateField("id_audit_appender", "?");
  913.             sqlQueryObject.addWhereCondition("id=?");
  914.             
  915.             sqlQuery = sqlQueryObject.createSQLUpdate();
  916.             stm = this.connectionDB.prepareStatement(sqlQuery);
  917.             stm.setString(1, appender.getName());
  918.             stm.setString(2, appender.getValue());
  919.             stm.setLong(3, appender.getIdAppender());
  920.             stm.executeUpdate();
  921.             stm.close();
  922.                         
  923.         } catch (Exception qe) {
  924.             throw new AuditException(qe.getMessage(),qe);
  925.         } finally {
  926.             try {
  927.                 if(stm!=null)
  928.                     stm.close();
  929.             } catch (Exception e) {
  930.                 // ignore exception
  931.             }
  932.         }
  933.     }
  934.     
  935.     
  936.     
  937.     public void deleteConfigurazione() throws AuditException {
  938.         PreparedStatement stm = null;
  939.         String sqlQuery = "";

  941.         try {
  942.             // Elimino tutti i filtri presenti
  943.             this.deleteFiltri();
  944.                         
  945.             // Elimino tutti gli appender presenti
  946.             this.deleteAppenders();
  947.             
  948.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  949.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_CONFIGURAZIONE);
  950.             sqlQuery = sqlQueryObject.createSQLDelete();
  951.             stm = this.connectionDB.prepareStatement(sqlQuery);
  952.             stm.executeUpdate();
  953.             stm.close();
  954.             
  955.         } catch (Exception qe) {
  956.             throw new AuditException(qe.getMessage(),qe);
  957.         } finally {
  958.             try {
  959.                 if(stm!=null)
  960.                     stm.close();
  961.             } catch (Exception e) {
  962.                 // ignore exception
  963.             }
  964.         }
  965.     }
  966.     
  967.     
  968.     public void deleteFiltri() throws AuditException {
  969.         PreparedStatement stm = null;
  970.         String sqlQuery = "";

  972.         try {
  973.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  974.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_FILTRI);
  975.             sqlQuery = sqlQueryObject.createSQLDelete();
  976.             stm = this.connectionDB.prepareStatement(sqlQuery);
  977.             stm.executeUpdate();
  978.             stm.close();
  979.             
  980.         } catch (Exception qe) {
  981.             throw new AuditException(qe.getMessage(),qe);
  982.         } finally {
  983.             try {
  984.                 if(stm!=null)
  985.                     stm.close();
  986.             } catch (Exception e) {
  987.                 // ignore exception
  988.             }
  989.         }
  990.     }
  991.     
  992.     public void deleteFiltro(Filtro f) throws AuditException {
  993.         PreparedStatement stm = null;
  994.         String sqlQuery = "";

  996.         try {
  997.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  998.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_FILTRI);
  999.             sqlQueryObject.addWhereCondition("id=?");
  1000.             sqlQuery = sqlQueryObject.createSQLDelete();
  1001.             stm = this.connectionDB.prepareStatement(sqlQuery);
  1002.             stm.setLong(1, f.getId());
  1003.             stm.executeUpdate();
  1004.             stm.close();
  1005.             
  1006.         } catch (Exception qe) {
  1007.             throw new AuditException(qe.getMessage(),qe);
  1008.         } finally {
  1009.             try {
  1010.                 if(stm!=null)
  1011.                     stm.close();
  1012.             } catch (Exception e) {
  1013.                 // ignore exception
  1014.             }
  1015.         }
  1016.     }
  1017.     
  1018.     public void deleteAppenders() throws AuditException {
  1019.         PreparedStatement stm = null;
  1020.         String sqlQuery = "";

  1022.         try {
  1023.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  1024.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_APPENDER_PROPERTIES);
  1025.             sqlQuery = sqlQueryObject.createSQLDelete();
  1026.             stm = this.connectionDB.prepareStatement(sqlQuery);
  1027.             stm.executeUpdate();
  1028.             stm.close();
  1029.             
  1030.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  1031.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_APPENDER);
  1032.             sqlQuery = sqlQueryObject.createSQLDelete();
  1033.             stm = this.connectionDB.prepareStatement(sqlQuery);
  1034.             stm.executeUpdate();
  1035.             stm.close();
  1036.             
  1037.         } catch (Exception qe) {
  1038.             throw new AuditException(qe.getMessage(),qe);
  1039.         } finally {
  1040.             try {
  1041.                 if(stm!=null)
  1042.                     stm.close();
  1043.             } catch (Exception e) {
  1044.                 // ignore exception
  1045.             }
  1046.         }
  1047.     }
  1048.     
  1049.     public void deleteAppenderProperties(Appender appender) throws AuditException {
  1050.         PreparedStatement stm = null;
  1051.         String sqlQuery = "";

  1053.         if (appender == null)
  1054.             throw new AuditException("[DriverAudit::deleteAppenderProperties] Parametro non valido.");
  1055.         
  1056.         if (appender.getId() <=0 )
  1057.             throw new AuditException("[DriverAudit::deleteAppenderProperties] Id ["+appender.getId()+"] non valido.");

  1059.         
  1060.         try {
  1061.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  1062.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_APPENDER_PROPERTIES);
  1063.             sqlQueryObject.addWhereCondition("id_audit_appender=?");
  1064.             sqlQuery = sqlQueryObject.createSQLDelete();
  1065.             stm = this.connectionDB.prepareStatement(sqlQuery);
  1066.             stm.setLong(1, appender.getId());
  1067.             stm.executeUpdate();
  1068.             stm.close();
  1069.             
  1070.         } catch (Exception qe) {
  1071.             throw new AuditException(qe.getMessage(),qe);
  1072.         } finally {
  1073.             try {
  1074.                 if(stm!=null)
  1075.                     stm.close();
  1076.             } catch (Exception e) {
  1077.                 // ignore exception
  1078.             }
  1079.         }
  1080.     }
  1081. }
Created with JaCoCo 0.8.8.202204050719