DriverConfigurazioneDB_serviziApplicativiLIB.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.core.config.driver.db;

  22. import static org.openspcoop2.core.constants.CostantiDB.CREATE;
  23. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  24. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.sql.Timestamp;
  31. import java.text.MessageFormat;
  32. import java.util.List;

  34. import org.openspcoop2.core.byok.BYOKUtilities;
  35. import org.openspcoop2.core.byok.BYOKWrappedValue;
  36. import org.openspcoop2.core.byok.IDriverBYOK;
  37. import org.openspcoop2.core.commons.CoreException;
  38. import org.openspcoop2.core.commons.DBUtils;
  39. import org.openspcoop2.core.config.Connettore;
  40. import org.openspcoop2.core.config.Credenziali;
  41. import org.openspcoop2.core.config.InvocazioneCredenziali;
  42. import org.openspcoop2.core.config.InvocazionePorta;
  43. import org.openspcoop2.core.config.InvocazionePortaGestioneErrore;
  44. import org.openspcoop2.core.config.InvocazioneServizio;
  45. import org.openspcoop2.core.config.Proprieta;
  46. import org.openspcoop2.core.config.RispostaAsincrona;
  47. import org.openspcoop2.core.config.Ruolo;
  48. import org.openspcoop2.core.config.ServizioApplicativo;
  49. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  50. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  51. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  52. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  53. import org.openspcoop2.core.constants.CostantiDB;
  54. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  55. import org.openspcoop2.core.constants.TipiConnettore;
  56. import org.openspcoop2.utils.certificate.CertificateUtils;
  57. import org.openspcoop2.utils.certificate.PrincipalType;
  58. import org.openspcoop2.utils.date.DateManager;
  59. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  60. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  61. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  62. import org.openspcoop2.utils.sql.ISQLQueryObject;
  63. import org.openspcoop2.utils.sql.SQLObjectFactory;

  65. /**
  66.  * DriverConfigurazioneDB_serviziApplicativiLIB
  67.  * 
  68.  * @author Stefano Corallo - corallo@link.it
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  */
  72. public class DriverConfigurazioneDB_serviziApplicativiLIB {


  75.     
  76.     /**
  77.      * 
  78.      * @param type
  79.      * @param aSA
  80.      * @param con
  81.      * @return id
  82.      * @throws DriverConfigurazioneException
  83.      */
  84.     public static long CRUDServizioApplicativo(int type, ServizioApplicativo aSA, Connection con, IDriverBYOK driverBYOK) throws DriverConfigurazioneException {
  85.         if (aSA == null)
  86.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo] Servizio Applicativo non valido.");

  88.         String nomeSA = aSA.getNome();
  89.         String tipoProprietario = aSA.getTipoSoggettoProprietario();
  90.         String nomeProprietario = aSA.getNomeSoggettoProprietario();

  92.         if (nomeSA == null || nomeSA.equals(""))
  93.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo] Nome Servizio Applicativo non valido.");
  94.         if (tipoProprietario == null || tipoProprietario.equals(""))
  95.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo] Tipo Proprietario Servizio Applicativo non valido.");
  96.         if (nomeProprietario == null || nomeProprietario.equals(""))
  97.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo] Nome Proprietario Servizio Applicativo non valido.");

  99.         PreparedStatement stm = null;
  100.         String sqlQuery;
  101.         PreparedStatement stmQuery = null;
  102.         ResultSet rs = null;
  103.         PreparedStatement stm2 = null;
  104.         int n = 0;

  106.         try {
  107.             String tipoSA = aSA.getTipo();
  108.             int useAsClient = aSA.getUseAsClient() ? CostantiDB.TRUE : CostantiDB.FALSE;
  109.             String descrizione = aSA.getDescrizione();
  110.             DriverConfigurazioneDBLib.logDebug("get ID Soggetto con tipo["+tipoProprietario+"] e nome["+nomeProprietario+"]");
  111.             long idProprietario = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  112.             DriverConfigurazioneDBLib.logDebug("get ID Soggetto con tipo["+tipoProprietario+"] e nome["+nomeProprietario+"] : "+idProprietario);
  113.             InvocazionePorta invPorta = aSA.getInvocazionePorta();
  114.             InvocazioneServizio invServizio = aSA.getInvocazioneServizio();
  115.             RispostaAsincrona ricezione = aSA.getRispostaAsincrona();
  116.             List<Proprieta> proprieta = aSA.getProprietaList();

  118.             Connettore connettoreRisp = null;
  119.             Connettore connettoreInv = null;
  120.             long idConnettoreRisp = 0;
  121.             long idConnettoreInv = 0;
  122.             long idServizioApplicativo = 0;
  123.             Credenziali credenzialiInvocazionePorta = null;
  124.             InvocazioneCredenziali credenzialiInvocazione = null;
  125.             InvocazionePortaGestioneErrore gestErr = null;
  126.             String fault = null;

  128.             switch (type) {
  129.             case CREATE:
  130.                 
  131.                 String utenteRichiedente = null;
  132.                 if(aSA.getProprietaOggetto()!=null && aSA.getProprietaOggetto().getUtenteRichiedente()!=null) {
  133.                     utenteRichiedente = aSA.getProprietaOggetto().getUtenteRichiedente();
  134.                 }
  135.                 else {
  136.                     utenteRichiedente = DBUtils.getSuperUserSoggettoSafe(DriverConfigurazioneDBLib.log, "CRUDPortaApplicativa",
  137.                             idProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  138.                 }
  139.                 
  140.                 Timestamp dataCreazione = null;
  141.                 if(aSA.getProprietaOggetto()!=null && aSA.getProprietaOggetto().getDataCreazione()!=null) {
  142.                     dataCreazione = new Timestamp(aSA.getProprietaOggetto().getDataCreazione().getTime());
  143.                 }
  144.                 else if(aSA.getOraRegistrazione()!=null){
  145.                     dataCreazione = new Timestamp(aSA.getOraRegistrazione().getTime());
  146.                 }
  147.                 else {
  148.                     dataCreazione = DateManager.getTimestamp();
  149.                 }
  150.                 
  151.                 // create
  152.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  153.                 sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI);
  154.                 sqlQueryObject.addInsertField("nome", "?");
  155.                 sqlQueryObject.addInsertField("tipo", "?");
  156.                 sqlQueryObject.addInsertField("as_client", "?");
  157.                 sqlQueryObject.addInsertField("descrizione", "?");
  158.                 sqlQueryObject.addInsertField("sbustamentorisp", "?");
  159.                 sqlQueryObject.addInsertField("sbustamento_protocol_info_risp", "?");
  160.                 sqlQueryObject.addInsertField("getmsgrisp", "?");
  161.                 sqlQueryObject.addInsertField("tipoauthrisp", "?");
  162.                 sqlQueryObject.addInsertField("utenterisp", "?");
  163.                 sqlQueryObject.addInsertField("passwordrisp", "?");
  164.                 sqlQueryObject.addInsertField("enc_passwordrisp", "?");
  165.                 sqlQueryObject.addInsertField("id_connettore_risp", "?");
  166.                 sqlQueryObject.addInsertField("sbustamentoinv", "?");
  167.                 sqlQueryObject.addInsertField("sbustamento_protocol_info_inv", "?");
  168.                 sqlQueryObject.addInsertField("getmsginv", "?");
  169.                 sqlQueryObject.addInsertField("tipoauthinv", "?");
  170.                 sqlQueryObject.addInsertField("utenteinv", "?");
  171.                 sqlQueryObject.addInsertField("passwordinv", "?");
  172.                 sqlQueryObject.addInsertField("enc_passwordinv", "?");
  173.                 sqlQueryObject.addInsertField("id_connettore_inv", "?");
  174.                 sqlQueryObject.addInsertField("id_soggetto", "?");
  175.                 sqlQueryObject.addInsertField("fault", "?");
  176.                 sqlQueryObject.addInsertField("tipoauth", "?");
  177.                 sqlQueryObject.addInsertField("utente", "?");
  178.                 sqlQueryObject.addInsertField("password", "?");
  179.                 sqlQueryObject.addInsertField("subject", "?");
  180.                 sqlQueryObject.addInsertField("cn_subject", "?");
  181.                 sqlQueryObject.addInsertField("issuer", "?");
  182.                 sqlQueryObject.addInsertField("cn_issuer", "?");
  183.                 sqlQueryObject.addInsertField("certificate", "?");
  184.                 sqlQueryObject.addInsertField("cert_strict_verification", "?");
  185.                 sqlQueryObject.addInsertField("token_policy", "?");
  186.                 sqlQueryObject.addInsertField("invio_x_rif_inv", "?");
  187.                 sqlQueryObject.addInsertField("risposta_x_rif_inv", "?");
  188.                 sqlQueryObject.addInsertField("invio_x_rif", "?");
  189.                 sqlQueryObject.addInsertField("invio_x_rif_risp", "?");
  190.                 sqlQueryObject.addInsertField("risposta_x_rif_risp", "?");
  191.                 sqlQueryObject.addInsertField("sbustamento_protocol_info", "?");
  192.                 sqlQueryObject.addInsertField("fault_actor", "?");
  193.                 sqlQueryObject.addInsertField("generic_fault_code", "?");
  194.                 sqlQueryObject.addInsertField("prefix_fault_code", "?");
  195.                 sqlQueryObject.addInsertField("tipologia_fruizione", "?");
  196.                 sqlQueryObject.addInsertField("tipologia_erogazione", "?");
  197.                 if(utenteRichiedente!=null) {
  198.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  199.                 }
  200.                 if(dataCreazione!=null) {
  201.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  202.                 }
  203.                 sqlQuery = sqlQueryObject.createSQLInsert();
  204.                 stm = con.prepareStatement(sqlQuery);

  206.                 // creo i connettori, ma disabilitati

  208.                 // connettore risp
  209.                 //il nome del connettore deve essere univoco Connettore[RISP o INV]_nomeSA+tipoSoggetto+nomeSoggetto
  210.                 connettoreRisp = new Connettore();
  211.                 connettoreRisp.setNome("ConnettoreRISP_" + aSA.getNome()+"_"+aSA.getTipoSoggettoProprietario()+aSA.getNomeSoggettoProprietario());
  212.                 connettoreRisp.setTipo(TipiConnettore.DISABILITATO.getNome());
  213.                 //Creo il connettore disabilitato
  214.                 idConnettoreRisp = DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(1, connettoreRisp, con, driverBYOK);
  215.                 //Se il connettore mi era stato passato allora devo aggiornare il connettore con i dati giusti
  216.                 if(ricezione!=null && ricezione.getConnettore()!=null){
  217.                     Connettore connettore= ricezione.getConnettore();
  218.                     //setto l'id del connettore e il nome che aveva prima
  219.                     connettore.setId(idConnettoreRisp);
  220.                     connettore.setNome(connettoreRisp.getNome());//il nome DEVE essere quello creato in precedenza per assicurarsi che sia univoco
  221.                     DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(CostantiDB.UPDATE, connettore, con, driverBYOK);
  222.                 }

  224.                 // connettore inv
  225.                 connettoreInv = new Connettore();
  226.                 connettoreInv.setNome("ConnettoreINV_" + aSA.getNome()+"_"+aSA.getTipoSoggettoProprietario()+aSA.getNomeSoggettoProprietario());
  227.                 connettoreInv.setTipo(TipiConnettore.DISABILITATO.getNome());
  228.                 idConnettoreInv = DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(1, connettoreInv, con, driverBYOK);

  230.                 //setto i valori corretti del connettore se mi era stato passato
  231.                 if(invServizio!=null && invServizio.getConnettore()!=null){
  232.                     Connettore connettore = invServizio.getConnettore();
  233.                     connettore.setId(idConnettoreInv);
  234.                     connettore.setNome(connettoreInv.getNome());//il nome DEVE essere quello creato in precedenza per assicurarsi che sia univoco
  235.                     DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(CostantiDB.UPDATE, connettore, con, driverBYOK);
  236.                 }

  238.                 int index = 1;
  239.                 
  240.                 stm.setString(index++, nomeSA);
  241.                 stm.setString(index++, tipoSA);
  242.                 stm.setInt(index++, useAsClient);
  243.                 stm.setString(index++, descrizione);

  245.                 // RicezioneRisposta
  246.                 stm.setInt(index++, (ricezione != null && (CostantiConfigurazione.ABILITATO.equals(ricezione.getSbustamentoSoap())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  247.                 stm.setInt(index++, (ricezione != null && (!CostantiConfigurazione.DISABILITATO.equals(ricezione.getSbustamentoInformazioniProtocollo())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  248.                 stm.setString(index++, ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getGetMessage()) : null);
  249.                 // setto credenziali risp
  250.                 credenzialiInvocazione = ricezione != null ? ricezione.getCredenziali() : null;
  251.                 stm.setString(index++, (ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getAutenticazione()) : null)); //l'autenticazione e' quella della risposta asincrona
  252.                 stm.setString(index++, (credenzialiInvocazione != null ? credenzialiInvocazione.getUser() : null));
  253.                 
  254.                 String plainValue = (credenzialiInvocazione != null ? credenzialiInvocazione.getPassword() : null);
  255.                 String encValue = null;
  256.                 if(driverBYOK!=null && plainValue!=null) {
  257.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  258.                     if(byokValue!=null) {
  259.                         encValue = byokValue.getWrappedValue();
  260.                         plainValue = byokValue.getWrappedPlainValue();
  261.                     }
  262.                 }
  263.                 stm.setString(index++, plainValue);
  264.                 stm.setString(index++, encValue);
  265.                 
  266.                 // setto idconnettore risp
  267.                 stm.setLong(index++, idConnettoreRisp);

  269.                 // InvocazioneServizio
  270.                 stm.setInt(index++, (invServizio != null && (CostantiConfigurazione.ABILITATO.equals(invServizio.getSbustamentoSoap())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  271.                 stm.setInt(index++, (invServizio != null && (!CostantiConfigurazione.DISABILITATO.equals(invServizio.getSbustamentoInformazioniProtocollo())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  272.                 stm.setString(index++, invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getGetMessage()) : null);
  273.                 // setto credenziali inv
  274.                 credenzialiInvocazione = invServizio != null ? invServizio.getCredenziali() : null;
  275.                 stm.setString(index++, (invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getAutenticazione()) : null));//l'autenticazione e' quella dell invocazione servizio
  276.                 stm.setString(index++, (credenzialiInvocazione != null ? credenzialiInvocazione.getUser() : null));
  277.                 
  278.                 plainValue = (credenzialiInvocazione != null ? credenzialiInvocazione.getPassword() : null);
  279.                 encValue = null;
  280.                 if(driverBYOK!=null && plainValue!=null) {
  281.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  282.                     if(byokValue!=null) {
  283.                         encValue = byokValue.getWrappedValue();
  284.                         plainValue = byokValue.getWrappedPlainValue();
  285.                     }
  286.                 }
  287.                 stm.setString(index++, plainValue);
  288.                 stm.setString(index++, encValue);
  289.                 
  290.                 // setto idconnettore inv
  291.                 stm.setLong(index++, idConnettoreInv);

  293.                 // idsoggetto proprietario
  294.                 stm.setLong(index++, idProprietario);

  296.                 // InvocazionePorta
  297.                 gestErr = invPorta != null ? invPorta.getGestioneErrore() : null;
  298.                 fault = (gestErr != null ? DriverConfigurazioneDBLib.getValue(gestErr.getFault()) : null);
  299.                 stm.setString(index++, fault);
  300.                 // setto credenziali invocaizone porta
  301.                 // per il momento c'e' soltato una credenziale,quindi un solo
  302.                 // oggetto nella lista
  303.                 credenzialiInvocazionePorta = (invPorta != null && invPorta.sizeCredenzialiList() > 0 ? invPorta.getCredenziali(0) : null);
  304.                 stm.setString(index++, (credenzialiInvocazionePorta != null ? DriverConfigurazioneDBLib.getValue(credenzialiInvocazionePorta.getTipo()) : null));
  305.                 stm.setString(index++, (credenzialiInvocazionePorta != null ? credenzialiInvocazionePorta.getUser() : null));
  306.                 stm.setString(index++, (credenzialiInvocazionePorta != null ? credenzialiInvocazionePorta.getPassword() : null));
  307.                 
  308.                 String subject = null;
  309.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getSubject()!=null && !"".equals(credenzialiInvocazionePorta.getSubject()))
  310.                     subject = credenzialiInvocazionePorta.getSubject();
  311.                 stm.setString(index++, (subject != null ? CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT) : null));
  312.                 String subjectCN = null;
  313.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getCnSubject()!=null && !"".equals(credenzialiInvocazionePorta.getCnSubject()))
  314.                     subjectCN = credenzialiInvocazionePorta.getCnSubject();
  315.                 stm.setString(index++, subjectCN);
  316.                 
  317.                 String issuer = null;
  318.                 if(credenzialiInvocazionePorta != null && org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(credenzialiInvocazionePorta.getTipo())) {
  319.                     stm.setString(index++, CostantiDB.getIssuerApiKey(credenzialiInvocazionePorta.isAppId()));
  320.                 }
  321.                 else {
  322.                     if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getIssuer()!=null && !"".equals(credenzialiInvocazionePorta.getIssuer()))
  323.                         issuer = credenzialiInvocazionePorta.getIssuer();
  324.                     stm.setString(index++, (issuer != null ? CertificateUtils.formatPrincipal(issuer, PrincipalType.ISSUER) : null));
  325.                 }
  326.                 String issuerCN = null;
  327.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getCnIssuer()!=null && !"".equals(credenzialiInvocazionePorta.getCnIssuer()))
  328.                     issuerCN = credenzialiInvocazionePorta.getCnIssuer();
  329.                 stm.setString(index++, issuerCN);
  330.                 
  331.                 byte [] certificate = null;
  332.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getCertificate()!=null) {
  333.                     certificate = credenzialiInvocazionePorta.getCertificate();
  334.                 }
  335.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  336.                 jdbcAdapter.setBinaryData(stm, index++, certificate);
  337.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.isCertificateStrictVerification()) {
  338.                     stm.setInt(index++, CostantiDB.TRUE);
  339.                 }               
  340.                 else {
  341.                     stm.setInt(index++, CostantiDB.FALSE);
  342.                 }
  343.                 
  344.                 stm.setString(index++, credenzialiInvocazionePorta!=null ? credenzialiInvocazionePorta.getTokenPolicy() : null);

  346.                 // aggiungo gestione invio/risposta per riferimento
  347.                 // invocazione servizio
  348.                 stm.setString(index++, invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getInvioPerRiferimento()) : null);
  349.                 stm.setString(index++, invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getRispostaPerRiferimento()) : null);
  350.                 // invocazione porta
  351.                 stm.setString(index++, invPorta != null ? DriverConfigurazioneDBLib.getValue(invPorta.getInvioPerRiferimento()) : null);
  352.                 // ricezione risposta
  353.                 stm.setString(index++, ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getInvioPerRiferimento()) : null);
  354.                 stm.setString(index++, ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getRispostaPerRiferimento()) : null);
  355.                 // sbustamento info protocolo
  356.                 stm.setInt(index++, (invPorta != null && (!CostantiConfigurazione.DISABILITATO.equals(invPorta.getSbustamentoInformazioniProtocollo())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  357.                 //Invocazione Porta : fault_actor, generic_fault_code, prefix_fault_code
  358.                 stm.setString(index++, gestErr!=null ? gestErr.getFaultActor() : null);
  359.                 stm.setString(index++, gestErr!=null ? DriverConfigurazioneDBLib.getValue(gestErr.getGenericFaultCode()) : null);
  360.                 stm.setString(index++, gestErr!=null ? gestErr.getPrefixFaultCode() : null);
  361.                                 
  362.                 //tipologia erogazione/fruizione
  363.                 stm.setString(index++, aSA.getTipologiaFruizione()!=null ? TipologiaFruizione.valueOf(aSA.getTipologiaFruizione().toUpperCase()).toString() : TipologiaFruizione.DISABILITATO.toString());
  364.                 stm.setString(index++, aSA.getTipologiaErogazione()!=null ? TipologiaErogazione.valueOf(aSA.getTipologiaErogazione().toUpperCase()).toString() : TipologiaErogazione.DISABILITATO.toString());
  365.                 
  366.                 if(utenteRichiedente!=null) {
  367.                     stm.setString(index++, utenteRichiedente);
  368.                 }
  369.                 
  370.                 if(dataCreazione!=null) {
  371.                     stm.setTimestamp(index++, dataCreazione);
  372.                 }
  373.                 
  374.                 n = stm.executeUpdate();
  375.                 stm.close();
  376.                 DriverConfigurazioneDBLib.logDebug("Inserted " + n + " row(s)");

  378.                 try {
  379.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  380.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  381.                     sqlQueryObject.addSelectField("id");
  382.                     sqlQueryObject.addWhereCondition("id_soggetto = ?");
  383.                     sqlQueryObject.addWhereCondition("nome = ?");
  384.                     sqlQueryObject.setANDLogicOperator(true);
  385.                     sqlQuery = sqlQueryObject.createSQLQuery();
  386.                     stmQuery = con.prepareStatement(sqlQuery);
  387.                     stmQuery.setLong(1, idProprietario);
  388.                     stmQuery.setString(2, nomeSA);
  389.     
  390.                     rs = stmQuery.executeQuery();
  391.     
  392.                     if (rs.next()) {
  393.                         idServizioApplicativo = rs.getLong("id");
  394.                         aSA.setId(idServizioApplicativo);
  395.                     } else {
  396.                         throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo(CREATE)] Impossibile trovare il servizio appena creato.");
  397.                     }
  398.                 }finally {
  399.                     if(rs!=null) {
  400.                         rs.close();
  401.                         rs = null;
  402.                     }
  403.                     if(stmQuery!=null) {
  404.                         stmQuery.close();
  405.                         stmQuery = null;
  406.                     }
  407.                 }
  408.                 
  409.                 // GestioneErrore
  410.                 if(aSA.getRispostaAsincrona()!=null && aSA.getRispostaAsincrona().getGestioneErrore()!=null){
  411.                     
  412.                     DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreServizioApplicativo(CostantiDB.CREATE, 
  413.                             aSA.getRispostaAsincrona().getGestioneErrore(), idProprietario, idServizioApplicativo, false, con);
  414.                     
  415.                     try {
  416.                         ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  417.                         sqlQueryObjectUpdate.addUpdateTable(CostantiDB.SERVIZI_APPLICATIVI);
  418.                         sqlQueryObjectUpdate.addUpdateField("id_gestione_errore_risp", "?");
  419.                         sqlQueryObjectUpdate.addWhereCondition("id = ?");
  420.                         stm2 = con.prepareStatement(sqlQueryObjectUpdate.createSQLUpdate());
  421.                         stm2.setLong(1, aSA.getRispostaAsincrona().getGestioneErrore().getId());
  422.                         stm2.setLong(2, idServizioApplicativo);
  423.                         stm2.executeUpdate();
  424.                     }finally {
  425.                         if(stm2!=null) {
  426.                             stm2.close();
  427.                             stm2 = null;
  428.                         }
  429.                     }
  430.                     
  431.                 }
  432.                 
  433.                 // GestioneErrore
  434.                 if(aSA.getInvocazioneServizio()!=null && aSA.getInvocazioneServizio().getGestioneErrore()!=null){
  435.                     
  436.                     DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreServizioApplicativo(CostantiDB.CREATE, 
  437.                             aSA.getInvocazioneServizio().getGestioneErrore(), idProprietario, idServizioApplicativo, true, con);
  438.                     
  439.                     try {
  440.                         ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  441.                         sqlQueryObjectUpdate.addUpdateTable(CostantiDB.SERVIZI_APPLICATIVI);
  442.                         sqlQueryObjectUpdate.addUpdateField("id_gestione_errore_inv", "?");
  443.                         sqlQueryObjectUpdate.addWhereCondition("id = ?");
  444.                         stm2 = con.prepareStatement(sqlQueryObjectUpdate.createSQLUpdate());
  445.                         stm2.setLong(1, aSA.getInvocazioneServizio().getGestioneErrore().getId());
  446.                         stm2.setLong(2, idServizioApplicativo);
  447.                         stm2.executeUpdate();
  448.                     }finally {
  449.                         if(stm2!=null) {
  450.                             stm2.close();
  451.                             stm2 = null;
  452.                         }
  453.                     }
  454.                 }
  455.                 
  456.                 // Ruoli
  457.                 n=0;
  458.                 if(invPorta!=null && invPorta.getRuoli()!=null && invPorta.getRuoli().sizeRuoloList()>0){
  459.                     for (int i = 0; i < invPorta.getRuoli().sizeRuoloList(); i++) {
  460.                         Ruolo ruolo = invPorta.getRuoli().getRuolo(i);
  461.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  462.                         sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  463.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  464.                         sqlQueryObject.addInsertField("ruolo", "?");
  465.                         sqlQuery = sqlQueryObject.createSQLInsert();
  466.                         stm = con.prepareStatement(sqlQuery);
  467.                         stm.setLong(1, aSA.getId());
  468.                         stm.setString(2, ruolo.getNome());
  469.                         stm.executeUpdate();
  470.                         stm.close();
  471.                         n++;
  472.                         DriverConfigurazioneDBLib.logDebug("Aggiunto ruolo[" + ruolo.getNome() + "] al servizioApplicativo "+idServizioApplicativo);
  473.                     }
  474.                 }
  475.                 
  476.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " ruoli al servizioApplicativo "+idServizioApplicativo);
  477.                 
  478.                 
  479.                 // Credenziali (le credenziali in questa tabella partono dal numero maggiore di 1)
  480.                 n=0;
  481.                 if(invPorta!=null && invPorta.sizeCredenzialiList()>1){
  482.                     for (int i = 1; i < invPorta.sizeCredenzialiList(); i++) {
  483.                         Credenziali credenziale = invPorta.getCredenziali(i);
  484.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  485.                         sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  486.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  487.                         sqlQueryObject.addInsertField("subject", "?");
  488.                         sqlQueryObject.addInsertField("cn_subject", "?");
  489.                         sqlQueryObject.addInsertField("issuer", "?");
  490.                         sqlQueryObject.addInsertField("cn_issuer", "?");
  491.                         sqlQueryObject.addInsertField("certificate", "?");
  492.                         sqlQueryObject.addInsertField("cert_strict_verification", "?");
  493.                         sqlQuery = sqlQueryObject.createSQLInsert();
  494.                         stm = con.prepareStatement(sqlQuery);
  495.                         
  496.                         index = 1;
  497.                         stm.setLong(index++, aSA.getId());
  498.                         
  499.                         String subjectCredenziale = null;
  500.                         if(credenziale!=null && credenziale.getSubject()!=null && !"".equals(credenziale.getSubject()))
  501.                             subjectCredenziale = credenziale.getSubject();
  502.                         stm.setString(index++, (subjectCredenziale != null ? CertificateUtils.formatPrincipal(subjectCredenziale, PrincipalType.SUBJECT) : null));
  503.                         String subjectCredenzialeCN = null;
  504.                         if(credenziale!=null && credenziale.getCnSubject()!=null && !"".equals(credenziale.getCnSubject()))
  505.                             subjectCredenzialeCN = credenziale.getCnSubject();
  506.                         stm.setString(index++, subjectCredenzialeCN);
  507.                         
  508.                         String issuerCredenziale = null;
  509.                         if(credenziale != null && org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(credenziale.getTipo())) {
  510.                             stm.setString(index++, CostantiDB.getIssuerApiKey(credenziale.isAppId()));
  511.                         }
  512.                         else {
  513.                             if(credenziale!=null && credenziale.getIssuer()!=null && !"".equals(credenziale.getIssuer()))
  514.                                 issuerCredenziale = credenziale.getIssuer();
  515.                             stm.setString(index++, (issuerCredenziale != null ? CertificateUtils.formatPrincipal(issuerCredenziale, PrincipalType.ISSUER) : null));
  516.                         }
  517.                         String issuerCredenzialeCN = null;
  518.                         if(credenziale!=null && credenziale.getCnIssuer()!=null && !"".equals(credenziale.getCnIssuer()))
  519.                             issuerCredenzialeCN = credenziale.getCnIssuer();
  520.                         stm.setString(index++, issuerCredenzialeCN);
  521.                         
  522.                         byte [] certificateCredenziale = null;
  523.                         if(credenziale!=null && credenziale.getCertificate()!=null) {
  524.                             certificateCredenziale = credenziale.getCertificate();
  525.                         }
  526.                         jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  527.                         jdbcAdapter.setBinaryData(stm, index++, certificateCredenziale);
  528.                         if(credenziale!=null && credenziale.isCertificateStrictVerification()) {
  529.                             stm.setInt(index++, CostantiDB.TRUE);
  530.                         }               
  531.                         else {
  532.                             stm.setInt(index++, CostantiDB.FALSE);
  533.                         }
  534.                         
  535.                         stm.executeUpdate();
  536.                         stm.close();
  537.                         n++;
  538.                         DriverConfigurazioneDBLib.logDebug("Aggiunta credenziale al servizioApplicativo "+idServizioApplicativo);
  539.                     }
  540.                 }
  541.                 
  542.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " credenziali al servizioApplicativo "+idServizioApplicativo);
  543.                 
  544.                 
  545.                 // Proprieta
  546.                 n=0;
  547.                 if(proprieta!=null && !proprieta.isEmpty()){
  548.                     for (int i = 0; i < proprieta.size(); i++) {
  549.                         Proprieta prop = proprieta.get(i);
  550.                         
  551.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  552.                         sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI_PROPS);
  553.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  554.                         sqlQueryObject.addInsertField("nome", "?");
  555.                         sqlQueryObject.addInsertField("valore", "?");
  556.                         sqlQueryObject.addInsertField("enc_value", "?");
  557.                         sqlQuery = sqlQueryObject.createSQLInsert();
  558.                         stm = con.prepareStatement(sqlQuery);
  559.                         
  560.                         int indexP = 1;
  561.                         stm.setLong(indexP++, aSA.getId());
  562.                         stm.setString(indexP++, prop.getNome());
  563.                         
  564.                         String plainValueP = prop.getValore();
  565.                         String encValueP = null;
  566.                         if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  567.                             BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  568.                             if(byokValue!=null) {
  569.                                 encValueP = byokValue.getWrappedValue();
  570.                                 plainValueP = byokValue.getWrappedPlainValue();
  571.                             }
  572.                         }
  573.                         
  574.                         stm.setString(indexP++, plainValueP);
  575.                         stm.setString(indexP++, encValueP);
  576.                         
  577.                         stm.executeUpdate();
  578.                         stm.close();
  579.                         n++;
  580.                         DriverConfigurazioneDBLib.logDebug("Aggiunta proprieta' [" + prop.getNome() + "] al servizioApplicativo "+idServizioApplicativo);
  581.                     }
  582.                 }
  583.                 
  584.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " proprieta' al servizioApplicativo "+idServizioApplicativo);
  585.                 
  586.                 
  587.                 // ProtocolProperties
  588.                 DriverConfigurazioneDBLib.crudProtocolProperty(CostantiDB.CREATE, aSA.getProtocolPropertyList(), 
  589.                         idServizioApplicativo, ProprietariProtocolProperty.SERVIZIO_APPLICATIVO, con, DriverConfigurazioneDBLib.tipoDB, driverBYOK);
  590.                 
  591.                 
  592.                 break;

  594.             case UPDATE:
  595.                 String oldNomeSA = null;
  596.                 String oldNomeProprietario = null;
  597.                 String oldTipoProprietario = null;
  598.                 if(aSA.getOldIDServizioApplicativoForUpdate()!=null){
  599.                     oldNomeSA = aSA.getOldIDServizioApplicativoForUpdate().getNome();
  600.                     if(aSA.getOldIDServizioApplicativoForUpdate().getIdSoggettoProprietario()!=null){
  601.                         oldNomeProprietario = aSA.getOldIDServizioApplicativoForUpdate().getIdSoggettoProprietario().getNome();
  602.                         oldTipoProprietario = aSA.getOldIDServizioApplicativoForUpdate().getIdSoggettoProprietario().getTipo();
  603.                     }
  604.                 }

  606.                 if (oldNomeSA == null || oldNomeSA.equals(""))
  607.                     oldNomeSA = nomeSA;
  608.                 if (oldNomeProprietario == null || oldNomeProprietario.equals(""))
  609.                     oldNomeProprietario = nomeProprietario;
  610.                 if (oldTipoProprietario == null || oldTipoProprietario.equals(""))
  611.                     oldTipoProprietario = tipoProprietario;

  613.                 long oldIdProprietario = DBUtils.getIdSoggetto(oldNomeProprietario, oldTipoProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  614.                 // Puo' darsi che l'old soggetto e il nuovo soggetto siano la stesso soggetto della tabella. E' stato cambiato il nome.
  615.                 if(oldIdProprietario <=0) {
  616.                     oldIdProprietario = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  617.                 }
  618.                 if(oldIdProprietario <=0) 
  619.                     throw new DriverConfigurazioneException("Impossibile recuperare l'id del Soggetto Proprietario del Servizio Applicativo");
  620.                 
  621.                 String utenteUltimaModifica = null;
  622.                 if(aSA.getProprietaOggetto()!=null && aSA.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  623.                     utenteUltimaModifica = aSA.getProprietaOggetto().getUtenteUltimaModifica();
  624.                 }
  625.                 
  626.                 Timestamp dataUltimaModifica = null;
  627.                 if(aSA.getProprietaOggetto()!=null && aSA.getProprietaOggetto().getDataUltimaModifica()!=null) {
  628.                     dataUltimaModifica = new Timestamp(aSA.getProprietaOggetto().getDataUltimaModifica().getTime());
  629.                 }
  630.                 else {
  631.                     dataUltimaModifica = DateManager.getTimestamp();
  632.                 }
  633.                 
  634.                 
  635.                 // update
  636.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  637.                 sqlQueryObject.addUpdateTable(CostantiDB.SERVIZI_APPLICATIVI);
  638.                 sqlQueryObject.addUpdateField("tipo", "?");
  639.                 sqlQueryObject.addUpdateField("as_client", "?");
  640.                 sqlQueryObject.addUpdateField("descrizione", "?");
  641.                 sqlQueryObject.addUpdateField("sbustamentorisp", "?");
  642.                 sqlQueryObject.addUpdateField("sbustamento_protocol_info_risp", "?");
  643.                 sqlQueryObject.addUpdateField("getmsgrisp", "?");
  644.                 sqlQueryObject.addUpdateField("tipoauthrisp", "?");
  645.                 sqlQueryObject.addUpdateField("utenterisp", "?");
  646.                 sqlQueryObject.addUpdateField("passwordrisp", "?");
  647.                 sqlQueryObject.addUpdateField("enc_passwordrisp", "?");
  648.                 sqlQueryObject.addUpdateField("id_connettore_risp", "?");
  649.                 sqlQueryObject.addUpdateField("sbustamentoinv", "?");
  650.                 sqlQueryObject.addUpdateField("sbustamento_protocol_info_inv", "?");
  651.                 sqlQueryObject.addUpdateField("getmsginv", "?");
  652.                 sqlQueryObject.addUpdateField("tipoauthinv", "?");
  653.                 sqlQueryObject.addUpdateField("utenteinv", "?");
  654.                 sqlQueryObject.addUpdateField("passwordinv", "?");
  655.                 sqlQueryObject.addUpdateField("enc_passwordinv", "?");
  656.                 sqlQueryObject.addUpdateField("id_connettore_inv", "?");
  657.                 sqlQueryObject.addUpdateField("fault", "?");
  658.                 sqlQueryObject.addUpdateField("tipoauth", "?");
  659.                 sqlQueryObject.addUpdateField("utente", "?");
  660.                 sqlQueryObject.addUpdateField("password", "?");
  661.                 sqlQueryObject.addUpdateField("subject", "?");
  662.                 sqlQueryObject.addUpdateField("cn_subject", "?");
  663.                 sqlQueryObject.addUpdateField("issuer", "?");
  664.                 sqlQueryObject.addUpdateField("cn_issuer", "?");
  665.                 sqlQueryObject.addUpdateField("certificate", "?");
  666.                 sqlQueryObject.addUpdateField("cert_strict_verification", "?");
  667.                 sqlQueryObject.addUpdateField("token_policy", "?");
  668.                 sqlQueryObject.addUpdateField("invio_x_rif_inv", "?");
  669.                 sqlQueryObject.addUpdateField("risposta_x_rif_inv", "?");
  670.                 sqlQueryObject.addUpdateField("invio_x_rif", "?");
  671.                 sqlQueryObject.addUpdateField("invio_x_rif_risp", "?");
  672.                 sqlQueryObject.addUpdateField("risposta_x_rif_risp", "?");
  673.                 sqlQueryObject.addUpdateField("sbustamento_protocol_info", "?");
  674.                 sqlQueryObject.addUpdateField("fault_actor", "?");
  675.                 sqlQueryObject.addUpdateField("generic_fault_code", "?");
  676.                 sqlQueryObject.addUpdateField("prefix_fault_code", "?");
  677.                 sqlQueryObject.addUpdateField("nome", "?");
  678.                 sqlQueryObject.addUpdateField("id_soggetto", "?");
  679.                 if(aSA.getRispostaAsincrona()!=null && aSA.getRispostaAsincrona().getGestioneErrore()!=null){
  680.                     sqlQueryObject.addUpdateField("id_gestione_errore_risp", "?");
  681.                 }
  682.                 if(aSA.getInvocazioneServizio()!=null && aSA.getInvocazioneServizio().getGestioneErrore()!=null){
  683.                     sqlQueryObject.addUpdateField("id_gestione_errore_inv", "?");
  684.                 }
  685.                 sqlQueryObject.addUpdateField("tipologia_fruizione", "?");
  686.                 sqlQueryObject.addUpdateField("tipologia_erogazione", "?");
  687.                 if(utenteUltimaModifica!=null) {
  688.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  689.                 }
  690.                 if(dataUltimaModifica!=null) {
  691.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  692.                 }
  693.                 sqlQueryObject.addWhereCondition("id=?");
  694.                 sqlQueryObject.addWhereCondition("nome=?");
  695.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  696.                 sqlQueryObject.setANDLogicOperator(true);
  697.                 sqlQuery = sqlQueryObject.createSQLUpdate();
  698.                 stm = con.prepareStatement(sqlQuery);

  700.                 idServizioApplicativo = getIdServizioApplicativo(oldNomeSA, oldTipoProprietario, oldNomeProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  701.                 // Puo' darsi che l'old soggetto e il nuovo soggetto siano la stesso soggetto della tabella. E' stato cambiato il nome.
  702.                 if(idServizioApplicativo<=0) {
  703.                     idServizioApplicativo = getIdServizioApplicativo(oldNomeSA, tipoProprietario, nomeProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  704.                 }
  705.                 if (idServizioApplicativo <= 0)
  706.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo(UPDATE)] ID del ServizioApplicativo necessario per l'aggiornamento.");
  707.                 // recupero i connettori

  709.                 // connettore risp asinc                
  710.                 RispostaAsincrona rispAsin = aSA.getRispostaAsincrona();
  711.                 connettoreRisp = rispAsin != null ? rispAsin.getConnettore() : new Connettore();
  712.                 String newNomeConnettoreRisp = "ConnettoreRISP_"+nomeSA+"_"+tipoProprietario+nomeProprietario;
  713.                 idConnettoreRisp = DriverConfigurazioneDB_connettoriLIB.getIdConnettoreSARISP(idServizioApplicativo, con);
  714.                 
  715.                 // connettore inv servizio
  716.                 InvocazioneServizio invServ = aSA.getInvocazioneServizio();
  717.                 connettoreInv = invServ != null ? invServizio.getConnettore() : new Connettore();
  718.                 String newNomeConnettoreInv = "ConnettoreINV_"+nomeSA+"_"+tipoProprietario+nomeProprietario;
  719.                 idConnettoreInv = DriverConfigurazioneDB_connettoriLIB.getIdConnettoreSAINV(idServizioApplicativo, con);
  720.                 
  721.                 //Controllo consistenza degli id dei connettori in quanto devono essere specificati
  722.                 //e quindi maggiori di 0
  723.                 if(idConnettoreInv <=0 || idConnettoreRisp<=0) throw new DriverConfigurazioneException("I connettori del servizio applicativo sono invalidi");
  724.                 
  725.                 /*
  726.                  * Problema:
  727.                  *  Se il nuovo connettore e' disabilitato (e il nome del connettore non cambia)
  728.                  *  il valore presente sul db non cambia anche se questo valore e' != da DISABILITATO
  729.                  * Fix:
  730.                  *  I valori del nuovo connettore devono essere sempre aggiornati
  731.                  *   
  732.                  */

  734.                 String nomeConnettoreRisp = DriverConfigurazioneDB_connettoriLIB.getConnettore(idConnettoreRisp, con, null).getNome();
  735.                 String nomeConnettoreInv = DriverConfigurazioneDB_connettoriLIB.getConnettore(idConnettoreInv, con, null).getNome();

  737.                 String pattern = "Aggiorno Connettore [{0}] : id [{1}] oldNome [{2}] newNome [{2}]";

  739.                 DriverConfigurazioneDBLib.logDebug(MessageFormat.format(pattern, "Risposta Asincrona",idConnettoreRisp, nomeConnettoreRisp, newNomeConnettoreRisp));
  740.                 //aggiorno connettore risp
  741.                 connettoreRisp.setNome(newNomeConnettoreRisp);
  742.                 connettoreRisp.setId(idConnettoreRisp);
  743.                 DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(CostantiDB.UPDATE, connettoreRisp, con, driverBYOK);

  745.                 //aggiorno connettore inv
  746.                 DriverConfigurazioneDBLib.logDebug(MessageFormat.format(pattern, "Invocazione Servizio",idConnettoreInv, nomeConnettoreInv, newNomeConnettoreInv));
  747.                 connettoreInv.setNome(newNomeConnettoreInv);
  748.                 connettoreInv.setId(idConnettoreInv);
  749.                 DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(CostantiDB.UPDATE, connettoreInv, con, driverBYOK);


  752.                 // Setto i dati del ServizioApplicativo

  754.                 index = 1;
  755.                 
  756.                 stm.setString(index++, tipoSA);
  757.                 stm.setInt(index++, useAsClient);
  758.                 stm.setString(index++, descrizione);

  760.                 // RicezioneRisposta
  761.                 stm.setInt(index++, (ricezione != null && (CostantiConfigurazione.ABILITATO.equals(ricezione.getSbustamentoSoap())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  762.                 stm.setInt(index++, (ricezione != null && (!CostantiConfigurazione.DISABILITATO.equals(ricezione.getSbustamentoInformazioniProtocollo())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  763.                 stm.setString(index++, ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getGetMessage()) : null);
  764.                 // setto credenziali risp
  765.                 credenzialiInvocazione = ricezione != null ? ricezione.getCredenziali() : null;
  766.                 stm.setString(index++, (ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getAutenticazione()) : null));
  767.                 stm.setString(index++, (credenzialiInvocazione != null ? credenzialiInvocazione.getUser() : null));
  768.                 
  769.                 plainValue = (credenzialiInvocazione != null ? credenzialiInvocazione.getPassword() : null);
  770.                 encValue = null;
  771.                 if(driverBYOK!=null && plainValue!=null) {
  772.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  773.                     if(byokValue!=null) {
  774.                         encValue = byokValue.getWrappedValue();
  775.                         plainValue = byokValue.getWrappedPlainValue();
  776.                     }
  777.                 }
  778.                 stm.setString(index++, plainValue);
  779.                 stm.setString(index++, encValue);
  780.                 
  781.                 // setto idconnettore risp
  782.                 stm.setLong(index++, idConnettoreRisp);

  784.                 // InvocazioneServizio
  785.                 stm.setInt(index++, (invServizio != null && (CostantiConfigurazione.ABILITATO.equals(invServizio.getSbustamentoSoap())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  786.                 stm.setInt(index++, (invServizio != null && (!CostantiConfigurazione.DISABILITATO.equals(invServizio.getSbustamentoInformazioniProtocollo())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  787.                 stm.setString(index++, invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getGetMessage()) : null);
  788.                 // setto credenziali inv
  789.                 credenzialiInvocazione = invServizio != null ? invServizio.getCredenziali() : null;
  790.                 stm.setString(index++, (invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getAutenticazione()) : null));
  791.                 stm.setString(index++, (credenzialiInvocazione != null ? credenzialiInvocazione.getUser() : null));
  792.                 
  793.                 plainValue = (credenzialiInvocazione != null ? credenzialiInvocazione.getPassword() : null);
  794.                 encValue = null;
  795.                 if(driverBYOK!=null && plainValue!=null) {
  796.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  797.                     if(byokValue!=null) {
  798.                         encValue = byokValue.getWrappedValue();
  799.                         plainValue = byokValue.getWrappedPlainValue();
  800.                     }
  801.                 }
  802.                 stm.setString(index++, plainValue);
  803.                 stm.setString(index++, encValue);
  804.                 
  805.                 // setto idconnettore inv
  806.                 stm.setLong(index++, idConnettoreInv);

  808.                 // InvocazionePorta
  809.                 gestErr = invPorta != null ? invPorta.getGestioneErrore() : null;
  810.                 fault = (gestErr != null ? DriverConfigurazioneDBLib.getValue(gestErr.getFault()) : null);
  811.                 stm.setString(index++, fault);
  812.                 // setto credenziali invocaizone porta
  813.                 // per il momento c'e' soltato una credenziale,quindi un solo
  814.                 // oggetto nella lista
  815.                 credenzialiInvocazionePorta = (invPorta != null && invPorta.sizeCredenzialiList() > 0 ? invPorta.getCredenziali(0) : null);
  816.                 stm.setString(index++, (credenzialiInvocazionePorta != null ? DriverConfigurazioneDBLib.getValue(credenzialiInvocazionePorta.getTipo()) : null));
  817.                 stm.setString(index++, (credenzialiInvocazionePorta != null ? credenzialiInvocazionePorta.getUser() : null));
  818.                 stm.setString(index++, (credenzialiInvocazionePorta != null ? credenzialiInvocazionePorta.getPassword() : null));
  819.                 
  820.                 subject = null;
  821.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getSubject()!=null && !"".equals(credenzialiInvocazionePorta.getSubject()))
  822.                     subject = credenzialiInvocazionePorta.getSubject();
  823.                 stm.setString(index++, (subject != null ? CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT) : null));
  824.                 subjectCN = null;
  825.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getCnSubject()!=null && !"".equals(credenzialiInvocazionePorta.getCnSubject()))
  826.                     subjectCN = credenzialiInvocazionePorta.getCnSubject();
  827.                 stm.setString(index++, subjectCN);
  828.                 
  829.                 issuer = null;
  830.                 if(credenzialiInvocazionePorta != null && org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(credenzialiInvocazionePorta.getTipo())) {
  831.                     stm.setString(index++, CostantiDB.getIssuerApiKey(credenzialiInvocazionePorta.isAppId()));
  832.                 }
  833.                 else {
  834.                     if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getIssuer()!=null && !"".equals(credenzialiInvocazionePorta.getIssuer()))
  835.                         issuer = credenzialiInvocazionePorta.getIssuer();
  836.                     stm.setString(index++, (issuer != null ? CertificateUtils.formatPrincipal(issuer, PrincipalType.ISSUER) : null));
  837.                 }
  838.                 issuerCN = null;
  839.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getCnIssuer()!=null && !"".equals(credenzialiInvocazionePorta.getCnIssuer()))
  840.                     issuerCN = credenzialiInvocazionePorta.getCnIssuer();
  841.                 stm.setString(index++, issuerCN);
  842.                 
  843.                 certificate = null;
  844.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.getCertificate()!=null) {
  845.                     certificate = credenzialiInvocazionePorta.getCertificate();
  846.                 }
  847.                 jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  848.                 jdbcAdapter.setBinaryData(stm, index++, certificate);
  849.                 if(credenzialiInvocazionePorta!=null && credenzialiInvocazionePorta.isCertificateStrictVerification()) {
  850.                     stm.setInt(index++, CostantiDB.TRUE);
  851.                 }               
  852.                 else {
  853.                     stm.setInt(index++, CostantiDB.FALSE);
  854.                 }
  855.                 
  856.                 stm.setString(index++, credenzialiInvocazionePorta!=null ? credenzialiInvocazionePorta.getTokenPolicy() : null);

  858.                 // aggiungo gestione invio/risposta per riferimento
  859.                 // invocazione servizio
  860.                 stm.setString(index++, invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getInvioPerRiferimento()) : null);
  861.                 stm.setString(index++, invServizio != null ? DriverConfigurazioneDBLib.getValue(invServizio.getRispostaPerRiferimento()) : null);
  862.                 // invocazione porta
  863.                 stm.setString(index++, invPorta != null ? DriverConfigurazioneDBLib.getValue(invPorta.getInvioPerRiferimento()) : null);
  864.                 // ricezione risposta
  865.                 stm.setString(index++, ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getInvioPerRiferimento()) : null);
  866.                 stm.setString(index++, ricezione != null ? DriverConfigurazioneDBLib.getValue(ricezione.getRispostaPerRiferimento()) : null);
  867.                 // protocol info
  868.                 stm.setInt(index++, (invPorta != null && (!CostantiConfigurazione.DISABILITATO.equals(invPorta.getSbustamentoInformazioniProtocollo())) ? CostantiDB.TRUE : CostantiDB.FALSE));
  869.                 //Invocazione Porta : fault_actor, generic_fault_code, prefix_fault_code
  870.                 stm.setString(index++, gestErr!=null ? gestErr.getFaultActor() : null);
  871.                 stm.setString(index++, gestErr!=null ? DriverConfigurazioneDBLib.getValue(gestErr.getGenericFaultCode()) : null);
  872.                 stm.setString(index++, gestErr!=null ? gestErr.getPrefixFaultCode() : null);
  873.                 //Aggiorno nome servizio applicativo
  874.                 stm.setString(index++, nomeSA);
  875.                 //Aggiorno il proprietario
  876.                 stm.setLong(index++, idProprietario<0 ? oldIdProprietario : idProprietario);

  878.                 // GestioneErrore risposta asincrona
  879.                 if(aSA.getRispostaAsincrona() !=null && aSA.getRispostaAsincrona().getGestioneErrore()!=null){
  880.                     DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreServizioApplicativo(CostantiDB.UPDATE, 
  881.                             aSA.getRispostaAsincrona().getGestioneErrore(), idProprietario, idServizioApplicativo, false, con);
  882.                     stm.setLong(index++, aSA.getRispostaAsincrona().getGestioneErrore().getId());
  883.                 }
  884.                 //  GestioneErrore invocazione servizio
  885.                 if(aSA.getInvocazioneServizio() !=null && aSA.getInvocazioneServizio().getGestioneErrore()!=null){
  886.                     DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreServizioApplicativo(CostantiDB.UPDATE, 
  887.                             aSA.getInvocazioneServizio().getGestioneErrore(), idProprietario, idServizioApplicativo, true, con);
  888.                     stm.setLong(index++, aSA.getInvocazioneServizio().getGestioneErrore().getId());
  889.                 }
  890.                 
  891.                 //tipologia erogazione/fruizione
  892.                 stm.setString(index++, aSA.getTipologiaFruizione()!=null ? TipologiaFruizione.valueOf(aSA.getTipologiaFruizione().toUpperCase()).toString() : TipologiaFruizione.DISABILITATO.toString());
  893.                 stm.setString(index++, aSA.getTipologiaErogazione()!=null ? TipologiaErogazione.valueOf(aSA.getTipologiaErogazione().toUpperCase()).toString() : TipologiaErogazione.DISABILITATO.toString());
  894.                 
  895.                 if(utenteUltimaModifica!=null) {
  896.                     stm.setString(index++, utenteUltimaModifica);
  897.                 }
  898.                 
  899.                 if(dataUltimaModifica!=null) {
  900.                     stm.setTimestamp(index++, dataUltimaModifica);
  901.                 }
  902.                 
  903.                 // where
  904.                 stm.setLong(index++, idServizioApplicativo); 
  905.                 stm.setString(index++, oldNomeSA); 
  906.                 stm.setLong(index++, oldIdProprietario); 

  908.                 n = stm.executeUpdate();
  909.                 stm.close();
  910.                 DriverConfigurazioneDBLib.logDebug("Updated " + n + " row(s)");

  912.                 
  913.                 
  914.                 // Ruoli
  915.                 
  916.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  917.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  918.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  919.                 sqlQuery = sqlQueryObject.createSQLDelete();
  920.                 stm = con.prepareStatement(sqlQuery);
  921.                 stm.setLong(1, aSA.getId());
  922.                 n=stm.executeUpdate();
  923.                 stm.close();
  924.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" ruoli associati al servizioApplicativo "+idServizioApplicativo);
  925.                 
  926.                 n=0;
  927.                 if(invPorta!=null && invPorta.getRuoli()!=null && invPorta.getRuoli().sizeRuoloList()>0){
  928.                     for (int i = 0; i < invPorta.getRuoli().sizeRuoloList(); i++) {
  929.                         Ruolo ruolo = invPorta.getRuoli().getRuolo(i);
  930.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  931.                         sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  932.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  933.                         sqlQueryObject.addInsertField("ruolo", "?");
  934.                         sqlQuery = sqlQueryObject.createSQLInsert();
  935.                         stm = con.prepareStatement(sqlQuery);
  936.                         stm.setLong(1, aSA.getId());
  937.                         stm.setString(2, ruolo.getNome());
  938.                         stm.executeUpdate();
  939.                         stm.close();
  940.                         n++;
  941.                         DriverConfigurazioneDBLib.logDebug("Aggiunto ruolo[" + ruolo.getNome() + "] al servizioApplicativo "+idServizioApplicativo);
  942.                     }
  943.                 }
  944.                 
  945.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " ruoli al servizioApplicativo "+idServizioApplicativo);
  946.                 
  947.                 
  948.                 
  949.                 
  950.                 
  951.                 
  952.                 
  953.                 // Credenziali  (le credenziali in questa tabella partono dal numero maggiore di 1)
  954.                 
  955.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  956.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  957.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  958.                 sqlQuery = sqlQueryObject.createSQLDelete();
  959.                 stm = con.prepareStatement(sqlQuery);
  960.                 stm.setLong(1, aSA.getId());
  961.                 n=stm.executeUpdate();
  962.                 stm.close();
  963.                 DriverConfigurazioneDBLib.logDebug("Cancellate "+n+" credenziali associate al servizioApplicativo "+idServizioApplicativo);
  964.                 
  965.                 n=0;
  966.                 if(invPorta!=null && invPorta.sizeCredenzialiList()>1){
  967.                     for (int i = 1; i < invPorta.sizeCredenzialiList(); i++) {
  968.                         Credenziali credenziale = invPorta.getCredenziali(i);
  969.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  970.                         sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  971.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  972.                         sqlQueryObject.addInsertField("subject", "?");
  973.                         sqlQueryObject.addInsertField("cn_subject", "?");
  974.                         sqlQueryObject.addInsertField("issuer", "?");
  975.                         sqlQueryObject.addInsertField("cn_issuer", "?");
  976.                         sqlQueryObject.addInsertField("certificate", "?");
  977.                         sqlQueryObject.addInsertField("cert_strict_verification", "?");
  978.                         sqlQuery = sqlQueryObject.createSQLInsert();
  979.                         stm = con.prepareStatement(sqlQuery);
  980.                         
  981.                         index = 1;
  982.                         stm.setLong(index++, aSA.getId());
  983.                         
  984.                         String subjectCredenziale = null;
  985.                         if(credenziale!=null && credenziale.getSubject()!=null && !"".equals(credenziale.getSubject()))
  986.                             subjectCredenziale = credenziale.getSubject();
  987.                         stm.setString(index++, (subjectCredenziale != null ? CertificateUtils.formatPrincipal(subjectCredenziale, PrincipalType.SUBJECT) : null));
  988.                         String subjectCredenzialeCN = null;
  989.                         if(credenziale!=null && credenziale.getCnSubject()!=null && !"".equals(credenziale.getCnSubject()))
  990.                             subjectCredenzialeCN = credenziale.getCnSubject();
  991.                         stm.setString(index++, subjectCredenzialeCN);
  992.                         
  993.                         String issuerCredenziale = null;
  994.                         if(credenziale != null && org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(credenziale.getTipo())) {
  995.                             stm.setString(index++, CostantiDB.getIssuerApiKey(credenziale.isAppId()));
  996.                         }
  997.                         else {
  998.                             if(credenziale!=null && credenziale.getIssuer()!=null && !"".equals(credenziale.getIssuer()))
  999.                                 issuerCredenziale = credenziale.getIssuer();
  1000.                             stm.setString(index++, (issuerCredenziale != null ? CertificateUtils.formatPrincipal(issuerCredenziale, PrincipalType.ISSUER) : null));
  1001.                         }
  1002.                         String issuerCredenzialeCN = null;
  1003.                         if(credenziale!=null && credenziale.getCnIssuer()!=null && !"".equals(credenziale.getCnIssuer()))
  1004.                             issuerCredenzialeCN = credenziale.getCnIssuer();
  1005.                         stm.setString(index++, issuerCredenzialeCN);
  1006.                         
  1007.                         byte [] certificateCredenziale = null;
  1008.                         if(credenziale!=null && credenziale.getCertificate()!=null) {
  1009.                             certificateCredenziale = credenziale.getCertificate();
  1010.                         }
  1011.                         jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  1012.                         jdbcAdapter.setBinaryData(stm, index++, certificateCredenziale);
  1013.                         if(credenziale!=null && credenziale.isCertificateStrictVerification()) {
  1014.                             stm.setInt(index++, CostantiDB.TRUE);
  1015.                         }               
  1016.                         else {
  1017.                             stm.setInt(index++, CostantiDB.FALSE);
  1018.                         }
  1019.                         
  1020.                         stm.executeUpdate();
  1021.                         stm.close();
  1022.                         n++;
  1023.                         DriverConfigurazioneDBLib.logDebug("Aggiunta credenziale al servizioApplicativo "+idServizioApplicativo);
  1024.                     }
  1025.                 }
  1026.                 
  1027.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " credenziali al servizioApplicativo "+idServizioApplicativo);
  1028.                 
  1029.                 
  1030.                 
  1031.                 // Proprieta
  1032.                 
  1033.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1034.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI_PROPS);
  1035.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1036.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1037.                 stm = con.prepareStatement(sqlQuery);
  1038.                 stm.setLong(1, aSA.getId());
  1039.                 n=stm.executeUpdate();
  1040.                 stm.close();
  1041.                 DriverConfigurazioneDBLib.logDebug("Cancellate "+n+" proprieta' associate al servizioApplicativo "+idServizioApplicativo);
  1042.                 
  1043.                 n=0;
  1044.                 if(proprieta!=null && !proprieta.isEmpty()){
  1045.                     for (int i = 0; i < proprieta.size(); i++) {
  1046.                         Proprieta prop = proprieta.get(i);
  1047.                         
  1048.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1049.                         sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_APPLICATIVI_PROPS);
  1050.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  1051.                         sqlQueryObject.addInsertField("nome", "?");
  1052.                         sqlQueryObject.addInsertField("valore", "?");
  1053.                         sqlQueryObject.addInsertField("enc_value", "?");
  1054.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1055.                         stm = con.prepareStatement(sqlQuery);
  1056.                         
  1057.                         int indexP = 1;
  1058.                         stm.setLong(indexP++, aSA.getId());
  1059.                         stm.setString(indexP++, prop.getNome());
  1060.                         
  1061.                         String plainValueP = prop.getValore();
  1062.                         String encValueP = null;
  1063.                         if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  1064.                             BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  1065.                             if(byokValue!=null) {
  1066.                                 encValueP = byokValue.getWrappedValue();
  1067.                                 plainValueP = byokValue.getWrappedPlainValue();
  1068.                             }
  1069.                         }
  1070.                         
  1071.                         stm.setString(indexP++, plainValueP);
  1072.                         stm.setString(indexP++, encValueP);
  1073.                         
  1074.                         stm.executeUpdate();
  1075.                         stm.close();
  1076.                         n++;
  1077.                         DriverConfigurazioneDBLib.logDebug("Aggiunta proprieta' [" + prop.getNome() + "] al servizioApplicativo "+idServizioApplicativo);
  1078.                     }
  1079.                 }
  1080.                 
  1081.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " proprieta' al servizioApplicativo "+idServizioApplicativo);
  1082.                 
  1083.                 
  1084.                 
  1085.                 
  1086.                 // ProtocolProperties
  1087.                 DriverConfigurazioneDBLib.crudProtocolProperty(CostantiDB.UPDATE, aSA.getProtocolPropertyList(), 
  1088.                         idServizioApplicativo, ProprietariProtocolProperty.SERVIZIO_APPLICATIVO, con, DriverConfigurazioneDBLib.tipoDB, driverBYOK);
  1089.                 
  1090.                 break;

  1092.             case DELETE:
  1093.                 // delete
  1094.                 /** if(aSA.getId()==null || aSA.getId()<=0) throw new
  1095.                 // DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServizioApplicativo(DELETE)]
  1096.                 // id del ServizioApplicativo non valida.");*/

  1098.                 DriverConfigurazioneDBLib.logDebug("get ID Servizio Applicativo con nome["+nomeSA+"] tipoProprietario["+tipoProprietario+"] nomeProprietario["+nomeProprietario+"]");
  1099.                 idServizioApplicativo = getIdServizioApplicativo(nomeSA, tipoProprietario, nomeProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  1100.                 DriverConfigurazioneDBLib.logDebug("get ID Servizio Applicativo: "+idServizioApplicativo); 

  1102.                 // ProtocolProperties
  1103.                 DriverConfigurazioneDBLib.crudProtocolProperty(CostantiDB.DELETE, null, 
  1104.                         idServizioApplicativo, ProprietariProtocolProperty.SERVIZIO_APPLICATIVO, con, DriverConfigurazioneDBLib.tipoDB, driverBYOK);
  1105.                 
  1106.                 // proprieta'
  1107.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1108.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI_PROPS);
  1109.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1110.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1111.                 stm = con.prepareStatement(sqlQuery);
  1112.                 stm.setLong(1, idServizioApplicativo);
  1113.                 n=stm.executeUpdate();
  1114.                 stm.close();
  1115.                 if (n > 0)
  1116.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " proprieta' associate al ServizioApplicativo[" + idServizioApplicativo + "]");
  1117.                 
  1118.                 // credenziali
  1119.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1120.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  1121.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1122.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1123.                 stm = con.prepareStatement(sqlQuery);
  1124.                 stm.setLong(1, idServizioApplicativo);
  1125.                 n=stm.executeUpdate();
  1126.                 stm.close();
  1127.                 if (n > 0)
  1128.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " credenziali associate al ServizioApplicativo[" + idServizioApplicativo + "]");
  1129.                 
  1130.                 // ruoli
  1131.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1132.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  1133.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1134.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1135.                 stm = con.prepareStatement(sqlQuery);
  1136.                 stm.setLong(1, idServizioApplicativo);
  1137.                 n=stm.executeUpdate();
  1138.                 stm.close();
  1139.                 if (n > 0)
  1140.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " ruoli associati al ServizioApplicativo[" + idServizioApplicativo + "]");
  1141.                 
  1142.                 /*
  1143.                  * BUG Devo prima eliminare l'associazione
  1144.                  */
  1145.                 /**
  1146.                 // cancello anche le associazioni delle porteapplicative
  1147.                 // associate a questo servizio
  1148.                 // serviziapplicativi
  1149.                 
  1150.                 List<Long> idsPA_SA = new ArrayList<>(); 
  1151.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDB_LIB.tipoDB);
  1152.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  1153.                 sqlQueryObject.addSelectField("id");
  1154.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1155.                 sqlQueryObject.setANDLogicOperator(true);
  1156.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1157.                 stm = con.prepareStatement(sqlQuery);
  1158.                 stm.setLong(1, idServizioApplicativo);
  1159.                 rs = stm.executeQuery();
  1160.                 while(rs.next()) {
  1161.                     idsPA_SA.add(rs.getLong("id"));
  1162.                 }
  1163.                 rs.close();
  1164.                 stm.close();
  1165.                 
  1166.                 if(!idsPA_SA.isEmpty()) {
  1167.                     for (Long idsapa : idsPA_SA) {
  1168.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDB_LIB.tipoDB);
  1169.                         sqlQueryObject.addDeleteTable(CostantiDB.PORTE_APPLICATIVE_SA_PROPS);
  1170.                         sqlQueryObject.addWhereCondition("id_porta=?");
  1171.                         sqlQuery = sqlQueryObject.createSQLDelete();
  1172.                         stm = con.prepareStatement(sqlQuery);
  1173.                         stm.setLong(1, idsapa);
  1174.                         n=stm.executeUpdate();
  1175.                         stm.close();
  1176.                         DriverConfigurazioneDB_LIB.logDebug("Eliminate "+n+" proprieta relative all'associazione '"+idsapa+"' (SA "+idServizioApplicativo+")");
  1177.                     }
  1178.                 }
  1179.                 
  1180.                 DriverConfigurazioneDB_LIB.logDebug("Deleted PA associazioni...");
  1181.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDB_LIB.tipoDB);
  1182.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_APPLICATIVE_SA);
  1183.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1184.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1185.                 stm = con.prepareStatement(sqlQuery);
  1186.                 stm.setLong(1, idServizioApplicativo);
  1187.                 n=stm.executeUpdate();
  1188.                 stm.close();
  1189.                 if (n > 0)
  1190.                     DriverConfigurazioneDB_LIB.logDebug("Deleted " + n + " associazioni di PortaApplicativa<->ServizioApplicativo associate al ServizioApplicativo[" + idServizioApplicativo + "]");

  1192.                 // faccio lo stesso per le portedelegate
  1193.                 DriverConfigurazioneDB_LIB.logDebug("Deleted PD associazioni...");
  1194.                 DriverConfigurazioneDB_LIB.logDebug("Deleted PA associazioni...");
  1195.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDB_LIB.tipoDB);
  1196.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_SA);
  1197.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1198.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1199.                 stm = con.prepareStatement(sqlQuery);
  1200.                 stm.setLong(1, idServizioApplicativo);
  1201.                 n=stm.executeUpdate();
  1202.                 stm.close();
  1203.                 if (n > 0)
  1204.                     DriverConfigurazioneDB_LIB.logDebug("Deleted " + n + " associazioni di PortaDelegata<->ServizioApplicativo associate al ServizioApplicativo[" + idServizioApplicativo + "]");
  1205.                  */


  1208.                 DriverConfigurazioneDBLib.logDebug("Deleted ...");
  1209.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1210.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_APPLICATIVI);
  1211.                 sqlQueryObject.addWhereCondition("id=?");
  1212.                 sqlQueryObject.addWhereCondition("nome=?");
  1213.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  1214.                 sqlQueryObject.setANDLogicOperator(true);
  1215.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1216.                 stm = con.prepareStatement(sqlQuery);
  1217.                 stm.setLong(1, idServizioApplicativo);
  1218.                 stm.setString(2, nomeSA);
  1219.                 stm.setLong(3, idProprietario);
  1220.                 DriverConfigurazioneDBLib.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idServizioApplicativo,nomeSA,idProprietario));
  1221.                 n=stm.executeUpdate();
  1222.                 stm.close();
  1223.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " row(s)");


  1226.                 //cancello i connettori

  1228.                 // Connettore asincrono
  1229.                 DriverConfigurazioneDBLib.logDebug("Recupero connettore asincrono ...");
  1230.                 if(aSA.getRispostaAsincrona()!=null && aSA.getRispostaAsincrona().getConnettore()!=null){
  1231.                     connettoreRisp=aSA.getRispostaAsincrona().getConnettore();
  1232.                 }else{
  1233.                     connettoreRisp = new Connettore();
  1234.                     connettoreRisp.setTipo(TipiConnettore.DISABILITATO.getNome());
  1235.                 }
  1236.                 nomeConnettoreRisp = "ConnettoreRISP_" + aSA.getNome()+"_"+aSA.getTipoSoggettoProprietario()+aSA.getNomeSoggettoProprietario();
  1237.                 connettoreRisp.setNome(nomeConnettoreRisp);
  1238.                 idConnettoreRisp = DBUtils.getIdConnettore(nomeConnettoreRisp, con, DriverConfigurazioneDBLib.tipoDB);
  1239.                 DriverConfigurazioneDBLib.logDebug("Recupero connettore asincrono id["+idConnettoreRisp+"]");
  1240.                 connettoreRisp.setId(idConnettoreRisp);


  1243.                 // Connettore inv servizio
  1244.                 DriverConfigurazioneDBLib.logDebug("Recupero connettore invocazione servizio ...");
  1245.                 if(aSA.getInvocazioneServizio()!=null && aSA.getInvocazioneServizio().getConnettore()!=null){
  1246.                     connettoreInv=aSA.getInvocazioneServizio().getConnettore();
  1247.                 }else{
  1248.                     connettoreInv = new Connettore();
  1249.                     connettoreInv.setTipo(TipiConnettore.DISABILITATO.getNome());
  1250.                 }
  1251.                 nomeConnettoreInv = "ConnettoreINV_" + aSA.getNome()+"_"+aSA.getTipoSoggettoProprietario()+aSA.getNomeSoggettoProprietario();
  1252.                 connettoreInv.setNome(nomeConnettoreInv);
  1253.                 idConnettoreInv = DBUtils.getIdConnettore(nomeConnettoreInv, con, DriverConfigurazioneDBLib.tipoDB);
  1254.                 DriverConfigurazioneDBLib.logDebug("Recupero connettore invocazione servizio id["+idConnettoreInv+"]");
  1255.                 connettoreInv.setId(idConnettoreInv);


  1258.                 //Controllo consistenza degli id dei connettori in quanto devono essere specificati
  1259.                 //e quindi maggiori di 0
  1260.                 if(idConnettoreInv <=0 || idConnettoreRisp<=0) throw new DriverConfigurazioneException("I connettori del servizio applicativo sono invalidi");

  1262.                 // se il connettore e' abilitato allora propago le modifiche al
  1263.                 // connettore
  1264.                 DriverConfigurazioneDBLib.logDebug("Delete connettore asincrono ...");
  1265.                 DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(CostantiDB.DELETE, connettoreRisp, con, driverBYOK);
  1266.                 DriverConfigurazioneDBLib.logDebug("Delete connettore invocazione servizio ...");
  1267.                 DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(CostantiDB.DELETE, connettoreInv, con, driverBYOK);

  1269.                 
  1270.                 // Delete gestione errore risposta asincrona
  1271.                 if(aSA.getRispostaAsincrona() !=null && aSA.getRispostaAsincrona().getGestioneErrore()!=null){
  1272.                     DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreServizioApplicativo(CostantiDB.DELETE, 
  1273.                             aSA.getRispostaAsincrona().getGestioneErrore(), idProprietario, idServizioApplicativo, false, con);
  1274.                 }
  1275.                 
  1276.                 
  1277.                 // Delete gestione errore invocazione servizio
  1278.                 if(aSA.getInvocazioneServizio() !=null && aSA.getInvocazioneServizio().getGestioneErrore()!=null){
  1279.                     DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreServizioApplicativo(CostantiDB.DELETE, 
  1280.                             aSA.getInvocazioneServizio().getGestioneErrore(), idProprietario, idServizioApplicativo, true, con);
  1281.                 }
  1282.                 

  1284.                 break;

  1286.             }

  1288.             return idServizioApplicativo;
  1289.         } catch (DriverConfigurazioneException e) {
  1290.             throw e;
  1291.         } catch (SQLException se) {
  1292.             throw new DriverConfigurazioneException("SQLException : " + se.getMessage(),se);
  1293.         } catch (Exception se) {
  1294.             throw new DriverConfigurazioneException("Exception : " + se.getMessage(),se);
  1295.         } finally {
  1296.             //Chiudo statement and resultset
  1297.             JDBCUtilities.closeResources(rs, stmQuery);
  1298.             JDBCUtilities.closeResources(stm);
  1299.             JDBCUtilities.closeResources(stm2);
  1300.         }
  1301.     }

  1303.     
  1304.     
  1305.     
  1306.     public static long getIdServizioApplicativo(String nomeServizioApplicativo, String tipoProprietario,String nomeProprietario,
  1307.             Connection con, String tipoDB) throws CoreException
  1308.     {
  1309.         return getIdServizioApplicativo(nomeServizioApplicativo, tipoProprietario, nomeProprietario, con, tipoDB, CostantiDB.SOGGETTI);
  1310.     }
  1311.     public static long getIdServizioApplicativo(String nomeServizioApplicativo, String tipoProprietario,String nomeProprietario,
  1312.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  1313.     {
  1314.         PreparedStatement stm = null;
  1315.         ResultSet rs = null;
  1316.         long idSoggetto;
  1317.         long idServizioApplicativo=-1;

  1319.         try
  1320.         {
  1321.             idSoggetto = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, tipoDB,tabellaSoggetti);

  1323.             //recupero l'id della porta applicativa appena inserita
  1324.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1325.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1326.             sqlQueryObject.addSelectField("id");
  1327.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  1328.             sqlQueryObject.addWhereCondition("nome = ?");
  1329.             sqlQueryObject.setANDLogicOperator(true);
  1330.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1331.             stm=con.prepareStatement(sqlQuery);
  1332.             stm.setLong(1, idSoggetto);
  1333.             stm.setString(2, nomeServizioApplicativo);

  1335.             rs=stm.executeQuery();

  1337.             if(rs.next())
  1338.             {
  1339.                 idServizioApplicativo=rs.getLong("id");
  1340.             }
  1341.             return idServizioApplicativo;
  1342.         }catch (Exception e) {
  1343.             throw new CoreException(e);
  1344.         }finally
  1345.         {
  1346.             //Chiudo statement and resultset
  1347.             JDBCUtilities.closeResources(rs, stm);

  1349.         }
  1350.     }
  1351.     
  1352. }
Created with JaCoCo 0.8.8.202204050719