DriverConfigurazioneDB_porteTrasformazioniDriver.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 java.sql.Connection;
  23. import java.sql.PreparedStatement;
  24. import java.sql.ResultSet;
  25. import java.util.ArrayList;
  26. import java.util.List;

  28. import org.openspcoop2.core.commons.DBUtils;
  29. import org.openspcoop2.core.commons.ISearch;
  30. import org.openspcoop2.core.commons.Liste;
  31. import org.openspcoop2.core.config.TrasformazioneRegola;
  32. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaRichiesta;
  33. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaRisposta;
  34. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  35. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
  36. import org.openspcoop2.core.config.TrasformazioneRegolaParametro;
  37. import org.openspcoop2.core.config.TrasformazioneRegolaRichiesta;
  38. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  39. import org.openspcoop2.core.config.TrasformazioneRest;
  40. import org.openspcoop2.core.config.TrasformazioneSoap;
  41. import org.openspcoop2.core.config.TrasformazioneSoapRisposta;
  42. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.constants.CostantiDB;
  45. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  46. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  47. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  48. import org.openspcoop2.utils.sql.ISQLQueryObject;
  49. import org.openspcoop2.utils.sql.SQLObjectFactory;

  51. /**
  52.  * DriverConfigurazioneDB_porteDriver
  53.  * 
  54.  * 
  55.  * @author Sandra Giangrandi (sandra@link.it)
  56.  * @author Stefano Corallo (corallo@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  */
  60. public class DriverConfigurazioneDB_porteTrasformazioniDriver {

  62.     private DriverConfigurazioneDB driver = null;
  63.     
  64.     protected DriverConfigurazioneDB_porteTrasformazioniDriver(DriverConfigurazioneDB driver) {
  65.         this.driver = driver;
  66.     }
  67.     
  68.     protected List<TrasformazioneRegola> porteDelegateTrasformazioniList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  69.         int idLista = Liste.PORTE_DELEGATE_TRASFORMAZIONI;
  70.         String nomeMetodo = "porteDelegateTrasformazioniList";
  71.         boolean delegata = true;
  72.         return getEngineTrasformazioniList(idPA, ricerca, idLista, nomeMetodo, delegata);
  73.     }
  74.     
  75.     protected List<TrasformazioneRegola> porteApplicativeTrasformazioniList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  76.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI;
  77.         String nomeMetodo = "porteApplicativeTrasformazioniList";
  78.         boolean delegata = false;
  79.         return getEngineTrasformazioniList(idPA, ricerca, idLista, nomeMetodo, delegata);
  80.     }
  81.     
  82.     private List<TrasformazioneRegola> getEngineTrasformazioniList(long idPA, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  83.         int offset; 
  84.         int limit;
  85.         String queryString;

  87.         limit = ricerca.getPageSize(idLista);
  88.         offset = ricerca.getIndexIniziale(idLista);

  90.         Connection con = null;
  91.         PreparedStatement stmt = null;
  92.         ResultSet rs = null;
  93.         PreparedStatement stm1 = null;
  94.         ResultSet rs1 = null;
  95.         PreparedStatement stm0 = null;
  96.         ResultSet rs0 = null;
  97.         
  98.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;

  100.         if (this.driver.atomica) {
  101.             try {
  102.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  103.             } catch (Exception e) {
  104.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  106.             }

  108.         } else
  109.             con = this.driver.globalConnection;

  111.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  113.         List<TrasformazioneRegola> lista = new ArrayList<>();
  114.         try {
  115.             
  116.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  117.             sqlQueryObject.addFromTable(nomeTabella);
  118.             sqlQueryObject.addSelectCountField(nomeTabella+".id", "cont");
  119.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  120.             sqlQueryObject.setSelectDistinct(true);
  121.             sqlQueryObject.setANDLogicOperator(true);
  122.             queryString = sqlQueryObject.createSQLQuery();
  123.             stmt = con.prepareStatement(queryString);
  124.             stmt.setLong(1, idPA);

  126.             rs = stmt.executeQuery();
  127.             if (rs.next())
  128.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  129.             rs.close();
  130.             stmt.close();

  132.             // ricavo le entries
  133.             if (limit == 0) // con limit
  134.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  135.             
  136.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  137.             sqlQueryObject.addFromTable(nomeTabella);
  138.             sqlQueryObject.addSelectField("id_porta");
  139.             sqlQueryObject.addSelectField("nome");
  140.             sqlQueryObject.addSelectField("posizione");
  141.             sqlQueryObject.addSelectField("id");
  142.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  143.             sqlQueryObject.setSelectDistinct(true);
  144.             sqlQueryObject.setANDLogicOperator(true);
  145.             sqlQueryObject.addOrderBy(nomeTabella+".posizione");
  146.             sqlQueryObject.addOrderBy(nomeTabella+".nome");
  147.             sqlQueryObject.setSortType(true);
  148.             sqlQueryObject.setLimit(limit);
  149.             sqlQueryObject.setOffset(offset);
  150.             queryString = sqlQueryObject.createSQLQuery();
  151.             stmt = con.prepareStatement(queryString);
  152.             stmt.setLong(1, idPA);

  154.             rs = stmt.executeQuery();

  156.             List<Long> idTrasformazione = new ArrayList<>();            
  157.             while (rs.next()) {
  158.                 
  159.                 idTrasformazione.add(rs.getLong("id"));
  160.                 
  161.             }
  162.             rs.close();
  163.             stmt.close();
  164.             
  165.             if(idTrasformazione!=null && !idTrasformazione.isEmpty()) {
  166.             
  167.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  168.                 sqlQueryObject.addFromTable(nomeTabella);
  169.                 sqlQueryObject.addSelectField("*");
  170.                 sqlQueryObject.setANDLogicOperator(true);
  171.                 sqlQueryObject.addWhereCondition("id = ?");
  172.                 queryString = sqlQueryObject.createSQLQuery();
  173.                 
  174.                 for (Long idLongTrasformazione : idTrasformazione) {
  175.                     
  176.                     stmt = con.prepareStatement(queryString);
  177.                     stmt.setLong(1, idLongTrasformazione);

  179.                     rs = stmt.executeQuery();
  180.                     
  181.                     if (rs.next()) {
  182.                                     
  183.                         TrasformazioneRegola regola = new TrasformazioneRegola();
  184.                         
  185.                         String nome = rs.getString("nome");
  186.                         regola.setNome(nome);
  187.         
  188.                         int posizione = rs.getInt("posizione");
  189.                         regola.setPosizione(posizione);
  190.                         
  191.                         StatoFunzionalita stato = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stato"));
  192.                         regola.setStato(stato);
  193.                         
  194.                         String applicabilita_azioni = rs.getString("applicabilita_azioni");
  195.                         String applicabilita_ct = rs.getString("applicabilita_ct");
  196.                         String applicabilita_pattern = rs.getString("applicabilita_pattern");
  197.                         String applicabilita_connettori = rs.getString("applicabilita_connettori");
  198.                         if( (applicabilita_azioni!=null && !"".equals(applicabilita_azioni)) ||
  199.                                 (applicabilita_ct!=null && !"".equals(applicabilita_ct)) ||
  200.                                 (applicabilita_pattern!=null && !"".equals(applicabilita_pattern))  ||
  201.                                 (applicabilita_connettori!=null && !"".equals(applicabilita_connettori)) 
  202.                                 ) {
  203.                             TrasformazioneRegolaApplicabilitaRichiesta applicabilita = new TrasformazioneRegolaApplicabilitaRichiesta();
  204.                             
  205.                             if( (applicabilita_azioni!=null && !"".equals(applicabilita_azioni)) ) {
  206.                                 if(applicabilita_azioni.contains(",")) {
  207.                                     String [] tmp = applicabilita_azioni.split(",");
  208.                                     for (int i = 0; i < tmp.length; i++) {
  209.                                         applicabilita.addAzione(tmp[i].trim());
  210.                                     }
  211.                                 }
  212.                                 else {
  213.                                     applicabilita.addAzione(applicabilita_azioni);
  214.                                 }
  215.                             }
  216.                             
  217.                             if( (applicabilita_ct!=null && !"".equals(applicabilita_ct)) ) {
  218.                                 if(applicabilita_ct.contains(",")) {
  219.                                     String [] tmp = applicabilita_ct.split(",");
  220.                                     for (int i = 0; i < tmp.length; i++) {
  221.                                         applicabilita.addContentType(tmp[i].trim());
  222.                                     }
  223.                                 }
  224.                                 else {
  225.                                     applicabilita.addContentType(applicabilita_ct);
  226.                                 }
  227.                             }
  228.                             
  229.                             if(applicabilita_pattern!=null && !"".equals(applicabilita_pattern)){
  230.                                 applicabilita.setPattern(applicabilita_pattern);
  231.                             }
  232.                             
  233.                             if( (applicabilita_connettori!=null && !"".equals(applicabilita_connettori)) ) {
  234.                                 if(applicabilita_connettori.contains(",")) {
  235.                                     String [] tmp = applicabilita_connettori.split(",");
  236.                                     for (int i = 0; i < tmp.length; i++) {
  237.                                         applicabilita.addConnettore(tmp[i].trim());
  238.                                     }
  239.                                 }
  240.                                 else {
  241.                                     applicabilita.addConnettore(applicabilita_connettori);
  242.                                 }
  243.                             }
  244.                             
  245.                             regola.setApplicabilita(applicabilita);
  246.                         }
  247.                         
  248.                         TrasformazioneRegolaRichiesta richiesta = new TrasformazioneRegolaRichiesta();
  249.                         
  250.                         int req_conversione_enabled = rs.getInt("req_conversione_enabled");
  251.                         if(CostantiDB.TRUE == req_conversione_enabled) {
  252.                             richiesta.setConversione(true);
  253.                         }
  254.                         else {
  255.                             richiesta.setConversione(false);
  256.                         }
  257.                         richiesta.setConversioneTipo(rs.getString("req_conversione_tipo"));
  258.                         IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  259.                         richiesta.setConversioneTemplate(jdbcAdapter.getBinaryData(rs, "req_conversione_template"));
  260.                         richiesta.setContentType(rs.getString("req_content_type"));
  261.                         
  262.                         int trasformazione_rest = rs.getInt("rest_transformation");
  263.                         if(CostantiDB.TRUE == trasformazione_rest) {
  264.                             TrasformazioneRest trasformazioneRest = new TrasformazioneRest();
  265.                             trasformazioneRest.setMetodo(rs.getString("rest_method"));
  266.                             trasformazioneRest.setPath(rs.getString("rest_path"));
  267.                             richiesta.setTrasformazioneRest(trasformazioneRest);
  268.                         }
  269.                             
  270.                         int trasformazione_soap = rs.getInt("soap_transformation");
  271.                         if(CostantiDB.TRUE == trasformazione_soap) {
  272.                             TrasformazioneSoap trasformazioneSoap = new TrasformazioneSoap();
  273.                             
  274.                             trasformazioneSoap.setVersione(DriverConfigurazioneDBLib.getEnumVersioneSOAP(rs.getString("soap_version")));
  275.                             trasformazioneSoap.setSoapAction(rs.getString("soap_action"));
  276.                             
  277.                             int envelope = rs.getInt("soap_envelope");
  278.                             if(CostantiDB.TRUE == envelope) {
  279.                                 trasformazioneSoap.setEnvelope(true);
  280.                             }
  281.                             else {
  282.                                 trasformazioneSoap.setEnvelope(false);
  283.                             }
  284.                             
  285.                             int envelope_as_attach = rs.getInt("soap_envelope_as_attach");
  286.                             if(CostantiDB.TRUE == envelope_as_attach) {
  287.                                 trasformazioneSoap.setEnvelopeAsAttachment(true);
  288.                                 
  289.                                 trasformazioneSoap.setEnvelopeBodyConversioneTipo(rs.getString("soap_envelope_tipo"));
  290.                                 trasformazioneSoap.setEnvelopeBodyConversioneTemplate(jdbcAdapter.getBinaryData(rs, "soap_envelope_template"));
  291.                             }
  292.                             else {
  293.                                 trasformazioneSoap.setEnvelopeAsAttachment(false);
  294.                             }
  295.                             
  296.                             richiesta.setTrasformazioneSoap(trasformazioneSoap);
  297.                         }
  298.                         
  299.                         
  300.                         regola.setId(rs.getLong("id"));
  301.                         
  302.                         regola.setRichiesta(richiesta);
  303.                         
  304.                         
  305.                         // ** SOGGETTI **
  306.                         
  307.                         if(!portaDelegata) {
  308.                             
  309.                             nomeTabella = CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI;
  310.                             
  311.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  312.                             sqlQueryObject.addFromTable(nomeTabella);
  313.                             sqlQueryObject.addSelectField("*");
  314.                             sqlQueryObject.addWhereCondition("id_trasformazione=?");
  315.                             String sqlQuery = sqlQueryObject.createSQLQuery();
  316.                             stm0 = con.prepareStatement(sqlQuery);
  317.                             stm0.setLong(1, regola.getId());
  318.                             rs0 = stm0.executeQuery();
  319.             
  320.                             while (rs0.next()) {
  321.                                 
  322.                                 if(regola.getApplicabilita()==null) {
  323.                                     regola.setApplicabilita(new TrasformazioneRegolaApplicabilitaRichiesta());
  324.                                 }
  325.                                 
  326.                                 TrasformazioneRegolaApplicabilitaSoggetto soggetto = new TrasformazioneRegolaApplicabilitaSoggetto();
  327.                                 soggetto.setTipo(rs0.getString("tipo_soggetto"));
  328.                                 soggetto.setNome(rs0.getString("nome_soggetto"));
  329.                                 
  330.                                 regola.getApplicabilita().addSoggetto(soggetto);
  331.                             
  332.                             }
  333.                             rs0.close();
  334.                             stm0.close();
  335.                         }
  336.                         
  337.                         
  338.                         // ** APPLICATIVI **
  339.                         
  340.                         nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA;
  341.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  342.                         sqlQueryObject.addFromTable(nomeTabella);
  343.                         sqlQueryObject.addSelectField("*");
  344.                         sqlQueryObject.addWhereCondition("id_trasformazione=?");
  345.                         String sqlQuery = sqlQueryObject.createSQLQuery();
  346.                         stm0 = con.prepareStatement(sqlQuery);
  347.                         stm0.setLong(1, regola.getId());
  348.                         rs0 = stm0.executeQuery();
  349.         
  350.                         // per ogni entry 
  351.                         // prendo l'id del servizio associato, recupero il nome e
  352.                         // aggiungo
  353.                         // il servizio applicativo alla PortaDelegata da ritornare
  354.                         while (rs0.next()) {
  355.                             long idSA = rs0.getLong("id_servizio_applicativo");
  356.         
  357.                             if (idSA != 0) {
  358.                                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  359.                                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  360.                                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  361.                                 sqlQueryObject.addSelectField("nome");
  362.                                 sqlQueryObject.addSelectField("tipo_soggetto");
  363.                                 sqlQueryObject.addSelectField("nome_soggetto");
  364.                                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id=?");
  365.                                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  366.                                 sqlQueryObject.setANDLogicOperator(true);
  367.                                 sqlQuery = sqlQueryObject.createSQLQuery();
  368.                                 stm1 = con.prepareStatement(sqlQuery);
  369.                                 stm1.setLong(1, idSA);
  370.         
  371.                                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idSA));
  372.         
  373.                                 rs1 = stm1.executeQuery();
  374.         
  375.                                 TrasformazioneRegolaApplicabilitaServizioApplicativo servizioApplicativo = null;
  376.                                 if (rs1.next()) {
  377.                                     // setto solo il nome come da specifica
  378.                                     servizioApplicativo = new TrasformazioneRegolaApplicabilitaServizioApplicativo();
  379.                                     servizioApplicativo.setId(idSA);
  380.                                     servizioApplicativo.setNome(rs1.getString("nome"));
  381.                                     servizioApplicativo.setTipoSoggettoProprietario(rs1.getString("tipo_soggetto"));
  382.                                     servizioApplicativo.setNomeSoggettoProprietario(rs1.getString("nome_soggetto"));
  383.                                     if(regola.getApplicabilita()==null) {
  384.                                         regola.setApplicabilita(new TrasformazioneRegolaApplicabilitaRichiesta());
  385.                                     }
  386.                                     regola.getApplicabilita().addServizioApplicativo(servizioApplicativo);
  387.                                 }
  388.                                 rs1.close();
  389.                                 stm1.close();
  390.                             }
  391.                         }
  392.                         rs0.close();
  393.                         stm0.close();
  394.                         
  395.                                         
  396.                         lista.add(regola);

  398.                     }
  399.                     
  400.                     rs.close();
  401.                     stmt.close();
  402.                 }
  403.             }

  405.         } catch (Exception qe) {
  406.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  407.         } finally {

  409.             //Chiudo statement and resultset
  410.             JDBCUtilities.closeResources(rs1, stm1);
  411.             JDBCUtilities.closeResources(rs0, stm0);
  412.             JDBCUtilities.closeResources(rs, stmt);

  414.             this.driver.closeConnection(con);
  415.         }
  416.         
  417.         return lista;
  418.     }
  419.     
  420.     protected boolean azioneUsataInTrasformazioniPortaDelegata(String azione) throws DriverConfigurazioneException {
  421.         return this.azioneUsataInTrasformazioni(azione, true);
  422.     }
  423.     protected boolean azioneUsataInTrasformazioniPortaApplicativa(String azione) throws DriverConfigurazioneException {
  424.         return this.azioneUsataInTrasformazioni(azione, false);
  425.     }
  426.     private boolean azioneUsataInTrasformazioni(String azione, boolean portaDelegata) throws DriverConfigurazioneException {

  428.         String nomeMetodo = "azioneUsataInTrasformazioni";
  429.         
  430.         Connection con = null;
  431.         PreparedStatement stmt = null;
  432.         ResultSet rs = null;

  434.         
  435.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;

  437.         if (this.driver.atomica) {
  438.             try {
  439.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  440.             } catch (Exception e) {
  441.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  443.             }

  445.         } else
  446.             con = this.driver.globalConnection;

  448.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  450.         try {
  451.             
  452.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  453.             sqlQueryObject.addFromTable(nomeTabella);
  454.             sqlQueryObject.addSelectField("applicabilita_azioni");
  455.             sqlQueryObject.addWhereLikeCondition("applicabilita_azioni", azione, false, true, false);
  456.             sqlQueryObject.setANDLogicOperator(true);
  457.             stmt = con.prepareStatement(sqlQueryObject.createSQLQuery());
  458.             rs = stmt.executeQuery();

  460.             while (rs.next()) {
  461.                 
  462.                 String checkAz = rs.getString("applicabilita_azioni");
  463.                 if(checkAz!=null) {
  464.                     if(azione.equals(checkAz)) {
  465.                         return true;
  466.                     }
  467.                     if(checkAz.contains(",")) {
  468.                         String [] tmp = checkAz.split(",");
  469.                         if(tmp!=null && tmp.length>0) {
  470.                             for (int i = 0; i < tmp.length; i++) {
  471.                                 if(azione.equals(tmp[i])) {
  472.                                     return true;
  473.                                 }
  474.                             }
  475.                         }
  476.                     }
  477.                 }

  479.             }

  481.         } catch (Exception qe) {
  482.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  483.         } finally {

  485.             //Chiudo statement and resultset
  486.             JDBCUtilities.closeResources(rs, stmt);

  488.             this.driver.closeConnection(con);
  489.         }
  490.         
  491.         return false;
  492.     }
  493.     
  494.     
  495.     protected TrasformazioneRegola getPortaApplicativaTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
  496.             List<TrasformazioneRegolaApplicabilitaSoggetto> soggetti,
  497.             List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi,
  498.             boolean interpretaNullList) throws DriverConfigurazioneException {
  499.         String nomeMetodo = "getPortaApplicativaTrasformazione";
  500.         boolean delegata = false;
  501.         
  502.         return getEngineTrasformazione(idPorta, azioni, pattern, contentType, connettori, soggetti, applicativi, nomeMetodo, delegata, interpretaNullList);
  503.         
  504.     }
  505.     
  506.     protected TrasformazioneRegola getPortaDelegataTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
  507.             List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi) throws DriverConfigurazioneException {
  508.         String nomeMetodo = "getPortaDelegataTrasformazione";
  509.         boolean delegata = true;
  510.         return getEngineTrasformazione(idPorta, azioni, pattern, contentType, connettori, null, applicativi, nomeMetodo, delegata, 
  511.                 true); // esiste solo una lista
  512.     }
  513.     
  514.     private TrasformazioneRegola getEngineTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
  515.             List<TrasformazioneRegolaApplicabilitaSoggetto> soggetti,
  516.             List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi,
  517.             String nomeMetodo, boolean portaDelegata, boolean interpretaNullList) throws DriverConfigurazioneException {
  518.         Connection con = null;
  519.         PreparedStatement stmt=null;
  520.         ResultSet risultato=null;
  521.         String queryString;
  522.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  523.         String nomeTabellaSoggetti = CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI; //portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SOGGETTI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI;
  524.         String nomeTabellaSA = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA;
  525.         
  526.         if (this.driver.atomica) {
  527.             try {
  528.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  529.             } catch (Exception e) {
  530.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  532.             }

  534.         } else
  535.             con = this.driver.globalConnection;

  537.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  538.         TrasformazioneRegola regola = null;
  539.         try {

  541.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  542.             sqlQueryObject.addFromTable(nomeTabella);
  543.             sqlQueryObject.addSelectField("*");
  544.             sqlQueryObject.setANDLogicOperator(true);
  545.             
  546.             sqlQueryObject.addWhereCondition("id_porta = ?");
  547.             
  548.             if(azioni != null) {
  549.                 //sqlQueryObject.addWhereCondition("applicabilita_azioni = ?");
  550.                 sqlQueryObject.addWhereLikeCondition("applicabilita_azioni", azioni, false, false);
  551.             } else {
  552.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_azioni");
  553.             }
  554.             
  555.             if(pattern != null) {
  556.                 //sqlQueryObject.addWhereCondition("applicabilita_pattern = ?");
  557.                 sqlQueryObject.addWhereLikeCondition("applicabilita_pattern", pattern, false, false);
  558.             } else {
  559.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_pattern");
  560.             }
  561.             
  562.             if(contentType != null) {
  563.                 //sqlQueryObject.addWhereCondition("applicabilita_ct = ?");
  564.                 sqlQueryObject.addWhereLikeCondition("applicabilita_ct", contentType, false, false);
  565.             } else {
  566.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_ct");
  567.             }
  568.             
  569.             if(connettori != null) {
  570.                 //sqlQueryObject.addWhereCondition("applicabilita_connettori = ?");
  571.                 sqlQueryObject.addWhereLikeCondition("applicabilita_connettori", connettori, false, false);
  572.             } else {
  573.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_connettori");
  574.             }
  575.             
  576.             if(!portaDelegata) {
  577.                 if(soggetti==null || soggetti.isEmpty()) {
  578.                     if(interpretaNullList) {
  579.                         ISQLQueryObject sqlQueryObjectExists = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  580.                         sqlQueryObjectExists.addFromTable(nomeTabellaSoggetti);
  581.                         sqlQueryObjectExists.addSelectField("id_trasformazione");
  582.                         sqlQueryObjectExists.setANDLogicOperator(true);
  583.                         sqlQueryObjectExists.addWhereCondition("id_trasformazione="+nomeTabella+".id");
  584.                         sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectExists); 
  585.                     }
  586.                 }
  587.                 else {
  588.                     sqlQueryObject.addFromTable(nomeTabellaSoggetti);
  589.                     sqlQueryObject.addWhereCondition(nomeTabellaSoggetti+".id_trasformazione="+nomeTabella+".id");
  590.                     List<String> conditions = new ArrayList<>();
  591.                     for (@SuppressWarnings("unused") TrasformazioneRegolaApplicabilitaSoggetto trasformazioneRegolaApplicabilitaSoggetto : soggetti) {
  592.                         StringBuilder bf = new StringBuilder();
  593.                         bf.append("( ");
  594.                         bf.append(nomeTabellaSoggetti).append(".tipo_soggetto=?");
  595.                         bf.append(" AND ");
  596.                         bf.append(nomeTabellaSoggetti).append(".nome_soggetto=?");
  597.                         bf.append(") ");
  598.                         conditions.add(bf.toString());
  599.                     }
  600.                     sqlQueryObject.addWhereCondition(false, conditions.toArray(new String[1]));
  601.                 }
  602.             }
  603.             
  604.             if(applicativi==null || applicativi.isEmpty()) {
  605.                 if(interpretaNullList) {
  606.                     ISQLQueryObject sqlQueryObjectExists = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  607.                     sqlQueryObjectExists.addFromTable(nomeTabellaSA);
  608.                     sqlQueryObjectExists.addSelectField("id_trasformazione");
  609.                     sqlQueryObjectExists.setANDLogicOperator(true);
  610.                     sqlQueryObjectExists.addWhereCondition("id_trasformazione="+nomeTabella+".id");
  611.                     sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectExists); 
  612.                 }
  613.             }
  614.             else {
  615.                 sqlQueryObject.addFromTable(nomeTabellaSA);
  616.                 sqlQueryObject.addWhereCondition(nomeTabellaSA+".id_trasformazione="+nomeTabella+".id");
  617.                 List<String> conditions = new ArrayList<>();
  618.                 for (@SuppressWarnings("unused") TrasformazioneRegolaApplicabilitaServizioApplicativo trasformazioneRegolaApplicabilitaSA : applicativi) {
  619.                     StringBuilder bf = new StringBuilder();
  620.                     bf.append("( ");
  621.                     bf.append(nomeTabellaSA).append(".id_servizio_applicativo=?");
  622.                     bf.append(") ");
  623.                     conditions.add(bf.toString());
  624.                 }
  625.                 sqlQueryObject.addWhereCondition(false, conditions.toArray(new String[1]));
  626.             }
  627.             
  628.             queryString = sqlQueryObject.createSQLQuery();
  629.             stmt = con.prepareStatement(queryString);
  630.             int parameterIndex = 1;
  631.             stmt.setLong(parameterIndex ++, idPorta);
  632. //          if(azioni != null)
  633. //              stmt.setString(parameterIndex ++, azioni);
  634. //          if(pattern != null)
  635. //              stmt.setString(parameterIndex ++, pattern);
  636. //          if(contentType != null)
  637. //              stmt.setString(parameterIndex ++, contentType);
  638.             
  639.             if(!portaDelegata) {
  640.                 if(soggetti==null || soggetti.isEmpty()) {
  641.                     // nop;
  642.                 }
  643.                 else {
  644.                     for (TrasformazioneRegolaApplicabilitaSoggetto trasformazioneRegolaApplicabilitaSoggetto : soggetti) {
  645.                         stmt.setString(parameterIndex ++, trasformazioneRegolaApplicabilitaSoggetto.getTipo());
  646.                         stmt.setString(parameterIndex ++, trasformazioneRegolaApplicabilitaSoggetto.getNome());
  647.                     }
  648.                 }
  649.             }
  650.             
  651.             if(applicativi==null || applicativi.isEmpty()) {
  652.                 // nop;
  653.             }
  654.             else {
  655.                 for (TrasformazioneRegolaApplicabilitaServizioApplicativo trasformazioneRegolaApplicabilitaSA : applicativi) {
  656.                     long idSA = DBUtils.getIdServizioApplicativo(trasformazioneRegolaApplicabilitaSA.getNome(), 
  657.                             trasformazioneRegolaApplicabilitaSA.getTipoSoggettoProprietario(), trasformazioneRegolaApplicabilitaSA.getNomeSoggettoProprietario(), con, this.driver.tipoDB);
  658.                     stmt.setLong(parameterIndex ++, idSA);
  659.                 }
  660.             }
  661.             
  662.             risultato = stmt.executeQuery();
  663.             if (risultato.next()) {
  664.                 
  665.                 regola = getEngineTrasformazione(risultato);
  666.             }
  667.             
  668.             risultato.close();
  669.             stmt.close();

  671.             return regola;

  673.         } catch (Exception qe) {
  674.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  675.         } finally {

  677.             //Chiudo statement and resultset
  678.             JDBCUtilities.closeResources(risultato, stmt);

  680.             this.driver.closeConnection(con);
  681.         }
  682.     }
  683.     
  684.     protected TrasformazioneRegola getPortaApplicativaTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
  685.         String nomeMetodo = "getPortaApplicativaTrasformazione";
  686.         boolean delegata = false;
  687.         return getEngineTrasformazione(idPorta, nome, nomeMetodo, delegata);
  688.     }
  689.     
  690.     protected TrasformazioneRegola getPortaDelegataTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
  691.         String nomeMetodo = "getPortaDelegataTrasformazione";
  692.         boolean delegata = true;
  693.         return getEngineTrasformazione(idPorta, nome, nomeMetodo, delegata);
  694.     }
  695.     
  696.     private TrasformazioneRegola getEngineTrasformazione(long idPorta, String nome, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  697.         Connection con = null;
  698.         PreparedStatement stmt=null;
  699.         ResultSet risultato=null;
  700.         String queryString;
  701.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;

  703.         if (this.driver.atomica) {
  704.             try {
  705.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  706.             } catch (Exception e) {
  707.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  709.             }

  711.         } else
  712.             con = this.driver.globalConnection;

  714.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  715.         TrasformazioneRegola regola = null;
  716.         try {

  718.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  719.             sqlQueryObject.addFromTable(nomeTabella);
  720.             sqlQueryObject.addSelectField("*");
  721.             sqlQueryObject.setANDLogicOperator(true);
  722.             
  723.             sqlQueryObject.addWhereCondition("id_porta = ?");
  724.             sqlQueryObject.addWhereCondition("nome = ?");
  725.             
  726.             
  727.             queryString = sqlQueryObject.createSQLQuery();
  728.             stmt = con.prepareStatement(queryString);
  729.             int parameterIndex = 1;
  730.             stmt.setLong(parameterIndex ++, idPorta);
  731.             stmt.setString(parameterIndex ++, nome);
  732.                         
  733.             risultato = stmt.executeQuery();
  734.             if (risultato.next()) {
  735.                 
  736.                 regola = getEngineTrasformazione(risultato);
  737.             }
  738.             
  739.             risultato.close();
  740.             stmt.close();

  742.             return regola;

  744.         } catch (Exception qe) {
  745.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  746.         } finally {

  748.             //Chiudo statement and resultset
  749.             JDBCUtilities.closeResources(risultato, stmt);

  751.             this.driver.closeConnection(con);
  752.         }
  753.     }
  754.     
  755.     private TrasformazioneRegola getEngineTrasformazione(ResultSet risultato) throws Exception {
  756.         TrasformazioneRegola regola  = new TrasformazioneRegola();
  757.                 
  758.         StatoFunzionalita stato = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(risultato.getString("stato"));
  759.         regola.setStato(stato);
  760.         
  761.         String applicabilita_azioni = risultato.getString("applicabilita_azioni");
  762.         String applicabilita_ct = risultato.getString("applicabilita_ct");
  763.         String applicabilita_pattern = risultato.getString("applicabilita_pattern");
  764.         String applicabilita_connettori = risultato.getString("applicabilita_connettori");
  765.         if( (applicabilita_azioni!=null && !"".equals(applicabilita_azioni)) ||
  766.                 (applicabilita_ct!=null && !"".equals(applicabilita_ct)) ||
  767.                 (applicabilita_pattern!=null && !"".equals(applicabilita_pattern))  ||
  768.                 (applicabilita_connettori!=null && !"".equals(applicabilita_connettori)) 
  769.                 ) {
  770.             TrasformazioneRegolaApplicabilitaRichiesta applicabilita = new TrasformazioneRegolaApplicabilitaRichiesta();
  771.             
  772.             if( (applicabilita_azioni!=null && !"".equals(applicabilita_azioni)) ) {
  773.                 if(applicabilita_azioni.contains(",")) {
  774.                     String [] tmp = applicabilita_azioni.split(",");
  775.                     for (int i = 0; i < tmp.length; i++) {
  776.                         applicabilita.addAzione(tmp[i].trim());
  777.                     }
  778.                 }
  779.                 else {
  780.                     applicabilita.addAzione(applicabilita_azioni);
  781.                 }
  782.             }
  783.             
  784.             if( (applicabilita_ct!=null && !"".equals(applicabilita_ct)) ) {
  785.                 if(applicabilita_ct.contains(",")) {
  786.                     String [] tmp = applicabilita_ct.split(",");
  787.                     for (int i = 0; i < tmp.length; i++) {
  788.                         applicabilita.addContentType(tmp[i].trim());
  789.                     }
  790.                 }
  791.                 else {
  792.                     applicabilita.addContentType(applicabilita_ct);
  793.                 }
  794.             }
  795.             
  796.             if(applicabilita_pattern!=null && !"".equals(applicabilita_pattern)){
  797.                 applicabilita.setPattern(applicabilita_pattern);
  798.             }
  799.             
  800.             if( (applicabilita_connettori!=null && !"".equals(applicabilita_connettori)) ) {
  801.                 if(applicabilita_connettori.contains(",")) {
  802.                     String [] tmp = applicabilita_connettori.split(",");
  803.                     for (int i = 0; i < tmp.length; i++) {
  804.                         applicabilita.addConnettore(tmp[i].trim());
  805.                     }
  806.                 }
  807.                 else {
  808.                     applicabilita.addConnettore(applicabilita_connettori);
  809.                 }
  810.             }
  811.             
  812.             regola.setApplicabilita(applicabilita);
  813.         }
  814.         
  815.         TrasformazioneRegolaRichiesta richiesta = new TrasformazioneRegolaRichiesta();
  816.         
  817.         int req_conversione_enabled = risultato.getInt("req_conversione_enabled");
  818.         if(CostantiDB.TRUE == req_conversione_enabled) {
  819.             richiesta.setConversione(true);
  820.         }
  821.         else {
  822.             richiesta.setConversione(false);
  823.         }
  824.         richiesta.setConversioneTipo(risultato.getString("req_conversione_tipo"));
  825.         IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  826.         richiesta.setConversioneTemplate(jdbcAdapter.getBinaryData(risultato, "req_conversione_template"));
  827.         richiesta.setContentType(risultato.getString("req_content_type"));
  828.         
  829.         int trasformazione_rest = risultato.getInt("rest_transformation");
  830.         if(CostantiDB.TRUE == trasformazione_rest) {
  831.             TrasformazioneRest trasformazioneRest = new TrasformazioneRest();
  832.             trasformazioneRest.setMetodo(risultato.getString("rest_method"));
  833.             trasformazioneRest.setPath(risultato.getString("rest_path"));
  834.             richiesta.setTrasformazioneRest(trasformazioneRest);
  835.         }
  836.             
  837.         int trasformazione_soap = risultato.getInt("soap_transformation");
  838.         if(CostantiDB.TRUE == trasformazione_soap) {
  839.             TrasformazioneSoap trasformazioneSoap = new TrasformazioneSoap();
  840.             
  841.             trasformazioneSoap.setVersione(DriverConfigurazioneDBLib.getEnumVersioneSOAP(risultato.getString("soap_version")));
  842.             trasformazioneSoap.setSoapAction(risultato.getString("soap_action"));
  843.             
  844.             int envelope = risultato.getInt("soap_envelope");
  845.             if(CostantiDB.TRUE == envelope) {
  846.                 trasformazioneSoap.setEnvelope(true);
  847.             }
  848.             else {
  849.                 trasformazioneSoap.setEnvelope(false);
  850.             }
  851.             
  852.             int envelope_as_attach = risultato.getInt("soap_envelope_as_attach");
  853.             if(CostantiDB.TRUE == envelope_as_attach) {
  854.                 trasformazioneSoap.setEnvelopeAsAttachment(true);
  855.                 
  856.                 trasformazioneSoap.setEnvelopeBodyConversioneTipo(risultato.getString("soap_envelope_tipo"));
  857.                 trasformazioneSoap.setEnvelopeBodyConversioneTemplate(jdbcAdapter.getBinaryData(risultato, "soap_envelope_template"));
  858.             }
  859.             else {
  860.                 trasformazioneSoap.setEnvelopeAsAttachment(false);
  861.             }
  862.             
  863.             richiesta.setTrasformazioneSoap(trasformazioneSoap);
  864.         }
  865.         
  866.         regola.setId(risultato.getLong("id"));
  867.         
  868.         regola.setRichiesta(richiesta);
  869.         
  870.         return regola;

  872.     }
  873.     
  874.     protected boolean existsPortaApplicativaTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori) throws DriverConfigurazioneException {
  875.         String nomeMetodo = "existsPortaApplicativaTrasformazione";
  876.         boolean delegata = false;
  877.         return _existsTrasformazione(idPorta, azioni, pattern, contentType, connettori, nomeMetodo, delegata);
  878.     }
  879.     
  880.     protected boolean existsPortaDelegataTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori) throws DriverConfigurazioneException {
  881.         String nomeMetodo = "existsPortaDelegataTrasformazione";
  882.         boolean delegata = true;
  883.         return _existsTrasformazione(idPorta, azioni, pattern, contentType, connettori, nomeMetodo, delegata);
  884.     }
  885.     
  886.     private boolean _existsTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  887.         Connection con = null;
  888.         PreparedStatement stmt=null;
  889.         ResultSet risultato=null;
  890.         String queryString;
  891.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;

  893.         if (this.driver.atomica) {
  894.             try {
  895.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  896.             } catch (Exception e) {
  897.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  899.             }

  901.         } else
  902.             con = this.driver.globalConnection;

  904.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  906.         try {

  908.             int count = 0;
  909.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  910.             sqlQueryObject.addFromTable(nomeTabella);
  911.             sqlQueryObject.addSelectCountField(nomeTabella+".id", "cont");
  912.             sqlQueryObject.setANDLogicOperator(true);
  913.             
  914.             sqlQueryObject.addWhereCondition("id_porta = ?");
  915.             
  916.             if(azioni != null) {
  917.                 //sqlQueryObject.addWhereCondition("applicabilita_azioni = ?");
  918.                 sqlQueryObject.addWhereLikeCondition("applicabilita_azioni", azioni, false, false);
  919.             } else {
  920.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_azioni");
  921.             }
  922.             
  923.             if(pattern != null) {
  924.                 //sqlQueryObject.addWhereCondition("applicabilita_pattern = ?");
  925.                 sqlQueryObject.addWhereLikeCondition("applicabilita_pattern", pattern, false, false);
  926.             } else {
  927.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_pattern");
  928.             }
  929.             
  930.             if(contentType != null) {
  931.                 //sqlQueryObject.addWhereCondition("applicabilita_ct = ?");
  932.                 sqlQueryObject.addWhereLikeCondition("applicabilita_ct", contentType, false, false);
  933.             } else {
  934.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_ct");
  935.             }
  936.             
  937.             if(connettori != null) {
  938.                 //sqlQueryObject.addWhereCondition("applicabilita_connettori = ?");
  939.                 sqlQueryObject.addWhereLikeCondition("applicabilita_connettori", connettori, false, false);
  940.             } else {
  941.                 sqlQueryObject.addWhereIsNullCondition("applicabilita_connettori");
  942.             }
  943.             
  944.             queryString = sqlQueryObject.createSQLQuery();
  945.             stmt = con.prepareStatement(queryString);
  946.             int parameterIndex = 1;
  947.             stmt.setLong(parameterIndex ++, idPorta);
  948. //          if(azioni != null)
  949. //              stmt.setString(parameterIndex ++, azioni);
  950. //          if(pattern != null)
  951. //              stmt.setString(parameterIndex ++, pattern);
  952. //          if(contentType != null)
  953. //              stmt.setString(parameterIndex ++, contentType);
  954.             
  955.             risultato = stmt.executeQuery();
  956.             if (risultato.next())
  957.                 count = risultato.getInt(1);
  958.             risultato.close();
  959.             stmt.close();

  961.             return count > 0;

  963.         } catch (Exception qe) {
  964.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  965.         } finally {

  967.             //Chiudo statement and resultset
  968.             JDBCUtilities.closeResources(risultato, stmt);

  970.             this.driver.closeConnection(con);
  971.         }
  972.     }
  973.     
  974.     protected boolean existsPortaApplicativaTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
  975.         String nomeMetodo = "existsPortaApplicativaTrasformazione";
  976.         boolean delegata = false;
  977.         return _existsTrasformazione(idPorta, nome, nomeMetodo, delegata);
  978.     }
  979.     
  980.     protected boolean existsPortaDelegataTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
  981.         String nomeMetodo = "existsPortaDelegataTrasformazione";
  982.         boolean delegata = true;
  983.         return _existsTrasformazione(idPorta, nome, nomeMetodo, delegata);
  984.     }
  985.     
  986.     private boolean _existsTrasformazione(long idPorta, String nome, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  987.         Connection con = null;
  988.         PreparedStatement stmt=null;
  989.         ResultSet risultato=null;
  990.         String queryString;
  991.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;

  993.         if (this.driver.atomica) {
  994.             try {
  995.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  996.             } catch (Exception e) {
  997.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  999.             }

  1001.         } else
  1002.             con = this.driver.globalConnection;

  1004.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  1006.         try {

  1008.             int count = 0;
  1009.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1010.             sqlQueryObject.addFromTable(nomeTabella);
  1011.             sqlQueryObject.addSelectCountField(nomeTabella+".id", "cont");
  1012.             sqlQueryObject.setANDLogicOperator(true);
  1013.             
  1014.             sqlQueryObject.addWhereCondition("id_porta = ?");
  1015.             sqlQueryObject.addWhereCondition("nome = ?");
  1016.                         
  1017.             queryString = sqlQueryObject.createSQLQuery();
  1018.             stmt = con.prepareStatement(queryString);
  1019.             int parameterIndex = 1;
  1020.             stmt.setLong(parameterIndex ++, idPorta);
  1021.             stmt.setString(parameterIndex ++, nome);
  1022.             
  1023.             risultato = stmt.executeQuery();
  1024.             if (risultato.next())
  1025.                 count = risultato.getInt(1);
  1026.             risultato.close();
  1027.             stmt.close();

  1029.             return count > 0;

  1031.         } catch (Exception qe) {
  1032.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1033.         } finally {

  1035.             //Chiudo statement and resultset
  1036.             JDBCUtilities.closeResources(risultato, stmt);

  1038.             this.driver.closeConnection(con);
  1039.         }
  1040.     }
  1041.     
  1042.     
  1043.     protected List<TrasformazioneRegolaRisposta> porteDelegateTrasformazioniRispostaList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1044.         int idLista = Liste.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE;
  1045.         String nomeMetodo = "porteDelegateTrasformazioniRispostaList";
  1046.         boolean delegata = true;
  1047.         return getEngineTrasformazioniRispostaList(idPD, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  1048.     }
  1049.     
  1050.     protected List<TrasformazioneRegolaRisposta> porteApplicativeTrasformazioniRispostaList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1051.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;
  1052.         String nomeMetodo = "porteApplicativeTrasformazioniRispostaList";
  1053.         boolean delegata = false;
  1054.         return getEngineTrasformazioniRispostaList(idPA, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  1055.     }
  1056.     
  1057.     private List<TrasformazioneRegolaRisposta> getEngineTrasformazioniRispostaList(long idPA, long idTrasformazione, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1058.         int offset; 
  1059.         int limit;
  1060.         String queryString;

  1062.         limit = ricerca.getPageSize(idLista);
  1063.         offset = ricerca.getIndexIniziale(idLista);

  1065.         Connection con = null;
  1066.         PreparedStatement stmt = null;
  1067.         ResultSet rs = null;
  1068.         
  1069.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1070.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;

  1072.         if (this.driver.atomica) {
  1073.             try {
  1074.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1075.             } catch (Exception e) {
  1076.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1078.             }

  1080.         } else
  1081.             con = this.driver.globalConnection;

  1083.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  1085.         List<TrasformazioneRegolaRisposta> lista = new ArrayList<>();
  1086.         try {
  1087.             
  1088.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1089.             sqlQueryObject.addFromTable(nomeTabella);
  1090.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1091.             sqlQueryObject.addSelectCountField(nomeTabellaRisposta+".id", "cont");
  1092.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1093.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  1094.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1095.             sqlQueryObject.setSelectDistinct(true);
  1096.             sqlQueryObject.setANDLogicOperator(true);
  1097.             queryString = sqlQueryObject.createSQLQuery();
  1098.             stmt = con.prepareStatement(queryString);
  1099.             stmt.setLong(1, idPA);
  1100.             stmt.setLong(2, idTrasformazione);

  1102.             rs = stmt.executeQuery();
  1103.             if (rs.next())
  1104.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  1105.             rs.close();
  1106.             stmt.close();

  1108.             // ricavo le entries
  1109.             if (limit == 0) // con limit
  1110.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  1111.             
  1112.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1113.             sqlQueryObject.addFromTable(nomeTabella);
  1114.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1115.             sqlQueryObject.addSelectAliasField(nomeTabellaRisposta, "id", "idTrasRisposta");
  1116.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".posizione");
  1117.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".nome");
  1118.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1119.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  1120.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1121.             sqlQueryObject.setSelectDistinct(true);
  1122.             sqlQueryObject.setANDLogicOperator(true);
  1123.             sqlQueryObject.addOrderBy(nomeTabellaRisposta+".posizione");
  1124.             sqlQueryObject.addOrderBy(nomeTabellaRisposta+".nome");
  1125.             sqlQueryObject.setSortType(true);
  1126.             sqlQueryObject.setLimit(limit);
  1127.             sqlQueryObject.setOffset(offset);
  1128.             queryString = sqlQueryObject.createSQLQuery();
  1129.             stmt = con.prepareStatement(queryString);
  1130.             stmt.setLong(1, idPA);
  1131.             stmt.setLong(2, idTrasformazione);

  1133.             rs = stmt.executeQuery();

  1135.             List<Long> idTrasformazioneRisposta = new ArrayList<>();
  1136.             while (rs.next()) { 
  1137.                 idTrasformazioneRisposta.add(rs.getLong("idTrasRisposta"));
  1138.             }
  1139.             rs.close();
  1140.             stmt.close();
  1141.             
  1142.             if(idTrasformazioneRisposta!=null && !idTrasformazioneRisposta.isEmpty()) {
  1143.                 for (Long idLongTrasformazioneRisposta : idTrasformazioneRisposta) {
  1144.                         
  1145.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1146.                     sqlQueryObject.addFromTable(nomeTabella);
  1147.                     sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1148.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".nome");
  1149.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".posizione");
  1150.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_status_min");
  1151.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_status_max");
  1152.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_ct");
  1153.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_pattern");
  1154.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_enabled");
  1155.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_tipo");
  1156.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_template");
  1157.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".content_type");
  1158.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".return_code");
  1159.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope");
  1160.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_as_attach");
  1161.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_tipo");
  1162.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_template");
  1163.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".id");
  1164.                     sqlQueryObject.addSelectField(nomeTabellaRisposta+".id_trasformazione");
  1165.                     sqlQueryObject.addSelectField(nomeTabella+".rest_transformation"); // serve per capire se nella risposta devo abilitare la soap trasformation
  1166.                     sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id=?");
  1167.                     sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1168.                     sqlQueryObject.setANDLogicOperator(true);
  1169.                     queryString = sqlQueryObject.createSQLQuery();
  1170.                     stmt = con.prepareStatement(queryString);
  1171.                     stmt.setLong(1, idLongTrasformazioneRisposta);

  1173.                     rs = stmt.executeQuery();
  1174.                     
  1175.                     if (rs.next()) { 
  1176.                         TrasformazioneRegolaRisposta risposta = _readTrasformazioneRegolaRisposta(rs);
  1177.                         lista.add(risposta);
  1178.                     }
  1179.                     
  1180.                     rs.close();
  1181.                     stmt.close();
  1182.                 }
  1183.             }

  1185.         } catch (Exception qe) {
  1186.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1187.         } finally {

  1189.             //Chiudo statement and resultset
  1190.             JDBCUtilities.closeResources(rs, stmt);

  1192.             this.driver.closeConnection(con);
  1193.         }
  1194.         
  1195.         return lista;
  1196.     } 
  1197.     
  1198.     protected TrasformazioneRegolaRisposta getPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
  1199.         String nomeMetodo = "getPortaApplicativaTrasformazioneRisposta";
  1200.         boolean delegata = false;
  1201.         return getEngineTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType, nomeMetodo, delegata);
  1202.     }
  1203.     
  1204.     protected TrasformazioneRegolaRisposta getPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
  1205.         String nomeMetodo = "getPortaDelegataTrasformazioneRisposta";
  1206.         boolean delegata = true;
  1207.         return getEngineTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType, nomeMetodo, delegata);
  1208.     }
  1209.     
  1210.     private TrasformazioneRegolaRisposta getEngineTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1211.         Connection con = null;
  1212.         PreparedStatement stmt=null;
  1213.         ResultSet rs =null;
  1214.         String queryString;
  1215.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1216.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;
  1217.         
  1218.         if (this.driver.atomica) {
  1219.             try {
  1220.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1221.             } catch (Exception e) {
  1222.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1224.             }

  1226.         } else
  1227.             con = this.driver.globalConnection;

  1229.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  1230.         TrasformazioneRegolaRisposta risposta = null;
  1231.         try {

  1233.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1234.             sqlQueryObject.addFromTable(nomeTabella);
  1235.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1236.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".nome");
  1237.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".posizione");
  1238.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_status_min");
  1239.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_status_max");
  1240.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_ct");
  1241.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_pattern");
  1242.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_enabled");
  1243.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_tipo");
  1244.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_template");
  1245.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".content_type");
  1246.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".return_code");
  1247.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope");
  1248.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_as_attach");
  1249.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_tipo");
  1250.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_template");
  1251.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".id");
  1252.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".id_trasformazione");
  1253.             sqlQueryObject.addSelectField(nomeTabella+".rest_transformation"); // serve per capire se nella risposta devo abilitare la soap trasformation
  1254.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1255.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  1256.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1257.             sqlQueryObject.setANDLogicOperator(true);
  1258.             
  1259.             if(statusMin != null) {
  1260.                 sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".applicabilita_status_min = ?");
  1261.             } else {
  1262.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_status_min");
  1263.             }
  1264.             
  1265.             if(statusMax != null) {
  1266.                 sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".applicabilita_status_max = ?");
  1267.             } else {
  1268.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_status_max");
  1269.             }
  1270.             
  1271.             if(pattern != null) {
  1272.                 sqlQueryObject.addWhereLikeCondition(nomeTabellaRisposta+".applicabilita_pattern", pattern, false, false);
  1273.             } else {
  1274.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_pattern");
  1275.             }
  1276.             
  1277.             if(contentType != null) {
  1278.                 sqlQueryObject.addWhereLikeCondition(nomeTabellaRisposta+".applicabilita_ct", contentType, false, false);
  1279.             } else {
  1280.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_ct");
  1281.             }
  1282.             
  1283.             queryString = sqlQueryObject.createSQLQuery();
  1284.             stmt = con.prepareStatement(queryString);
  1285.             int parameterIndex = 1;
  1286.             stmt.setLong(parameterIndex ++, idPorta);
  1287.             stmt.setLong(parameterIndex ++, idTrasformazione);
  1288.             
  1289.             if(statusMin != null)
  1290.                 stmt.setInt(parameterIndex ++, statusMin);
  1291.             if(statusMax != null)
  1292.                 stmt.setInt(parameterIndex ++, statusMax);
  1293.             
  1294.             rs = stmt.executeQuery();
  1295.             if (rs.next()) {
  1296.                 
  1297.                 risposta = _readTrasformazioneRegolaRisposta(rs);
  1298.             }
  1299.             
  1300.             rs.close();
  1301.             stmt.close();

  1303.             return risposta;

  1305.         } catch (Exception qe) {
  1306.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1307.         } finally {

  1309.             //Chiudo statement and resultset
  1310.             JDBCUtilities.closeResources(rs, stmt);

  1312.             this.driver.closeConnection(con);
  1313.         }
  1314.     }
  1315.     
  1316.     protected TrasformazioneRegolaRisposta getPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
  1317.         String nomeMetodo = "getPortaApplicativaTrasformazioneRisposta";
  1318.         boolean delegata = false;
  1319.         return getEngineTrasformazioneRisposta(idPorta, idTrasformazione, nome, nomeMetodo, delegata);
  1320.     }
  1321.     
  1322.     protected TrasformazioneRegolaRisposta getPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
  1323.         String nomeMetodo = "getPortaDelegataTrasformazioneRisposta";
  1324.         boolean delegata = true;
  1325.         return getEngineTrasformazioneRisposta(idPorta, idTrasformazione, nome, nomeMetodo, delegata);
  1326.     }
  1327.     
  1328.     private TrasformazioneRegolaRisposta getEngineTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1329.         Connection con = null;
  1330.         PreparedStatement stmt=null;
  1331.         ResultSet rs =null;
  1332.         String queryString;
  1333.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1334.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;
  1335.         
  1336.         if (this.driver.atomica) {
  1337.             try {
  1338.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1339.             } catch (Exception e) {
  1340.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1342.             }

  1344.         } else
  1345.             con = this.driver.globalConnection;

  1347.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  1348.         TrasformazioneRegolaRisposta risposta = null;
  1349.         try {

  1351.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1352.             sqlQueryObject.addFromTable(nomeTabella);
  1353.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1354.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".nome");
  1355.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".posizione");
  1356.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_status_min");
  1357.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_status_max");
  1358.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_ct");
  1359.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".applicabilita_pattern");
  1360.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_enabled");
  1361.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_tipo");
  1362.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".conversione_template");
  1363.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".content_type");
  1364.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".return_code");
  1365.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope");
  1366.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_as_attach");
  1367.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_tipo");
  1368.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".soap_envelope_template");
  1369.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".id");
  1370.             sqlQueryObject.addSelectField(nomeTabellaRisposta+".id_trasformazione");
  1371.             sqlQueryObject.addSelectField(nomeTabella+".rest_transformation"); // serve per capire se nella risposta devo abilitare la soap trasformation
  1372.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1373.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  1374.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1375.             sqlQueryObject.setANDLogicOperator(true);
  1376.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".nome = ?");
  1377.             
  1378.             
  1379.             queryString = sqlQueryObject.createSQLQuery();
  1380.             stmt = con.prepareStatement(queryString);
  1381.             int parameterIndex = 1;
  1382.             stmt.setLong(parameterIndex ++, idPorta);
  1383.             stmt.setLong(parameterIndex ++, idTrasformazione);
  1384.             
  1385.             stmt.setString(parameterIndex ++, nome);
  1386.             
  1387.             rs = stmt.executeQuery();
  1388.             if (rs.next()) {
  1389.                 
  1390.                 risposta = _readTrasformazioneRegolaRisposta(rs);
  1391.             }
  1392.             
  1393.             rs.close();
  1394.             stmt.close();

  1396.             return risposta;

  1398.         } catch (Exception qe) {
  1399.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1400.         } finally {

  1402.             //Chiudo statement and resultset
  1403.             JDBCUtilities.closeResources(rs, stmt);

  1405.             this.driver.closeConnection(con);
  1406.         }
  1407.     }
  1408.     
  1409.     private TrasformazioneRegolaRisposta _readTrasformazioneRegolaRisposta(ResultSet rs) throws Exception{
  1410.         TrasformazioneRegolaRisposta risposta = new TrasformazioneRegolaRisposta();
  1411.         
  1412.         String nome = rs.getString("nome");
  1413.         risposta.setNome(nome);

  1415.         int posizione = rs.getInt("posizione");
  1416.         risposta.setPosizione(posizione);
  1417.         
  1418.         int applicabilita_status_min = rs.getInt("applicabilita_status_min");
  1419.         int applicabilita_status_max = rs.getInt("applicabilita_status_max");
  1420.         String applicabilita_ct = rs.getString("applicabilita_ct");
  1421.         String applicabilita_pattern = rs.getString("applicabilita_pattern");
  1422.         if( (applicabilita_status_min >0 || applicabilita_status_max>0) ||
  1423.                 (applicabilita_ct!=null && !"".equals(applicabilita_ct)) ||
  1424.                 (applicabilita_pattern!=null && !"".equals(applicabilita_pattern)) 
  1425.                 ) {
  1426.             TrasformazioneRegolaApplicabilitaRisposta applicabilita = new TrasformazioneRegolaApplicabilitaRisposta();
  1427.             
  1428.             if(applicabilita_status_min>0) {
  1429.                 applicabilita.setReturnCodeMin(applicabilita_status_min);
  1430.             }
  1431.             if(applicabilita_status_max>0) {
  1432.                 applicabilita.setReturnCodeMax(applicabilita_status_max);
  1433.             }

  1435.             if( (applicabilita_ct!=null && !"".equals(applicabilita_ct)) ) {
  1436.                 if(applicabilita_ct.contains(",")) {
  1437.                     String [] tmp = applicabilita_ct.split(",");
  1438.                     for (int i = 0; i < tmp.length; i++) {
  1439.                         applicabilita.addContentType(tmp[i].trim());
  1440.                     }
  1441.                 }
  1442.                 else {
  1443.                     applicabilita.addContentType(applicabilita_ct);
  1444.                 }
  1445.             }
  1446.             
  1447.             if(applicabilita_pattern!=null && !"".equals(applicabilita_pattern)){
  1448.                 applicabilita.setPattern(applicabilita_pattern);
  1449.             }
  1450.             
  1451.             risposta.setApplicabilita(applicabilita);
  1452.         }
  1453.         
  1454.         int conversione_enabled = rs.getInt("conversione_enabled");
  1455.         if(CostantiDB.TRUE == conversione_enabled) {
  1456.             risposta.setConversione(true);
  1457.         }
  1458.         else {
  1459.             risposta.setConversione(false);
  1460.         }
  1461.         risposta.setConversioneTipo(rs.getString("conversione_tipo"));
  1462.         IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  1463.         risposta.setConversioneTemplate(jdbcAdapter.getBinaryData(rs, "conversione_template"));
  1464.         risposta.setContentType(rs.getString("content_type"));
  1465.         risposta.setReturnCode(rs.getString("return_code"));
  1466.         
  1467.         int trasformazione_rest = rs.getInt("rest_transformation");
  1468.         if(CostantiDB.TRUE == trasformazione_rest) {
  1469.         
  1470.             // la risposta deve essere ritornata in SOAP
  1471.             
  1472.             TrasformazioneSoapRisposta trasformazioneSoap = new TrasformazioneSoapRisposta();
  1473.             
  1474.             int envelope = rs.getInt("soap_envelope");
  1475.             if(CostantiDB.TRUE == envelope) {
  1476.                 trasformazioneSoap.setEnvelope(true);
  1477.             }
  1478.             else {
  1479.                 trasformazioneSoap.setEnvelope(false);
  1480.             }
  1481.             
  1482.             int envelope_as_attach = rs.getInt("soap_envelope_as_attach");
  1483.             if(CostantiDB.TRUE == envelope_as_attach) {
  1484.                 trasformazioneSoap.setEnvelopeAsAttachment(true);
  1485.                 
  1486.                 trasformazioneSoap.setEnvelopeBodyConversioneTipo(rs.getString("soap_envelope_tipo"));
  1487.                 trasformazioneSoap.setEnvelopeBodyConversioneTemplate(jdbcAdapter.getBinaryData(rs, "soap_envelope_template"));
  1488.             }
  1489.             else {
  1490.                 trasformazioneSoap.setEnvelopeAsAttachment(false);
  1491.             }
  1492.             
  1493.             risposta.setTrasformazioneSoap(trasformazioneSoap);
  1494.             
  1495.         }

  1497.         risposta.setId(rs.getLong("id"));
  1498.         
  1499.         return  risposta;
  1500.     }
  1501.     
  1502.     protected boolean existsPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
  1503.         String nomeMetodo = "existsPortaApplicativaTrasformazioneRisposta";
  1504.         boolean delegata = false;
  1505.         return _existsTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType, nomeMetodo, delegata);
  1506.     }
  1507.     
  1508.     protected boolean existsPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
  1509.         String nomeMetodo = "existsPortaDelegataTrasformazioneRisposta";
  1510.         boolean delegata = true;
  1511.         return _existsTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType, nomeMetodo, delegata);
  1512.     }
  1513.     
  1514.     private boolean _existsTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1515.         Connection con = null;
  1516.         PreparedStatement stmt=null;
  1517.         ResultSet risultato=null;
  1518.         String queryString;
  1519.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1520.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;

  1522.         if (this.driver.atomica) {
  1523.             try {
  1524.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1525.             } catch (Exception e) {
  1526.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1528.             }

  1530.         } else
  1531.             con = this.driver.globalConnection;

  1533.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  1535.         try {

  1537.             int count = 0;
  1538.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1539.             sqlQueryObject.addFromTable(nomeTabella);
  1540.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1541.             sqlQueryObject.addSelectCountField(nomeTabellaRisposta+".id", "cont");
  1542.             sqlQueryObject.setANDLogicOperator(true);
  1543.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1544.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  1545.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1546.             
  1547.             
  1548.             if(statusMin != null) {
  1549.                 sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".applicabilita_status_min = ?");
  1550.             } else {
  1551.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_status_min");
  1552.             }
  1553.             
  1554.             if(statusMax != null) {
  1555.                 sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".applicabilita_status_max = ?");
  1556.             } else {
  1557.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_status_max");
  1558.             }
  1559.             
  1560.             if(pattern != null) {
  1561.                 //sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".applicabilita_pattern = ?");
  1562.                 sqlQueryObject.addWhereLikeCondition(nomeTabellaRisposta+".applicabilita_pattern", pattern, false, false);
  1563.             } else {
  1564.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_pattern");
  1565.             }
  1566.             
  1567.             if(contentType != null) {
  1568.                 //sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".applicabilita_ct = ?");
  1569.                 sqlQueryObject.addWhereLikeCondition(nomeTabellaRisposta+".applicabilita_ct", contentType, false, false);
  1570.             } else {
  1571.                 sqlQueryObject.addWhereIsNullCondition(nomeTabellaRisposta+".applicabilita_ct");
  1572.             }
  1573.             
  1574.             queryString = sqlQueryObject.createSQLQuery();
  1575.             stmt = con.prepareStatement(queryString);
  1576.             int parameterIndex = 1;
  1577.             stmt.setLong(parameterIndex ++, idPorta);
  1578.             stmt.setLong(parameterIndex ++, idTrasformazione);
  1579.             
  1580.             if(statusMin != null)
  1581.                 stmt.setInt(parameterIndex ++, statusMin);
  1582.             if(statusMax != null)
  1583.                 stmt.setInt(parameterIndex ++, statusMax);
  1584. //          if(pattern != null)
  1585. //              stmt.setString(parameterIndex ++, pattern);
  1586. //          if(contentType != null)
  1587. //              stmt.setString(parameterIndex ++, contentType);
  1588.             
  1589.             risultato = stmt.executeQuery();
  1590.             if (risultato.next())
  1591.                 count = risultato.getInt(1);
  1592.             risultato.close();
  1593.             stmt.close();

  1595.             return count > 0;

  1597.         } catch (Exception qe) {
  1598.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1599.         } finally {

  1601.             //Chiudo statement and resultset
  1602.             JDBCUtilities.closeResources(risultato, stmt);

  1604.             this.driver.closeConnection(con);
  1605.         }
  1606.     }
  1607.     
  1608.     protected boolean existsPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
  1609.         String nomeMetodo = "existsPortaApplicativaTrasformazioneRisposta";
  1610.         boolean delegata = false;
  1611.         return _existsTrasformazioneRisposta(idPorta, idTrasformazione, nome, nomeMetodo, delegata);
  1612.     }
  1613.     
  1614.     protected boolean existsPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
  1615.         String nomeMetodo = "existsPortaDelegataTrasformazioneRisposta";
  1616.         boolean delegata = true;
  1617.         return _existsTrasformazioneRisposta(idPorta, idTrasformazione, nome, nomeMetodo, delegata);
  1618.     }
  1619.     
  1620.     private boolean _existsTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1621.         Connection con = null;
  1622.         PreparedStatement stmt=null;
  1623.         ResultSet risultato=null;
  1624.         String queryString;
  1625.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1626.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;

  1628.         if (this.driver.atomica) {
  1629.             try {
  1630.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1631.             } catch (Exception e) {
  1632.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1634.             }

  1636.         } else
  1637.             con = this.driver.globalConnection;

  1639.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  1641.         try {

  1643.             int count = 0;
  1644.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1645.             sqlQueryObject.addFromTable(nomeTabella);
  1646.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  1647.             sqlQueryObject.addSelectCountField(nomeTabellaRisposta+".id", "cont");
  1648.             sqlQueryObject.setANDLogicOperator(true);
  1649.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1650.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  1651.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  1652.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".nome = ?");
  1653.             
  1654.             
  1655.             queryString = sqlQueryObject.createSQLQuery();
  1656.             stmt = con.prepareStatement(queryString);
  1657.             int parameterIndex = 1;
  1658.             stmt.setLong(parameterIndex ++, idPorta);
  1659.             stmt.setLong(parameterIndex ++, idTrasformazione);
  1660.             
  1661.             stmt.setString(parameterIndex ++, nome);
  1662.             
  1663.             risultato = stmt.executeQuery();
  1664.             if (risultato.next())
  1665.                 count = risultato.getInt(1);
  1666.             risultato.close();
  1667.             stmt.close();

  1669.             return count > 0;

  1671.         } catch (Exception qe) {
  1672.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1673.         } finally {

  1675.             //Chiudo statement and resultset
  1676.             JDBCUtilities.closeResources(risultato, stmt);

  1678.             this.driver.closeConnection(con);
  1679.         }
  1680.     }
  1681.     
  1682.     protected List<TrasformazioneRegolaApplicabilitaServizioApplicativo> porteDelegateTrasformazioniServiziApplicativiList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1683.         int idLista = Liste.PORTE_DELEGATE_TRASFORMAZIONI_SERVIZIO_APPLICATIVO;
  1684.         String nomeMetodo = "porteDelegateTrasformazioniServiziApplicativiList";
  1685.         boolean delegata = true;
  1686.         return getEngineTrasformazioniServiziApplicativiList(idPD, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  1687.     }
  1688.     
  1689.     protected List<TrasformazioneRegolaApplicabilitaServizioApplicativo> porteApplicativeTrasformazioniServiziApplicativiList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1690.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI_SERVIZIO_APPLICATIVO_AUTORIZZATO;
  1691.         String nomeMetodo = "porteApplicativeTrasformazioniServiziApplicativiList";
  1692.         boolean delegata = false;
  1693.         return getEngineTrasformazioniServiziApplicativiList(idPA, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  1694.     }
  1695.     
  1696.     private List<TrasformazioneRegolaApplicabilitaServizioApplicativo> getEngineTrasformazioniServiziApplicativiList(long idPA, long idTrasformazione, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1697.         int offset; 
  1698.         int limit;
  1699.         String queryString;

  1701.         limit = ricerca.getPageSize(idLista);
  1702.         offset = ricerca.getIndexIniziale(idLista);

  1704.         Connection con = null;
  1705.         PreparedStatement stmt = null;
  1706.         ResultSet rs = null;
  1707.         
  1708.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1709.         String nomeTabellaTrasformazioneSA = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA;
  1710.         String nomeTabellaSA = CostantiDB.SERVIZI_APPLICATIVI;
  1711.         String nomeTabellaSoggetti = CostantiDB.SOGGETTI;

  1713.         if (this.driver.atomica) {
  1714.             try {
  1715.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1716.             } catch (Exception e) {
  1717.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1719.             }

  1721.         } else
  1722.             con = this.driver.globalConnection;

  1724.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  1726.         List<TrasformazioneRegolaApplicabilitaServizioApplicativo> lista = new ArrayList<>();
  1727.         try {
  1728.             
  1729.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1730.             sqlQueryObject.addFromTable(nomeTabella);
  1731.             sqlQueryObject.addFromTable(nomeTabellaTrasformazioneSA);
  1732.             sqlQueryObject.addSelectCountField(nomeTabellaTrasformazioneSA+".id", "cont");
  1733.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1734.             sqlQueryObject.addWhereCondition(nomeTabellaTrasformazioneSA+".id_trasformazione=?");
  1735.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaTrasformazioneSA+".id_trasformazione");
  1736.             sqlQueryObject.setSelectDistinct(true);
  1737.             sqlQueryObject.setANDLogicOperator(true);
  1738.             queryString = sqlQueryObject.createSQLQuery();
  1739.             stmt = con.prepareStatement(queryString);
  1740.             stmt.setLong(1, idPA);
  1741.             stmt.setLong(2, idTrasformazione);

  1743.             rs = stmt.executeQuery();
  1744.             if (rs.next())
  1745.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  1746.             rs.close();
  1747.             stmt.close();

  1749.             // ricavo le entries
  1750.             if (limit == 0) // con limit
  1751.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  1752.             
  1753.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1754.             sqlQueryObject.addFromTable(nomeTabella);
  1755.             sqlQueryObject.addFromTable(nomeTabellaTrasformazioneSA);
  1756.             sqlQueryObject.addFromTable(nomeTabellaSA);
  1757.             sqlQueryObject.addFromTable(nomeTabellaSoggetti);
  1758.             sqlQueryObject.addSelectAliasField(nomeTabellaTrasformazioneSA, "id", "idTrasSA");
  1759.             sqlQueryObject.addSelectField(nomeTabellaSA+".nome");
  1760.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1761.             sqlQueryObject.addWhereCondition(nomeTabellaTrasformazioneSA+".id_trasformazione=?");
  1762.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaTrasformazioneSA+".id_trasformazione");
  1763.             sqlQueryObject.addWhereCondition(nomeTabellaSA+".id="+nomeTabellaTrasformazioneSA+".id_servizio_applicativo");
  1764.             sqlQueryObject.addWhereCondition(nomeTabellaSA+".id_soggetto="+nomeTabellaSoggetti+".id");
  1765.             sqlQueryObject.setSelectDistinct(true);
  1766.             sqlQueryObject.setANDLogicOperator(true);
  1767.             sqlQueryObject.addOrderBy(nomeTabellaSA+".nome");
  1768.             sqlQueryObject.setSortType(true);
  1769.             sqlQueryObject.setLimit(limit);
  1770.             sqlQueryObject.setOffset(offset);
  1771.             queryString = sqlQueryObject.createSQLQuery();
  1772.             stmt = con.prepareStatement(queryString);
  1773.             stmt.setLong(1, idPA);
  1774.             stmt.setLong(2, idTrasformazione);

  1776.             rs = stmt.executeQuery();

  1778.             List<Long> idLong = new ArrayList<>();
  1779.             while (rs.next()) { 
  1780.                 idLong.add(rs.getLong("idTrasSA"));
  1781.             }
  1782.             rs.close();
  1783.             stmt.close();
  1784.             
  1785.             if(!idLong.isEmpty()) {
  1786.                 
  1787.                 for (Long idLongTrasf : idLong) {
  1788.                     
  1789.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1790.                     sqlQueryObject.addFromTable(nomeTabella);
  1791.                     sqlQueryObject.addFromTable(nomeTabellaTrasformazioneSA);
  1792.                     sqlQueryObject.addFromTable(nomeTabellaSA);
  1793.                     sqlQueryObject.addFromTable(nomeTabellaSoggetti);
  1794.                     sqlQueryObject.addSelectField(nomeTabellaSA+".nome");
  1795.                     sqlQueryObject.addSelectField(nomeTabellaSoggetti+".tipo_soggetto");
  1796.                     sqlQueryObject.addSelectField(nomeTabellaSoggetti+".nome_soggetto");
  1797.                     sqlQueryObject.addSelectField(nomeTabellaTrasformazioneSA+".id");
  1798.                     sqlQueryObject.addSelectField(nomeTabellaTrasformazioneSA+".id_trasformazione");
  1799.                     sqlQueryObject.addSelectField(nomeTabellaTrasformazioneSA+".id_servizio_applicativo");
  1800.                     sqlQueryObject.addWhereCondition(nomeTabellaTrasformazioneSA+".id=?");
  1801.                     sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaTrasformazioneSA+".id_trasformazione");
  1802.                     sqlQueryObject.addWhereCondition(nomeTabellaSA+".id="+nomeTabellaTrasformazioneSA+".id_servizio_applicativo");
  1803.                     sqlQueryObject.addWhereCondition(nomeTabellaSA+".id_soggetto="+nomeTabellaSoggetti+".id");
  1804.                     sqlQueryObject.setANDLogicOperator(true);
  1805.                     queryString = sqlQueryObject.createSQLQuery();
  1806.                     stmt = con.prepareStatement(queryString);
  1807.                     stmt.setLong(1, idLongTrasf);
  1808.                     
  1809.                     rs = stmt.executeQuery();
  1810.                     if(rs.next()) {
  1811.                         TrasformazioneRegolaApplicabilitaServizioApplicativo risposta = new TrasformazioneRegolaApplicabilitaServizioApplicativo();
  1812.                         risposta.setId(rs.getLong("id"));
  1813.                         risposta.setNome(rs.getString("nome"));
  1814.                         risposta.setTipoSoggettoProprietario(rs.getString("tipo_soggetto"));
  1815.                         risposta.setNomeSoggettoProprietario(rs.getString("nome_soggetto"));
  1816.                         lista.add(risposta);        
  1817.                     }
  1818.                     
  1819.                     rs.close();
  1820.                     stmt.close();
  1821.                     
  1822.                 }
  1823.                 
  1824.             }

  1826.         } catch (Exception qe) {
  1827.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1828.         } finally {

  1830.             //Chiudo statement and resultset
  1831.             JDBCUtilities.closeResources(rs, stmt);

  1833.             this.driver.closeConnection(con);
  1834.         }
  1835.         
  1836.         return lista;
  1837.     } 
  1838.     
  1839.     protected List<TrasformazioneRegolaApplicabilitaSoggetto> porteApplicativeTrasformazioniSoggettiList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1840.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTO;
  1841.         String nomeMetodo = "porteApplicativeTrasformazioniSoggettiList";
  1842.         boolean delegata = false;
  1843.         return getEngineTrasformazioniSoggettiList(idPA, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  1844.     }
  1845.     
  1846.     private List<TrasformazioneRegolaApplicabilitaSoggetto> getEngineTrasformazioniSoggettiList(long idPA, long idTrasformazione, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1847.         int offset; 
  1848.         int limit;
  1849.         String queryString;

  1851.         limit = ricerca.getPageSize(idLista);
  1852.         offset = ricerca.getIndexIniziale(idLista);

  1854.         Connection con = null;
  1855.         PreparedStatement stmt = null;
  1856.         ResultSet rs = null;
  1857.         
  1858.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  1859.         String nomeTabellaSoggetti = CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI;

  1861.         if (this.driver.atomica) {
  1862.             try {
  1863.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1864.             } catch (Exception e) {
  1865.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1867.             }

  1869.         } else
  1870.             con = this.driver.globalConnection;

  1872.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  1874.         List<TrasformazioneRegolaApplicabilitaSoggetto> lista = new ArrayList<>();
  1875.         try {
  1876.             
  1877.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1878.             sqlQueryObject.addFromTable(nomeTabella);
  1879.             sqlQueryObject.addFromTable(nomeTabellaSoggetti);
  1880.             sqlQueryObject.addSelectCountField(nomeTabellaSoggetti+".id", "cont");
  1881.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1882.             sqlQueryObject.addWhereCondition(nomeTabellaSoggetti+".id_trasformazione=?");
  1883.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaSoggetti+".id_trasformazione");
  1884.             sqlQueryObject.setSelectDistinct(true);
  1885.             sqlQueryObject.setANDLogicOperator(true);
  1886.             queryString = sqlQueryObject.createSQLQuery();
  1887.             stmt = con.prepareStatement(queryString);
  1888.             stmt.setLong(1, idPA);
  1889.             stmt.setLong(2, idTrasformazione);

  1891.             rs = stmt.executeQuery();
  1892.             if (rs.next())
  1893.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  1894.             rs.close();
  1895.             stmt.close();

  1897.             // ricavo le entries
  1898.             if (limit == 0) // con limit
  1899.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  1900.             
  1901.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1902.             sqlQueryObject.addFromTable(nomeTabella);
  1903.             sqlQueryObject.addFromTable(nomeTabellaSoggetti);
  1904.             sqlQueryObject.addSelectAliasField(nomeTabellaSoggetti, "id", "idTrasSoggetto");
  1905.             sqlQueryObject.addSelectField(nomeTabellaSoggetti+".tipo_soggetto");
  1906.             sqlQueryObject.addSelectField(nomeTabellaSoggetti+".nome_soggetto");
  1907.             sqlQueryObject.addSelectField(nomeTabellaSoggetti+".id");
  1908.             sqlQueryObject.addSelectField(nomeTabellaSoggetti+".id_trasformazione");
  1909.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  1910.             sqlQueryObject.addWhereCondition(nomeTabellaSoggetti+".id_trasformazione=?");
  1911.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaSoggetti+".id_trasformazione");
  1912.             sqlQueryObject.setSelectDistinct(true);
  1913.             sqlQueryObject.setANDLogicOperator(true);
  1914.             sqlQueryObject.addOrderBy(nomeTabellaSoggetti+".tipo_soggetto");
  1915.             sqlQueryObject.addOrderBy(nomeTabellaSoggetti+".nome_soggetto");
  1916.             sqlQueryObject.setSortType(true);
  1917.             sqlQueryObject.setLimit(limit);
  1918.             sqlQueryObject.setOffset(offset);
  1919.             queryString = sqlQueryObject.createSQLQuery();
  1920.             stmt = con.prepareStatement(queryString);
  1921.             stmt.setLong(1, idPA);
  1922.             stmt.setLong(2, idTrasformazione);

  1924.             rs = stmt.executeQuery();

  1926.             List<Long> idLong = new ArrayList<>();
  1927.             while (rs.next()) { 
  1928.                 idLong.add(rs.getLong("idTrasSoggetto"));
  1929.             }
  1930.             rs.close();
  1931.             stmt.close();
  1932.             
  1933.             if(!idLong.isEmpty()) {
  1934.                 
  1935.                 for (Long idLongTrasf : idLong) {
  1936.                     
  1937.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1938.                     sqlQueryObject.addFromTable(nomeTabella);
  1939.                     sqlQueryObject.addFromTable(nomeTabellaSoggetti);
  1940.                     sqlQueryObject.addSelectField(nomeTabellaSoggetti+".tipo_soggetto");
  1941.                     sqlQueryObject.addSelectField(nomeTabellaSoggetti+".nome_soggetto");
  1942.                     sqlQueryObject.addSelectField(nomeTabellaSoggetti+".id");
  1943.                     sqlQueryObject.addSelectField(nomeTabellaSoggetti+".id_trasformazione");
  1944.                     sqlQueryObject.addWhereCondition(nomeTabellaSoggetti+".id=?");
  1945.                     sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaSoggetti+".id_trasformazione");
  1946.                     sqlQueryObject.setANDLogicOperator(true);
  1947.                     queryString = sqlQueryObject.createSQLQuery();
  1948.                     stmt = con.prepareStatement(queryString);
  1949.                     stmt.setLong(1, idLongTrasf);

  1951.                     rs = stmt.executeQuery();
  1952.                     
  1953.                     if(rs.next()) {
  1954.                         TrasformazioneRegolaApplicabilitaSoggetto risposta = new TrasformazioneRegolaApplicabilitaSoggetto();
  1955.                         risposta.setId(rs.getLong("id"));
  1956.                         risposta.setTipo(rs.getString("tipo_soggetto"));
  1957.                         risposta.setNome(rs.getString("nome_soggetto"));
  1958.                         lista.add(risposta);
  1959.                     }
  1960.                     
  1961.                     rs.close();
  1962.                     stmt.close();
  1963.                     
  1964.                 }
  1965.                 
  1966.             }

  1968.         } catch (Exception qe) {
  1969.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1970.         } finally {

  1972.             //Chiudo statement and resultset
  1973.             JDBCUtilities.closeResources(rs, stmt);

  1975.             this.driver.closeConnection(con);
  1976.         }
  1977.         
  1978.         return lista;
  1979.     } 
  1980.     
  1981.     
  1982.     protected List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRispostaHeaderList(long idPD, long idTrasformazione, long idTrasformazioneRisposta, ISearch ricerca) throws DriverConfigurazioneException {
  1983.         int idLista = Liste.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE_HEADER;
  1984.         String nomeMetodo = "porteDelegateTrasformazioniRispostaHeaderList";
  1985.         boolean delegata = true;
  1986.         return getEngineTrasformazioniRispostaHeaderList(idPD, idTrasformazione, idTrasformazioneRisposta, ricerca, idLista, nomeMetodo, delegata);
  1987.     }
  1988.     
  1989.     protected List<TrasformazioneRegolaParametro> porteApplicativeTrasformazioniRispostaHeaderList(long idPA, long idTrasformazione, long idTrasformazioneRisposta, ISearch ricerca) throws DriverConfigurazioneException {
  1990.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE_HEADER;
  1991.         String nomeMetodo = "porteApplicativeTrasformazioniRispostaHeaderList";
  1992.         boolean delegata = false;
  1993.         return getEngineTrasformazioniRispostaHeaderList(idPA, idTrasformazione, idTrasformazioneRisposta, ricerca, idLista, nomeMetodo, delegata);
  1994.     }
  1995.     
  1996.     private List<TrasformazioneRegolaParametro> getEngineTrasformazioniRispostaHeaderList(long idPA, long idTrasformazione, long idTrasformazioneRisposta, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  1997.         int offset; 
  1998.         int limit;
  1999.         String queryString;

  2001.         limit = ricerca.getPageSize(idLista);
  2002.         offset = ricerca.getIndexIniziale(idLista);

  2004.         Connection con = null;
  2005.         PreparedStatement stmt = null;
  2006.         ResultSet rs = null;
  2007.         
  2008.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2009.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;
  2010.         String nomeTabellaRispostaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE_HEADER : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE_HEADER;

  2012.         if (this.driver.atomica) {
  2013.             try {
  2014.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2015.             } catch (Exception e) {
  2016.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2018.             }

  2020.         } else
  2021.             con = this.driver.globalConnection;

  2023.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  2025.         List<TrasformazioneRegolaParametro> lista = new ArrayList<>();
  2026.         try {
  2027.             
  2028.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2029.             sqlQueryObject.addFromTable(nomeTabella);
  2030.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  2031.             sqlQueryObject.addFromTable(nomeTabellaRispostaHeader);
  2032.             sqlQueryObject.addSelectCountField(nomeTabellaRispostaHeader+".id", "cont");
  2033.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2034.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  2035.             sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".id_transform_risp=?");
  2036.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  2037.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id="+nomeTabellaRispostaHeader+".id_transform_risp");
  2038.             sqlQueryObject.setSelectDistinct(true);
  2039.             sqlQueryObject.setANDLogicOperator(true);
  2040.             queryString = sqlQueryObject.createSQLQuery();
  2041.             stmt = con.prepareStatement(queryString);
  2042.             stmt.setLong(1, idPA);
  2043.             stmt.setLong(2, idTrasformazione);
  2044.             stmt.setLong(3, idTrasformazioneRisposta);

  2046.             rs = stmt.executeQuery();
  2047.             if (rs.next())
  2048.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  2049.             rs.close();
  2050.             stmt.close();

  2052.             // ricavo le entries
  2053.             if (limit == 0) // con limit
  2054.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  2055.             
  2056.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2057.             sqlQueryObject.addFromTable(nomeTabella);
  2058.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  2059.             sqlQueryObject.addFromTable(nomeTabellaRispostaHeader);
  2060.             sqlQueryObject.addSelectAliasField(nomeTabellaRispostaHeader, "id", "idTrasParametro");
  2061.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".tipo");
  2062.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".nome");
  2063.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".id");
  2064.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".id_transform_risp");
  2065.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2066.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  2067.             sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".id_transform_risp=?");
  2068.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  2069.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id="+nomeTabellaRispostaHeader+".id_transform_risp");
  2070.             sqlQueryObject.setSelectDistinct(true);
  2071.             sqlQueryObject.setANDLogicOperator(true);
  2072.             sqlQueryObject.addOrderBy(nomeTabellaRispostaHeader+".nome");
  2073.             sqlQueryObject.setSortType(true);
  2074.             sqlQueryObject.setLimit(limit);
  2075.             sqlQueryObject.setOffset(offset);
  2076.             queryString = sqlQueryObject.createSQLQuery();
  2077.             stmt = con.prepareStatement(queryString);
  2078.             stmt.setLong(1, idPA);
  2079.             stmt.setLong(2, idTrasformazione);
  2080.             stmt.setLong(3, idTrasformazioneRisposta);

  2082.             rs = stmt.executeQuery();

  2084.             List<Long> idLong = new ArrayList<>();
  2085.             while (rs.next()) { 
  2086.                 idLong.add(rs.getLong("idTrasParametro"));
  2087.             }
  2088.             rs.close();
  2089.             stmt.close();
  2090.             
  2091.             if(!idLong.isEmpty()) {
  2092.                 
  2093.                 for (Long idLongTrasf : idLong) {
  2094.                     
  2095.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2096.                     sqlQueryObject.addFromTable(nomeTabella);
  2097.                     sqlQueryObject.addFromTable(nomeTabellaRisposta);
  2098.                     sqlQueryObject.addFromTable(nomeTabellaRispostaHeader);
  2099.                     sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".tipo");
  2100.                     sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".nome");
  2101.                     sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".valore");
  2102.                     sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".identificazione_fallita");
  2103.                     sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".id");
  2104.                     sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".id_transform_risp");
  2105.                     sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".id=?");
  2106.                     sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  2107.                     sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id="+nomeTabellaRispostaHeader+".id_transform_risp");
  2108.                     sqlQueryObject.setANDLogicOperator(true);
  2109.                     queryString = sqlQueryObject.createSQLQuery();
  2110.                     stmt = con.prepareStatement(queryString);
  2111.                     stmt.setLong(1, idLongTrasf);

  2113.                     rs = stmt.executeQuery();

  2115.                     if(rs.next()) {
  2116.                         
  2117.                         TrasformazioneRegolaParametro parametro = new TrasformazioneRegolaParametro();
  2118.                         parametro.setConversioneTipo(DriverConfigurazioneDBLib.getEnumTrasformazioneRegolaParametroTipoAzione(rs.getString("tipo")));
  2119.                         parametro.setNome(rs.getString("nome"));
  2120.                         parametro.setValore(rs.getString("valore"));
  2121.                         parametro.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumTrasformazioneIdentificazioneRisorsaFallita(rs.getString("identificazione_fallita")));
  2122.                         parametro.setId(rs.getLong("id"));
  2123.                         lista.add(parametro);
  2124.                         
  2125.                     }
  2126.                     
  2127.                     rs.close();
  2128.                     stmt.close();
  2129.                     
  2130.                 }
  2131.                 
  2132.             }

  2134.         } catch (Exception qe) {
  2135.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2136.         } finally {

  2138.             //Chiudo statement and resultset
  2139.             JDBCUtilities.closeResources(rs, stmt);

  2141.             this.driver.closeConnection(con);
  2142.         }
  2143.         
  2144.         return lista;
  2145.     } 
  2146.     
  2147.     protected boolean existsPortaApplicativaTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2148.         String nomeMetodo = "existsPortaApplicativaTrasformazioneRispostaHeader";
  2149.         boolean delegata = false;
  2150.         return _existsTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo, nomeMetodo, delegata);
  2151.     }
  2152.     
  2153.     protected boolean existsPortaDelegataTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2154.         String nomeMetodo = "existsPortaDelegataTrasformazioneRispostaHeader";
  2155.         boolean delegata = true;
  2156.         return _existsTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo, nomeMetodo, delegata);
  2157.     }
  2158.     
  2159.     private boolean _existsTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2160.         Connection con = null;
  2161.         PreparedStatement stmt=null;
  2162.         ResultSet risultato=null;
  2163.         String queryString;
  2164.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2165.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;
  2166.         String nomeTabellaRispostaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE_HEADER : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE_HEADER;

  2168.         if (this.driver.atomica) {
  2169.             try {
  2170.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2171.             } catch (Exception e) {
  2172.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2174.             }

  2176.         } else
  2177.             con = this.driver.globalConnection;

  2179.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  2181.         try {

  2183.             int count = 0;
  2184.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2185.             sqlQueryObject.addFromTable(nomeTabella);
  2186.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  2187.             sqlQueryObject.addFromTable(nomeTabellaRispostaHeader);
  2188.             sqlQueryObject.addSelectCountField(nomeTabellaRispostaHeader+".id", "cont");
  2189.             sqlQueryObject.setANDLogicOperator(true);
  2190.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2191.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  2192.             sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".id_transform_risp=?");
  2193.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  2194.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id="+nomeTabellaRispostaHeader+".id_transform_risp");
  2195.             sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".nome = ?");
  2196.             if(checkTipo) {
  2197.                 sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".tipo = ?");
  2198.             }
  2199.             
  2200.             queryString = sqlQueryObject.createSQLQuery();
  2201.             stmt = con.prepareStatement(queryString);
  2202.             int parameterIndex = 1;
  2203.             stmt.setLong(parameterIndex ++, idPorta);
  2204.             stmt.setLong(parameterIndex ++, idTrasformazione);
  2205.             stmt.setLong(parameterIndex ++, idTrasformazioneRisposta);
  2206.             stmt.setString(parameterIndex ++, nome);
  2207.             if(checkTipo) {
  2208.                 stmt.setString(parameterIndex ++, tipo);
  2209.             }
  2210.             
  2211.             risultato = stmt.executeQuery();
  2212.             if (risultato.next())
  2213.                 count = risultato.getInt(1);
  2214.             risultato.close();
  2215.             stmt.close();

  2217.             return count > 0;

  2219.         } catch (Exception qe) {
  2220.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2221.         } finally {

  2223.             //Chiudo statement and resultset
  2224.             JDBCUtilities.closeResources(risultato, stmt);

  2226.             this.driver.closeConnection(con);
  2227.         }
  2228.     }
  2229.     
  2230.     protected TrasformazioneRegolaParametro getPortaApplicativaTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2231.         String nomeMetodo = "getPortaApplicativaTrasformazioneRispostaHeader";
  2232.         boolean delegata = false;
  2233.         return getEngineTrasformazioneRispostaHeader(idPorta, idTrasformazione,  idTrasformazioneRisposta, nome, tipo, checkTipo, nomeMetodo, delegata);
  2234.     }
  2235.     
  2236.     protected TrasformazioneRegolaParametro getPortaDelegataTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2237.         String nomeMetodo = "getPortaDelegataTrasformazioneRispostaHeader";
  2238.         boolean delegata = true;
  2239.         return getEngineTrasformazioneRispostaHeader(idPorta, idTrasformazione,  idTrasformazioneRisposta, nome, tipo, checkTipo, nomeMetodo, delegata);
  2240.     }
  2241.     
  2242.     private TrasformazioneRegolaParametro getEngineTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2243.         Connection con = null;
  2244.         PreparedStatement stmt=null;
  2245.         ResultSet rs =null;
  2246.         String queryString;
  2247.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2248.         String nomeTabellaRisposta = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE;
  2249.         String nomeTabellaRispostaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_RISPOSTE_HEADER : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTE_HEADER;
  2250.         
  2251.         if (this.driver.atomica) {
  2252.             try {
  2253.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2254.             } catch (Exception e) {
  2255.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2257.             }

  2259.         } else
  2260.             con = this.driver.globalConnection;

  2262.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  2263.         TrasformazioneRegolaParametro parametro = null;
  2264.         try {

  2266.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2267.             sqlQueryObject.addFromTable(nomeTabella);
  2268.             sqlQueryObject.addFromTable(nomeTabellaRisposta);
  2269.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".nome");
  2270.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".valore");
  2271.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".tipo");
  2272.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".identificazione_fallita");
  2273.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".id");
  2274.             sqlQueryObject.addSelectField(nomeTabellaRispostaHeader+".id_transform_risp");
  2275.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2276.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id_trasformazione=?");
  2277.             sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".id_transform_risp=?");
  2278.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRisposta+".id_trasformazione");
  2279.             sqlQueryObject.addWhereCondition(nomeTabellaRisposta+".id="+nomeTabellaRispostaHeader+".id_transform_risp");
  2280.             sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".nome = ?");
  2281.             if(checkTipo) {
  2282.                 sqlQueryObject.addWhereCondition(nomeTabellaRispostaHeader+".tipo = ?");
  2283.             }
  2284.             sqlQueryObject.setANDLogicOperator(true);

  2286.             queryString = sqlQueryObject.createSQLQuery();
  2287.             stmt = con.prepareStatement(queryString);
  2288.             int parameterIndex = 1;
  2289.             stmt.setLong(parameterIndex ++, idPorta);
  2290.             stmt.setLong(parameterIndex ++, idTrasformazione);
  2291.             stmt.setLong(parameterIndex ++, idTrasformazioneRisposta);
  2292.             stmt.setString(parameterIndex ++, nome);
  2293.             if(checkTipo) {
  2294.                 stmt.setString(parameterIndex ++, tipo);
  2295.             }
  2296.             
  2297.             rs = stmt.executeQuery();
  2298.             if (rs.next()) {
  2299.                 parametro = new TrasformazioneRegolaParametro();
  2300.                 parametro.setConversioneTipo(DriverConfigurazioneDBLib.getEnumTrasformazioneRegolaParametroTipoAzione(rs.getString("tipo")));
  2301.                 parametro.setNome(rs.getString("nome"));
  2302.                 parametro.setValore(rs.getString("valore"));
  2303.                 parametro.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumTrasformazioneIdentificazioneRisorsaFallita(rs.getString("identificazione_fallita")));
  2304.                 parametro.setId(rs.getLong("id"));
  2305.             }
  2306.             
  2307.             rs.close();
  2308.             stmt.close();

  2310.             return parametro;

  2312.         } catch (Exception qe) {
  2313.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2314.         } finally {

  2316.             //Chiudo statement and resultset
  2317.             JDBCUtilities.closeResources(rs, stmt);

  2319.             this.driver.closeConnection(con);
  2320.         }
  2321.     }
  2322.     
  2323.     protected List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRichiestaHeaderList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  2324.         int idLista = Liste.PORTE_DELEGATE_TRASFORMAZIONI_RICHIESTA_HEADER;
  2325.         String nomeMetodo = "porteDelegateTrasformazioniRichiestaHeaderList";
  2326.         boolean delegata = true;
  2327.         return getEngineTrasformazioniRichiestaHeaderList(idPD, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  2328.     }
  2329.     
  2330.     protected List<TrasformazioneRegolaParametro> porteApplicativeTrasformazioniRichiestaHeaderList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  2331.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI_RICHIESTA_HEADER;
  2332.         String nomeMetodo = "porteApplicativeTrasformazioniRichiestaHeaderList";
  2333.         boolean delegata = false;
  2334.         return getEngineTrasformazioniRichiestaHeaderList(idPA, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  2335.     }
  2336.     
  2337.     private List<TrasformazioneRegolaParametro> getEngineTrasformazioniRichiestaHeaderList(long idPA, long idTrasformazione, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2338.         int offset; 
  2339.         int limit;
  2340.         String queryString;

  2342.         limit = ricerca.getPageSize(idLista);
  2343.         offset = ricerca.getIndexIniziale(idLista);

  2345.         Connection con = null;
  2346.         PreparedStatement stmt = null;
  2347.         ResultSet rs = null;
  2348.         
  2349.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2350.         String nomeTabellaRichiestaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_HEADER : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_HEADER;

  2352.         if (this.driver.atomica) {
  2353.             try {
  2354.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2355.             } catch (Exception e) {
  2356.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2358.             }

  2360.         } else
  2361.             con = this.driver.globalConnection;

  2363.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  2365.         List<TrasformazioneRegolaParametro> lista = new ArrayList<>();
  2366.         try {
  2367.             
  2368.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2369.             sqlQueryObject.addFromTable(nomeTabella);
  2370.             sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2371.             sqlQueryObject.addSelectCountField(nomeTabellaRichiestaHeader+".id", "cont");
  2372.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2373.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2374.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2375.             sqlQueryObject.setSelectDistinct(true);
  2376.             sqlQueryObject.setANDLogicOperator(true);
  2377.             queryString = sqlQueryObject.createSQLQuery();
  2378.             stmt = con.prepareStatement(queryString);
  2379.             stmt.setLong(1, idPA);
  2380.             stmt.setLong(2, idTrasformazione);

  2382.             rs = stmt.executeQuery();
  2383.             if (rs.next())
  2384.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  2385.             rs.close();
  2386.             stmt.close();

  2388.             // ricavo le entries
  2389.             if (limit == 0) // con limit
  2390.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  2391.             
  2392.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2393.             sqlQueryObject.addFromTable(nomeTabella);
  2394.             sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2395.             sqlQueryObject.addSelectAliasField(nomeTabellaRichiestaHeader, "id", "idTrasParametro");
  2396.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".tipo");
  2397.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".nome");
  2398.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id");
  2399.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id_trasformazione");
  2400.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2401.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2402.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2403.             sqlQueryObject.setSelectDistinct(true);
  2404.             sqlQueryObject.setANDLogicOperator(true);
  2405.             sqlQueryObject.addOrderBy(nomeTabellaRichiestaHeader+".nome");
  2406.             sqlQueryObject.setSortType(true);
  2407.             sqlQueryObject.setLimit(limit);
  2408.             sqlQueryObject.setOffset(offset);
  2409.             queryString = sqlQueryObject.createSQLQuery();
  2410.             stmt = con.prepareStatement(queryString);
  2411.             stmt.setLong(1, idPA);
  2412.             stmt.setLong(2, idTrasformazione);

  2414.             rs = stmt.executeQuery();

  2416.             List<Long> idLong = new ArrayList<>();
  2417.             while (rs.next()) { 
  2418.                 idLong.add(rs.getLong("idTrasParametro"));
  2419.             }
  2420.             rs.close();
  2421.             stmt.close();
  2422.             
  2423.             if(!idLong.isEmpty()) {
  2424.                 
  2425.                 for (Long idLongTrasf : idLong) {
  2426.                     
  2427.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2428.                     sqlQueryObject.addFromTable(nomeTabella);
  2429.                     sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2430.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".tipo");
  2431.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".nome");
  2432.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".valore");
  2433.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".identificazione_fallita");
  2434.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id");
  2435.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id_trasformazione");
  2436.                     sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id=?");
  2437.                     sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2438.                     sqlQueryObject.setANDLogicOperator(true);
  2439.                     queryString = sqlQueryObject.createSQLQuery();
  2440.                     stmt = con.prepareStatement(queryString);
  2441.                     stmt.setLong(1, idLongTrasf);

  2443.                     rs = stmt.executeQuery();
  2444.                     
  2445.                     if(rs.next()) {
  2446.                         
  2447.                         TrasformazioneRegolaParametro parametro = new TrasformazioneRegolaParametro();
  2448.                         parametro.setConversioneTipo(DriverConfigurazioneDBLib.getEnumTrasformazioneRegolaParametroTipoAzione(rs.getString("tipo")));
  2449.                         parametro.setNome(rs.getString("nome"));
  2450.                         parametro.setValore(rs.getString("valore"));
  2451.                         parametro.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumTrasformazioneIdentificazioneRisorsaFallita(rs.getString("identificazione_fallita")));
  2452.                         parametro.setId(rs.getLong("id"));
  2453.                         lista.add(parametro);
  2454.                         
  2455.                     }
  2456.                     
  2457.                     rs.close();
  2458.                     stmt.close();
  2459.                     
  2460.                 }
  2461.                 
  2462.             }
  2463.             

  2465.         } catch (Exception qe) {
  2466.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2467.         } finally {

  2469.             //Chiudo statement and resultset
  2470.             JDBCUtilities.closeResources(rs, stmt);

  2472.             this.driver.closeConnection(con);
  2473.         }
  2474.         
  2475.         return lista;
  2476.     } 
  2477.     
  2478.     protected boolean existsPortaApplicativaTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2479.         String nomeMetodo = "existsPortaApplicativaTrasformazioneRichiestaHeader";
  2480.         boolean delegata = false;
  2481.         return _existsTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2482.     }
  2483.     
  2484.     protected boolean existsPortaDelegataTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2485.         String nomeMetodo = "existsPortaDelegataTrasformazioneRichiestaHeader";
  2486.         boolean delegata = true;
  2487.         return _existsTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2488.     }
  2489.     
  2490.     private boolean _existsTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2491.         Connection con = null;
  2492.         PreparedStatement stmt=null;
  2493.         ResultSet risultato=null;
  2494.         String queryString;
  2495.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2496.         String nomeTabellaRichiestaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_HEADER : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_HEADER;

  2498.         if (this.driver.atomica) {
  2499.             try {
  2500.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2501.             } catch (Exception e) {
  2502.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2504.             }

  2506.         } else
  2507.             con = this.driver.globalConnection;

  2509.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  2511.         try {

  2513.             int count = 0;
  2514.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2515.             sqlQueryObject.addFromTable(nomeTabella);
  2516.             sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2517.             sqlQueryObject.addSelectCountField(nomeTabellaRichiestaHeader+".id", "cont");
  2518.             sqlQueryObject.setANDLogicOperator(true);
  2519.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2520.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2521.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2522.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".nome = ?");
  2523.             if(checkTipo) {
  2524.                 sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".tipo = ?");
  2525.             }
  2526.             
  2527.             queryString = sqlQueryObject.createSQLQuery();
  2528.             stmt = con.prepareStatement(queryString);
  2529.             int parameterIndex = 1;
  2530.             stmt.setLong(parameterIndex ++, idPorta);
  2531.             stmt.setLong(parameterIndex ++, idTrasformazione);
  2532.             stmt.setString(parameterIndex ++, nome);
  2533.             if(checkTipo) {
  2534.                 stmt.setString(parameterIndex ++, tipo);
  2535.             }
  2536.             
  2537.             risultato = stmt.executeQuery();
  2538.             if (risultato.next())
  2539.                 count = risultato.getInt(1);
  2540.             risultato.close();
  2541.             stmt.close();

  2543.             return count > 0;

  2545.         } catch (Exception qe) {
  2546.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2547.         } finally {

  2549.             //Chiudo statement and resultset
  2550.             JDBCUtilities.closeResources(risultato, stmt);

  2552.             this.driver.closeConnection(con);
  2553.         }
  2554.     }
  2555.     
  2556.     protected TrasformazioneRegolaParametro getPortaApplicativaTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2557.         String nomeMetodo = "getPortaApplicativaTrasformazioneRichiestaHeader";
  2558.         boolean delegata = false;
  2559.         return getEngineTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2560.     }
  2561.     
  2562.     protected TrasformazioneRegolaParametro getPortaDelegataTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2563.         String nomeMetodo = "getPortaDelegataTrasformazioneRichiestaHeader";
  2564.         boolean delegata = true;
  2565.         return getEngineTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2566.     }
  2567.     
  2568.     private TrasformazioneRegolaParametro getEngineTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2569.         Connection con = null;
  2570.         PreparedStatement stmt=null;
  2571.         ResultSet rs =null;
  2572.         String queryString;
  2573.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2574.         String nomeTabellaRichiestaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_HEADER : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_HEADER;
  2575.         
  2576.         if (this.driver.atomica) {
  2577.             try {
  2578.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2579.             } catch (Exception e) {
  2580.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2582.             }

  2584.         } else
  2585.             con = this.driver.globalConnection;

  2587.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  2588.         TrasformazioneRegolaParametro parametro = null;
  2589.         try {

  2591.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2592.             sqlQueryObject.addFromTable(nomeTabella);
  2593.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".nome");
  2594.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".valore");
  2595.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".tipo");
  2596.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".identificazione_fallita");
  2597.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id");
  2598.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id_trasformazione");
  2599.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2600.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2601.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2602.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".nome = ?");
  2603.             if(checkTipo) {
  2604.                 sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".tipo = ?");
  2605.             }
  2606.             sqlQueryObject.setANDLogicOperator(true);

  2608.             queryString = sqlQueryObject.createSQLQuery();
  2609.             stmt = con.prepareStatement(queryString);
  2610.             int parameterIndex = 1;
  2611.             stmt.setLong(parameterIndex ++, idPorta);
  2612.             stmt.setLong(parameterIndex ++, idTrasformazione);
  2613.             stmt.setString(parameterIndex ++, nome);
  2614.             if(checkTipo) {
  2615.                 stmt.setString(parameterIndex ++, tipo);
  2616.             }
  2617.             
  2618.             rs = stmt.executeQuery();
  2619.             if (rs.next()) {
  2620.                 parametro = new TrasformazioneRegolaParametro();
  2621.                 parametro.setConversioneTipo(DriverConfigurazioneDBLib.getEnumTrasformazioneRegolaParametroTipoAzione(rs.getString("tipo")));
  2622.                 parametro.setNome(rs.getString("nome"));
  2623.                 parametro.setValore(rs.getString("valore"));
  2624.                 parametro.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumTrasformazioneIdentificazioneRisorsaFallita(rs.getString("identificazione_fallita")));
  2625.                 parametro.setId(rs.getLong("id"));
  2626.             }
  2627.             
  2628.             rs.close();
  2629.             stmt.close();

  2631.             return parametro;

  2633.         } catch (Exception qe) {
  2634.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2635.         } finally {

  2637.             //Chiudo statement and resultset
  2638.             JDBCUtilities.closeResources(rs, stmt);

  2640.             this.driver.closeConnection(con);
  2641.         }
  2642.     }
  2643.     
  2644.     protected List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRichiestaUrlParameterList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  2645.         int idLista = Liste.PORTE_DELEGATE_TRASFORMAZIONI_RICHIESTA_PARAMETRI;
  2646.         String nomeMetodo = "porteDelegateTrasformazioniRichiestaUrlParameterList";
  2647.         boolean delegata = true;
  2648.         return getEngineTrasformazioniRichiestaUrlParameterList(idPD, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  2649.     }
  2650.     
  2651.     protected List<TrasformazioneRegolaParametro> porteApplicativeTrasformazioniRichiestaUrlParameterList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  2652.         int idLista = Liste.PORTE_APPLICATIVE_TRASFORMAZIONI_RICHIESTA_PARAMETRI;
  2653.         String nomeMetodo = "porteApplicativeTrasformazioniRichiestaUrlParameterList";
  2654.         boolean delegata = false;
  2655.         return getEngineTrasformazioniRichiestaUrlParameterList(idPA, idTrasformazione, ricerca, idLista, nomeMetodo, delegata);
  2656.     }
  2657.     
  2658.     private List<TrasformazioneRegolaParametro> getEngineTrasformazioniRichiestaUrlParameterList(long idPA, long idTrasformazione, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2659.         int offset; 
  2660.         int limit;
  2661.         String queryString;

  2663.         limit = ricerca.getPageSize(idLista);
  2664.         offset = ricerca.getIndexIniziale(idLista);

  2666.         Connection con = null;
  2667.         PreparedStatement stmt = null;
  2668.         ResultSet rs = null;
  2669.         
  2670.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2671.         String nomeTabellaRichiestaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_URL : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_URL;

  2673.         if (this.driver.atomica) {
  2674.             try {
  2675.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2676.             } catch (Exception e) {
  2677.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2679.             }

  2681.         } else
  2682.             con = this.driver.globalConnection;

  2684.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  2686.         List<TrasformazioneRegolaParametro> lista = new ArrayList<>();
  2687.         try {
  2688.             
  2689.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2690.             sqlQueryObject.addFromTable(nomeTabella);
  2691.             sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2692.             sqlQueryObject.addSelectCountField(nomeTabellaRichiestaHeader+".id", "cont");
  2693.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2694.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2695.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2696.             sqlQueryObject.setSelectDistinct(true);
  2697.             sqlQueryObject.setANDLogicOperator(true);
  2698.             queryString = sqlQueryObject.createSQLQuery();
  2699.             stmt = con.prepareStatement(queryString);
  2700.             stmt.setLong(1, idPA);
  2701.             stmt.setLong(2, idTrasformazione);

  2703.             rs = stmt.executeQuery();
  2704.             if (rs.next())
  2705.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  2706.             rs.close();
  2707.             stmt.close();

  2709.             // ricavo le entries
  2710.             if (limit == 0) // con limit
  2711.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  2712.             
  2713.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2714.             sqlQueryObject.addFromTable(nomeTabella);
  2715.             sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2716.             sqlQueryObject.addSelectAliasField(nomeTabellaRichiestaHeader, "id", "idTrasParametro");
  2717.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".nome");
  2718.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id");
  2719.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id_trasformazione");
  2720.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2721.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2722.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2723.             sqlQueryObject.setSelectDistinct(true);
  2724.             sqlQueryObject.setANDLogicOperator(true);
  2725.             sqlQueryObject.addOrderBy(nomeTabellaRichiestaHeader+".nome");
  2726.             sqlQueryObject.setSortType(true);
  2727.             sqlQueryObject.setLimit(limit);
  2728.             sqlQueryObject.setOffset(offset);
  2729.             queryString = sqlQueryObject.createSQLQuery();
  2730.             stmt = con.prepareStatement(queryString);
  2731.             stmt.setLong(1, idPA);
  2732.             stmt.setLong(2, idTrasformazione);

  2734.             rs = stmt.executeQuery();

  2736.             List<Long> idLong = new ArrayList<>();
  2737.             while (rs.next()) { 
  2738.                 idLong.add(rs.getLong("idTrasParametro"));
  2739.             }
  2740.             rs.close();
  2741.             stmt.close();
  2742.             
  2743.             if(!idLong.isEmpty()) {
  2744.                 
  2745.                 for (Long idLongTrasf : idLong) {
  2746.                     
  2747.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2748.                     sqlQueryObject.addFromTable(nomeTabella);
  2749.                     sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2750.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".tipo");
  2751.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".nome");
  2752.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".valore");
  2753.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".identificazione_fallita");
  2754.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id");
  2755.                     sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id_trasformazione");
  2756.                     sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id=?");
  2757.                     sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2758.                     sqlQueryObject.setANDLogicOperator(true);
  2759.                     queryString = sqlQueryObject.createSQLQuery();
  2760.                     stmt = con.prepareStatement(queryString);
  2761.                     stmt.setLong(1, idLongTrasf);
  2762.                     
  2763.                     rs = stmt.executeQuery();
  2764.                     
  2765.                     if(rs.next()) {
  2766.                         TrasformazioneRegolaParametro parametro = new TrasformazioneRegolaParametro();
  2767.                         parametro.setConversioneTipo(DriverConfigurazioneDBLib.getEnumTrasformazioneRegolaParametroTipoAzione(rs.getString("tipo")));
  2768.                         parametro.setNome(rs.getString("nome"));
  2769.                         parametro.setValore(rs.getString("valore"));
  2770.                         parametro.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumTrasformazioneIdentificazioneRisorsaFallita(rs.getString("identificazione_fallita")));
  2771.                         parametro.setId(rs.getLong("id"));
  2772.                         lista.add(parametro);
  2773.                     }
  2774.                     
  2775.                     rs.close();
  2776.                     stmt.close();
  2777.                     
  2778.                 }
  2779.             }

  2781.         } catch (Exception qe) {
  2782.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2783.         } finally {

  2785.             //Chiudo statement and resultset
  2786.             JDBCUtilities.closeResources(rs, stmt);

  2788.             this.driver.closeConnection(con);
  2789.         }
  2790.         
  2791.         return lista;
  2792.     } 
  2793.     
  2794.     protected boolean existsPortaApplicativaTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2795.         String nomeMetodo = "existsPortaApplicativaTrasformazioneRichiestaUrlParameter";
  2796.         boolean delegata = false;
  2797.         return _existsTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2798.     }
  2799.     
  2800.     protected boolean existsPortaDelegataTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2801.         String nomeMetodo = "existsPortaDelegataTrasformazioneRichiestaUrlParameter";
  2802.         boolean delegata = true;
  2803.         return _existsTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2804.     }
  2805.     
  2806.     private boolean _existsTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2807.         Connection con = null;
  2808.         PreparedStatement stmt=null;
  2809.         ResultSet risultato=null;
  2810.         String queryString;
  2811.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2812.         String nomeTabellaRichiestaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_URL : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_URL;

  2814.         if (this.driver.atomica) {
  2815.             try {
  2816.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2817.             } catch (Exception e) {
  2818.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2820.             }

  2822.         } else
  2823.             con = this.driver.globalConnection;

  2825.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  2827.         try {

  2829.             int count = 0;
  2830.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2831.             sqlQueryObject.addFromTable(nomeTabella);
  2832.             sqlQueryObject.addFromTable(nomeTabellaRichiestaHeader);
  2833.             sqlQueryObject.addSelectCountField(nomeTabellaRichiestaHeader+".id", "cont");
  2834.             sqlQueryObject.setANDLogicOperator(true);
  2835.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2836.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2837.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2838.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".nome = ?");
  2839.             if(checkTipo) {
  2840.                 sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".tipo = ?");
  2841.             }
  2842.             
  2843.             queryString = sqlQueryObject.createSQLQuery();
  2844.             stmt = con.prepareStatement(queryString);
  2845.             int parameterIndex = 1;
  2846.             stmt.setLong(parameterIndex ++, idPorta);
  2847.             stmt.setLong(parameterIndex ++, idTrasformazione);
  2848.             stmt.setString(parameterIndex ++, nome);
  2849.             if(checkTipo) {
  2850.                 stmt.setString(parameterIndex ++, tipo);
  2851.             }
  2852.             
  2853.             risultato = stmt.executeQuery();
  2854.             if (risultato.next())
  2855.                 count = risultato.getInt(1);
  2856.             risultato.close();
  2857.             stmt.close();

  2859.             return count > 0;

  2861.         } catch (Exception qe) {
  2862.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2863.         } finally {

  2865.             //Chiudo statement and resultset
  2866.             JDBCUtilities.closeResources(risultato, stmt);

  2868.             this.driver.closeConnection(con);
  2869.         }
  2870.     }
  2871.     
  2872.     protected TrasformazioneRegolaParametro getPortaApplicativaTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2873.         String nomeMetodo = "getPortaApplicativaTrasformazioneRichiestaUrlParameter";
  2874.         boolean delegata = false;
  2875.         return getEngineTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2876.     }
  2877.     
  2878.     protected TrasformazioneRegolaParametro getPortaDelegataTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
  2879.         String nomeMetodo = "getPortaDelegataTrasformazioneRichiestaUrlParameter";
  2880.         boolean delegata = true;
  2881.         return getEngineTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo, nomeMetodo, delegata);
  2882.     }
  2883.     
  2884.     private TrasformazioneRegolaParametro getEngineTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  2885.         Connection con = null;
  2886.         PreparedStatement stmt=null;
  2887.         ResultSet rs =null;
  2888.         String queryString;
  2889.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI;
  2890.         String nomeTabellaRichiestaHeader = portaDelegata ? CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_URL : CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_URL;
  2891.         
  2892.         if (this.driver.atomica) {
  2893.             try {
  2894.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2895.             } catch (Exception e) {
  2896.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2898.             }

  2900.         } else
  2901.             con = this.driver.globalConnection;

  2903.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  2904.         TrasformazioneRegolaParametro parametro = null;
  2905.         try {

  2907.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2908.             sqlQueryObject.addFromTable(nomeTabella);
  2909.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".nome");
  2910.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".valore");
  2911.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".tipo");
  2912.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".identificazione_fallita");
  2913.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id");
  2914.             sqlQueryObject.addSelectField(nomeTabellaRichiestaHeader+".id_trasformazione");
  2915.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  2916.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".id_trasformazione=?");
  2917.             sqlQueryObject.addWhereCondition(nomeTabella+".id="+nomeTabellaRichiestaHeader+".id_trasformazione");
  2918.             sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".nome = ?");
  2919.             if(checkTipo) {
  2920.                 sqlQueryObject.addWhereCondition(nomeTabellaRichiestaHeader+".tipo = ?");
  2921.             }
  2922.             sqlQueryObject.setANDLogicOperator(true);

  2924.             queryString = sqlQueryObject.createSQLQuery();
  2925.             stmt = con.prepareStatement(queryString);
  2926.             int parameterIndex = 1;
  2927.             stmt.setLong(parameterIndex ++, idPorta);
  2928.             stmt.setLong(parameterIndex ++, idTrasformazione);
  2929.             stmt.setString(parameterIndex ++, nome);
  2930.             if(checkTipo) {
  2931.                 stmt.setString(parameterIndex ++, tipo);
  2932.             }
  2933.             
  2934.             rs = stmt.executeQuery();
  2935.             if (rs.next()) {
  2936.                 parametro = new TrasformazioneRegolaParametro();
  2937.                 parametro.setConversioneTipo(DriverConfigurazioneDBLib.getEnumTrasformazioneRegolaParametroTipoAzione(rs.getString("tipo")));
  2938.                 parametro.setNome(rs.getString("nome"));
  2939.                 parametro.setValore(rs.getString("valore"));
  2940.                 parametro.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumTrasformazioneIdentificazioneRisorsaFallita(rs.getString("identificazione_fallita")));
  2941.                 parametro.setId(rs.getLong("id"));
  2942.             }
  2943.             
  2944.             rs.close();
  2945.             stmt.close();

  2947.             return parametro;

  2949.         } catch (Exception qe) {
  2950.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2951.         } finally {

  2953.             //Chiudo statement and resultset
  2954.             JDBCUtilities.closeResources(rs, stmt);

  2956.             this.driver.closeConnection(con);
  2957.         }
  2958.     }
  2959. }
Created with JaCoCo 0.8.8.202204050719