PorteDelegateCore.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.pd;

  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.DBUtils;
  29. import org.openspcoop2.core.commons.ISearch;
  30. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  31. import org.openspcoop2.core.config.AutorizzazioneScope;
  32. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  33. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  34. import org.openspcoop2.core.config.GestioneToken;
  35. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  36. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  37. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  38. import org.openspcoop2.core.config.PortaDelegata;
  39. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneToken;
  40. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  41. import org.openspcoop2.core.config.Proprieta;
  42. import org.openspcoop2.core.config.ProprietaOggetto;
  43. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  44. import org.openspcoop2.core.config.Ruolo;
  45. import org.openspcoop2.core.config.Scope;
  46. import org.openspcoop2.core.config.ServizioApplicativo;
  47. import org.openspcoop2.core.config.TrasformazioneRegola;
  48. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  49. import org.openspcoop2.core.config.TrasformazioneRegolaParametro;
  50. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  51. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  52. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  53. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  54. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  55. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  56. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  57. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  58. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  59. import org.openspcoop2.core.constants.CostantiDB;
  60. import org.openspcoop2.core.id.IDPortaDelegata;
  61. import org.openspcoop2.core.id.IDServizio;
  62. import org.openspcoop2.core.id.IDSoggetto;
  63. import org.openspcoop2.core.mapping.DBMappingUtils;
  64. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  65. import org.openspcoop2.core.mvc.properties.utils.DBPropertiesUtils;
  66. import org.openspcoop2.core.registry.Fruitore;
  67. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  68. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  69. import org.openspcoop2.web.ctrlstat.core.AutorizzazioneUtilities;
  70. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  71. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  72. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  73. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  74. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  75. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  76. import org.openspcoop2.web.lib.mvc.ServletUtils;

  78. /**
  79.  * PorteDelegateCore
  80.  *
  81.  * @author Poli Andrea (apoli@link.it)
  82.  * @author $Author$
  83.  * @version $Rev$, $Date$
  84.  */
  85. public class PorteDelegateCore extends ControlStationCore {

  87.     public PorteDelegateCore() throws DriverControlStationException {
  88.         super();
  89.     }
  90.     public PorteDelegateCore(ControlStationCore core) throws DriverControlStationException {
  91.         super(core);
  92.     }
  93.     

  95.     public void configureControlloAccessiPortaDelegata(PortaDelegata portaDelegata, 
  96.             String fruizioneAutenticazione, String fruizioneAutenticazioneOpzionale, TipoAutenticazionePrincipal fruizioneAutenticazionePrincipal, List<String> fruizioneAutenticazioneParametroList,
  97.             String fruizioneAutorizzazione, String fruizioneAutorizzazioneAutenticati, String fruizioneAutorizzazioneRuoli, String fruizioneAutorizzazioneRuoliTipologia, String fruizioneAutorizzazioneRuoliMatch,
  98.             String fruizioneServizioApplicativo, String fruizioneRuolo, 
  99.             String autorizzazioneAutenticatiToken, 
  100.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  101.             String fruizioneAutorizzazioneTokenOptions,
  102.             String fruizioneAutorizzazioneScope, String fruizioneScope, String fruizioneAutorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  103.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) {
  104.         
  105.         portaDelegata.setAutenticazione(fruizioneAutenticazione);
  106.         if(fruizioneAutenticazioneOpzionale != null){
  107.             if(ServletUtils.isCheckBoxEnabled(fruizioneAutenticazioneOpzionale))
  108.                 portaDelegata.setAutenticazioneOpzionale(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO);
  109.             else 
  110.                 portaDelegata.setAutenticazioneOpzionale(org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO);
  111.         } else 
  112.             portaDelegata.setAutenticazioneOpzionale(null);
  113.         portaDelegata.getProprietaAutenticazioneList().clear();
  114.         List<Proprieta> proprietaAutenticazione = this.convertToAutenticazioneProprieta(fruizioneAutenticazione, fruizioneAutenticazionePrincipal, fruizioneAutenticazioneParametroList);
  115.         if(proprietaAutenticazione!=null && !proprietaAutenticazione.isEmpty()) {
  116.             portaDelegata.getProprietaAutenticazioneList().addAll(proprietaAutenticazione);
  117.         }
  118.         
  119.         portaDelegata.setAutorizzazione(AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString(fruizioneAutorizzazione, 
  120.                 ServletUtils.isCheckBoxEnabled(fruizioneAutorizzazioneAutenticati), 
  121.                 ServletUtils.isCheckBoxEnabled(fruizioneAutorizzazioneRuoli),
  122.                 ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken), 
  123.                 ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken),
  124.                 ServletUtils.isCheckBoxEnabled(fruizioneAutorizzazioneScope),
  125.                 fruizioneAutorizzazioneTokenOptions,
  126.                 RuoloTipologia.toEnumConstant(fruizioneAutorizzazioneRuoliTipologia)));
  127.         
  128.         if(fruizioneAutorizzazione != null && fruizioneAutorizzazione.equals(AutorizzazioneUtilities.STATO_XACML_POLICY) && allegatoXacmlPolicy.getValue() != null) {
  129.             portaDelegata.setXacmlPolicy(new String(allegatoXacmlPolicy.getValue()));
  130.         } else {
  131.             portaDelegata.setXacmlPolicy(null);
  132.         }
  133.         
  134.         if(fruizioneAutorizzazioneRuoliMatch!=null && !"".equals(fruizioneAutorizzazioneRuoliMatch)){
  135.             RuoloTipoMatch tipoRuoloMatch = RuoloTipoMatch.toEnumConstant(fruizioneAutorizzazioneRuoliMatch);
  136.             if(tipoRuoloMatch!=null){
  137.                 if(portaDelegata.getRuoli()==null){
  138.                     portaDelegata.setRuoli(new AutorizzazioneRuoli());
  139.                 }
  140.                 portaDelegata.getRuoli().setMatch(tipoRuoloMatch);
  141.             }
  142.         }

  144.         // servizioApplicativo
  145.         if(fruizioneServizioApplicativo!=null && !"".equals(fruizioneServizioApplicativo) && !"-".equals(fruizioneServizioApplicativo)){
  146.             PortaDelegataServizioApplicativo sa = new PortaDelegataServizioApplicativo();
  147.             sa.setNome(fruizioneServizioApplicativo);
  148.             portaDelegata.addServizioApplicativo(sa);
  149.         }

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

  309.         try {
  310.             // prendo una connessione
  311.             con = ControlStationCore.dbM.getConnection();
  312.             // istanzio il driver
  313.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  315.             return driver.getDriverConfigurazioneDB().getPorteDelegateWithServizio(idServizio);

  317.         } catch (Exception e) {
  318.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  319.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  320.         } finally {
  321.             ControlStationCore.dbM.releaseConnection(con);
  322.         }
  323.     }
  324.     
  325.     public List<PortaDelegata> porteDelegateWithSoggettoErogatoreList(long idSoggettoErogatore) throws DriverConfigurazioneException {
  326.         Connection con = null;
  327.         String nomeMetodo = "porteDelegateWithSoggettoErogatoreList";
  328.         DriverControlStationDB driver = null;

  330.         try {
  331.             // prendo una connessione
  332.             con = ControlStationCore.dbM.getConnection();
  333.             // istanzio il driver
  334.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  336.             return driver.getDriverConfigurazioneDB().porteDelegateWithSoggettoErogatoreList(idSoggettoErogatore);

  338.         } catch (Exception e) {
  339.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  340.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  341.         } finally {
  342.             ControlStationCore.dbM.releaseConnection(con);
  343.         }
  344.     }

  346.     public List<PortaDelegata> porteDelegateWithTipoNomeErogatoreList(String tipoSoggettoErogatore, String nomeSoggettoErogatore) throws DriverConfigurazioneException {
  347.         Connection con = null;
  348.         String nomeMetodo = "porteDelegateWithTipoNomeErogatoreList";
  349.         DriverControlStationDB driver = null;

  351.         try {
  352.             // prendo una connessione
  353.             con = ControlStationCore.dbM.getConnection();
  354.             // istanzio il driver
  355.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  357.             return driver.getDriverConfigurazioneDB().porteDelegateWithTipoNomeErogatoreList(tipoSoggettoErogatore, nomeSoggettoErogatore);

  359.         } catch (Exception e) {
  360.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  361.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  362.         } finally {
  363.             ControlStationCore.dbM.releaseConnection(con);
  364.         }
  365.     }
  366.     
  367.     public List<PortaDelegata> getPorteDelegateWithServizio(Long idServizio, String tiposervizio, String nomeservizio, Integer versioneServizio,
  368.             Long idSoggetto, String tiposoggetto, String nomesoggetto) throws DriverConfigurazioneException {
  369.         Connection con = null;
  370.         String nomeMetodo = "getPorteDelegateWithServizio";
  371.         DriverControlStationDB driver = null;

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

  379.             return driver.getDriverConfigurazioneDB().getPorteDelegateWithServizio(idServizio, tiposervizio, nomeservizio, versioneServizio,
  380.                     idSoggetto, tiposoggetto, nomesoggetto);

  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.     }

  390.     public boolean existsPortaDelegataAzione(String nome) throws DriverConfigurazioneException {
  391.         Connection con = null;
  392.         String nomeMetodo = "existsPortaDelegataAzione";
  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.             return driver.getDriverConfigurazioneDB().existsPortaDelegataAzione(nome);

  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.     
  411.     public boolean existsPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException {
  412.         Connection con = null;
  413.         String nomeMetodo = "existsPortaDelegata";
  414.         DriverControlStationDB driver = null;

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

  422.             return driver.getDriverConfigurazioneDB().existsPortaDelegata(idPD);

  424.         } catch (Exception e) {
  425.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  426.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  427.         } finally {
  428.             ControlStationCore.dbM.releaseConnection(con);
  429.         }
  430.     }
  431.     
  432.     public List<MessageSecurityFlowParameter> porteDelegateMessageSecurityRequestList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  433.         Connection con = null;
  434.         String nomeMetodo = "porteDelegateMessageSecurityRequestList";
  435.         DriverControlStationDB driver = null;

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

  443.             return driver.getDriverConfigurazioneDB().porteDelegateMessageSecurityRequestList(idPortaDelegata, ricerca);

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

  452.     }

  454.     public List<MessageSecurityFlowParameter> porteDelegateMessageSecurityResponseList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  455.         Connection con = null;
  456.         String nomeMetodo = "porteDelegateMessageSecurityResponseList";
  457.         DriverControlStationDB driver = null;

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

  465.             return driver.getDriverConfigurazioneDB().porteDelegateMessageSecurityResponseList(idPortaDelegata, ricerca);

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

  474.     }
  475.     
  476.     public PortaDelegata getPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  477.         Connection con = null;
  478.         String nomeMetodo = "getPortaDelegata(id)";
  479.         DriverControlStationDB driver = null;

  481.         try {
  482.             // prendo una connessione
  483.             con = ControlStationCore.dbM.getConnection();
  484.             // istanzio il driver
  485.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  487.             return driver.getDriverConfigurazioneDB().getPortaDelegata(idPD);

  489.         } catch (DriverConfigurazioneNotFound de) {
  490.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] Exception :" + de.getMessage(),de);
  491.             throw de;
  492.         } catch (Exception e) {
  493.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  494.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  495.         } finally {
  496.             ControlStationCore.dbM.releaseConnection(con);
  497.         }

  499.     }
  500.     
  501.     public PortaDelegata getPortaDelegata(long idPortaDelegata) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  502.         Connection con = null;
  503.         String nomeMetodo = "getPortaDelegata(long)";
  504.         DriverControlStationDB driver = null;

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

  512.             return driver.getDriverConfigurazioneDB().getPortaDelegata(idPortaDelegata);

  514.         } catch (DriverConfigurazioneNotFound de) {
  515.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] Exception :" + de.getMessage(),de);
  516.             throw de;
  517.         } catch (Exception e) {
  518.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  519.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  520.         } finally {
  521.             ControlStationCore.dbM.releaseConnection(con);
  522.         }
  523.     }
  524.     
  525.     public ProprietaOggetto getProprietaOggetto(IDPortaDelegata idPD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  526.         Connection con = null;
  527.         String nomeMetodo = "getProprietaOggetto(id)";
  528.         DriverControlStationDB driver = null;

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

  536.             return driver.getDriverConfigurazioneDB().getProprietaOggetto(idPD);

  538.         } catch (DriverConfigurazioneNotFound de) {
  539.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] Exception :" + de.getMessage(),de);
  540.             throw de;
  541.         } catch (Exception e) {
  542.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  543.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  544.         } finally {
  545.             ControlStationCore.dbM.releaseConnection(con);
  546.         }
  547.     }
  548.     
  549.     public void updateProprietaOggetto(IDPortaDelegata idPD, String user) throws DriverConfigurazioneException {
  550.         Connection con = null;
  551.         String nomeMetodo = "updateProprietaOggetto";
  552.         DriverControlStationDB driver = null;

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

  560.             driver.getDriverConfigurazioneDB().updateProprietaOggetto(idPD, user);

  562.         }catch (Exception e) {
  563.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  564.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  565.         } finally {
  566.             ControlStationCore.dbM.releaseConnection(con);
  567.         }
  568.     }
  569.     
  570.     public boolean azioneUsataInTrasformazioniPortaDelegata(String nome) throws DriverConfigurazioneException {
  571.         Connection con = null;
  572.         String nomeMetodo = "azioneUsataInTrasformazioniPortaDelegata";
  573.         DriverControlStationDB driver = null;

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

  581.             return driver.getDriverConfigurazioneDB().azioneUsataInTrasformazioniPortaDelegata(nome);

  583.         } catch (Exception e) {
  584.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  585.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  586.         } finally {
  587.             ControlStationCore.dbM.releaseConnection(con);
  588.         }
  589.     }
  590.     
  591.     public List<MappingFruizionePortaDelegata> getMappingConGruppiPerAzione(String nomeAzione, List<IDServizio> list) throws DriverConfigurazioneException {
  592.         Connection con = null;
  593.         String nomeMetodo = "getMappingConGruppiPerAzione";
  594.         
  595.         try {
  596.             // prendo una connessione
  597.             con = ControlStationCore.dbM.getConnection();
  598.             
  599.             List<MappingFruizionePortaDelegata> listInUtilizzo = new ArrayList<>();
  600.             
  601.             if(list!=null && !list.isEmpty()) {
  602.                 for (IDServizio idServizio : list) {
  603.                     
  604.                     AccordiServizioParteSpecificaCore aspsCore = new AccordiServizioParteSpecificaCore(this);
  605.                     Long idS = aspsCore.getIdAccordoServizioParteSpecifica(con, idServizio);
  606.                     ConsoleSearch s = new ConsoleSearch(true);
  607.                     List<Fruitore> listFruitori = aspsCore.serviziFruitoriList(con, idS, s);
  608.                     if(listFruitori!=null && !listFruitori.isEmpty()) {
  609.                     
  610.                         for (Fruitore fruitore : listFruitori) {
  611.                             IDSoggetto idSoggettoFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  612.                             List<MappingFruizionePortaDelegata> lPD = DBMappingUtils.mappingFruizionePortaDelegataList(con, this.tipoDB, idSoggettoFruitore, idServizio, false);
  613.                             if(lPD!=null && !lPD.isEmpty()) {
  614.                                 for (MappingFruizionePortaDelegata mapping : lPD) {
  615.                                     fill(nomeAzione, mapping, listInUtilizzo);
  616.                                 }
  617.                             }
  618.                         }
  619.                         
  620.                     }
  621.                 }
  622.             }
  623.                 
  624.             return listInUtilizzo;

  626.         } catch (Exception e) {
  627.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  628.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  629.         } finally {
  630.             ControlStationCore.dbM.releaseConnection(con);
  631.         }
  632.     }
  633.     private void fill(String nomeAzione, MappingFruizionePortaDelegata mapping, List<MappingFruizionePortaDelegata> listInUtilizzo) throws DriverConfigurazioneException {
  634.         try {
  635.             PortaDelegata pd = this.getPortaDelegata(mapping.getIdPortaDelegata());
  636.             if(pd!=null && pd.getAzione()!=null && pd.getAzione().getAzioneDelegataList()!=null &&
  637.                     pd.getAzione().getAzioneDelegataList().contains(nomeAzione)) {
  638.                 listInUtilizzo.add(mapping);
  639.             }
  640.         }catch(DriverConfigurazioneNotFound notFound) {
  641.             // ignore
  642.         }
  643.     }
  644.     
  645.     public List<MappingFruizionePortaDelegata> getMapping(List<IDServizio> list, boolean addDefault, boolean addNotDefault) throws DriverConfigurazioneException {
  646.         Connection con = null;
  647.         String nomeMetodo = "getMapping";
  648.         
  649.         try {
  650.             // prendo una connessione
  651.             con = ControlStationCore.dbM.getConnection();
  652.             
  653.             List<MappingFruizionePortaDelegata> listMappingDefault = new ArrayList<>();
  654.             
  655.             if(list!=null && !list.isEmpty()) {
  656.                 for (IDServizio idServizio : list) {
  657.                     
  658.                     AccordiServizioParteSpecificaCore aspsCore = new AccordiServizioParteSpecificaCore(this);
  659.                     Long idS = aspsCore.getIdAccordoServizioParteSpecifica(con, idServizio);
  660.                     ConsoleSearch s = new ConsoleSearch(true);
  661.                     List<Fruitore> listFruitori = aspsCore.serviziFruitoriList(con, idS, s);
  662.                     if(listFruitori!=null && !listFruitori.isEmpty()) {
  663.                     
  664.                         for (Fruitore fruitore : listFruitori) {
  665.                             IDSoggetto idSoggettoFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  666.                             List<MappingFruizionePortaDelegata> lPD = DBMappingUtils.mappingFruizionePortaDelegataList(con, this.tipoDB, idSoggettoFruitore, idServizio, false);
  667.                             if(lPD!=null && !lPD.isEmpty()) {
  668.                                 for (MappingFruizionePortaDelegata mapping : lPD) {
  669.                                     if(mapping.isDefault()) {
  670.                                         if(addDefault) {
  671.                                             listMappingDefault.add(mapping);
  672.                                         }
  673.                                     }
  674.                                     else {
  675.                                         if(addNotDefault) {
  676.                                             listMappingDefault.add(mapping);
  677.                                         }
  678.                                     }
  679.                                 }
  680.                             }
  681.                         }
  682.                         
  683.                     }
  684.                 }
  685.             }
  686.             
  687.             return listMappingDefault;

  689.         } catch (Exception e) {
  690.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  691.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  692.         } finally {
  693.             ControlStationCore.dbM.releaseConnection(con);
  694.         }
  695.     }
  696.     
  697.     public List<IDPortaDelegata> getPortaDelegataAzione(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  698.         Connection con = null;
  699.         String nomeMetodo = "getPortaDelegataAzione";
  700.         DriverControlStationDB driver = null;

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

  708.             return driver.getDriverConfigurazioneDB().getPortaDelegataAzione(nome);

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

  718.     
  719.     public long getIdPortaDelegata(String nomePorta) throws DriverConfigurazioneException {
  720.         Connection con = null;
  721.         String nomeMetodo = "getPortaDelegata";
  722.     
  723.         try {
  724.             // prendo una connessione
  725.             con = ControlStationCore.dbM.getConnection();
  726.             return DBUtils.getIdPortaDelegata(nomePorta,  con, this.getTipoDatabase());

  728.         }catch (Exception e) {
  729.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  730.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  731.         } finally {
  732.             ControlStationCore.dbM.releaseConnection(con);
  733.         }
  734.     }
  735.     
  736.     public List<IDPortaDelegata> getAllIdPorteDelegate(FiltroRicercaPorteDelegate filtroRicerca) throws DriverConfigurazioneException {
  737.         Connection con = null;
  738.         String nomeMetodo = "getAllIdPorteDelegate";
  739.         DriverControlStationDB driver = null;

  741.         try {
  742.             // prendo una connessione
  743.             con = ControlStationCore.dbM.getConnection();
  744.             // istanzio il driver
  745.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  747.             return driver.getDriverConfigurazioneDB().getAllIdPorteDelegate(filtroRicerca);

  749.         } catch (DriverConfigurazioneNotFound notFound) {
  750.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  notFound), notFound);
  751.             return new ArrayList<>();
  752.         } catch (Exception e) {
  753.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  754.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  755.         } finally {
  756.             ControlStationCore.dbM.releaseConnection(con);
  757.         }

  759.     }

  761.     public List<PortaDelegata> porteDelegateList(long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
  762.         Connection con = null;
  763.         String nomeMetodo = "porteDelegateList";
  764.         DriverControlStationDB driver = null;

  766.         try {
  767.             // prendo una connessione
  768.             con = ControlStationCore.dbM.getConnection();
  769.             // istanzio il driver
  770.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  772.             return driver.getDriverConfigurazioneDB().porteDelegateList(idSoggetto, ricerca);

  774.         } catch (Exception e) {
  775.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  776.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  777.         } finally {
  778.             ControlStationCore.dbM.releaseConnection(con);
  779.         }

  781.     }
  782.     
  783.     public List<PortaDelegata> porteDelegateList(String superUser, ISearch ricerca) throws DriverConfigurazioneException {
  784.         Connection con = null;
  785.         String nomeMetodo = "porteDelegateList";
  786.         DriverControlStationDB driver = null;

  788.         try {
  789.             // prendo una connessione
  790.             con = ControlStationCore.dbM.getConnection();
  791.             // istanzio il driver
  792.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  794.             return driver.getDriverConfigurazioneDB().porteDelegateList(superUser, ricerca);

  796.         } catch (Exception e) {
  797.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  798.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  799.         } finally {
  800.             ControlStationCore.dbM.releaseConnection(con);
  801.         }

  803.     }

  805.     public List<ServizioApplicativo> porteDelegateServizioApplicativoList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  806.         Connection con = null;
  807.         String nomeMetodo = "porteDelegateServizioApplicativoList";
  808.         DriverControlStationDB driver = null;

  810.         try {
  811.             // prendo una connessione
  812.             con = ControlStationCore.dbM.getConnection();
  813.             // istanzio il driver
  814.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  816.             return driver.getDriverConfigurazioneDB().porteDelegateServizioApplicativoList(idPortaDelegata, ricerca);

  818.         } catch (Exception e) {
  819.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  820.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  821.         } finally {
  822.             ControlStationCore.dbM.releaseConnection(con);
  823.         }

  825.     }
  826.     
  827.     public List<ServizioApplicativo> porteDelegateServizioApplicativoTokenList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  828.         Connection con = null;
  829.         String nomeMetodo = "porteDelegateServizioApplicativoTokenList";
  830.         DriverControlStationDB driver = null;

  832.         try {
  833.             // prendo una connessione
  834.             con = ControlStationCore.dbM.getConnection();
  835.             // istanzio il driver
  836.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  838.             return driver.getDriverConfigurazioneDB().porteDelegateServizioApplicativoTokenList(idPortaDelegata, ricerca);

  840.         } catch (Exception e) {
  841.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  842.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  843.         } finally {
  844.             ControlStationCore.dbM.releaseConnection(con);
  845.         }

  847.     }
  848.     
  849.     public List<CorrelazioneApplicativaElemento> porteDelegateCorrelazioneApplicativaList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  850.         Connection con = null;
  851.         String nomeMetodo = "porteDelegateCorrelazioneApplicativaList";
  852.         DriverControlStationDB driver = null;

  854.         try {
  855.             // prendo una connessione
  856.             con = ControlStationCore.dbM.getConnection();
  857.             // istanzio il driver
  858.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  860.             return driver.getDriverConfigurazioneDB().porteDelegateCorrelazioneApplicativaList(idPortaDelegata, ricerca);

  862.         } catch (Exception e) {
  863.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  864.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  865.         } finally {
  866.             ControlStationCore.dbM.releaseConnection(con);
  867.         }

  869.     }
  870.     
  871.     public List<CorrelazioneApplicativaRispostaElemento> porteDelegateCorrelazioneApplicativaRispostaList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  872.         Connection con = null;
  873.         String nomeMetodo = "porteDelegateCorrelazioneApplicativaRispostaList";
  874.         DriverControlStationDB driver = null;

  876.         try {
  877.             // prendo una connessione
  878.             con = ControlStationCore.dbM.getConnection();
  879.             // istanzio il driver
  880.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  882.             return driver.getDriverConfigurazioneDB().porteDelegateCorrelazioneApplicativaRispostaList(idPortaDelegata, ricerca);

  884.         } catch (Exception e) {
  885.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  886.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e));
  887.         } finally {
  888.             ControlStationCore.dbM.releaseConnection(con);
  889.         }

  891.     }
  892.     
  893.     public List<MtomProcessorFlowParameter> porteDelegateMTOMRequestList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  894.         Connection con = null;
  895.         String nomeMetodo = "porteDelegateMTOMRequestList";
  896.         DriverControlStationDB driver = null;

  898.         try {
  899.             // prendo una connessione
  900.             con = ControlStationCore.dbM.getConnection();
  901.             // istanzio il driver
  902.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  904.             return driver.getDriverConfigurazioneDB().porteDelegateMTOMRequestList(idPortaDelegata, ricerca);

  906.         } catch (Exception e) {
  907.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  908.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  909.         } finally {
  910.             ControlStationCore.dbM.releaseConnection(con);
  911.         }

  913.     }

  915.     public List<MtomProcessorFlowParameter> porteDelegateMTOMResponseList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  916.         Connection con = null;
  917.         String nomeMetodo = "porteDelegateMTOMResponseList";
  918.         DriverControlStationDB driver = null;

  920.         try {
  921.             // prendo una connessione
  922.             con = ControlStationCore.dbM.getConnection();
  923.             // istanzio il driver
  924.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  926.             return driver.getDriverConfigurazioneDB().porteDelegateMTOMResponseList(idPortaDelegata, ricerca);

  928.         } catch (Exception e) {
  929.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  930.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  931.         } finally {
  932.             ControlStationCore.dbM.releaseConnection(con);
  933.         }

  935.     }
  936.     
  937.     
  938.     
  939.     public IDPortaDelegata getIDPortaDelegataAssociataDefault(IDServizio idServizio, IDSoggetto fruitore) throws DriverConfigurazioneException {
  940.         Connection con = null;
  941.         String nomeMetodo = "getIDPortaDelegataAssociataDefault";
  942.         DriverControlStationDB driver = null;

  944.         try {
  945.             // prendo una connessione
  946.             con = ControlStationCore.dbM.getConnection();
  947.             // istanzio il driver
  948.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  950.             return driver.getIDPortaDelegataAssociataDefault(idServizio,fruitore);

  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 IDPortaDelegata getIDPortaDelegataAssociataAzione(IDServizio idServizio, IDSoggetto fruitore) throws DriverConfigurazioneException {
  961.         Connection con = null;
  962.         String nomeMetodo = "getIDPortaDelegataAssociataAzione";
  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.getIDPortaDelegataAssociataAzione(idServizio,fruitore);

  973.         } catch (Exception e) {
  974.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  975.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  976.         } finally {
  977.             ControlStationCore.dbM.releaseConnection(con);
  978.         }
  979.     }
  980.     
  981.     public List<IDPortaDelegata> getIDPorteDelegateAssociate(IDServizio idServizio, IDSoggetto fruitore) throws DriverConfigurazioneException {
  982.         Connection con = null;
  983.         String nomeMetodo = "getIDPorteDelegateAssociate";
  984.         DriverControlStationDB driver = null;

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

  992.             return driver.getIDPorteDelegateAssociate(idServizio,fruitore);

  994.         } catch (Exception e) {
  995.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  996.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  997.         } finally {
  998.             ControlStationCore.dbM.releaseConnection(con);
  999.         }
  1000.     }
  1001.     
  1002.     public boolean existsMappingFruizionePortaDelegata(MappingFruizionePortaDelegata mapping) throws DriverConfigurazioneException {
  1003.         Connection con = null;
  1004.         String nomeMetodo = "existsMappingFruizionePortaDelegata";
  1005.         DriverControlStationDB driver = null;

  1007.         try {
  1008.             // prendo una connessione
  1009.             con = ControlStationCore.dbM.getConnection();
  1010.             // istanzio il driver
  1011.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1013.             return driver.existsMappingFruizionePortaDelegata(mapping);

  1015.         } catch (Exception e) {
  1016.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1017.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1018.         } finally {
  1019.             ControlStationCore.dbM.releaseConnection(con);
  1020.         }
  1021.     }
  1022.     
  1023.     public List<String> portaDelegataRuoliList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
  1024.         Connection con = null;
  1025.         String nomeMetodo = "portaDelegataRuoliList";
  1026.         DriverControlStationDB driver = null;

  1028.         try {
  1029.             // prendo una connessione
  1030.             con = ControlStationCore.dbM.getConnection();
  1031.             // istanzio il driver
  1032.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1034.             return driver.getDriverConfigurazioneDB().portaDelegataRuoliList(idPD, ricerca);

  1036.         } catch (Exception e) {
  1037.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1038.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1039.         } finally {
  1040.             ControlStationCore.dbM.releaseConnection(con);
  1041.         }

  1043.     }
  1044.     
  1045.     public List<String> portaDelegataRuoliTokenList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
  1046.         Connection con = null;
  1047.         String nomeMetodo = "portaDelegataRuoliTokenList";
  1048.         DriverControlStationDB driver = null;

  1050.         try {
  1051.             // prendo una connessione
  1052.             con = ControlStationCore.dbM.getConnection();
  1053.             // istanzio il driver
  1054.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1056.             return driver.getDriverConfigurazioneDB().portaDelegataRuoliTokenList(idPD, ricerca);

  1058.         } catch (Exception e) {
  1059.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1060.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1061.         } finally {
  1062.             ControlStationCore.dbM.releaseConnection(con);
  1063.         }

  1065.     }
  1066.     
  1067.     public List<String> portaDelegataScopeList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
  1068.         Connection con = null;
  1069.         String nomeMetodo = "portaDelegataScopeList";
  1070.         DriverControlStationDB driver = null;

  1072.         try {
  1073.             // prendo una connessione
  1074.             con = ControlStationCore.dbM.getConnection();
  1075.             // istanzio il driver
  1076.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1078.             return driver.getDriverConfigurazioneDB().portaDelegataScopeList(idPD, ricerca);

  1080.         } catch (Exception e) {
  1081.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1082.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1083.         } finally {
  1084.             ControlStationCore.dbM.releaseConnection(con);
  1085.         }

  1087.     }
  1088.     
  1089.     public void aggiornaDescrizioneMappingFruizionePortaDelegata(MappingFruizionePortaDelegata mapping, String user) throws DriverConfigurazioneException {
  1090.         Connection con = null;
  1091.         String nomeMetodo = "aggiornaDescrizioneMappingFruizionePortaDelegata";
  1092.         try {
  1093.             // prendo una connessione
  1094.             con = ControlStationCore.dbM.getConnection();
  1095.             
  1096.             DBMappingUtils.updateMappingFruizione(mapping.getTableId(), mapping.getDescrizione(), con, this.tipoDB);
  1097.             
  1098.             if(mapping.getIdPortaDelegata()!=null) {
  1099.                 this.updateProprietaOggetto(mapping.getIdPortaDelegata(), user);
  1100.             }

  1102.         } catch (Exception e) {
  1103.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1104.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1105.         } finally {
  1106.             ControlStationCore.dbM.releaseConnection(con);
  1107.         }
  1108.     }
  1109.     
  1110.     public MappingFruizionePortaDelegata getMappingFruizionePortaDelegata(PortaDelegata pd) throws DriverConfigurazioneException {
  1111.         Connection con = null;
  1112.         String nomeMetodo = "getMappingFruizionePortaDelegata";
  1113.         try {
  1114.             // prendo una connessione
  1115.             con = ControlStationCore.dbM.getConnection();
  1116.             
  1117.             IDPortaDelegata idPD = new IDPortaDelegata();
  1118.             idPD.setNome(pd.getNome());
  1119.             
  1120.             IDSoggetto idFruitore = new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario());
  1121.             
  1122.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  1123.                     pd.getSoggettoErogatore().getTipo(),pd.getSoggettoErogatore().getNome(), 
  1124.                     pd.getServizio().getVersione());
  1125.             
  1126.             return DBMappingUtils.getMappingFruizione(idServizio, idFruitore, idPD, con, this.tipoDB);

  1128.         } catch (Exception e) {
  1129.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1130.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1131.         } finally {
  1132.             ControlStationCore.dbM.releaseConnection(con);
  1133.         }
  1134.     }
  1135.     public List<MappingFruizionePortaDelegata> countMappingFruizionePortaDelegata(IDSoggetto idFruitore, IDServizio idServizio) throws DriverConfigurazioneException {
  1136.         Connection con = null;
  1137.         String nomeMetodo = "countMappingFruizionePortaDelegata";
  1138.         try {
  1139.             // prendo una connessione
  1140.             con = ControlStationCore.dbM.getConnection();
  1141.             
  1142.             return DBMappingUtils.mappingFruizionePortaDelegataList(con, this.tipoDB, idFruitore, idServizio, false);

  1144.         } catch (Exception e) {
  1145.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1146.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1147.         } finally {
  1148.             ControlStationCore.dbM.releaseConnection(con);
  1149.         }
  1150.     }
  1151.     
  1152.     private static boolean showGroup = true;
  1153.     public static boolean isShowGroup() {
  1154.         return showGroup;
  1155.     }
  1156.     public static void setShowGroup(boolean showGroup) {
  1157.         PorteDelegateCore.showGroup = showGroup;
  1158.     }
  1159.     
  1160.     public String getLabelRegolaMappingFruizionePortaDelegata(String functionDi, String function, PortaDelegata pd) throws DriverConfigurazioneException {
  1161.         return getLabelRegolaMappingFruizionePortaDelegata(functionDi, function, pd, 50);
  1162.     }
  1163.     public String getLabelRegolaMappingFruizionePortaDelegata(String functionDi, String function, PortaDelegata pd, boolean forceGroupName) throws DriverConfigurazioneException {
  1164.         return getLabelRegolaMappingFruizionePortaDelegata(functionDi, function, pd, 50, forceGroupName);
  1165.     }
  1166.     public String getLabelRegolaMappingFruizionePortaDelegata(String functionDi, String function, PortaDelegata pd, int sizeSubstring) throws DriverConfigurazioneException {
  1167.         return getLabelRegolaMappingFruizionePortaDelegata(functionDi, function, pd, sizeSubstring, false);
  1168.     }
  1169.     public String getLabelRegolaMappingFruizionePortaDelegata(String functionDi, String function, PortaDelegata pd, int sizeSubstring, boolean forceGroupName) throws DriverConfigurazioneException {
  1170.                 
  1171.         String prefix = "";
  1172.         if(functionDi!=null) {
  1173.             prefix = functionDi;
  1174.             if(showGroup) {
  1175.                 prefix = convertPrefixConfigDelGruppo(prefix);
  1176.             }
  1177.         }
  1178.         
  1179.         MappingFruizionePortaDelegata mapping = this.getMappingFruizionePortaDelegata(pd);
  1180.         if(mapping.isDefault()) {
  1181.             if(this.countMappingFruizionePortaDelegata(mapping.getIdFruitore(),mapping.getIdServizio()).size()>1 || forceGroupName) {
  1182.                 if(showGroup) {
  1183.                     return prefix+getLabelGroup(mapping.getDescrizione());
  1184.                 }
  1185.                 else {
  1186.                     return prefix+PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MAPPING_FRUIZIONE_PD_NOME_DEFAULT;
  1187.                 }
  1188.             }
  1189.             else {
  1190.                 return function!=null ? function : PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MAPPING_FRUIZIONE_PD_NOME_DEFAULT;
  1191.             }
  1192.         }
  1193.         else {
  1194.             if(showGroup) {
  1195.                 StringBuilder sb = new StringBuilder(mapping.getDescrizione());
  1196.                 if(sb.length()>sizeSubstring)
  1197.                     return prefix+getLabelGroup(sb.toString().substring(0, (sizeSubstring-3))+"...");
  1198.                 else 
  1199.                     return prefix+getLabelGroup(sb.toString());
  1200.             }
  1201.             else {
  1202.                 List<String> listaAzioni = pd.getAzione()!= null ?  pd.getAzione().getAzioneDelegataList() : new ArrayList<>();
  1203.                 if(!listaAzioni.isEmpty()) {
  1204.                     StringBuilder sb = new StringBuilder();
  1205.                     for (String string : listaAzioni) {
  1206.                         if(sb.length() >0)
  1207.                             sb.append(", ");
  1208.                         
  1209.                         sb.append(string);
  1210.                     }
  1211.                     if(sb.length()>sizeSubstring)
  1212.                         return prefix+sb.toString().substring(0, (sizeSubstring-3))+"...";
  1213.                     else 
  1214.                         return prefix+sb.toString();
  1215.                 }
  1216.                 else {
  1217.                     return prefix+"???";
  1218.                 }
  1219.             }
  1220.         }
  1221.     }
  1222.     public List<Proprieta> porteDelPropList(long idPortaDelegata, ConsoleSearch ricerca) throws DriverConfigurazioneException {
  1223.         Connection con = null;
  1224.         String nomeMetodo = "porteDelPropList";
  1225.         DriverControlStationDB driver = null;

  1227.         try {
  1228.             // prendo una connessione
  1229.             con = ControlStationCore.dbM.getConnection();
  1230.             // istanzio il driver
  1231.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1233.             return driver.getDriverConfigurazioneDB().porteDelegatePropList(idPortaDelegata, ricerca);

  1235.         } catch (Exception e) {
  1236.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1237.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1238.         } finally {
  1239.             ControlStationCore.dbM.releaseConnection(con);
  1240.         }
  1241.     }
  1242.     
  1243.     public List<String> nomiProprietaPD(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoServiziProtocollo) throws DriverConfigurazioneException {
  1244.         Connection con = null;
  1245.         String nomeMetodo = "nomiProprietaPD";
  1246.         DriverControlStationDB driver = null;

  1248.         try {
  1249.             // prendo una connessione
  1250.             con = ControlStationCore.dbM.getConnection();
  1251.             // istanzio il driver
  1252.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1253.             
  1254.             return driver.getDriverConfigurazioneDB().nomiProprietaPD(filterSoggettoTipo, filterSoggettoNome, tipoServiziProtocollo);

  1256.         } catch (Exception e) {
  1257.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1258.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1259.         } finally {
  1260.             ControlStationCore.dbM.releaseConnection(con);
  1261.         }
  1262.     }
  1263.     
  1264.     public Map<String, Properties> readMessageSecurityRequestPropertiesConfiguration(long idPortaDelegata) throws DriverConfigurazioneException {
  1265.         Connection con = null;
  1266.         String nomeMetodo = "readMessageSecurityRequestPropertiesConfiguration";
  1267.         try {
  1268.             // prendo una connessione
  1269.             con = ControlStationCore.dbM.getConnection();
  1270.             Map<String, String> readProperties = DBPropertiesUtils.readProperties(con, this.tipoDB, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_NOME, 
  1271.                     CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_ENC_VALUE,
  1272.                     CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_ID_PORTA, idPortaDelegata,
  1273.                     this.getDriverBYOKUtilities().getDriverBYOKManagerNode(false, true));
  1274.             return DBPropertiesUtils.toMultiMap(readProperties);
  1275.         } catch (Exception e) {
  1276.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1277.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1278.         } finally {
  1279.             ControlStationCore.dbM.releaseConnection(con);
  1280.         }   
  1281.     }
  1282.     
  1283.     public Map<String, Properties> readMessageSecurityResponsePropertiesConfiguration(long idPortaDelegata) throws DriverConfigurazioneException {
  1284.         Connection con = null;
  1285.         String nomeMetodo = "readMessageSecurityResponsePropertiesConfiguration";
  1286.         try {
  1287.             // prendo una connessione
  1288.             con = ControlStationCore.dbM.getConnection();
  1289.             Map<String, String> readProperties = DBPropertiesUtils.readProperties(con, this.tipoDB, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_NOME, 
  1290.                     CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_ENC_VALUE, 
  1291.                     CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_ID_PORTA, idPortaDelegata,
  1292.                     this.getDriverBYOKUtilities().getDriverBYOKManagerNode(false, true));
  1293.             return DBPropertiesUtils.toMultiMap(readProperties);
  1294.         } catch (Exception e) {
  1295.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1296.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1297.         } finally {
  1298.             ControlStationCore.dbM.releaseConnection(con);
  1299.         }   
  1300.     }
  1301.     
  1302.     public List<ResponseCachingConfigurazioneRegola> getResponseCachingConfigurazioneRegolaList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  1303.         Connection con = null;
  1304.         String nomeMetodo = "getResponseCachingConfigurazioneRegolaList";
  1305.         DriverControlStationDB driver = null;

  1307.         try {
  1308.             // prendo una connessione
  1309.             con = ControlStationCore.dbM.getConnection();
  1310.             // istanzio il driver
  1311.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1313.             return driver.getDriverConfigurazioneDB().portaDelegataResponseCachingConfigurazioneRegolaList(idPA, ricerca);

  1315.         } catch (Exception e) {
  1316.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1317.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1318.         } finally {
  1319.             ControlStationCore.dbM.releaseConnection(con);
  1320.         }

  1322.     }
  1323.     
  1324.     public boolean existsResponseCachingConfigurazioneRegola(Long idPorta, Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException{
  1325.         Connection con = null;
  1326.         String nomeMetodo = "existsResponseCachingConfigurazioneRegola";
  1327.         DriverControlStationDB driver = null;

  1329.         try {
  1330.             // prendo una connessione
  1331.             con = ControlStationCore.dbM.getConnection();
  1332.             // istanzio il driver
  1333.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1334.             return driver.getDriverConfigurazioneDB().existsPortaDelegataResponseCachingConfigurazioneRegola(idPorta, statusMin,statusMax,fault);
  1335.         } catch (Exception e) {
  1336.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1337.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1338.         } finally {
  1339.             ControlStationCore.dbM.releaseConnection(con);
  1340.         }
  1341.     }
  1342.     
  1343.     public List<TrasformazioneRegola> porteDelegateTrasformazioniList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
  1344.         Connection con = null;
  1345.         String nomeMetodo = "porteDelegateTrasformazioniList";
  1346.         DriverControlStationDB driver = null;

  1348.         try {
  1349.             // prendo una connessione
  1350.             con = ControlStationCore.dbM.getConnection();
  1351.             // istanzio il driver
  1352.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1354.             return driver.getDriverConfigurazioneDB().porteDelegateTrasformazioniList(idPortaDelegata, ricerca);

  1356.         } catch (Exception e) {
  1357.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1358.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1359.         } finally {
  1360.             ControlStationCore.dbM.releaseConnection(con);
  1361.         }
  1362.     }
  1363.     
  1364.     
  1365.     public boolean existsTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori) throws DriverConfigurazioneException{
  1366.         Connection con = null;
  1367.         String nomeMetodo = "existsTrasformazione";
  1368.         DriverControlStationDB driver = null;

  1370.         try {
  1371.             // prendo una connessione
  1372.             con = ControlStationCore.dbM.getConnection();
  1373.             // istanzio il driver
  1374.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1375.             return driver.getDriverConfigurazioneDB().existsPortaDelegataTrasformazione(idPorta, azioni, pattern, contentType, connettori);
  1376.         } catch (Exception e) {
  1377.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1378.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1379.         } finally {
  1380.             ControlStationCore.dbM.releaseConnection(con);
  1381.         }
  1382.     }
  1383.     
  1384.     public boolean existsTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException{
  1385.         Connection con = null;
  1386.         String nomeMetodo = "existsTrasformazione";
  1387.         DriverControlStationDB driver = null;

  1389.         try {
  1390.             // prendo una connessione
  1391.             con = ControlStationCore.dbM.getConnection();
  1392.             // istanzio il driver
  1393.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1394.             return driver.getDriverConfigurazioneDB().existsPortaDelegataTrasformazione(idPorta, nome);
  1395.         } catch (Exception e) {
  1396.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1397.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1398.         } finally {
  1399.             ControlStationCore.dbM.releaseConnection(con);
  1400.         }
  1401.     }
  1402.     
  1403.     public TrasformazioneRegola getTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
  1404.             List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi) throws DriverConfigurazioneException{
  1405.         Connection con = null;
  1406.         String nomeMetodo = "getTrasformazione";
  1407.         DriverControlStationDB driver = null;

  1409.         try {
  1410.             // prendo una connessione
  1411.             con = ControlStationCore.dbM.getConnection();
  1412.             // istanzio il driver
  1413.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1414.             return driver.getDriverConfigurazioneDB().getPortaDelegataTrasformazione(idPorta, azioni, pattern, contentType, connettori, applicativi);
  1415.         } catch (Exception e) {
  1416.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1417.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1418.         } finally {
  1419.             ControlStationCore.dbM.releaseConnection(con);
  1420.         }
  1421.     }
  1422.     
  1423.     public TrasformazioneRegola getTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException{
  1424.         Connection con = null;
  1425.         String nomeMetodo = "getTrasformazione";
  1426.         DriverControlStationDB driver = null;

  1428.         try {
  1429.             // prendo una connessione
  1430.             con = ControlStationCore.dbM.getConnection();
  1431.             // istanzio il driver
  1432.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1433.             return driver.getDriverConfigurazioneDB().getPortaDelegataTrasformazione(idPorta, nome);
  1434.         } catch (Exception e) {
  1435.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1436.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1437.         } finally {
  1438.             ControlStationCore.dbM.releaseConnection(con);
  1439.         }
  1440.     }
  1441.     
  1442.     public List<TrasformazioneRegolaRisposta> porteDelegateTrasformazioniRispostaList(long idPortaDelegata, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1443.         Connection con = null;
  1444.         String nomeMetodo = "porteDelegateTrasformazioniRispostaList";
  1445.         DriverControlStationDB driver = null;

  1447.         try {
  1448.             // prendo una connessione
  1449.             con = ControlStationCore.dbM.getConnection();
  1450.             // istanzio il driver
  1451.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1453.             return driver.getDriverConfigurazioneDB().porteDelegateTrasformazioniRispostaList(idPortaDelegata, idTrasformazione, ricerca);

  1455.         } catch (Exception e) {
  1456.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1457.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1458.         } finally {
  1459.             ControlStationCore.dbM.releaseConnection(con);
  1460.         }
  1461.     }
  1462.     
  1463.     public boolean existsTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException{
  1464.         Connection con = null;
  1465.         String nomeMetodo = "existsTrasformazioneRisposta";
  1466.         DriverControlStationDB driver = null;

  1468.         try {
  1469.             // prendo una connessione
  1470.             con = ControlStationCore.dbM.getConnection();
  1471.             // istanzio il driver
  1472.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1473.             return driver.getDriverConfigurazioneDB().existsPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
  1474.         } catch (Exception e) {
  1475.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1476.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1477.         } finally {
  1478.             ControlStationCore.dbM.releaseConnection(con);
  1479.         }
  1480.     }
  1481.     
  1482.     public boolean existsTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException{
  1483.         Connection con = null;
  1484.         String nomeMetodo = "existsTrasformazioneRisposta";
  1485.         DriverControlStationDB driver = null;

  1487.         try {
  1488.             // prendo una connessione
  1489.             con = ControlStationCore.dbM.getConnection();
  1490.             // istanzio il driver
  1491.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1492.             return driver.getDriverConfigurazioneDB().existsPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, nome);
  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.     public TrasformazioneRegolaRisposta getTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException{
  1502.         Connection con = null;
  1503.         String nomeMetodo = "getTrasformazioneRisposta";
  1504.         DriverControlStationDB driver = null;

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

  1525.         try {
  1526.             // prendo una connessione
  1527.             con = ControlStationCore.dbM.getConnection();
  1528.             // istanzio il driver
  1529.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1530.             return driver.getDriverConfigurazioneDB().getPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, nome);
  1531.         } catch (Exception e) {
  1532.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1533.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1534.         } finally {
  1535.             ControlStationCore.dbM.releaseConnection(con);
  1536.         }
  1537.     }
  1538.     
  1539.     public List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRispostaHeaderList(long idPortaDelegata, long idTrasformazione, long idTrasformazioneRisposta,  ISearch ricerca) throws DriverConfigurazioneException {
  1540.         Connection con = null;
  1541.         String nomeMetodo = "porteDelegateTrasformazioniRispostaList";
  1542.         DriverControlStationDB driver = null;

  1544.         try {
  1545.             // prendo una connessione
  1546.             con = ControlStationCore.dbM.getConnection();
  1547.             // istanzio il driver
  1548.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1550.             return driver.getDriverConfigurazioneDB().porteDelegateTrasformazioniRispostaHeaderList(idPortaDelegata, idTrasformazione, idTrasformazioneRisposta, ricerca);

  1552.         } catch (Exception e) {
  1553.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1554.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1555.         } finally {
  1556.             ControlStationCore.dbM.releaseConnection(con);
  1557.         }
  1558.     }
  1559.     
  1560.     public boolean existsTrasformazioneRispostaHeader(long idPorta, long idTrasformazione,  long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1561.         Connection con = null;
  1562.         String nomeMetodo = "existsTrasformazioneRispostaHeader";
  1563.         DriverControlStationDB driver = null;

  1565.         try {
  1566.             // prendo una connessione
  1567.             con = ControlStationCore.dbM.getConnection();
  1568.             // istanzio il driver
  1569.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1570.             return driver.getDriverConfigurazioneDB().existsPortaDelegataTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo);
  1571.         } catch (Exception e) {
  1572.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1573.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1574.         } finally {
  1575.             ControlStationCore.dbM.releaseConnection(con);
  1576.         }
  1577.     }
  1578.     
  1579.     public TrasformazioneRegolaParametro getTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1580.         Connection con = null;
  1581.         String nomeMetodo = "getTrasformazioneRispostaHeader";
  1582.         DriverControlStationDB driver = null;

  1584.         try {
  1585.             // prendo una connessione
  1586.             con = ControlStationCore.dbM.getConnection();
  1587.             // istanzio il driver
  1588.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1589.             return driver.getDriverConfigurazioneDB().getPortaDelegataTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo);
  1590.         } catch (Exception e) {
  1591.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1592.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1593.         } finally {
  1594.             ControlStationCore.dbM.releaseConnection(con);
  1595.         }
  1596.     }
  1597.     
  1598.     public List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRichiestaHeaderList(long idPortaDelegata, long idTrasformazione,  ISearch ricerca) throws DriverConfigurazioneException {
  1599.         Connection con = null;
  1600.         String nomeMetodo = "porteDelegateTrasformazioniRichiestaHeaderList";
  1601.         DriverControlStationDB driver = null;

  1603.         try {
  1604.             // prendo una connessione
  1605.             con = ControlStationCore.dbM.getConnection();
  1606.             // istanzio il driver
  1607.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1609.             return driver.getDriverConfigurazioneDB().porteDelegateTrasformazioniRichiestaHeaderList(idPortaDelegata, idTrasformazione, ricerca);

  1611.         } catch (Exception e) {
  1612.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1613.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1614.         } finally {
  1615.             ControlStationCore.dbM.releaseConnection(con);
  1616.         }
  1617.     }
  1618.     
  1619.     public List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRichiestaUrlParameterList(long idPortaDelegata, long idTrasformazione,  ISearch ricerca) throws DriverConfigurazioneException {
  1620.         Connection con = null;
  1621.         String nomeMetodo = "porteDelegateTrasformazioniRichiestaUrlParameterList";
  1622.         DriverControlStationDB driver = null;

  1624.         try {
  1625.             // prendo una connessione
  1626.             con = ControlStationCore.dbM.getConnection();
  1627.             // istanzio il driver
  1628.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1630.             return driver.getDriverConfigurazioneDB().porteDelegateTrasformazioniRichiestaUrlParameterList(idPortaDelegata, idTrasformazione, ricerca);

  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 boolean existsTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1641.         Connection con = null;
  1642.         String nomeMetodo = "existsTrasformazioneRichiestaHeader";
  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().existsPortaDelegataTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
  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 TrasformazioneRegolaParametro getTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1660.         Connection con = null;
  1661.         String nomeMetodo = "getTrasformazioneRichiestaHeader";
  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().getPortaDelegataTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
  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 boolean existsTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1679.         Connection con = null;
  1680.         String nomeMetodo = "existsTrasformazioneRichiestaUrlParameter";
  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);
  1688.             return driver.getDriverConfigurazioneDB().existsPortaDelegataTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
  1689.         } catch (Exception e) {
  1690.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1691.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1692.         } finally {
  1693.             ControlStationCore.dbM.releaseConnection(con);
  1694.         }
  1695.     }
  1696.     
  1697.     public TrasformazioneRegolaParametro getTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException{
  1698.         Connection con = null;
  1699.         String nomeMetodo = "getTrasformazioneRichiestaUrlParameter";
  1700.         DriverControlStationDB driver = null;

  1702.         try {
  1703.             // prendo una connessione
  1704.             con = ControlStationCore.dbM.getConnection();
  1705.             // istanzio il driver
  1706.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1707.             return driver.getDriverConfigurazioneDB().getPortaDelegataTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
  1708.         } catch (Exception e) {
  1709.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1710.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1711.         } finally {
  1712.             ControlStationCore.dbM.releaseConnection(con);
  1713.         }
  1714.     }
  1715.     
  1716.     public List<TrasformazioneRegolaApplicabilitaServizioApplicativo> porteDelegateTrasformazioniServiziApplicativiAutorizzatiList(long idPortaApplicativa, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
  1717.         Connection con = null;
  1718.         String nomeMetodo = "porteDelegateTrasformazioniServiziApplicativiAutorizzatiList";
  1719.         DriverControlStationDB driver = null;

  1721.         try {
  1722.             // prendo una connessione
  1723.             con = ControlStationCore.dbM.getConnection();
  1724.             // istanzio il driver
  1725.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1727.             return driver.getDriverConfigurazioneDB().porteDelegateTrasformazioniServiziApplicativiList(idPortaApplicativa, idTrasformazione, ricerca);

  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.         }

  1736.     }
  1737.     
  1738.     public List<Proprieta> porteDelegateAutenticazioneCustomPropList(long idPortaDelegata, ConsoleSearch ricerca) throws DriverConfigurazioneException {
  1739.         Connection con = null;
  1740.         String nomeMetodo = "porteDelegateAutenticazioneCustomPropList";
  1741.         DriverControlStationDB driver = null;

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

  1749.             return driver.getDriverConfigurazioneDB().porteDelegateAutenticazioneCustomPropList(idPortaDelegata, ricerca); 

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

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

  1770.             return driver.getDriverConfigurazioneDB().porteDelegateAutorizzazioneCustomPropList(idPortaDelegata, ricerca); 

  1772.         } catch (Exception e) {
  1773.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1774.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1775.         } finally {
  1776.             ControlStationCore.dbM.releaseConnection(con);
  1777.         }
  1778.     }
  1779.     
  1780.     public List<Proprieta> porteDelegateAutorizzazioneContenutoCustomPropList(long idPortaDelegata, ConsoleSearch ricerca) throws DriverConfigurazioneException {
  1781.         Connection con = null;
  1782.         String nomeMetodo = "porteDelegateAutorizzazioneContenutoCustomPropList";
  1783.         DriverControlStationDB driver = null;

  1785.         try {
  1786.             // prendo una connessione
  1787.             con = ControlStationCore.dbM.getConnection();
  1788.             // istanzio il driver
  1789.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1791.             return driver.getDriverConfigurazioneDB().porteDelegateAutorizzazioneContenutoCustomPropList(idPortaDelegata, ricerca); 

  1793.         } catch (Exception e) {
  1794.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1795.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1796.         } finally {
  1797.             ControlStationCore.dbM.releaseConnection(con);
  1798.         }
  1799.     }
  1800. }
Created with JaCoCo 0.8.8.202204050719