DriverAuditDBAppender.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.sql.Timestamp;
  29. import java.text.SimpleDateFormat;
  30. import java.util.ArrayList;
  31. import java.util.Calendar;
  32. import java.util.Date;
  33. import java.util.List;

  35. import org.openspcoop2.core.commons.ISearch;
  36. import org.openspcoop2.utils.TipiDatabase;
  37. import org.openspcoop2.utils.date.DateUtils;
  38. import org.openspcoop2.utils.jdbc.CustomKeyGeneratorObject;
  39. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKey;
  40. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyJDBCType;
  41. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyObject;
  42. import org.openspcoop2.utils.sql.ISQLQueryObject;
  43. import org.openspcoop2.utils.sql.SQLObjectFactory;
  44. import org.openspcoop2.web.lib.audit.costanti.Costanti;
  45. import org.openspcoop2.web.lib.audit.log.Binary;
  46. import org.openspcoop2.web.lib.audit.log.Operation;
  47. import org.openspcoop2.web.lib.audit.log.constants.Stato;
  48. import org.openspcoop2.web.lib.audit.log.constants.Tipologia;

  50. /**
  51.  * Sono forniti metodi per la lettura dei dati di Users
  52.  * 
  53.  * 
  54.  * @author Andrea Poli (apoli@link.it)
  55.  * @author Stefano Corallo (corallo@link.it)
  56.  * @author Sandra Giangrandi (sandra@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  * 
  60.  */

  62. public class DriverAuditDBAppender {

  64.     /** Connessione al Database */
  65.     private Connection connectionDB;

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

  70.     public DriverAuditDBAppender(Connection con, String tipoDB) throws AuditException {
  71.         this.connectionDB = con;
  72.         if (con == null)
  73.             throw new AuditException("Connessione al Database non definita");

  75.         this.tipoDB = tipoDB;
  76.         if (tipoDB == null)
  77.             throw new AuditException("Il tipoDatabase non puo essere null.");
  78.     }

  80.     
  81.     
  82.     
  83.     public Operation getOperation(long id) throws AuditException {
  84.         
  85.         Operation operation = null;
  86.         PreparedStatement stm = null;
  87.         ResultSet rs = null;

  89.         if(id<=0){
  90.             throw new AuditException("[DriverAudit::getOperation]  Id non valido");
  91.         }
  92.         
  93.         try {
  94.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  95.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_OPERATIONS_TABLE);
  96.             sqlQueryObject.addSelectField("*");
  97.             sqlQueryObject.addWhereCondition("id=?");
  98.             String sqlQuery = sqlQueryObject.createSQLQuery();
  99.             stm = this.connectionDB.prepareStatement(sqlQuery);
  100.             stm.setLong(1, id);
  101.             rs = stm.executeQuery();
  102.             if (rs.next()) {
  103.                 operation = new Operation();
  104.                 operation.setTipologia(Tipologia.toEnumConstant(rs.getString("tipo_operazione")));
  105.                 operation.setTipoOggetto(rs.getString("tipo"));
  106.                 operation.setObjectId(rs.getString("object_id"));
  107.                 operation.setObjectOldId(rs.getString("object_old_id"));
  108.                 operation.setUtente(rs.getString("utente"));
  109.                 operation.setStato(Stato.toEnumConstant(rs.getString("stato")));
  110.                 operation.setObjectDetails(rs.getString("object_details"));
  111.                 operation.setObjectClass(rs.getString("object_class"));
  112.                 operation.setError(rs.getString("error"));
  113.                 operation.setTimeRequest(rs.getTimestamp("time_request"));
  114.                 operation.setTimeExecute(rs.getTimestamp("time_execute"));
  115.                 operation.setId(id);
  116.                 
  117.                 // binaries
  118.                 ArrayList<Binary> list = this.getBinaries(id);
  119.                 if(list!=null && !list.isEmpty()){
  120.                     operation.setBinaryList(list);
  121.                 }   
  122.                 
  123.             }else{
  124.                 throw new AuditException("[DriverAudit::getOperation] non presente");
  125.             }
  126.         
  127.             return operation;
  128.         } catch (SQLException se) {
  129.             throw new AuditException("[DriverAudit::getOperation] SqlException: " + se.getMessage(),se);
  130.         } catch (Exception ex) {
  131.             throw new AuditException("[DriverAudit::getOperation] Exception: " + ex.getMessage(),ex);
  132.         } finally {
  133.             try {
  134.                 if(rs!=null) {
  135.                     rs.close();
  136.                 }
  137.             } catch (Exception e) {
  138.                 // ignore exception
  139.             }
  140.             try {
  141.                 if(stm!=null) {
  142.                     stm.close();
  143.                 }
  144.             } catch (Exception e) {
  145.                 // ignore exception
  146.             }
  147.         }
  148.     }
  149.     
  150.     public ArrayList<Binary> getBinaries(long idOperation) throws AuditException {
  151.         
  152.         ArrayList<Binary> binaries = new ArrayList<Binary>();
  153.         PreparedStatement stm = null;
  154.         ResultSet rs = null;

  156.         if(idOperation<=0){
  157.             throw new AuditException("[DriverAudit::getBinaries]  Id non valido");
  158.         }
  159.         
  160.         try {
  161.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  162.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  163.             sqlQueryObject.addSelectField("*");
  164.             sqlQueryObject.addWhereCondition("id_audit_operation=?");
  165.             String sqlQuery = sqlQueryObject.createSQLQuery();
  166.             stm = this.connectionDB.prepareStatement(sqlQuery);
  167.             stm.setLong(1, idOperation);
  168.             rs = stm.executeQuery();
  169.             while (rs.next()) {
  170.                 binaries.add(this.getBinary(rs.getLong("id")));
  171.             }
  172.         
  173.             return binaries;
  174.         } catch (SQLException se) {
  175.             throw new AuditException("[DriverAudit::getBinaries] SqlException: " + se.getMessage(),se);
  176.         } catch (Exception ex) {
  177.             throw new AuditException("[DriverAudit::getBinaries] Exception: " + ex.getMessage(),ex);
  178.         } finally {
  179.             try {
  180.                 if(rs!=null) {
  181.                     rs.close();
  182.                 }
  183.             } catch (Exception e) {
  184.                 // ignore exception
  185.             }
  186.             try {
  187.                 if(stm!=null) {
  188.                     stm.close();
  189.                 }
  190.             } catch (Exception e) {
  191.                 // ignore exception
  192.             }
  193.         }
  194.     }
  195.     
  196.     public Binary getBinary(long id) throws AuditException {
  197.         
  198.         Binary binary = null;
  199.         PreparedStatement stm = null;
  200.         ResultSet rs = null;

  202.         if(id<=0){
  203.             throw new AuditException("[DriverAudit::getBinary]  Id non valido");
  204.         }
  205.         
  206.         try {
  207.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  208.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  209.             sqlQueryObject.addSelectField("*");
  210.             sqlQueryObject.addWhereCondition("id=?");
  211.             String sqlQuery = sqlQueryObject.createSQLQuery();
  212.             stm = this.connectionDB.prepareStatement(sqlQuery);
  213.             stm.setLong(1, id);
  214.             rs = stm.executeQuery();
  215.             if (rs.next()) {
  216.                 binary = new Binary();
  217.                 
  218.                 binary.setBinaryId(rs.getString("binary_id"));
  219.                 binary.setChecksum(rs.getLong("checksum")); 
  220.                 binary.setIdOperation(rs.getLong("id_audit_operation"));
  221.                 binary.setId(id);
  222.                 
  223.             }else{
  224.                 throw new AuditException("[DriverAudit::getBinary] non presente");
  225.             }
  226.         
  227.             return binary;
  228.         } catch (SQLException se) {
  229.             throw new AuditException("[DriverAudit::getBinary] SqlException: " + se.getMessage(),se);
  230.         } catch (Exception ex) {
  231.             throw new AuditException("[DriverAudit::getBinary] Exception: " + ex.getMessage(),ex);
  232.         } finally {
  233.             try {
  234.                 if(rs!=null) {
  235.                     rs.close();
  236.                 }
  237.             } catch (Exception e) {
  238.                 // ignore exception
  239.             }
  240.             try {
  241.                 if(stm!=null) {
  242.                     stm.close();
  243.                 }
  244.             } catch (Exception e) {
  245.                 // ignore exception
  246.             }
  247.         }
  248.     }
  249.     
  250.     
  251.     public void createOperation(Operation operation) throws AuditException {
  252.         
  253.         if (operation == null)
  254.             throw new AuditException("[DriverAudit::createOperation] Parametro non valido.");

  256.         
  257.         try {
  258.             
  259.             //Inserimento della traccia nel DB
  260.             if(!TipiDatabase.isAMember(this.tipoDB)){
  261.                 throw new Exception("Tipo database ["+this.tipoDB+"] non supportato");
  262.             }
  263.             TipiDatabase tipo = TipiDatabase.toEnumConstant(this.tipoDB);
  264.             // ** Preparazione parametri
  265.             Timestamp timeRequestT = null;
  266.             if(operation.getTimeRequest()!=null){
  267.                 timeRequestT = new Timestamp(operation.getTimeRequest().getTime());
  268.             }
  269.             Timestamp timeExecuteT = null;
  270.             if(operation.getTimeExecute()!=null){
  271.                 timeExecuteT = new Timestamp(operation.getTimeExecute().getTime());
  272.             }
  273.             // ** Insert and return generated key
  274.             CustomKeyGeneratorObject customKeyGeneratorObject = new CustomKeyGeneratorObject(Costanti.DB_AUDIT_OPERATIONS_TABLE, Costanti.DB_AUDIT_OPERATIONS_TABLE_ID, 
  275.                     Costanti.DB_AUDIT_OPERATIONS_TABLE_SEQUENCE, Costanti.DB_AUDIT_OPERATIONS_TABLE_FOR_ID_SEQUENCE);
  276.             long idoperazione = InsertAndGeneratedKey.insertAndReturnGeneratedKey(this.connectionDB, tipo, customKeyGeneratorObject, 
  277.                         new InsertAndGeneratedKeyObject("tipo_operazione", operation.getTipologia()!=null ? operation.getTipologia().getValue() : null, InsertAndGeneratedKeyJDBCType.STRING),
  278.                         new InsertAndGeneratedKeyObject("tipo", operation.getTipoOggetto(), InsertAndGeneratedKeyJDBCType.STRING),
  279.                         new InsertAndGeneratedKeyObject("object_id", operation.getObjectId(), InsertAndGeneratedKeyJDBCType.STRING),
  280.                         new InsertAndGeneratedKeyObject("object_old_id", operation.getObjectOldId(), InsertAndGeneratedKeyJDBCType.STRING),
  281.                         new InsertAndGeneratedKeyObject("utente", operation.getUtente(), InsertAndGeneratedKeyJDBCType.STRING),
  282.                         new InsertAndGeneratedKeyObject("stato", operation.getStato()!=null ? operation.getStato().getValue() : null, InsertAndGeneratedKeyJDBCType.STRING),
  283.                         new InsertAndGeneratedKeyObject("object_details", operation.getObjectDetails(), InsertAndGeneratedKeyJDBCType.STRING),
  284.                         new InsertAndGeneratedKeyObject("object_class", operation.getObjectClass(), InsertAndGeneratedKeyJDBCType.STRING),
  285.                         new InsertAndGeneratedKeyObject("error", operation.getError(), InsertAndGeneratedKeyJDBCType.STRING),
  286.                         new InsertAndGeneratedKeyObject("time_request", timeRequestT, InsertAndGeneratedKeyJDBCType.TIMESTAMP),
  287.                         new InsertAndGeneratedKeyObject("time_execute", timeExecuteT, InsertAndGeneratedKeyJDBCType.TIMESTAMP));
  288.             if(idoperazione<=0){
  289.                 throw new Exception("ID autoincrementale non ottenuto");
  290.             }                       
  291.             
  292.             // binaries
  293.             for(int i=0; i<operation.sizeBinaryList(); i++){
  294.                 Binary binary = operation.getBinary(i);
  295.                 binary.setIdOperation(idoperazione);
  296.                 this.createBinary(binary);
  297.             }
  298.             
  299.             // Aggiorno l'id
  300.             operation.setId(idoperazione);
  301.             
  302.         } catch (Exception qe) {
  303.             throw new AuditException(qe.getMessage(),qe);
  304.         } 
  305.     }
  306.     
  307.     public void createBinary(Binary binary) throws AuditException {
  308.         ResultSet rs = null;
  309.         PreparedStatement stm = null;
  310.         String sqlQuery = "";

  312.         if (binary == null)
  313.             throw new AuditException("[DriverAudit::createBinary] Parametro non valido.");
  314.         if (binary.getIdOperation() == null)
  315.             throw new AuditException("[DriverAudit::createBinary] IDOperation non valido.");
  316.         if (binary.getIdOperation() <= 0)
  317.             throw new AuditException("[DriverAudit::createBinary] IDOperation("+binary.getIdOperation()+") non valido.");
  318.         
  319.         try {
  320.             
  321.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  322.             sqlQueryObject.addInsertTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  323.             sqlQueryObject.addInsertField("binary_id", "?");
  324.             sqlQueryObject.addInsertField("checksum", "?");
  325.             sqlQueryObject.addInsertField("id_audit_operation", "?");
  326.             sqlQuery = sqlQueryObject.createSQLInsert();
  327.             stm = this.connectionDB.prepareStatement(sqlQuery);
  328.             
  329.             stm.setString(1, binary.getBinaryId());
  330.             stm.setLong(2, binary.getChecksum());
  331.             stm.setLong(3, binary.getIdOperation());
  332.             stm.executeUpdate();
  333.             stm.close();
  334.             
  335.             // Recupero id
  336.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  337.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  338.             sqlQueryObject.addSelectField(Costanti.DB_AUDIT_BINARIES_TABLE, "id");
  339.             sqlQueryObject.addWhereCondition("binary_id=?");
  340.             sqlQueryObject.addWhereCondition("id_audit_operation=?");
  341.             sqlQueryObject.setANDLogicOperator(true);
  342.             sqlQuery = sqlQueryObject.createSQLQuery();
  343.             stm = this.connectionDB.prepareStatement(sqlQuery);
  344.             stm.setString(1, binary.getBinaryId());
  345.             stm.setLong(2, binary.getIdOperation());
  346.             rs = stm.executeQuery();
  347.             if(rs.next()){
  348.                 binary.setId(rs.getLong("id"));
  349.             }else{
  350.                 throw new Exception("Identificativo dopo l'insert non recuperato");
  351.             }
  352.             
  353.         } catch (Exception qe) {
  354.             throw new AuditException(qe.getMessage(),qe);
  355.         } finally {

  357.             try {
  358.                 if(rs!=null) {
  359.                     rs.close();
  360.                 }
  361.             } catch (Exception e) {
  362.                 // ignore exception
  363.             }
  364.             try {
  365.                 if(stm!=null) {
  366.                     stm.close();
  367.                 }
  368.             } catch (Exception e) {
  369.                 // ignore exception
  370.             }
  371.         }
  372.     }
  373.     
  374.     
  375.     public void updateOperation(Operation operation,boolean updateBinaries) throws AuditException {
  376.         ResultSet rs = null;
  377.         PreparedStatement stm = null;
  378.         String sqlQuery = "";

  380.         if (operation == null)
  381.             throw new AuditException("[DriverAudit::updateOperation] Parametro non valido.");
  382.         if (operation.getId()<=0)
  383.             throw new AuditException("[DriverAudit::updateOperation] ID ("+operation.getId()+") non valido.");

  385.         
  386.         try {
  387.             
  388.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  389.             sqlQueryObject.addUpdateTable(Costanti.DB_AUDIT_OPERATIONS_TABLE);
  390.             sqlQueryObject.addUpdateField("tipo_operazione", "?");
  391.             sqlQueryObject.addUpdateField("tipo", "?");
  392.             sqlQueryObject.addUpdateField("object_id", "?");
  393.             sqlQueryObject.addUpdateField("object_old_id", "?");
  394.             sqlQueryObject.addUpdateField("utente", "?");
  395.             sqlQueryObject.addUpdateField("stato", "?");
  396.             sqlQueryObject.addUpdateField("object_details", "?");
  397.             sqlQueryObject.addUpdateField("object_class", "?");
  398.             sqlQueryObject.addUpdateField("error", "?");
  399.             sqlQueryObject.addUpdateField("time_request", "?");
  400.             sqlQueryObject.addUpdateField("time_execute", "?");
  401.             sqlQueryObject.addWhereCondition("id=?");
  402.             sqlQuery = sqlQueryObject.createSQLUpdate();
  403.             stm = this.connectionDB.prepareStatement(sqlQuery);
  404.             
  405.             stm.setString(1, operation.getTipologia()!=null ? operation.getTipologia().getValue() : null);
  406.             stm.setString(2, operation.getTipoOggetto());
  407.             stm.setString(3, operation.getObjectId());
  408.             stm.setString(4, operation.getObjectOldId());
  409.             stm.setString(5, operation.getUtente());
  410.             stm.setString(6, operation.getStato()!=null ? operation.getStato().getValue() : null);
  411.             stm.setString(7, operation.getObjectDetails());
  412.             stm.setString(8, operation.getObjectClass());
  413.             stm.setString(9, operation.getError());
  414.             stm.setTimestamp(10, new Timestamp(operation.getTimeRequest().getTime()));
  415.             stm.setTimestamp(11, new Timestamp(operation.getTimeExecute().getTime()));
  416.             stm.setLong(12,operation.getId());
  417.             stm.executeUpdate();
  418.             
  419.             if(updateBinaries){
  420.             
  421.                 // deleteAllBinaries
  422.                 this.deleteBinaries(operation.getId());
  423.                 
  424.                 // binaries
  425.                 for(int i=0; i<operation.sizeBinaryList(); i++){
  426.                     Binary binary = operation.getBinary(i);
  427.                     binary.setIdOperation(operation.getId());
  428.                     this.createBinary(binary);
  429.                 }
  430.                 
  431.             }
  432.             
  433.         } catch (Exception qe) {
  434.             throw new AuditException(qe.getMessage(),qe);
  435.         } finally {

  437.             //Chiudo statement and resultset
  438.             try {
  439.                 if (rs != null)
  440.                     rs.close();
  441.             } catch (Exception e) {
  442.                 //ignore
  443.             }
  444.             try {
  445.                 if (stm != null)
  446.                     stm.close();
  447.             } catch (Exception e) {
  448.                 //ignore
  449.             }
  450.         }
  451.     }
  452.     
  453.     public void updateBinary(Binary binary) throws AuditException {
  454.         PreparedStatement stm = null;
  455.         String sqlQuery = "";

  457.         if (binary == null)
  458.             throw new AuditException("[DriverAudit::updateBinary] Parametro non valido.");
  459.         if (binary.getIdOperation() == null)
  460.             throw new AuditException("[DriverAudit::updateBinary] IDOperation non valido.");
  461.         if (binary.getIdOperation() <= 0)
  462.             throw new AuditException("[DriverAudit::updateBinary] IDOperation("+binary.getIdOperation()+") non valido.");
  463.         if (binary.getId() == null)
  464.             throw new AuditException("[DriverAudit::updateBinary] ID non valido.");
  465.         if (binary.getId() <= 0)
  466.             throw new AuditException("[DriverAudit::updateBinary] ID("+binary.getId()+") non valido.");
  467.         
  468.         try {
  469.             
  470.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  471.             sqlQueryObject.addUpdateTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  472.             sqlQueryObject.addUpdateField("binary_id", "?");
  473.             sqlQueryObject.addUpdateField("checksum", "?");
  474.             sqlQueryObject.addUpdateField("id_audit_operation", "?");
  475.             sqlQueryObject.addWhereCondition("id=?");
  476.             sqlQuery = sqlQueryObject.createSQLUpdate();
  477.             stm = this.connectionDB.prepareStatement(sqlQuery);
  478.             
  479.             stm.setString(1, binary.getBinaryId());
  480.             stm.setLong(2, binary.getChecksum());
  481.             stm.setLong(3, binary.getIdOperation());
  482.             stm.setLong(4, binary.getId());
  483.             stm.executeUpdate();
  484.             stm.close();
  485.             
  486.         } catch (Exception qe) {
  487.             throw new AuditException(qe.getMessage(),qe);
  488.         } finally {

  490.             //Chiudo statement and resultset
  491.             try {
  492.                 if (stm != null)
  493.                     stm.close();
  494.             } catch (Exception e) {
  495.                 //ignore
  496.             }
  497.         }
  498.     }
  499.     
  500.     
  501.     
  502.     
  503.     public void deleteOperation(Operation operation) throws AuditException {
  504.         if (operation == null)
  505.             throw new AuditException("[DriverAudit::deleteOperation] Parametro non valido.");
  506.         if (operation.getId() <= 0)
  507.             throw new AuditException("[DriverAudit::deleteOperation] ID("+operation.getId()+") non valido.");
  508.         this.deleteOperation(operation.getId());
  509.     }
  510.     
  511.     public void deleteOperation(long id) throws AuditException {
  512.         PreparedStatement stm = null;
  513.         String sqlQuery = "";

  515.         if (id <= 0)
  516.             throw new AuditException("[DriverAudit::deleteBinary] ID("+id+") non valido.");
  517.         
  518.         try {
  519.             
  520.             this.deleteBinaries(id);
  521.             
  522.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  523.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_OPERATIONS_TABLE);
  524.             sqlQueryObject.addWhereCondition("id=?");
  525.             sqlQuery = sqlQueryObject.createSQLDelete();
  526.             stm = this.connectionDB.prepareStatement(sqlQuery);
  527.             stm.setLong(1, id);
  528.             stm.executeUpdate();
  529.             stm.close();
  530.             
  531.         } catch (Exception qe) {
  532.             throw new AuditException(qe.getMessage(),qe);
  533.         } finally {

  535.             //Chiudo statement and resultset
  536.             try {
  537.                 if (stm != null)
  538.                     stm.close();
  539.             } catch (Exception e) {
  540.                 //ignore
  541.             }
  542.         }
  543.     }
  544.     
  545.     
  546.     public void deleteBinaries(long idOperation) throws AuditException {
  547.         PreparedStatement stm = null;
  548.         String sqlQuery = "";

  550.         if (idOperation <= 0)
  551.             throw new AuditException("[DriverAudit::deleteBinary] IDOperation("+idOperation+") non valido.");
  552.         
  553.         try {
  554.             
  555.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  556.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  557.             sqlQueryObject.addWhereCondition("id_audit_operation=?");
  558.             sqlQuery = sqlQueryObject.createSQLDelete();
  559.             stm = this.connectionDB.prepareStatement(sqlQuery);
  560.             stm.setLong(1, idOperation);
  561.             stm.executeUpdate();
  562.             stm.close();
  563.             
  564.         } catch (Exception qe) {
  565.             throw new AuditException(qe.getMessage(),qe);
  566.         } finally {

  568.             //Chiudo statement and resultset
  569.             try {
  570.                 if (stm != null)
  571.                     stm.close();
  572.             } catch (Exception e) {
  573.                 //ignore
  574.             }
  575.         }
  576.     }
  577.     
  578.     public void deleteBinary(Binary binary) throws AuditException {
  579.         if (binary == null)
  580.             throw new AuditException("[DriverAudit::deleteBinary] Parametro non valido.");
  581.         if (binary.getId() == null)
  582.             throw new AuditException("[DriverAudit::deleteBinary] ID non valido.");
  583.         if (binary.getId() <= 0)
  584.             throw new AuditException("[DriverAudit::deleteBinary] ID("+binary.getId()+") non valido.");
  585.         this.deleteBinary(binary.getId());
  586.     }
  587.     
  588.     public void deleteBinary(long id) throws AuditException {
  589.         PreparedStatement stm = null;
  590.         String sqlQuery = "";

  592.         if (id <= 0)
  593.             throw new AuditException("[DriverAudit::deleteBinary] ID("+id+") non valido.");
  594.         
  595.         try {
  596.             
  597.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  598.             sqlQueryObject.addDeleteTable(Costanti.DB_AUDIT_BINARIES_TABLE);
  599.             sqlQueryObject.addWhereCondition("id=?");
  600.             sqlQuery = sqlQueryObject.createSQLDelete();
  601.             stm = this.connectionDB.prepareStatement(sqlQuery);
  602.             stm.setLong(1, id);
  603.             stm.executeUpdate();
  604.             stm.close();
  605.             
  606.         } catch (Exception qe) {
  607.             throw new AuditException(qe.getMessage(),qe);
  608.         } finally {

  610.             //Chiudo statement and resultset
  611.             try {
  612.                 if (stm != null)
  613.                     stm.close();
  614.             } catch (Exception e) {
  615.                 //ignore
  616.             }
  617.         }
  618.     }

  620.     public List<Operation> auditOperationList(ISearch ricerca, int idLista,
  621.             String datainizio, String datafine, String tipooperazione,
  622.             String tipooggetto, String id, String oldid, String utente,
  623.             String statooperazione, String contoggetto) throws AuditException {
  624.         String nomeMetodo = "auditOperationList";
  625.         int offset;
  626.         int limit;
  627.         //String search;
  628.         String queryString;

  630.         limit = ricerca.getPageSize(idLista);
  631.         offset = ricerca.getIndexIniziale(idLista);
  632.         //search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  634.         PreparedStatement stmt=null;
  635.         ResultSet risultato=null;
  636.         ArrayList<Operation> lista = new ArrayList<Operation>();

  638.         try {
  639.             // Conversione Data
  640.             SimpleDateFormat simpleDateFormat = DateUtils.getDefaultDateFormatter("yyyy-MM-dd");
  641.             Date dataInizioData = datainizio != null && !"".equals(datainizio) ?
  642.                     simpleDateFormat.parse(datainizio) : null;
  643.             Date dataFineData = datafine != null && !"".equals(datafine) ?
  644.                     simpleDateFormat.parse(datafine) : null;
  645.             // data fine inidica l intera giornata quinid aggiungo 1 giorno alla
  646.             // data
  647.             // inserita
  648.             if (dataFineData != null) {
  649.                 Calendar cal = Calendar.getInstance();
  650.                 cal.setTime(dataFineData);
  651.                 cal.add(Calendar.DAY_OF_WEEK, 1);
  652.                 dataFineData = cal.getTime();
  653.             }
  654.             Calendar cal_start = null;
  655.             if (dataInizioData != null) {
  656.                 cal_start = Calendar.getInstance();
  657.                 cal_start.setTime(dataInizioData);
  658.             }
  659.             Calendar cal_end = null;
  660.             if (dataFineData != null) {
  661.                 cal_end = Calendar.getInstance();
  662.                 cal_end.setTime(dataFineData);
  663.             }

  665.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  666.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_OPERATIONS_TABLE);
  667.             sqlQueryObject.addSelectCountField("*", "cont");
  668.             if (datainizio != null && !datainizio.equals(""))
  669.                 sqlQueryObject.addWhereCondition("time_request >= ?");
  670.             if (datafine != null && !datafine.equals(""))
  671.                 sqlQueryObject.addWhereCondition("time_request <= ?");
  672.             if (tipooperazione != null && !tipooperazione.equals("-"))
  673.                 sqlQueryObject.addWhereCondition("tipo_operazione = ?");
  674.             if (tipooggetto != null && !tipooggetto.equals("-"))
  675.                 sqlQueryObject.addWhereCondition("tipo = ?");
  676.             if (utente != null && !utente.equals(""))
  677.                 sqlQueryObject.addWhereCondition("utente = ?");
  678.             if (statooperazione != null && !statooperazione.equals("-"))
  679.                 sqlQueryObject.addWhereCondition("stato = ?");
  680.             if (id != null && !id.equals("")) {
  681.                 //sqlQueryObject.addWhereCondition("object_id = ?");
  682.                 sqlQueryObject.addWhereLikeCondition("object_id",id, true, true);
  683.             }
  684.             if (oldid != null && !oldid.equals("")) {
  685.                 //sqlQueryObject.addWhereCondition("object_old_id = ?");
  686.                 sqlQueryObject.addWhereLikeCondition("object_old_id",id, true, true);
  687.             }
  688.             if (contoggetto != null && !contoggetto.equals(""))
  689.                 sqlQueryObject.addWhereLikeCondition("object_details",
  690.                         contoggetto, true, true);
  691.             sqlQueryObject.setANDLogicOperator(true);
  692.             queryString = sqlQueryObject.createSQLQuery();
  693.             stmt = this.connectionDB.prepareStatement(queryString);
  694.             int param_index = 0;
  695.             if (datainizio != null && !datainizio.equals(""))
  696.                 stmt.setTimestamp(++param_index, new Timestamp(cal_start.getTimeInMillis()));
  697.             if (datafine != null && !datafine.equals(""))
  698.                 stmt.setTimestamp(++param_index, new Timestamp(cal_end.getTimeInMillis()));
  699.             if (tipooperazione != null && !tipooperazione.equals("-"))
  700.                 stmt.setString(++param_index, tipooperazione);
  701.             if (tipooggetto != null && !tipooggetto.equals("-"))
  702.                 stmt.setString(++param_index, tipooggetto);
  703.             if (utente != null && !utente.equals(""))
  704.                 stmt.setString(++param_index, utente);
  705.             if (statooperazione != null && !statooperazione.equals("-"))
  706.                 stmt.setString(++param_index, statooperazione);
  707.             /*if (id != null && !id.equals(""))
  708.                 stmt.setString(++param_index, id);
  709.             if (oldid != null && !oldid.equals(""))
  710.                 stmt.setString(++param_index, oldid);*/
  711.             risultato = stmt.executeQuery();
  712.             if (risultato.next())
  713.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  714.             risultato.close();
  715.             stmt.close();

  717.             // ricavo le entries
  718.             if (limit == 0) // con limit
  719.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  721.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  722.             sqlQueryObject.addFromTable(Costanti.DB_AUDIT_OPERATIONS_TABLE);
  723.             sqlQueryObject.addSelectField("id");
  724.             sqlQueryObject.addSelectField("time_execute");
  725.             if (datainizio != null && !datainizio.equals(""))
  726.                 sqlQueryObject.addWhereCondition("time_request >= ?");
  727.             if (datafine != null && !datafine.equals(""))
  728.                 sqlQueryObject.addWhereCondition("time_request <= ?");
  729.             if (tipooperazione != null && !tipooperazione.equals("-"))
  730.                 sqlQueryObject.addWhereCondition("tipo_operazione = ?");
  731.             if (tipooggetto != null && !tipooggetto.equals("-"))
  732.                 sqlQueryObject.addWhereCondition("tipo = ?");
  733.             if (utente != null && !utente.equals(""))
  734.                 sqlQueryObject.addWhereCondition("utente = ?");
  735.             if (statooperazione != null && !statooperazione.equals("-"))
  736.                 sqlQueryObject.addWhereCondition("stato = ?");
  737.             if (id != null && !id.equals("")) {
  738.                 //sqlQueryObject.addWhereCondition("object_id = ?");
  739.                 sqlQueryObject.addWhereLikeCondition("object_id",id, true, true);
  740.             }
  741.             if (oldid != null && !oldid.equals("")) {
  742.                 //sqlQueryObject.addWhereCondition("object_old_id = ?");
  743.                 sqlQueryObject.addWhereLikeCondition("object_old_id",id, true, true);
  744.             }
  745.             if (contoggetto != null && !contoggetto.equals(""))
  746.                 sqlQueryObject.addWhereLikeCondition("object_details",
  747.                         contoggetto, true, true);
  748.             sqlQueryObject.setANDLogicOperator(true);
  749.             sqlQueryObject.addOrderBy("time_execute");
  750.             sqlQueryObject.setSortType(false);
  751.             sqlQueryObject.setLimit(limit);
  752.             sqlQueryObject.setOffset(offset);
  753.             queryString = sqlQueryObject.createSQLQuery();
  754.             stmt = this.connectionDB.prepareStatement(queryString);
  755.             param_index = 0;
  756.             if (datainizio != null && !datainizio.equals(""))
  757.                 stmt.setTimestamp(++param_index, new Timestamp(cal_start.getTimeInMillis()));
  758.             if (datafine != null && !datafine.equals(""))
  759.                 stmt.setTimestamp(++param_index, new Timestamp(cal_end.getTimeInMillis()));
  760.             if (tipooperazione != null && !tipooperazione.equals("-"))
  761.                 stmt.setString(++param_index, tipooperazione);
  762.             if (tipooggetto != null && !tipooggetto.equals("-"))
  763.                 stmt.setString(++param_index, tipooggetto);
  764.             if (utente != null && !utente.equals(""))
  765.                 stmt.setString(++param_index, utente);
  766.             if (statooperazione != null && !statooperazione.equals("-"))
  767.                 stmt.setString(++param_index, statooperazione);
  768.             /*if (id != null && !id.equals(""))
  769.                 stmt.setString(++param_index, id);
  770.             if (oldid != null && !oldid.equals(""))
  771.                 stmt.setString(++param_index, oldid);*/
  772.             risultato = stmt.executeQuery();
  773.             while (risultato.next()) {
  774.                 lista.add(this.getOperation(risultato.getLong("id")));
  775.             }

  777.             return lista;

  779.         } catch (Exception qe) {
  780.             throw new AuditException("[DriverAuditDBAppender::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  781.         } finally {
  782.             try {
  783.                 if(risultato!=null) {
  784.                     risultato.close();
  785.                 }
  786.             } catch (Exception e) {
  787.                 // ignore exception
  788.             }
  789.             try {
  790.                 if(stmt!=null) {
  791.                     stmt.close();
  792.                 }
  793.             } catch (Exception e) {
  794.                 // ignore exception
  795.             }
  796.         }
  797.     }
  798. }
Created with JaCoCo 0.8.8.202204050719