DriverConfigurazioneDB_handlerLIB.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.ConfigurazioneHandler;
  34. import org.openspcoop2.core.config.ConfigurazioneMessageHandlers;
  35. import org.openspcoop2.core.config.ConfigurazioneServiceHandlers;
  36. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  37. import org.openspcoop2.core.constants.CostantiDB;
  38. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  39. import org.openspcoop2.utils.sql.ISQLQueryObject;
  40. import org.openspcoop2.utils.sql.SQLObjectFactory;

  42. /**
  43.  * DriverConfigurazioneDB_handlerLIB
  44.  * 
  45.  * @author Stefano Corallo - corallo@link.it
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  */
  49. public class DriverConfigurazioneDB_handlerLIB {



  53.     protected static ConfigurazioneMessageHandlers readConfigurazioneMessageHandlers(Connection con, Long idPortaDelegata, Long idPortaApplicatva, boolean request) throws Exception {
  54.         PreparedStatement stm1=null;
  55.         ResultSet rs1= null;
  56.         try {
  57.             
  58.             ConfigurazioneMessageHandlers config = null;
  59.             
  60.             String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  61.             if(idPortaDelegata!=null) {
  62.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  63.             }
  64.             else if(idPortaApplicatva!=null) {
  65.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  66.             }
  67.             
  68.             List<String> tipologie = new ArrayList<>();
  69.             String suffix = request ? CostantiDB.HANDLER_REQUEST_SUFFIX : CostantiDB.HANDLER_RESPONSE_SUFFIX;
  70.             tipologie.add(CostantiDB.HANDLER_PRE_IN+suffix);
  71.             tipologie.add(CostantiDB.HANDLER_IN+suffix);
  72.             if(request) {
  73.                 tipologie.add(CostantiDB.HANDLER_IN_PROTOCOL+suffix);
  74.             }
  75.             tipologie.add(CostantiDB.HANDLER_OUT+suffix);
  76.             tipologie.add(CostantiDB.HANDLER_POST_OUT+suffix);
  77.             
  78.             for (String tipologia : tipologie) {
  79.                 
  80.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  81.                 sqlQueryObject.addFromTable(tabella);
  82.                 sqlQueryObject.addSelectField("*");
  83.                 if(idPortaDelegata!=null || idPortaApplicatva!=null) {
  84.                     sqlQueryObject.addWhereCondition("id_porta=?");
  85.                 }
  86.                 sqlQueryObject.addWhereCondition("tipologia=?");
  87.                 sqlQueryObject.addOrderBy("posizione");
  88.                 
  89.                 sqlQueryObject.setANDLogicOperator(true);
  90.                 String sqlQuery = sqlQueryObject.createSQLQuery();
  91.                 stm1 = con.prepareStatement(sqlQuery);
  92.                 int index = 1;
  93.                 if(idPortaDelegata!=null) {
  94.                     stm1.setLong(index++, idPortaDelegata);
  95.                 }
  96.                 else if(idPortaApplicatva!=null) {
  97.                     stm1.setLong(index++, idPortaApplicatva);
  98.                 }
  99.                 stm1.setString(index++, tipologia);
  100.                 rs1 = stm1.executeQuery();
  101.                 List<ConfigurazioneHandler> list = new ArrayList<ConfigurazioneHandler>();
  102.                 while(rs1.next()){
  103.                     
  104.                     ConfigurazioneHandler handler = new ConfigurazioneHandler();
  105.                     handler.setId(rs1.getLong("id"));
  106.                     handler.setTipo(rs1.getString("tipo"));
  107.                     handler.setPosizione(rs1.getInt("posizione"));
  108.                     String stato = rs1.getString("stato");
  109.                     if(stato!=null && !"".equals(stato)) {
  110.                         handler.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(stato));
  111.                     }
  112.                     list.add(handler);
  113.                     
  114.                 }
  115.                 rs1.close();
  116.                 stm1.close();
  117.                 
  118.                 if(!list.isEmpty()) {
  119.                     if(config==null) {
  120.                         config = new ConfigurazioneMessageHandlers();
  121.                     }
  122.                     if(tipologia.startsWith(CostantiDB.HANDLER_PRE_IN)) {
  123.                         config.setPreInList(list);
  124.                     }
  125.                     else if(tipologia.startsWith(CostantiDB.HANDLER_IN_PROTOCOL)) { // prima di in senno c'e' il bu
  126.                         config.setInProtocolInfoList(list);
  127.                     }
  128.                     else if(tipologia.startsWith(CostantiDB.HANDLER_IN)) {
  129.                         config.setInList(list);
  130.                     }
  131.                     else if(tipologia.startsWith(CostantiDB.HANDLER_OUT)) {
  132.                         config.setOutList(list);
  133.                     }
  134.                     else if(tipologia.startsWith(CostantiDB.HANDLER_POST_OUT)) {
  135.                         config.setPostOutList(list);
  136.                     }
  137.                 }
  138.             }
  139.             
  140.             return config;
  141.             
  142.         }finally {
  143.             JDBCUtilities.closeResources(rs1, stm1);
  144.         }
  145.     }
  146.     
  147.     protected static ConfigurazioneServiceHandlers readConfigurazioneServiceHandlers(Connection con, Long idPortaDelegata, Long idPortaApplicatva, boolean request) throws Exception {
  148.         PreparedStatement stm1=null;
  149.         ResultSet rs1= null;
  150.         try {
  151.             
  152.             ConfigurazioneServiceHandlers config = null;
  153.             
  154.             String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  155.             if(idPortaDelegata!=null) {
  156.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  157.             }
  158.             else if(idPortaApplicatva!=null) {
  159.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  160.             }
  161.             
  162.             List<String> tipologie = new ArrayList<>();
  163.             tipologie.add(CostantiDB.HANDLER_INIT);
  164.             tipologie.add(CostantiDB.HANDLER_EXIT);
  165.             tipologie.add(CostantiDB.HANDLER_INTEGRATION_MANAGER_REQUEST);
  166.             tipologie.add(CostantiDB.HANDLER_INTEGRATION_MANAGER_RESPONSE);
  167.             
  168.             for (String tipologia : tipologie) {
  169.                 
  170.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  171.                 sqlQueryObject.addFromTable(tabella);
  172.                 sqlQueryObject.addSelectField("*");
  173.                 if(idPortaDelegata!=null || idPortaApplicatva!=null) {
  174.                     sqlQueryObject.addWhereCondition("id_porta=?");
  175.                 }
  176.                 sqlQueryObject.addWhereCondition("tipologia=?");
  177.                 sqlQueryObject.addOrderBy("posizione");
  178.                 
  179.                 sqlQueryObject.setANDLogicOperator(true);
  180.                 String sqlQuery = sqlQueryObject.createSQLQuery();
  181.                 stm1 = con.prepareStatement(sqlQuery);
  182.                 int index = 1;
  183.                 if(idPortaDelegata!=null) {
  184.                     stm1.setLong(index++, idPortaDelegata);
  185.                 }
  186.                 else if(idPortaApplicatva!=null) {
  187.                     stm1.setLong(index++, idPortaApplicatva);
  188.                 }
  189.                 stm1.setString(index++, tipologia);
  190.                 rs1 = stm1.executeQuery();
  191.                 List<ConfigurazioneHandler> list = new ArrayList<ConfigurazioneHandler>();
  192.                 while(rs1.next()){
  193.                     
  194.                     ConfigurazioneHandler handler = new ConfigurazioneHandler();
  195.                     handler.setId(rs1.getLong("id"));
  196.                     handler.setTipo(rs1.getString("tipo"));
  197.                     handler.setPosizione(rs1.getInt("posizione"));
  198.                     String stato = rs1.getString("stato");
  199.                     if(stato!=null && !"".equals(stato)) {
  200.                         handler.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(stato));
  201.                     }
  202.                     list.add(handler);
  203.                     
  204.                 }
  205.                 rs1.close();
  206.                 stm1.close();
  207.                 
  208.                 if(!list.isEmpty()) {
  209.                     if(config==null) {
  210.                         config = new ConfigurazioneServiceHandlers();
  211.                     }
  212.                     if(tipologia.equals(CostantiDB.HANDLER_INIT)) {
  213.                         config.setInitList(list);
  214.                     }
  215.                     else if(tipologia.equals(CostantiDB.HANDLER_EXIT)) {
  216.                         config.setExitList(list);
  217.                     }
  218.                     else if(tipologia.equals(CostantiDB.HANDLER_INTEGRATION_MANAGER_REQUEST)) {
  219.                         config.setIntegrationManagerRequestList(list);
  220.                     }
  221.                     else if(tipologia.equals(CostantiDB.HANDLER_INTEGRATION_MANAGER_RESPONSE)) {
  222.                         config.setIntegrationManagerResponseList(list);
  223.                     }
  224.                 }
  225.             }
  226.             
  227.             return config;
  228.             
  229.         }finally {
  230.             JDBCUtilities.closeResources(rs1, stm1);
  231.         }
  232.     }
  233.     
  234.     static void CRUDConfigurazioneMessageHandlers(int type, Connection con, Long idPortaDelegata, Long idPortaApplicatva, boolean request, ConfigurazioneMessageHandlers config) throws DriverConfigurazioneException {
  235.         
  236.         Long idPorta = null;
  237.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  238.         if(idPortaDelegata!=null) {
  239.             tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  240.             idPorta = idPortaDelegata;
  241.         }
  242.         else if(idPortaApplicatva!=null) {
  243.             tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  244.             idPorta = idPortaApplicatva;
  245.         }
  246.         
  247.         String suffix = request ? CostantiDB.HANDLER_REQUEST_SUFFIX : CostantiDB.HANDLER_RESPONSE_SUFFIX;
  248.                 
  249.         PreparedStatement updateStmt = null;
  250.         try {
  251.             switch (type) {
  252.             case CREATE:
  253.         
  254.                 if(config==null) {
  255.                     break;
  256.                 }
  257.                 
  258.                 createConfigurazioneHandlers(con, config.getPreInList(), tabella, CostantiDB.HANDLER_PRE_IN+suffix, idPorta);
  259.                 createConfigurazioneHandlers(con, config.getInList(), tabella, CostantiDB.HANDLER_IN+suffix, idPorta);
  260.                 if(request) {
  261.                     createConfigurazioneHandlers(con, config.getInProtocolInfoList(), tabella, CostantiDB.HANDLER_IN_PROTOCOL+suffix, idPorta);
  262.                 }
  263.                 createConfigurazioneHandlers(con, config.getOutList(), tabella, CostantiDB.HANDLER_OUT+suffix, idPorta);
  264.                 createConfigurazioneHandlers(con, config.getPostOutList(), tabella, CostantiDB.HANDLER_POST_OUT+suffix, idPorta);

  266.                 break;
  267.                 
  268.             case UPDATE:
  269.                 
  270.                 // Faccio prima delete
  271.                 CRUDConfigurazioneMessageHandlers(DELETE, con, idPortaDelegata, idPortaApplicatva, request, null);
  272.                 
  273.                 // Creo la nuova immagine
  274.                 if(config!=null) {
  275.                     CRUDConfigurazioneMessageHandlers(CREATE, con, idPortaDelegata, idPortaApplicatva, request, config);
  276.                 }
  277.                 break;
  278.                 
  279.             case DELETE:
  280.                 
  281.                 List<String> tipologie = new ArrayList<>();
  282.                 tipologie.add(CostantiDB.HANDLER_PRE_IN+suffix);
  283.                 tipologie.add(CostantiDB.HANDLER_IN+suffix);
  284.                 if(request) {
  285.                     tipologie.add(CostantiDB.HANDLER_IN_PROTOCOL+suffix);
  286.                 }
  287.                 tipologie.add(CostantiDB.HANDLER_OUT+suffix);
  288.                 tipologie.add(CostantiDB.HANDLER_POST_OUT+suffix);
  289.                 
  290.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  291.                 sqlQueryObject.addDeleteTable(tabella);
  292.                 sqlQueryObject.setANDLogicOperator(true);
  293.                 if(idPorta!=null) {
  294.                     sqlQueryObject.addWhereCondition("id_porta=?");
  295.                 }
  296.                 sqlQueryObject.addWhereINCondition("tipologia", true, tipologie.toArray(new String[1]));
  297.                 String updateQuery = sqlQueryObject.createSQLDelete();
  298.                 updateStmt = con.prepareStatement(updateQuery);
  299.                 int index = 1;
  300.                 if(idPorta!=null) {
  301.                     updateStmt.setLong(index++, idPorta);
  302.                 }
  303.                 updateStmt.executeUpdate();
  304.                 updateStmt.close();

  306.                 break;
  307.             }
  308.         
  309.         } catch (SQLException se) {
  310.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneMessageHandlers] SQLException [" + se.getMessage() + "].",se);
  311.         }catch (Exception se) {
  312.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneMessageHandlers] Exception [" + se.getMessage() + "].",se);
  313.         } finally {
  314.     
  315.             JDBCUtilities.closeResources(updateStmt);
  316.             
  317.         }
  318.     }
  319.     
  320.     static void CRUDConfigurazioneServiceHandlers(int type, Connection con, Long idPortaDelegata, Long idPortaApplicatva, boolean request, ConfigurazioneServiceHandlers config) throws DriverConfigurazioneException {
  321.         
  322.         Long idPorta = null;
  323.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  324.         if(idPortaDelegata!=null) {
  325.             tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  326.             idPorta = idPortaDelegata;
  327.         }
  328.         else if(idPortaApplicatva!=null) {
  329.             tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  330.             idPorta = idPortaApplicatva;
  331.         }
  332.         
  333.         @SuppressWarnings("unused")
  334.         String suffix = request ? CostantiDB.HANDLER_REQUEST_SUFFIX : CostantiDB.HANDLER_RESPONSE_SUFFIX;
  335.                 
  336.         PreparedStatement updateStmt = null;
  337.         try {
  338.             switch (type) {
  339.             case CREATE:
  340.         
  341.                 if(config==null) {
  342.                     break;
  343.                 }
  344.                 
  345.                 createConfigurazioneHandlers(con, config.getInitList(), tabella, CostantiDB.HANDLER_INIT, idPorta);
  346.                 createConfigurazioneHandlers(con, config.getExitList(), tabella, CostantiDB.HANDLER_EXIT, idPorta);
  347.                 createConfigurazioneHandlers(con, config.getIntegrationManagerRequestList(), tabella, CostantiDB.HANDLER_INTEGRATION_MANAGER_REQUEST, idPorta);
  348.                 createConfigurazioneHandlers(con, config.getIntegrationManagerResponseList(), tabella, CostantiDB.HANDLER_INTEGRATION_MANAGER_RESPONSE, idPorta);       

  350.                 break;
  351.                 
  352.             case UPDATE:
  353.                 
  354.                 // Faccio prima delete
  355.                 CRUDConfigurazioneServiceHandlers(DELETE, con, idPortaDelegata, idPortaApplicatva, request, null);
  356.                 
  357.                 // Creo la nuova immagine
  358.                 if(config!=null) {
  359.                     CRUDConfigurazioneServiceHandlers(CREATE, con, idPortaDelegata, idPortaApplicatva, request, config);
  360.                 }
  361.                 break;
  362.                 
  363.             case DELETE:
  364.                 
  365.                 List<String> tipologie = new ArrayList<>();
  366.                 tipologie.add(CostantiDB.HANDLER_INIT);
  367.                 tipologie.add(CostantiDB.HANDLER_EXIT);
  368.                 tipologie.add(CostantiDB.HANDLER_INTEGRATION_MANAGER_REQUEST);
  369.                 tipologie.add(CostantiDB.HANDLER_INTEGRATION_MANAGER_RESPONSE);
  370.                 
  371.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  372.                 sqlQueryObject.addDeleteTable(tabella);
  373.                 sqlQueryObject.setANDLogicOperator(true);
  374.                 if(idPorta!=null) {
  375.                     sqlQueryObject.addWhereCondition("id_porta=?");
  376.                 }
  377.                 sqlQueryObject.addWhereINCondition("tipologia", true, tipologie.toArray(new String[1]));
  378.                 String updateQuery = sqlQueryObject.createSQLDelete();
  379.                 updateStmt = con.prepareStatement(updateQuery);
  380.                 int index = 1;
  381.                 if(idPorta!=null) {
  382.                     updateStmt.setLong(index++, idPorta);
  383.                 }
  384.                 updateStmt.executeUpdate();
  385.                 updateStmt.close();

  387.                 break;
  388.             }
  389.         
  390.         } catch (SQLException se) {
  391.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneMessageHandlers] SQLException [" + se.getMessage() + "].",se);
  392.         }catch (Exception se) {
  393.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneMessageHandlers] Exception [" + se.getMessage() + "].",se);
  394.         } finally {
  395.     
  396.             JDBCUtilities.closeResources(updateStmt);
  397.             
  398.         }
  399.     }
  400.     
  401.     private static void createConfigurazioneHandlers(Connection con, List<ConfigurazioneHandler> list, String tabella, String tipologia, Long idPorta) throws Exception {
  402.         if(list!=null && !list.isEmpty()) {
  403.             for (ConfigurazioneHandler handler : list) {
  404.                 PreparedStatement updateStmt = null;
  405.                 try {
  406.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  407.                     sqlQueryObject.addInsertTable(tabella);
  408.                     if(idPorta!=null) {
  409.                         sqlQueryObject.addInsertField("id_porta", "?");
  410.                     }
  411.                     sqlQueryObject.addInsertField("tipologia", "?");
  412.                     sqlQueryObject.addInsertField("tipo", "?");
  413.                     sqlQueryObject.addInsertField("posizione", "?");
  414.                     sqlQueryObject.addInsertField("stato", "?");
  415.                     String updateQuery = sqlQueryObject.createSQLInsert();
  416.                     updateStmt = con.prepareStatement(updateQuery);
  417.                     int index = 1;
  418.                     if(idPorta!=null) {
  419.                         updateStmt.setLong(index++, idPorta);
  420.                     }
  421.                     updateStmt.setString(index++, tipologia);
  422.                     updateStmt.setString(index++, handler.getTipo());
  423.                     updateStmt.setInt(index++, handler.getPosizione());
  424.                     updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(handler.getStato()));
  425.                     updateStmt.executeUpdate();
  426.                     updateStmt.close();
  427.                     updateStmt = null;
  428.                 } finally {
  429.                     JDBCUtilities.closeResources(updateStmt);   
  430.                 }
  431.             }
  432.         }
  433.     }

  435. }
Created with JaCoCo 0.8.8.202204050719