DriverConfigurazioneDBTracciamentoLIB.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.  */
  20. package org.openspcoop2.core.config.driver.db;

  22. import static org.openspcoop2.core.constants.CostantiDB.CREATE;
  23. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  24. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;

  31. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  32. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletrace;
  33. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletraceConnector;
  34. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  38. import org.openspcoop2.utils.sql.ISQLQueryObject;
  39. import org.openspcoop2.utils.sql.SQLObjectFactory;
  40. import org.openspcoop2.utils.sql.SQLQueryObjectException;

  42. /**
  43.  * DriverConfigurazioneDBTracciamentoLIB
  44.  * 
  45.  * @author Poli Andrea (poli@link.it)
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  */
  49. public class DriverConfigurazioneDBTracciamentoLIB {
  50.     
  51.     private DriverConfigurazioneDBTracciamentoLIB() {}


  54.     static void crudTracciamentoConfigurazione(int type, Connection con, TracciamentoConfigurazione tracciamentoConfig, 
  55.             Long idProprietario, String tipoProprietario, String tipoConfigurazione) throws DriverConfigurazioneException {
  56.         
  57.         PreparedStatement updateStmt = null;
  58.         try {
  59.             switch (type) {
  60.             case CREATE:
  61.         
  62.                 if(tracciamentoConfig==null) {
  63.                     break;
  64.                 }
  65.                 
  66.                 createTracciamentoConfigurazione(con, tracciamentoConfig, 
  67.                         idProprietario, tipoProprietario, tipoConfigurazione);
  68.                 
  69.                 break;
  70.                 
  71.             case UPDATE:
  72.                 
  73.                 // Per la delete recupero l'immagine attuale del config
  74.                 TracciamentoConfigurazione tracciamentoConfigOld = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, idProprietario, tipoProprietario, tipoConfigurazione);
  75.                 if(tracciamentoConfigOld!=null) {
  76.                     crudTracciamentoConfigurazione(DELETE, con, tracciamentoConfigOld, idProprietario, tipoProprietario, tipoConfigurazione);
  77.                 }
  78.                 
  79.                 // Creo la nuova immagine
  80.                 if(tracciamentoConfig!=null) {
  81.                     crudTracciamentoConfigurazione(CREATE, con, tracciamentoConfig, idProprietario, tipoProprietario, tipoConfigurazione);
  82.                 }
  83.                 break;
  84.                 
  85.             case DELETE:
  86.                 
  87.                 if(tracciamentoConfig==null) {
  88.                     break;
  89.                 }
  90.                                 
  91.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  92.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE);
  93.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_PROPRIETARIO+"=?");
  94.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_TIPO+"=?");
  95.                 if(idProprietario!=null) {
  96.                     sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_ID_PROPRIETARIO+"=?");
  97.                 }
  98.                 sqlQueryObject.setANDLogicOperator(true);
  99.                 String updateQuery = sqlQueryObject.createSQLDelete();
  100.                 updateStmt = con.prepareStatement(updateQuery);
  101.                 int index = 1;
  102.                 updateStmt.setString(index++, tipoProprietario);
  103.                 updateStmt.setString(index++, tipoConfigurazione);
  104.                 if(idProprietario!=null) {
  105.                     updateStmt.setLong(index++, idProprietario);
  106.                 }
  107.                 updateStmt.executeUpdate();
  108.                 
  109.                 break;
  110.                 
  111.             default: 
  112.                 break;
  113.             
  114.             }
  115.                     
  116.         } catch (SQLException se) {
  117.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::crudTracciamentoConfigurazione] SQLException [" + se.getMessage() + "].",se);
  118.         }catch (Exception se) {
  119.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::crudTracciamentoConfigurazione] Exception [" + se.getMessage() + "].",se);
  120.         } finally {
  121.     
  122.             JDBCUtilities.closeResources(updateStmt);
  123.             
  124.         }
  125.     }
  126.         
  127.     private static void createTracciamentoConfigurazione(Connection con, TracciamentoConfigurazione tracciamentoConfig, 
  128.             Long idProprietario, String tipoProprietario, String tipoConfigurazione) throws SQLException, SQLQueryObjectException {
  129.         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  130.         sqlQueryObject.addInsertTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE);
  131.         sqlQueryObject.addInsertField(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_PROPRIETARIO, "?");
  132.         sqlQueryObject.addInsertField(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_TIPO, "?");
  133.         sqlQueryObject.addInsertField(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_ID_PROPRIETARIO, "?");
  134.         sqlQueryObject.addInsertField("stato", "?");
  135.         sqlQueryObject.addInsertField("filtro_esiti", "?");
  136.         sqlQueryObject.addInsertField("request_in", "?");
  137.         sqlQueryObject.addInsertField("request_out", "?");
  138.         sqlQueryObject.addInsertField("response_out", "?");
  139.         sqlQueryObject.addInsertField("response_out_complete", "?");
  140.         
  141.         PreparedStatement updateStmt = null;
  142.         try {
  143.             String updateQuery = sqlQueryObject.createSQLInsert();
  144.             updateStmt = con.prepareStatement(updateQuery);
  145.             int index = 1;
  146.             updateStmt.setString(index++, tipoProprietario);
  147.             updateStmt.setString(index++, tipoConfigurazione);
  148.             updateStmt.setLong(index++, idProprietario!=null ? idProprietario : -1);
  149.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getStato()));
  150.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getFiltroEsiti()));
  151.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getRequestIn()));
  152.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getRequestOut()));
  153.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getResponseOut()));
  154.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getResponseOutComplete()));
  155.             updateStmt.executeUpdate();
  156.             updateStmt.close();
  157.             updateStmt=null;
  158.         } finally {
  159.             JDBCUtilities.closeResources(updateStmt);
  160.         }
  161.     }
  162.     
  163.     protected static TracciamentoConfigurazione readTracciamentoConfigurazione(Connection con, Long idProprietario, String tipoProprietario, String tipoConfigurazione) throws DriverConfigurazioneException {
  164.         PreparedStatement stm1=null;
  165.         ResultSet rs1= null;
  166.         try {
  167.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  168.             sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE);
  169.             sqlQueryObject.addSelectField("*");
  170.             sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_PROPRIETARIO+"=?");
  171.             sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_TIPO+"=?");
  172.             if(idProprietario!=null) {
  173.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_ID_PROPRIETARIO+"=?");
  174.             }
  175.             sqlQueryObject.setANDLogicOperator(true);
  176.             
  177.             String sqlQuery = sqlQueryObject.createSQLQuery();
  178.             
  179.             stm1 = con.prepareStatement(sqlQuery);
  180.             int index = 1;
  181.             stm1.setString(index++, tipoProprietario);
  182.             stm1.setString(index++, tipoConfigurazione);
  183.             if(idProprietario!=null) {
  184.                 stm1.setLong(index++, idProprietario);
  185.             }
  186.             rs1 = stm1.executeQuery();
  187.             
  188.             TracciamentoConfigurazione tracciamentoConfig = null;
  189.             if(rs1.next()){
  190.                 
  191.                 tracciamentoConfig = new TracciamentoConfigurazione();
  192.                 
  193.                 tracciamentoConfig.setId(rs1.getLong("id"));
  194.                 
  195.                 tracciamentoConfig.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConPersonalizzazione(rs1.getString("stato")));
  196.                 tracciamentoConfig.setFiltroEsiti(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("filtro_esiti")));
  197.                 tracciamentoConfig.setRequestIn(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaBloccante(rs1.getString("request_in")));
  198.                 tracciamentoConfig.setRequestOut(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaBloccante(rs1.getString("request_out")));
  199.                 tracciamentoConfig.setResponseOut(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaBloccante(rs1.getString("response_out")));
  200.                 tracciamentoConfig.setResponseOutComplete(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("response_out_complete")));
  201.                 
  202.             }
  203.             return tracciamentoConfig;

  205.         }catch (Exception se) {
  206.             throw new DriverConfigurazioneException(se.getMessage(),se);
  207.         }finally {
  208.             JDBCUtilities.closeResources(rs1, stm1);
  209.         }
  210.     }
  211.     
  212.     
  213.     
  214.     
  215.     
  216.     
  217.     static void crudTracciamentoConfigurazioneFiletrace(int type, Connection con, TracciamentoConfigurazioneFiletrace tracciamentoConfig, 
  218.             Long idProprietario, String tipoProprietario) throws DriverConfigurazioneException {
  219.         
  220.         PreparedStatement updateStmt = null;
  221.         try {
  222.             switch (type) {
  223.             case CREATE:
  224.         
  225.                 if(tracciamentoConfig==null) {
  226.                     break;
  227.                 }
  228.                 
  229.                 createTracciamentoConfigurazioneFiletrace(con, tracciamentoConfig, 
  230.                         idProprietario, tipoProprietario);
  231.                 
  232.                 break;
  233.                 
  234.             case UPDATE:
  235.                 
  236.                 // Per la delete recupero l'immagine attuale del config
  237.                 TracciamentoConfigurazioneFiletrace tracciamentoConfigOld = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazioneFiletrace(con, idProprietario, tipoProprietario);
  238.                 if(tracciamentoConfigOld!=null) {
  239.                     crudTracciamentoConfigurazioneFiletrace(DELETE, con, tracciamentoConfigOld, idProprietario, tipoProprietario);
  240.                 }
  241.                 
  242.                 // Creo la nuova immagine
  243.                 if(tracciamentoConfig!=null) {
  244.                     crudTracciamentoConfigurazioneFiletrace(CREATE, con, tracciamentoConfig, idProprietario, tipoProprietario);
  245.                 }
  246.                 break;
  247.                 
  248.             case DELETE:
  249.                 
  250.                 if(tracciamentoConfig==null) {
  251.                     break;
  252.                 }
  253.                                 
  254.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  255.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE);
  256.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE_COLUMN_PROPRIETARIO+"=?");
  257.                 if(idProprietario!=null) {
  258.                     sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE_COLUMN_ID_PROPRIETARIO+"=?");
  259.                 }
  260.                 sqlQueryObject.setANDLogicOperator(true);
  261.                 String updateQuery = sqlQueryObject.createSQLDelete();
  262.                 updateStmt = con.prepareStatement(updateQuery);
  263.                 int index = 1;
  264.                 updateStmt.setString(index++, tipoProprietario);
  265.                 if(idProprietario!=null) {
  266.                     updateStmt.setLong(index++, idProprietario);
  267.                 }
  268.                 updateStmt.executeUpdate();
  269.                 
  270.                 break;
  271.                 
  272.             default: 
  273.                 break;
  274.             
  275.             }
  276.                     
  277.         } catch (SQLException se) {
  278.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::crudTracciamentoConfigurazioneFiletrace] SQLException [" + se.getMessage() + "].",se);
  279.         }catch (Exception se) {
  280.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::crudTracciamentoConfigurazioneFiletrace] Exception [" + se.getMessage() + "].",se);
  281.         } finally {
  282.     
  283.             JDBCUtilities.closeResources(updateStmt);
  284.             
  285.         }
  286.     }
  287.     
  288.     private static void createTracciamentoConfigurazioneFiletrace(Connection con, TracciamentoConfigurazioneFiletrace tracciamentoConfig, 
  289.             Long idProprietario, String tipoProprietario) throws SQLException, SQLQueryObjectException {
  290.         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  291.         sqlQueryObject.addInsertTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE);
  292.         sqlQueryObject.addInsertField(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE_COLUMN_PROPRIETARIO, "?");
  293.         sqlQueryObject.addInsertField(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE_COLUMN_ID_PROPRIETARIO, "?");
  294.         sqlQueryObject.addInsertField("config", "?");
  295.         sqlQueryObject.addInsertField("dump_in_stato", "?");
  296.         sqlQueryObject.addInsertField("dump_in_stato_hdr", "?");
  297.         sqlQueryObject.addInsertField("dump_in_stato_body", "?");
  298.         sqlQueryObject.addInsertField("dump_out_stato", "?");
  299.         sqlQueryObject.addInsertField("dump_out_stato_hdr", "?");
  300.         sqlQueryObject.addInsertField("dump_out_stato_body", "?");
  301.         
  302.         PreparedStatement updateStmt = null;
  303.         try {
  304.             String updateQuery = sqlQueryObject.createSQLInsert();
  305.             updateStmt = con.prepareStatement(updateQuery);
  306.             int index = 1;
  307.             updateStmt.setString(index++, tipoProprietario);
  308.             updateStmt.setLong(index++, idProprietario!=null ? idProprietario : -1);
  309.             updateStmt.setString(index++, tracciamentoConfig.getConfig());
  310.             updateStmt.setString(index++, tracciamentoConfig.getDumpIn()!=null ? DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getDumpIn().getStato()) : null);
  311.             updateStmt.setString(index++, tracciamentoConfig.getDumpIn()!=null ? DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getDumpIn().getHeader()) : null);
  312.             updateStmt.setString(index++, tracciamentoConfig.getDumpIn()!=null ? DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getDumpIn().getPayload()) : null);
  313.             updateStmt.setString(index++, tracciamentoConfig.getDumpOut()!=null ? DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getDumpOut().getStato()) : null);
  314.             updateStmt.setString(index++, tracciamentoConfig.getDumpOut()!=null ? DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getDumpOut().getHeader()) : null);
  315.             updateStmt.setString(index++, tracciamentoConfig.getDumpOut()!=null ? DriverConfigurazioneDBLib.getValue(tracciamentoConfig.getDumpOut().getPayload()) : null);
  316.             
  317.             updateStmt.executeUpdate();
  318.             updateStmt.close();
  319.             updateStmt=null;
  320.         } finally {
  321.             JDBCUtilities.closeResources(updateStmt);
  322.         }
  323.     }
  324.         
  325.     protected static TracciamentoConfigurazioneFiletrace readTracciamentoConfigurazioneFiletrace(Connection con, Long idProprietario, String tipoProprietario) throws DriverConfigurazioneException {
  326.         PreparedStatement stm1=null;
  327.         ResultSet rs1= null;
  328.         try {
  329.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  330.             sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE);
  331.             sqlQueryObject.addSelectField("*");
  332.             sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE_COLUMN_PROPRIETARIO+"=?");
  333.             if(idProprietario!=null) {
  334.                 sqlQueryObject.addWhereCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_FILETRACE_COLUMN_ID_PROPRIETARIO+"=?");
  335.             }
  336.             sqlQueryObject.setANDLogicOperator(true);
  337.             
  338.             String sqlQuery = sqlQueryObject.createSQLQuery();
  339.             
  340.             stm1 = con.prepareStatement(sqlQuery);
  341.             int index = 1;
  342.             stm1.setString(index++, tipoProprietario);
  343.             if(idProprietario!=null) {
  344.                 stm1.setLong(index++, idProprietario);
  345.             }
  346.             rs1 = stm1.executeQuery();
  347.             
  348.             TracciamentoConfigurazioneFiletrace tracciamentoConfig = null;
  349.             if(rs1.next()){
  350.                 
  351.                 tracciamentoConfig = new TracciamentoConfigurazioneFiletrace();
  352.                 
  353.                 tracciamentoConfig.setId(rs1.getLong("id"));
  354.                 
  355.                 tracciamentoConfig.setConfig(rs1.getString("config"));
  356.                 
  357.                 StatoFunzionalita inStato = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_in_stato"));
  358.                 StatoFunzionalita inStatoHdr = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_in_stato_hdr"));
  359.                 StatoFunzionalita inStatoBody = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_in_stato_body"));
  360.                 if(inStato!=null || inStatoHdr!=null || inStatoBody!=null) {
  361.                     tracciamentoConfig.setDumpIn(new TracciamentoConfigurazioneFiletraceConnector());
  362.                     tracciamentoConfig.getDumpIn().setStato(inStato);
  363.                     tracciamentoConfig.getDumpIn().setHeader(inStatoHdr);
  364.                     tracciamentoConfig.getDumpIn().setPayload(inStatoBody);
  365.                 }
  366.                 
  367.                 StatoFunzionalita outStato = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_out_stato"));
  368.                 StatoFunzionalita outStatoHdr = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_out_stato_hdr"));
  369.                 StatoFunzionalita outStatoBody = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_out_stato_body"));
  370.                 if(outStato!=null || outStatoHdr!=null || outStatoBody!=null) {
  371.                     tracciamentoConfig.setDumpOut(new TracciamentoConfigurazioneFiletraceConnector());
  372.                     tracciamentoConfig.getDumpOut().setStato(outStato);
  373.                     tracciamentoConfig.getDumpOut().setHeader(outStatoHdr);
  374.                     tracciamentoConfig.getDumpOut().setPayload(outStatoBody);
  375.                 }

  377.             }
  378.             return tracciamentoConfig;

  380.         }catch (Exception se) {
  381.             throw new DriverConfigurazioneException(se.getMessage(),se);
  382.         }finally {
  383.             JDBCUtilities.closeResources(rs1, stm1);
  384.         }
  385.     }

  387.     
  388. }
Created with JaCoCo 0.8.8.202204050719