DriverRegistroServiziDB_accordiServiziCompostiDriver.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.  */



  23. package org.openspcoop2.core.registry.driver.db;

  25. import java.sql.Connection;
  26. import java.sql.PreparedStatement;
  27. import java.sql.ResultSet;
  28. import java.sql.SQLException;
  29. import java.util.ArrayList;
  30. import java.util.List;

  32. import org.openspcoop2.core.commons.CoreException;
  33. import org.openspcoop2.core.commons.DBUtils;
  34. import org.openspcoop2.core.commons.ISearch;
  35. import org.openspcoop2.core.commons.Liste;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.core.id.IDAccordoCooperazione;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.id.IDSoggetto;
  40. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  41. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioComposto;
  42. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
  43. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  44. import org.openspcoop2.core.registry.Documento;
  45. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  46. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  47. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  48. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  49. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  50. import org.openspcoop2.utils.sql.ISQLQueryObject;
  51. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  64.     private DriverRegistroServiziDB driver = null;
  65.     
  66.     protected DriverRegistroServiziDB_accordiServiziCompostiDriver(DriverRegistroServiziDB driver) {
  67.         this.driver = driver;
  68.     }
  69.     
  70.     protected void readAccordoServizioComposto(AccordoServizioParteComune as,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  71.         Connection con = null;
  72.         PreparedStatement stm = null;
  73.         ResultSet rs = null;
  74.         PreparedStatement stm2 = null;
  75.         ResultSet rs2 = null;
  76.         String sqlQuery = null;

  78.         try {
  79.             this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  80.             // prendo la connessione dal pool
  81.             if(conParam!=null)
  82.                 con = conParam;
  83.             else if (this.driver.atomica)
  84.                 con = this.driver.getConnectionFromDatasource("readAccordoServizioComposto");
  85.             else
  86.                 con = this.driver.globalConnection;

  88.             if(as.getId()==null || as.getId()<=0)
  89.                 throw new Exception("Accordo id non definito");

  91.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  92.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  93.             sqlQueryObject.addSelectField("*");
  94.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  95.             sqlQueryObject.setANDLogicOperator(true);
  96.             sqlQuery = sqlQueryObject.createSQLQuery();
  97.             stm = con.prepareStatement(sqlQuery);
  98.             stm.setLong(1, as.getId());

  100.             this.driver.logDebug("eseguo query : " + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, as.getId()));
  101.             rs = stm.executeQuery();

  103.             AccordoServizioParteComuneServizioComposto asComposto = null;
  104.             if (rs.next()) {

  106.                 asComposto = new AccordoServizioParteComuneServizioComposto();
  107.                 asComposto.setId(rs.getLong("id"));
  108.                 asComposto.setIdAccordoCooperazione(rs.getLong("id_accordo_cooperazione"));

  110.                 IDAccordoCooperazione idAccordoCooperazione = this.driver.getIdAccordoCooperazione(asComposto.getIdAccordoCooperazione(), con);
  111.                 String uriAccordo = this.driver.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordoCooperazione);
  112.                 asComposto.setAccordoCooperazione(uriAccordo);
  113.             }
  114.             rs.close();
  115.             stm.close();

  117.             if(asComposto!=null){

  119.                 // read servizi componenti
  120.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  121.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  122.                 sqlQueryObject.addSelectField("*");
  123.                 sqlQueryObject.addWhereCondition("id_servizio_composto = ?");
  124.                 sqlQueryObject.setANDLogicOperator(true);
  125.                 sqlQuery = sqlQueryObject.createSQLQuery();
  126.                 stm = con.prepareStatement(sqlQuery);
  127.                 stm.setLong(1, asComposto.getId());
  128.                 this.driver.logDebug("eseguo query : " + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, asComposto.getId()));
  129.                 rs = stm.executeQuery();

  131.                 while (rs.next()) {

  133.                     AccordoServizioParteComuneServizioCompostoServizioComponente asComponente = new AccordoServizioParteComuneServizioCompostoServizioComponente();
  134.                     asComponente.setIdServizioComponente(rs.getLong("id_servizio_componente"));
  135.                     asComponente.setAzione(rs.getString("azione"));

  137.                     AccordoServizioParteSpecifica aspsServizioComponente = this.driver.getAccordoServizioParteSpecifica(asComponente.getIdServizioComponente(),con);
  138.                     asComponente.setTipo(aspsServizioComponente.getTipo());
  139.                     asComponente.setNome(aspsServizioComponente.getNome());
  140.                     asComponente.setVersione(aspsServizioComponente.getVersione());
  141.                     asComponente.setTipoSoggetto(aspsServizioComponente.getTipoSoggettoErogatore());
  142.                     asComponente.setNomeSoggetto(aspsServizioComponente.getNomeSoggettoErogatore());

  144.                     asComposto.addServizioComponente(asComponente);
  145.                 }
  146.                 rs.close();
  147.                 stm.close();


  150.                 // setto all'interno dell'accordo
  151.                 as.setServizioComposto(asComposto);
  152.             }

  154.         }catch (DriverRegistroServiziNotFound e) {
  155.             throw e;
  156.         }catch (Exception se) {
  157.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::readPortTypes] Exception :" + se.getMessage(),se);
  158.         } finally {

  160.             JDBCUtilities.closeResources(rs2, stm2);

  162.             JDBCUtilities.closeResources(rs, stm);

  164.             this.driver.closeConnection(conParam, con);

  166.         }
  167.     }

  169.     
  170.     protected List<AccordoServizioParteComune> accordiServizio_serviziComponentiConSoggettoErogatore(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  171.         String nomeMetodo = "accordiServizio_serviziComponentiConSoggettoErogatore";

  173.         String queryString;

  175.         Connection con = null;
  176.         PreparedStatement stmt = null;
  177.         ResultSet risultato = null;

  179.         ArrayList<AccordoServizioParteComune> idAccordoServizio = new ArrayList<AccordoServizioParteComune>();

  181.         if (this.driver.atomica) {
  182.             try {
  183.                 con = this.driver.getConnectionFromDatasource("accordiServizio_serviziComponentiConSoggettoErogatore");

  185.             } catch (Exception e) {
  186.                 throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  188.             }

  190.         } else
  191.             con = this.driver.globalConnection;

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

  195.         try {
  196.             ISQLQueryObject sqlQueryObjectSoggetti = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  197.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.SOGGETTI);
  198.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI);
  199.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  200.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  201.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.SERVIZI);

  203.             sqlQueryObjectSoggetti.addSelectAliasField(CostantiDB.ACCORDI, "id","idAccordoServizio");

  205.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI+".id="+CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo");
  206.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id="+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_composto");
  207.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente="+CostantiDB.SERVIZI+".id");
  208.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SOGGETTI+".id="+CostantiDB.SERVIZI+".id_soggetto");
  209.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto=?");
  210.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto=?");
  211.             sqlQueryObjectSoggetti.setANDLogicOperator(true);
  212.             queryString = sqlQueryObjectSoggetti.createSQLQuery();

  214.             this.driver.logDebug("eseguo query : " + DriverRegistroServiziDB_LIB.formatSQLString(queryString));

  216.             stmt = con.prepareStatement(queryString);
  217.             stmt.setString(1,idSoggetto.getTipo());
  218.             stmt.setString(2,idSoggetto.getNome());
  219.             risultato = stmt.executeQuery();

  221.             while (risultato.next()) {

  223.                 long idAccordoServizioLong = risultato.getLong("idAccordoServizio");
  224.                 idAccordoServizio.add(this.driver.getAccordoServizioParteComune(idAccordoServizioLong));

  226.             }

  228.         } catch (Exception se) {

  230.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  231.         } finally {

  233.             //Chiudo statement and resultset
  234.             JDBCUtilities.closeResources(risultato, stmt);

  236.             this.driver.closeConnection(con);
  237.         }


  240.         return idAccordoServizio;
  241.     }

  243.     protected List<AccordoServizioParteComune> accordiServizio_serviziComponenti(IDServizio idServizio) throws DriverRegistroServiziException {
  244.         String nomeMetodo = "accordiServizio_serviziComponenti";

  246.         String queryString;

  248.         Connection con = null;
  249.         PreparedStatement stmt = null;
  250.         ResultSet risultato = null;

  252.         ArrayList<AccordoServizioParteComune> idAccordoServizio = new ArrayList<AccordoServizioParteComune>();

  254.         if (this.driver.atomica) {
  255.             try {
  256.                 con = this.driver.getConnectionFromDatasource("accordiServizio_serviziComponenti");

  258.             } catch (Exception e) {
  259.                 throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  261.             }

  263.         } else
  264.             con = this.driver.globalConnection;

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

  268.         try {
  269.             ISQLQueryObject sqlQueryObjectSoggetti = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  270.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.SOGGETTI);
  271.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI);
  272.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  273.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  274.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.SERVIZI);

  276.             sqlQueryObjectSoggetti.addSelectAliasField(CostantiDB.ACCORDI, "id","idAccordoServizio");

  278.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI+".id="+CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo");
  279.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id="+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_composto");
  280.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente="+CostantiDB.SERVIZI+".id");
  281.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SOGGETTI+".id="+CostantiDB.SERVIZI+".id_soggetto");
  282.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto=?");
  283.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto=?");
  284.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SERVIZI+".tipo_servizio=?");
  285.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SERVIZI+".nome_servizio=?");
  286.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SERVIZI+".versione_servizio=?");
  287.             sqlQueryObjectSoggetti.setANDLogicOperator(true);
  288.             queryString = sqlQueryObjectSoggetti.createSQLQuery();

  290.             this.driver.logDebug("eseguo query : " + DriverRegistroServiziDB_LIB.formatSQLString(queryString));

  292.             stmt = con.prepareStatement(queryString);
  293.             stmt.setString(1,idServizio.getSoggettoErogatore().getTipo());
  294.             stmt.setString(2,idServizio.getSoggettoErogatore().getNome());
  295.             stmt.setString(3, idServizio.getTipo());
  296.             stmt.setString(4, idServizio.getNome());
  297.             stmt.setInt(5, idServizio.getVersione());
  298.             risultato = stmt.executeQuery();

  300.             while (risultato.next()) {

  302.                 long idAccordoServizioLong = risultato.getLong("idAccordoServizio");
  303.                 idAccordoServizio.add(this.driver.getAccordoServizioParteComune(idAccordoServizioLong));

  305.             }

  307.         } catch (Exception se) {

  309.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  310.         } finally {

  312.             //Chiudo statement and resultset
  313.             JDBCUtilities.closeResources(risultato, stmt);

  315.             this.driver.closeConnection(con);
  316.         }


  319.         return idAccordoServizio;
  320.     }


  323.     protected List<AccordoServizioParteComune> accordiServizioWithAccordoCooperazione(IDAccordoCooperazione idAccordoCooperazione) throws DriverRegistroServiziException {
  324.         String nomeMetodo = "accordiServizioWithAccordoCooperazione";

  326.         String queryString;

  328.         Connection con = null;
  329.         PreparedStatement stmt = null;
  330.         ResultSet risultato = null;

  332.         ArrayList<AccordoServizioParteComune> idAccordoServizio = new ArrayList<AccordoServizioParteComune>();

  334.         if (this.driver.atomica) {
  335.             try {
  336.                 con = this.driver.getConnectionFromDatasource("accordiServizioWithAccordoCooperazione");

  338.             } catch (Exception e) {
  339.                 throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  341.             }

  343.         } else
  344.             con = this.driver.globalConnection;

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

  348.         try {
  349.             ISQLQueryObject sqlQueryObjectSoggetti = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);

  351.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI);
  352.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  353.             sqlQueryObjectSoggetti.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE);

  355.             sqlQueryObjectSoggetti.addSelectAliasField(CostantiDB.ACCORDI, "id","idAccordoServizio");

  357.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI+".id="+CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo");
  358.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo_cooperazione="+CostantiDB.ACCORDI_COOPERAZIONE+".id");
  359.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_COOPERAZIONE+".nome=?");
  360.             sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_COOPERAZIONE+".versione=?");
  361.             if(idAccordoCooperazione.getSoggettoReferente()!=null){
  362.                 sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.ACCORDI_COOPERAZIONE+".id_referente=?");
  363.             }
  364.             sqlQueryObjectSoggetti.setANDLogicOperator(true);
  365.             queryString = sqlQueryObjectSoggetti.createSQLQuery();

  367.             this.driver.logDebug("eseguo query : " + DriverRegistroServiziDB_LIB.formatSQLString(queryString));

  369.             stmt = con.prepareStatement(queryString);
  370.             stmt.setString(1,idAccordoCooperazione.getNome());
  371.             stmt.setInt(2,idAccordoCooperazione.getVersione());
  372.             if(idAccordoCooperazione.getSoggettoReferente()!=null){
  373.                 stmt.setLong(3, DBUtils.getIdSoggetto(idAccordoCooperazione.getSoggettoReferente().getNome(), idAccordoCooperazione.getSoggettoReferente().getTipo(), con, this.driver.tipoDB));
  374.             }
  375.             risultato = stmt.executeQuery();

  377.             while (risultato.next()) {

  379.                 long idAccordoServizioLong = risultato.getLong("idAccordoServizio");
  380.                 idAccordoServizio.add(this.driver.getAccordoServizioParteComune(idAccordoServizioLong));

  382.             }

  384.         } catch (Exception se) {

  386.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  387.         } finally {

  389.             //Chiudo statement and resultset
  390.             JDBCUtilities.closeResources(risultato, stmt);

  392.             this.driver.closeConnection(con);
  393.         }


  396.         return idAccordoServizio;
  397.     }
  398.     
  399.     protected long getIdServizioCorrelato(String nomeServizio, String tipoServizio, String nomeProprietario, String tipoProprietario, Connection con) throws DriverRegistroServiziException {
  400.         PreparedStatement stm = null;
  401.         ResultSet rs = null;
  402.         long idSoggetto;
  403.         long idServizio = 0;
  404.         try {
  405.             idSoggetto = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, this.driver.tipoDB, this.driver.tabellaSoggetti);

  407.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  408.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  409.             sqlQueryObject.addSelectField("*");
  410.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  411.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  412.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  413.             sqlQueryObject.addWhereCondition("servizio_correlato = ?");
  414.             sqlQueryObject.setANDLogicOperator(true);
  415.             String query = sqlQueryObject.createSQLQuery();
  416.             stm = con.prepareStatement(query);
  417.             stm.setString(1, tipoServizio);
  418.             stm.setString(2, nomeServizio);
  419.             stm.setLong(3, idSoggetto);
  420.             stm.setString(4, CostantiRegistroServizi.ABILITATO.toString());
  421.             rs = stm.executeQuery();

  423.             if (rs.next()) {
  424.                 idServizio = rs.getLong("id");
  425.             }

  427.             return idServizio;

  429.         } catch (CoreException e) {
  430.             throw new DriverRegistroServiziException(e.getMessage(),e);
  431.         } catch (SQLException e) {
  432.             throw new DriverRegistroServiziException(e.getMessage(),e);
  433.         } catch (Exception e) {
  434.             throw new DriverRegistroServiziException(e.getMessage(),e);
  435.         } finally {
  436.             //Chiudo statement and resultset
  437.             JDBCUtilities.closeResources(rs, stm);

  439.         }
  440.     }
  441.     
  442.     protected List<AccordoServizioParteComuneServizioCompostoServizioComponente> accordiComponentiList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  443.         String nomeMetodo = "accordiComponentiList";
  444.         int idLista = Liste.ACCORDI_COMPONENTI;
  445.         int offset;
  446.         int limit;
  447.         String search;
  448.         String queryString;

  450.         limit = ricerca.getPageSize(idLista);
  451.         offset = ricerca.getIndexIniziale(idLista);
  452.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  453.         ricerca.getSearchString(idLista);

  455.         Connection con = null;
  456.         PreparedStatement stmt = null;
  457.         ResultSet risultato = null;

  459.         ArrayList<AccordoServizioParteComuneServizioCompostoServizioComponente> lista = new ArrayList<AccordoServizioParteComuneServizioCompostoServizioComponente>();

  461.         if (this.driver.atomica) {
  462.             try {
  463.                 con = this.driver.getConnectionFromDatasource("accordiComponentiList");

  465.             } catch (Exception e) {
  466.                 throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  468.             }

  470.         } else
  471.             con = this.driver.globalConnection;

  473.         try {

  475.             /*
  476.              *  SELECT * from acc_serv_composti composti, acc_serv_componenti componenti 
  477.              *  where composti.id_accordo=5 and composti.id=componenti.id_servizio_composto;

  479.              */
  480.             if (!search.equals("")) {
  481.                 //query con search
  482.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  483.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  484.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  485.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  486.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  487.                 sqlQueryObject.addSelectCountField(CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente", "cont");
  488.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo = ?");
  489.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id = "+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_composto");
  490.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id = "+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente");
  491.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".id = "+CostantiDB.SERVIZI+".id_soggetto");
  492.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("tipo_soggetto",search,true,true),
  493.                         sqlQueryObject.getWhereLikeCondition("nome_soggetto",search,true,true),
  494.                         sqlQueryObject.getWhereLikeCondition("tipo_servizio",search,true,true),
  495.                         sqlQueryObject.getWhereLikeCondition("nome_servizio",search,true,true));
  496.                 sqlQueryObject.setANDLogicOperator(true);
  497.                 queryString = sqlQueryObject.createSQLQuery();
  498.             } else {
  499.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  500.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  501.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  502.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  503.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  504.                 sqlQueryObject.addSelectCountField(CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente", "cont");
  505.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo = ?");
  506.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id = "+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_composto");
  507.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id = "+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente");
  508.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".id = "+CostantiDB.SERVIZI+".id_soggetto");
  509.                 sqlQueryObject.setANDLogicOperator(true);
  510.                 queryString = sqlQueryObject.createSQLQuery();
  511.             }

  513.             stmt = con.prepareStatement(queryString);
  514.             stmt.setLong(1,idAccordo);
  515.             risultato = stmt.executeQuery();
  516.             if (risultato.next())
  517.                 ricerca.setNumEntries(idLista,risultato.getInt("cont"));
  518.             risultato.close();
  519.             stmt.close();

  521.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  522.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  523.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  524.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  525.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);

  527.             sqlQueryObject.addSelectField(CostantiDB.ACCORDI_SERVIZI_COMPONENTI,"id_servizio_componente");
  528.             sqlQueryObject.addSelectField(CostantiDB.ACCORDI_SERVIZI_COMPONENTI,"azione");
  529.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI,"tipo_soggetto");
  530.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI,"nome_soggetto");
  531.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI,"tipo_servizio");
  532.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI,"nome_servizio");

  534.             sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo = ?");
  535.             sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id = "+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_composto");
  536.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id = "+CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente");
  537.             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".id = "+CostantiDB.SERVIZI+".id_soggetto");


  540.             if (limit == 0) // con limit
  541.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  543.             if (!search.equals("")) { // con search
  544.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("tipo_soggetto",search,true,true),
  545.                         sqlQueryObject.getWhereLikeCondition("nome_soggetto",search,true,true),
  546.                         sqlQueryObject.getWhereLikeCondition("tipo_servizio",search,true,true),
  547.                         sqlQueryObject.getWhereLikeCondition("nome_servizio",search,true,true));
  548.             } 

  550.             sqlQueryObject.setANDLogicOperator(true);

  552.             sqlQueryObject.addOrderBy("tipo_servizio");
  553.             sqlQueryObject.addOrderBy("nome_servizio");
  554.             sqlQueryObject.addOrderBy("tipo_soggetto");
  555.             sqlQueryObject.addOrderBy("nome_soggetto");
  556.             sqlQueryObject.setSortType(true);
  557.             sqlQueryObject.setLimit(limit);
  558.             sqlQueryObject.setOffset(offset);

  560.             queryString = sqlQueryObject.createSQLQuery();

  562.             stmt = con.prepareStatement(queryString);
  563.             stmt.setLong(1, idAccordo);
  564.             risultato = stmt.executeQuery();

  566.             while(risultato.next()){

  568.                 long idServizioComponente = risultato.getLong("id_servizio_componente");
  569.                 String azione = risultato.getString("azione");
  570.                 AccordoServizioParteComuneServizioCompostoServizioComponente asComponente = new AccordoServizioParteComuneServizioCompostoServizioComponente();
  571.                 asComponente.setAzione(azione);
  572.                 asComponente.setIdServizioComponente(idServizioComponente);
  573.                 asComponente.setTipo(risultato.getString("tipo_servizio"));
  574.                 asComponente.setNome(risultato.getString("nome_servizio"));
  575.                 asComponente.setTipoSoggetto(risultato.getString("tipo_soggetto"));
  576.                 asComponente.setNomeSoggetto(risultato.getString("nome_soggetto"));

  578.                 lista.add(asComponente);
  579.             }


  582.             return lista;

  584.         } catch (Exception se) {

  586.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  587.         } finally {
  588.             //Chiudo statement and resultset
  589.             JDBCUtilities.closeResources(risultato, stmt);
  590.             this.driver.closeConnection(con);
  591.         }
  592.     }

  594.     protected List<Documento> accordiCoopAllegatiList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  595.         String nomeMetodo = "accordiCoopAllegatiList";
  596.         int idLista = Liste.ACCORDI_COOP_ALLEGATI;
  597.         int offset;
  598.         int limit;
  599.         String search;
  600.         String queryString;

  602.         limit = ricerca.getPageSize(idLista);
  603.         offset = ricerca.getIndexIniziale(idLista);
  604.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  605.         ricerca.getSearchString(idLista);

  607.         Connection con = null;
  608.         PreparedStatement stmt = null;
  609.         ResultSet risultato = null;

  611.         ArrayList<Documento> lista = new ArrayList<Documento>();

  613.         if (this.driver.atomica) {
  614.             try {
  615.                 con = this.driver.getConnectionFromDatasource("accordiCoopAllegatiList");

  617.             } catch (Exception e) {
  618.                 throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  620.             }

  622.         } else
  623.             con = this.driver.globalConnection;

  625.         try {

  627.             if (!search.equals("")) {
  628.                 //query con search
  629.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  630.                 sqlQueryObject.addFromTable(CostantiDB.DOCUMENTI);
  631.                 sqlQueryObject.addSelectCountField("*", "cont");
  632.                 sqlQueryObject.addWhereCondition("id_proprietario = ?");
  633.                 sqlQueryObject.addWhereCondition("tipo_proprietario = ?");
  634.                 sqlQueryObject.addWhereCondition(false, 
  635.                         //sqlQueryObject.getWhereLikeCondition("ruolo",search,true,true),
  636.                         sqlQueryObject.getWhereLikeCondition("nome",search,true,true));
  637.                 sqlQueryObject.setANDLogicOperator(true);
  638.                 queryString = sqlQueryObject.createSQLQuery();
  639.             } else {
  640.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  641.                 sqlQueryObject.addFromTable(CostantiDB.DOCUMENTI);
  642.                 sqlQueryObject.addSelectCountField("*", "cont");
  643.                 sqlQueryObject.addWhereCondition("id_proprietario = ?");
  644.                 sqlQueryObject.addWhereCondition("tipo_proprietario = ?");
  645.                 sqlQueryObject.setANDLogicOperator(true);
  646.                 queryString = sqlQueryObject.createSQLQuery();
  647.             }

  649.             stmt = con.prepareStatement(queryString);
  650.             stmt.setLong(1,idAccordo);
  651.             stmt.setString(2, ProprietariDocumento.accordoCooperazione.toString());
  652.             risultato = stmt.executeQuery();
  653.             if (risultato.next())
  654.                 ricerca.setNumEntries(idLista,risultato.getInt("cont"));
  655.             risultato.close();
  656.             stmt.close();

  658.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  659.             sqlQueryObject.addFromTable(CostantiDB.DOCUMENTI);
  660.             sqlQueryObject.addSelectField("id");
  661.             sqlQueryObject.addSelectField("nome");
  662.             sqlQueryObject.addSelectField("ruolo");
  663.             sqlQueryObject.addSelectField("id_proprietario");
  664.             sqlQueryObject.addSelectField("tipo_proprietario");
  665.             //where
  666.             sqlQueryObject.addWhereCondition("id_proprietario = ?");
  667.             sqlQueryObject.addWhereCondition("tipo_proprietario = ?");

  669.             // ricavo le entries
  670.             if (limit == 0) // con limit
  671.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  673.             if (!search.equals("")) { // con search
  674.                 sqlQueryObject.addWhereCondition(false, 
  675.                         //sqlQueryObject.getWhereLikeCondition("ruolo",search,true,true),
  676.                         sqlQueryObject.getWhereLikeCondition("nome",search,true,true));
  677.             } 

  679.             sqlQueryObject.setANDLogicOperator(true);
  680.             sqlQueryObject.addOrderBy("nome");
  681.             sqlQueryObject.setSortType(true);
  682.             sqlQueryObject.setLimit(limit);
  683.             sqlQueryObject.setOffset(offset);
  684.             queryString = sqlQueryObject.createSQLQuery();

  686.             stmt = con.prepareStatement(queryString);
  687.             stmt.setLong(1, idAccordo);
  688.             stmt.setString(2, ProprietariDocumento.accordoCooperazione.toString());
  689.             risultato = stmt.executeQuery();

  691.             while(risultato.next()){
  692.                 Documento doc = DriverRegistroServiziDB_documentiLIB.getDocumento(risultato.getLong("id"),false, con, this.driver.tipoDB); 
  693.                 lista.add(doc);
  694.             }

  696.             return lista;

  698.         } catch (Exception se) {

  700.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  701.         } finally {
  702.             //Chiudo statement and resultset
  703.             JDBCUtilities.closeResources(risultato, stmt);
  704.             this.driver.closeConnection(con);
  705.         }
  706.     }
  707. }
Created with JaCoCo 0.8.8.202204050719