PorteApplicativeCore.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.web.ctrlstat.servlet.pa;

  22. import java.sql.Connection;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Properties;

  28. import org.openspcoop2.core.commons.ISearch;
  29. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  30. import org.openspcoop2.core.config.AutorizzazioneScope;
  31. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  32. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  33. import org.openspcoop2.core.config.GestioneToken;
  34. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  35. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  36. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  37. import org.openspcoop2.core.config.PortaApplicativa;
  38. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  39. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetti;
  40. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetto;
  41. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneToken;
  42. import org.openspcoop2.core.config.PortaApplicativaAzione;
  43. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  44. import org.openspcoop2.core.config.Proprieta;
  45. import org.openspcoop2.core.config.ProprietaOggetto;
  46. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  47. import org.openspcoop2.core.config.Ruolo;
  48. import org.openspcoop2.core.config.Scope;
  49. import org.openspcoop2.core.config.ServizioApplicativo;
  50. import org.openspcoop2.core.config.TrasformazioneRegola;
  51. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  52. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
  53. import org.openspcoop2.core.config.TrasformazioneRegolaParametro;
  54. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  55. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  56. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  57. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  58. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  59. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  60. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  61. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  62. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  63. import org.openspcoop2.core.constants.CostantiDB;
  64. import org.openspcoop2.core.id.IDPortaApplicativa;
  65. import org.openspcoop2.core.id.IDServizio;
  66. import org.openspcoop2.core.id.IDServizioApplicativo;
  67. import org.openspcoop2.core.id.IDSoggetto;
  68. import org.openspcoop2.core.mapping.DBMappingUtils;
  69. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  70. import org.openspcoop2.core.mvc.properties.utils.DBPropertiesUtils;
  71. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  72. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  73. import org.openspcoop2.core.registry.beans.AzioneSintetica;
  74. import org.openspcoop2.core.registry.beans.OperationSintetica;
  75. import org.openspcoop2.core.registry.beans.PortTypeSintetico;
  76. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  77. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  78. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  79. import org.openspcoop2.web.ctrlstat.core.AutorizzazioneUtilities;
  80. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  81. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  82. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  83. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  84. import org.openspcoop2.web.lib.mvc.ServletUtils;

  86. /**
  87.  * PorteApplicativeCore
  88.  *
  89.  * @author Poli Andrea (apoli@link.it)
  90.  * @author $Author$
  91.  * @version $Rev$, $Date$
  92.  */
  93. public class PorteApplicativeCore extends ControlStationCore {

  95.     public PorteApplicativeCore() throws DriverControlStationException {
  96.         super();
  97.     }
  98.     public PorteApplicativeCore(ControlStationCore core) throws DriverControlStationException {
  99.         super(core);
  100.     }
  101.     
  102.     public void configureControlloAccessiPortaApplicativa(PortaApplicativa pa,
  103.             String erogazioneAutenticazione, String erogazioneAutenticazioneOpzionale, TipoAutenticazionePrincipal erogazioneAutenticazionePrincipal, List<String> erogazioneAutenticazioneParametroList,
  104.             String erogazioneAutorizzazione, String erogazioneAutorizzazioneAutenticati, String erogazioneAutorizzazioneRuoli, String erogazioneAutorizzazioneRuoliTipologia, String erogazioneAutorizzazioneRuoliMatch,
  105.             String nomeSA, String erogazioneRuolo, IDSoggetto idErogazioneSoggettoAutenticato, 
  106.             String autorizzazioneAutenticatiToken, 
  107.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  108.             String erogazioneAutorizzazioneTokenOptions,
  109.             String erogazioneAutorizzazioneScope, String erogazioneScope, String erogazioneAutorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  110.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) {
  111.         pa.setAutenticazione(erogazioneAutenticazione);
  112.         if(erogazioneAutenticazioneOpzionale != null){
  113.             if(ServletUtils.isCheckBoxEnabled(erogazioneAutenticazioneOpzionale))
  114.                 pa.setAutenticazioneOpzionale(StatoFunzionalita.ABILITATO);
  115.             else 
  116.                 pa.setAutenticazioneOpzionale(StatoFunzionalita.DISABILITATO);
  117.         } else 
  118.             pa.setAutenticazioneOpzionale(null);
  119.         pa.getProprietaAutenticazioneList().clear();
  120.         List<Proprieta> proprietaAutenticazione = this.convertToAutenticazioneProprieta(erogazioneAutenticazione, erogazioneAutenticazionePrincipal, erogazioneAutenticazioneParametroList);
  121.         if(proprietaAutenticazione!=null && !proprietaAutenticazione.isEmpty()) {
  122.             pa.getProprietaAutenticazioneList().addAll(proprietaAutenticazione);
  123.         }
  124.         
  125.         pa.setAutorizzazione(AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString(erogazioneAutorizzazione, 
  126.                 ServletUtils.isCheckBoxEnabled(erogazioneAutorizzazioneAutenticati), 
  127.                 ServletUtils.isCheckBoxEnabled(erogazioneAutorizzazioneRuoli),
  128.                 ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken), 
  129.                 ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken),
  130.                 ServletUtils.isCheckBoxEnabled(erogazioneAutorizzazioneScope),
  131.                 erogazioneAutorizzazioneTokenOptions,
  132.                 RuoloTipologia.toEnumConstant(erogazioneAutorizzazioneRuoliTipologia)));
  133.         
  134.         if(erogazioneAutorizzazione != null && erogazioneAutorizzazione.equals(AutorizzazioneUtilities.STATO_XACML_POLICY) && allegatoXacmlPolicy.getValue() != null) {
  135.             pa.setXacmlPolicy(new String(allegatoXacmlPolicy.getValue()));
  136.         } else {
  137.             pa.setXacmlPolicy(null);
  138.         }
  139.         
  140.         if(erogazioneAutorizzazioneRuoliMatch!=null && !"".equals(erogazioneAutorizzazioneRuoliMatch)){
  141.             RuoloTipoMatch tipoRuoloMatch = RuoloTipoMatch.toEnumConstant(erogazioneAutorizzazioneRuoliMatch);
  142.             if(tipoRuoloMatch!=null){
  143.                 if(pa.getRuoli()==null){
  144.                     pa.setRuoli(new AutorizzazioneRuoli());
  145.                 }
  146.                 pa.getRuoli().setMatch(tipoRuoloMatch);
  147.             }
  148.         }
  149.         
  150.         if(nomeSA!=null && !"".equals(nomeSA) && !"-".equals(nomeSA)){
  151.             PortaApplicativaServizioApplicativo sa = new PortaApplicativaServizioApplicativo();
  152.             sa.setNome(nomeSA);
  153.             pa.addServizioApplicativo(sa);
  154.         }

  156.         // ruolo
  157.         if(erogazioneRuolo!=null && !"".equals(erogazioneRuolo) && !"-".equals(erogazioneRuolo)){
  158.             if(pa.getRuoli()==null){
  159.                 pa.setRuoli(new AutorizzazioneRuoli());
  160.             }
  161.             Ruolo ruolo = new Ruolo();
  162.             ruolo.setNome(erogazioneRuolo);
  163.             pa.getRuoli().addRuolo(ruolo);
  164.         }
  165.         
  166.         if(idErogazioneSoggettoAutenticato!=null){
  167.             if(pa.getSoggetti() == null) {
  168.                 pa.setSoggetti(new PortaApplicativaAutorizzazioneSoggetti());
  169.             }
  170.             
  171.             PortaApplicativaAutorizzazioneSoggetto soggetto = new PortaApplicativaAutorizzazioneSoggetto();
  172.             soggetto.setTipo(idErogazioneSoggettoAutenticato.getTipo());
  173.             soggetto.setNome(idErogazioneSoggettoAutenticato.getNome()); 
  174.             pa.getSoggetti().addSoggetto(soggetto);
  175.         }
  176.         
  177.         // token applicativi
  178.         if(ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken)) {
  179.             if(pa.getAutorizzazioneToken()==null) {
  180.                 pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken() );
  181.             }
  182.             pa.getAutorizzazioneToken().setAutorizzazioneApplicativi(StatoFunzionalita.ABILITATO); 
  183.         }
  184.         else {
  185.             if(pa.getAutorizzazioneToken()!=null) {
  186.                 pa.getAutorizzazioneToken().setAutorizzazioneApplicativi(null);
  187.                 pa.getAutorizzazioneToken().setServiziApplicativi(null);
  188.             }
  189.         }
  190.         
  191.         // token ruoli
  192.         if(ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken)) {
  193.             if(pa.getAutorizzazioneToken()==null) {
  194.                 pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken() );
  195.             }
  196.             pa.getAutorizzazioneToken().setAutorizzazioneRuoli(StatoFunzionalita.ABILITATO); 
  197.             
  198.             if(autorizzazioneRuoliTipologiaToken!=null && !"".equals(autorizzazioneRuoliTipologiaToken)){
  199.                 org.openspcoop2.core.config.constants.RuoloTipologia ruoloTipologia = org.openspcoop2.core.config.constants.RuoloTipologia.toEnumConstant(autorizzazioneRuoliTipologiaToken);
  200.                 pa.getAutorizzazioneToken().setTipologiaRuoli(ruoloTipologia);
  201.             }
  202.             else {
  203.                 pa.getAutorizzazioneToken().setTipologiaRuoli(null);
  204.             }
  205.             
  206.             if(autorizzazioneRuoliMatchToken!=null && !"".equals(autorizzazioneRuoliMatchToken)){
  207.                 RuoloTipoMatch ruoloTipoMatch = RuoloTipoMatch.toEnumConstant(autorizzazioneRuoliMatchToken);
  208.                 if(ruoloTipoMatch!=null){
  209.                     if(pa.getAutorizzazioneToken().getRuoli()==null){
  210.                         pa.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  211.                     }
  212.                     pa.getAutorizzazioneToken().getRuoli().setMatch(ruoloTipoMatch);
  213.                 }
  214.                 else {
  215.                     if(pa.getAutorizzazioneToken().getRuoli()!=null){
  216.                         pa.getAutorizzazioneToken().getRuoli().setMatch(null);
  217.                     }
  218.                 }
  219.             }
  220.             else {
  221.                 if(pa.getAutorizzazioneToken().getRuoli()!=null){
  222.                     pa.getAutorizzazioneToken().getRuoli().setMatch(null);
  223.                 }
  224.             }
  225.         }
  226.         else {
  227.             if(pa.getAutorizzazioneToken()!=null) {
  228.                 pa.getAutorizzazioneToken().setAutorizzazioneRuoli(null);
  229.                 pa.getAutorizzazioneToken().setTipologiaRuoli(null);
  230.                 pa.getAutorizzazioneToken().setRuoli(null);
  231.             }
  232.         }
  233.         
  234.         // token options
  235.         // impostato in configureControlloAccessiGestioneToken 
  236.         
  237.         // scope
  238.         if(ServletUtils.isCheckBoxEnabled(erogazioneAutorizzazioneScope)) {
  239.             if(pa.getScope() == null)
  240.                 pa.setScope(new AutorizzazioneScope());
  241.             
  242.             pa.getScope().setStato(StatoFunzionalita.ABILITATO); 
  243.         }
  244.         else {
  245.             pa.setScope(null);
  246.         }
  247.         if(erogazioneScope!=null && !"".equals(erogazioneScope) && !"-".equals(erogazioneScope)){
  248.             if(pa.getScope() == null) {
  249.                 pa.setScope(new AutorizzazioneScope());
  250.             }
  251.             Scope scope = new Scope();
  252.             scope.setNome(erogazioneScope);
  253.             pa.getScope().addScope(scope);
  254.         }
  255.         if(erogazioneAutorizzazioneScopeMatch!=null && !"".equals(erogazioneAutorizzazioneScopeMatch)){
  256.             ScopeTipoMatch scopeTipoMatch = ScopeTipoMatch.toEnumConstant(erogazioneAutorizzazioneScopeMatch);
  257.             if(scopeTipoMatch!=null){
  258.                 if(pa.getScope()==null){
  259.                     pa.setScope(new AutorizzazioneScope());
  260.                 }
  261.                 pa.getScope().setMatch(scopeTipoMatch);
  262.             }
  263.         }
  264.         
  265.         // attribute authority
  266.         while (pa.sizeAttributeAuthorityList()>0) {
  267.             pa.removeAttributeAuthority(0);
  268.         }
  269.         if(StatoFunzionalita.ABILITATO.getValue().equals(identificazioneAttributiStato) && attributeAuthoritySelezionate!=null && attributeAuthoritySelezionate.length>0) {
  270.             for (String aaName : attributeAuthoritySelezionate) {
  271.                 pa.addAttributeAuthority(this.buildAttributeAuthority(attributeAuthoritySelezionate.length, aaName, attributeAuthorityAttributi));
  272.             }
  273.         }
  274.     }
  275.     
  276.     public void configureControlloAccessiGestioneToken (PortaApplicativa portaApplicativa, String gestioneToken, 
  277.             String gestioneTokenPolicy,  String gestioneTokenOpzionale,  
  278.             String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  279.             String autenticazioneTokenIssuer, String autenticazioneTokenClientId, String autenticazioneTokenSubject, String autenticazioneTokenUsername, String autenticazioneTokenEMail,
  280.             String autorizzazioneTokenOptions) {
  281.         if(portaApplicativa.getGestioneToken() == null)
  282.             portaApplicativa.setGestioneToken(new GestioneToken());
  283.         
  284.         if(gestioneToken!=null && gestioneToken.equals(StatoFunzionalita.ABILITATO.getValue())) {
  285.             portaApplicativa.getGestioneToken().setPolicy(gestioneTokenPolicy);
  286.             if(ServletUtils.isCheckBoxEnabled(gestioneTokenOpzionale)) {
  287.                 portaApplicativa.getGestioneToken().setTokenOpzionale(StatoFunzionalita.ABILITATO);
  288.             }
  289.             else {
  290.                 portaApplicativa.getGestioneToken().setTokenOpzionale(StatoFunzionalita.DISABILITATO);
  291.             }
  292.             portaApplicativa.getGestioneToken().setValidazione(StatoFunzionalitaConWarning.toEnumConstant(gestioneTokenValidazioneInput));
  293.             portaApplicativa.getGestioneToken().setIntrospection(StatoFunzionalitaConWarning.toEnumConstant(gestioneTokenIntrospection));
  294.             portaApplicativa.getGestioneToken().setUserInfo(StatoFunzionalitaConWarning.toEnumConstant(gestioneTokenUserInfo));
  295.             portaApplicativa.getGestioneToken().setForward(StatoFunzionalita.toEnumConstant(gestioneTokenForward));     
  296.             portaApplicativa.getGestioneToken().setOptions(autorizzazioneTokenOptions);
  297.             if(portaApplicativa.getGestioneToken().getAutenticazione()==null) {
  298.                 portaApplicativa.getGestioneToken().setAutenticazione(new GestioneTokenAutenticazione());
  299.             }
  300.             portaApplicativa.getGestioneToken().getAutenticazione().setIssuer(ServletUtils.isCheckBoxEnabled(autenticazioneTokenIssuer) ? StatoFunzionalita.ABILITATO : StatoFunzionalita.toEnumConstant(autenticazioneTokenIssuer)); 
  301.             portaApplicativa.getGestioneToken().getAutenticazione().setClientId(ServletUtils.isCheckBoxEnabled(autenticazioneTokenClientId) ? StatoFunzionalita.ABILITATO : StatoFunzionalita.toEnumConstant(autenticazioneTokenClientId)); 
  302.             portaApplicativa.getGestioneToken().getAutenticazione().setSubject(ServletUtils.isCheckBoxEnabled(autenticazioneTokenSubject) ? StatoFunzionalita.ABILITATO : StatoFunzionalita.toEnumConstant(autenticazioneTokenSubject)); 
  303.             portaApplicativa.getGestioneToken().getAutenticazione().setUsername(ServletUtils.isCheckBoxEnabled(autenticazioneTokenUsername) ? StatoFunzionalita.ABILITATO : StatoFunzionalita.toEnumConstant(autenticazioneTokenUsername)); 
  304.             portaApplicativa.getGestioneToken().getAutenticazione().setEmail(ServletUtils.isCheckBoxEnabled(autenticazioneTokenEMail) ? StatoFunzionalita.ABILITATO : StatoFunzionalita.toEnumConstant(autenticazioneTokenEMail)); 
  305.         } else {
  306.             portaApplicativa.getGestioneToken().setPolicy(null);
  307.             portaApplicativa.getGestioneToken().setTokenOpzionale(StatoFunzionalita.DISABILITATO); 
  308.             portaApplicativa.getGestioneToken().setValidazione(StatoFunzionalitaConWarning.DISABILITATO);
  309.             portaApplicativa.getGestioneToken().setIntrospection(StatoFunzionalitaConWarning.DISABILITATO);
  310.             portaApplicativa.getGestioneToken().setUserInfo(StatoFunzionalitaConWarning.DISABILITATO);
  311.             portaApplicativa.getGestioneToken().setForward(StatoFunzionalita.DISABILITATO); 
  312.             portaApplicativa.getGestioneToken().setOptions(null);
  313.             if(portaApplicativa.getGestioneToken().getAutenticazione()!=null) {
  314.                 portaApplicativa.getGestioneToken().setAutenticazione(null);
  315.             }
  316.         }
  317.     }
  318.     
  319.     
  320.     public List<PortaApplicativa> porteAppWithServizio(long idSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverConfigurazioneException {
  321.         Connection con = null;
  322.         String nomeMetodo = "porteAppWithTipoNomeServizio";
  323.         DriverControlStationDB driver = null;

  325.         try {
  326.             // prendo una connessione
  327.             con = ControlStationCore.dbM.getConnection();
  328.             // istanzio il driver
  329.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  331.             return driver.getDriverConfigurazioneDB().porteAppWithServizio(idSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio);

  333.         } catch (Exception e) {
  334.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  335.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  336.         } finally {
  337.             ControlStationCore.dbM.releaseConnection(con);
  338.         }
  339.     }
  340.     
  341.     public PortaApplicativa getPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  342.         Connection con = null;
  343.         String nomeMetodo = "getPortaApplicativa";
  344.         DriverControlStationDB driver = null;

  346.         try {
  347.             // prendo una connessione
  348.             con = ControlStationCore.dbM.getConnection();
  349.             // istanzio il driver
  350.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  352.             return driver.getDriverConfigurazioneDB().getPortaApplicativa(idPA);

  354.         } catch (DriverConfigurazioneNotFound de) {
  355.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  356.             throw de;
  357.         } catch (Exception e) {
  358.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  359.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  360.         } finally {
  361.             ControlStationCore.dbM.releaseConnection(con);
  362.         }

  364.     }
  365.     
  366.     public ProprietaOggetto getProprietaOggetto(IDPortaApplicativa idPA) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  367.         Connection con = null;
  368.         String nomeMetodo = "getProprietaOggetto";
  369.         DriverControlStationDB driver = null;

  371.         try {
  372.             // prendo una connessione
  373.             con = ControlStationCore.dbM.getConnection();
  374.             // istanzio il driver
  375.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  377.             return driver.getDriverConfigurazioneDB().getProprietaOggetto(idPA);

  379.         } catch (DriverConfigurazioneNotFound de) {
  380.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  381.             throw de;
  382.         } catch (Exception e) {
  383.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  384.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  385.         } finally {
  386.             ControlStationCore.dbM.releaseConnection(con);
  387.         }
  388.     }
  389.     
  390.     public void updateProprietaOggetto(IDPortaApplicativa idPA, String user) throws DriverConfigurazioneException {
  391.         Connection con = null;
  392.         String nomeMetodo = "updateProprietaOggetto";
  393.         DriverControlStationDB driver = null;

  395.         try {
  396.             // prendo una connessione
  397.             con = ControlStationCore.dbM.getConnection();
  398.             // istanzio il driver
  399.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  401.             driver.getDriverConfigurazioneDB().updateProprietaOggetto(idPA, user);

  403.         } catch (Exception e) {
  404.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  405.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  406.         } finally {
  407.             ControlStationCore.dbM.releaseConnection(con);
  408.         }
  409.     }
  410.     

  412.     public List<PortaApplicativa> porteAppList(long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
  413.         Connection con = null;
  414.         String nomeMetodo = "porteAppList";
  415.         DriverControlStationDB driver = null;

  417.         try {
  418.             // prendo una connessione
  419.             con = ControlStationCore.dbM.getConnection();
  420.             // istanzio il driver
  421.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  423.             return driver.getDriverConfigurazioneDB().porteAppList(idSoggetto, ricerca);

  425.         } catch (Exception e) {
  426.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  427.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  428.         } finally {
  429.             ControlStationCore.dbM.releaseConnection(con);
  430.         }

  432.     }
  433.     
  434.     public List<PortaApplicativa> porteAppList(String superUser, ISearch ricerca) throws DriverConfigurazioneException {
  435.         Connection con = null;
  436.         String nomeMetodo = "porteAppList";
  437.         DriverControlStationDB driver = null;

  439.         try {
  440.             // prendo una connessione
  441.             con = ControlStationCore.dbM.getConnection();
  442.             // istanzio il driver
  443.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  445.             return driver.getDriverConfigurazioneDB().porteAppList(superUser, ricerca);

  447.         } catch (Exception e) {
  448.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  449.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  450.         } finally {
  451.             ControlStationCore.dbM.releaseConnection(con);
  452.         }

  454.     }

  456.     public List<PortaApplicativa> getPorteApplicativeBySoggettoVirtuale(IDSoggetto soggettoVirtuale) throws DriverConfigurazioneException {
  457.         Connection con = null;
  458.         String nomeMetodo = "getPorteApplicativeBySoggettoVirtuale";
  459.         DriverControlStationDB driver = null;

  461.         try {
  462.             // prendo una connessione
  463.             con = ControlStationCore.dbM.getConnection();
  464.             // istanzio il driver
  465.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  467.             return driver.getDriverConfigurazioneDB().getPorteApplicativeBySoggettoVirtuale(soggettoVirtuale);

  469.         } catch (Exception e) {
  470.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  471.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e));
  472.         } finally {
  473.             ControlStationCore.dbM.releaseConnection(con);
  474.         }

  476.     }

  478.     

  480.     public List<Proprieta> porteAppPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  481.         Connection con = null;
  482.         String nomeMetodo = "porteAppPropList";
  483.         DriverControlStationDB driver = null;

  485.         try {
  486.             // prendo una connessione
  487.             con = ControlStationCore.dbM.getConnection();
  488.             // istanzio il driver
  489.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  491.             return driver.getDriverConfigurazioneDB().porteAppPropList(idPortaApplicativa, ricerca);

  493.         } catch (Exception e) {
  494.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  495.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  496.         } finally {
  497.             ControlStationCore.dbM.releaseConnection(con);
  498.         }

  500.     }
  501.     
  502.     public List<String> nomiProprietaPA(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoServiziProtocollo) throws DriverConfigurazioneException {
  503.         Connection con = null;
  504.         String nomeMetodo = "nomiProprietaPA";
  505.         DriverControlStationDB driver = null;

  507.         try {
  508.             // prendo una connessione
  509.             con = ControlStationCore.dbM.getConnection();
  510.             // istanzio il driver
  511.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  513.             return driver.getDriverConfigurazioneDB().nomiProprietaPA(filterSoggettoTipo, filterSoggettoNome, tipoServiziProtocollo);

  515.         } catch (Exception e) {
  516.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  517.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  518.         } finally {
  519.             ControlStationCore.dbM.releaseConnection(con);
  520.         }

  522.     }

  524.     public List<ServizioApplicativo> porteAppServizioApplicativoList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  525.         Connection con = null;
  526.         String nomeMetodo = "porteAppServizioApplicativoList";
  527.         DriverControlStationDB driver = null;

  529.         try {
  530.             // prendo una connessione
  531.             con = ControlStationCore.dbM.getConnection();
  532.             // istanzio il driver
  533.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  535.             return driver.getDriverConfigurazioneDB().porteAppServizioApplicativoList(idPortaApplicativa, ricerca);

  537.         } catch (Exception e) {
  538.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  539.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  540.         } finally {
  541.             ControlStationCore.dbM.releaseConnection(con);
  542.         }

  544.     }
  545.     
  546.     public List<PortaApplicativaAutorizzazioneSoggetto> porteAppSoggettoList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  547.         Connection con = null;
  548.         String nomeMetodo = "porteAppSoggettoList";
  549.         DriverControlStationDB driver = null;

  551.         try {
  552.             // prendo una connessione
  553.             con = ControlStationCore.dbM.getConnection();
  554.             // istanzio il driver
  555.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  557.             return driver.getDriverConfigurazioneDB().porteAppSoggettoList(idPortaApplicativa, ricerca);

  559.         } catch (Exception e) {
  560.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  561.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  562.         } finally {
  563.             ControlStationCore.dbM.releaseConnection(con);
  564.         }

  566.     }
  567.     
  568.     public List<PortaApplicativaAutorizzazioneServizioApplicativo> porteAppServiziApplicativiAutorizzatiList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  569.         Connection con = null;
  570.         String nomeMetodo = "porteAppServiziApplicativiAutorizzatiList";
  571.         DriverControlStationDB driver = null;

  573.         try {
  574.             // prendo una connessione
  575.             con = ControlStationCore.dbM.getConnection();
  576.             // istanzio il driver
  577.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  579.             return driver.getDriverConfigurazioneDB().porteAppServiziApplicativiAutorizzatiList(idPortaApplicativa, ricerca);

  581.         } catch (Exception e) {
  582.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  583.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  584.         } finally {
  585.             ControlStationCore.dbM.releaseConnection(con);
  586.         }

  588.     }

  590.     public List<PortaApplicativaAutorizzazioneServizioApplicativo> porteAppServiziApplicativiAutorizzatiTokenList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  591.         Connection con = null;
  592.         String nomeMetodo = "porteAppServiziApplicativiAutorizzatiTokenList";
  593.         DriverControlStationDB driver = null;

  595.         try {
  596.             // prendo una connessione
  597.             con = ControlStationCore.dbM.getConnection();
  598.             // istanzio il driver
  599.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  601.             return driver.getDriverConfigurazioneDB().porteAppServiziApplicativiAutorizzatiTokenList(idPortaApplicativa, ricerca);

  603.         } catch (Exception e) {
  604.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  605.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  606.         } finally {
  607.             ControlStationCore.dbM.releaseConnection(con);
  608.         }

  610.     }

  612.     public List<MessageSecurityFlowParameter> porteAppMessageSecurityRequestList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  613.         Connection con = null;
  614.         String nomeMetodo = "porteAppMessageSecurityRequestList";
  615.         DriverControlStationDB driver = null;

  617.         try {
  618.             // prendo una connessione
  619.             con = ControlStationCore.dbM.getConnection();
  620.             // istanzio il driver
  621.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  623.             return driver.getDriverConfigurazioneDB().porteAppMessageSecurityRequestList(idPortaApplicativa, ricerca);

  625.         } catch (Exception e) {
  626.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  627.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  628.         } finally {
  629.             ControlStationCore.dbM.releaseConnection(con);
  630.         }

  632.     }

  634.     public List<PortaApplicativa> porteAppWithIdServizio(long idServizio) throws DriverConfigurazioneException {
  635.         Connection con = null;
  636.         String nomeMetodo = "porteAppWithIdServizio";
  637.         DriverControlStationDB driver = null;

  639.         try {
  640.             // prendo una connessione
  641.             con = ControlStationCore.dbM.getConnection();
  642.             // istanzio il driver
  643.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  645.             return driver.getDriverConfigurazioneDB().porteAppWithIdServizio(idServizio);

  647.         } catch (Exception e) {
  648.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  649.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  650.         } finally {
  651.             ControlStationCore.dbM.releaseConnection(con);
  652.         }

  654.     }

  656.     public List<MessageSecurityFlowParameter> porteAppMessageSecurityResponseList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  657.         Connection con = null;
  658.         String nomeMetodo = "porteAppMessageSecurityResponseList";
  659.         DriverControlStationDB driver = null;

  661.         try {
  662.             // prendo una connessione
  663.             con = ControlStationCore.dbM.getConnection();
  664.             // istanzio il driver
  665.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  667.             return driver.getDriverConfigurazioneDB().porteAppMessageSecurityResponseList(idPortaApplicativa, ricerca);

  669.         } catch (Exception e) {
  670.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  671.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  672.         } finally {
  673.             ControlStationCore.dbM.releaseConnection(con);
  674.         }

  676.     }

  678.     public List<CorrelazioneApplicativaElemento> porteApplicativeCorrelazioneApplicativaList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  679.         Connection con = null;
  680.         String nomeMetodo = "porteApplicativeCorrelazioneApplicativaList";
  681.         DriverControlStationDB driver = null;

  683.         try {
  684.             // prendo una connessione
  685.             con = ControlStationCore.dbM.getConnection();
  686.             // istanzio il driver
  687.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  689.             return driver.getDriverConfigurazioneDB().porteApplicativeCorrelazioneApplicativaList(idPortaApplicativa, ricerca);

  691.         } catch (Exception e) {
  692.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  693.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  694.         } finally {
  695.             ControlStationCore.dbM.releaseConnection(con);
  696.         }

  698.     }
  699.     
  700.     public List<CorrelazioneApplicativaRispostaElemento> porteApplicativeCorrelazioneApplicativaRispostaList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  701.         Connection con = null;
  702.         String nomeMetodo = "porteApplicativeCorrelazioneApplicativaRispostaList";
  703.         DriverControlStationDB driver = null;

  705.         try {
  706.             // prendo una connessione
  707.             con = ControlStationCore.dbM.getConnection();
  708.             // istanzio il driver
  709.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  711.             return driver.getDriverConfigurazioneDB().porteApplicativeCorrelazioneApplicativaRispostaList(idPortaApplicativa, ricerca);

  713.         } catch (Exception e) {
  714.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  715.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e));
  716.         } finally {
  717.             ControlStationCore.dbM.releaseConnection(con);
  718.         }

  720.     }
  721.     
  722.     public List<PortaApplicativaAzione> porteAppAzioneList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  723.         Connection con = null;
  724.         String nomeMetodo = "porteAppAzioneList";
  725.         DriverControlStationDB driver = null;

  727.         try {
  728.             // prendo una connessione
  729.             con = ControlStationCore.dbM.getConnection();
  730.             // istanzio il driver
  731.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  733.             return driver.getDriverConfigurazioneDB().porteAppAzioneList(idPortaApplicativa, ricerca);

  735.         } catch (Exception e) {
  736.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  737.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  738.         } finally {
  739.             ControlStationCore.dbM.releaseConnection(con);
  740.         }

  742.     }

  744.     

  746.     public PortaApplicativa getPortaApplicativa(long idPortaApplicativa) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  747.         Connection con = null;
  748.         String nomeMetodo = "getPortaApplicativa";
  749.         DriverControlStationDB driver = null;

  751.         try {
  752.             // prendo una connessione
  753.             con = ControlStationCore.dbM.getConnection();
  754.             // istanzio il driver
  755.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  757.             return driver.getDriverConfigurazioneDB().getPortaApplicativa(idPortaApplicativa);

  759.         } catch (DriverConfigurazioneNotFound de) {
  760.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  761.             throw de;
  762.         } catch (Exception e) {
  763.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  764.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  765.         } finally {
  766.             ControlStationCore.dbM.releaseConnection(con);
  767.         }
  768.     }

  770.     
  771.     public boolean existsPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneException {
  772.         Connection con = null;
  773.         String nomeMetodo = "existsPortaApplicativa";
  774.         DriverControlStationDB driver = null;

  776.         try {
  777.             // prendo una connessione
  778.             con = ControlStationCore.dbM.getConnection();
  779.             // istanzio il driver
  780.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  782.             return driver.getDriverConfigurazioneDB().existsPortaApplicativa(idPA);

  784.         } catch (Exception e) {
  785.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  786.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  787.         } finally {
  788.             ControlStationCore.dbM.releaseConnection(con);
  789.         }
  790.     }

  792.     public boolean existsPortaApplicativa(IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException {
  793.         Connection con = null;
  794.         String nomeMetodo = "existsPortaApplicativa (ricercaPuntuale)";
  795.         DriverControlStationDB driver = null;

  797.         try {
  798.             // prendo una connessione
  799.             con = ControlStationCore.dbM.getConnection();
  800.             // istanzio il driver
  801.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  803.             List<PortaApplicativa> list = driver.getDriverConfigurazioneDB().getPorteApplicative(idServizio, ricercaPuntuale);
  804.             
  805.             return list!=null && !list.isEmpty();
  806.         } catch(DriverConfigurazioneNotFound nfe) {
  807.             return false;
  808.         } catch (Exception e) {
  809.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  810.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  811.         } finally {
  812.             ControlStationCore.dbM.releaseConnection(con);
  813.         }
  814.     }

  816.     public boolean existsPortaApplicativaVirtuale(IDServizio idServizio, IDSoggetto soggettoVirtuale, boolean ricercaPuntuale) throws DriverConfigurazioneException {
  817.         Connection con = null;
  818.         String nomeMetodo = "existsPortaApplicativa_soggettoVirtuale (ricercaPuntuale)";
  819.         DriverControlStationDB driver = null;

  821.         try {
  822.             // prendo una connessione
  823.             con = ControlStationCore.dbM.getConnection();
  824.             // istanzio il driver
  825.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  827.             List<PortaApplicativa> list = driver.getDriverConfigurazioneDB().getPorteApplicativeVirtuali(soggettoVirtuale, idServizio, ricercaPuntuale);
  828.             
  829.             return list!=null && !list.isEmpty();

  831.         } catch (Exception e) {
  832.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  833.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  834.         } finally {
  835.             ControlStationCore.dbM.releaseConnection(con);
  836.         }
  837.     }

  839.     public boolean existsPortaApplicativaAzione(String nome) throws DriverConfigurazioneException {
  840.         Connection con = null;
  841.         String nomeMetodo = "existsPortaApplicativaAzione";
  842.         DriverControlStationDB driver = null;

  844.         try {
  845.             // prendo una connessione
  846.             con = ControlStationCore.dbM.getConnection();
  847.             // istanzio il driver
  848.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  850.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaAzione(nome);

  852.         } catch (Exception e) {
  853.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  854.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  855.         } finally {
  856.             ControlStationCore.dbM.releaseConnection(con);
  857.         }
  858.     }
  859.     
  860.     public boolean azioneUsataInTrasformazioniPortaApplicativa(String nome) throws DriverConfigurazioneException {
  861.         Connection con = null;
  862.         String nomeMetodo = "azioneUsataInTrasformazioniPortaApplicativa";
  863.         DriverControlStationDB driver = null;

  865.         try {
  866.             // prendo una connessione
  867.             con = ControlStationCore.dbM.getConnection();
  868.             // istanzio il driver
  869.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  871.             return driver.getDriverConfigurazioneDB().azioneUsataInTrasformazioniPortaApplicativa(nome);

  873.         } catch (Exception e) {
  874.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  875.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  876.         } finally {
  877.             ControlStationCore.dbM.releaseConnection(con);
  878.         }
  879.     }
  880.     
  881.     public List<MappingErogazionePortaApplicativa> getMappingConGruppiPerAzione(String nomeAzione, List<IDServizio> list) throws DriverConfigurazioneException {
  882.         Connection con = null;
  883.         String nomeMetodo = "getMappingConGruppiPerAzione";
  884.         
  885.         try {
  886.             // prendo una connessione
  887.             con = ControlStationCore.dbM.getConnection();
  888.             
  889.             List<MappingErogazionePortaApplicativa> listInUtilizzo = new ArrayList<>();
  890.             
  891.             if(list!=null && !list.isEmpty()) {
  892.                 for (IDServizio idServizio : list) {
  893.                     List<MappingErogazionePortaApplicativa> lPA = DBMappingUtils.mappingErogazionePortaApplicativaList(con, this.tipoDB, idServizio, false);
  894.                     if(lPA!=null && !lPA.isEmpty()) {
  895.                         for (MappingErogazionePortaApplicativa mapping : lPA) {
  896.                             try {
  897.                                 PortaApplicativa pa = this.getPortaApplicativa(mapping.getIdPortaApplicativa());
  898.                                 if(pa!=null && pa.getAzione()!=null && pa.getAzione().getAzioneDelegataList()!=null &&
  899.                                         pa.getAzione().getAzioneDelegataList().contains(nomeAzione)) {
  900.                                     listInUtilizzo.add(mapping);
  901.                                 }
  902.                             }catch(DriverConfigurazioneNotFound notFound) {
  903.                                 // ignore
  904.                             }
  905.                         }
  906.                     }
  907.                 }
  908.             }
  909.             
  910.             return listInUtilizzo;

  912.         } catch (Exception e) {
  913.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  914.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  915.         } finally {
  916.             ControlStationCore.dbM.releaseConnection(con);
  917.         }
  918.     }
  919.     
  920.     public List<MappingErogazionePortaApplicativa> getMapping(List<IDServizio> list, boolean addDefault, boolean addNotDefault) throws DriverConfigurazioneException {
  921.         Connection con = null;
  922.         String nomeMetodo = "getMapping";
  923.         
  924.         try {
  925.             // prendo una connessione
  926.             con = ControlStationCore.dbM.getConnection();
  927.             
  928.             List<MappingErogazionePortaApplicativa> listMappingDefault = new ArrayList<>();
  929.             
  930.             if(list!=null && !list.isEmpty()) {
  931.                 for (IDServizio idServizio : list) {
  932.                     List<MappingErogazionePortaApplicativa> lPA = DBMappingUtils.mappingErogazionePortaApplicativaList(con, this.tipoDB, idServizio, false);
  933.                     if(lPA!=null && !lPA.isEmpty()) {
  934.                         for (MappingErogazionePortaApplicativa mapping : lPA) {
  935.                             if(mapping.isDefault()) {
  936.                                 if(addDefault) {
  937.                                     listMappingDefault.add(mapping);
  938.                                 }
  939.                             }
  940.                             else {
  941.                                 if(addNotDefault) {
  942.                                     listMappingDefault.add(mapping);
  943.                                 }
  944.                             }
  945.                         }
  946.                     }
  947.                 }
  948.             }
  949.             
  950.             return listMappingDefault;

  952.         } catch (Exception e) {
  953.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  954.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  955.         } finally {
  956.             ControlStationCore.dbM.releaseConnection(con);
  957.         }
  958.     }
  959.     
  960.     public List<IDPortaApplicativa> getPortaApplicativaAzione(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  961.         Connection con = null;
  962.         String nomeMetodo = "getPortaApplicativaAzione";
  963.         DriverControlStationDB driver = null;

  965.         try {
  966.             // prendo una connessione
  967.             con = ControlStationCore.dbM.getConnection();
  968.             // istanzio il driver
  969.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  971.             return driver.getDriverConfigurazioneDB().getPortaApplicativaAzione(nome);

  973.         }catch(DriverConfigurazioneNotFound dNotF){
  974.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] Exception :" + dNotF.getMessage(), dNotF);
  975.             throw dNotF;
  976.         } catch (Exception e) {
  977.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  978.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  979.         } finally {
  980.             ControlStationCore.dbM.releaseConnection(con);
  981.         }
  982.     }

  984.     public List<PortaApplicativa> getPorteApplicativaByIdProprietario(long idProprietario) throws DriverConfigurazioneException {
  985.         Connection con = null;
  986.         String nomeMetodo = "getPorteApplicativaByIdProprietario";
  987.         DriverControlStationDB driver = null;

  989.         try {
  990.             // prendo una connessione
  991.             con = ControlStationCore.dbM.getConnection();
  992.             // istanzio il driver
  993.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  995.             return driver.getDriverConfigurazioneDB().getPorteApplicativaByIdProprietario(idProprietario);

  997.         } catch (Exception e) {
  998.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  999.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1000.         } finally {
  1001.             ControlStationCore.dbM.releaseConnection(con);
  1002.         }
  1003.     }

  1005.     public List<PortaApplicativa> getPorteApplicativeWithServizio(Long idServizio, String tiposervizio, String nomeservizio, Integer versioneServizio,
  1006.             Long idSoggetto, String tiposoggetto, String nomesoggetto) throws DriverConfigurazioneException {
  1007.         Connection con = null;
  1008.         String nomeMetodo = "getPorteApplicativeWithServizio";
  1009.         DriverControlStationDB driver = null;

  1011.         try {
  1012.             // prendo una connessione
  1013.             con = ControlStationCore.dbM.getConnection();
  1014.             // istanzio il driver
  1015.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1017.             return driver.getDriverConfigurazioneDB().getPorteApplicativeWithServizio(idServizio, tiposervizio, nomeservizio, versioneServizio,
  1018.                     idSoggetto, tiposoggetto, nomesoggetto);

  1020.         } catch (Exception e) {
  1021.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1022.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1023.         } finally {
  1024.             ControlStationCore.dbM.releaseConnection(con);
  1025.         }
  1026.     }

  1028.     public PortaApplicativa getPortaApplicativaWithSoggettoAndServizio(String nome, Long idSoggetto, Long idServizio, String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverConfigurazioneException {
  1029.         Connection con = null;
  1030.         String nomeMetodo = "getPortaApplicativaWithSoggettoAndServizio";
  1031.         DriverControlStationDB driver = null;

  1033.         try {
  1034.             // prendo una connessione
  1035.             con = ControlStationCore.dbM.getConnection();
  1036.             // istanzio il driver
  1037.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1039.             return driver.getDriverConfigurazioneDB().getPortaApplicativaWithSoggettoAndServizio(nome, idSoggetto, idServizio, tipoServizio, nomeServizio, versioneServizio);

  1041.         } catch (Exception e) {
  1042.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1043.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1044.         } finally {
  1045.             ControlStationCore.dbM.releaseConnection(con);
  1046.         }
  1047.     }
  1048.     
  1049.     public List<MtomProcessorFlowParameter> porteApplicativeMTOMRequestList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1050.         Connection con = null;
  1051.         String nomeMetodo = "porteApplicativeMTOMRequestList";
  1052.         DriverControlStationDB driver = null;

  1054.         try {
  1055.             // prendo una connessione
  1056.             con = ControlStationCore.dbM.getConnection();
  1057.             // istanzio il driver
  1058.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1060.             return driver.getDriverConfigurazioneDB().porteApplicativeMTOMRequestList(idPortaApplicativa, ricerca);

  1062.         } catch (Exception e) {
  1063.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1064.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1065.         } finally {
  1066.             ControlStationCore.dbM.releaseConnection(con);
  1067.         }

  1069.     }

  1071.     public List<MtomProcessorFlowParameter> porteApplicativeMTOMResponseList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1072.         Connection con = null;
  1073.         String nomeMetodo = "porteApplicativeMTOMResponseList";
  1074.         DriverControlStationDB driver = null;

  1076.         try {
  1077.             // prendo una connessione
  1078.             con = ControlStationCore.dbM.getConnection();
  1079.             // istanzio il driver
  1080.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1082.             return driver.getDriverConfigurazioneDB().porteApplicativeMTOMResponseList(idPortaApplicativa, ricerca);

  1084.         } catch (Exception e) {
  1085.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1086.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1087.         } finally {
  1088.             ControlStationCore.dbM.releaseConnection(con);
  1089.         }

  1091.     }
  1092.     
  1093.     
  1094.     public IDPortaApplicativa getIDPortaApplicativaAssociataDefault(IDServizio idServizio) throws DriverConfigurazioneException {
  1095.         Connection con = null;
  1096.         String nomeMetodo = "getIDPortaApplicativaAssociataDefault";
  1097.         DriverControlStationDB driver = null;

  1099.         try {
  1100.             // prendo una connessione
  1101.             con = ControlStationCore.dbM.getConnection();
  1102.             // istanzio il driver
  1103.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1105.             return driver.getIDPortaApplicativaAssociataDefault(idServizio);

  1107.         } catch (Exception e) {
  1108.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1109.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1110.         } finally {
  1111.             ControlStationCore.dbM.releaseConnection(con);
  1112.         }
  1113.     }
  1114.     public IDPortaApplicativa getIDPortaApplicativaAssociataAzione(IDServizio idServizio) throws DriverConfigurazioneException {
  1115.         Connection con = null;
  1116.         String nomeMetodo = "getIDPortaApplicativaAssociataAzione";
  1117.         DriverControlStationDB driver = null;

  1119.         try {
  1120.             // prendo una connessione
  1121.             con = ControlStationCore.dbM.getConnection();
  1122.             // istanzio il driver
  1123.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1125.             return driver.getIDPortaApplicativaAssociataAzione(idServizio);

  1127.         } catch (Exception e) {
  1128.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1129.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1130.         } finally {
  1131.             ControlStationCore.dbM.releaseConnection(con);
  1132.         }
  1133.     }
  1134.     public List<IDPortaApplicativa> getIDPorteApplicativeAssociate(IDServizio idServizio) throws DriverConfigurazioneException {
  1135.         Connection con = null;
  1136.         String nomeMetodo = "getIDPorteApplicativeAssociate";
  1137.         DriverControlStationDB driver = null;

  1139.         try {
  1140.             // prendo una connessione
  1141.             con = ControlStationCore.dbM.getConnection();
  1142.             // istanzio il driver
  1143.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1145.             return driver.getIDPorteApplicativeAssociate(idServizio);

  1147.         } catch (Exception e) {
  1148.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1149.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1150.         } finally {
  1151.             ControlStationCore.dbM.releaseConnection(con);
  1152.         }
  1153.     }
  1154.     public boolean existsMappingErogazionePortaApplicativa(MappingErogazionePortaApplicativa mapping) throws DriverConfigurazioneException {
  1155.         Connection con = null;
  1156.         String nomeMetodo = "existsMappingErogazionePortaApplicativa";
  1157.         DriverControlStationDB driver = null;

  1159.         try {
  1160.             // prendo una connessione
  1161.             con = ControlStationCore.dbM.getConnection();
  1162.             // istanzio il driver
  1163.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1165.             return driver.existsMappingErogazionePortaApplicativa(mapping);

  1167.         } catch (Exception e) {
  1168.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1169.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1170.         } finally {
  1171.             ControlStationCore.dbM.releaseConnection(con);
  1172.         }
  1173.     }
  1174.     
  1175.     public void aggiornaDescrizioneMappingErogazionePortaApplicativa(MappingErogazionePortaApplicativa mapping, String user) throws DriverConfigurazioneException {
  1176.         Connection con = null;
  1177.         String nomeMetodo = "aggiornaDescrizioneMappingErogazionePortaApplicativa";
  1178.         try {
  1179.             // prendo una connessione
  1180.             con = ControlStationCore.dbM.getConnection();
  1181.             
  1182.             DBMappingUtils.updateMappingErogazione(mapping.getTableId(), mapping.getDescrizione(), con, this.tipoDB);

  1184.             if(mapping.getIdPortaApplicativa()!=null) {
  1185.                 this.updateProprietaOggetto(mapping.getIdPortaApplicativa(), user);
  1186.             }
  1187.             
  1188.         } catch (Exception e) {
  1189.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1190.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1191.         } finally {
  1192.             ControlStationCore.dbM.releaseConnection(con);
  1193.         }
  1194.     }
  1195.     
  1196.     public MappingErogazionePortaApplicativa getMappingErogazionePortaApplicativa(PortaApplicativa pa) throws DriverConfigurazioneException {
  1197.         Connection con = null;
  1198.         String nomeMetodo = "getMappingErogazionePortaApplicativa";
  1199.         try {
  1200.             // prendo una connessione
  1201.             con = ControlStationCore.dbM.getConnection();
  1202.             
  1203.             IDPortaApplicativa idPA = new IDPortaApplicativa();
  1204.             idPA.setNome(pa.getNome());
  1205.             
  1206.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  1207.                     pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(), 
  1208.                     pa.getServizio().getVersione());
  1209.             
  1210.             return DBMappingUtils.getMappingErogazione(idServizio, idPA, con, this.tipoDB);

  1212.         } catch (Exception e) {
  1213.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1214.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1215.         } finally {
  1216.             ControlStationCore.dbM.releaseConnection(con);
  1217.         }
  1218.     }

  1220.     public List<MappingErogazionePortaApplicativa> countMappingErogazionePortaApplicativa(IDServizio idServizio) throws DriverConfigurazioneException {
  1221.         Connection con = null;
  1222.         String nomeMetodo = "countMappingErogazionePortaApplicativa";
  1223.         try {
  1224.             // prendo una connessione
  1225.             con = ControlStationCore.dbM.getConnection();
  1226.             
  1227.             return DBMappingUtils.mappingErogazionePortaApplicativaList(con, this.tipoDB, idServizio, false);

  1229.         } catch (Exception e) {
  1230.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1231.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1232.         } finally {
  1233.             ControlStationCore.dbM.releaseConnection(con);
  1234.         }
  1235.     }
  1236.     
  1237.     private static boolean showGroup = true;
  1238.     public static boolean isShowGroup() {
  1239.         return showGroup;
  1240.     }
  1241.     public static void setShowGroup(boolean showGroup) {
  1242.         PorteApplicativeCore.showGroup = showGroup;
  1243.     }
  1244.     
  1245.     public String getLabelRegolaMappingErogazionePortaApplicativa(String functionDi, String function, PortaApplicativa pa) throws DriverConfigurazioneException {
  1246.         return getLabelRegolaMappingErogazionePortaApplicativa(functionDi, function, pa, 50, false);
  1247.     }
  1248.     public String getLabelRegolaMappingErogazionePortaApplicativa(String functionDi, String function, PortaApplicativa pa, boolean forceGroupName) throws DriverConfigurazioneException {
  1249.         return getLabelRegolaMappingErogazionePortaApplicativa(functionDi, function, pa, 50, forceGroupName);
  1250.     }
  1251.     public String getLabelRegolaMappingErogazionePortaApplicativa(String functionDi, String function, PortaApplicativa pa, int sizeSubstring) throws DriverConfigurazioneException {
  1252.         return getLabelRegolaMappingErogazionePortaApplicativa(functionDi, function, pa, sizeSubstring, false);
  1253.     }
  1254.     public String getLabelRegolaMappingErogazionePortaApplicativa(String functionDi, String function, PortaApplicativa pa, int sizeSubstring, boolean forceGroupName) throws DriverConfigurazioneException {
  1255.         
  1256.         String prefix = "";
  1257.         if(functionDi!=null) {
  1258.             prefix = functionDi;
  1259.             if(showGroup) {
  1260.                 prefix = convertPrefixConfigDelGruppo(prefix);
  1261.             }
  1262.         }
  1263.         
  1264.         MappingErogazionePortaApplicativa mapping = this.getMappingErogazionePortaApplicativa(pa);
  1265.                 
  1266.         if(mapping.isDefault()) {
  1267.             if(this.countMappingErogazionePortaApplicativa(mapping.getIdServizio()).size()>1 || forceGroupName) {
  1268.                 if(showGroup) {
  1269.                     return prefix+getLabelGroup(mapping.getDescrizione());
  1270.                 }
  1271.                 else {
  1272.                     return prefix+PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MAPPING_EROGAZIONE_PA_NOME_DEFAULT;
  1273.                 }
  1274.             }
  1275.             else {
  1276.                 return function!=null ? function : PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MAPPING_EROGAZIONE_PA_NOME_DEFAULT;
  1277.             }
  1278.         }
  1279.         else {
  1280.             if(showGroup) {
  1281.                 StringBuilder sb = new StringBuilder(mapping.getDescrizione());
  1282.                 if(sb.length()>sizeSubstring)
  1283.                     return prefix+getLabelGroup(sb.toString().substring(0, (sizeSubstring-3))+"...");
  1284.                 else 
  1285.                     return prefix+getLabelGroup(sb.toString());
  1286.             }
  1287.             else {
  1288.                 List<String> listaAzioni = pa.getAzione()!= null ?  pa.getAzione().getAzioneDelegataList() : new ArrayList<>();
  1289.                 if(!listaAzioni.isEmpty()) {
  1290.                     StringBuilder sb = new StringBuilder();
  1291.                     for (String string : listaAzioni) {
  1292.                         if(sb.length() >0)
  1293.                             sb.append(", ");
  1294.                         
  1295.                         sb.append(string);
  1296.                     }
  1297.                     if(sb.length()>sizeSubstring)
  1298.                         return prefix+sb.toString().substring(0, (sizeSubstring-3))+"...";
  1299.                     else 
  1300.                         return prefix+sb.toString();
  1301.                 }
  1302.                 else {
  1303.                     return prefix+"???";
  1304.                 }
  1305.             }
  1306.         }
  1307.     }
  1308.     
  1309.     public List<IDPortaApplicativa> getAllIdPorteApplicative(FiltroRicercaPorteApplicative filtroRicerca) throws DriverConfigurazioneException {
  1310.         Connection con = null;
  1311.         String nomeMetodo = "getAllIdPorteApplicative";
  1312.         DriverControlStationDB driver = null;

  1314.         try {
  1315.             // prendo una connessione
  1316.             con = ControlStationCore.dbM.getConnection();
  1317.             // istanzio il driver
  1318.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1320.             return driver.getDriverConfigurazioneDB().getAllIdPorteApplicative(filtroRicerca);

  1322.         } catch (DriverConfigurazioneNotFound notFound) {
  1323.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] Exception :" + notFound.getMessage(), notFound);
  1324.             return new ArrayList<>();
  1325.         } catch (Exception e) {
  1326.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1327.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1328.         } finally {
  1329.             ControlStationCore.dbM.releaseConnection(con);
  1330.         }
  1331.     }
  1332.     
  1333.     public List<String> portaApplicativaRuoliList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  1334.         Connection con = null;
  1335.         String nomeMetodo = "portaApplicativaRuoliList";
  1336.         DriverControlStationDB driver = null;

  1338.         try {
  1339.             // prendo una connessione
  1340.             con = ControlStationCore.dbM.getConnection();
  1341.             // istanzio il driver
  1342.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1344.             return driver.getDriverConfigurazioneDB().portaApplicativaRuoliList(idPA, ricerca);

  1346.         } catch (Exception e) {
  1347.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1348.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1349.         } finally {
  1350.             ControlStationCore.dbM.releaseConnection(con);
  1351.         }

  1353.     }
  1354.     
  1355.     public List<String> portaApplicativaRuoliTokenList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  1356.         Connection con = null;
  1357.         String nomeMetodo = "portaApplicativaRuoliTokenList";
  1358.         DriverControlStationDB driver = null;

  1360.         try {
  1361.             // prendo una connessione
  1362.             con = ControlStationCore.dbM.getConnection();
  1363.             // istanzio il driver
  1364.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1366.             return driver.getDriverConfigurazioneDB().portaApplicativaRuoliTokenList(idPA, ricerca);

  1368.         } catch (Exception e) {
  1369.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1370.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1371.         } finally {
  1372.             ControlStationCore.dbM.releaseConnection(con);
  1373.         }

  1375.     }
  1376.     
  1377.     public List<String> portaApplicativaScopeList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  1378.         Connection con = null;
  1379.         String nomeMetodo = "portaApplicativaScopeList";
  1380.         DriverControlStationDB driver = null;

  1382.         try {
  1383.             // prendo una connessione
  1384.             con = ControlStationCore.dbM.getConnection();
  1385.             // istanzio il driver
  1386.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1388.             return driver.getDriverConfigurazioneDB().portaApplicativaScopeList(idPA, ricerca);

  1390.         } catch (Exception e) {
  1391.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1392.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1393.         } finally {
  1394.             ControlStationCore.dbM.releaseConnection(con);
  1395.         }

  1397.     }
  1398.     
  1399.     public Map<String, Properties> readMessageSecurityRequestPropertiesConfiguration(long idPortaDelegata) throws DriverConfigurazioneException {
  1400.         Connection con = null;
  1401.         String nomeMetodo = "readMessageSecurityRequestPropertiesConfiguration";
  1402.         try {
  1403.             // prendo una connessione
  1404.             con = ControlStationCore.dbM.getConnection();
  1405.             Map<String, String> readProperties = DBPropertiesUtils.readProperties(con, this.tipoDB, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_NOME, 
  1406.                     CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_ENC_VALUE, 
  1407.                     CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_ID_PORTA, idPortaDelegata,
  1408.                     this.getDriverBYOKUtilities().getDriverBYOKManagerNode(false, true));
  1409.             return DBPropertiesUtils.toMultiMap(readProperties);
  1410.         } catch (Exception e) {
  1411.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1412.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1413.         } finally {
  1414.             ControlStationCore.dbM.releaseConnection(con);
  1415.         }   
  1416.     }
  1417.     
  1418.     public Map<String, Properties> readMessageSecurityResponsePropertiesConfiguration(long idPortaDelegata) throws DriverConfigurazioneException {
  1419.         Connection con = null;
  1420.         String nomeMetodo = "readMessageSecurityResponsePropertiesConfiguration";
  1421.         try {
  1422.             // prendo una connessione
  1423.             con = ControlStationCore.dbM.getConnection();
  1424.             Map<String, String> readProperties = DBPropertiesUtils.readProperties(con, this.tipoDB, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_NOME, 
  1425.                     CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_ENC_VALUE, 
  1426.                     CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_ID_PORTA, idPortaDelegata,
  1427.                     this.getDriverBYOKUtilities().getDriverBYOKManagerNode(false, true));
  1428.             return DBPropertiesUtils.toMultiMap(readProperties);
  1429.         } catch (Exception e) {
  1430.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1431.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1432.         } finally {
  1433.             ControlStationCore.dbM.releaseConnection(con);
  1434.         }   
  1435.     }
  1436.     
  1437.     
  1438.     public List<ResponseCachingConfigurazioneRegola> getResponseCachingConfigurazioneRegolaList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  1439.         Connection con = null;
  1440.         String nomeMetodo = "getResponseCachingConfigurazioneRegolaList";
  1441.         DriverControlStationDB driver = null;

  1443.         try {
  1444.             // prendo una connessione
  1445.             con = ControlStationCore.dbM.getConnection();
  1446.             // istanzio il driver
  1447.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1449.             return driver.getDriverConfigurazioneDB().portaApplicativaResponseCachingConfigurazioneRegolaList(idPA, ricerca);

  1451.         } catch (Exception e) {
  1452.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1453.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1454.         } finally {
  1455.             ControlStationCore.dbM.releaseConnection(con);
  1456.         }

  1458.     }
  1459.     
  1460.     public boolean existsResponseCachingConfigurazioneRegola(long idPorta, Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException{
  1461.         Connection con = null;
  1462.         String nomeMetodo = "existsResponseCachingConfigurazioneRegola";
  1463.         DriverControlStationDB driver = null;

  1465.         try {
  1466.             // prendo una connessione
  1467.             con = ControlStationCore.dbM.getConnection();
  1468.             // istanzio il driver
  1469.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1470.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaResponseCachingConfigurazioneRegola(idPorta, statusMin,statusMax,fault);
  1471.         } catch (Exception e) {
  1472.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1473.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1474.         } finally {
  1475.             ControlStationCore.dbM.releaseConnection(con);
  1476.         }
  1477.     }
  1478.     
  1479.     
  1480.     public List<TrasformazioneRegola> porteAppTrasformazioniList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1481.         Connection con = null;
  1482.         String nomeMetodo = "porteAppTrasformazioniList";
  1483.         DriverControlStationDB driver = null;

  1485.         try {
  1486.             // prendo una connessione
  1487.             con = ControlStationCore.dbM.getConnection();
  1488.             // istanzio il driver
  1489.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1491.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniList(idPortaApplicativa, ricerca);

  1493.         } catch (Exception e) {
  1494.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1495.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1496.         } finally {
  1497.             ControlStationCore.dbM.releaseConnection(con);
  1498.         }
  1499.     }
  1500.     
  1501.     
  1502.     public boolean existsTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori) throws DriverConfigurazioneException{
  1503.         Connection con = null;
  1504.         String nomeMetodo = "existsTrasformazione";
  1505.         DriverControlStationDB driver = null;

  1507.         try {
  1508.             // prendo una connessione
  1509.             con = ControlStationCore.dbM.getConnection();
  1510.             // istanzio il driver
  1511.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1512.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazione(idPorta, azioni, pattern, contentType, connettori);
  1513.         } catch (Exception e) {
  1514.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1515.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1516.         } finally {
  1517.             ControlStationCore.dbM.releaseConnection(con);
  1518.         }
  1519.     }
  1520.     
  1521.     public boolean existsTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException{
  1522.         Connection con = null;
  1523.         String nomeMetodo = "existsTrasformazione";
  1524.         DriverControlStationDB driver = null;

  1526.         try {
  1527.             // prendo una connessione
  1528.             con = ControlStationCore.dbM.getConnection();
  1529.             // istanzio il driver
  1530.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1531.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazione(idPorta, nome);
  1532.         } catch (Exception e) {
  1533.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1534.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1535.         } finally {
  1536.             ControlStationCore.dbM.releaseConnection(con);
  1537.         }
  1538.     }
  1539.     
  1540.     public TrasformazioneRegola getTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
  1541.             List<TrasformazioneRegolaApplicabilitaSoggetto> soggetti,
  1542.             List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi,
  1543.             boolean interpretaNullList) throws DriverConfigurazioneException{
  1544.         Connection con = null;
  1545.         String nomeMetodo = "getTrasformazione";
  1546.         DriverControlStationDB driver = null;

  1548.         try {
  1549.             // prendo una connessione
  1550.             con = ControlStationCore.dbM.getConnection();
  1551.             // istanzio il driver
  1552.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1553.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazione(idPorta, azioni, pattern, contentType, connettori, soggetti, applicativi, interpretaNullList);
  1554.         } catch (Exception e) {
  1555.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1556.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1557.         } finally {
  1558.             ControlStationCore.dbM.releaseConnection(con);
  1559.         }
  1560.     }
  1561.     
  1562.     public TrasformazioneRegola getTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException{
  1563.         Connection con = null;
  1564.         String nomeMetodo = "getTrasformazione";
  1565.         DriverControlStationDB driver = null;

  1567.         try {
  1568.             // prendo una connessione
  1569.             con = ControlStationCore.dbM.getConnection();
  1570.             // istanzio il driver
  1571.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1572.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazione(idPorta, nome);
  1573.         } catch (Exception e) {
  1574.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1575.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1576.         } finally {
  1577.             ControlStationCore.dbM.releaseConnection(con);
  1578.         }
  1579.     }
  1580.     
  1581.     public List<TrasformazioneRegolaRisposta> porteAppTrasformazioniRispostaList(long idPortaApplicativa, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1582.         Connection con = null;
  1583.         String nomeMetodo = "porteAppTrasformazioniRispostaList";
  1584.         DriverControlStationDB driver = null;

  1586.         try {
  1587.             // prendo una connessione
  1588.             con = ControlStationCore.dbM.getConnection();
  1589.             // istanzio il driver
  1590.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1592.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniRispostaList(idPortaApplicativa, idTrasformazione, ricerca);

  1594.         } catch (Exception e) {
  1595.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1596.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1597.         } finally {
  1598.             ControlStationCore.dbM.releaseConnection(con);
  1599.         }
  1600.     }
  1601.     
  1602.     public boolean existsTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException{
  1603.         Connection con = null;
  1604.         String nomeMetodo = "existsTrasformazioneRisposta";
  1605.         DriverControlStationDB driver = null;

  1607.         try {
  1608.             // prendo una connessione
  1609.             con = ControlStationCore.dbM.getConnection();
  1610.             // istanzio il driver
  1611.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1612.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
  1613.         } catch (Exception e) {
  1614.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1615.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1616.         } finally {
  1617.             ControlStationCore.dbM.releaseConnection(con);
  1618.         }
  1619.     }
  1620.     
  1621.     public boolean existsTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException{
  1622.         Connection con = null;
  1623.         String nomeMetodo = "existsTrasformazioneRisposta";
  1624.         DriverControlStationDB driver = null;

  1626.         try {
  1627.             // prendo una connessione
  1628.             con = ControlStationCore.dbM.getConnection();
  1629.             // istanzio il driver
  1630.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1631.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, nome);
  1632.         } catch (Exception e) {
  1633.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1634.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1635.         } finally {
  1636.             ControlStationCore.dbM.releaseConnection(con);
  1637.         }
  1638.     }
  1639.     
  1640.     public TrasformazioneRegolaRisposta getTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException{
  1641.         Connection con = null;
  1642.         String nomeMetodo = "getTrasformazioneRisposta";
  1643.         DriverControlStationDB driver = null;

  1645.         try {
  1646.             // prendo una connessione
  1647.             con = ControlStationCore.dbM.getConnection();
  1648.             // istanzio il driver
  1649.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1650.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
  1651.         } catch (Exception e) {
  1652.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1653.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1654.         } finally {
  1655.             ControlStationCore.dbM.releaseConnection(con);
  1656.         }
  1657.     }
  1658.     
  1659.     public TrasformazioneRegolaRisposta getTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException{
  1660.         Connection con = null;
  1661.         String nomeMetodo = "getTrasformazioneRisposta";
  1662.         DriverControlStationDB driver = null;

  1664.         try {
  1665.             // prendo una connessione
  1666.             con = ControlStationCore.dbM.getConnection();
  1667.             // istanzio il driver
  1668.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1669.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, nome);
  1670.         } catch (Exception e) {
  1671.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1672.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1673.         } finally {
  1674.             ControlStationCore.dbM.releaseConnection(con);
  1675.         }
  1676.     }
  1677.     
  1678.     public List<TrasformazioneRegolaParametro> porteAppTrasformazioniRispostaHeaderList(long idPortaApplicativa, long idTrasformazione, long idTrasformazioneRisposta,  ISearch ricerca) throws DriverConfigurazioneException {
  1679.         Connection con = null;
  1680.         String nomeMetodo = "porteAppTrasformazioniRispostaList";
  1681.         DriverControlStationDB driver = null;

  1683.         try {
  1684.             // prendo una connessione
  1685.             con = ControlStationCore.dbM.getConnection();
  1686.             // istanzio il driver
  1687.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1689.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniRispostaHeaderList(idPortaApplicativa, idTrasformazione, idTrasformazioneRisposta, ricerca);

  1691.         } catch (Exception e) {
  1692.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1693.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1694.         } finally {
  1695.             ControlStationCore.dbM.releaseConnection(con);
  1696.         }
  1697.     }
  1698.     
  1699.     public boolean existsTrasformazioneRispostaHeader(long idPorta, long idTrasformazione,  long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1700.         Connection con = null;
  1701.         String nomeMetodo = "existsTrasformazioneRispostaHeader";
  1702.         DriverControlStationDB driver = null;

  1704.         try {
  1705.             // prendo una connessione
  1706.             con = ControlStationCore.dbM.getConnection();
  1707.             // istanzio il driver
  1708.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1709.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo);
  1710.         } catch (Exception e) {
  1711.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1712.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1713.         } finally {
  1714.             ControlStationCore.dbM.releaseConnection(con);
  1715.         }
  1716.     }
  1717.     
  1718.     public TrasformazioneRegolaParametro getTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1719.         Connection con = null;
  1720.         String nomeMetodo = "getTrasformazioneRispostaHeader";
  1721.         DriverControlStationDB driver = null;

  1723.         try {
  1724.             // prendo una connessione
  1725.             con = ControlStationCore.dbM.getConnection();
  1726.             // istanzio il driver
  1727.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1728.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo);
  1729.         } catch (Exception e) {
  1730.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1731.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1732.         } finally {
  1733.             ControlStationCore.dbM.releaseConnection(con);
  1734.         }
  1735.     }
  1736.     
  1737.     public List<TrasformazioneRegolaParametro> porteAppTrasformazioniRichiestaHeaderList(long idPortaApplicativa, long idTrasformazione,  ISearch ricerca) throws DriverConfigurazioneException {
  1738.         Connection con = null;
  1739.         String nomeMetodo = "porteAppTrasformazioniRichiestaHeaderList";
  1740.         DriverControlStationDB driver = null;

  1742.         try {
  1743.             // prendo una connessione
  1744.             con = ControlStationCore.dbM.getConnection();
  1745.             // istanzio il driver
  1746.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1748.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniRichiestaHeaderList(idPortaApplicativa, idTrasformazione, ricerca);

  1750.         } catch (Exception e) {
  1751.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1752.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1753.         } finally {
  1754.             ControlStationCore.dbM.releaseConnection(con);
  1755.         }
  1756.     }
  1757.     
  1758.     public List<TrasformazioneRegolaParametro> porteAppTrasformazioniRichiestaUrlParameterList(long idPortaApplicativa, long idTrasformazione,  ISearch ricerca) throws DriverConfigurazioneException {
  1759.         Connection con = null;
  1760.         String nomeMetodo = "porteAppTrasformazioniRichiestaUrlParameterList";
  1761.         DriverControlStationDB driver = null;

  1763.         try {
  1764.             // prendo una connessione
  1765.             con = ControlStationCore.dbM.getConnection();
  1766.             // istanzio il driver
  1767.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1769.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniRichiestaUrlParameterList(idPortaApplicativa, idTrasformazione, ricerca);

  1771.         } catch (Exception e) {
  1772.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1773.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1774.         } finally {
  1775.             ControlStationCore.dbM.releaseConnection(con);
  1776.         }
  1777.     }
  1778.     
  1779.     public boolean existsTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1780.         Connection con = null;
  1781.         String nomeMetodo = "existsTrasformazioneRichiestaHeader";
  1782.         DriverControlStationDB driver = null;

  1784.         try {
  1785.             // prendo una connessione
  1786.             con = ControlStationCore.dbM.getConnection();
  1787.             // istanzio il driver
  1788.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1789.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
  1790.         } catch (Exception e) {
  1791.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1792.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1793.         } finally {
  1794.             ControlStationCore.dbM.releaseConnection(con);
  1795.         }
  1796.     }
  1797.     
  1798.     public TrasformazioneRegolaParametro getTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1799.         Connection con = null;
  1800.         String nomeMetodo = "getTrasformazioneRichiestaHeader";
  1801.         DriverControlStationDB driver = null;

  1803.         try {
  1804.             // prendo una connessione
  1805.             con = ControlStationCore.dbM.getConnection();
  1806.             // istanzio il driver
  1807.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1808.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
  1809.         } catch (Exception e) {
  1810.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1811.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1812.         } finally {
  1813.             ControlStationCore.dbM.releaseConnection(con);
  1814.         }
  1815.     }
  1816.     
  1817.     public boolean existsTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1818.         Connection con = null;
  1819.         String nomeMetodo = "existsTrasformazioneRichiestaUrlParameter";
  1820.         DriverControlStationDB driver = null;

  1822.         try {
  1823.             // prendo una connessione
  1824.             con = ControlStationCore.dbM.getConnection();
  1825.             // istanzio il driver
  1826.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1827.             return driver.getDriverConfigurazioneDB().existsPortaApplicativaTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
  1828.         } catch (Exception e) {
  1829.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1830.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1831.         } finally {
  1832.             ControlStationCore.dbM.releaseConnection(con);
  1833.         }
  1834.     }
  1835.     
  1836.     public TrasformazioneRegolaParametro getTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1837.         Connection con = null;
  1838.         String nomeMetodo = "getTrasformazioneRichiestaUrlParameter";
  1839.         DriverControlStationDB driver = null;

  1841.         try {
  1842.             // prendo una connessione
  1843.             con = ControlStationCore.dbM.getConnection();
  1844.             // istanzio il driver
  1845.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1846.             return driver.getDriverConfigurazioneDB().getPortaApplicativaTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
  1847.         } catch (Exception e) {
  1848.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1849.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1850.         } finally {
  1851.             ControlStationCore.dbM.releaseConnection(con);
  1852.         }
  1853.     }
  1854.     
  1855.     public List<TrasformazioneRegolaApplicabilitaSoggetto> porteAppTrasformazioniSoggettoList(long idPortaApplicativa, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1856.         Connection con = null;
  1857.         String nomeMetodo = "porteAppTrasformazioniSoggettoList";
  1858.         DriverControlStationDB driver = null;

  1860.         try {
  1861.             // prendo una connessione
  1862.             con = ControlStationCore.dbM.getConnection();
  1863.             // istanzio il driver
  1864.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1866.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniSoggettiList(idPortaApplicativa, idTrasformazione, ricerca);

  1868.         } catch (Exception e) {
  1869.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1870.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1871.         } finally {
  1872.             ControlStationCore.dbM.releaseConnection(con);
  1873.         }

  1875.     }
  1876.     
  1877.     public List<TrasformazioneRegolaApplicabilitaServizioApplicativo> porteAppTrasformazioniServiziApplicativiAutorizzatiList(long idPortaApplicativa, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1878.         Connection con = null;
  1879.         String nomeMetodo = "porteAppTrasformazioniServiziApplicativiAutorizzatiList";
  1880.         DriverControlStationDB driver = null;

  1882.         try {
  1883.             // prendo una connessione
  1884.             con = ControlStationCore.dbM.getConnection();
  1885.             // istanzio il driver
  1886.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1888.             return driver.getDriverConfigurazioneDB().porteApplicativeTrasformazioniServiziApplicativiList(idPortaApplicativa, idTrasformazione, ricerca);

  1890.         } catch (Exception e) {
  1891.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1892.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1893.         } finally {
  1894.             ControlStationCore.dbM.releaseConnection(con);
  1895.         }

  1897.     }
  1898.     
  1899.     public List<Proprieta> porteApplicativeAutenticazioneCustomPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1900.         Connection con = null;
  1901.         String nomeMetodo = "porteApplicativeAutenticazioneCustomPropList";
  1902.         DriverControlStationDB driver = null;

  1904.         try {
  1905.             // prendo una connessione
  1906.             con = ControlStationCore.dbM.getConnection();
  1907.             // istanzio il driver
  1908.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1910.             return driver.getDriverConfigurazioneDB().porteApplicativeAutenticazioneCustomPropList(idPortaApplicativa, ricerca);

  1912.         } catch (Exception e) {
  1913.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1914.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1915.         } finally {
  1916.             ControlStationCore.dbM.releaseConnection(con);
  1917.         }

  1919.     }
  1920.     
  1921.     public List<Proprieta> porteApplicativeAutorizzazioneCustomPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1922.         Connection con = null;
  1923.         String nomeMetodo = "porteApplicativeAutorizzazioneCustomPropList";
  1924.         DriverControlStationDB driver = null;

  1926.         try {
  1927.             // prendo una connessione
  1928.             con = ControlStationCore.dbM.getConnection();
  1929.             // istanzio il driver
  1930.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1932.             return driver.getDriverConfigurazioneDB().porteApplicativeAutorizzazioneCustomPropList(idPortaApplicativa, ricerca);

  1934.         } catch (Exception e) {
  1935.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1936.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1937.         } finally {
  1938.             ControlStationCore.dbM.releaseConnection(con);
  1939.         }

  1941.     }
  1942.     
  1943.     public List<Proprieta> porteApplicativeAutorizzazioneContenutoCustomPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1944.         Connection con = null;
  1945.         String nomeMetodo = "porteApplicativeAutorizzazioneContenutoCustomPropList";
  1946.         DriverControlStationDB driver = null;

  1948.         try {
  1949.             // prendo una connessione
  1950.             con = ControlStationCore.dbM.getConnection();
  1951.             // istanzio il driver
  1952.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1954.             return driver.getDriverConfigurazioneDB().porteApplicativeAutorizzazioneContenutoCustomPropList(idPortaApplicativa, ricerca);

  1956.         } catch (Exception e) {
  1957.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1958.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1959.         } finally {
  1960.             ControlStationCore.dbM.releaseConnection(con);
  1961.         }

  1963.     }
  1964.     
  1965.     public List<Proprieta> porteApplicativeConnettoriMultipliConfigPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
  1966.         Connection con = null;
  1967.         String nomeMetodo = "porteApplicativeConnettoriMultipliConfigPropList";
  1968.         DriverControlStationDB driver = null;

  1970.         try {
  1971.             // prendo una connessione
  1972.             con = ControlStationCore.dbM.getConnection();
  1973.             // istanzio il driver
  1974.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1976.             return driver.getDriverConfigurazioneDB().porteApplicativeConnettoriMultipliConfigPropList(idPortaApplicativa, ricerca);

  1978.         } catch (Exception e) {
  1979.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1980.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1981.         } finally {
  1982.             ControlStationCore.dbM.releaseConnection(con);
  1983.         }
  1984.     }
  1985.     
  1986.     public List<Proprieta> porteApplicativeConnettoriMultipliPropList(long idPaSa, ISearch ricerca) throws DriverConfigurazioneException {
  1987.         Connection con = null;
  1988.         String nomeMetodo = "porteApplicativeConnettoriMultipliPropList";
  1989.         DriverControlStationDB driver = null;

  1991.         try {
  1992.             // prendo una connessione
  1993.             con = ControlStationCore.dbM.getConnection();
  1994.             // istanzio il driver
  1995.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1997.             return driver.getDriverConfigurazioneDB().porteApplicativeConnettoriMultipliPropList(idPaSa, ricerca);

  1999.         } catch (Exception e) {
  2000.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2001.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2002.         } finally {
  2003.             ControlStationCore.dbM.releaseConnection(con);
  2004.         }
  2005.     }
  2006.     
  2007.     public List<IDPortaApplicativa> porteApplicativeWithApplicativoErogatore(IDServizioApplicativo idSA) throws DriverConfigurazioneException {
  2008.         Connection con = null;
  2009.         String nomeMetodo = "porteApplicativeWithApplicativoErogatore";
  2010.         DriverControlStationDB driver = null;

  2012.         try {
  2013.             // prendo una connessione
  2014.             con = ControlStationCore.dbM.getConnection();
  2015.             // istanzio il driver
  2016.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  2018.             return driver.getDriverConfigurazioneDB().porteApplicativeWithApplicativoErogatore(idSA);

  2020.         } catch (Exception e) {
  2021.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2022.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2023.         } finally {
  2024.             ControlStationCore.dbM.releaseConnection(con);
  2025.         }
  2026.     }
  2027.     
  2028.     public boolean azioniTutteOneway(AccordoServizioParteSpecifica asps, AccordoServizioParteComuneSintetico as, List<String> azioniDaControllare) {
  2029.         String profiloCollaborazioneAccordo = as.getProfiloCollaborazione().toString();
  2030.         if (profiloCollaborazioneAccordo.equals(CostantiRegistroServizi.ONEWAY.getValue())) {
  2031.             profiloCollaborazioneAccordo = "oneway";
  2032.         } else if (profiloCollaborazioneAccordo.equals(CostantiRegistroServizi.SINCRONO.getValue())) {
  2033.             profiloCollaborazioneAccordo = "sincrono";
  2034.         } else if (profiloCollaborazioneAccordo.equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO.getValue())) {
  2035.             profiloCollaborazioneAccordo = "asincronoSimmetrico";
  2036.         } else if (profiloCollaborazioneAccordo.equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO.getValue())) {
  2037.             profiloCollaborazioneAccordo = "asincronoAsimmetrico";
  2038.         }
  2039.         
  2040.         for (String nomeAzione : azioniDaControllare) {
  2041.             boolean isProfiloOneWay = true;
  2042.             // recupero profilo collaborazione azione se l'azione e'
  2043.             // specificata e il profilo azione e' ridefinito
  2044.             String profiloCollaborazioneAzione = "";
  2045.             if (nomeAzione != null && !nomeAzione.equals("")) {
  2046.                 if(asps.getPortType()!=null){
  2047.                     for (PortTypeSintetico pt : as.getPortType()) {
  2048.                         if(pt.getNome().equals(asps.getPortType())){
  2049.                             for (OperationSintetica op : pt.getAzione()) {
  2050.                                 if(op.getNome().equals(nomeAzione)){
  2051.                                     if(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(op.getProfAzione())){
  2052.                                         if(op.getProfiloCollaborazione()!=null)
  2053.                                             profiloCollaborazioneAzione = op.getProfiloCollaborazione().toString();
  2054.                                     }
  2055.                                     else{
  2056.                                         if(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(pt.getProfiloPT()) &&
  2057.                                             pt.getProfiloCollaborazione()!=null) {
  2058.                                             profiloCollaborazioneAzione = pt.getProfiloCollaborazione().toString();
  2059.                                         }
  2060.                                     }
  2061.                                 }
  2062.                             }
  2063.                         }
  2064.                     }
  2065.                 }
  2066.                 else{
  2067.                     for (int i = 0; i < as.getAzione().size(); i++) {
  2068.                         AzioneSintetica tmpAz = as.getAzione().get(i);
  2069.                         if (tmpAz.getProfAzione().equals(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO)) {
  2070.                             if(tmpAz.getProfiloCollaborazione()!=null)
  2071.                                 profiloCollaborazioneAzione = tmpAz.getProfiloCollaborazione().toString();
  2072.                             break;
  2073.                         }
  2074.                     }
  2075.                 }
  2076.             }

  2078.             // Controllo se nomeAzione e' specificato allora e' possibile
  2079.             // che il profilo azione sia ridefinito
  2080.             // quindi devo controllare se e' diverso da oneway
  2081.             if (nomeAzione != null && !nomeAzione.equals("")) {
  2082.                 // se e' diverso da oneway posso avere solo un azione
  2083.                 if ( profiloCollaborazioneAzione != null && !profiloCollaborazioneAzione.equals("") ){
  2084.                     if (!profiloCollaborazioneAzione.equals(CostantiRegistroServizi.ONEWAY.getValue())) {
  2085.                         isProfiloOneWay = false;
  2086.                     }
  2087.                 }
  2088.                 else{
  2089.                     if (!profiloCollaborazioneAccordo.equals(CostantiRegistroServizi.ONEWAY.getValue())) {
  2090.                         isProfiloOneWay = false;
  2091.                     }   
  2092.                 }
  2093.             } else {
  2094.                 // non ho azione (o azione con profilo non ridefinito)
  2095.                 // allora considero il profilo dell'accordo
  2096.                 if (!profiloCollaborazioneAccordo.equals(CostantiRegistroServizi.ONEWAY.getValue())) {
  2097.                     isProfiloOneWay = false;
  2098.                 }
  2099.             }
  2100.             
  2101.             if(!isProfiloOneWay)
  2102.                 return false;
  2103.         }
  2104.         
  2105.         
  2106.         return true;
  2107.     }
  2108. }
Created with JaCoCo 0.8.8.202204050719