DriverConfigurazioneDB_porteDelegateLIB.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.util.List;

  33. import org.openspcoop2.core.byok.BYOKUtilities;
  34. import org.openspcoop2.core.byok.BYOKWrappedValue;
  35. import org.openspcoop2.core.byok.IDriverBYOK;
  36. import org.openspcoop2.core.commons.DBUtils;
  37. import org.openspcoop2.core.commons.IExtendedInfo;
  38. import org.openspcoop2.core.config.AttributeAuthority;
  39. import org.openspcoop2.core.config.ConfigurazionePortaHandler;
  40. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  41. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  42. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  43. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  44. import org.openspcoop2.core.config.CorsConfigurazione;
  45. import org.openspcoop2.core.config.GestioneToken;
  46. import org.openspcoop2.core.config.MessageSecurity;
  47. import org.openspcoop2.core.config.MessageSecurityFlow;
  48. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  49. import org.openspcoop2.core.config.MtomProcessor;
  50. import org.openspcoop2.core.config.MtomProcessorFlow;
  51. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  52. import org.openspcoop2.core.config.PortaDelegata;
  53. import org.openspcoop2.core.config.PortaDelegataAzione;
  54. import org.openspcoop2.core.config.PortaDelegataServizio;
  55. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  56. import org.openspcoop2.core.config.PortaDelegataSoggettoErogatore;
  57. import org.openspcoop2.core.config.Proprieta;
  58. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  59. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  60. import org.openspcoop2.core.config.Ruolo;
  61. import org.openspcoop2.core.config.Scope;
  62. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  63. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletrace;
  64. import org.openspcoop2.core.config.constants.MTOMProcessorType;
  65. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  66. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  67. import org.openspcoop2.core.config.constants.StatoFunzionalitaCacheDigestQueryParameter;
  68. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  69. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  70. import org.openspcoop2.core.constants.CRUDType;
  71. import org.openspcoop2.core.constants.CostantiDB;
  72. import org.openspcoop2.utils.date.DateManager;
  73. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  74. import org.openspcoop2.utils.sql.ISQLQueryObject;
  75. import org.openspcoop2.utils.sql.SQLObjectFactory;

  77. /**
  78.  * DriverConfigurazioneDB_soggettiLIB
  79.  * 
  80.  * @author Stefano Corallo - corallo@link.it
  81.  * @author $Author$
  82.  * @version $Rev$, $Date$
  83.  */
  84. public class DriverConfigurazioneDB_porteDelegateLIB {



  88.     
  89.     /**
  90.      * 
  91.      * @param type
  92.      * @param aPD
  93.      * @param con
  94.      * @throws DriverConfigurazioneException
  95.      */
  96.     public static long CRUDPortaDelegata(int type, PortaDelegata aPD, Connection con, IDriverBYOK driverBYOK) throws DriverConfigurazioneException {

  98.         if (aPD == null)
  99.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata] Porta Delegata non valida.");

  101.         // parametri necessari
  102.         String nomePorta = aPD.getNome();
  103.         String nomeProprietario = aPD.getNomeSoggettoProprietario();
  104.         String tipoProprietario = aPD.getTipoSoggettoProprietario();
  105.         if (nomePorta == null || nomePorta.equals(""))
  106.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata] Nome della Porta Delegata non valido.");
  107.         if (nomeProprietario == null || nomeProprietario.equals(""))
  108.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata] Nome proprietario Porta Delegata non valido.");
  109.         if (tipoProprietario == null || tipoProprietario.equals(""))
  110.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata] Tipo proprietario della Porta Delegata non valido.");

  112.         PreparedStatement stm = null;
  113.         String sqlQuery;
  114.         ResultSet rs = null;

  116.         String autenticazione = aPD.getAutenticazione();
  117.         String autorizzazione = aPD.getAutorizzazione();
  118.         String autorizzazioneXacmlPolicy = aPD.getXacmlPolicy();
  119.         String autorizzazioneContenuto = aPD.getAutorizzazioneContenuto();
  120.         String descrizione = aPD.getDescrizione();
  121.         GestioneToken gestioneToken = aPD.getGestioneToken();

  123.         PortaDelegataAzione azione = aPD.getAzione();
  124.         long idAzione = ((azione != null && azione.getId() != null) ? azione.getId() : -1);

  126.         long idSoggettoProprietario;
  127.         try {
  128.             idSoggettoProprietario = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  129.         } catch (Exception e1) {
  130.             throw new DriverConfigurazioneException(e1);
  131.         }
  132.         long idPortaDelegata = -1;

  134.         PortaDelegataSoggettoErogatore soggErogatore = aPD.getSoggettoErogatore();
  135.         long idSoggettoErogatore = ((soggErogatore != null && soggErogatore.getId() != null) ? soggErogatore.getId() : -1);
  136.         /**System.out.println("PRIMA PD SOGGETTO: "+idSoggettoErogatore);*/
  137.         /** SEMPRE, VA AGGIORNATO ANCHE IN UPDATE if(idSoggettoErogatore<=0 &&*/
  138.         if(
  139.                 soggErogatore!=null && soggErogatore.getTipo()!=null && soggErogatore.getNome()!=null) {
  140.             try {
  141.                 idSoggettoErogatore = DBUtils.getIdSoggetto(soggErogatore.getNome(), soggErogatore.getTipo(), con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  142.                 /**System.out.println("DOPO PD SOGGETTO: "+idSoggettoErogatore);*/
  143.             } catch (Exception e1) {
  144.                 DriverConfigurazioneDBLib.logDebug(e1.getMessage(),e1); // potrebbe non esistere la tabella
  145.             }
  146.         }
  147.         
  148.         PortaDelegataServizio servizio = aPD.getServizio();
  149.         long idServizioPD = ((servizio != null && servizio.getId() != null) ? servizio.getId() : -1);
  150.         /**System.out.println("PRIMA PD: "+idServizioPD);*/
  151.         /** SEMPRE, VA AGGIORNATO ANCHE IN UPDATE if(idServizioPD<=0 &&*/
  152.         if(
  153.                 idSoggettoErogatore>0 && servizio!=null && servizio.getTipo()!=null && servizio.getNome()!=null && servizio.getVersione()!=null && servizio.getVersione()>0) {
  154.             try {
  155.                 idServizioPD = DBUtils.getIdServizio(servizio.getNome(), servizio.getTipo(), servizio.getVersione(), idSoggettoErogatore, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  156.                 /**System.out.println("DOPO PD: "+idServizioPD);*/
  157.             } catch (Exception e1) {
  158.                 DriverConfigurazioneDBLib.logDebug(e1.getMessage(),e1); // potrebbe non esistere la tabella
  159.             }
  160.         }

  162.         MtomProcessor mtomProcessor = aPD.getMtomProcessor();
  163.         MTOMProcessorType mtomModeRequest = null;
  164.         MTOMProcessorType mtomModeResponse = null;
  165.         if(mtomProcessor!=null){
  166.             if(mtomProcessor.getRequestFlow()!=null){
  167.                 mtomModeRequest = mtomProcessor.getRequestFlow().getMode();
  168.             }
  169.             if(mtomProcessor.getResponseFlow()!=null){
  170.                 mtomModeResponse = mtomProcessor.getResponseFlow().getMode();
  171.             }
  172.         }
  173.         
  174.         MessageSecurity messageSecurity = aPD.getMessageSecurity();
  175.         String messageSecurityStatus = aPD.getStatoMessageSecurity();
  176.         StatoFunzionalita messageSecurityApplyMtomRequest = null;
  177.         StatoFunzionalita messageSecurityApplyMtomResponse = null;
  178.         String securityRequestMode = null;
  179.         String securityResponseMode = null;
  180.         if(messageSecurity!=null){
  181.             if(messageSecurity.getRequestFlow()!=null){
  182.                 messageSecurityApplyMtomRequest = messageSecurity.getRequestFlow().getApplyToMtom();
  183.                 securityRequestMode = messageSecurity.getRequestFlow().getMode();
  184.             }
  185.             if(messageSecurity.getResponseFlow()!=null){
  186.                 messageSecurityApplyMtomResponse = messageSecurity.getResponseFlow().getApplyToMtom();
  187.                 securityResponseMode = messageSecurity.getResponseFlow().getMode();
  188.             }
  189.         }
  190.         
  191.         CorrelazioneApplicativa corrApp = aPD.getCorrelazioneApplicativa();
  192.         CorrelazioneApplicativaRisposta corrAppRisposta = aPD.getCorrelazioneApplicativaRisposta();
  193.         
  194.         String msgDiagSeverita = null;
  195.         String tracciamentoStato = null;
  196.         String tracciamentoEsiti = null;
  197.         String transazioniTempiElaborazione = null;
  198.         String transazioniToken = null;
  199.         TracciamentoConfigurazione tracciamentoDatabase = null;
  200.         TracciamentoConfigurazione tracciamentoFiletrace = null;
  201.         TracciamentoConfigurazioneFiletrace tracciamentoFiletraceDetails = null;
  202.         if(aPD.getTracciamento()!=null){
  203.             msgDiagSeverita = DriverConfigurazioneDBLib.getValue(aPD.getTracciamento().getSeverita());
  204.             tracciamentoStato =  DriverConfigurazioneDBLib.getValue(aPD.getTracciamento().getStato());
  205.             tracciamentoEsiti = aPD.getTracciamento().getEsiti();
  206.             if(aPD.getTracciamento().getTransazioni()!=null) {
  207.                 transazioniTempiElaborazione = DriverConfigurazioneDBLib.getValue(aPD.getTracciamento().getTransazioni().getTempiElaborazione());
  208.                 transazioniToken = DriverConfigurazioneDBLib.getValue(aPD.getTracciamento().getTransazioni().getToken());
  209.             }
  210.             tracciamentoDatabase = aPD.getTracciamento().getDatabase();
  211.             tracciamentoFiletrace = aPD.getTracciamento().getFiletrace();
  212.             tracciamentoFiletraceDetails = aPD.getTracciamento().getFiletraceConfig();
  213.         }
  214.         
  215.         CorsConfigurazione corsConfigurazione = aPD.getGestioneCors();
  216.         String corsStato = null;
  217.         String corsTipo = null; 
  218.         String corsAllAllowOrigins = null; 
  219.         String corsAllAllowMethods = null; 
  220.         String corsAllAllowHeaders = null; 
  221.         String corsAllowCredentials = null; 
  222.         int corsAllowMaxAge = CostantiDB.FALSE;
  223.         Integer corsAllowMaxAgeSeconds = null;
  224.         String corsAllowOrigins = null; 
  225.         String corsAllowHeaders = null; 
  226.         String corsAllowMethods = null; 
  227.         String corsAllowExposeHeaders = null; 
  228.         if(corsConfigurazione!=null) {
  229.             corsStato = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getStato());
  230.             corsTipo = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getTipo());
  231.             corsAllAllowOrigins = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllAllowOrigins());
  232.             corsAllAllowMethods = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllAllowMethods());
  233.             corsAllAllowHeaders = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllAllowHeaders());
  234.             corsAllowCredentials = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllowCredentials());
  235.             if(corsConfigurazione.getAccessControlMaxAge()!=null) {
  236.                 corsAllowMaxAge = CostantiDB.TRUE;
  237.                 corsAllowMaxAgeSeconds = corsConfigurazione.getAccessControlMaxAge();   
  238.             }
  239.             if(corsConfigurazione.getAccessControlAllowOrigins()!=null && corsConfigurazione.getAccessControlAllowOrigins().sizeOriginList()>0) {
  240.                 StringBuilder bf = new StringBuilder();
  241.                 for (int i = 0; i < corsConfigurazione.getAccessControlAllowOrigins().sizeOriginList(); i++) {
  242.                     if(i>0) {
  243.                         bf.append(",");
  244.                     }
  245.                     bf.append(corsConfigurazione.getAccessControlAllowOrigins().getOrigin(i));
  246.                 }
  247.                 corsAllowOrigins = bf.toString();
  248.             }
  249.             if(corsConfigurazione.getAccessControlAllowHeaders()!=null && corsConfigurazione.getAccessControlAllowHeaders().sizeHeaderList()>0) {
  250.                 StringBuilder bf = new StringBuilder();
  251.                 for (int i = 0; i < corsConfigurazione.getAccessControlAllowHeaders().sizeHeaderList(); i++) {
  252.                     if(i>0) {
  253.                         bf.append(",");
  254.                     }
  255.                     bf.append(corsConfigurazione.getAccessControlAllowHeaders().getHeader(i));
  256.                 }
  257.                 corsAllowHeaders = bf.toString();
  258.             }
  259.             if(corsConfigurazione.getAccessControlAllowMethods()!=null && corsConfigurazione.getAccessControlAllowMethods().sizeMethodList()>0) {
  260.                 StringBuilder bf = new StringBuilder();
  261.                 for (int i = 0; i < corsConfigurazione.getAccessControlAllowMethods().sizeMethodList(); i++) {
  262.                     if(i>0) {
  263.                         bf.append(",");
  264.                     }
  265.                     bf.append(corsConfigurazione.getAccessControlAllowMethods().getMethod(i));
  266.                 }
  267.                 corsAllowMethods = bf.toString();
  268.             }
  269.             if(corsConfigurazione.getAccessControlExposeHeaders()!=null && corsConfigurazione.getAccessControlExposeHeaders().sizeHeaderList()>0) {
  270.                 StringBuilder bf = new StringBuilder();
  271.                 for (int i = 0; i < corsConfigurazione.getAccessControlExposeHeaders().sizeHeaderList(); i++) {
  272.                     if(i>0) {
  273.                         bf.append(",");
  274.                     }
  275.                     bf.append(corsConfigurazione.getAccessControlExposeHeaders().getHeader(i));
  276.                 }
  277.                 corsAllowExposeHeaders = bf.toString();
  278.             }
  279.         }
  280.         
  281.         ResponseCachingConfigurazione responseCachingConfigurazone = aPD.getResponseCaching();
  282.         String responseCacheStato = null;
  283.         Integer responseCacheSeconds = null;
  284.         Long responseCacheMaxMsgSize = null;
  285.         String responseCacheHashUrl = null;
  286.         String responseCacheHashQuery = null;
  287.         String responseCacheHashQueryList = null;
  288.         String responseCacheHashHeaders = null;
  289.         String responseCacheHashHeadersList = null;
  290.         String responseCacheHashPayload = null;
  291.         boolean responseCacheNoCache = true;
  292.         boolean responseCacheMaxAge = true;
  293.         boolean responseCacheNoStore = true;
  294.         List<ResponseCachingConfigurazioneRegola> responseCacheRegole = null;
  295.         if(responseCachingConfigurazone!=null) {
  296.             responseCacheStato = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazone.getStato());
  297.             responseCacheSeconds = responseCachingConfigurazone.getCacheTimeoutSeconds();
  298.             responseCacheMaxMsgSize = responseCachingConfigurazone.getMaxMessageSize();
  299.             if(responseCachingConfigurazone.getControl()!=null) {
  300.                 responseCacheNoCache = responseCachingConfigurazone.getControl().getNoCache();
  301.                 responseCacheMaxAge = responseCachingConfigurazone.getControl().getMaxAge();
  302.                 responseCacheNoStore = responseCachingConfigurazone.getControl().getNoStore();
  303.             }
  304.             if(responseCachingConfigurazone.getHashGenerator()!=null) {
  305.                 responseCacheHashUrl = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazone.getHashGenerator().getRequestUri());
  306.                 
  307.                 responseCacheHashQuery = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazone.getHashGenerator().getQueryParameters());
  308.                 if(StatoFunzionalitaCacheDigestQueryParameter.SELEZIONE_PUNTUALE.equals(responseCachingConfigurazone.getHashGenerator().getQueryParameters()) &&
  309.                     (responseCachingConfigurazone.getHashGenerator().getQueryParameterList()!=null && responseCachingConfigurazone.getHashGenerator().sizeQueryParameterList()>0) 
  310.                     ){
  311.                     StringBuilder bf = new StringBuilder();
  312.                     for (int i = 0; i < responseCachingConfigurazone.getHashGenerator().sizeQueryParameterList(); i++) {
  313.                         if(i>0) {
  314.                             bf.append(",");
  315.                         }
  316.                         bf.append(responseCachingConfigurazone.getHashGenerator().getQueryParameter(i));
  317.                     }
  318.                     responseCacheHashQueryList = bf.toString();
  319.                 }
  320.                 
  321.                 responseCacheHashHeaders = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazone.getHashGenerator().getHeaders());
  322.                 if(StatoFunzionalita.ABILITATO.equals(responseCachingConfigurazone.getHashGenerator().getHeaders()) &&
  323.                     (responseCachingConfigurazone.getHashGenerator().getHeaderList()!=null && responseCachingConfigurazone.getHashGenerator().sizeHeaderList()>0) 
  324.                     ){
  325.                     StringBuilder bf = new StringBuilder();
  326.                     for (int i = 0; i < responseCachingConfigurazone.getHashGenerator().sizeHeaderList(); i++) {
  327.                         if(i>0) {
  328.                             bf.append(",");
  329.                         }
  330.                         bf.append(responseCachingConfigurazone.getHashGenerator().getHeader(i));
  331.                     }
  332.                     responseCacheHashHeadersList = bf.toString();
  333.                 }
  334.                 
  335.                 responseCacheHashPayload = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazone.getHashGenerator().getPayload());
  336.             }
  337.             responseCacheRegole = responseCachingConfigurazone.getRegolaList();
  338.         }
  339.         
  340.         ConfigurazionePortaHandler configHandlers = aPD.getConfigurazioneHandler();
  341.         
  342.         ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  343.         IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoPortaDelegata();
  344.         
  345.         try {
  346.             int n = 0;
  347.             int i = 0;
  348.             switch (type) {
  349.             case CREATE:

  351.                 //soggetto erogatore
  352.                 String tipoSoggErogatore = (soggErogatore != null ? soggErogatore.getTipo() : null);
  353.                 String nomeSoggErogatore = (soggErogatore != null ? soggErogatore.getNome() : null);
  354.                 if(tipoSoggErogatore==null || tipoSoggErogatore.equals("")) throw new DriverConfigurazioneException("Tipo Soggetto Erogatore non impostato.");
  355.                 if(nomeSoggErogatore==null || nomeSoggErogatore.equals("")) throw new DriverConfigurazioneException("Nome Soggetto Erogatore non impostato.");

  357.                 //servizio
  358.                 String tipoServizio = (servizio != null ? servizio.getTipo() : null);
  359.                 String nomeServizio = (servizio != null ? servizio.getNome() : null);
  360.                 Integer versioneServizio = (servizio != null ? servizio.getVersione() : null);
  361.                 if(tipoServizio==null || tipoServizio.equals("")) throw new DriverConfigurazioneException("Tipo Servizio non impostato.");
  362.                 if(nomeServizio==null || nomeServizio.equals("")) throw new DriverConfigurazioneException("Nome Servizio non impostato.");
  363.                 if(versioneServizio==null) throw new DriverConfigurazioneException("Versione Servizio non impostato.");

  365.                 //Azione
  366.                 String nomeAzione = (azione != null ? azione.getNome() : null);
  367.                 String patternAzione = (azione != null ? azione.getPattern() : null);
  368.                 String nomePortaDeleganteAzione = (azione != null ? azione.getNomePortaDelegante() : null);
  369.                 StatoFunzionalita forceInterfaceBased = (azione != null ? azione.getForceInterfaceBased() : null);
  370.                 PortaDelegataAzioneIdentificazione modeAzione = (azione != null ? azione.getIdentificazione() : null);
  371.                 //Se il bean Azione nn e' presente allora non controllo nulla
  372.                 if(azione!=null){
  373.                     if(modeAzione==null || modeAzione.equals("")) 
  374.                         modeAzione = PortaDelegataAzioneIdentificazione.STATIC;
  375.                     switch (modeAzione) {
  376.                     case CONTENT_BASED:
  377.                     case URL_BASED:
  378.                     case HEADER_BASED:
  379.                         if(patternAzione==null || patternAzione.equals("")) throw new DriverConfigurazioneException("Pattern Azione non impostato.");
  380.                         nomeAzione=null;
  381.                         break;
  382.                     case DELEGATED_BY:
  383.                         if(nomePortaDeleganteAzione==null || nomePortaDeleganteAzione.equals("")) throw new DriverConfigurazioneException("Nome Porta Delegante Azione non impostata.");
  384.                         nomeAzione=null;
  385.                         break;
  386.                     case INPUT_BASED:
  387.                     case SOAP_ACTION_BASED:
  388.                     case INTERFACE_BASED:
  389.                         //nessun campo obbligatorio
  390.                         break;
  391.                     case STATIC:
  392.                         //se non c'e' l'id dell'azione ci deve essere il nome
  393.                         if(idAzione<=0){
  394.                             if(nomeAzione==null || nomeAzione.equals("")) throw new DriverConfigurazioneException("Nome Azione non impostato.");
  395.                         }
  396.                         patternAzione=null;
  397.                         break;
  398.                     default:
  399.                         break;
  400.                     }
  401.                 }
  402.                 
  403.                 String utenteRichiedente = null;
  404.                 if(aPD.getProprietaOggetto()!=null && aPD.getProprietaOggetto().getUtenteRichiedente()!=null) {
  405.                     utenteRichiedente = aPD.getProprietaOggetto().getUtenteRichiedente();
  406.                 }
  407.                 else {
  408.                     utenteRichiedente = DBUtils.getSuperUserServizioSafe(DriverConfigurazioneDBLib.log, "CRUDPortaApplicativa",
  409.                             idServizioPD, con, DriverConfigurazioneDBLib.tipoDB);
  410.                 }
  411.                 
  412.                 Timestamp dataCreazione = null;
  413.                 if(aPD.getProprietaOggetto()!=null && aPD.getProprietaOggetto().getDataCreazione()!=null) {
  414.                     dataCreazione = new Timestamp(aPD.getProprietaOggetto().getDataCreazione().getTime());
  415.                 }
  416.                 else if(aPD.getOraRegistrazione()!=null){
  417.                     dataCreazione = new Timestamp(aPD.getOraRegistrazione().getTime());
  418.                 }
  419.                 else {
  420.                     dataCreazione = DateManager.getTimestamp();
  421.                 }

  423.                 // create
  424.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  425.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE);
  426.                 sqlQueryObject.addInsertField("nome_porta", "?");
  427.                 sqlQueryObject.addInsertField("descrizione", "?");
  428.                 sqlQueryObject.addInsertField("id_soggetto_erogatore", "?");
  429.                 sqlQueryObject.addInsertField("tipo_soggetto_erogatore", "?");
  430.                 sqlQueryObject.addInsertField("nome_soggetto_erogatore", "?");
  431.                 sqlQueryObject.addInsertField("id_servizio", "?");
  432.                 sqlQueryObject.addInsertField("tipo_servizio", "?");
  433.                 sqlQueryObject.addInsertField("nome_servizio", "?");
  434.                 sqlQueryObject.addInsertField("versione_servizio", "?");
  435.                 sqlQueryObject.addInsertField("id_azione", "?");
  436.                 sqlQueryObject.addInsertField("nome_azione", "?");
  437.                 sqlQueryObject.addInsertField("mode_azione", "?");
  438.                 sqlQueryObject.addInsertField("pattern_azione", "?");
  439.                 sqlQueryObject.addInsertField("nome_porta_delegante_azione", "?");
  440.                 sqlQueryObject.addInsertField("force_interface_based_azione", "?");
  441.                 sqlQueryObject.addInsertField("autenticazione", "?");
  442.                 sqlQueryObject.addInsertField("autenticazione_opzionale", "?");
  443.                 sqlQueryObject.addInsertField("token_policy", "?");
  444.                 sqlQueryObject.addInsertField("token_opzionale", "?");
  445.                 sqlQueryObject.addInsertField("token_validazione", "?");
  446.                 sqlQueryObject.addInsertField("token_introspection", "?");
  447.                 sqlQueryObject.addInsertField("token_user_info", "?");
  448.                 sqlQueryObject.addInsertField("token_forward", "?");
  449.                 sqlQueryObject.addInsertField("token_options", "?");
  450.                 sqlQueryObject.addInsertField("token_authn_issuer", "?");
  451.                 sqlQueryObject.addInsertField("token_authn_client_id", "?");
  452.                 sqlQueryObject.addInsertField("token_authn_subject", "?");
  453.                 sqlQueryObject.addInsertField("token_authn_username", "?");
  454.                 sqlQueryObject.addInsertField("token_authn_email", "?");
  455.                 sqlQueryObject.addInsertField("autorizzazione", "?");
  456.                 sqlQueryObject.addInsertField("autorizzazione_xacml", "?");
  457.                 sqlQueryObject.addInsertField("autorizzazione_contenuto", "?");
  458.                 sqlQueryObject.addInsertField("mtom_request_mode", "?");
  459.                 sqlQueryObject.addInsertField("mtom_response_mode", "?");
  460.                 sqlQueryObject.addInsertField("security", "?");
  461.                 sqlQueryObject.addInsertField("security_mtom_req", "?");
  462.                 sqlQueryObject.addInsertField("security_mtom_res", "?");
  463.                 sqlQueryObject.addInsertField("security_request_mode", "?");
  464.                 sqlQueryObject.addInsertField("security_response_mode", "?");
  465.                 sqlQueryObject.addInsertField("id_soggetto", "?");
  466.                 sqlQueryObject.addInsertField("ricevuta_asincrona_sim", "?");
  467.                 sqlQueryObject.addInsertField("ricevuta_asincrona_asim", "?");
  468.                 sqlQueryObject.addInsertField("integrazione", "?");
  469.                 sqlQueryObject.addInsertField("scadenza_correlazione_appl", "?");
  470.                 sqlQueryObject.addInsertField("validazione_contenuti_stato", "?");
  471.                 sqlQueryObject.addInsertField("validazione_contenuti_tipo", "?");
  472.                 sqlQueryObject.addInsertField("validazione_contenuti_mtom", "?");
  473.                 sqlQueryObject.addInsertField("allega_body", "?");
  474.                 sqlQueryObject.addInsertField("scarta_body", "?");
  475.                 sqlQueryObject.addInsertField("gestione_manifest", "?");
  476.                 sqlQueryObject.addInsertField("stateless", "?");
  477.                 sqlQueryObject.addInsertField("local_forward", "?");
  478.                 sqlQueryObject.addInsertField("local_forward_pa", "?");
  479.                 sqlQueryObject.addInsertField("ruoli_match", "?");
  480.                 sqlQueryObject.addInsertField("token_sa_stato", "?");
  481.                 sqlQueryObject.addInsertField("token_ruoli_stato", "?");
  482.                 sqlQueryObject.addInsertField("token_ruoli_match", "?");
  483.                 sqlQueryObject.addInsertField("token_ruoli_tipologia", "?");
  484.                 sqlQueryObject.addInsertField("scope_stato", "?");
  485.                 sqlQueryObject.addInsertField("scope_match", "?");
  486.                 sqlQueryObject.addInsertField("ricerca_porta_azione_delegata", "?");
  487.                 sqlQueryObject.addInsertField("msg_diag_severita", "?");
  488.                 sqlQueryObject.addInsertField("tracciamento_stato", "?");
  489.                 sqlQueryObject.addInsertField("tracciamento_esiti", "?");
  490.                 sqlQueryObject.addInsertField("transazioni_tempi", "?");
  491.                 sqlQueryObject.addInsertField("transazioni_token", "?");
  492.                 sqlQueryObject.addInsertField("stato", "?");
  493.                 // cors
  494.                 sqlQueryObject.addInsertField("cors_stato", "?");
  495.                 sqlQueryObject.addInsertField("cors_tipo", "?");
  496.                 sqlQueryObject.addInsertField("cors_all_allow_origins", "?");
  497.                 sqlQueryObject.addInsertField("cors_all_allow_methods", "?");
  498.                 sqlQueryObject.addInsertField("cors_all_allow_headers", "?");
  499.                 sqlQueryObject.addInsertField("cors_allow_credentials", "?");
  500.                 sqlQueryObject.addInsertField("cors_allow_max_age", "?");
  501.                 sqlQueryObject.addInsertField("cors_allow_max_age_seconds", "?");
  502.                 sqlQueryObject.addInsertField("cors_allow_origins", "?");
  503.                 sqlQueryObject.addInsertField("cors_allow_headers", "?");
  504.                 sqlQueryObject.addInsertField("cors_allow_methods", "?");
  505.                 sqlQueryObject.addInsertField("cors_allow_expose_headers", "?");
  506.                 // responseCaching
  507.                 sqlQueryObject.addInsertField("response_cache_stato", "?");
  508.                 sqlQueryObject.addInsertField("response_cache_seconds", "?");
  509.                 sqlQueryObject.addInsertField("response_cache_max_msg_size", "?");
  510.                 sqlQueryObject.addInsertField("response_cache_control_nocache", "?");
  511.                 sqlQueryObject.addInsertField("response_cache_control_maxage", "?");
  512.                 sqlQueryObject.addInsertField("response_cache_control_nostore", "?");
  513.                 sqlQueryObject.addInsertField("response_cache_hash_url", "?");
  514.                 sqlQueryObject.addInsertField("response_cache_hash_query", "?");
  515.                 sqlQueryObject.addInsertField("response_cache_hash_query_list", "?");
  516.                 sqlQueryObject.addInsertField("response_cache_hash_headers", "?");
  517.                 sqlQueryObject.addInsertField("response_cache_hash_hdr_list", "?");
  518.                 sqlQueryObject.addInsertField("response_cache_hash_payload", "?");
  519.                 // id
  520.                 sqlQueryObject.addInsertField("id_accordo", "?");
  521.                 sqlQueryObject.addInsertField("id_port_type", "?");
  522.                 // options
  523.                 sqlQueryObject.addInsertField("options", "?");
  524.                 // options
  525.                 sqlQueryObject.addInsertField("canale", "?");
  526.                 if(utenteRichiedente!=null) {
  527.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  528.                 }
  529.                 if(dataCreazione!=null) {
  530.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  531.                 }
  532.                 sqlQuery = sqlQueryObject.createSQLInsert();
  533.                 stm = con.prepareStatement(sqlQuery);
  534.                 int index = 1;
  535.                 stm.setString(index++, nomePorta);
  536.                 stm.setString(index++, descrizione);
  537.                 stm.setLong(index++, idSoggettoErogatore);              
  538.                 stm.setString(index++, tipoSoggErogatore);
  539.                 stm.setString(index++, nomeSoggErogatore);
  540.                 stm.setLong(index++, idServizioPD);
  541.                 stm.setString(index++, tipoServizio);
  542.                 stm.setString(index++, nomeServizio);
  543.                 stm.setInt(index++, versioneServizio);
  544.                 stm.setLong(index++, idAzione);
  545.                 stm.setString(index++, nomeAzione);
  546.                 if(modeAzione!=null){
  547.                     stm.setString(index++, modeAzione.toString());
  548.                 }
  549.                 else{
  550.                     stm.setString(index++, null);
  551.                 }
  552.                 stm.setString(index++, patternAzione);
  553.                 stm.setString(index++, nomePortaDeleganteAzione);
  554.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(forceInterfaceBased));
  555.                 // autenticazione
  556.                 stm.setString(index++, autenticazione);
  557.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getAutenticazioneOpzionale()) : null);
  558.                 // token
  559.                 stm.setString(index++, gestioneToken!=null ? gestioneToken.getPolicy() : null);
  560.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getTokenOpzionale()) : null);
  561.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getValidazione()) : null);
  562.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getIntrospection()) : null);
  563.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getUserInfo()) : null);
  564.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getForward()) : null);
  565.                 stm.setString(index++, gestioneToken!=null ? gestioneToken.getOptions() : null);
  566.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  567.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getIssuer()) : null);
  568.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  569.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getClientId()) : null);
  570.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  571.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getSubject()) : null);
  572.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  573.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getUsername()) : null);
  574.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  575.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getEmail()) : null);
  576.                 // autorizzazione
  577.                 stm.setString(index++, autorizzazione);
  578.                 stm.setString(index++, autorizzazioneXacmlPolicy);
  579.                 stm.setString(index++, autorizzazioneContenuto);
  580.                 // mtom
  581.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(mtomModeRequest));
  582.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(mtomModeResponse));
  583.                 // messageSecurity
  584.                 stm.setString(index++, messageSecurityStatus);
  585.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(messageSecurityApplyMtomRequest));
  586.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(messageSecurityApplyMtomResponse));
  587.                 stm.setString(index++, securityRequestMode);
  588.                 stm.setString(index++, securityResponseMode);
  589.                 // proprietario
  590.                 stm.setLong(index++, idSoggettoProprietario);
  591.                 //ricevuta asincrona_asimmetrica/simmetrica
  592.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(aPD.getRicevutaAsincronaSimmetrica()));
  593.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(aPD.getRicevutaAsincronaAsimmetrica()));              
  594.                 //integrazione
  595.                 stm.setString(index++, aPD.getIntegrazione());
  596.                 //correlazione applicativa scadenza
  597.                 stm.setString(index++, aPD.getCorrelazioneApplicativa()!=null ? aPD.getCorrelazioneApplicativa().getScadenza() : null);
  598.                 //validazione xsd
  599.                 stm.setString(index++, aPD.getValidazioneContenutiApplicativi()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getValidazioneContenutiApplicativi().getStato()) : null);
  600.                 stm.setString(index++, aPD.getValidazioneContenutiApplicativi()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getValidazioneContenutiApplicativi().getTipo()) : null);
  601.                 stm.setString(index++, aPD.getValidazioneContenutiApplicativi()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getValidazioneContenutiApplicativi().getAcceptMtomMessage()) : null);

  603.                 // InvocazionePorta: funzionalita' attachment
  604.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getAllegaBody()) : null);
  605.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getScartaBody()) : null);
  606.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getGestioneManifest()) : null);
  607.                 
  608.                 // Stateless
  609.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getStateless()) : null);
  610.                 
  611.                 // LocalForward
  612.                 stm.setString(index++, aPD!=null && aPD.getLocalForward()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getLocalForward().getStato()) : null);
  613.                 stm.setString(index++, aPD!=null && aPD.getLocalForward()!=null ? aPD.getLocalForward().getPortaApplicativa() : null);
  614.                 
  615.                 // Ruoli
  616.                 stm.setString(index++, aPD!=null && aPD.getRuoli()!=null && aPD.getRuoli().getMatch()!=null ? 
  617.                         aPD.getRuoli().getMatch().getValue() : null);
  618.                 
  619.                 // Token sa
  620.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getAutorizzazioneApplicativi()!=null ? 
  621.                         DriverConfigurazioneDBLib.getValue(aPD.getAutorizzazioneToken().getAutorizzazioneApplicativi()) : null);
  622.                 
  623.                 // Token ruoli
  624.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getAutorizzazioneRuoli()!=null ? 
  625.                         DriverConfigurazioneDBLib.getValue(aPD.getAutorizzazioneToken().getAutorizzazioneRuoli()) : null);
  626.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getRuoli()!=null && 
  627.                         aPD.getAutorizzazioneToken().getRuoli().getMatch()!=null ? 
  628.                         aPD.getAutorizzazioneToken().getRuoli().getMatch().getValue() : null);
  629.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getTipologiaRuoli()!=null ? 
  630.                         aPD.getAutorizzazioneToken().getTipologiaRuoli().getValue() : null);
  631.                 
  632.                 // Scope
  633.                 stm.setString(index++, aPD!=null && aPD.getScope()!=null && aPD.getScope().getStato()!=null ? 
  634.                         DriverConfigurazioneDBLib.getValue(aPD.getScope().getStato()) : null);
  635.                 stm.setString(index++, aPD!=null && aPD.getScope()!=null && aPD.getScope().getMatch()!=null ? 
  636.                         aPD.getScope().getMatch().getValue() : null);
  637.                 
  638.                 // Ricerca Porta Azione Delegata
  639.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getRicercaPortaAzioneDelegata()) : null);
  640.                 
  641.                 // Tracciamento
  642.                 stm.setString(index++, msgDiagSeverita);
  643.                 stm.setString(index++, tracciamentoStato);
  644.                 stm.setString(index++, tracciamentoEsiti);
  645.                 stm.setString(index++, transazioniTempiElaborazione);
  646.                 stm.setString(index++, transazioniToken);
  647.                 
  648.                 // Stato
  649.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getStato()) : null);
  650.                 
  651.                 // cors
  652.                 stm.setString(index++, corsStato);
  653.                 stm.setString(index++, corsTipo);
  654.                 stm.setString(index++, corsAllAllowOrigins);
  655.                 stm.setString(index++, corsAllAllowMethods);
  656.                 stm.setString(index++, corsAllAllowHeaders);
  657.                 stm.setString(index++, corsAllowCredentials);
  658.                 stm.setInt(index++, corsAllowMaxAge);
  659.                 if(corsAllowMaxAgeSeconds!=null) {
  660.                     stm.setInt(index++, corsAllowMaxAgeSeconds);
  661.                 }
  662.                 else {
  663.                     stm.setNull(index++, java.sql.Types.INTEGER);
  664.                 }
  665.                 stm.setString(index++, corsAllowOrigins);
  666.                 stm.setString(index++, corsAllowHeaders);
  667.                 stm.setString(index++, corsAllowMethods);
  668.                 stm.setString(index++, corsAllowExposeHeaders);
  669.                 
  670.                 // responseCaching
  671.                 stm.setString(index++, responseCacheStato);
  672.                 if(responseCacheSeconds!=null) {
  673.                     stm.setInt(index++, responseCacheSeconds);
  674.                 }
  675.                 else {
  676.                     stm.setNull(index++, java.sql.Types.INTEGER);
  677.                 }
  678.                 if(responseCacheMaxMsgSize!=null) {
  679.                     stm.setLong(index++, responseCacheMaxMsgSize);
  680.                 }
  681.                 else {
  682.                     stm.setNull(index++, java.sql.Types.BIGINT);
  683.                 }
  684.                 stm.setInt(index++, responseCacheNoCache ? CostantiDB.TRUE : CostantiDB.FALSE);
  685.                 stm.setInt(index++, responseCacheMaxAge ? CostantiDB.TRUE : CostantiDB.FALSE);
  686.                 stm.setInt(index++, responseCacheNoStore ? CostantiDB.TRUE : CostantiDB.FALSE);
  687.                 stm.setString(index++, responseCacheHashUrl);
  688.                 stm.setString(index++, responseCacheHashQuery);
  689.                 stm.setString(index++, responseCacheHashQueryList);
  690.                 stm.setString(index++, responseCacheHashHeaders);
  691.                 stm.setString(index++, responseCacheHashHeadersList);
  692.                 stm.setString(index++, responseCacheHashPayload);
  693.                 
  694.                 //idaccordo
  695.                 stm.setLong(index++, aPD.getIdAccordo()!=null ? aPD.getIdAccordo() : -1L);
  696.                 stm.setLong(index++, aPD.getIdPortType() !=null ? aPD.getIdPortType() : -1L);
  697.                 
  698.                 // options
  699.                 stm.setString(index++, aPD.getOptions());
  700.                 
  701.                 // canale
  702.                 stm.setString(index++, aPD.getCanale());
  703.                 
  704.                 if(utenteRichiedente!=null) {
  705.                     stm.setString(index++, utenteRichiedente);
  706.                 }
  707.                 
  708.                 if(dataCreazione!=null) {
  709.                     stm.setTimestamp(index++, dataCreazione);
  710.                 }
  711.                 
  712.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + 
  713.                         DBUtils.formatSQLString(sqlQuery, nomePorta, descrizione, 
  714.                                 idSoggettoErogatore, tipoSoggErogatore, nomeSoggErogatore, 
  715.                                 idServizioPD, tipoServizio, nomeServizio, 
  716.                                 idAzione, nomeAzione, modeAzione, patternAzione, nomePortaDeleganteAzione, DriverConfigurazioneDBLib.getValue(forceInterfaceBased),
  717.                                 autenticazione, aPD.getAutenticazioneOpzionale(),
  718.                                 (gestioneToken!=null ? gestioneToken.getPolicy() : null),
  719.                                 (gestioneToken!=null ? gestioneToken.getTokenOpzionale() : null),
  720.                                 (gestioneToken!=null ? gestioneToken.getValidazione() : null),
  721.                                 (gestioneToken!=null ? gestioneToken.getIntrospection() : null),
  722.                                 (gestioneToken!=null ? gestioneToken.getUserInfo() : null),
  723.                                 (gestioneToken!=null ? gestioneToken.getForward() : null),
  724.                                 (gestioneToken!=null ? gestioneToken.getOptions() : null),
  725.                                 ((gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? gestioneToken.getAutenticazione().getIssuer() : null),
  726.                                 ((gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? gestioneToken.getAutenticazione().getClientId() : null),
  727.                                 ((gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? gestioneToken.getAutenticazione().getSubject() : null),
  728.                                 ((gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? gestioneToken.getAutenticazione().getUsername() : null),
  729.                                 ((gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? gestioneToken.getAutenticazione().getEmail() : null),
  730.                                 autorizzazione, autorizzazioneXacmlPolicy, autorizzazioneContenuto,
  731.                                 mtomModeRequest, mtomModeResponse,
  732.                                 messageSecurityStatus, messageSecurityApplyMtomRequest, messageSecurityApplyMtomResponse, securityRequestMode, securityResponseMode,
  733.                                 idSoggettoProprietario,
  734.                                 aPD.getRicevutaAsincronaSimmetrica(),aPD.getRicevutaAsincronaAsimmetrica(),aPD.getIntegrazione(),
  735.                                 (aPD.getCorrelazioneApplicativa()!=null ? aPD.getCorrelazioneApplicativa().getScadenza() : null),
  736.                                 (aPD.getValidazioneContenutiApplicativi()!=null ? aPD.getValidazioneContenutiApplicativi().getStato() : null),
  737.                                 (aPD.getValidazioneContenutiApplicativi()!=null ? aPD.getValidazioneContenutiApplicativi().getTipo() : null),
  738.                                 (aPD.getValidazioneContenutiApplicativi()!=null ? aPD.getValidazioneContenutiApplicativi().getAcceptMtomMessage() : null),
  739.                                 aPD.getAllegaBody(),aPD.getScartaBody(),aPD.getGestioneManifest(),aPD.getStateless(),aPD.getLocalForward(),
  740.                                 (aPD!=null && aPD.getRuoli()!=null && aPD.getRuoli().getMatch()!=null ? 
  741.                                         aPD.getRuoli().getMatch().getValue() : null),
  742.                                 (aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getAutorizzazioneApplicativi()!=null ? 
  743.                                         DriverConfigurazioneDBLib.getValue(aPD.getAutorizzazioneToken().getAutorizzazioneApplicativi()) : null),
  744.                                 (aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getAutorizzazioneRuoli()!=null ? 
  745.                                         DriverConfigurazioneDBLib.getValue(aPD.getAutorizzazioneToken().getAutorizzazioneRuoli()) : null),
  746.                                 (aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getRuoli()!=null && 
  747.                                     aPD.getAutorizzazioneToken().getRuoli().getMatch()!=null ? 
  748.                                         aPD.getAutorizzazioneToken().getRuoli().getMatch().getValue() : null),
  749.                                 (aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getTipologiaRuoli()!=null ? 
  750.                                         aPD.getAutorizzazioneToken().getTipologiaRuoli().getValue() : null),
  751.                                 (aPD!=null && aPD.getScope()!=null && aPD.getScope().getStato()!=null ? 
  752.                                         aPD.getScope().getStato() : null),
  753.                                 (aPD!=null && aPD.getScope()!=null && aPD.getScope().getMatch()!=null ? 
  754.                                         aPD.getScope().getMatch().getValue() : null),
  755.                                 aPD.getRicercaPortaAzioneDelegata(),
  756.                                 msgDiagSeverita,tracciamentoStato,tracciamentoEsiti,transazioniTempiElaborazione,transazioniToken,
  757.                                 aPD.getStato(),
  758.                                 corsStato, corsTipo, corsAllAllowOrigins, corsAllAllowMethods, corsAllAllowHeaders, corsAllowCredentials, corsAllowMaxAge, corsAllowMaxAgeSeconds,
  759.                                 corsAllowOrigins, corsAllowHeaders, corsAllowMethods, corsAllowExposeHeaders,
  760.                                 responseCacheStato, responseCacheSeconds, responseCacheMaxMsgSize, 
  761.                                 (responseCacheNoCache ? CostantiDB.TRUE : CostantiDB.FALSE),
  762.                                 (responseCacheMaxAge ? CostantiDB.TRUE : CostantiDB.FALSE),
  763.                                 (responseCacheNoStore ? CostantiDB.TRUE : CostantiDB.FALSE),
  764.                                 responseCacheHashUrl, responseCacheHashQuery, responseCacheHashQueryList, responseCacheHashHeaders, responseCacheHashHeadersList, responseCacheHashPayload,
  765.                                 aPD.getIdAccordo(),aPD.getIdPortType(),
  766.                                 aPD.getOptions(),
  767.                                 aPD.getCanale()));
  768.                 n = stm.executeUpdate();
  769.                 stm.close();

  771.                 DriverConfigurazioneDBLib.logDebug("Inserted " + n + " row(s).");

  773.                 // recupero l'id della porta delegata appena inserita
  774.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  775.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  776.                 sqlQueryObject.addSelectField("id");
  777.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  778.                 sqlQueryObject.addWhereCondition("nome_porta = ?");
  779.                 sqlQueryObject.setANDLogicOperator(true);
  780.                 sqlQuery = sqlQueryObject.createSQLQuery();
  781.                 stm = con.prepareStatement(sqlQuery);
  782.                 stm.setLong(1, idSoggettoProprietario);
  783.                 stm.setString(2, nomePorta);

  785.                 rs = stm.executeQuery();

  787.                 if (rs.next()) {
  788.                     idPortaDelegata = rs.getLong("id");
  789.                     aPD.setId(idPortaDelegata);
  790.                     rs.close();
  791.                     stm.close();
  792.                 } else {
  793.                     rs.close();
  794.                     stm.close();
  795.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata(CREATE)] Impossibile recuperare l'ID della PortaDelegata appena create.");
  796.                 }

  798.                 if(mtomProcessor!=null){
  799.                     
  800.                     MtomProcessorFlowParameter reqParam = null;
  801.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  802.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MTOM_REQUEST);
  803.                     sqlQueryObject.addInsertField("id_porta", "?");
  804.                     sqlQueryObject.addInsertField("nome", "?");
  805.                     sqlQueryObject.addInsertField("pattern", "?");
  806.                     sqlQueryObject.addInsertField("content_type", "?");
  807.                     sqlQueryObject.addInsertField("required", "?");
  808.                     sqlQuery = sqlQueryObject.createSQLInsert();
  809.                     stm = con.prepareStatement(sqlQuery);

  811.                     i = 0;
  812.                     if(mtomProcessor.getRequestFlow()!=null){
  813.                         MtomProcessorFlow flow = mtomProcessor.getRequestFlow();
  814.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  815.                             reqParam = flow.getParameter(i);
  816.                             stm.setLong(1, idPortaDelegata);
  817.                             stm.setString(2, reqParam.getNome());
  818.                             stm.setString(3, reqParam.getPattern());
  819.                             stm.setString(4, reqParam.getContentType());
  820.                             stm.setInt(5, reqParam.getRequired() ? CostantiDB.TRUE : CostantiDB.FALSE);

  822.                             stm.executeUpdate();
  823.                         }   
  824.                     }
  825.                     stm.close();
  826.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " mtom request flow con id=" + idPortaDelegata);

  828.                     MtomProcessorFlowParameter resParam = null;
  829.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  830.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MTOM_RESPONSE);
  831.                     sqlQueryObject.addInsertField("id_porta", "?");
  832.                     sqlQueryObject.addInsertField("nome", "?");
  833.                     sqlQueryObject.addInsertField("pattern", "?");
  834.                     sqlQueryObject.addInsertField("content_type", "?");
  835.                     sqlQueryObject.addInsertField("required", "?");
  836.                     sqlQuery = sqlQueryObject.createSQLInsert();
  837.                     stm = con.prepareStatement(sqlQuery);
  838.                     
  839.                     i = 0;
  840.                     if(mtomProcessor.getResponseFlow()!=null){
  841.                         MtomProcessorFlow flow = mtomProcessor.getResponseFlow();
  842.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  843.                             resParam = flow.getParameter(i);
  844.                             stm.setLong(1, idPortaDelegata);
  845.                             stm.setString(2, resParam.getNome());
  846.                             stm.setString(3, resParam.getPattern());
  847.                             stm.setString(4, resParam.getContentType());
  848.                             stm.setInt(5, resParam.getRequired() ? CostantiDB.TRUE : CostantiDB.FALSE);
  849.     
  850.                             stm.executeUpdate();
  851.                         }
  852.                     }
  853.                     stm.close();
  854.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " mtom response flow con id=" + idPortaDelegata);
  855.                     
  856.                 }
  857.                 
  858.                 // se security abilitato setto la lista
  859.                 /**if ((messageSecurity != null) && CostantiConfigurazione.ABILITATO.toString().equals(messageSecurityStatus) )  {*/
  860.                 // Devo settarli sempre se ci sono, in modo che lo switch abilitato-disabilitato funzioni
  861.                 if ((messageSecurity != null) )  {
  862.                     MessageSecurityFlowParameter reqParam = null;
  863.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  864.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST);
  865.                     sqlQueryObject.addInsertField("id_porta", "?");
  866.                     sqlQueryObject.addInsertField("nome", "?");
  867.                     sqlQueryObject.addInsertField("valore", "?");
  868.                     sqlQueryObject.addInsertField("enc_value", "?");
  869.                     sqlQuery = sqlQueryObject.createSQLInsert();
  870.                     stm = con.prepareStatement(sqlQuery);

  872.                     i = 0;
  873.                     if(messageSecurity.getRequestFlow()!=null){
  874.                         MessageSecurityFlow flow = messageSecurity.getRequestFlow();
  875.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  876.                             reqParam = flow.getParameter(i);
  877.                             int indexSec = 1;
  878.                             stm.setLong(indexSec++, idPortaDelegata);
  879.                             stm.setString(indexSec++, reqParam.getNome());
  880.                             
  881.                             String plainValue = reqParam.getValore();
  882.                             String encValue = null;
  883.                             if(driverBYOK!=null && 
  884.                                     (
  885.                                             DriverConfigurazioneDB_genericPropertiesDriver.isConfidentialProperty(securityRequestMode, reqParam.getNome())
  886.                                             ||
  887.                                             BYOKUtilities.isWrappedValue(plainValue)
  888.                                     )
  889.                             ) {
  890.                                 BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  891.                                 if(byokValue!=null) {
  892.                                     encValue = byokValue.getWrappedValue();
  893.                                     plainValue = byokValue.getWrappedPlainValue();
  894.                                 }
  895.                             }
  896.                             stm.setString(indexSec++, plainValue);
  897.                             stm.setString(indexSec++, encValue);

  899.                             stm.executeUpdate();
  900.                         }   
  901.                     }
  902.                     stm.close();
  903.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " request flow con id=" + idPortaDelegata);

  905.                     MessageSecurityFlowParameter resParam = null;
  906.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  907.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE);
  908.                     sqlQueryObject.addInsertField("id_porta", "?");
  909.                     sqlQueryObject.addInsertField("nome", "?");
  910.                     sqlQueryObject.addInsertField("valore", "?");
  911.                     sqlQueryObject.addInsertField("enc_value", "?");
  912.                     sqlQuery = sqlQueryObject.createSQLInsert();
  913.                     stm = con.prepareStatement(sqlQuery);
  914.                     
  915.                     i = 0;
  916.                     if(messageSecurity.getResponseFlow()!=null){
  917.                         MessageSecurityFlow flow = messageSecurity.getResponseFlow();
  918.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  919.                             resParam = flow.getParameter(i);
  920.                             int indexSec = 1;
  921.                             stm.setLong(indexSec++, idPortaDelegata);
  922.                             stm.setString(indexSec++, resParam.getNome());
  923.                             
  924.                             String plainValue = resParam.getValore();
  925.                             String encValue = null;
  926.                             if(driverBYOK!=null && 
  927.                                     (
  928.                                             DriverConfigurazioneDB_genericPropertiesDriver.isConfidentialProperty(securityResponseMode, resParam.getNome())
  929.                                             ||
  930.                                             BYOKUtilities.isWrappedValue(plainValue)
  931.                                     )
  932.                             ) {
  933.                                 BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  934.                                 if(byokValue!=null) {
  935.                                     encValue = byokValue.getWrappedValue();
  936.                                     plainValue = byokValue.getWrappedPlainValue();
  937.                                 }
  938.                             }
  939.                             stm.setString(indexSec++, plainValue);
  940.                             stm.setString(indexSec++, encValue);
  941.     
  942.                             stm.executeUpdate();
  943.                         }
  944.                     }
  945.                     stm.close();
  946.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " response flow con id=" + idPortaDelegata);
  947.                 }

  949.                 // la lista di correlazioni applicative contiene tutti e soli gli elementi necessari quindi resetto la lista nel db e riscrivo la lista nuova
  950.                 if (corrApp != null) {

  952.                     //inserisco i valori presenti nella lista 
  953.                     CorrelazioneApplicativaElemento cae = null;
  954.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  955.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE);
  956.                     sqlQueryObject.addInsertField("id_porta", "?");
  957.                     sqlQueryObject.addInsertField("nome_elemento", "?");
  958.                     sqlQueryObject.addInsertField("mode_correlazione", "?");
  959.                     sqlQueryObject.addInsertField("pattern", "?");
  960.                     sqlQueryObject.addInsertField("identificazione_fallita", "?");
  961.                     sqlQueryObject.addInsertField("riuso_id", "?");
  962.                     sqlQuery = sqlQueryObject.createSQLInsert();
  963.                     stm = con.prepareStatement(sqlQuery);

  965.                     for (i = 0; i < corrApp.sizeElementoList(); i++) {
  966.                         cae = corrApp.getElemento(i);
  967.                         stm.setLong(1, idPortaDelegata);
  968.                         stm.setString(2, cae.getNome());
  969.                         stm.setString(3, DriverConfigurazioneDBLib.getValue(cae.getIdentificazione()));
  970.                         if (cae.getPattern() != null)
  971.                             stm.setString(4, cae.getPattern());
  972.                         else
  973.                             stm.setString(4, "");
  974.                         stm.setString(5, DriverConfigurazioneDBLib.getValue(cae.getIdentificazioneFallita()));
  975.                         stm.setString(6, DriverConfigurazioneDBLib.getValue(cae.getRiusoIdentificativo()));
  976.                         stm.executeUpdate();
  977.                     }
  978.                     stm.close();
  979.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " correlazione applicativa con id=" + idPortaDelegata);
  980.                 }
  981.                 
  982.                 // la lista di correlazioni applicative contiene tutti e soli gli elementi necessari quindi resetto la lista nel db e riscrivo la lista nuova
  983.                 if (corrAppRisposta != null) {

  985.                     //inserisco i valori presenti nella lista 
  986.                     CorrelazioneApplicativaRispostaElemento cae = null;
  987.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  988.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE_RISPOSTA);
  989.                     sqlQueryObject.addInsertField("id_porta", "?");
  990.                     sqlQueryObject.addInsertField("nome_elemento", "?");
  991.                     sqlQueryObject.addInsertField("mode_correlazione", "?");
  992.                     sqlQueryObject.addInsertField("pattern", "?");
  993.                     sqlQueryObject.addInsertField("identificazione_fallita", "?");
  994.                     sqlQuery = sqlQueryObject.createSQLInsert();
  995.                     stm = con.prepareStatement(sqlQuery);

  997.                     for (i = 0; i < corrAppRisposta.sizeElementoList(); i++) {
  998.                         cae = corrAppRisposta.getElemento(i);
  999.                         stm.setLong(1, idPortaDelegata);
  1000.                         stm.setString(2, cae.getNome());
  1001.                         stm.setString(3, DriverConfigurazioneDBLib.getValue(cae.getIdentificazione()));
  1002.                         if (cae.getPattern() != null)
  1003.                             stm.setString(4, cae.getPattern());
  1004.                         else
  1005.                             stm.setString(4, "");
  1006.                         stm.setString(5, DriverConfigurazioneDBLib.getValue(cae.getIdentificazioneFallita()));
  1007.                         stm.executeUpdate();
  1008.                     }
  1009.                     stm.close();
  1010.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " correlazione applicativa risposta con id=" + idPortaDelegata);
  1011.                 }
  1012.                 
  1013.                 // serviziapplicativi
  1014.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1015.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_SA);
  1016.                 sqlQueryObject.addInsertField("id_porta", "?");
  1017.                 sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  1018.                 sqlQuery = sqlQueryObject.createSQLInsert();
  1019.                 stm = con.prepareStatement(sqlQuery);

  1021.                 for (i = 0; i < aPD.sizeServizioApplicativoList(); i++) {
  1022.                     PortaDelegataServizioApplicativo servizioApplicativo = aPD.getServizioApplicativo(i);
  1023.                     String nomeSA = servizioApplicativo.getNome();
  1024.                     //il tipo e il nome proprietario servizio applicativo sono gli stessi della porta delegata
  1025.                     String nomeProprietarioSA = aPD.getNomeSoggettoProprietario(); //servizioApplicativo.getNomeSoggettoProprietario();
  1026.                     String tipoProprietarioSA = aPD.getTipoSoggettoProprietario(); //servizioApplicativo.getTipoSoggettoProprietario();
  1027.                     if (nomeSA == null || nomeSA.equals(""))
  1028.                         throw new DriverConfigurazioneException("Nome del ServizioApplicativo associato non valido.");
  1029.                     if (nomeProprietarioSA == null || nomeProprietarioSA.equals(""))
  1030.                         throw new DriverConfigurazioneException("Nome Proprietario del ServizioApplicativo associato non valido.");
  1031.                     if (tipoProprietarioSA == null || tipoProprietarioSA.equals(""))
  1032.                         throw new DriverConfigurazioneException("Tipo Proprietario del ServizioApplicativo associato non valido.");

  1034.                     long idSA = DriverConfigurazioneDB_serviziApplicativiLIB.getIdServizioApplicativo(nomeSA, tipoProprietarioSA, nomeProprietarioSA, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);

  1036.                     if (idSA <= 0)
  1037.                         throw new DriverConfigurazioneException("Impossibile recuperare l'id del Servizio Applicativo [" + nomeSA + "] di [" + tipoProprietarioSA + "/" + nomeProprietarioSA + "]");

  1039.                     stm.setLong(1, idPortaDelegata);
  1040.                     stm.setLong(2, idSA);
  1041.                     stm.executeUpdate();
  1042.                 }
  1043.                 stm.close();
  1044.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " associazioni ServizioApplicativo<->PortaDelegata associati alla PortaDelegata[" + idPortaDelegata + "]");

  1046.                 // set prop autenticazione
  1047.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1048.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP);
  1049.                 sqlQueryObject.addInsertField("id_porta", "?");
  1050.                 sqlQueryObject.addInsertField("nome", "?");
  1051.                 sqlQueryObject.addInsertField("valore", "?");
  1052.                 sqlQueryObject.addInsertField("enc_value", "?");
  1053.                 sqlQuery = sqlQueryObject.createSQLInsert();
  1054.                 stm = con.prepareStatement(sqlQuery);
  1055.                 for (i = 0; i < aPD.sizeProprietaAutenticazioneList(); i++) {
  1056.                     Proprieta propProtocollo = aPD.getProprietaAutenticazione(i);

  1058.                     int indexP = 1;
  1059.                     stm.setLong(indexP++, aPD.getId());
  1060.                     stm.setString(indexP++, propProtocollo.getNome());
  1061.                     
  1062.                     String plainValueP = propProtocollo.getValore();
  1063.                     String encValueP = null;
  1064.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  1065.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  1066.                         if(byokValue!=null) {
  1067.                             encValueP = byokValue.getWrappedValue();
  1068.                             plainValueP = byokValue.getWrappedPlainValue();
  1069.                         }
  1070.                     }
  1071.                     
  1072.                     stm.setString(indexP++, plainValueP);
  1073.                     stm.setString(indexP++, encValueP);
  1074.                     
  1075.                     stm.executeUpdate();
  1076.                 }
  1077.                 stm.close();
  1078.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " SetProtocolPropAutenticazione associati alla PortaDelegata[" + idPortaDelegata + "]");
  1079.                 
  1080.                 
  1081.                 // set prop autorizzazione
  1082.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1083.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP);
  1084.                 sqlQueryObject.addInsertField("id_porta", "?");
  1085.                 sqlQueryObject.addInsertField("nome", "?");
  1086.                 sqlQueryObject.addInsertField("valore", "?");
  1087.                 sqlQueryObject.addInsertField("enc_value", "?");
  1088.                 sqlQuery = sqlQueryObject.createSQLInsert();
  1089.                 stm = con.prepareStatement(sqlQuery);
  1090.                 for (i = 0; i < aPD.sizeProprietaAutorizzazioneList(); i++) {
  1091.                     Proprieta propProtocollo = aPD.getProprietaAutorizzazione(i);

  1093.                     int indexP = 1;
  1094.                     stm.setLong(indexP++, aPD.getId());
  1095.                     stm.setString(indexP++, propProtocollo.getNome());
  1096.                     
  1097.                     String plainValueP = propProtocollo.getValore();
  1098.                     String encValueP = null;
  1099.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  1100.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  1101.                         if(byokValue!=null) {
  1102.                             encValueP = byokValue.getWrappedValue();
  1103.                             plainValueP = byokValue.getWrappedPlainValue();
  1104.                         }
  1105.                     }
  1106.                     
  1107.                     stm.setString(indexP++, plainValueP);
  1108.                     stm.setString(indexP++, encValueP);
  1109.                     
  1110.                     stm.executeUpdate();
  1111.                 }
  1112.                 stm.close();
  1113.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " SetProtocolPropAutorizzazione associati alla PortaDelegata[" + idPortaDelegata + "]");
  1114.                 
  1115.                 
  1116.                 // set prop autorizzazione contenuto
  1117.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1118.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP);
  1119.                 sqlQueryObject.addInsertField("id_porta", "?");
  1120.                 sqlQueryObject.addInsertField("nome", "?");
  1121.                 sqlQueryObject.addInsertField("valore", "?");
  1122.                 sqlQueryObject.addInsertField("enc_value", "?");
  1123.                 sqlQuery = sqlQueryObject.createSQLInsert();
  1124.                 stm = con.prepareStatement(sqlQuery);
  1125.                 for (i = 0; i < aPD.sizeProprietaAutorizzazioneContenutoList(); i++) {
  1126.                     Proprieta propProtocollo = aPD.getProprietaAutorizzazioneContenuto(i);
  1127.                     
  1128.                     int indexP = 1;
  1129.                     stm.setLong(indexP++, aPD.getId());
  1130.                     stm.setString(indexP++, propProtocollo.getNome());
  1131.                     
  1132.                     String plainValueP = propProtocollo.getValore();
  1133.                     String encValueP = null;
  1134.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  1135.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  1136.                         if(byokValue!=null) {
  1137.                             encValueP = byokValue.getWrappedValue();
  1138.                             plainValueP = byokValue.getWrappedPlainValue();
  1139.                         }
  1140.                     }
  1141.                     
  1142.                     stm.setString(indexP++, plainValueP);
  1143.                     stm.setString(indexP++, encValueP);
  1144.                     
  1145.                     stm.executeUpdate();
  1146.                 }
  1147.                 stm.close();
  1148.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " SetProtocolPropAutorizzazioneContenuto associati alla PortaDelegata[" + idPortaDelegata + "]");
  1149.                 
  1150.                 
  1151.                 
  1152.                 // set prop rate limiting
  1153.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1154.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_RATE_LIMITING_PROP);
  1155.                 sqlQueryObject.addInsertField("id_porta", "?");
  1156.                 sqlQueryObject.addInsertField("nome", "?");
  1157.                 sqlQueryObject.addInsertField("valore", "?");
  1158.                 sqlQuery = sqlQueryObject.createSQLInsert();
  1159.                 stm = con.prepareStatement(sqlQuery);
  1160.                 for (i = 0; i < aPD.sizeProprietaRateLimitingList(); i++) {
  1161.                     Proprieta propProtocollo = aPD.getProprietaRateLimiting(i);
  1162.                     stm.setLong(1, aPD.getId());
  1163.                     stm.setString(2, propProtocollo.getNome());
  1164.                     stm.setString(3, propProtocollo.getValore());
  1165.                     stm.executeUpdate();
  1166.                 }
  1167.                 stm.close();
  1168.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " SetProtocolPropRateLimiting associati alla PortaDelegata[" + idPortaDelegata + "]");
  1169.                 
  1170.                 
  1171.                 
  1172.                 
  1173.                 
  1174.                 // set prop
  1175.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1176.                 sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_PROP);
  1177.                 sqlQueryObject.addInsertField("id_porta", "?");
  1178.                 sqlQueryObject.addInsertField("nome", "?");
  1179.                 sqlQueryObject.addInsertField("valore", "?");
  1180.                 sqlQueryObject.addInsertField("enc_value", "?");
  1181.                 sqlQuery = sqlQueryObject.createSQLInsert();
  1182.                 stm = con.prepareStatement(sqlQuery);
  1183.                 for (i = 0; i < aPD.sizeProprietaList(); i++) {
  1184.                     Proprieta propProtocollo = aPD.getProprieta(i);
  1185.                     
  1186.                     int indexP = 1;
  1187.                     stm.setLong(indexP++, aPD.getId());
  1188.                     stm.setString(indexP++, propProtocollo.getNome());
  1189.                     
  1190.                     String plainValueP = propProtocollo.getValore();
  1191.                     String encValueP = null;
  1192.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  1193.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  1194.                         if(byokValue!=null) {
  1195.                             encValueP = byokValue.getWrappedValue();
  1196.                             plainValueP = byokValue.getWrappedPlainValue();
  1197.                         }
  1198.                     }
  1199.                     
  1200.                     stm.setString(indexP++, plainValueP);
  1201.                     stm.setString(indexP++, encValueP);
  1202.                     
  1203.                     stm.executeUpdate();
  1204.                 }
  1205.                 stm.close();
  1206.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " SetProtocolProp associati alla PortaDelegata[" + idPortaDelegata + "]");
  1207.                 
  1208.                 // Ruoli
  1209.                 n=0;
  1210.                 if(aPD.getRuoli()!=null && aPD.getRuoli().sizeRuoloList()>0){
  1211.                     for (int j = 0; j < aPD.getRuoli().sizeRuoloList(); j++) {
  1212.                         Ruolo ruolo = aPD.getRuoli().getRuolo(j);
  1213.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1214.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  1215.                         sqlQueryObject.addInsertField("id_porta", "?");
  1216.                         sqlQueryObject.addInsertField("ruolo", "?");
  1217.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1218.                         stm = con.prepareStatement(sqlQuery);
  1219.                         stm.setLong(1, aPD.getId());
  1220.                         stm.setString(2, ruolo.getNome());
  1221.                         stm.executeUpdate();
  1222.                         stm.close();
  1223.                         n++;
  1224.                         DriverConfigurazioneDBLib.logDebug("Aggiunto ruolo[" + ruolo.getNome() + "] alla PortaDelegata[" + idPortaDelegata + "]");
  1225.                     }
  1226.                 }
  1227.                 
  1228.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " ruoli alla PortaDelegata[" + idPortaDelegata + "]");
  1229.                 
  1230.                 // Scope
  1231.                 n=0;
  1232.                 if(aPD.getScope()!=null && aPD.getScope().sizeScopeList()>0){
  1233.                     for (int j = 0; j < aPD.getScope().sizeScopeList(); j++) {
  1234.                         Scope scope = aPD.getScope().getScope(j);
  1235.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1236.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  1237.                         sqlQueryObject.addInsertField("id_porta", "?");
  1238.                         sqlQueryObject.addInsertField("scope", "?");
  1239.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1240.                         stm = con.prepareStatement(sqlQuery);
  1241.                         stm.setLong(1, aPD.getId());
  1242.                         stm.setString(2, scope.getNome());
  1243.                         stm.executeUpdate();
  1244.                         stm.close();
  1245.                         n++;
  1246.                         DriverConfigurazioneDBLib.logDebug("Aggiunto scope[" + scope.getNome() + "] alla PortaDelegata[" + idPortaDelegata + "]");
  1247.                     }
  1248.                 }
  1249.                 
  1250.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " scope alla PortaDelegata[" + idPortaDelegata + "]");
  1251.                 
  1252.                 
  1253.                 // serviziapplicativi (token)
  1254.                 if(aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  1255.                         aPD.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  1256.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1257.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  1258.                     sqlQueryObject.addInsertField("id_porta", "?");
  1259.                     sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  1260.                     sqlQuery = sqlQueryObject.createSQLInsert();
  1261.                     stm = con.prepareStatement(sqlQuery);
  1262.     
  1263.                     for (i = 0; i < aPD.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList(); i++) {
  1264.                         PortaDelegataServizioApplicativo servizioApplicativo = aPD.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(i);
  1265.                         String nomeSA = servizioApplicativo.getNome();
  1266.                         //il tipo e il nome proprietario servizio applicativo sono gli stessi della porta delegata
  1267.                         String nomeProprietarioSA = aPD.getNomeSoggettoProprietario(); //servizioApplicativo.getNomeSoggettoProprietario();
  1268.                         String tipoProprietarioSA = aPD.getTipoSoggettoProprietario(); //servizioApplicativo.getTipoSoggettoProprietario();
  1269.                         if (nomeSA == null || nomeSA.equals(""))
  1270.                             throw new DriverConfigurazioneException("Nome del ServizioApplicativo associato non valido.");
  1271.                         if (nomeProprietarioSA == null || nomeProprietarioSA.equals(""))
  1272.                             throw new DriverConfigurazioneException("Nome Proprietario del ServizioApplicativo associato non valido.");
  1273.                         if (tipoProprietarioSA == null || tipoProprietarioSA.equals(""))
  1274.                             throw new DriverConfigurazioneException("Tipo Proprietario del ServizioApplicativo associato non valido.");
  1275.     
  1276.                         long idSA = DriverConfigurazioneDB_serviziApplicativiLIB.getIdServizioApplicativo(nomeSA, tipoProprietarioSA, nomeProprietarioSA, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  1277.     
  1278.                         if (idSA <= 0)
  1279.                             throw new DriverConfigurazioneException("Impossibile recuperare l'id del Servizio Applicativo [" + nomeSA + "] di [" + tipoProprietarioSA + "/" + nomeProprietarioSA + "]");
  1280.     
  1281.                         stm.setLong(1, idPortaDelegata);
  1282.                         stm.setLong(2, idSA);
  1283.                         stm.executeUpdate();
  1284.                     }
  1285.                     stm.close();
  1286.                     DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " associazioni ServizioApplicativo<->PortaDelegata (token) associati alla PortaDelegata[" + idPortaDelegata + "]");
  1287.                 }
  1288.                 
  1289.                 // Ruoli (Token)
  1290.                 n=0;
  1291.                 if(aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getRuoli()!=null &&
  1292.                         aPD.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0){
  1293.                     for (int j = 0; j < aPD.getAutorizzazioneToken().getRuoli().sizeRuoloList(); j++) {
  1294.                         Ruolo ruolo = aPD.getAutorizzazioneToken().getRuoli().getRuolo(j);
  1295.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1296.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  1297.                         sqlQueryObject.addInsertField("id_porta", "?");
  1298.                         sqlQueryObject.addInsertField("ruolo", "?");
  1299.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1300.                         stm = con.prepareStatement(sqlQuery);
  1301.                         stm.setLong(1, aPD.getId());
  1302.                         stm.setString(2, ruolo.getNome());
  1303.                         stm.executeUpdate();
  1304.                         stm.close();
  1305.                         n++;
  1306.                         DriverConfigurazioneDBLib.logDebug("Aggiunto ruolo[" + ruolo.getNome() + "] (token) alla PortaDelegata[" + idPortaDelegata + "]");
  1307.                     }
  1308.                 }
  1309.                 
  1310.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " ruoli (token) alla PortaDelegata[" + idPortaDelegata + "]");
  1311.                 
  1312.                 // Azioni
  1313.                 n=0;
  1314.                 if(aPD.getAzione()!=null && aPD.getAzione().sizeAzioneDelegataList()>0){
  1315.                     for (int j = 0; j < aPD.getAzione().sizeAzioneDelegataList(); j++) {
  1316.                         String azioneDelegata = aPD.getAzione().getAzioneDelegata(j);
  1317.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1318.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  1319.                         sqlQueryObject.addInsertField("id_porta", "?");
  1320.                         sqlQueryObject.addInsertField("azione", "?");
  1321.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1322.                         stm = con.prepareStatement(sqlQuery);
  1323.                         stm.setLong(1, aPD.getId());
  1324.                         stm.setString(2, azioneDelegata);
  1325.                         stm.executeUpdate();
  1326.                         stm.close();
  1327.                         n++;
  1328.                         DriverConfigurazioneDBLib.logDebug("Aggiunto azione delegata [" + azioneDelegata + "] alla PortaDelegata[" + idPortaDelegata + "]");
  1329.                     }
  1330.                 }
  1331.                 
  1332.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " azioni delegate alla PortaDelegata[" + idPortaDelegata + "]");
  1333.                 
  1334.                 
  1335.                 // Cache Regole
  1336.                 n=0;
  1337.                 if(responseCacheRegole!=null && responseCacheRegole.size()>0){
  1338.                     for (int j = 0; j < responseCacheRegole.size(); j++) {
  1339.                         ResponseCachingConfigurazioneRegola regola = responseCacheRegole.get(j);
  1340.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1341.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_CACHE_REGOLE);
  1342.                         sqlQueryObject.addInsertField("id_porta", "?");
  1343.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  1344.                             sqlQueryObject.addInsertField("status_min", "?");
  1345.                         }
  1346.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  1347.                             sqlQueryObject.addInsertField("status_max", "?");
  1348.                         }
  1349.                         sqlQueryObject.addInsertField("fault", "?");
  1350.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  1351.                             sqlQueryObject.addInsertField("cache_seconds", "?");
  1352.                         }
  1353.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1354.                         stm = con.prepareStatement(sqlQuery);
  1355.                         int indexCR = 1;
  1356.                         stm.setLong(indexCR++, aPD.getId());
  1357.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  1358.                             stm.setInt(indexCR++, regola.getReturnCodeMin());
  1359.                         }
  1360.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  1361.                             stm.setInt(indexCR++, regola.getReturnCodeMax());
  1362.                         }
  1363.                         stm.setInt(indexCR++, regola.getFault() ? CostantiDB.TRUE : CostantiDB.FALSE);
  1364.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  1365.                             stm.setInt(indexCR++, regola.getCacheTimeoutSeconds());
  1366.                         }
  1367.                         stm.executeUpdate();
  1368.                         stm.close();
  1369.                         n++;
  1370.                         DriverConfigurazioneDBLib.logDebug("Aggiunta regola di cache alla PortaDelegata[" + idPortaDelegata + "]");
  1371.                     }
  1372.                 }
  1373.                 
  1374.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " regole di cache alla PortaDelegata[" + idPortaDelegata + "]");
  1375.                 
  1376.                 
  1377.                 // AttributeAuthority
  1378.                 n=0;
  1379.                 if(aPD.sizeAttributeAuthorityList()>0){
  1380.                     for (int j = 0; j < aPD.sizeAttributeAuthorityList(); j++) {
  1381.                         AttributeAuthority aa = aPD.getAttributeAuthority(j);
  1382.                         
  1383.                         String attributi = null;
  1384.                         if(aa.sizeAttributoList()>0) {
  1385.                             StringBuilder bf = new StringBuilder();
  1386.                             for (int aaI = 0; aaI < aa.sizeAttributoList(); aaI++) {
  1387.                                 if(aaI>0) {
  1388.                                     bf.append(",");
  1389.                                 }
  1390.                                 bf.append(aa.getAttributo(aaI));
  1391.                             }
  1392.                             attributi = bf.toString();
  1393.                         }
  1394.                         
  1395.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1396.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_ATTRIBUTE_AUTHORITY);
  1397.                         sqlQueryObject.addInsertField("id_porta", "?");
  1398.                         sqlQueryObject.addInsertField("nome", "?");
  1399.                         sqlQueryObject.addInsertField("attributi", "?");
  1400.                         sqlQuery = sqlQueryObject.createSQLInsert();
  1401.                         stm = con.prepareStatement(sqlQuery);
  1402.                         stm.setLong(1, aPD.getId());
  1403.                         stm.setString(2, aa.getNome());
  1404.                         stm.setString(3, attributi);
  1405.                         stm.executeUpdate();
  1406.                         stm.close();
  1407.                         n++;
  1408.                         DriverConfigurazioneDBLib.logDebug("Aggiunto A.A.[" + aa.getNome() + "] alla PortaDelegata[" + idPortaDelegata + "]");
  1409.                     }
  1410.                 }
  1411.                 
  1412.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " A.A. alla PortaDelegata[" + idPortaDelegata + "]");
  1413.                 
  1414.                 
  1415.                 // tracciamentoConfigurazione
  1416.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoDatabase, aPD.getId(), 
  1417.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  1418.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  1419.                 
  1420.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoFiletrace, aPD.getId(), 
  1421.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  1422.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  1423.                 
  1424.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoFiletraceDetails, aPD.getId(), 
  1425.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD);
  1426.                 
  1427.                 // dumpConfigurazione
  1428.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, aPD.getDump(), aPD.getId(), CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_PD);
  1429.                 
  1430.                 // trasformazioni
  1431.                 DriverConfigurazioneDBTrasformazioniLib.CRUDTrasformazioni(type, con, aPD.getTrasformazioni(), aPD.getId(), true);
  1432.                 
  1433.                 // handlers
  1434.                 if(configHandlers!=null) {
  1435.                     if(configHandlers.getRequest()!=null) {
  1436.                         DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, aPD.getId(), null, true, configHandlers.getRequest());
  1437.                     }
  1438.                     if(configHandlers.getResponse()!=null) {
  1439.                         DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, aPD.getId(), null, false, configHandlers.getResponse());
  1440.                     }
  1441.                 }
  1442.                 
  1443.                 // extendedInfo
  1444.                 i=0;
  1445.                 if(aPD.sizeExtendedInfoList()>0){
  1446.                     if(extInfoConfigurazioneDriver!=null){
  1447.                         for (i = 0; i < aPD.sizeExtendedInfoList(); i++) {
  1448.                             extInfoConfigurazioneDriver.createExtendedInfo(con, DriverConfigurazioneDBLib.log, aPD, aPD.getExtendedInfo(i), CRUDType.CREATE);
  1449.                         }
  1450.                     }
  1451.                 }
  1452.                 DriverConfigurazioneDBLib.logDebug("Inseriti " + i + " associazioni ExtendedInfo<->PortaDelegata associati alla PortaDelegata[" + idPortaDelegata + "]");
  1453.                 
  1454.                 break;

  1456.             case UPDATE:
  1457.                 //soggetto erogatore
  1458.                 tipoSoggErogatore = (soggErogatore != null ? soggErogatore.getTipo() : null);
  1459.                 nomeSoggErogatore = (soggErogatore != null ? soggErogatore.getNome() : null);
  1460.                 if(tipoSoggErogatore==null || tipoSoggErogatore.equals("")) throw new DriverConfigurazioneException("Tipo Soggetto Erogatore non impostato.");
  1461.                 if(nomeSoggErogatore==null || nomeSoggErogatore.equals("")) throw new DriverConfigurazioneException("Nome Soggetto Erogatore non impostato.");

  1463.                 //servizio
  1464.                 tipoServizio = (servizio != null ? servizio.getTipo() : null);
  1465.                 nomeServizio = (servizio != null ? servizio.getNome() : null);
  1466.                 versioneServizio = (servizio != null ? servizio.getVersione() : null);
  1467.                 if(tipoServizio==null || tipoServizio.equals("")) throw new DriverConfigurazioneException("Tipo Servizio non impostato.");
  1468.                 if(nomeServizio==null || nomeServizio.equals("")) throw new DriverConfigurazioneException("Nome Servizio non impostato.");
  1469.                 if(versioneServizio==null) throw new DriverConfigurazioneException("Versione Servizio non impostato.");

  1471.                 //Azione
  1472.                 nomeAzione = (azione != null ? azione.getNome() : null);
  1473.                 patternAzione = (azione != null ? azione.getPattern() : null);
  1474.                 modeAzione = (azione != null ? azione.getIdentificazione() : null);
  1475.                 nomePortaDeleganteAzione = (azione != null ? azione.getNomePortaDelegante() : null);
  1476.                 forceInterfaceBased = (azione != null ? azione.getForceInterfaceBased() : null);
  1477.                 //Se il bean Azione nn e' presente allora non controllo nulla
  1478.                 if(azione!=null){
  1479.                     if(modeAzione==null || modeAzione.equals("")) 
  1480.                         modeAzione = PortaDelegataAzioneIdentificazione.STATIC;
  1481.                     switch (modeAzione) {
  1482.                     case CONTENT_BASED:
  1483.                     case URL_BASED:
  1484.                     case HEADER_BASED:
  1485.                         if(patternAzione==null || patternAzione.equals("")) throw new DriverConfigurazioneException("Pattern Azione non impostato.");
  1486.                         nomeAzione=null;
  1487.                         break;
  1488.                     case DELEGATED_BY:
  1489.                         if(nomePortaDeleganteAzione==null || nomePortaDeleganteAzione.equals("")) throw new DriverConfigurazioneException("Nome Porta Delegante Azione non impostata.");
  1490.                         nomeAzione=null;
  1491.                         break;
  1492.                     case INPUT_BASED:
  1493.                     case SOAP_ACTION_BASED:
  1494.                     case INTERFACE_BASED:
  1495.                         //nessun campo obbligatorio
  1496.                         break;
  1497.                     case STATIC:
  1498.                         //se non c'e' l'id dell'azione ci deve essere il nome
  1499.                         if(idAzione<=0){
  1500.                             if(nomeAzione==null || nomeAzione.equals("")) throw new DriverConfigurazioneException("Nome Azione non impostato.");
  1501.                         }
  1502.                         patternAzione=null;
  1503.                         break;
  1504.                     default:
  1505.                         break;
  1506.                     }
  1507.                 }

  1509.                 // update
  1510.                 String oldNomePD = null;
  1511.                 if(aPD.getOldIDPortaDelegataForUpdate()!=null){
  1512.                     oldNomePD = aPD.getOldIDPortaDelegataForUpdate().getNome();
  1513.                 }
  1514.                 DriverConfigurazioneDBLib.logDebug("OLD-PD["+oldNomePD+"] PD["+nomePorta+"]");
  1515.                 
  1516.                 if (oldNomePD == null || oldNomePD.equals("")){
  1517.                     DriverConfigurazioneDBLib.logDebug("old nomePD is null, assegno: "+nomePorta);
  1518.                     oldNomePD = nomePorta;
  1519.                 }

  1521.                 /** if(aPD.getId() == null || aPD.getId()<=0) throw new*/
  1522.                 // DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata(UPDATE)]
  1523.                 // L'id della porta e' necessario per effettuare l'UPDATE.");
  1524.                 idPortaDelegata = DBUtils.getIdPortaDelegata(oldNomePD, con, DriverConfigurazioneDBLib.tipoDB);
  1525.                 // Puo' darsi che l'old soggetto e il nuovo soggetto siano la stesso soggetto della tabella. E' stato cambiato il nome.
  1526.                 if(idPortaDelegata<=0) {
  1527.                     idPortaDelegata = DBUtils.getIdPortaDelegata(oldNomePD, con, DriverConfigurazioneDBLib.tipoDB);
  1528.                 }
  1529.                 if(idPortaDelegata<=0) 
  1530.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata(UPDATE)] id porta delegata non trovato nome["+oldNomePD+"]");
  1531.                 aPD.setId(idPortaDelegata);
  1532.                 
  1533.                 String utenteUltimaModifica = null;
  1534.                 if(aPD.getProprietaOggetto()!=null && aPD.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  1535.                     utenteUltimaModifica = aPD.getProprietaOggetto().getUtenteUltimaModifica();
  1536.                 }
  1537.                 
  1538.                 Timestamp dataUltimaModifica = null;
  1539.                 if(aPD.getProprietaOggetto()!=null && aPD.getProprietaOggetto().getDataUltimaModifica()!=null) {
  1540.                     dataUltimaModifica = new Timestamp(aPD.getProprietaOggetto().getDataUltimaModifica().getTime());
  1541.                 }
  1542.                 else {
  1543.                     dataUltimaModifica = DateManager.getTimestamp();
  1544.                 }
  1545.                 
  1546.                 
  1547.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1548.                 sqlQueryObject.addUpdateTable(CostantiDB.PORTE_DELEGATE);
  1549.                 sqlQueryObject.addUpdateField("nome_porta", "?");
  1550.                 sqlQueryObject.addUpdateField("descrizione", "?");
  1551.                 sqlQueryObject.addUpdateField("id_soggetto_erogatore", "?");
  1552.                 sqlQueryObject.addUpdateField("tipo_soggetto_erogatore", "?");
  1553.                 sqlQueryObject.addUpdateField("nome_soggetto_erogatore", "?");
  1554.                 sqlQueryObject.addUpdateField("id_servizio", "?");
  1555.                 sqlQueryObject.addUpdateField("tipo_servizio", "?");
  1556.                 sqlQueryObject.addUpdateField("nome_servizio", "?");
  1557.                 sqlQueryObject.addUpdateField("versione_servizio", "?");
  1558.                 sqlQueryObject.addUpdateField("id_azione", "?");
  1559.                 sqlQueryObject.addUpdateField("nome_azione", "?");
  1560.                 sqlQueryObject.addUpdateField("mode_azione", "?");
  1561.                 sqlQueryObject.addUpdateField("pattern_azione", "?");
  1562.                 sqlQueryObject.addUpdateField("nome_porta_delegante_azione", "?");
  1563.                 sqlQueryObject.addUpdateField("force_interface_based_azione", "?");
  1564.                 sqlQueryObject.addUpdateField("autenticazione", "?");
  1565.                 sqlQueryObject.addUpdateField("autenticazione_opzionale", "?");
  1566.                 sqlQueryObject.addUpdateField("token_policy", "?");
  1567.                 sqlQueryObject.addUpdateField("token_opzionale", "?");
  1568.                 sqlQueryObject.addUpdateField("token_validazione", "?");
  1569.                 sqlQueryObject.addUpdateField("token_introspection", "?");
  1570.                 sqlQueryObject.addUpdateField("token_user_info", "?");
  1571.                 sqlQueryObject.addUpdateField("token_forward", "?");
  1572.                 sqlQueryObject.addUpdateField("token_options", "?");
  1573.                 sqlQueryObject.addUpdateField("token_authn_issuer", "?");
  1574.                 sqlQueryObject.addUpdateField("token_authn_client_id", "?");
  1575.                 sqlQueryObject.addUpdateField("token_authn_subject", "?");
  1576.                 sqlQueryObject.addUpdateField("token_authn_username", "?");
  1577.                 sqlQueryObject.addUpdateField("token_authn_email", "?");
  1578.                 sqlQueryObject.addUpdateField("autorizzazione", "?");
  1579.                 sqlQueryObject.addUpdateField("autorizzazione_xacml", "?");
  1580.                 sqlQueryObject.addUpdateField("autorizzazione_contenuto", "?");
  1581.                 sqlQueryObject.addUpdateField("mtom_request_mode", "?");
  1582.                 sqlQueryObject.addUpdateField("mtom_response_mode", "?");
  1583.                 sqlQueryObject.addUpdateField("security", "?");
  1584.                 sqlQueryObject.addUpdateField("security_mtom_req", "?");
  1585.                 sqlQueryObject.addUpdateField("security_mtom_res", "?");
  1586.                 sqlQueryObject.addUpdateField("security_request_mode", "?");
  1587.                 sqlQueryObject.addUpdateField("security_response_mode", "?");
  1588.                 sqlQueryObject.addUpdateField("id_soggetto", "?");
  1589.                 sqlQueryObject.addUpdateField("ricevuta_asincrona_sim", "?");
  1590.                 sqlQueryObject.addUpdateField("ricevuta_asincrona_asim", "?");
  1591.                 sqlQueryObject.addUpdateField("integrazione", "?");
  1592.                 sqlQueryObject.addUpdateField("scadenza_correlazione_appl", "?");
  1593.                 sqlQueryObject.addUpdateField("validazione_contenuti_stato", "?");
  1594.                 sqlQueryObject.addUpdateField("validazione_contenuti_tipo", "?");
  1595.                 sqlQueryObject.addUpdateField("validazione_contenuti_mtom", "?");               
  1596.                 sqlQueryObject.addUpdateField("allega_body", "?");
  1597.                 sqlQueryObject.addUpdateField("scarta_body", "?");
  1598.                 sqlQueryObject.addUpdateField("gestione_manifest", "?");
  1599.                 sqlQueryObject.addUpdateField("stateless", "?");
  1600.                 sqlQueryObject.addUpdateField("local_forward", "?");
  1601.                 sqlQueryObject.addUpdateField("local_forward_pa", "?");
  1602.                 sqlQueryObject.addUpdateField("ruoli_match", "?");
  1603.                 sqlQueryObject.addUpdateField("token_sa_stato", "?");
  1604.                 sqlQueryObject.addUpdateField("token_ruoli_stato", "?");
  1605.                 sqlQueryObject.addUpdateField("token_ruoli_match", "?");
  1606.                 sqlQueryObject.addUpdateField("token_ruoli_tipologia", "?");
  1607.                 sqlQueryObject.addUpdateField("scope_stato", "?");
  1608.                 sqlQueryObject.addUpdateField("scope_match", "?");
  1609.                 sqlQueryObject.addUpdateField("ricerca_porta_azione_delegata", "?");
  1610.                 sqlQueryObject.addUpdateField("msg_diag_severita", "?");
  1611.                 sqlQueryObject.addUpdateField("tracciamento_stato", "?");
  1612.                 sqlQueryObject.addUpdateField("tracciamento_esiti", "?");
  1613.                 sqlQueryObject.addUpdateField("transazioni_tempi", "?");
  1614.                 sqlQueryObject.addUpdateField("transazioni_token", "?");
  1615.                 sqlQueryObject.addUpdateField("stato", "?");
  1616.                 // cors
  1617.                 sqlQueryObject.addUpdateField("cors_stato", "?");
  1618.                 sqlQueryObject.addUpdateField("cors_tipo", "?");
  1619.                 sqlQueryObject.addUpdateField("cors_all_allow_origins", "?");
  1620.                 sqlQueryObject.addUpdateField("cors_all_allow_methods", "?");
  1621.                 sqlQueryObject.addUpdateField("cors_all_allow_headers", "?");
  1622.                 sqlQueryObject.addUpdateField("cors_allow_credentials", "?");
  1623.                 sqlQueryObject.addUpdateField("cors_allow_max_age", "?");
  1624.                 sqlQueryObject.addUpdateField("cors_allow_max_age_seconds", "?");
  1625.                 sqlQueryObject.addUpdateField("cors_allow_origins", "?");
  1626.                 sqlQueryObject.addUpdateField("cors_allow_headers", "?");
  1627.                 sqlQueryObject.addUpdateField("cors_allow_methods", "?");
  1628.                 sqlQueryObject.addUpdateField("cors_allow_expose_headers", "?");
  1629.                 // responseCaching
  1630.                 sqlQueryObject.addUpdateField("response_cache_stato", "?");
  1631.                 sqlQueryObject.addUpdateField("response_cache_seconds", "?");
  1632.                 sqlQueryObject.addUpdateField("response_cache_max_msg_size", "?");
  1633.                 sqlQueryObject.addUpdateField("response_cache_control_nocache", "?");
  1634.                 sqlQueryObject.addUpdateField("response_cache_control_maxage", "?");
  1635.                 sqlQueryObject.addUpdateField("response_cache_control_nostore", "?");
  1636.                 sqlQueryObject.addUpdateField("response_cache_hash_url", "?");
  1637.                 sqlQueryObject.addUpdateField("response_cache_hash_query", "?");
  1638.                 sqlQueryObject.addUpdateField("response_cache_hash_query_list", "?");
  1639.                 sqlQueryObject.addUpdateField("response_cache_hash_headers", "?");
  1640.                 sqlQueryObject.addUpdateField("response_cache_hash_hdr_list", "?");
  1641.                 sqlQueryObject.addUpdateField("response_cache_hash_payload", "?");
  1642.                 // id
  1643.                 sqlQueryObject.addUpdateField("id_accordo", "?");
  1644.                 sqlQueryObject.addUpdateField("id_port_type", "?");
  1645.                 // options
  1646.                 sqlQueryObject.addUpdateField("options", "?");
  1647.                 // canale
  1648.                 sqlQueryObject.addUpdateField("canale", "?");
  1649.                 
  1650.                 if(utenteUltimaModifica!=null) {
  1651.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  1652.                 }
  1653.                 if(dataUltimaModifica!=null) {
  1654.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  1655.                 }
  1656.                 
  1657.                 sqlQueryObject.addWhereCondition("id=?");
  1658.                 sqlQueryObject.setANDLogicOperator(true);
  1659.                 sqlQuery = sqlQueryObject.createSQLUpdate();
  1660.                 stm = con.prepareStatement(sqlQuery);

  1662.                 index = 1;
  1663.                 stm.setString(index++, nomePorta);
  1664.                 stm.setString(index++, descrizione);
  1665.                 stm.setLong(index++, idSoggettoErogatore);
  1666.                 stm.setString(index++, tipoSoggErogatore);
  1667.                 stm.setString(index++, nomeSoggErogatore);
  1668.                 stm.setLong(index++, idServizioPD);
  1669.                 stm.setString(index++, tipoServizio);
  1670.                 stm.setString(index++, nomeServizio);
  1671.                 stm.setInt(index++, versioneServizio);
  1672.                 stm.setLong(index++, idAzione);
  1673.                 stm.setString(index++, nomeAzione);
  1674.                 if(modeAzione!=null)
  1675.                     stm.setString(index++, modeAzione.toString());
  1676.                 else
  1677.                     stm.setString(index++, null);
  1678.                 stm.setString(index++, patternAzione);
  1679.                 stm.setString(index++, nomePortaDeleganteAzione);
  1680.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(forceInterfaceBased));
  1681.                 // autenticazione
  1682.                 stm.setString(index++, autenticazione);
  1683.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getAutenticazioneOpzionale()) : null);
  1684.                 // token
  1685.                 stm.setString(index++, gestioneToken!=null ? gestioneToken.getPolicy() : null);
  1686.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getTokenOpzionale()) : null);
  1687.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getValidazione()) : null);
  1688.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getIntrospection()) : null);
  1689.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getUserInfo()) : null);
  1690.                 stm.setString(index++, gestioneToken!=null ? DriverConfigurazioneDBLib.getValue(gestioneToken.getForward()) : null);
  1691.                 stm.setString(index++, gestioneToken!=null ? gestioneToken.getOptions() : null);
  1692.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  1693.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getIssuer()) : null);
  1694.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  1695.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getClientId()) : null);
  1696.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  1697.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getSubject()) : null);
  1698.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  1699.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getUsername()) : null);
  1700.                 stm.setString(index++, (gestioneToken!=null && gestioneToken.getAutenticazione()!=null) ? 
  1701.                         DriverConfigurazioneDBLib.getValue(gestioneToken.getAutenticazione().getEmail()) : null);
  1702.                 // autorizzazione
  1703.                 stm.setString(index++, autorizzazione);
  1704.                 stm.setString(index++, autorizzazioneXacmlPolicy);
  1705.                 stm.setString(index++, autorizzazioneContenuto);
  1706.                 // mtom
  1707.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(mtomModeRequest));
  1708.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(mtomModeResponse));
  1709.                 // messageSecurity
  1710.                 stm.setString(index++, messageSecurityStatus);
  1711.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(messageSecurityApplyMtomRequest));
  1712.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(messageSecurityApplyMtomResponse));
  1713.                 stm.setString(index++, securityRequestMode);
  1714.                 stm.setString(index++, securityResponseMode);
  1715.                 // soggettoProprietario
  1716.                 stm.setLong(index++, idSoggettoProprietario);
  1717.                 //ricevuta asincrona_asimmetrica/simmetrica
  1718.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(aPD.getRicevutaAsincronaSimmetrica()));
  1719.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(aPD.getRicevutaAsincronaAsimmetrica()));
  1720.                 //integrazione
  1721.                 stm.setString(index++, aPD.getIntegrazione());
  1722.                 //scadenza correlazione applicativa
  1723.                 stm.setString(index++, aPD.getCorrelazioneApplicativa()!=null ? aPD.getCorrelazioneApplicativa().getScadenza() : null);
  1724.                 //validazione xsd
  1725.                 stm.setString(index++, aPD.getValidazioneContenutiApplicativi()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getValidazioneContenutiApplicativi().getStato()) : null);
  1726.                 stm.setString(index++, aPD.getValidazioneContenutiApplicativi()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getValidazioneContenutiApplicativi().getTipo()) : null);
  1727.                 stm.setString(index++, aPD.getValidazioneContenutiApplicativi()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getValidazioneContenutiApplicativi().getAcceptMtomMessage()) : null);
  1728.                 // InvocazionePorta: funzionalita' attachment
  1729.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getAllegaBody()) : null);
  1730.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getScartaBody()) : null);
  1731.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getGestioneManifest()) : null);
  1732.                 // Stateless
  1733.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getStateless()) : null);
  1734.                 // LocalForward
  1735.                 stm.setString(index++, aPD!=null && aPD.getLocalForward()!=null ? DriverConfigurazioneDBLib.getValue(aPD.getLocalForward().getStato()) : null);
  1736.                 stm.setString(index++, aPD!=null && aPD.getLocalForward()!=null ? aPD.getLocalForward().getPortaApplicativa() : null);
  1737.                 // Ruoli
  1738.                 stm.setString(index++, aPD!=null && aPD.getRuoli()!=null && aPD.getRuoli().getMatch()!=null ? 
  1739.                         aPD.getRuoli().getMatch().getValue() : null);
  1740.                 // Token sa
  1741.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getAutorizzazioneApplicativi()!=null ? 
  1742.                         DriverConfigurazioneDBLib.getValue(aPD.getAutorizzazioneToken().getAutorizzazioneApplicativi()) : null);    
  1743.                 // Token ruoli
  1744.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getAutorizzazioneRuoli()!=null ? 
  1745.                         DriverConfigurazioneDBLib.getValue(aPD.getAutorizzazioneToken().getAutorizzazioneRuoli()) : null);
  1746.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getRuoli()!=null && 
  1747.                         aPD.getAutorizzazioneToken().getRuoli().getMatch()!=null ? 
  1748.                         aPD.getAutorizzazioneToken().getRuoli().getMatch().getValue() : null);
  1749.                 stm.setString(index++, aPD!=null && aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getTipologiaRuoli()!=null ? 
  1750.                         aPD.getAutorizzazioneToken().getTipologiaRuoli().getValue() : null);
  1751.                 // Scope
  1752.                 stm.setString(index++, aPD!=null && aPD.getScope()!=null && aPD.getScope().getStato()!=null ? 
  1753.                         DriverConfigurazioneDBLib.getValue(aPD.getScope().getStato()) : null);
  1754.                 stm.setString(index++, aPD!=null && aPD.getScope()!=null && aPD.getScope().getMatch()!=null ? 
  1755.                         aPD.getScope().getMatch().getValue() : null);
  1756.                 // RicercaPortaAzioneDelegata
  1757.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getRicercaPortaAzioneDelegata()) : null);
  1758.                 // Tracciamento
  1759.                 stm.setString(index++, msgDiagSeverita);
  1760.                 stm.setString(index++, tracciamentoStato);
  1761.                 stm.setString(index++, tracciamentoEsiti);
  1762.                 stm.setString(index++, transazioniTempiElaborazione);
  1763.                 stm.setString(index++, transazioniToken);
  1764.                 // Stato
  1765.                 stm.setString(index++, aPD!=null ? DriverConfigurazioneDBLib.getValue(aPD.getStato()) : null);
  1766.                 // cors
  1767.                 stm.setString(index++, corsStato);
  1768.                 stm.setString(index++, corsTipo);
  1769.                 stm.setString(index++, corsAllAllowOrigins);
  1770.                 stm.setString(index++, corsAllAllowMethods);
  1771.                 stm.setString(index++, corsAllAllowHeaders);
  1772.                 stm.setString(index++, corsAllowCredentials);
  1773.                 stm.setInt(index++, corsAllowMaxAge);
  1774.                 if(corsAllowMaxAgeSeconds!=null) {
  1775.                     stm.setInt(index++, corsAllowMaxAgeSeconds);
  1776.                 }
  1777.                 else {
  1778.                     stm.setNull(index++, java.sql.Types.INTEGER);
  1779.                 }
  1780.                 stm.setString(index++, corsAllowOrigins);
  1781.                 stm.setString(index++, corsAllowHeaders);
  1782.                 stm.setString(index++, corsAllowMethods);
  1783.                 stm.setString(index++, corsAllowExposeHeaders);
  1784.                 
  1785.                 // responseCaching
  1786.                 stm.setString(index++, responseCacheStato);
  1787.                 if(responseCacheSeconds!=null) {
  1788.                     stm.setInt(index++, responseCacheSeconds);
  1789.                 }
  1790.                 else {
  1791.                     stm.setNull(index++, java.sql.Types.INTEGER);
  1792.                 }
  1793.                 if(responseCacheMaxMsgSize!=null) {
  1794.                     stm.setLong(index++, responseCacheMaxMsgSize);
  1795.                 }
  1796.                 else {
  1797.                     stm.setNull(index++, java.sql.Types.BIGINT);
  1798.                 }
  1799.                 stm.setInt(index++, responseCacheNoCache ? CostantiDB.TRUE : CostantiDB.FALSE);
  1800.                 stm.setInt(index++, responseCacheMaxAge ? CostantiDB.TRUE : CostantiDB.FALSE);
  1801.                 stm.setInt(index++, responseCacheNoStore ? CostantiDB.TRUE : CostantiDB.FALSE);
  1802.                 stm.setString(index++, responseCacheHashUrl);
  1803.                 stm.setString(index++, responseCacheHashQuery);
  1804.                 stm.setString(index++, responseCacheHashQueryList);
  1805.                 stm.setString(index++, responseCacheHashHeaders);
  1806.                 stm.setString(index++, responseCacheHashHeadersList);
  1807.                 stm.setString(index++, responseCacheHashPayload);
  1808.                 //idAccordo
  1809.                 stm.setLong(index++,aPD.getIdAccordo() != null ? aPD.getIdAccordo() : -1L);
  1810.                 stm.setLong(index++, aPD.getIdPortType() != null ? aPD.getIdPortType() : -1L);
  1811.                 // options
  1812.                 stm.setString(index++, aPD.getOptions());
  1813.                 // canale
  1814.                 stm.setString(index++, aPD.getCanale());
  1815.                 
  1816.                 if(utenteUltimaModifica!=null) {
  1817.                     stm.setString(index++, utenteUltimaModifica);
  1818.                 }
  1819.                 
  1820.                 if(dataUltimaModifica!=null) {
  1821.                     stm.setTimestamp(index++, dataUltimaModifica);
  1822.                 }
  1823.                 
  1824.                 // where
  1825.                 stm.setLong(index++, idPortaDelegata);

  1827.                 /**DriverConfigurazioneDB_LIB.log.debug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, nomePorta, descrizione, 
  1828.                 // soggErogatore.getId(), soggErogatore.getTipo(), soggErogatore.getNome(), soggErogatore.getIdentificazione(), servizio.getId(), 
  1829.                 // servizio.getTipo(), servizio.getNome(), servizio.getIdentificazione(), azione.getId(), azione.getNome(), azione.getIdentificazione(), 
  1830.                 // autenticazione, autorizzazione, messageSecurityStatus, idSoggettoProprietario, idPortaDelegata));*/

  1832.                 n = stm.executeUpdate();
  1833.                 stm.close();
  1834.                 DriverConfigurazioneDBLib.logDebug("Updated " + n + " row(s).");

  1836.                 
  1837.                 
  1838.                 // mtom
  1839.                 
  1840.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1841.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MTOM_REQUEST);
  1842.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1843.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1844.                 stm = con.prepareStatement(sqlQuery);
  1845.                 stm.setLong(1, idPortaDelegata);
  1846.                 stm.executeUpdate();
  1847.                 stm.close();

  1849.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1850.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MTOM_RESPONSE);
  1851.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1852.                 sqlQuery = sqlQueryObject.createSQLDelete();
  1853.                 stm = con.prepareStatement(sqlQuery);
  1854.                 stm.setLong(1, idPortaDelegata);
  1855.                 stm.executeUpdate();
  1856.                 stm.close();
  1857.                 
  1858.                 if(mtomProcessor!=null){
  1859.                 
  1860.                     MtomProcessorFlowParameter reqParam = null;
  1861.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1862.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MTOM_REQUEST);
  1863.                     sqlQueryObject.addInsertField("id_porta", "?");
  1864.                     sqlQueryObject.addInsertField("nome", "?");
  1865.                     sqlQueryObject.addInsertField("pattern", "?");
  1866.                     sqlQueryObject.addInsertField("content_type", "?");
  1867.                     sqlQueryObject.addInsertField("required", "?");
  1868.                     sqlQuery = sqlQueryObject.createSQLInsert();
  1869.                     stm = con.prepareStatement(sqlQuery);
  1870.     
  1871.                     i = 0;
  1872.                     if(mtomProcessor.getRequestFlow()!=null){
  1873.                         MtomProcessorFlow flow = mtomProcessor.getRequestFlow();
  1874.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  1875.                             reqParam = flow.getParameter(i);
  1876.                             stm.setLong(1, idPortaDelegata);
  1877.                             stm.setString(2, reqParam.getNome());
  1878.                             stm.setString(3, reqParam.getPattern());
  1879.                             stm.setString(4, reqParam.getContentType());
  1880.                             stm.setInt(5, reqParam.getRequired() ? CostantiDB.TRUE : CostantiDB.FALSE);
  1881.     
  1882.                             stm.executeUpdate();
  1883.                         }   
  1884.                     }
  1885.                     stm.close();
  1886.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " mtom request flow con id=" + idPortaDelegata);
  1887.     
  1888.                     MtomProcessorFlowParameter resParam = null;
  1889.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1890.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MTOM_RESPONSE);
  1891.                     sqlQueryObject.addInsertField("id_porta", "?");
  1892.                     sqlQueryObject.addInsertField("nome", "?");
  1893.                     sqlQueryObject.addInsertField("pattern", "?");
  1894.                     sqlQueryObject.addInsertField("content_type", "?");
  1895.                     sqlQueryObject.addInsertField("required", "?");
  1896.                     sqlQuery = sqlQueryObject.createSQLInsert();
  1897.                     stm = con.prepareStatement(sqlQuery);
  1898.                     
  1899.                     i = 0;
  1900.                     if(mtomProcessor.getResponseFlow()!=null){
  1901.                         MtomProcessorFlow flow = mtomProcessor.getResponseFlow();
  1902.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  1903.                             resParam = flow.getParameter(i);
  1904.                             stm.setLong(1, idPortaDelegata);
  1905.                             stm.setString(2, resParam.getNome());
  1906.                             stm.setString(3, resParam.getPattern());
  1907.                             stm.setString(4, resParam.getContentType());
  1908.                             stm.setInt(5, resParam.getRequired() ? CostantiDB.TRUE : CostantiDB.FALSE);
  1909.     
  1910.                             stm.executeUpdate();
  1911.                         }
  1912.                     }
  1913.                     stm.close();
  1914.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " mtom response flow con id=" + idPortaDelegata);
  1915.                     
  1916.                 }
  1917.                 
  1918.                 
  1919.                 
  1920.                 // se security abilitato setto la lista
  1921.                 // la lista contiene tutti e soli gli elementi necessari quindi resetto la lista nel db e riscrivo la lista nuova
  1922.                 /**if ((messageSecurity != null) && CostantiConfigurazione.ABILITATO.toString().equals(messageSecurityStatus) )  {*/
  1923.                 // Devo settarli sempre se ci sono, in modo che lo switch abilitato-disabilitato funzioni
  1924.                 if ((messageSecurity != null) )  {

  1926.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1927.                     sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST);
  1928.                     sqlQueryObject.addWhereCondition("id_porta=?");
  1929.                     sqlQuery = sqlQueryObject.createSQLDelete();
  1930.                     stm = con.prepareStatement(sqlQuery);
  1931.                     stm.setLong(1, idPortaDelegata);
  1932.                     stm.executeUpdate();
  1933.                     stm.close();

  1935.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1936.                     sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE);
  1937.                     sqlQueryObject.addWhereCondition("id_porta=?");
  1938.                     sqlQuery = sqlQueryObject.createSQLDelete();
  1939.                     stm = con.prepareStatement(sqlQuery);
  1940.                     stm.setLong(1, idPortaDelegata);
  1941.                     stm.executeUpdate();
  1942.                     stm.close();

  1944.                     //inserisco i valori presenti nella lista 
  1945.                     MessageSecurityFlowParameter reqParam = null;
  1946.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1947.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST);
  1948.                     sqlQueryObject.addInsertField("id_porta", "?");
  1949.                     sqlQueryObject.addInsertField("nome", "?");
  1950.                     sqlQueryObject.addInsertField("valore", "?");
  1951.                     sqlQueryObject.addInsertField("enc_value", "?");
  1952.                     sqlQuery = sqlQueryObject.createSQLInsert();
  1953.                     stm = con.prepareStatement(sqlQuery);

  1955.                     i = 0;
  1956.                     if(messageSecurity.getRequestFlow()!=null){
  1957.                         MessageSecurityFlow flow = messageSecurity.getRequestFlow();
  1958.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  1959.                             reqParam = flow.getParameter(i);
  1960.                             int indexSec = 1;
  1961.                             stm.setLong(indexSec++, idPortaDelegata);
  1962.                             stm.setString(indexSec++, reqParam.getNome());
  1963.                             
  1964.                             String plainValue = reqParam.getValore();
  1965.                             String encValue = null;
  1966.                             if(driverBYOK!=null && 
  1967.                                     (
  1968.                                             DriverConfigurazioneDB_genericPropertiesDriver.isConfidentialProperty(securityRequestMode, reqParam.getNome())
  1969.                                             ||
  1970.                                             BYOKUtilities.isWrappedValue(plainValue)
  1971.                                     )
  1972.                             ) {
  1973.                                 BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  1974.                                 if(byokValue!=null) {
  1975.                                     encValue = byokValue.getWrappedValue();
  1976.                                     plainValue = byokValue.getWrappedPlainValue();
  1977.                                 }
  1978.                             }
  1979.                             stm.setString(indexSec++, plainValue);
  1980.                             stm.setString(indexSec++, encValue);
  1981.                             
  1982.                             stm.executeUpdate();
  1983.                         }
  1984.                     }
  1985.                     stm.close();
  1986.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " request flow con id=" + idPortaDelegata);

  1988.                     MessageSecurityFlowParameter resParam = null;
  1989.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1990.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE);
  1991.                     sqlQueryObject.addInsertField("id_porta", "?");
  1992.                     sqlQueryObject.addInsertField("nome", "?");
  1993.                     sqlQueryObject.addInsertField("valore", "?");
  1994.                     sqlQueryObject.addInsertField("enc_value", "?");
  1995.                     sqlQuery = sqlQueryObject.createSQLInsert();
  1996.                     stm = con.prepareStatement(sqlQuery);
  1997.                     
  1998.                     i = 0;
  1999.                     if(messageSecurity.getResponseFlow()!=null){
  2000.                         MessageSecurityFlow flow = messageSecurity.getResponseFlow();
  2001.                         for (i = 0; i < flow.sizeParameterList(); i++) {
  2002.                             resParam = flow.getParameter(i);
  2003.                             int indexSec = 1;
  2004.                             stm.setLong(indexSec++, idPortaDelegata);
  2005.                             stm.setString(indexSec++, resParam.getNome());
  2006.                             
  2007.                             String plainValue = resParam.getValore();
  2008.                             String encValue = null;
  2009.                             if(driverBYOK!=null && 
  2010.                                     (
  2011.                                             DriverConfigurazioneDB_genericPropertiesDriver.isConfidentialProperty(securityResponseMode, resParam.getNome())
  2012.                                             ||
  2013.                                             BYOKUtilities.isWrappedValue(plainValue)
  2014.                                     )
  2015.                             ) {
  2016.                                 BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  2017.                                 if(byokValue!=null) {
  2018.                                     encValue = byokValue.getWrappedValue();
  2019.                                     plainValue = byokValue.getWrappedPlainValue();
  2020.                                 }
  2021.                             }
  2022.                             stm.setString(indexSec++, plainValue);
  2023.                             stm.setString(indexSec++, encValue);
  2024.                             
  2025.                             stm.executeUpdate();
  2026.                         }
  2027.                     }
  2028.                     stm.close();
  2029.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " response flow con id=" + idPortaDelegata);
  2030.                 }


  2033.                 // la lista di correlazioni applicative contiene tutti e soli gli elementi necessari quindi resetto la lista nel db e riscrivo la lista nuova
  2034.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2035.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE);
  2036.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2037.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2038.                 stm = con.prepareStatement(sqlQuery);
  2039.                 stm.setLong(1, idPortaDelegata);
  2040.                 stm.executeUpdate();
  2041.                 stm.close();
  2042.                 
  2043.                 if (corrApp != null) {
  2044.                     //inserisco i valori presenti nella lista 
  2045.                     CorrelazioneApplicativaElemento cae = null;
  2046.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2047.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE);
  2048.                     sqlQueryObject.addInsertField("id_porta", "?");
  2049.                     sqlQueryObject.addInsertField("nome_elemento", "?");
  2050.                     sqlQueryObject.addInsertField("mode_correlazione", "?");
  2051.                     sqlQueryObject.addInsertField("pattern", "?");
  2052.                     sqlQueryObject.addInsertField("identificazione_fallita", "?");
  2053.                     sqlQueryObject.addInsertField("riuso_id", "?");
  2054.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2055.                     stm = con.prepareStatement(sqlQuery);

  2057.                     for (i = 0; i < corrApp.sizeElementoList(); i++) {
  2058.                         cae = corrApp.getElemento(i);
  2059.                         stm.setLong(1, idPortaDelegata);
  2060.                         stm.setString(2, cae.getNome());
  2061.                         stm.setString(3, DriverConfigurazioneDBLib.getValue(cae.getIdentificazione()));
  2062.                         if (cae.getPattern() != null)
  2063.                             stm.setString(4, cae.getPattern());
  2064.                         else
  2065.                             stm.setString(4, "");
  2066.                         stm.setString(5, DriverConfigurazioneDBLib.getValue(cae.getIdentificazioneFallita()));
  2067.                         stm.setString(6, DriverConfigurazioneDBLib.getValue(cae.getRiusoIdentificativo()));
  2068.                         stm.executeUpdate();
  2069.                     }
  2070.                     stm.close();
  2071.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " correlazione applicativa con id=" + idPortaDelegata);
  2072.                 }

  2074.                 // la lista di correlazioni applicative risposta contiene tutti e soli gli elementi necessari quindi resetto la lista nel db e riscrivo la lista nuova
  2075.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2076.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE_RISPOSTA);
  2077.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2078.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2079.                 stm = con.prepareStatement(sqlQuery);
  2080.                 stm.setLong(1, idPortaDelegata);
  2081.                 stm.executeUpdate();
  2082.                 stm.close();
  2083.                 
  2084.                 if (corrAppRisposta != null) {
  2085.                     //inserisco i valori presenti nella lista 
  2086.                     CorrelazioneApplicativaRispostaElemento cae = null;
  2087.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2088.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE_RISPOSTA);
  2089.                     sqlQueryObject.addInsertField("id_porta", "?");
  2090.                     sqlQueryObject.addInsertField("nome_elemento", "?");
  2091.                     sqlQueryObject.addInsertField("mode_correlazione", "?");
  2092.                     sqlQueryObject.addInsertField("pattern", "?");
  2093.                     sqlQueryObject.addInsertField("identificazione_fallita", "?");
  2094.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2095.                     stm = con.prepareStatement(sqlQuery);

  2097.                     for (i = 0; i < corrAppRisposta.sizeElementoList(); i++) {
  2098.                         cae = corrAppRisposta.getElemento(i);
  2099.                         stm.setLong(1, idPortaDelegata);
  2100.                         stm.setString(2, cae.getNome());
  2101.                         stm.setString(3, DriverConfigurazioneDBLib.getValue(cae.getIdentificazione()));
  2102.                         if (cae.getPattern() != null)
  2103.                             stm.setString(4, cae.getPattern());
  2104.                         else
  2105.                             stm.setString(4, "");
  2106.                         stm.setString(5, DriverConfigurazioneDBLib.getValue(cae.getIdentificazioneFallita()));
  2107.                         stm.executeUpdate();
  2108.                     }
  2109.                     stm.close();
  2110.                     DriverConfigurazioneDBLib.logDebug("Inserted " + i + " correlazione applicativa risposta con id=" + idPortaDelegata);
  2111.                 }
  2112.                 
  2113.                 /*Sincronizzazione servizi applicativi*/
  2114.                 //la lista dei servizi applicativi passata contiene tutti e soli i servizi applicativi necessari
  2115.                 //quindi nel db devono essere presenti tutti e solo quelli presenti nella lista
  2116.                 //se la lista e' vuota allora i servizi applicativi vanno cancellati

  2118.                 //cancello i servizi applicativi associati alla porta e inserisco tutti e soli quelli presenti in lista
  2119.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2120.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_SA);
  2121.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2122.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2123.                 stm = con.prepareStatement(sqlQuery);
  2124.                 stm.setLong(1, idPortaDelegata);
  2125.                 n=stm.executeUpdate();
  2126.                 stm.close();
  2127.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" servizi applicativi associati alla Porta Delegata "+idPortaDelegata);
  2128.                 //scrivo la lista nel db
  2129.                 n=0;
  2130.                 for (i = 0; i < aPD.sizeServizioApplicativoList(); i++) {
  2131.                     PortaDelegataServizioApplicativo servizioApplicativo = aPD.getServizioApplicativo(i);

  2133.                     String nomeSA = servizioApplicativo.getNome();
  2134.                     //il tipo e il nome proprietario servizio applicativo sono gli stessi della porta delegata
  2135.                     //controllo se sono settati gli old, perche potrei essere in un caso di update
  2136.                     String nomeProprietarioSA = aPD.getNomeSoggettoProprietario(); 
  2137.                     String tipoProprietarioSA = aPD.getTipoSoggettoProprietario(); 

  2139.                     if (nomeSA == null || nomeSA.equals(""))
  2140.                         throw new DriverConfigurazioneException("Nome del ServizioApplicativo associato non valido.");
  2141.                     if (nomeProprietarioSA == null || nomeProprietarioSA.equals(""))
  2142.                         throw new DriverConfigurazioneException("Nome Proprietario del ServizioApplicativo associato non valido.");
  2143.                     if (tipoProprietarioSA == null || tipoProprietarioSA.equals(""))
  2144.                         throw new DriverConfigurazioneException("Tipo Proprietario del ServizioApplicativo associato non valido.");

  2146.                     long idSA = DriverConfigurazioneDB_serviziApplicativiLIB.getIdServizioApplicativo(nomeSA, tipoProprietarioSA, nomeProprietarioSA, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);

  2148.                     if (idSA <= 0)
  2149.                         throw new DriverConfigurazioneException("Impossibile recuperare l'id del Servizio Applicativo [" + nomeSA + "] di [" + tipoProprietarioSA + "/" + nomeProprietarioSA + "]");

  2151.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2152.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_SA);
  2153.                     sqlQueryObject.addInsertField("id_porta", "?");
  2154.                     sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  2155.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2156.                     stm = con.prepareStatement(sqlQuery);
  2157.                     stm.setLong(1, idPortaDelegata);
  2158.                     stm.setLong(2, idSA);

  2160.                     stm.executeUpdate();
  2161.                     stm.close();
  2162.                     n++;
  2163.                     DriverConfigurazioneDBLib.logDebug("Aggiunta associazione PortaDelegata<->ServizioApplicativo [" + idPortaDelegata + "]<->[" + idSA + "]");
  2164.                 }

  2166.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " associazioni PortaDelegata<->ServizioApplicativo associati alla PortaDelegata[" + idPortaDelegata + "]");

  2168.                 
  2169.                 
  2170.                 /*Proprieta Autenticazione associate alla Porta Delegata*/

  2172.                 //La lista di proprieta contiene tutte e sole le proprieta associate alla porta
  2173.                 //cancello le proprieta per poi sincronizzarle con la lista passata
  2174.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2175.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP);
  2176.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2177.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2178.                 stm = con.prepareStatement(sqlQuery);
  2179.                 stm.setLong(1, idPortaDelegata);
  2180.                 n=stm.executeUpdate();
  2181.                 stm.close();
  2182.                 DriverConfigurazioneDBLib.logDebug("Eliminate "+n+" proprieta di autenticazione associate alla Porta Delegata "+idPortaDelegata);
  2183.                 // set prop
  2184.                 int newProps = 0;
  2185.                 for (i = 0; i < aPD.sizeProprietaAutenticazioneList(); i++) {
  2186.                     Proprieta propProtocollo = aPD.getProprietaAutenticazione(i);

  2188.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2189.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP);
  2190.                     sqlQueryObject.addInsertField("id_porta", "?");
  2191.                     sqlQueryObject.addInsertField("nome", "?");
  2192.                     sqlQueryObject.addInsertField("valore", "?");
  2193.                     sqlQueryObject.addInsertField("enc_value", "?");
  2194.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2195.                     stm = con.prepareStatement(sqlQuery);

  2197.                     int indexP = 1;
  2198.                     stm.setLong(indexP++, idPortaDelegata);
  2199.                     stm.setString(indexP++, propProtocollo.getNome());
  2200.                     
  2201.                     String plainValueP = propProtocollo.getValore();
  2202.                     String encValueP = null;
  2203.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  2204.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  2205.                         if(byokValue!=null) {
  2206.                             encValueP = byokValue.getWrappedValue();
  2207.                             plainValueP = byokValue.getWrappedPlainValue();
  2208.                         }
  2209.                     }
  2210.                     
  2211.                     stm.setString(indexP++, plainValueP);
  2212.                     stm.setString(indexP++, encValueP);
  2213.                     
  2214.                     stm.executeUpdate();
  2215.                     stm.close();
  2216.                     newProps++;
  2217.                 }
  2218.                 DriverConfigurazioneDBLib.logDebug("Inserted " + newProps + " SetProtocolProp Autenticazione associati alla PortaDelegata[" + idPortaDelegata + "]");
  2219.                 
  2220.                 
  2221.                 
  2222.                 /*Proprieta Autorizzazione associate alla Porta Delegata*/

  2224.                 //La lista di proprieta contiene tutte e sole le proprieta associate alla porta
  2225.                 //cancello le proprieta per poi sincronizzarle con la lista passata
  2226.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2227.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP);
  2228.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2229.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2230.                 stm = con.prepareStatement(sqlQuery);
  2231.                 stm.setLong(1, idPortaDelegata);
  2232.                 n=stm.executeUpdate();
  2233.                 stm.close();
  2234.                 DriverConfigurazioneDBLib.logDebug("Eliminate "+n+" proprieta di autorizzazione associate alla Porta Delegata "+idPortaDelegata);
  2235.                 // set prop
  2236.                 newProps = 0;
  2237.                 for (i = 0; i < aPD.sizeProprietaAutorizzazioneList(); i++) {
  2238.                     Proprieta propProtocollo = aPD.getProprietaAutorizzazione(i);

  2240.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2241.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP);
  2242.                     sqlQueryObject.addInsertField("id_porta", "?");
  2243.                     sqlQueryObject.addInsertField("nome", "?");
  2244.                     sqlQueryObject.addInsertField("valore", "?");
  2245.                     sqlQueryObject.addInsertField("enc_value", "?");
  2246.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2247.                     stm = con.prepareStatement(sqlQuery);

  2249.                     int indexP = 1;
  2250.                     stm.setLong(indexP++, idPortaDelegata);
  2251.                     stm.setString(indexP++, propProtocollo.getNome());
  2252.                     
  2253.                     String plainValueP = propProtocollo.getValore();
  2254.                     String encValueP = null;
  2255.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  2256.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  2257.                         if(byokValue!=null) {
  2258.                             encValueP = byokValue.getWrappedValue();
  2259.                             plainValueP = byokValue.getWrappedPlainValue();
  2260.                         }
  2261.                     }
  2262.                     
  2263.                     stm.setString(indexP++, plainValueP);
  2264.                     stm.setString(indexP++, encValueP);
  2265.                     
  2266.                     stm.executeUpdate();
  2267.                     stm.close();
  2268.                     newProps++;
  2269.                 }
  2270.                 DriverConfigurazioneDBLib.logDebug("Inserted " + newProps + " SetProtocolProp Autorizzazione associati alla PortaDelegata[" + idPortaDelegata + "]");
  2271.                 
  2272.                 
  2273.                 
  2274.                 
  2275.                 /*Proprieta Autorizzazione Contenuti associate alla Porta Delegata*/

  2277.                 //La lista di proprieta contiene tutte e sole le proprieta associate alla porta
  2278.                 //cancello le proprieta per poi sincronizzarle con la lista passata
  2279.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2280.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP);
  2281.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2282.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2283.                 stm = con.prepareStatement(sqlQuery);
  2284.                 stm.setLong(1, idPortaDelegata);
  2285.                 n=stm.executeUpdate();
  2286.                 stm.close();
  2287.                 DriverConfigurazioneDBLib.logDebug("Eliminate "+n+" proprieta di autorizzazione contenuti associate alla Porta Delegata "+idPortaDelegata);
  2288.                 // set prop
  2289.                 newProps = 0;
  2290.                 for (i = 0; i < aPD.sizeProprietaAutorizzazioneContenutoList(); i++) {
  2291.                     Proprieta propProtocollo = aPD.getProprietaAutorizzazioneContenuto(i);

  2293.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2294.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP);
  2295.                     sqlQueryObject.addInsertField("id_porta", "?");
  2296.                     sqlQueryObject.addInsertField("nome", "?");
  2297.                     sqlQueryObject.addInsertField("valore", "?");
  2298.                     sqlQueryObject.addInsertField("enc_value", "?");
  2299.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2300.                     stm = con.prepareStatement(sqlQuery);

  2302.                     int indexP = 1;
  2303.                     stm.setLong(indexP++, idPortaDelegata);
  2304.                     stm.setString(indexP++, propProtocollo.getNome());
  2305.                     
  2306.                     String plainValueP = propProtocollo.getValore();
  2307.                     String encValueP = null;
  2308.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  2309.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  2310.                         if(byokValue!=null) {
  2311.                             encValueP = byokValue.getWrappedValue();
  2312.                             plainValueP = byokValue.getWrappedPlainValue();
  2313.                         }
  2314.                     }
  2315.                     
  2316.                     stm.setString(indexP++, plainValueP);
  2317.                     stm.setString(indexP++, encValueP);
  2318.                     
  2319.                     stm.executeUpdate();
  2320.                     stm.close();
  2321.                     newProps++;
  2322.                 }
  2323.                 DriverConfigurazioneDBLib.logDebug("Inserted " + newProps + " SetProtocolProp AutorizzazioneContenuto associati alla PortaDelegata[" + idPortaDelegata + "]");
  2324.                 
  2325.                 
  2326.                 
  2327.                 
  2328.                 
  2329.                 /*Proprieta Rate Limiting associate alla Porta Delegata*/

  2331.                 //La lista di proprieta contiene tutte e sole le proprieta associate alla porta
  2332.                 //cancello le proprieta per poi sincronizzarle con la lista passata
  2333.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2334.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_RATE_LIMITING_PROP);
  2335.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2336.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2337.                 stm = con.prepareStatement(sqlQuery);
  2338.                 stm.setLong(1, idPortaDelegata);
  2339.                 n=stm.executeUpdate();
  2340.                 stm.close();
  2341.                 DriverConfigurazioneDBLib.logDebug("Eliminate "+n+" proprieta di rate limiting associate alla Porta Delegata "+idPortaDelegata);
  2342.                 // set prop
  2343.                 newProps = 0;
  2344.                 for (i = 0; i < aPD.sizeProprietaRateLimitingList(); i++) {
  2345.                     Proprieta propProtocollo = aPD.getProprietaRateLimiting(i);

  2347.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2348.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_RATE_LIMITING_PROP);
  2349.                     sqlQueryObject.addInsertField("id_porta", "?");
  2350.                     sqlQueryObject.addInsertField("nome", "?");
  2351.                     sqlQueryObject.addInsertField("valore", "?");
  2352.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2353.                     stm = con.prepareStatement(sqlQuery);

  2355.                     stm.setLong(1, idPortaDelegata);
  2356.                     stm.setString(2, propProtocollo.getNome());
  2357.                     stm.setString(3, propProtocollo.getValore());
  2358.                     stm.executeUpdate();
  2359.                     stm.close();
  2360.                     newProps++;
  2361.                 }
  2362.                 DriverConfigurazioneDBLib.logDebug("Inserted " + newProps + " SetProtocolPropRateLimiting associati alla PortaDelegata[" + idPortaDelegata + "]");
  2363.                 
  2364.                 
  2365.                 
  2366.                 
  2367.                 
  2368.                 
  2369.                 /*Proprieta associate alla Porta Delegata*/

  2371.                 //La lista di proprieta contiene tutte e sole le proprieta associate alla porta
  2372.                 //cancello le proprieta per poi sincronizzarle con la lista passata
  2373.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2374.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_PROP);
  2375.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2376.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2377.                 stm = con.prepareStatement(sqlQuery);
  2378.                 stm.setLong(1, idPortaDelegata);
  2379.                 n=stm.executeUpdate();
  2380.                 stm.close();
  2381.                 DriverConfigurazioneDBLib.logDebug("Eliminate "+n+" proprieta associate alla Porta Delegata "+idPortaDelegata);
  2382.                 // set prop
  2383.                 newProps = 0;
  2384.                 for (i = 0; i < aPD.sizeProprietaList(); i++) {
  2385.                     Proprieta propProtocollo = aPD.getProprieta(i);

  2387.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2388.                     sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_PROP);
  2389.                     sqlQueryObject.addInsertField("id_porta", "?");
  2390.                     sqlQueryObject.addInsertField("nome", "?");
  2391.                     sqlQueryObject.addInsertField("valore", "?");
  2392.                     sqlQueryObject.addInsertField("enc_value", "?");
  2393.                     sqlQuery = sqlQueryObject.createSQLInsert();
  2394.                     stm = con.prepareStatement(sqlQuery);

  2396.                     int indexP = 1;
  2397.                     stm.setLong(indexP++, idPortaDelegata);
  2398.                     stm.setString(indexP++, propProtocollo.getNome());
  2399.                     
  2400.                     String plainValueP = propProtocollo.getValore();
  2401.                     String encValueP = null;
  2402.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValueP) ) {
  2403.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValueP);
  2404.                         if(byokValue!=null) {
  2405.                             encValueP = byokValue.getWrappedValue();
  2406.                             plainValueP = byokValue.getWrappedPlainValue();
  2407.                         }
  2408.                     }
  2409.                     
  2410.                     stm.setString(indexP++, plainValueP);
  2411.                     stm.setString(indexP++, encValueP);
  2412.                     
  2413.                     stm.executeUpdate();
  2414.                     stm.close();
  2415.                     newProps++;
  2416.                 }
  2417.                 DriverConfigurazioneDBLib.logDebug("Inserted " + newProps + " SetProtocolProp associati alla PortaDelegata[" + idPortaDelegata + "]");
  2418.                 
  2419.                 
  2420.                 // Ruoli
  2421.                 
  2422.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2423.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  2424.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2425.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2426.                 stm = con.prepareStatement(sqlQuery);
  2427.                 stm.setLong(1, idPortaDelegata);
  2428.                 n=stm.executeUpdate();
  2429.                 stm.close();
  2430.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" ruoli associati alla Porta Delegata "+idPortaDelegata);
  2431.                 
  2432.                 n=0;
  2433.                 if(aPD.getRuoli()!=null && aPD.getRuoli().sizeRuoloList()>0){
  2434.                     for (int j = 0; j < aPD.getRuoli().sizeRuoloList(); j++) {
  2435.                         Ruolo ruolo = aPD.getRuoli().getRuolo(j);
  2436.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2437.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  2438.                         sqlQueryObject.addInsertField("id_porta", "?");
  2439.                         sqlQueryObject.addInsertField("ruolo", "?");
  2440.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2441.                         stm = con.prepareStatement(sqlQuery);
  2442.                         stm.setLong(1, idPortaDelegata);
  2443.                         stm.setString(2, ruolo.getNome());
  2444.                         stm.executeUpdate();
  2445.                         stm.close();
  2446.                         n++;
  2447.                         DriverConfigurazioneDBLib.logDebug("Aggiunto ruolo[" + ruolo.getNome() + "] alla PortaDelegata[" + idPortaDelegata + "]");
  2448.                     }
  2449.                 }
  2450.                 
  2451.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " ruoli alla PortaDelegata[" + idPortaDelegata + "]");
  2452.                 
  2453.                 
  2454.                 
  2455.                 // Scope
  2456.                 
  2457.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2458.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  2459.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2460.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2461.                 stm = con.prepareStatement(sqlQuery);
  2462.                 stm.setLong(1, idPortaDelegata);
  2463.                 n=stm.executeUpdate();
  2464.                 stm.close();
  2465.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" scope associati alla Porta Delegata "+idPortaDelegata);
  2466.                 
  2467.                 n=0;
  2468.                 if(aPD.getScope()!=null && aPD.getScope().sizeScopeList()>0){
  2469.                     for (int j = 0; j < aPD.getScope().sizeScopeList(); j++) {
  2470.                         Scope scope = aPD.getScope().getScope(j);
  2471.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2472.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  2473.                         sqlQueryObject.addInsertField("id_porta", "?");
  2474.                         sqlQueryObject.addInsertField("scope", "?");
  2475.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2476.                         stm = con.prepareStatement(sqlQuery);
  2477.                         stm.setLong(1, idPortaDelegata);
  2478.                         stm.setString(2, scope.getNome());
  2479.                         stm.executeUpdate();
  2480.                         stm.close();
  2481.                         n++;
  2482.                         DriverConfigurazioneDBLib.logDebug("Aggiunto scope[" + scope.getNome() + "] alla PortaDelegata[" + idPortaDelegata + "]");
  2483.                     }
  2484.                 }
  2485.                 
  2486.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " scope alla PortaDelegata[" + idPortaDelegata + "]");
  2487.                 
  2488.                 
  2489.                 
  2490.                 
  2491.                 /*Sincronizzazione servizi applicativi token */
  2492.                 //la lista dei servizi applicativi passata contiene tutti e soli i servizi applicativi necessari
  2493.                 //quindi nel db devono essere presenti tutti e solo quelli presenti nella lista
  2494.                 //se la lista e' vuota allora i servizi applicativi vanno cancellati

  2496.                 //cancello i servizi applicativi associati alla porta e inserisco tutti e soli quelli presenti in lista
  2497.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2498.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  2499.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2500.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2501.                 stm = con.prepareStatement(sqlQuery);
  2502.                 stm.setLong(1, idPortaDelegata);
  2503.                 n=stm.executeUpdate();
  2504.                 stm.close();
  2505.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" servizi applicativi (token) associati alla Porta Delegata "+idPortaDelegata);
  2506.             
  2507.                 // serviziapplicativi (token)
  2508.                 if(aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  2509.                         aPD.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  2510.                     //scrivo la lista nel db
  2511.                     n=0;
  2512.                     for (i = 0; i < aPD.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList(); i++) {
  2513.                         PortaDelegataServizioApplicativo servizioApplicativo = aPD.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(i);
  2514.     
  2515.                         String nomeSA = servizioApplicativo.getNome();
  2516.                         //il tipo e il nome proprietario servizio applicativo sono gli stessi della porta delegata
  2517.                         //controllo se sono settati gli old, perche potrei essere in un caso di update
  2518.                         String nomeProprietarioSA = aPD.getNomeSoggettoProprietario(); 
  2519.                         String tipoProprietarioSA = aPD.getTipoSoggettoProprietario(); 
  2520.     
  2521.                         if (nomeSA == null || nomeSA.equals(""))
  2522.                             throw new DriverConfigurazioneException("Nome del ServizioApplicativo associato non valido.");
  2523.                         if (nomeProprietarioSA == null || nomeProprietarioSA.equals(""))
  2524.                             throw new DriverConfigurazioneException("Nome Proprietario del ServizioApplicativo associato non valido.");
  2525.                         if (tipoProprietarioSA == null || tipoProprietarioSA.equals(""))
  2526.                             throw new DriverConfigurazioneException("Tipo Proprietario del ServizioApplicativo associato non valido.");
  2527.     
  2528.                         long idSA = DriverConfigurazioneDB_serviziApplicativiLIB.getIdServizioApplicativo(nomeSA, tipoProprietarioSA, nomeProprietarioSA, con, DriverConfigurazioneDBLib.tipoDB,DriverConfigurazioneDBLib.tabellaSoggetti);
  2529.     
  2530.                         if (idSA <= 0)
  2531.                             throw new DriverConfigurazioneException("Impossibile recuperare l'id del Servizio Applicativo [" + nomeSA + "] di [" + tipoProprietarioSA + "/" + nomeProprietarioSA + "]");
  2532.     
  2533.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2534.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  2535.                         sqlQueryObject.addInsertField("id_porta", "?");
  2536.                         sqlQueryObject.addInsertField("id_servizio_applicativo", "?");
  2537.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2538.                         stm = con.prepareStatement(sqlQuery);
  2539.                         stm.setLong(1, idPortaDelegata);
  2540.                         stm.setLong(2, idSA);
  2541.     
  2542.                         stm.executeUpdate();
  2543.                         stm.close();
  2544.                         n++;
  2545.                         DriverConfigurazioneDBLib.logDebug("Aggiunta associazione PortaDelegata<->ServizioApplicativo (token) [" + idPortaDelegata + "]<->[" + idSA + "]");
  2546.                     }
  2547.     
  2548.                     DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " associazioni PortaDelegata<->ServizioApplicativo (token) associati alla PortaDelegata[" + idPortaDelegata + "]");
  2549.                 }
  2550.                 
  2551.                 
  2552.                 
  2553.                 // Ruoli (token)
  2554.                 
  2555.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2556.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  2557.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2558.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2559.                 stm = con.prepareStatement(sqlQuery);
  2560.                 stm.setLong(1, idPortaDelegata);
  2561.                 n=stm.executeUpdate();
  2562.                 stm.close();
  2563.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" ruoli (token) associati alla Porta Delegata "+idPortaDelegata);
  2564.                 
  2565.                 n=0;
  2566.                 if(aPD.getAutorizzazioneToken()!=null && aPD.getAutorizzazioneToken().getRuoli()!=null &&
  2567.                         aPD.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0){
  2568.                     for (int j = 0; j < aPD.getAutorizzazioneToken().getRuoli().sizeRuoloList(); j++) {
  2569.                         Ruolo ruolo = aPD.getAutorizzazioneToken().getRuoli().getRuolo(j);
  2570.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2571.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  2572.                         sqlQueryObject.addInsertField("id_porta", "?");
  2573.                         sqlQueryObject.addInsertField("ruolo", "?");
  2574.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2575.                         stm = con.prepareStatement(sqlQuery);
  2576.                         stm.setLong(1, idPortaDelegata);
  2577.                         stm.setString(2, ruolo.getNome());
  2578.                         stm.executeUpdate();
  2579.                         stm.close();
  2580.                         n++;
  2581.                         DriverConfigurazioneDBLib.logDebug("Aggiunto ruolo[" + ruolo.getNome() + "] (token) alla PortaDelegata[" + idPortaDelegata + "]");
  2582.                     }
  2583.                 }
  2584.                 
  2585.                 DriverConfigurazioneDBLib.logDebug("Aggiunti " + n + " ruoli (token) alla PortaDelegata[" + idPortaDelegata + "]");
  2586.                 
  2587.                 
  2588.                 // Azioni
  2589.                 
  2590.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2591.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  2592.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2593.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2594.                 stm = con.prepareStatement(sqlQuery);
  2595.                 stm.setLong(1, idPortaDelegata);
  2596.                 n=stm.executeUpdate();
  2597.                 stm.close();
  2598.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" azioni delegate associate alla Porta Delegata "+idPortaDelegata);
  2599.                 
  2600.                 n=0;
  2601.                 if(aPD.getAzione()!=null && aPD.getAzione().sizeAzioneDelegataList()>0){
  2602.                     for (int j = 0; j < aPD.getAzione().sizeAzioneDelegataList(); j++) {
  2603.                         String azioneDelegata = aPD.getAzione().getAzioneDelegata(j);
  2604.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2605.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  2606.                         sqlQueryObject.addInsertField("id_porta", "?");
  2607.                         sqlQueryObject.addInsertField("azione", "?");
  2608.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2609.                         stm = con.prepareStatement(sqlQuery);
  2610.                         stm.setLong(1, idPortaDelegata);
  2611.                         stm.setString(2, azioneDelegata);
  2612.                         stm.executeUpdate();
  2613.                         stm.close();
  2614.                         n++;
  2615.                         DriverConfigurazioneDBLib.logDebug("Aggiunta azione delegata [" + azioneDelegata + "] alla PortaDelegata[" + idPortaDelegata + "]");
  2616.                     }
  2617.                 }
  2618.                 
  2619.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " azioni delegate alla PortaDelegata[" + idPortaDelegata + "]");
  2620.                 
  2621.                 
  2622.                 
  2623.                 
  2624.                 // Cache Regole
  2625.                 
  2626.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2627.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_CACHE_REGOLE);
  2628.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2629.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2630.                 stm = con.prepareStatement(sqlQuery);
  2631.                 stm.setLong(1, idPortaDelegata);
  2632.                 n=stm.executeUpdate();
  2633.                 stm.close();
  2634.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" regole di cache associate alla Porta Delegata "+idPortaDelegata);
  2635.                 
  2636.                 n=0;
  2637.                 if(responseCacheRegole!=null && responseCacheRegole.size()>0){
  2638.                     for (int j = 0; j < responseCacheRegole.size(); j++) {
  2639.                         ResponseCachingConfigurazioneRegola regola = responseCacheRegole.get(j);
  2640.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2641.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_CACHE_REGOLE);
  2642.                         sqlQueryObject.addInsertField("id_porta", "?");
  2643.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  2644.                             sqlQueryObject.addInsertField("status_min", "?");
  2645.                         }
  2646.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  2647.                             sqlQueryObject.addInsertField("status_max", "?");
  2648.                         }
  2649.                         sqlQueryObject.addInsertField("fault", "?");
  2650.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  2651.                             sqlQueryObject.addInsertField("cache_seconds", "?");
  2652.                         }
  2653.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2654.                         stm = con.prepareStatement(sqlQuery);
  2655.                         int indexCR = 1;
  2656.                         stm.setLong(indexCR++, idPortaDelegata);
  2657.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  2658.                             stm.setInt(indexCR++, regola.getReturnCodeMin());
  2659.                         }
  2660.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  2661.                             stm.setInt(indexCR++, regola.getReturnCodeMax());
  2662.                         }
  2663.                         stm.setInt(indexCR++, regola.getFault() ? CostantiDB.TRUE : CostantiDB.FALSE);
  2664.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  2665.                             stm.setInt(indexCR++, regola.getCacheTimeoutSeconds());
  2666.                         }
  2667.                         stm.executeUpdate();
  2668.                         stm.close();
  2669.                         n++;
  2670.                         DriverConfigurazioneDBLib.logDebug("Aggiunta regola di cache alla PortaDelegata[" + idPortaDelegata + "]");
  2671.                     }
  2672.                 }
  2673.                 
  2674.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " regole di cache alla PortaDelegata[" + idPortaDelegata + "]");
  2675.                 
  2676.                 
  2677.                 
  2678.                 // AttributeAuthority
  2679.                 
  2680.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2681.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_ATTRIBUTE_AUTHORITY);
  2682.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2683.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2684.                 stm = con.prepareStatement(sqlQuery);
  2685.                 stm.setLong(1, idPortaDelegata);
  2686.                 n=stm.executeUpdate();
  2687.                 stm.close();
  2688.                 DriverConfigurazioneDBLib.logDebug("Cancellate "+n+" A.A. associate alla Porta Delegata "+idPortaDelegata);
  2689.                 
  2690.                 n=0;
  2691.                 if(aPD.sizeAttributeAuthorityList()>0){
  2692.                     for (int j = 0; j < aPD.sizeAttributeAuthorityList(); j++) {
  2693.                         AttributeAuthority aa = aPD.getAttributeAuthority(j);
  2694.                         
  2695.                         String attributi = null;
  2696.                         if(aa.sizeAttributoList()>0) {
  2697.                             StringBuilder bf = new StringBuilder();
  2698.                             for (int aaI = 0; aaI < aa.sizeAttributoList(); aaI++) {
  2699.                                 if(aaI>0) {
  2700.                                     bf.append(",");
  2701.                                 }
  2702.                                 bf.append(aa.getAttributo(aaI));
  2703.                             }
  2704.                             attributi = bf.toString();
  2705.                         }
  2706.                         
  2707.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2708.                         sqlQueryObject.addInsertTable(CostantiDB.PORTE_DELEGATE_ATTRIBUTE_AUTHORITY);
  2709.                         sqlQueryObject.addInsertField("id_porta", "?");
  2710.                         sqlQueryObject.addInsertField("nome", "?");
  2711.                         sqlQueryObject.addInsertField("attributi", "?");
  2712.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2713.                         stm = con.prepareStatement(sqlQuery);
  2714.                         stm.setLong(1, idPortaDelegata);
  2715.                         stm.setString(2, aa.getNome());
  2716.                         stm.setString(3, attributi);
  2717.                         stm.executeUpdate();
  2718.                         stm.close();
  2719.                         n++;
  2720.                         DriverConfigurazioneDBLib.logDebug("Aggiunta A.A.[" + aa.getNome() + "] alla PortaDelegata[" + idPortaDelegata + "]");
  2721.                     }
  2722.                 }
  2723.                 
  2724.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " A.A. alla PortaDelegata[" + idPortaDelegata + "]");
  2725.                 
  2726.                 
  2727.                 
  2728.                 // tracciamentoConfigurazione
  2729.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoDatabase, idPortaDelegata, 
  2730.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  2731.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2732.                 
  2733.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoFiletrace, idPortaDelegata, 
  2734.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  2735.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2736.                 
  2737.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoFiletraceDetails, idPortaDelegata, 
  2738.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD);
  2739.                 
  2740.                 
  2741.                 // dumpConfigurazione
  2742.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, aPD.getDump(), idPortaDelegata, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_PD);
  2743.                 
  2744.                 
  2745.                 // trasformazioni
  2746.                 DriverConfigurazioneDBTrasformazioniLib.CRUDTrasformazioni(type, con, aPD.getTrasformazioni(), idPortaDelegata, true);
  2747.                 
  2748.                 
  2749.                 // Handlers
  2750.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, idPortaDelegata, null, true, (configHandlers!=null) ? configHandlers.getRequest() : null);
  2751.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, idPortaDelegata, null, false, (configHandlers!=null) ? configHandlers.getResponse() : null);
  2752.                 
  2753.                 
  2754.                 // extendedInfo
  2755.                 if(extInfoConfigurazioneDriver!=null){
  2756.                     extInfoConfigurazioneDriver.deleteAllExtendedInfo(con, DriverConfigurazioneDBLib.log, aPD, CRUDType.UPDATE);
  2757.                 }
  2758.                 
  2759.                 i=0;
  2760.                 if(aPD.sizeExtendedInfoList()>0 &&
  2761.                     (extInfoConfigurazioneDriver!=null)
  2762.                     ){
  2763.                     for (i = 0; i < aPD.sizeExtendedInfoList(); i++) {
  2764.                         extInfoConfigurazioneDriver.createExtendedInfo(con, DriverConfigurazioneDBLib.log, aPD, aPD.getExtendedInfo(i), CRUDType.UPDATE);
  2765.                     }
  2766.                 }
  2767.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + i + " associazioni ExtendedInfo<->PortaDelegata associati alla PortaDelegata[" + idPortaDelegata + "]");
  2768.                 
  2769.                 
  2770.                 break;

  2772.             case DELETE:
  2773.                 // delete
  2774.                 idPortaDelegata = DBUtils.getIdPortaDelegata(nomePorta, con, DriverConfigurazioneDBLib.tipoDB);
  2775.                 if (idPortaDelegata <= 0)
  2776.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata(DELETE)] Non e' stato possibile recuperare l'id della Porta Delegata, necessario per effettuare la DELETE.");

  2778.                 // tracciamentoConfigurazione
  2779.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoDatabase, idPortaDelegata, 
  2780.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  2781.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2782.                 
  2783.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoFiletrace, idPortaDelegata, 
  2784.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  2785.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2786.                 
  2787.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoFiletraceDetails, idPortaDelegata, 
  2788.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD);
  2789.                 
  2790.                 // dumpConfigurazione
  2791.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, aPD.getDump(), idPortaDelegata, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_PD);
  2792.                 
  2793.                 // trasformazioni
  2794.                 DriverConfigurazioneDBTrasformazioniLib.CRUDTrasformazioni(type, con, aPD.getTrasformazioni(), idPortaDelegata, true);
  2795.                 
  2796.                 // Handlers
  2797.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, idPortaDelegata, null, true, (configHandlers!=null) ? configHandlers.getRequest() : null);
  2798.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, idPortaDelegata, null, false, (configHandlers!=null) ? configHandlers.getResponse() : null);
  2799.                 
  2800.                 // AttributeAuthority
  2801.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2802.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_ATTRIBUTE_AUTHORITY);
  2803.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2804.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2805.                 stm = con.prepareStatement(sqlQuery);
  2806.                 stm.setLong(1, idPortaDelegata);
  2807.                 n=stm.executeUpdate();
  2808.                 stm.close();
  2809.                 DriverConfigurazioneDBLib.logDebug("Cancellate "+n+" A.A. associate alla Porta Delegata "+idPortaDelegata);
  2810.                 
  2811.                 // Cache Regole
  2812.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2813.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_CACHE_REGOLE);
  2814.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2815.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2816.                 stm = con.prepareStatement(sqlQuery);
  2817.                 stm.setLong(1, idPortaDelegata);
  2818.                 n=stm.executeUpdate();
  2819.                 stm.close();
  2820.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" regole di cache associate alla Porta Delegata "+idPortaDelegata);
  2821.                 
  2822.                 // azioni delegate
  2823.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2824.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  2825.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2826.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2827.                 stm = con.prepareStatement(sqlQuery);
  2828.                 stm.setLong(1, idPortaDelegata);
  2829.                 n=stm.executeUpdate();
  2830.                 stm.close();
  2831.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" azioni delegate associate alla Porta Delegata "+idPortaDelegata);
  2832.                 
  2833.                 // ruoli (token)
  2834.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2835.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  2836.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2837.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2838.                 stm = con.prepareStatement(sqlQuery);
  2839.                 stm.setLong(1, idPortaDelegata);
  2840.                 n=stm.executeUpdate();
  2841.                 stm.close();
  2842.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" ruoli (token) associati alla Porta Delegata "+idPortaDelegata);
  2843.                 
  2844.                 // servizi applicativi (token)
  2845.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2846.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  2847.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2848.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2849.                 stm = con.prepareStatement(sqlQuery);
  2850.                 stm.setLong(1, idPortaDelegata);
  2851.                 n=stm.executeUpdate();
  2852.                 stm.close();
  2853.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " associazioni PortaDelegata<->ServizioApplicativo (token) associati alla PortaDelegata[" + idPortaDelegata + "]");
  2854.                 
  2855.                 // ruoli
  2856.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2857.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  2858.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2859.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2860.                 stm = con.prepareStatement(sqlQuery);
  2861.                 stm.setLong(1, idPortaDelegata);
  2862.                 n=stm.executeUpdate();
  2863.                 stm.close();
  2864.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" ruoli associati alla Porta Delegata "+idPortaDelegata);
  2865.                 
  2866.                 // scope
  2867.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2868.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  2869.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2870.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2871.                 stm = con.prepareStatement(sqlQuery);
  2872.                 stm.setLong(1, idPortaDelegata);
  2873.                 n=stm.executeUpdate();
  2874.                 stm.close();
  2875.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" scope associati alla Porta Delegata "+idPortaDelegata);
  2876.                 
  2877.                 // mtom
  2878.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2879.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MTOM_REQUEST);
  2880.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2881.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2882.                 stm = con.prepareStatement(sqlQuery);
  2883.                 stm.setLong(1, idPortaDelegata);
  2884.                 n=stm.executeUpdate();
  2885.                 stm.close();
  2886.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " request flow con id=" + idPortaDelegata);

  2888.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2889.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MTOM_RESPONSE);
  2890.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2891.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2892.                 stm = con.prepareStatement(sqlQuery);
  2893.                 stm.setLong(1, idPortaDelegata);
  2894.                 n=stm.executeUpdate();
  2895.                 stm.close();
  2896.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " response flow con id=" + idPortaDelegata);

  2898.                 
  2899.                 // message security
  2900.                 //if ( CostantiConfigurazione.ABILITATO.toString().equals(messageSecurityStatus) )  {
  2901.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2902.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST);
  2903.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2904.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2905.                 stm = con.prepareStatement(sqlQuery);
  2906.                 stm.setLong(1, idPortaDelegata);
  2907.                 n=stm.executeUpdate();
  2908.                 stm.close();
  2909.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " request flow con id=" + idPortaDelegata);

  2911.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2912.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE);
  2913.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2914.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2915.                 stm = con.prepareStatement(sqlQuery);
  2916.                 stm.setLong(1, idPortaDelegata);
  2917.                 n=stm.executeUpdate();
  2918.                 stm.close();
  2919.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " response flow con id=" + idPortaDelegata);
  2920.                 //}

  2922.                 // servizi applicativi
  2923.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2924.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_SA);
  2925.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2926.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2927.                 stm = con.prepareStatement(sqlQuery);
  2928.                 stm.setLong(1, idPortaDelegata);
  2929.                 n=stm.executeUpdate();
  2930.                 stm.close();
  2931.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " associazioni PortaDelegata<->ServizioApplicativo associati alla PortaDelegata[" + idPortaDelegata + "]");

  2933.                 // cancello anche le flow di request/response associate a questa
  2934.                 // porta applicativa
  2935.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2936.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST);
  2937.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2938.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2939.                 stm = con.prepareStatement(sqlQuery);
  2940.                 stm.setLong(1, idPortaDelegata);
  2941.                 n=stm.executeUpdate();
  2942.                 stm.close();
  2943.                 if (n > 0)
  2944.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " security_request flow associate alla PortaDelegata[" + idPortaDelegata + "]");

  2946.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2947.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE);
  2948.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2949.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2950.                 stm = con.prepareStatement(sqlQuery);
  2951.                 stm.setLong(1, idPortaDelegata);
  2952.                 n=stm.executeUpdate();
  2953.                 stm.close();
  2954.                 if (n > 0)
  2955.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " security_response flow associate alla PortaDelegata[" + idPortaDelegata + "]");

  2957.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2958.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE);
  2959.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2960.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2961.                 stm = con.prepareStatement(sqlQuery);
  2962.                 stm.setLong(1, idPortaDelegata);

  2964.                 n = stm.executeUpdate();
  2965.                 stm.close();
  2966.                 if (n > 0)
  2967.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " correlazione associate alla PortaDelegata[" + idPortaDelegata + "]");

  2969.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2970.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE_RISPOSTA);
  2971.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2972.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2973.                 stm = con.prepareStatement(sqlQuery);
  2974.                 stm.setLong(1, idPortaDelegata);

  2976.                 n = stm.executeUpdate();
  2977.                 stm.close();
  2978.                 if (n > 0)
  2979.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " correlazione per la rispsota associate alla PortaDelegata[" + idPortaDelegata + "]");

  2981.                 // cancello le prop
  2982.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2983.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_PROP);
  2984.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2985.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2986.                 stm = con.prepareStatement(sqlQuery);
  2987.                 stm.setLong(1, idPortaDelegata);
  2988.                 n=stm.executeUpdate();
  2989.                 stm.close();
  2990.                 if (n > 0)
  2991.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " SetProtocolProp associati alla PortaDelegata[" + idPortaDelegata + "]");
  2992.                 
  2993.                 // cancello le prop di rate limiting
  2994.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2995.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_RATE_LIMITING_PROP);
  2996.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2997.                 sqlQuery = sqlQueryObject.createSQLDelete();
  2998.                 stm = con.prepareStatement(sqlQuery);
  2999.                 stm.setLong(1, idPortaDelegata);
  3000.                 n=stm.executeUpdate();
  3001.                 stm.close();
  3002.                 if (n > 0)
  3003.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " SetProtocolPropRateLimiting associati alla PortaDelegata[" + idPortaDelegata + "]");
  3004.                 
  3005.                 // cancello le prop di autorizzazione contenuti
  3006.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3007.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP);
  3008.                 sqlQueryObject.addWhereCondition("id_porta=?");
  3009.                 sqlQuery = sqlQueryObject.createSQLDelete();
  3010.                 stm = con.prepareStatement(sqlQuery);
  3011.                 stm.setLong(1, idPortaDelegata);
  3012.                 n=stm.executeUpdate();
  3013.                 stm.close();
  3014.                 if (n > 0)
  3015.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " SetProtocolPropAutorizzazioneContenuto associati alla PortaDelegata[" + idPortaDelegata + "]");
  3016.                 
  3017.                 // cancello le prop di autorizzazione
  3018.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3019.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP);
  3020.                 sqlQueryObject.addWhereCondition("id_porta=?");
  3021.                 sqlQuery = sqlQueryObject.createSQLDelete();
  3022.                 stm = con.prepareStatement(sqlQuery);
  3023.                 stm.setLong(1, idPortaDelegata);
  3024.                 n=stm.executeUpdate();
  3025.                 stm.close();
  3026.                 if (n > 0)
  3027.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " SetProtocolPropAutorizzazione associati alla PortaDelegata[" + idPortaDelegata + "]");
  3028.                 
  3029.                 
  3030.                 // cancello le prop di autenticazione
  3031.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3032.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP);
  3033.                 sqlQueryObject.addWhereCondition("id_porta=?");
  3034.                 sqlQuery = sqlQueryObject.createSQLDelete();
  3035.                 stm = con.prepareStatement(sqlQuery);
  3036.                 stm.setLong(1, idPortaDelegata);
  3037.                 n=stm.executeUpdate();
  3038.                 stm.close();
  3039.                 if (n > 0)
  3040.                     DriverConfigurazioneDBLib.logDebug("Deleted " + n + " SetProtocolPropAutenticazione associati alla PortaDelegata[" + idPortaDelegata + "]");
  3041.                 
  3042.                 // extendedInfo
  3043.                 if(extInfoConfigurazioneDriver!=null){
  3044.                     extInfoConfigurazioneDriver.deleteAllExtendedInfo(con, DriverConfigurazioneDBLib.log, aPD, CRUDType.DELETE);
  3045.                 }
  3046.                 
  3047.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3048.                 sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE);
  3049.                 sqlQueryObject.addWhereCondition("id=?");
  3050.                 sqlQuery = sqlQueryObject.createSQLDelete();
  3051.                 stm = con.prepareStatement(sqlQuery);
  3052.                 stm.setLong(1, idPortaDelegata);
  3053.                 DriverConfigurazioneDBLib.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaDelegata));
  3054.                 n=stm.executeUpdate();
  3055.                 stm.close();
  3056.                 DriverConfigurazioneDBLib.logDebug("Deleted " + n + " row(s).");


  3059.                 break;
  3060.             }
  3061.             return idPortaDelegata;
  3062.         } catch (DriverConfigurazioneException e) {
  3063.             throw e;
  3064.         } catch (SQLException se) {
  3065.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDPortaDelegata] SQLException : " + se.getMessage(),se);
  3066.         } catch (Exception e) {
  3067.             throw new DriverConfigurazioneException("Errore durante operazione("+type+") CRUDPortaDelegata.",e);
  3068.         }finally {
  3069.             //Chiudo statement and resultset
  3070.             JDBCUtilities.closeResources(rs, stm);
  3071.         }
  3072.     }


  3075.     
  3076. }
Created with JaCoCo 0.8.8.202204050719