DriverConfigurazioneDB_dumpLIB.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;
  30. import java.util.ArrayList;
  31. import java.util.List;

  33. import org.openspcoop2.core.config.DumpConfigurazione;
  34. import org.openspcoop2.core.config.DumpConfigurazioneRegola;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.utils.TipiDatabase;
  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.jdbc.JDBCUtilities;
  43. import org.openspcoop2.utils.sql.ISQLQueryObject;
  44. import org.openspcoop2.utils.sql.SQLObjectFactory;

  46. /**
  47.  * DriverConfigurazioneDB_configDumpLIB
  48.  * 
  49.  * @author Stefano Corallo - corallo@link.it
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52.  */
  53. public class DriverConfigurazioneDB_dumpLIB {


  56.     
  57.     static void CRUDDumpConfigurazione(int type, Connection con, DumpConfigurazione dumpConfig, 
  58.             Long idProprietario, String tipoProprietario) throws DriverConfigurazioneException {
  59.         
  60.         PreparedStatement updateStmt = null;
  61.         try {
  62.             switch (type) {
  63.             case CREATE:
  64.         
  65.                 if(dumpConfig==null) {
  66.                     break;
  67.                 }
  68.                 
  69.                 long idRequestIn = -1;
  70.                 if(dumpConfig.getRichiestaIngresso()!=null) {
  71.                     idRequestIn = createDumpConfigurazioneRegola(dumpConfig.getRichiestaIngresso(), con);
  72.                 }
  73.                 
  74.                 long idRequestOut = -1;
  75.                 if(dumpConfig.getRichiestaUscita()!=null) {
  76.                     idRequestOut = createDumpConfigurazioneRegola(dumpConfig.getRichiestaUscita(), con);
  77.                 }
  78.                 
  79.                 long idResponseIn = -1;
  80.                 if(dumpConfig.getRispostaIngresso()!=null) {
  81.                     idResponseIn = createDumpConfigurazioneRegola(dumpConfig.getRispostaIngresso(), con);
  82.                 }
  83.                 
  84.                 long idResponseOut = -1;
  85.                 if(dumpConfig.getRispostaUscita()!=null) {
  86.                     idResponseOut = createDumpConfigurazioneRegola(dumpConfig.getRispostaUscita(), con);
  87.                 }
  88.                 
  89.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  90.                 sqlQueryObject.addInsertTable(CostantiDB.DUMP_CONFIGURAZIONE);
  91.                 sqlQueryObject.addInsertField("proprietario", "?");
  92.                 sqlQueryObject.addInsertField("id_proprietario", "?");
  93.                 sqlQueryObject.addInsertField("dump_realtime", "?");
  94.                 sqlQueryObject.addInsertField("id_richiesta_ingresso", "?");
  95.                 sqlQueryObject.addInsertField("id_richiesta_uscita", "?");
  96.                 sqlQueryObject.addInsertField("id_risposta_ingresso", "?");
  97.                 sqlQueryObject.addInsertField("id_risposta_uscita", "?");
  98.                 String updateQuery = sqlQueryObject.createSQLInsert();
  99.                 updateStmt = con.prepareStatement(updateQuery);
  100.                 int index = 1;
  101.                 updateStmt.setString(index++, tipoProprietario);
  102.                 updateStmt.setLong(index++, idProprietario!=null ? idProprietario : -1);
  103.                 updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(dumpConfig.getRealtime()));
  104.                 updateStmt.setLong(index++, idRequestIn);
  105.                 updateStmt.setLong(index++, idRequestOut);
  106.                 updateStmt.setLong(index++, idResponseIn);
  107.                 updateStmt.setLong(index++, idResponseOut);
  108.                 updateStmt.executeUpdate();
  109.                 updateStmt.close();
  110.                 
  111.                 break;
  112.                 
  113.             case UPDATE:
  114.                 
  115.                 // Per la delete recupero l'immagine attuale del confi
  116.                 DumpConfigurazione dumpConfigOld = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, idProprietario, tipoProprietario);
  117.                 if(dumpConfigOld!=null) {
  118.                     CRUDDumpConfigurazione(DELETE, con, dumpConfigOld, idProprietario, tipoProprietario);
  119.                 }
  120.                 
  121.                 // Creo la nuova immagine
  122.                 if(dumpConfig!=null) {
  123.                     CRUDDumpConfigurazione(CREATE, con, dumpConfig, idProprietario, tipoProprietario);
  124.                 }
  125.                 break;
  126.                 
  127.             case DELETE:
  128.                 
  129.                 if(dumpConfig==null) {
  130.                     break;
  131.                 }
  132.                 
  133.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  134.                 sqlQueryObject.addDeleteTable(CostantiDB.DUMP_CONFIGURAZIONE_REGOLA);
  135.                 sqlQueryObject.addWhereCondition("id=?");
  136.                 sqlQueryObject.setANDLogicOperator(true);
  137.                 updateQuery = sqlQueryObject.createSQLDelete();
  138.                 
  139.                 if(dumpConfig.getRichiestaIngresso()!=null) {
  140.                     updateStmt = con.prepareStatement(updateQuery);
  141.                     updateStmt.setLong(1, dumpConfig.getRichiestaIngresso().getId());
  142.                     updateStmt.executeUpdate();
  143.                     updateStmt.close();
  144.                 }
  145.                 if(dumpConfig.getRichiestaUscita()!=null) {
  146.                     updateStmt = con.prepareStatement(updateQuery);
  147.                     updateStmt.setLong(1, dumpConfig.getRichiestaUscita().getId());
  148.                     updateStmt.executeUpdate();
  149.                     updateStmt.close();
  150.                 }
  151.                 if(dumpConfig.getRispostaIngresso()!=null) {
  152.                     updateStmt = con.prepareStatement(updateQuery);
  153.                     updateStmt.setLong(1, dumpConfig.getRispostaIngresso().getId());
  154.                     updateStmt.executeUpdate();
  155.                     updateStmt.close();
  156.                 }
  157.                 if(dumpConfig.getRispostaUscita()!=null) {
  158.                     updateStmt = con.prepareStatement(updateQuery);
  159.                     updateStmt.setLong(1, dumpConfig.getRispostaUscita().getId());
  160.                     updateStmt.executeUpdate();
  161.                     updateStmt.close();
  162.                 }
  163.                 
  164.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  165.                 sqlQueryObject.addDeleteTable(CostantiDB.DUMP_CONFIGURAZIONE);
  166.                 if(!CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG.equals(tipoProprietario) &&
  167.                         !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD.equals(tipoProprietario) &&
  168.                         !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA.equals(tipoProprietario)) {
  169.                     sqlQueryObject.addWhereCondition("id_proprietario=?");
  170.                 }
  171.                 sqlQueryObject.addWhereCondition("proprietario=?");
  172.                 sqlQueryObject.setANDLogicOperator(true);
  173.                 updateQuery = sqlQueryObject.createSQLDelete();
  174.                 updateStmt = con.prepareStatement(updateQuery);
  175.                 index = 1;
  176.                 if(!CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG.equals(tipoProprietario) &&
  177.                         !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD.equals(tipoProprietario) &&
  178.                         !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA.equals(tipoProprietario)) {
  179.                     updateStmt.setLong(index++, idProprietario);
  180.                 }
  181.                 updateStmt.setString(index++, tipoProprietario);
  182.                 updateStmt.executeUpdate();
  183.                 
  184.                 break;
  185.             }
  186.         
  187.         } catch (SQLException se) {
  188.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDDumpConfigurazione] SQLException [" + se.getMessage() + "].",se);
  189.         }catch (Exception se) {
  190.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDDumpConfigurazione] Exception [" + se.getMessage() + "].",se);
  191.         } finally {
  192.     
  193.             JDBCUtilities.closeResources(updateStmt);
  194.             
  195.         }
  196.     }
  197.     
  198.     private static long createDumpConfigurazioneRegola(DumpConfigurazioneRegola dumpRegola, Connection con) throws Exception {
  199.         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  200.         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("body", DriverConfigurazioneDBLib.getValue(dumpRegola.getBody()) , InsertAndGeneratedKeyJDBCType.STRING) );
  201.         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("payload", DriverConfigurazioneDBLib.getValue(dumpRegola.getPayload()) , InsertAndGeneratedKeyJDBCType.STRING) );
  202.         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("payload_parsing", DriverConfigurazioneDBLib.getValue(dumpRegola.getPayloadParsing()) , InsertAndGeneratedKeyJDBCType.STRING) );
  203.         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("attachments", DriverConfigurazioneDBLib.getValue(dumpRegola.getAttachments()) , InsertAndGeneratedKeyJDBCType.STRING) );
  204.         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("headers", DriverConfigurazioneDBLib.getValue(dumpRegola.getHeaders()) , InsertAndGeneratedKeyJDBCType.STRING) );
  205.         
  206.         long idDumpconfigurazioneRegola = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  207.                 new CustomKeyGeneratorObject(CostantiDB.DUMP_CONFIGURAZIONE_REGOLA, CostantiDB.DUMP_CONFIGURAZIONE_REGOLA_COLUMN_ID, 
  208.                         CostantiDB.DUMP_CONFIGURAZIONE_REGOLA_SEQUENCE, CostantiDB.DUMP_CONFIGURAZIONE_REGOLA_TABLE_FOR_ID),
  209.                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  210.         if(idDumpconfigurazioneRegola<=0){
  211.             throw new Exception("ID (dump configurazione regola) autoincrementale non ottenuto");
  212.         }
  213.         return idDumpconfigurazioneRegola;
  214.     }
  215.     
  216.     protected static DumpConfigurazione readDumpConfigurazione(Connection con, Long idProprietario, String tipoProprietario) throws Exception {
  217.         PreparedStatement stm1=null;
  218.         ResultSet rs1= null;
  219.         try {
  220.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  221.             sqlQueryObject.addFromTable(CostantiDB.DUMP_CONFIGURAZIONE);
  222.             sqlQueryObject.addSelectField("*");
  223.             if(!CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG.equals(tipoProprietario) &&
  224.                     !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD.equals(tipoProprietario) &&
  225.                     !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA.equals(tipoProprietario)) {
  226.                 sqlQueryObject.addWhereCondition("id_proprietario=?");
  227.             }
  228.             sqlQueryObject.addWhereCondition("proprietario=?");
  229.             sqlQueryObject.setANDLogicOperator(true);
  230.             
  231.             String sqlQuery = sqlQueryObject.createSQLQuery();
  232.             
  233.             stm1 = con.prepareStatement(sqlQuery);
  234.             int index = 1;
  235.             if(!CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG.equals(tipoProprietario) &&
  236.                     !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD.equals(tipoProprietario) &&
  237.                     !CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA.equals(tipoProprietario)) {
  238.                 stm1.setLong(index++, idProprietario);
  239.             }
  240.             stm1.setString(index++, tipoProprietario);
  241.             rs1 = stm1.executeQuery();
  242.             
  243.             //recuper tutti gli appender e le prop di ogni appender
  244.             DumpConfigurazione dumpConfig = null;
  245.             if(rs1.next()){
  246.                 
  247.                 dumpConfig = new DumpConfigurazione();
  248.                 
  249.                 dumpConfig.setId(rs1.getLong("id"));
  250.                 
  251.                 dumpConfig.setRealtime(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("dump_realtime")));
  252.                 
  253.                 long idRequestIn = rs1.getLong("id_richiesta_ingresso");
  254.                 if(idRequestIn>0) {
  255.                     dumpConfig.setRichiestaIngresso(readDumpConfigurazioneRegola(con, idRequestIn));
  256.                 }
  257.                 
  258.                 long idRequestOut = rs1.getLong("id_richiesta_uscita");
  259.                 if(idRequestOut>0) {
  260.                     dumpConfig.setRichiestaUscita(readDumpConfigurazioneRegola(con, idRequestOut));
  261.                 }
  262.                 
  263.                 long idResponseIn = rs1.getLong("id_risposta_ingresso");
  264.                 if(idResponseIn>0) {
  265.                     dumpConfig.setRispostaIngresso(readDumpConfigurazioneRegola(con, idResponseIn));
  266.                 }
  267.                 
  268.                 long idResponseOut = rs1.getLong("id_risposta_uscita");
  269.                 if(idResponseOut>0) {
  270.                     dumpConfig.setRispostaUscita(readDumpConfigurazioneRegola(con, idResponseOut));
  271.                 }
  272.                 
  273.             }
  274.             return dumpConfig;

  276.         }finally {
  277.             JDBCUtilities.closeResources(rs1, stm1);
  278.         }
  279.     }
  280.     
  281.     private static DumpConfigurazioneRegola readDumpConfigurazioneRegola(Connection con, long idRegola) throws Exception {
  282.         PreparedStatement stm1=null;
  283.         ResultSet rs1= null;
  284.         try {
  285.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  286.             sqlQueryObject.addFromTable(CostantiDB.DUMP_CONFIGURAZIONE_REGOLA);
  287.             sqlQueryObject.addSelectField("*");
  288.             sqlQueryObject.addWhereCondition("id=?");
  289.             sqlQueryObject.setANDLogicOperator(true);
  290.             
  291.             String sqlQuery = sqlQueryObject.createSQLQuery();
  292.             
  293.             stm1 = con.prepareStatement(sqlQuery);
  294.             stm1.setLong(1, idRegola);
  295.             rs1 = stm1.executeQuery();
  296.             
  297.             //recuper tutti gli appender e le prop di ogni appender
  298.             DumpConfigurazioneRegola dumpConfig = new DumpConfigurazioneRegola(); // ci sono i default
  299.             if(rs1.next()){
  300.                 
  301.                 dumpConfig.setId(rs1.getLong("id"));
  302.                 dumpConfig.setBody(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("body")));
  303.                 dumpConfig.setPayload(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("payload")));
  304.                 dumpConfig.setPayloadParsing(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("payload_parsing")));
  305.                 dumpConfig.setAttachments(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("attachments")));
  306.                 dumpConfig.setHeaders(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs1.getString("headers")));
  307.                 
  308.             }

  310.             return dumpConfig;

  312.         }finally {
  313.             JDBCUtilities.closeResources(rs1, stm1);
  314.         }
  315.     }
  316.     

  318.     
  319. }
Created with JaCoCo 0.8.8.202204050719