DriverRegistroServiziDB_accordiParteSpecificaLIB.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 static org.openspcoop2.core.constants.CostantiDB.CREATE;
  26. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  27. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  29. import java.sql.Connection;
  30. import java.sql.PreparedStatement;
  31. import java.sql.ResultSet;
  32. import java.sql.SQLException;
  33. import java.sql.Timestamp;
  34. import java.util.ArrayList;
  35. import java.util.List;

  37. import org.openspcoop2.core.byok.IDriverBYOK;
  38. import org.openspcoop2.core.commons.CoreException;
  39. import org.openspcoop2.core.commons.DBUtils;
  40. import org.openspcoop2.core.constants.CostantiDB;
  41. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  42. import org.openspcoop2.core.id.IDAccordo;
  43. import org.openspcoop2.core.id.IDServizio;
  44. import org.openspcoop2.core.id.IDSoggetto;
  45. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  46. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  47. import org.openspcoop2.core.registry.Connettore;
  48. import org.openspcoop2.core.registry.Documento;
  49. import org.openspcoop2.core.registry.Fruitore;
  50. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  51. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  52. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  53. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  54. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  55. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  56. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  57. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  58. import org.openspcoop2.utils.date.DateManager;
  59. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  60. import org.openspcoop2.utils.sql.ISQLQueryObject;
  61. import org.openspcoop2.utils.sql.SQLObjectFactory;

  63. /**
  64.  * Classe utilizzata per effettuare query ad un registro dei servizi openspcoop
  65.  * formato db.
  66.  * 
  67.  * 
  68.  * @author Sandra Giangrandi (sandra@link.it)
  69.  * @author Stefano Corallo (corallo@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  */
  73. public class DriverRegistroServiziDB_accordiParteSpecificaLIB {
  74.     
  75.     /**
  76.      * CRUD oggetto AccordoServizioParteSpecifica Non si occupa di chiudere la connessione con
  77.      * il db in caso di errore in quanto verra' gestita dal metodo chiamante
  78.      * 
  79.      * @param type
  80.      *            Tipo operazione {1 (CREATE),2 (UPDATE),3 (DELETE)}
  81.      * @param asps
  82.      * @param con
  83.      * @throws DriverRegistroServiziException
  84.      */
  85.     public static long CRUDAccordoServizioParteSpecifica(int type, org.openspcoop2.core.registry.AccordoServizioParteSpecifica asps, Connection con,
  86.             String tipoDatabase, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  87.         if (asps == null)
  88.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] asps non valido.");

  90.         String nomeProprietario = asps.getNomeSoggettoErogatore();
  91.         String tipoProprietario = asps.getTipoSoggettoErogatore();
  92.         String nomeServizio = asps.getNome();
  93.         String tipoServizio = asps.getTipo();
  94.         Integer versioneServizio = asps.getVersione();
  95.         String descrizione = asps.getDescrizione();
  96.         String stato = asps.getStatoPackage();

  98.         if (nomeProprietario == null || nomeProprietario.equals(""))
  99.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametro Nome Proprietario non valido.");
  100.         if (tipoProprietario == null || tipoProprietario.equals(""))
  101.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametro Tipo Proprietario non valido.");
  102.         if (nomeServizio == null || nomeServizio.equals(""))
  103.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametro Nome Servizio non valido.");
  104.         if (tipoServizio == null || tipoServizio.equals(""))
  105.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametro Tipo Servizio non valido.");
  106.         if (versioneServizio == null)
  107.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametro Versione Servizio non valido.");

  109.         Connettore connettore = null;
  110.         if(asps.getConfigurazioneServizio()!=null){
  111.             connettore = asps.getConfigurazioneServizio().getConnettore();
  112.         }

  114.         String wsdlImplementativoErogatore = (asps.getByteWsdlImplementativoErogatore()!=null ? new String(asps.getByteWsdlImplementativoErogatore()) : null );
  115.         String wsdlImplementativoFruitore =  (asps.getByteWsdlImplementativoFruitore()!=null ? new String(asps.getByteWsdlImplementativoFruitore()) : null );
  116.         
  117.         wsdlImplementativoErogatore = wsdlImplementativoErogatore!=null && !"".equals(wsdlImplementativoErogatore.trim().replace("\n", "")) ? wsdlImplementativoErogatore : null;
  118.         wsdlImplementativoFruitore = wsdlImplementativoFruitore!=null && !"".equals(wsdlImplementativoFruitore.trim().replace("\n", "")) ? wsdlImplementativoFruitore : null;
  119.                 
  120.         String superUser = asps.getSuperUser();
  121.         StatoFunzionalita servizioCorrelato = (TipologiaServizio.CORRELATO.equals(asps.getTipologiaServizio()) ? CostantiRegistroServizi.ABILITATO : CostantiRegistroServizi.DISABILITATO);
  122.         String portType = (asps.getPortType()!=null ? asps.getPortType() : null );
  123.                 
  124.         long idSoggetto = -1;

  126.         // Recupero IDAccordo
  127.         long idAccordoLong = -1;
  128.         try {
  129.             //L accordo mi serve solo in caso di create/update
  130.             if(type!=CostantiDB.DELETE){
  131.                 String uriAccordo = asps.getAccordoServizioParteComune();
  132.                 if(uriAccordo==null || uriAccordo.equals("")) throw new DriverRegistroServiziException("L'uri dell'Accordo di Servizio non puo essere null.");
  133.                 IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(uriAccordo);
  134.                 idAccordoLong = DBUtils.getIdAccordoServizioParteComune(idAccordo, con, DriverRegistroServiziDB_LIB.tipoDB);
  135.             }
  136.         } catch (Exception e) {
  137.             DriverRegistroServiziDB_LIB.logError("Driver Error for get IDAccordo nome:["+asps.getAccordoServizioParteComune()+"].", e);
  138.             throw new DriverRegistroServiziException(e);
  139.         }

  141.         try {
  142.             String nomeS = nomeProprietario;
  143.             String tipoS = tipoProprietario;
  144.             idSoggetto = DBUtils.getIdSoggetto(nomeS, tipoS, con, DriverRegistroServiziDB_LIB.tipoDB);
  145.         } catch (CoreException e) {
  146.             DriverRegistroServiziDB_LIB.logError("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] getIdSoggetto failed: "+e.getMessage(), e);
  147.             throw new DriverRegistroServiziException(e);
  148.         }
  149.         if (idSoggetto <= 0)
  150.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametri non validi. Impossibile risalire all'id del soggettoo");       
  151.         //l'id accordo mi serve solo in caso di create/update
  152.         if(idAccordoLong <= 0 && type!=CostantiDB.DELETE)
  153.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Parametri non validi. Impossibile risalire all'id dell'accordo");

  155.         long idConnettore;
  156.         if (connettore == null && type != CostantiDB.CREATE && type!=CostantiDB.DELETE)
  157.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Il Connettore non puo essere nullo.");

  159.         PreparedStatement updateStmt = null;
  160.         ResultSet updateRS = null;
  161.         String updateQuery = "";

  163.         try {
  164.             long idServizio = 0;
  165.             int n = 0;
  166.             int sizeFruitori=0;
  167.             int sizeAzioni=0;
  168.             Fruitore fruitore;

  170.             asps.setIdAccordo(idAccordoLong);
  171.             switch (type) {
  172.             case CREATE:
  173.                 // CREATE

  175.                 if (connettore == null) {
  176.                     connettore = new Connettore();
  177.                     connettore.setNome("CNT_" + tipoProprietario+"/"+nomeProprietario +"_"+ tipoServizio + "/" +nomeServizio+"/"+versioneServizio);
  178.                 }

  180.                 if (connettore.getNome() == null || connettore.getNome().equals("")) {
  181.                     // setto il nome del connettore
  182.                     connettore.setNome("CNT_" + tipoProprietario+"/"+nomeProprietario +"_"+ tipoServizio + "/" +nomeServizio+"/"+versioneServizio );
  183.                 }

  185.                 // creo il connettore del servizio
  186.                 idConnettore = DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(1, connettore, con, driverBYOK);

  188.                 String utenteRichiedente = null;
  189.                 if(asps.getProprietaOggetto()!=null && asps.getProprietaOggetto().getUtenteRichiedente()!=null) {
  190.                     utenteRichiedente = asps.getProprietaOggetto().getUtenteRichiedente();
  191.                 }
  192.                 else {
  193.                     utenteRichiedente = superUser;
  194.                 }
  195.                 
  196.                 Timestamp dataCreazione = null;
  197.                 if(asps.getProprietaOggetto()!=null && asps.getProprietaOggetto().getDataCreazione()!=null) {
  198.                     dataCreazione = new Timestamp(asps.getProprietaOggetto().getDataCreazione().getTime());
  199.                 }
  200.                 else if(asps.getOraRegistrazione()!=null){
  201.                     dataCreazione = new Timestamp(asps.getOraRegistrazione().getTime());
  202.                 }
  203.                 else {
  204.                     dataCreazione = DateManager.getTimestamp();
  205.                 }
  206.                 
  207.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  208.                 sqlQueryObject.addInsertTable(CostantiDB.SERVIZI);
  209.                 sqlQueryObject.addInsertField("nome_servizio", "?");
  210.                 sqlQueryObject.addInsertField("tipo_servizio", "?");
  211.                 sqlQueryObject.addInsertField("versione_servizio", "?");
  212.                 sqlQueryObject.addInsertField("id_soggetto", "?");
  213.                 sqlQueryObject.addInsertField("id_accordo", "?");
  214.                 sqlQueryObject.addInsertField("servizio_correlato", "?");
  215.                 sqlQueryObject.addInsertField("id_connettore", "?");
  216.                 sqlQueryObject.addInsertField("wsdl_implementativo_erogatore", "?");
  217.                 sqlQueryObject.addInsertField("wsdl_implementativo_fruitore", "?");
  218.                 sqlQueryObject.addInsertField("superuser", "?");
  219.                 sqlQueryObject.addInsertField("privato", "?");
  220.                 sqlQueryObject.addInsertField("port_type", "?");
  221.                 sqlQueryObject.addInsertField("profilo", "?");
  222.                 sqlQueryObject.addInsertField("descrizione", "?");
  223.                 if(stato!=null)
  224.                     sqlQueryObject.addInsertField("stato", "?");
  225.                 if(asps.getOraRegistrazione()!=null)
  226.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  227.                 sqlQueryObject.addInsertField("message_type", "?");
  228.                 if(utenteRichiedente!=null) {
  229.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  230.                 }
  231.                 if(dataCreazione!=null) {
  232.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  233.                 }
  234.                 
  235.                 updateQuery = sqlQueryObject.createSQLInsert();
  236.                 updateStmt = con.prepareStatement(updateQuery);

  238.                 int index = 1;
  239.                 updateStmt.setString(index++, nomeServizio);
  240.                 updateStmt.setString(index++, tipoServizio);
  241.                 updateStmt.setInt(index++, versioneServizio);
  242.                 updateStmt.setLong(index++, idSoggetto);
  243.                 updateStmt.setLong(index++, idAccordoLong);
  244.                 updateStmt.setString(index++, DriverRegistroServiziDB_LIB.getValue(servizioCorrelato));
  245.                 updateStmt.setLong(index++, idConnettore);
  246.                 updateStmt.setString(index++, wsdlImplementativoErogatore);
  247.                 updateStmt.setString(index++, wsdlImplementativoFruitore);
  248.                 updateStmt.setString(index++, superUser);
  249.                 if(asps.getPrivato()!=null && asps.getPrivato())
  250.                     updateStmt.setInt(index++, 1);
  251.                 else
  252.                     updateStmt.setInt(index++, 0);
  253.                 updateStmt.setString(index++, portType);
  254.                 updateStmt.setString(index++, asps.getVersioneProtocollo());
  255.                 updateStmt.setString(index++, descrizione);
  256.                                 
  257.                 if(stato!=null){
  258.                     updateStmt.setString(index++, stato);
  259.                 }
  260.                 
  261.                 if(asps.getOraRegistrazione()!=null){
  262.                     updateStmt.setTimestamp(index++, new Timestamp(asps.getOraRegistrazione().getTime()));
  263.                 }
  264.                 
  265.                 updateStmt.setString(index++, DriverRegistroServiziDB_LIB.getValue(asps.getMessageType()));
  266.                 
  267.                 if(utenteRichiedente!=null) {
  268.                     updateStmt.setString(index++, utenteRichiedente);
  269.                 }
  270.                 
  271.                 if(dataCreazione!=null) {
  272.                     updateStmt.setTimestamp(index++, dataCreazione);
  273.                 }
  274.                 
  275.                 // eseguo lo statement
  276.                 n = updateStmt.executeUpdate();
  277.                 updateStmt.close();
  278.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica CREATE : \n" + 
  279.                         DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, nomeServizio, tipoServizio, versioneServizio,
  280.                                 idSoggetto, idAccordoLong, servizioCorrelato, idConnettore, wsdlImplementativoErogatore, wsdlImplementativoFruitore, superUser));
  281.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica type = " + type + " row affected =" + n);

  283.                 
  284.                 // recupero l'id del servizio inserito
  285.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  286.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  287.                 sqlQueryObject.addSelectField("*");
  288.                 sqlQueryObject.addWhereCondition("nome_servizio = ?");
  289.                 sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  290.                 sqlQueryObject.addWhereCondition("versione_servizio = ?");
  291.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  292.                 sqlQueryObject.setANDLogicOperator(true);
  293.                 updateQuery = sqlQueryObject.createSQLQuery();
  294.                 updateStmt = con.prepareStatement(updateQuery);

  296.                 updateStmt.setString(1, nomeServizio);
  297.                 updateStmt.setString(2, tipoServizio);
  298.                 updateStmt.setInt(3, versioneServizio);
  299.                 updateStmt.setLong(4, idSoggetto);

  301.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica recupero l'id del servizio appena creato : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, nomeServizio, tipoServizio, idSoggetto));
  302.                 updateRS = updateStmt.executeQuery();

  304.                 if (updateRS.next()) {
  305.                     idServizio = updateRS.getLong("id");
  306.                 }
  307.                 updateRS.close();
  308.                 updateStmt.close();

  310.                 if(idServizio<=0)
  311.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica(addFruitore)] id servizio non recuperato");
  312.                 asps.setId(idServizio);
  313.                                 
  314.                 
  315.                 // aggiungo fruitori
  316.                 sizeFruitori = asps.sizeFruitoreList();
  317.                 fruitore = null;
  318.                 for (int i = 0; i < sizeFruitori; i++) {
  319.                     fruitore = asps.getFruitore(i);
  320.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaFruitore(1, fruitore, con, asps, driverBYOK);
  321.                 }
  322.                 
  323.                 // aggiungo azioni
  324.                 if(asps.getConfigurazioneServizio()!=null){
  325.                     sizeAzioni = asps.getConfigurazioneServizio().sizeConfigurazioneAzioneList();
  326.                     for (int i = 0; i < sizeAzioni; i++) {
  327.                         ConfigurazioneServizioAzione conf = asps.getConfigurazioneServizio().getConfigurazioneAzione(i);
  328.                         DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaAzioni(1, conf, con, asps, driverBYOK);
  329.                     }
  330.                 }
  331.                 
  332.                 // Documenti generici servizio
  333.                 List<Documento> documenti = new ArrayList<>();
  334.                 // Allegati
  335.                 for(int i=0; i<asps.sizeAllegatoList(); i++){
  336.                     Documento doc = asps.getAllegato(i);
  337.                     doc.setRuolo(RuoliDocumento.allegato.toString());
  338.                     documenti.add(doc);
  339.                 }
  340.                 // Specifiche Semiformali
  341.                 for(int i=0; i<asps.sizeSpecificaSemiformaleList(); i++){
  342.                     Documento doc = asps.getSpecificaSemiformale(i);
  343.                     doc.setRuolo(RuoliDocumento.specificaSemiformale.toString());
  344.                     documenti.add(doc);
  345.                 }
  346.                 // Specifiche Livelli di Servizio
  347.                 for(int i=0; i<asps.sizeSpecificaLivelloServizioList(); i++){
  348.                     Documento doc = asps.getSpecificaLivelloServizio(i);
  349.                     doc.setRuolo(RuoliDocumento.specificaLivelloServizio.toString());
  350.                     documenti.add(doc);
  351.                 }
  352.                 // Specifiche Sicurezza
  353.                 for(int i=0; i<asps.sizeSpecificaSicurezzaList(); i++){
  354.                     Documento doc = asps.getSpecificaSicurezza(i);
  355.                     doc.setRuolo(RuoliDocumento.specificaSicurezza.toString());
  356.                     documenti.add(doc);
  357.                 }
  358.                 // CRUD
  359.                 DriverRegistroServiziDB_documentiLIB.CRUDDocumento(CostantiDB.CREATE, documenti, idServizio, ProprietariDocumento.servizio, con, tipoDatabase);
  360.                 

  362.                 // ProtocolProperties
  363.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.CREATE, asps.getProtocolPropertyList(), 
  364.                         idServizio, ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA, con, DriverRegistroServiziDB_LIB.tipoDB, driverBYOK);
  365.                 
  366.                 
  367.                 break;

  369.             case UPDATE:
  370.                 // UPDATE
  371.                 String oldNomeSoggetto = null;
  372.                 String oldTipoSoggetto = null;
  373.                 String oldNomeServizio = null;
  374.                 String oldTipoServizio = null;
  375.                 Integer oldVersioneServizio = null;
  376.                 if(asps.getOldIDServizioForUpdate()!=null){
  377.                     if(asps.getOldIDServizioForUpdate().getSoggettoErogatore()!=null){
  378.                         oldNomeSoggetto = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  379.                         oldTipoSoggetto = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo();
  380.                     }
  381.                     oldNomeServizio = asps.getOldIDServizioForUpdate().getNome();
  382.                     oldTipoServizio = asps.getOldIDServizioForUpdate().getTipo();
  383.                     oldVersioneServizio = asps.getOldIDServizioForUpdate().getVersione();
  384.                 }

  386.                 if (oldNomeServizio == null || oldNomeServizio.equals(""))
  387.                     oldNomeServizio = nomeServizio;
  388.                 if (oldTipoServizio == null || oldTipoServizio.equals(""))
  389.                     oldTipoServizio = tipoServizio;
  390.                 if (oldNomeSoggetto == null || oldNomeSoggetto.equals(""))
  391.                     oldNomeSoggetto = nomeProprietario;
  392.                 if (oldTipoSoggetto == null || oldTipoSoggetto.equals(""))
  393.                     oldTipoSoggetto = tipoProprietario;
  394.                 if (oldVersioneServizio == null)
  395.                     oldVersioneServizio = versioneServizio;

  397.                 //recupero id servizio
  398.                 idServizio = DBUtils.getIdServizio(oldNomeServizio, oldTipoServizio, oldVersioneServizio, oldNomeSoggetto, oldTipoSoggetto, con, DriverRegistroServiziDB_LIB.tipoDB);
  399.                 if (idServizio <= 0){
  400.                     // Puo' darsi che l'old soggetto e il nuovo soggetto siano la stesso soggetto della tabella. E' stato cambiato il nome.
  401.                     idServizio = DBUtils.getIdServizio(oldNomeServizio, oldTipoServizio, oldVersioneServizio, nomeProprietario, tipoProprietario, con, DriverRegistroServiziDB_LIB.tipoDB);
  402.                 }
  403.                 if (idServizio <= 0)
  404.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica(UPDATE)] Id Servizio non valido.");

  406.                 //recupero l'id del connettore
  407.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizio(oldNomeServizio, oldTipoServizio, oldVersioneServizio, oldNomeSoggetto, oldTipoSoggetto, con);
  408.                 if (idConnettore <= 0){
  409.                     // Puo' darsi che l'old soggetto e il nuovo soggetto siano la stesso soggetto della tabella. E' stato cambiato il nome.
  410.                     idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizio(oldNomeServizio, oldTipoServizio, oldVersioneServizio, nomeProprietario, tipoProprietario, con);
  411.                 }
  412.                 if (idConnettore <= 0)
  413.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] id connettore nullo.");
  414.                 connettore.setId(idConnettore);

  416.                 String utenteUltimaModifica = null;
  417.                 if(asps.getProprietaOggetto()!=null && asps.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  418.                     utenteUltimaModifica = asps.getProprietaOggetto().getUtenteUltimaModifica();
  419.                 }
  420.                 else {
  421.                     utenteUltimaModifica = superUser;
  422.                 }
  423.                 
  424.                 Timestamp dataUltimaModifica = null;
  425.                 if(asps.getProprietaOggetto()!=null && asps.getProprietaOggetto().getDataUltimaModifica()!=null) {
  426.                     dataUltimaModifica = new Timestamp(asps.getProprietaOggetto().getDataUltimaModifica().getTime());
  427.                 }
  428.                 /**else {
  429.                     dataUltimaModifica = DateManager.getTimestamp();
  430.                 } Se presente si aggiorna, altrimenti no, e si mantiene il precedente valore per gestire le modifiche delle fruizioni */ 
  431.                 
  432.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  433.                 sqlQueryObject.addUpdateTable(CostantiDB.SERVIZI);
  434.                 sqlQueryObject.addUpdateField("nome_servizio", "?");
  435.                 sqlQueryObject.addUpdateField("tipo_servizio", "?");
  436.                 sqlQueryObject.addUpdateField("versione_servizio", "?");
  437.                 sqlQueryObject.addUpdateField("id_soggetto", "?");
  438.                 sqlQueryObject.addUpdateField("id_accordo", "?");
  439.                 sqlQueryObject.addUpdateField("servizio_correlato", "?");
  440.                 sqlQueryObject.addUpdateField("id_connettore", "?");
  441.                 sqlQueryObject.addUpdateField("wsdl_implementativo_erogatore", "?");
  442.                 sqlQueryObject.addUpdateField("wsdl_implementativo_fruitore", "?");
  443.                 sqlQueryObject.addUpdateField("superuser", "?");
  444.                 sqlQueryObject.addUpdateField("privato", "?");
  445.                 sqlQueryObject.addUpdateField("port_type", "?");
  446.                 sqlQueryObject.addUpdateField("profilo", "?");
  447.                 sqlQueryObject.addUpdateField("descrizione", "?");
  448.                 if(stato!=null)
  449.                     sqlQueryObject.addUpdateField("stato", "?");
  450.                 if(asps.getOraRegistrazione()!=null)
  451.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  452.                 sqlQueryObject.addUpdateField("message_type", "?");
  453.                 if(utenteUltimaModifica!=null) {
  454.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  455.                 }
  456.                 if(dataUltimaModifica!=null) {
  457.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  458.                 }
  459.                 sqlQueryObject.addWhereCondition("id=?");
  460.                 updateQuery = sqlQueryObject.createSQLUpdate();
  461.                 updateStmt = con.prepareStatement(updateQuery);

  463.                 index = 1;
  464.                 
  465.                 updateStmt.setString(index++, nomeServizio);
  466.                 updateStmt.setString(index++, tipoServizio);
  467.                 updateStmt.setInt(index++, versioneServizio);
  468.                 updateStmt.setLong(index++, idSoggetto);
  469.                 updateStmt.setLong(index++, idAccordoLong);
  470.                 updateStmt.setString(index++, DriverRegistroServiziDB_LIB.getValue(servizioCorrelato));
  471.                 updateStmt.setLong(index++, idConnettore);
  472.                 updateStmt.setString(index++, wsdlImplementativoErogatore);
  473.                 updateStmt.setString(index++, wsdlImplementativoFruitore);
  474.                 updateStmt.setString(index++, superUser);
  475.                 if(asps.getPrivato()!=null && asps.getPrivato())
  476.                     updateStmt.setInt(index++, 1);
  477.                 else
  478.                     updateStmt.setInt(index++, 0);
  479.                 updateStmt.setString(index++, portType);
  480.                 updateStmt.setString(index++, asps.getVersioneProtocollo());
  481.                 updateStmt.setString(index++, descrizione);
  482.             
  483.                 if(stato!=null){
  484.                     updateStmt.setString(index++, stato);
  485.                 }
  486.                 
  487.                 if(asps.getOraRegistrazione()!=null){
  488.                     updateStmt.setTimestamp(index++, new Timestamp(asps.getOraRegistrazione().getTime()));
  489.                 }
  490.                 
  491.                 updateStmt.setString(index++, DriverRegistroServiziDB_LIB.getValue(asps.getMessageType()));
  492.     
  493.                 if(utenteUltimaModifica!=null) {
  494.                     updateStmt.setString(index++, utenteUltimaModifica);
  495.                 }
  496.                 
  497.                 if(dataUltimaModifica!=null) {
  498.                     updateStmt.setTimestamp(index++, dataUltimaModifica);
  499.                 }
  500.                 
  501.                 updateStmt.setLong(index++, idServizio);


  504.                 // eseguo lo statement
  505.                 n = updateStmt.executeUpdate();
  506.                 updateStmt.close();
  507.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica type = " + type + " row affected =" + n);
  508.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica UPDATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, nomeServizio, tipoServizio, idSoggetto, idAccordoLong, servizioCorrelato, idConnettore, wsdlImplementativoErogatore, wsdlImplementativoFruitore, superUser, idServizio));

  510.                 
  511.                 // aggiorno nome connettore
  512.                 String newNomeConnettore = "CNT_" + tipoProprietario+"/"+nomeProprietario +"_"+ tipoServizio + "/" +nomeServizio+ "/"+versioneServizio;
  513.                 connettore.setNome(newNomeConnettore);
  514.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(2, connettore, con, driverBYOK);

  516.                 
  517.                 //aggiorno fruitori
  518.                 //La lista dei fruitori del servizio contiene tutti e soli i fruitori di questo servizio
  519.                 //prima vengono cancellati i fruitori esistenti e poi vengono riaggiunti
  520.                 sizeFruitori = asps.sizeFruitoreList();
  521.                 fruitore = null;
  522.                 // NON POSSO: esistono i mapping
  523. //              //cancellazione
  524. /**             DriverRegistroServiziDB_LIB.deleteAllFruitoriServizio(idServizio, con);
  525. //              //creazione
  526. //              for (int i = 0; i < sizeFruitori; i++) {
  527. //                  fruitore = asps.getFruitore(i);
  528. //                  DriverRegistroServiziDB_LIB.CRUDAccordoServizioParteSpecificaFruitore(1, fruitore, con, servizio);
  529. //              }*/
  530.                 List<Long> idFruitoriEsistenti = new ArrayList<>();
  531.                 for (int i = 0; i < sizeFruitori; i++) {
  532.                     fruitore = asps.getFruitore(i);
  533.                     // i dati del servizio sono gia' stati modificati, devo usare i dati nuovi
  534.                     IDServizio idS = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, 
  535.                                             new IDSoggetto(tipoProprietario, nomeProprietario), versioneServizio);
  536.                     long idFruizione = DBUtils.getIdFruizioneServizio(idS, 
  537.                             new IDSoggetto(fruitore.getTipo(), fruitore.getNome()), con, tipoDatabase);
  538.                     int typeFruitore = 1; // create
  539.                     if(idFruizione>0){
  540.                         typeFruitore = 2; // update
  541.                     }
  542.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaFruitore(typeFruitore, fruitore, con, asps, driverBYOK);
  543.                     idFruitoriEsistenti.add(DBUtils.getIdSoggetto(fruitore.getNome(), fruitore.getTipo(), con, tipoDatabase));
  544.                 }
  545.                 DriverRegistroServiziDB_accordiParteSpecificaLIB.deleteAllFruitoriServizio(idServizio, idFruitoriEsistenti, con);
  546.     

  548.                 //aggiorno azioni
  549.                 //La lista delle azioni del servizio contiene tutti e soli le azioni di questo servizio
  550.                 //prima vengono cancellati le azioni esistenti e poi vengono riaggiunte
  551.                 if(asps.getConfigurazioneServizio()!=null){
  552.                     sizeAzioni = asps.getConfigurazioneServizio().sizeConfigurazioneAzioneList();
  553.                     //cancellazione
  554.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.deleteAllAzioniServizio(idServizio, con);
  555.                     //creazione
  556.                     for (int i = 0; i < sizeAzioni; i++) {
  557.                         ConfigurazioneServizioAzione conf = asps.getConfigurazioneServizio().getConfigurazioneAzione(i);
  558.                         DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaAzioni(1, conf, con, asps, driverBYOK);
  559.                     }
  560.                 }
  561.                 

  563.                 
  564.                 // Documenti generici servizio
  565.                 documenti = new ArrayList<>();
  566.                 // Allegati
  567.                 for(int i=0; i<asps.sizeAllegatoList(); i++){
  568.                     Documento doc = asps.getAllegato(i);
  569.                     doc.setRuolo(RuoliDocumento.allegato.toString());
  570.                     documenti.add(doc);
  571.                 }
  572.                 // Specifiche Semiformali
  573.                 for(int i=0; i<asps.sizeSpecificaSemiformaleList(); i++){
  574.                     Documento doc = asps.getSpecificaSemiformale(i);
  575.                     doc.setRuolo(RuoliDocumento.specificaSemiformale.toString());
  576.                     documenti.add(doc);
  577.                 }
  578.                 // Specifiche Livelli di Servizio
  579.                 for(int i=0; i<asps.sizeSpecificaLivelloServizioList(); i++){
  580.                     Documento doc = asps.getSpecificaLivelloServizio(i);
  581.                     doc.setRuolo(RuoliDocumento.specificaLivelloServizio.toString());
  582.                     documenti.add(doc);
  583.                 }
  584.                 // Specifiche Sicurezza
  585.                 for(int i=0; i<asps.sizeSpecificaSicurezzaList(); i++){
  586.                     Documento doc = asps.getSpecificaSicurezza(i);
  587.                     doc.setRuolo(RuoliDocumento.specificaSicurezza.toString());
  588.                     documenti.add(doc);
  589.                 }
  590.                 // CRUD
  591.                 DriverRegistroServiziDB_documentiLIB.CRUDDocumento(CostantiDB.UPDATE, documenti, idServizio, ProprietariDocumento.servizio, con, tipoDatabase);
  592.                 
  593.                 
  594.                 // ProtocolProperties
  595.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.UPDATE, asps.getProtocolPropertyList(), 
  596.                         idServizio, ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA, con, DriverRegistroServiziDB_LIB.tipoDB, driverBYOK);
  597.                 
  598.                 
  599.                 break;

  601.             case DELETE:
  602.                 // DELETE
  603.                 idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeProprietario, tipoProprietario, con, DriverRegistroServiziDB_LIB.tipoDB);
  604.                 if (idServizio <= 0)
  605.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica(DELETE)] Id Servizio non valido.");
  606.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizio(nomeServizio, tipoServizio, versioneServizio, nomeProprietario, tipoProprietario, con);
  607.                 if (idConnettore <= 0)
  608.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica(DELETE)] Id Connettore non valido.");

  610.                 //  elimino fruitori
  611.                 sizeFruitori = asps.sizeFruitoreList();
  612.                 fruitore = null;
  613.                 for (int i = 0; i < sizeFruitori; i++) {
  614.                     fruitore = asps.getFruitore(i);

  616.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaFruitore(3, fruitore, con, asps, driverBYOK);
  617.                 }
  618.                 
  619.                 // elimino azioni
  620.                 if(asps.getConfigurazioneServizio()!=null){
  621.                     sizeAzioni = asps.getConfigurazioneServizio().sizeConfigurazioneAzioneList();
  622.                     for (int i = 0; i < sizeAzioni; i++) {
  623.                         ConfigurazioneServizioAzione conf = asps.getConfigurazioneServizio().getConfigurazioneAzione(i);
  624.                         DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaAzioni(3, conf, con, asps, driverBYOK);
  625.                     }
  626.                 }

  628.                 
  629.                 // Documenti generici accordo di servizio
  630.                 // Allegati
  631.                 // Specifiche Semiformali
  632.                 // Specifiche Livelli di Servizio
  633.                 // Specifiche Sicurezza
  634.                 DriverRegistroServiziDB_documentiLIB.CRUDDocumento(CostantiDB.DELETE, null, idServizio, ProprietariDocumento.servizio, con, tipoDatabase);
  635.                 
  636.                 
  637.                 // ProtocolProperties
  638.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.DELETE, null, 
  639.                         idServizio, ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA, con, DriverRegistroServiziDB_LIB.tipoDB, driverBYOK);
  640.                 
  641.                 
  642.                 // Delete tabella informazioni digest
  643.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  644.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_DIGEST_PARAMS);
  645.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_DIGEST_PARAMS_COLUMN_ID_SERVIZIO_REF + "=?");
  646.                 try (PreparedStatement stmt = con.prepareStatement(sqlQueryObject.createSQLDelete())) {
  647.                     stmt.setLong(1, idServizio);
  648.                     n = stmt.executeUpdate();
  649.                 }

  651.                 
  652.                 // Delete servizio
  653.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  654.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI);
  655.                 sqlQueryObject.addWhereCondition("id=?");
  656.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  657.                 updateStmt = con.prepareStatement(sqlQuery);
  658.                 updateStmt.setLong(1, idServizio);
  659.                 n=updateStmt.executeUpdate();
  660.                 updateStmt.close();
  661.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica type = " + type + " row affected =" + n);
  662.                 // elimino connettore
  663.                 connettore=new Connettore();
  664.                 connettore.setId(idConnettore);
  665.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(CostantiDB.DELETE, connettore, con, driverBYOK);
  666.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecifica CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, idServizio));

  668.                 // nn cancello azioni nn interessa per adesso

  670.                 break;
  671.             }

  673.             return n;

  675.         } catch (CoreException e) {
  676.             throw new DriverRegistroServiziException(e);
  677.         } catch (SQLException se) {
  678.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] SQLException [" + se.getMessage() + "].", se);

  680.         } catch (Exception se) {
  681.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecifica] Exception [" + se.getMessage() + "].", se);

  683.         } finally {
  684.             JDBCUtilities.closeResources(updateRS, updateStmt);
  685.         }

  687.     }

  689.     /**
  690.      * Aggiunge un fruitore di un servizio alla lista dei fruitori dei servizi
  691.      * 
  692.      * @param type
  693.      * @param fruitore
  694.      * @param con
  695.      */
  696.     public static long CRUDAccordoServizioParteSpecificaFruitore(int type, Fruitore fruitore, Connection con, AccordoServizioParteSpecifica servizio, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  697.         PreparedStatement updateStmt = null;
  698.         String updateQuery;
  699.         PreparedStatement selectStmt = null;
  700.         String selectQuery = "";
  701.         ResultSet selectRS = null;

  703.         long idServizio = -1;
  704.         try{
  705.             String tipoServ = servizio.getTipo();
  706.             String nomeServ = servizio.getNome();
  707.             Integer verServ = servizio.getVersione();
  708.             String tipoSogg = servizio.getTipoSoggettoErogatore();
  709.             String nomeSogg = servizio.getNomeSoggettoErogatore();
  710.             
  711.             idServizio = DBUtils.getIdServizio(nomeServ, tipoServ, verServ, nomeSogg, tipoSogg, con, DriverRegistroServiziDB_LIB.tipoDB);
  712.         } catch (CoreException e1) {
  713.             DriverRegistroServiziDB_LIB.logError("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] getIdServizio failed: "+e1.getMessage(), e1);
  714.             throw new DriverRegistroServiziException(e1);
  715.         }

  717.         if (idServizio <= 0)
  718.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] ID Servizio non valido.");

  720.         Connettore connettore = fruitore.getConnettore();
  721.         if (connettore == null && type != CostantiDB.CREATE && type!=CostantiDB.DELETE)
  722.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] il connettore non puo essere nullo.");

  724.         String nomeSoggetto = fruitore.getNome();
  725.         String tipoSoggetto = fruitore.getTipo();
  726.         if (nomeSoggetto == null || nomeSoggetto.equals(""))
  727.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] Nome Fruitore non valido.");
  728.         if (tipoSoggetto == null || tipoSoggetto.equals(""))
  729.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] Tipo Fruitore non valido.");

  731.         String stato = fruitore.getStatoPackage();
  732.         
  733.         String descrizione = fruitore.getDescrizione();
  734.         
  735.         long idSoggettoFruitore = -1;
  736.         try {
  737.             idSoggettoFruitore = DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, DriverRegistroServiziDB_LIB.tipoDB);
  738.         } catch (CoreException e1) {
  739.             DriverRegistroServiziDB_LIB.logError("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] getIdSoggetto failed: "+e1.getMessage(), e1);
  740.             throw new DriverRegistroServiziException(e1);
  741.         }
  742.         if (idSoggettoFruitore <= 0)
  743.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore] Id Soggetto Fruitore non valido.");
  744.         String wsdlImplementativoErogatore = (fruitore.getByteWsdlImplementativoErogatore()!=null ? new String(fruitore.getByteWsdlImplementativoErogatore()) : null );
  745.         wsdlImplementativoErogatore = wsdlImplementativoErogatore!=null && !"".equals(wsdlImplementativoErogatore.trim().replaceAll("\n", "")) ? wsdlImplementativoErogatore : null;
  746.         String wsdlImplementativoFruitore =  (fruitore.getByteWsdlImplementativoFruitore()!=null ? new String(fruitore.getByteWsdlImplementativoFruitore()) : null );
  747.         wsdlImplementativoFruitore = wsdlImplementativoFruitore!=null && !"".equals(wsdlImplementativoFruitore.trim().replaceAll("\n", "")) ? wsdlImplementativoFruitore : null;
  748.         
  749.         long idFruizione = 0;
  750.         if (CostantiDB.CREATE != type) {
  751.             idFruizione = DriverRegistroServiziDB_LIB.getIdFruizione(idServizio, nomeSoggetto, tipoSoggetto, con);
  752.         }
  753.         
  754.         long idConnettore = 0;
  755.         long n = 0;
  756.         try {
  757.             switch (type) {
  758.             case 1:
  759.                 if (connettore == null) {
  760.                     connettore = new Connettore();
  761.                 }

  763.                 connettore.setNome("CNT_SF_" + tipoSoggetto+"/"+nomeSoggetto + "_" + servizio.getTipoSoggettoErogatore()+"/"+servizio.getNomeSoggettoErogatore() + "_" + 
  764.                         servizio.getTipo() +"/"+servizio.getNome()+"/"+servizio.getVersione());
  765.                 
  766.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(CostantiDB.CREATE, connettore, con, driverBYOK);
  767.                 idConnettore = connettore.getId();

  769.                 String utenteRichiedente = null;
  770.                 if(fruitore.getProprietaOggetto()!=null && fruitore.getProprietaOggetto().getUtenteRichiedente()!=null) {
  771.                     utenteRichiedente = fruitore.getProprietaOggetto().getUtenteRichiedente();
  772.                 }
  773.                 else {
  774.                     utenteRichiedente = DBUtils.getSuperUserServizioSafe(DriverRegistroServiziDB_LIB.log, "DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitore",
  775.                             idServizio, con, DriverRegistroServiziDB_LIB.tipoDB);
  776.                 }
  777.                 
  778.                 Timestamp dataCreazione = null;
  779.                 if(fruitore.getProprietaOggetto()!=null && fruitore.getProprietaOggetto().getDataCreazione()!=null) {
  780.                     dataCreazione = new Timestamp(fruitore.getProprietaOggetto().getDataCreazione().getTime());
  781.                 }
  782.                 else if(fruitore.getOraRegistrazione()!=null){
  783.                     dataCreazione = new Timestamp(fruitore.getOraRegistrazione().getTime());
  784.                 }
  785.                 else {
  786.                     dataCreazione = DateManager.getTimestamp();
  787.                 }
  788.                 
  789.                 // create
  790.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  791.                 sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_FRUITORI);
  792.                 sqlQueryObject.addInsertField("id_servizio", "?");
  793.                 sqlQueryObject.addInsertField("id_soggetto", "?");
  794.                 sqlQueryObject.addInsertField("id_connettore", "?");
  795.                 sqlQueryObject.addInsertField("wsdl_implementativo_erogatore", "?");
  796.                 sqlQueryObject.addInsertField("wsdl_implementativo_fruitore", "?");
  797.                 if(stato!=null)
  798.                     sqlQueryObject.addInsertField("stato", "?");
  799.                 if(fruitore.getOraRegistrazione()!=null)
  800.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  801.                 sqlQueryObject.addInsertField("descrizione", "?");
  802.                 if(utenteRichiedente!=null) {
  803.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  804.                 }
  805.                 if(dataCreazione!=null) {
  806.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  807.                 }
  808.                 updateQuery = sqlQueryObject.createSQLInsert();
  809.                 updateStmt = con.prepareStatement(updateQuery);

  811.                 updateStmt.setLong(1, idServizio);
  812.                 updateStmt.setLong(2, idSoggettoFruitore);
  813.                 updateStmt.setLong(3, idConnettore);
  814.                 updateStmt.setString(4, wsdlImplementativoErogatore);
  815.                 updateStmt.setString(5, wsdlImplementativoFruitore);
  816.                 
  817.                 int index = 6;
  818.                 
  819.                 if(stato!=null){
  820.                     updateStmt.setString(index, stato);
  821.                     index++;
  822.                 }
  823.                 if(fruitore.getOraRegistrazione()!=null){
  824.                     updateStmt.setTimestamp(index, new Timestamp(fruitore.getOraRegistrazione().getTime()));
  825.                     index++;
  826.                 }
  827.                 
  828.                 updateStmt.setString(index, descrizione);
  829.                 index++;
  830.                 
  831.                 if(utenteRichiedente!=null) {
  832.                     updateStmt.setString(index, utenteRichiedente);
  833.                     index++;
  834.                 }
  835.                 
  836.                 if(dataCreazione!=null) {
  837.                     updateStmt.setTimestamp(index, dataCreazione);
  838.                     index++;
  839.                 }

  841.                 n = updateStmt.executeUpdate();
  842.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitore CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, idServizio, idSoggettoFruitore, idConnettore, wsdlImplementativoErogatore, wsdlImplementativoFruitore));

  844.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  845.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  846.                 sqlQueryObject.addSelectField("id");
  847.                 sqlQueryObject.addWhereCondition("id_servizio = ?");
  848.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  849.                 sqlQueryObject.addWhereCondition("id_connettore = ?");
  850.                 sqlQueryObject.setANDLogicOperator(true);
  851.                 selectQuery = sqlQueryObject.createSQLQuery();
  852.                 selectStmt = con.prepareStatement(selectQuery);
  853.                 selectStmt.setLong(1, idServizio);
  854.                 selectStmt.setLong(2, idSoggettoFruitore);
  855.                 selectStmt.setLong(3, idConnettore);

  857.                 selectRS = selectStmt.executeQuery();
  858.                 if (selectRS.next())
  859.                     idFruizione = selectRS.getLong("id");
  860.                 
  861.                 
  862.                 // aggiungo azioni
  863.                 int sizeAzioni = fruitore.sizeConfigurazioneAzioneList();
  864.                 for (int i = 0; i < sizeAzioni; i++) {
  865.                     ConfigurazioneServizioAzione conf = fruitore.getConfigurazioneAzione(i);
  866.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaFruitoreAzioni(1, conf, con, servizio, fruitore, driverBYOK);
  867.                 }
  868.                 
  869.                 // ProtocolProperties
  870.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.UPDATE, fruitore.getProtocolPropertyList(), 
  871.                         idFruizione, ProprietariProtocolProperty.FRUITORE, con, DriverRegistroServiziDB_LIB.tipoDB, driverBYOK);
  872.                 
  873.                 break;

  875.             case 2:
  876.                 // update
  877.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizioFruitore(idServizio, nomeSoggetto, tipoSoggetto, con);
  878.                 if(idConnettore<0) throw new DriverRegistroServiziException("Il connettore del Fruitore del Servizio e' invalido id<0");
  879.                 connettore.setId(idConnettore);

  881.                 String utenteUltimaModifica = null;
  882.                 if(fruitore.getProprietaOggetto()!=null && fruitore.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  883.                     utenteUltimaModifica = fruitore.getProprietaOggetto().getUtenteUltimaModifica();
  884.                 }
  885.                 
  886.                 Timestamp dataUltimaModifica = null;
  887.                 if(fruitore.getProprietaOggetto()!=null && fruitore.getProprietaOggetto().getDataUltimaModifica()!=null) {
  888.                     dataUltimaModifica = new Timestamp(fruitore.getProprietaOggetto().getDataUltimaModifica().getTime());
  889.                 }
  890.                 /**else {
  891.                     dataUltimaModifica = DateManager.getTimestamp();
  892.                 }Se presente si aggiorna, altrimenti no, e si mantiene il precedente valore per gestire le modifiche delle fruizioni */ 
  893.                 
  894.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  895.                 sqlQueryObject.addUpdateTable(CostantiDB.SERVIZI_FRUITORI);
  896.                 sqlQueryObject.addUpdateField("wsdl_implementativo_erogatore", "?");
  897.                 sqlQueryObject.addUpdateField("wsdl_implementativo_fruitore", "?");
  898.                 if(stato!=null)
  899.                     sqlQueryObject.addUpdateField("stato", "?");
  900.                 if(fruitore.getOraRegistrazione()!=null)
  901.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  902.                 sqlQueryObject.addUpdateField("descrizione", "?");
  903.                 if(utenteUltimaModifica!=null) {
  904.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  905.                 }
  906.                 if(dataUltimaModifica!=null) {
  907.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  908.                 }
  909.                 sqlQueryObject.addWhereCondition("id_servizio=?");
  910.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  911.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  912.                 sqlQueryObject.setANDLogicOperator(true);
  913.                 updateQuery = sqlQueryObject.createSQLUpdate();
  914.                 updateStmt = con.prepareStatement(updateQuery);

  916.                 updateStmt.setString(1, wsdlImplementativoErogatore);
  917.                 updateStmt.setString(2, wsdlImplementativoFruitore);

  919.                 index = 3;
  920.                 
  921.                 if(stato!=null){
  922.                     updateStmt.setString(index, stato);
  923.                     index++;
  924.                 }
  925.                 
  926.                 if(fruitore.getOraRegistrazione()!=null){
  927.                     updateStmt.setTimestamp(index, new Timestamp(fruitore.getOraRegistrazione().getTime()));
  928.                     index++;
  929.                 }
  930.                 
  931.                 updateStmt.setString(index, descrizione);
  932.                 index++;
  933.                 
  934.                 if(utenteUltimaModifica!=null) {
  935.                     updateStmt.setString(index, utenteUltimaModifica);
  936.                     index++;
  937.                 }
  938.                 
  939.                 if(dataUltimaModifica!=null) {
  940.                     updateStmt.setTimestamp(index, dataUltimaModifica);
  941.                     index++;
  942.                 }
  943.                     
  944.                 updateStmt.setLong(index,idServizio);
  945.                 index++;
  946.                 updateStmt.setLong(index,idSoggettoFruitore);
  947.                 index++;
  948.                 updateStmt.setLong(index,idConnettore);
  949.                 index++;
  950.                 
  951.                 n= updateStmt.executeUpdate();
  952.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitore UPDATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, wsdlImplementativoErogatore, wsdlImplementativoFruitore, idServizio, idSoggettoFruitore, idConnettore));

  954.                 // modifico i dati del connettore
  955.                 //aggiorno nome
  956.                 DriverRegistroServiziDB_LIB.logDebug("Tento aggiornamento connettore id: ["+idConnettore+"] oldNome: ["+connettore.getNome()+"]...");
  957.                 String newNomeConnettore = "CNT_SF_" + tipoSoggetto+"/"+nomeSoggetto + "_" + servizio.getTipoSoggettoErogatore()+"/"+servizio.getNomeSoggettoErogatore() + "_" + 
  958.                         servizio.getTipo() +"/"+servizio.getNome()+"/"+servizio.getVersione();
  959.                 connettore.setNome(newNomeConnettore);
  960.                 DriverRegistroServiziDB_LIB.logDebug("nuovo nome connettore ["+newNomeConnettore+"]");
  961.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(2, connettore, con, driverBYOK);
  962.                 
  963.                 //aggiorno azioni
  964.                 //La lista delle azioni del servizio contiene tutti e soli le azioni di questo servizio
  965.                 //prima vengono cancellati le azioni esistenti e poi vengono riaggiunte
  966.                 sizeAzioni = fruitore.sizeConfigurazioneAzioneList();
  967.                 //cancellazione
  968.                 DriverRegistroServiziDB_accordiParteSpecificaLIB.deleteAllAzioniFruizioneServizio(idFruizione, con);
  969.                 //creazione
  970.                 for (int i = 0; i < sizeAzioni; i++) {
  971.                     ConfigurazioneServizioAzione conf = fruitore.getConfigurazioneAzione(i);
  972.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaFruitoreAzioni(1, conf, con, servizio, fruitore, driverBYOK);
  973.                 }
  974.                                 
  975.                 // ProtocolProperties
  976.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.UPDATE, fruitore.getProtocolPropertyList(), 
  977.                         idFruizione, ProprietariProtocolProperty.FRUITORE, con, DriverRegistroServiziDB_LIB.tipoDB, driverBYOK);
  978.                 
  979.                 break;

  981.             case 3:
  982.                 
  983.                 // ProtocolProperties
  984.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.DELETE, null, 
  985.                         idFruizione, ProprietariProtocolProperty.FRUITORE, con, DriverRegistroServiziDB_LIB.tipoDB, driverBYOK);
  986.                 
  987.                 
  988.                 // elimino azioni
  989.                 sizeAzioni = fruitore.sizeConfigurazioneAzioneList();
  990.                 for (int i = 0; i < sizeAzioni; i++) {
  991.                     ConfigurazioneServizioAzione conf = fruitore.getConfigurazioneAzione(i);
  992.                     DriverRegistroServiziDB_accordiParteSpecificaLIB.CRUDAccordoServizioParteSpecificaFruitoreAzioni(3, conf, con, servizio, fruitore, driverBYOK);
  993.                 }
  994.                 
  995.                 // delete
  996.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizioFruitore(idServizio, nomeSoggetto, tipoSoggetto, con);
  997.                 connettore.setId(idConnettore);
  998.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  999.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_FRUITORI);
  1000.                 sqlQueryObject.addWhereCondition("id_servizio=?");
  1001.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  1002.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  1003.                 sqlQueryObject.setANDLogicOperator(true);
  1004.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  1005.                 updateStmt = con.prepareStatement(sqlQuery);
  1006.                 updateStmt.setLong(1, idServizio);
  1007.                 updateStmt.setLong(2, idSoggettoFruitore);
  1008.                 updateStmt.setLong(3, idConnettore);
  1009.                 n=updateStmt.executeUpdate();
  1010.                 updateStmt.close();
  1011.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitore DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, idServizio, idSoggettoFruitore, idConnettore));

  1013.                 // elimino il connettore
  1014.                 connettore=new Connettore();
  1015.                 connettore.setId(idConnettore);
  1016.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(3, connettore, con, driverBYOK);

  1018.                 break;
  1019.             }

  1021.             DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitore type = " + type + " row affected =" + n);

  1023.             if (CostantiDB.CREATE == type) {
  1024.                 return idFruizione;
  1025.             }

  1027.             return n;

  1029.         } catch (SQLException se) {
  1030.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDFruitore] SQLException : " + se.getMessage(),se);
  1031.         }  catch (Exception se) {
  1032.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDFruitore] Exception : " + se.getMessage(),se);
  1033.         }finally {
  1034.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1035.             JDBCUtilities.closeResources(updateStmt);
  1036.         }
  1037.     }
  1038.     
  1039.     
  1040.     public static long CRUDAccordoServizioParteSpecificaAzioni(int type, ConfigurazioneServizioAzione conf, Connection con, AccordoServizioParteSpecifica servizio, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  1041.         PreparedStatement updateStmt = null;
  1042.         String updateQuery;
  1043.         PreparedStatement selectStmt = null;
  1044.         String selectQuery = "";
  1045.         ResultSet selectRS = null;

  1047.         long idServizio = -1;
  1048.         try{
  1049.             String tipoServ = servizio.getTipo();
  1050.             String nomeServ = servizio.getNome();
  1051.             Integer verServ = servizio.getVersione();
  1052.             String tipoSogg = servizio.getTipoSoggettoErogatore();
  1053.             String nomeSogg = servizio.getNomeSoggettoErogatore();
  1054.             
  1055.             idServizio = DBUtils.getIdServizio(nomeServ, tipoServ, verServ, nomeSogg, tipoSogg, con, DriverRegistroServiziDB_LIB.tipoDB);
  1056.         } catch (CoreException e1) {
  1057.             DriverRegistroServiziDB_LIB.logError("Driver Error.", e1);
  1058.             throw new DriverRegistroServiziException(e1);
  1059.         }

  1061.         if (idServizio <= 0)
  1062.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] ID Servizio non valido.");

  1064.         Connettore connettore = conf.getConnettore();
  1065.         if (connettore == null && type != CostantiDB.CREATE && type!=CostantiDB.DELETE)
  1066.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] il connettore non puo essere nullo.");

  1068.         if(conf.sizeAzioneList()<=0) {
  1069.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] la configurazione non contiene azioni??");
  1070.         }
  1071.         
  1072.         String azioneValue = conf.getAzione(0); // prendo la prima, tanto devono essere tutte diverse tra le varie configurazioni
  1073.         if (azioneValue == null || azioneValue.equals(""))
  1074.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] Azione non valida.");

  1076.         String nomeConnettore = "CNT_SAZIONE_" + servizio.getTipoSoggettoErogatore()+"/"+servizio.getNomeSoggettoErogatore() +"_"+ servizio.getTipo() +"/"+servizio.getNome()+"/"+servizio.getVersione()+"_"+azioneValue;
  1077.         if (connettore == null) {
  1078.             connettore = new Connettore();
  1079.         }
  1080.         connettore.setNome(nomeConnettore);
  1081.         
  1082.         long idConnettore = 0;
  1083.         long n = 0;
  1084.         try {
  1085.             switch (type) {
  1086.             case 1:
  1087.                 
  1088.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(CostantiDB.CREATE, connettore, con, driverBYOK);
  1089.                 idConnettore = connettore.getId();

  1091.                 // create
  1092.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1093.                 sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_AZIONI);
  1094.                 sqlQueryObject.addInsertField("id_servizio", "?");
  1095.                 sqlQueryObject.addInsertField("id_connettore", "?");
  1096.                 updateQuery = sqlQueryObject.createSQLInsert();
  1097.                 updateStmt = con.prepareStatement(updateQuery);
  1098.                 updateStmt.setLong(1, idServizio);
  1099.                 updateStmt.setLong(2, idConnettore);
  1100.                 n = updateStmt.executeUpdate();
  1101.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaAzioni CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, idServizio, idConnettore));
  1102.                 updateStmt.close();
  1103.                 
  1104.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1105.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_AZIONI);
  1106.                 sqlQueryObject.addSelectField("id");
  1107.                 sqlQueryObject.addWhereCondition("id_servizio = ?");
  1108.                 sqlQueryObject.addWhereCondition("id_connettore = ?"); // idconnettore sara' univoco!
  1109.                 sqlQueryObject.setANDLogicOperator(true);
  1110.                 selectQuery = sqlQueryObject.createSQLQuery();
  1111.                 selectStmt = con.prepareStatement(selectQuery);
  1112.                 selectStmt.setLong(1, idServizio);
  1113.                 selectStmt.setLong(2, idConnettore);
  1114.                 selectRS = selectStmt.executeQuery();
  1115.                 long idServizioAzione = -1;
  1116.                 if (selectRS.next()) {
  1117.                     idServizioAzione = selectRS.getLong("id");
  1118.                 }
  1119.                 selectRS.close();
  1120.                 selectStmt.close();
  1121.                 if(idServizioAzione<=0) {
  1122.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] Recuro id per idServizio["+idServizio+"] idConnettore["+idConnettore+"] non riuscito");
  1123.                 }
  1124.                 
  1125.                 for (String azione : conf.getAzioneList()) {
  1126.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1127.                     sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_AZIONE);
  1128.                     sqlQueryObject.addInsertField("nome_azione", "?");
  1129.                     sqlQueryObject.addInsertField("id_servizio_azioni", "?");
  1130.                     updateQuery = sqlQueryObject.createSQLInsert();
  1131.                     updateStmt = con.prepareStatement(updateQuery);
  1132.                     updateStmt.setString(1, azione);
  1133.                     updateStmt.setLong(2, idServizioAzione);
  1134.                     n = updateStmt.executeUpdate();
  1135.                     DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaAzione CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, azione, idServizioAzione));
  1136.                     updateStmt.close(); 
  1137.                 }
  1138.                 
  1139.                 break;

  1141.             case 2:
  1142.                 // update
  1143.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizioAzione(idServizio, azioneValue, con);
  1144.                 if(idConnettore<0) throw new DriverRegistroServiziException("Il connettore dell'azione ["+azioneValue+"] del Servizio e' invalido id<0");
  1145.                 connettore.setId(idConnettore);

  1147.                 // modifico i dati del connettore
  1148.                 //aggiorno nome
  1149.                 DriverRegistroServiziDB_LIB.logDebug("Tento aggiornamento connettore id: ["+idConnettore+"] oldNome: ["+connettore.getNome()+"]...");
  1150.                 DriverRegistroServiziDB_LIB.logDebug("nuovo nome connettore ["+connettore.getNome()+"]");
  1151.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(2, connettore, con, driverBYOK);

  1153.                 break;

  1155.             case 3:
  1156.                 // delete
  1157.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreServizioAzione(idServizio, azioneValue, con);
  1158.                 connettore.setId(idConnettore);
  1159.                 
  1160.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1161.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_AZIONI);
  1162.                 sqlQueryObject.addSelectField("id");
  1163.                 sqlQueryObject.addWhereCondition("id_servizio = ?");
  1164.                 sqlQueryObject.addWhereCondition("id_connettore = ?"); // idconnettore sara' univoco!
  1165.                 sqlQueryObject.setANDLogicOperator(true);
  1166.                 selectQuery = sqlQueryObject.createSQLQuery();
  1167.                 selectStmt = con.prepareStatement(selectQuery);
  1168.                 selectStmt.setLong(1, idServizio);
  1169.                 selectStmt.setLong(2, idConnettore);
  1170.                 selectRS = selectStmt.executeQuery();
  1171.                 idServizioAzione = -1;
  1172.                 if (selectRS.next()) {
  1173.                     idServizioAzione = selectRS.getLong("id");
  1174.                 }
  1175.                 selectRS.close();
  1176.                 selectStmt.close();
  1177.                 if(idServizioAzione<=0) {
  1178.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] Recuro id per idServizio["+idServizio+"] idConnettore["+idConnettore+"] non riuscito");
  1179.                 }
  1180.                     
  1181.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1182.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_AZIONE);
  1183.                 sqlQueryObject.addWhereCondition("id_servizio_azioni=?");
  1184.                 sqlQueryObject.setANDLogicOperator(true);
  1185.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  1186.                 updateStmt = con.prepareStatement(sqlQuery);
  1187.                 updateStmt.setLong(1, idServizioAzione);
  1188.                 n=updateStmt.executeUpdate();
  1189.                 updateStmt.close();
  1190.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaAzioni DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, idServizioAzione));

  1192.                 
  1193.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1194.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_AZIONI);
  1195.                 sqlQueryObject.addWhereCondition("id=?");
  1196.                 sqlQueryObject.setANDLogicOperator(true);
  1197.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1198.                 updateStmt = con.prepareStatement(sqlQuery);
  1199.                 updateStmt.setLong(1, idServizioAzione);
  1200.                 n=updateStmt.executeUpdate();
  1201.                 updateStmt.close();
  1202.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaAzioni DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery,idServizioAzione));

  1204.                 // elimino il connettore
  1205.                 connettore=new Connettore();
  1206.                 connettore.setId(idConnettore);
  1207.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(3, connettore, con, driverBYOK);

  1209.                 break;
  1210.             }

  1212.             DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaAzioni type = " + type + " row affected =" + n);

  1214.             return n;

  1216.         } catch (SQLException se) {
  1217.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] SQLException : " + se.getMessage(),se);
  1218.         }  catch (Exception se) {
  1219.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaAzioni] Exception : " + se.getMessage(),se);
  1220.         }finally {
  1221.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1222.             JDBCUtilities.closeResources(updateStmt);
  1223.         }
  1224.     }
  1225.     
  1226.     public static long CRUDAccordoServizioParteSpecificaFruitoreAzioni(int type, ConfigurazioneServizioAzione conf, Connection con, 
  1227.             AccordoServizioParteSpecifica servizio, Fruitore fruitore, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  1228.         PreparedStatement updateStmt = null;
  1229.         String updateQuery;
  1230.         PreparedStatement selectStmt = null;
  1231.         String selectQuery = "";
  1232.         ResultSet selectRS = null;
  1233.         
  1234.         long idFruizione = -1;
  1235.         try{
  1236.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(servizio); 
  1237.             IDSoggetto idFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  1238.             idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, DriverRegistroServiziDB_LIB.tipoDB);
  1239.         } catch (CoreException e1) {
  1240.             DriverRegistroServiziDB_LIB.logError("Driver Error.", e1);
  1241.             throw new DriverRegistroServiziException(e1);
  1242.         }
  1243.         if (idFruizione <= 0)
  1244.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] ID Servizio non valido.");
  1245.         
  1246.         Connettore connettore = conf.getConnettore();
  1247.         if (connettore == null && type != CostantiDB.CREATE && type!=CostantiDB.DELETE)
  1248.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] il connettore non puo essere nullo.");

  1250.         if(conf.sizeAzioneList()<=0) {
  1251.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] la configurazione non contiene azioni??");
  1252.         }
  1253.         
  1254.         String azioneValue = conf.getAzione(0); // prendo la prima, tanto devono essere tutte diverse tra le varie configurazioni
  1255.         if (azioneValue == null || azioneValue.equals(""))
  1256.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] Azione non valida.");

  1258.         String nomeConnettore = "CNT_SF_AZIONE_" + fruitore.getTipo()+"/"+fruitore.getNome()+"_"+  servizio.getTipoSoggettoErogatore()+"/"+servizio.getNomeSoggettoErogatore() +"_"+ servizio.getTipo() +"/"+servizio.getNome()+"/"+servizio.getVersione()+"_"+azioneValue;
  1259.         if (connettore == null) {
  1260.             connettore = new Connettore();
  1261.         }
  1262.         connettore.setNome(nomeConnettore);
  1263.         
  1264.         long idConnettore = 0;
  1265.         long n = 0;
  1266.         try {
  1267.             switch (type) {
  1268.             case 1:
  1269.                 
  1270.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(CostantiDB.CREATE, connettore, con, driverBYOK);
  1271.                 idConnettore = connettore.getId();

  1273.                 // create
  1274.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1275.                 sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1276.                 sqlQueryObject.addInsertField("id_fruizione", "?");
  1277.                 sqlQueryObject.addInsertField("id_connettore", "?");
  1278.                 updateQuery = sqlQueryObject.createSQLInsert();
  1279.                 updateStmt = con.prepareStatement(updateQuery);
  1280.                 updateStmt.setLong(1, idFruizione);
  1281.                 updateStmt.setLong(2, idConnettore);
  1282.                 n = updateStmt.executeUpdate();
  1283.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitoreAzioni CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, idFruizione, idConnettore));
  1284.                 updateStmt.close();
  1285.                 
  1286.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1287.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1288.                 sqlQueryObject.addSelectField("id");
  1289.                 sqlQueryObject.addWhereCondition("id_fruizione = ?");
  1290.                 sqlQueryObject.addWhereCondition("id_connettore = ?"); // idconnettore sara' univoco!
  1291.                 sqlQueryObject.setANDLogicOperator(true);
  1292.                 selectQuery = sqlQueryObject.createSQLQuery();
  1293.                 selectStmt = con.prepareStatement(selectQuery);
  1294.                 selectStmt.setLong(1, idFruizione);
  1295.                 selectStmt.setLong(2, idConnettore);
  1296.                 selectRS = selectStmt.executeQuery();
  1297.                 long idFruizioneAzione = -1;
  1298.                 if (selectRS.next()) {
  1299.                     idFruizioneAzione = selectRS.getLong("id");
  1300.                 }
  1301.                 selectRS.close();
  1302.                 selectStmt.close();
  1303.                 if(idFruizioneAzione<=0) {
  1304.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] Recuro id per idFruizione["+idFruizione+"] idConnettore["+idConnettore+"] non riuscito");
  1305.                 }
  1306.                 
  1307.                 for (String azione : conf.getAzioneList()) {
  1308.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1309.                     sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_FRUITORI_AZIONE);
  1310.                     sqlQueryObject.addInsertField("nome_azione", "?");
  1311.                     sqlQueryObject.addInsertField("id_fruizione_azioni", "?");
  1312.                     updateQuery = sqlQueryObject.createSQLInsert();
  1313.                     updateStmt = con.prepareStatement(updateQuery);
  1314.                     updateStmt.setString(1, azione);
  1315.                     updateStmt.setLong(2, idFruizioneAzione);
  1316.                     n = updateStmt.executeUpdate();
  1317.                     DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitoreAzioni CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, azione, idFruizioneAzione));
  1318.                     updateStmt.close(); 
  1319.                 }
  1320.                 
  1321.                 break;

  1323.             case 2:
  1324.                 // update
  1325.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreFruizioneServizioAzione(idFruizione, azioneValue, con);
  1326.                 if(idConnettore<0) throw new DriverRegistroServiziException("Il connettore dell'azione ["+azioneValue+"] della fruizione di Servizio e' invalido id<0");
  1327.                 connettore.setId(idConnettore);

  1329.                 // modifico i dati del connettore
  1330.                 //aggiorno nome
  1331.                 DriverRegistroServiziDB_LIB.logDebug("Tento aggiornamento connettore id: ["+idConnettore+"] oldNome: ["+connettore.getNome()+"]...");
  1332.                 DriverRegistroServiziDB_LIB.logDebug("nuovo nome connettore ["+connettore.getNome()+"]");
  1333.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(2, connettore, con, driverBYOK);

  1335.                 break;

  1337.             case 3:
  1338.                 // delete
  1339.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreFruizioneServizioAzione(idFruizione, azioneValue, con);
  1340.                 connettore.setId(idConnettore);
  1341.                 
  1342.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1343.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1344.                 sqlQueryObject.addSelectField("id");
  1345.                 sqlQueryObject.addWhereCondition("id_fruizione = ?");
  1346.                 sqlQueryObject.addWhereCondition("id_connettore = ?"); // idconnettore sara' univoco!
  1347.                 sqlQueryObject.setANDLogicOperator(true);
  1348.                 selectQuery = sqlQueryObject.createSQLQuery();
  1349.                 selectStmt = con.prepareStatement(selectQuery);
  1350.                 selectStmt.setLong(1, idFruizione);
  1351.                 selectStmt.setLong(2, idConnettore);
  1352.                 selectRS = selectStmt.executeQuery();
  1353.                 idFruizioneAzione = -1;
  1354.                 if (selectRS.next()) {
  1355.                     idFruizioneAzione = selectRS.getLong("id");
  1356.                 }
  1357.                 selectRS.close();
  1358.                 selectStmt.close();
  1359.                 if(idFruizioneAzione<=0) {
  1360.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] Recuro id per idFruizione["+idFruizione+"] idConnettore["+idConnettore+"] non riuscito");
  1361.                 }
  1362.                     
  1363.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1364.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_FRUITORI_AZIONE);
  1365.                 sqlQueryObject.addWhereCondition("id_fruizione_azioni=?");
  1366.                 sqlQueryObject.setANDLogicOperator(true);
  1367.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  1368.                 updateStmt = con.prepareStatement(sqlQuery);
  1369.                 updateStmt.setLong(1, idFruizioneAzione);
  1370.                 n=updateStmt.executeUpdate();
  1371.                 updateStmt.close();
  1372.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitoreAzioni DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, idFruizioneAzione));

  1374.                 
  1375.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1376.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1377.                 sqlQueryObject.addWhereCondition("id=?");
  1378.                 sqlQueryObject.setANDLogicOperator(true);
  1379.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1380.                 updateStmt = con.prepareStatement(sqlQuery);
  1381.                 updateStmt.setLong(1, idFruizioneAzione);
  1382.                 n=updateStmt.executeUpdate();
  1383.                 updateStmt.close();
  1384.                 DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitoreAzioni DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery,idFruizioneAzione));

  1386.                 // elimino il connettore
  1387.                 connettore=new Connettore();
  1388.                 connettore.setId(idConnettore);
  1389.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(3, connettore, con, driverBYOK);

  1391.                 break;
  1392.             }

  1394.             DriverRegistroServiziDB_LIB.logDebug("CRUDAccordoServizioParteSpecificaFruitoreAzioni type = " + type + " row affected =" + n);

  1396.             return n;

  1398.         } catch (SQLException se) {
  1399.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] SQLException : " + se.getMessage(),se);
  1400.         }  catch (Exception se) {
  1401.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioParteSpecificaFruitoreAzioni] Exception : " + se.getMessage(),se);
  1402.         }finally {
  1403.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1404.             JDBCUtilities.closeResources(updateStmt);
  1405.         }
  1406.     }

  1408.     
  1409.     /**
  1410.      * Cancella tutti i fruitori di un servizio e i connettori associati ai fruitori
  1411.      * @param idServizio
  1412.      * @param con
  1413.      * @throws DriverRegistroServiziException
  1414.      */
  1415.     private static void deleteAllFruitoriServizio(long idServizio, List<Long> idFruitoriEsistenti, Connection con) throws DriverRegistroServiziException {
  1416.         PreparedStatement stm = null;
  1417.         ResultSet rs = null;
  1418.         try {

  1420.             ArrayList<Long> listaFruizioniDaEliminare = new ArrayList<>();
  1421.             ArrayList<Long> listaFruizioniDaEliminareConnettori = new ArrayList<>();

  1423.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1424.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1425.             sqlQueryObject.addSelectField("*");
  1426.             sqlQueryObject.addWhereCondition("id_servizio = ?");
  1427.             String query = sqlQueryObject.createSQLQuery();
  1428.             stm = con.prepareStatement(query);
  1429.             stm.setLong(1, idServizio);

  1431.             rs=stm.executeQuery();
  1432.             //recupero i connettori da cancellare
  1433.             while(rs.next()){
  1434.                 long idSoggettoFruitore = rs.getLong("id_soggetto");
  1435.                 boolean find = false;
  1436.                 for (int i = 0; i < idFruitoriEsistenti.size(); i++) {
  1437.                     if(idSoggettoFruitore == idFruitoriEsistenti.get(i)){
  1438.                         find = true;
  1439.                         break;
  1440.                     }
  1441.                 }
  1442.                 if(!find){
  1443.                     listaFruizioniDaEliminare.add(rs.getLong("id"));
  1444.                     listaFruizioniDaEliminareConnettori.add(rs.getLong("id_connettore"));
  1445.                 }
  1446.             }
  1447.             rs.close();
  1448.             stm.close();

  1450.             for (int i = 0; i < listaFruizioniDaEliminare.size(); i++) {
  1451.             
  1452.                 long idFruizione = listaFruizioniDaEliminare.get(i);
  1453.                 
  1454.                 // ProtocolProperties
  1455.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.DELETE, null, 
  1456.                         idFruizione, ProprietariProtocolProperty.FRUITORE, con, DriverRegistroServiziDB_LIB.tipoDB, null);
  1457.                 
  1458.                 //cancellazione azioni
  1459.                 DriverRegistroServiziDB_accordiParteSpecificaLIB.deleteAllAzioniFruizioneServizio(idFruizione, con);
  1460.                 
  1461.                 //elimino prima le entry nella tab servizi_fruitori per rispettare le dipendenze
  1462.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1463.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_FRUITORI);
  1464.                 sqlQueryObject.addWhereCondition("id=?");
  1465.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  1466.                 stm = con.prepareStatement(sqlQuery);
  1467.                 stm.setLong(1, idFruizione);
  1468.                 int n=stm.executeUpdate();
  1469.                 stm.close();
  1470.                 DriverRegistroServiziDB_LIB.logDebug("Cancellata (row:"+n+") fruizione con id:"+idFruizione);
  1471.     
  1472.             }
  1473.             
  1474.             for (int i = 0; i < listaFruizioniDaEliminareConnettori.size(); i++) {
  1475.                 
  1476.                 long idFruizione = listaFruizioniDaEliminare.get(i);
  1477.                 long idConnettore = listaFruizioniDaEliminareConnettori.get(i);
  1478.                 
  1479.                 //cancello adesso i connettori custom
  1480.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1481.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  1482.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  1483.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  1484.                 stm = con.prepareStatement(sqlQuery);
  1485.                 stm.setLong(1, idConnettore);
  1486.                 stm.executeUpdate();
  1487.                 stm.close();
  1488.                 DriverRegistroServiziDB_LIB.logDebug("Cancellato connettore custom associato al connettore con id:"+idConnettore+" associato alla fruizione con id:"+idFruizione);
  1489.                 
  1490.                 //cancello adesso i connettori
  1491.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1492.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI);
  1493.                 sqlQueryObject.addWhereCondition("id=?");
  1494.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1495.                 stm = con.prepareStatement(sqlQuery);
  1496.                 stm.setLong(1, idConnettore);
  1497.                 stm.executeUpdate();
  1498.                 stm.close();
  1499.                 DriverRegistroServiziDB_LIB.logDebug("Cancellati connettoro con id:"+idConnettore+" associato alla fruizione con id:"+idFruizione);
  1500.                 
  1501.             }



  1505.         } catch (SQLException e) {
  1506.             DriverRegistroServiziDB_LIB.logError("Errore SQL", e);
  1507.             throw new DriverRegistroServiziException(e);
  1508.         }catch (Exception e) {
  1509.             DriverRegistroServiziDB_LIB.logError("Errore", e);
  1510.             throw new DriverRegistroServiziException(e);
  1511.         } finally {
  1512.             JDBCUtilities.closeResources(stm);
  1513.         }
  1514.     }
  1515.     
  1516.     
  1517.     /**
  1518.      * Cancella tutti le azioni di un servizio e i connettori associati alle azioni
  1519.      * @param idServizio
  1520.      * @param con
  1521.      * @throws DriverRegistroServiziException
  1522.      */
  1523.     private static void deleteAllAzioniServizio(long idServizio, Connection con) throws DriverRegistroServiziException {
  1524.         PreparedStatement stm = null;
  1525.         ResultSet rs = null;
  1526.         try {

  1528.             ArrayList<Long> listaConnettori = new ArrayList<>();
  1529.             ArrayList<Long> listaConfigurazioni = new ArrayList<>();

  1531.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1532.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_AZIONI);
  1533.             sqlQueryObject.addSelectField("*");
  1534.             sqlQueryObject.addWhereCondition("id_servizio = ?");
  1535.             String query = sqlQueryObject.createSQLQuery();
  1536.             stm = con.prepareStatement(query);
  1537.             stm.setLong(1, idServizio);

  1539.             rs=stm.executeQuery();
  1540.             //recupero i connettori da cancellare
  1541.             while(rs.next()){
  1542.                 listaConnettori.add(rs.getLong("id_connettore"));
  1543.                 listaConfigurazioni.add(rs.getLong("id"));
  1544.             }
  1545.             rs.close();
  1546.             stm.close();

  1548.             //elimino prima le entry nella tab servizi_azione per rispettare le dipendenze
  1549.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1550.             sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_AZIONE);
  1551.             sqlQueryObject.addWhereCondition("id_servizio_azioni=?");
  1552.             String sqlQuery = sqlQueryObject.createSQLDelete();
  1553.             stm = con.prepareStatement(sqlQuery);
  1554.             for (Long idConfigurazione : listaConfigurazioni) {
  1555.                 stm.setLong(1, idConfigurazione);
  1556.                 int n=stm.executeUpdate();
  1557.                 DriverRegistroServiziDB_LIB.logDebug("Cancellati "+n+" Azioni della configurazione del servizio "+idConfigurazione);
  1558.             }
  1559.             stm.close();
  1560.                         
  1561.             //elimino prima le entry nella tab servizi_azioni per rispettare le dipendenze
  1562.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1563.             sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_AZIONI);
  1564.             sqlQueryObject.addWhereCondition("id_servizio=?");
  1565.             sqlQuery = sqlQueryObject.createSQLDelete();
  1566.             stm = con.prepareStatement(sqlQuery);
  1567.             stm.setLong(1, idServizio);
  1568.             int n=stm.executeUpdate();
  1569.             stm.close();
  1570.             DriverRegistroServiziDB_LIB.logDebug("Cancellati "+n+" Azioni del servizio "+idServizio);

  1572.             //cancello adesso i connettori custom
  1573.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1574.             sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  1575.             sqlQueryObject.addWhereCondition("id_connettore=?");
  1576.             sqlQuery = sqlQueryObject.createSQLDelete();
  1577.             stm = con.prepareStatement(sqlQuery);
  1578.             for (Long idConnettore : listaConnettori) {
  1579.                 stm.setLong(1, idConnettore);
  1580.                 stm.executeUpdate();
  1581.             }
  1582.             stm.close();
  1583.             DriverRegistroServiziDB_LIB.logDebug("Cancellati connettori "+listaConnettori.toString()+" associati alle azioni del servizio "+idServizio);
  1584.             
  1585.             //cancello adesso i connettori
  1586.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1587.             sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI);
  1588.             sqlQueryObject.addWhereCondition("id=?");
  1589.             sqlQuery = sqlQueryObject.createSQLDelete();
  1590.             stm = con.prepareStatement(sqlQuery);
  1591.             for (Long idConnettore : listaConnettori) {
  1592.                 stm.setLong(1, idConnettore);
  1593.                 stm.executeUpdate();
  1594.             }
  1595.             stm.close();
  1596.             DriverRegistroServiziDB_LIB.logDebug("Cancellati connettori "+listaConnettori.toString()+" associati ai Fruitori del servizio "+idServizio);



  1600.         } catch (SQLException e) {
  1601.             DriverRegistroServiziDB_LIB.logError("Errore SQL", e);
  1602.             throw new DriverRegistroServiziException(e);
  1603.         }catch (Exception e) {
  1604.             DriverRegistroServiziDB_LIB.logError("Errore", e);
  1605.             throw new DriverRegistroServiziException(e);
  1606.         } finally {
  1607.             JDBCUtilities.closeResources(stm);
  1608.         }
  1609.     }

  1611.     
  1612.     private static void deleteAllAzioniFruizioneServizio(long idFruizione, Connection con) throws DriverRegistroServiziException {
  1613.         PreparedStatement stm = null;
  1614.         ResultSet rs = null;
  1615.         try {

  1617.             ArrayList<Long> listaConnettori = new ArrayList<>();
  1618.             ArrayList<Long> listaConfigurazioni = new ArrayList<>();

  1620.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1621.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1622.             sqlQueryObject.addSelectField("*");
  1623.             sqlQueryObject.addWhereCondition("id_fruizione = ?");
  1624.             String query = sqlQueryObject.createSQLQuery();
  1625.             stm = con.prepareStatement(query);
  1626.             stm.setLong(1, idFruizione);

  1628.             rs=stm.executeQuery();
  1629.             //recupero i connettori da cancellare
  1630.             while(rs.next()){
  1631.                 listaConnettori.add(rs.getLong("id_connettore"));
  1632.                 listaConfigurazioni.add(rs.getLong("id"));
  1633.             }
  1634.             rs.close();
  1635.             stm.close();

  1637.             //elimino prima le entry nella tab servizi_azione per rispettare le dipendenze
  1638.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1639.             sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_FRUITORI_AZIONE);
  1640.             sqlQueryObject.addWhereCondition("id_fruizione_azioni=?");
  1641.             String sqlQuery = sqlQueryObject.createSQLDelete();
  1642.             stm = con.prepareStatement(sqlQuery);
  1643.             for (Long idConfigurazione : listaConfigurazioni) {
  1644.                 stm.setLong(1, idConfigurazione);
  1645.                 int n=stm.executeUpdate();
  1646.                 DriverRegistroServiziDB_LIB.logDebug("Cancellati "+n+" Azioni della configurazione della fruizione del servizio "+idConfigurazione);
  1647.             }
  1648.             stm.close();
  1649.                         
  1650.             //elimino prima le entry nella tab servizi_azioni per rispettare le dipendenze
  1651.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1652.             sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1653.             sqlQueryObject.addWhereCondition("id_fruizione=?");
  1654.             sqlQuery = sqlQueryObject.createSQLDelete();
  1655.             stm = con.prepareStatement(sqlQuery);
  1656.             stm.setLong(1, idFruizione);
  1657.             int n=stm.executeUpdate();
  1658.             stm.close();
  1659.             DriverRegistroServiziDB_LIB.logDebug("Cancellati "+n+" Azioni della fruizione del servizio "+idFruizione);

  1661.             //cancello adesso i connettori custom
  1662.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1663.             sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  1664.             sqlQueryObject.addWhereCondition("id_connettore=?");
  1665.             sqlQuery = sqlQueryObject.createSQLDelete();
  1666.             stm = con.prepareStatement(sqlQuery);
  1667.             for (Long idConnettore : listaConnettori) {
  1668.                 stm.setLong(1, idConnettore);
  1669.                 stm.executeUpdate();
  1670.             }
  1671.             stm.close();
  1672.             DriverRegistroServiziDB_LIB.logDebug("Cancellati connettori "+listaConnettori.toString()+" associati alle azioni della fruizione del servizio "+idFruizione);
  1673.             
  1674.             //cancello adesso i connettori
  1675.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1676.             sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI);
  1677.             sqlQueryObject.addWhereCondition("id=?");
  1678.             sqlQuery = sqlQueryObject.createSQLDelete();
  1679.             stm = con.prepareStatement(sqlQuery);
  1680.             for (Long idConnettore : listaConnettori) {
  1681.                 stm.setLong(1, idConnettore);
  1682.                 stm.executeUpdate();
  1683.             }
  1684.             stm.close();
  1685.             DriverRegistroServiziDB_LIB.logDebug("Cancellati connettori "+listaConnettori.toString()+" associati ai Fruitori della fruizione del servizio "+idFruizione);



  1689.         } catch (SQLException e) {
  1690.             DriverRegistroServiziDB_LIB.logError("Errore SQL", e);
  1691.             throw new DriverRegistroServiziException(e);
  1692.         }catch (Exception e) {
  1693.             DriverRegistroServiziDB_LIB.logError("Errore", e);
  1694.             throw new DriverRegistroServiziException(e);
  1695.         } finally {
  1696.             JDBCUtilities.closeResources(stm);
  1697.         }
  1698.     }
  1699.     
  1700.     
  1701. }
Created with JaCoCo 0.8.8.202204050719