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.                 if(CostantiDB.isServiziDigestEnabled()) {
  644.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  645.                     sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_DIGEST_PARAMS);
  646.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_DIGEST_PARAMS_COLUMN_ID_SERVIZIO_REF + "=?");
  647.                     try (PreparedStatement stmt = con.prepareStatement(sqlQueryObject.createSQLDelete())) {
  648.                         stmt.setLong(1, idServizio);
  649.                         n = stmt.executeUpdate();
  650.                     }
  651.                 }

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

  670.                 // nn cancello azioni nn interessa per adesso

  672.                 break;
  673.             }

  675.             return n;

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

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

  685.         } finally {
  686.             JDBCUtilities.closeResources(updateRS, updateStmt);
  687.         }

  689.     }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  918.                 updateStmt.setString(1, wsdlImplementativoErogatore);
  919.                 updateStmt.setString(2, wsdlImplementativoFruitore);

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

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

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

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

  1020.                 break;
  1021.             }

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

  1025.             if (CostantiDB.CREATE == type) {
  1026.                 return idFruizione;
  1027.             }

  1029.             return n;

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

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

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

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

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

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

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

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

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

  1155.                 break;

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

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

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

  1211.                 break;
  1212.             }

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

  1216.             return n;

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

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

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

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

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

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

  1337.                 break;

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

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

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

  1393.                 break;
  1394.             }

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

  1398.             return n;

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

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

  1422.             ArrayList<Long> listaFruizioniDaEliminare = new ArrayList<>();
  1423.             ArrayList<Long> listaFruizioniDaEliminareConnettori = new ArrayList<>();

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

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

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



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

  1530.             ArrayList<Long> listaConnettori = new ArrayList<>();
  1531.             ArrayList<Long> listaConfigurazioni = new ArrayList<>();

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

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

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

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



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

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

  1619.             ArrayList<Long> listaConnettori = new ArrayList<>();
  1620.             ArrayList<Long> listaConfigurazioni = new ArrayList<>();

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

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

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

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



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