ConfigIntegrationReader.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.  */

  21. package org.openspcoop2.protocol.basic.registry;

  23. import java.sql.Connection;
  24. import java.util.ArrayList;
  25. import java.util.List;

  27. import org.apache.commons.lang.StringUtils;
  28. import org.openspcoop2.core.allarmi.Allarme;
  29. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  30. import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
  31. import org.openspcoop2.core.commons.Liste;
  32. import org.openspcoop2.core.commons.Search;
  33. import org.openspcoop2.core.config.CanaliConfigurazione;
  34. import org.openspcoop2.core.config.ConfigurazioneMultitenant;
  35. import org.openspcoop2.core.config.GenericProperties;
  36. import org.openspcoop2.core.config.PortaApplicativa;
  37. import org.openspcoop2.core.config.PortaDelegata;
  38. import org.openspcoop2.core.config.Proprieta;
  39. import org.openspcoop2.core.config.ServizioApplicativo;
  40. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  41. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  42. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  45. import org.openspcoop2.core.config.driver.IDriverConfigurazioneCRUD;
  46. import org.openspcoop2.core.config.driver.IDriverConfigurazioneGet;
  47. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  48. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  49. import org.openspcoop2.core.constants.CostantiDB;
  50. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  51. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  52. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  53. import org.openspcoop2.core.id.IDPortaApplicativa;
  54. import org.openspcoop2.core.id.IDPortaDelegata;
  55. import org.openspcoop2.core.id.IDServizio;
  56. import org.openspcoop2.core.id.IDServizioApplicativo;
  57. import org.openspcoop2.core.id.IDSoggetto;
  58. import org.openspcoop2.core.mapping.DBMappingUtils;
  59. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  60. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  61. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  62. import org.openspcoop2.protocol.sdk.ProtocolException;
  63. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  64. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReaderInUso;
  65. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaPorteApplicative;
  66. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaPorteDelegate;
  67. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaServiziApplicativi;
  68. import org.openspcoop2.protocol.sdk.registry.RegistryException;
  69. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  70. import org.openspcoop2.utils.certificate.CertificateInfo;
  71. import org.openspcoop2.utils.crypt.CryptConfig;
  72. import org.openspcoop2.utils.resources.Loader;
  73. import org.slf4j.Logger;

  75. /**
  76.  *  ArchiveRegistryReader
  77.  *
  78.  * @author Poli Andrea (apoli@link.it)
  79.  * @author $Author$
  80.  * @version $Rev$, $Date$
  81.  */
  82. public class ConfigIntegrationReader implements IConfigIntegrationReader {

  84.     private IDriverConfigurazioneGet driverConfigurazioneGET;
  85.     private IDriverConfigurazioneCRUD driverConfigurazioneCRUD;
  86.     
  87.     private IConfigIntegrationReaderInUso inUsoDriver = null;
  88.     
  89.     private Logger log;
  90.     public ConfigIntegrationReader(IDriverConfigurazioneGet driverConfigurazione,Logger log) throws ProtocolException{
  91.         this.driverConfigurazioneGET = driverConfigurazione;
  92.         if(this.driverConfigurazioneGET instanceof IDriverConfigurazioneCRUD){
  93.             this.driverConfigurazioneCRUD = (IDriverConfigurazioneCRUD) this.driverConfigurazioneGET;
  94.         }
  95.         this.log = log;
  96.         
  97.         Loader loader = new Loader();
  98.         try {
  99.             this.inUsoDriver = (IConfigIntegrationReaderInUso) loader.newInstance("org.openspcoop2.protocol.engine.registry.ConfigIntegrationReaderInUso");
  100.         }catch(Exception e) {
  101.             throw new ProtocolException(e.getMessage(),e);
  102.         }
  103.         this.inUsoDriver.init(this.driverConfigurazioneGET, log);
  104.     }
  105.     
  106.     private static final String NOT_IMPLEMENTED = "Not Implemented";

  108.     
  109.     // SERVIZI APPLICATIVI
  110.     
  111.     @Override
  112.     public boolean existsServizioApplicativo(IDServizioApplicativo idServizioApplicativo) {
  113.         try{
  114.             if(this.driverConfigurazioneCRUD!=null){
  115.                 return this.driverConfigurazioneCRUD.existsServizioApplicativo(idServizioApplicativo);
  116.             }
  117.             else{
  118.                 return this.driverConfigurazioneGET.getServizioApplicativo(idServizioApplicativo)!=null;
  119.             }
  120.         }catch(Exception e){
  121.             return false;
  122.         }
  123.     }
  124.     
  125.     @Override
  126.     public boolean existsServizioApplicativoByCredenzialiBasic(String username, String password, CryptConfig config){
  127.         try{
  128.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiBasic(username, password, config)!=null;
  129.         }catch(Exception e){
  130.             return false;
  131.         }
  132.     }
  133.     
  134.     @Override
  135.     public ServizioApplicativo getServizioApplicativoByCredenzialiBasic(String username, String password, CryptConfig config) throws RegistryNotFound,RegistryException{
  136.         try{
  137.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiBasic(username, password, config);
  138.         } catch (DriverConfigurazioneNotFound de) {
  139.             throw new RegistryNotFound(de.getMessage(),de);
  140.         }catch(Exception e){
  141.             throw new RegistryException(e.getMessage(),e);
  142.         }
  143.     }
  144.     
  145.     @Override
  146.     public boolean existsServizioApplicativoByCredenzialiSsl(String subject, String issuer){
  147.         try{
  148.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiSsl(subject, issuer)!=null;
  149.         }catch(Exception e){
  150.             return false;
  151.         }   
  152.     }
  153.     
  154.     @Override
  155.     public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String subject, String issuer) throws RegistryNotFound,RegistryException{
  156.         try{
  157.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiSsl(subject, issuer);
  158.         } catch (DriverConfigurazioneNotFound de) {
  159.             throw new RegistryNotFound(de.getMessage(),de);
  160.         }catch(Exception e){
  161.             throw new RegistryException(e.getMessage(),e);
  162.         }
  163.     }
  164.     
  165.     @Override
  166.     public boolean existsServizioApplicativoByCredenzialiSsl(String subject, String issuer,
  167.             List<String> tipiSoggetto, 
  168.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) {
  169.         try{
  170.             return this.getServizioApplicativoByCredenzialiSsl(subject, issuer,
  171.                     tipiSoggetto, 
  172.                     includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni)!=null;
  173.         }catch(Exception e){
  174.             return false;
  175.         }   
  176.     }
  177.     @Override
  178.     public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String subject, String issuer,
  179.             List<String> tipiSoggetto, 
  180.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws RegistryNotFound,RegistryException{
  181.         try{
  182.             if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  183.                 return ((DriverConfigurazioneDB)this.driverConfigurazioneGET).getServizioApplicativoByCredenzialiSsl(subject, issuer,
  184.                         tipiSoggetto, 
  185.                         includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  186.             }
  187.             else {
  188.                 throw new RegistryException("Unsupported");
  189.             }
  190.         } catch (DriverConfigurazioneNotFound de) {
  191.             throw new RegistryNotFound(de.getMessage(),de);
  192.         }catch(Exception e){
  193.             throw new RegistryException(e.getMessage(),e);
  194.         }
  195.     }
  196.     
  197.     @Override
  198.     public boolean existsServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier){
  199.         try{
  200.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier)!=null;
  201.         }catch(Exception e){
  202.             return false;
  203.         }   
  204.     }
  205.     
  206.     @Override
  207.     public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier) throws RegistryNotFound,RegistryException{
  208.         try{
  209.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier);
  210.         } catch (DriverConfigurazioneNotFound de) {
  211.             throw new RegistryNotFound(de.getMessage(),de);
  212.         }catch(Exception e){
  213.             throw new RegistryException(e.getMessage(),e);
  214.         }
  215.     }
  216.     
  217.     @Override
  218.     public boolean existsServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier,
  219.             List<String> tipiSoggetto, 
  220.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) {
  221.         try{
  222.             return this.getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier,
  223.                     tipiSoggetto, 
  224.                     includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni)!=null;
  225.         }catch(Exception e){
  226.             return false;
  227.         }   
  228.     }
  229.     @Override
  230.     public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier,
  231.             List<String> tipiSoggetto, 
  232.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws RegistryNotFound,RegistryException{
  233.         try{
  234.             if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  235.                 return ((DriverConfigurazioneDB)this.driverConfigurazioneGET).getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier);
  236.             }
  237.             else {
  238.                 throw new RegistryException("Unsupported");
  239.             }
  240.         } catch (DriverConfigurazioneNotFound de) {
  241.             throw new RegistryNotFound(de.getMessage(),de);
  242.         }catch(Exception e){
  243.             throw new RegistryException(e.getMessage(),e);
  244.         }
  245.     }
  246.     
  247.     @Override
  248.     public boolean existsServizioApplicativoByCredenzialiPrincipal(String principal){
  249.         try{
  250.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiPrincipal(principal)!=null;
  251.         }catch(Exception e){
  252.             return false;
  253.         }   
  254.     }
  255.     
  256.     @Override
  257.     public ServizioApplicativo getServizioApplicativoByCredenzialiPrincipal(String principal) throws RegistryNotFound,RegistryException{
  258.         try{
  259.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiPrincipal(principal);
  260.         } catch (DriverConfigurazioneNotFound de) {
  261.             throw new RegistryNotFound(de.getMessage(),de);
  262.         }catch(Exception e){
  263.             throw new RegistryException(e.getMessage(),e);
  264.         }
  265.     }
  266.     
  267.     @Override
  268.     public boolean existsServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) {
  269.         try{
  270.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiToken(tokenPolicy, tokenClientId, tokenWithHttpsEnabled)!=null;
  271.         }catch(Exception e){
  272.             return false;
  273.         }
  274.     }
  275.     
  276.     @Override
  277.     public ServizioApplicativo getServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) throws RegistryNotFound,RegistryException{
  278.         try{
  279.             return this.driverConfigurazioneGET.getServizioApplicativoByCredenzialiToken(tokenPolicy, tokenClientId, tokenWithHttpsEnabled);
  280.         } catch (DriverConfigurazioneNotFound de) {
  281.             throw new RegistryNotFound(de.getMessage(),de);
  282.         }catch(Exception e){
  283.             throw new RegistryException(e.getMessage(),e);
  284.         }
  285.     }
  286.     
  287.     @Override
  288.     public ServizioApplicativo getServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws RegistryNotFound,RegistryException{
  289.         try{
  290.             return this.driverConfigurazioneGET.getServizioApplicativo(idServizioApplicativo);
  291.         } catch (DriverConfigurazioneNotFound de) {
  292.             throw new RegistryNotFound(de.getMessage(),de);
  293.         }catch(Exception e){
  294.             throw new RegistryException(e.getMessage(),e);
  295.         }
  296.     }
  297.         
  298.     @Override
  299.     public List<IDServizioApplicativo> findIdServiziApplicativi(ProtocolFiltroRicercaServiziApplicativi filtroRicerca) throws RegistryNotFound,RegistryException{
  300.         try{
  301.             return this.driverConfigurazioneGET.getAllIdServiziApplicativi(filtroRicerca);
  302.         } catch (DriverConfigurazioneNotFound de) {
  303.             throw new RegistryNotFound(de.getMessage(),de);
  304.         }catch(Exception e){
  305.             throw new RegistryException(e.getMessage(),e);
  306.         }
  307.     }
  308.     
  309.     @Override
  310.     public List<IDServizioApplicativo> findIdServiziApplicativiByPaAuth(PortaApplicativa pa, boolean authToken, boolean authTrasporto) throws RegistryNotFound,RegistryException{
  311.         try{
  312.             if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  313.                 IDSoggetto idSoggetto = new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario());
  314.                 String superuser = null;
  315.                 
  316.                 boolean returnAll = false;
  317.                 
  318.                 boolean bothSslAndToken = false;
  319.                 String tokenPolicy = null;
  320.                 boolean tokenPolicyOR = false;
  321.                 if(pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null) {
  322.                     tokenPolicy = pa.getGestioneToken().getPolicy();
  323.                 }
  324.                 
  325.                 // find by credenziali trasporto        
  326.                 List<IDServizioApplicativo> ltrasporto = null;
  327.                 if(authTrasporto) {
  328.                     if(pa.getAutenticazione()!=null && StringUtils.isNotEmpty(pa.getAutenticazione())) {
  329.                         TipoAutenticazione auth = TipoAutenticazione.toEnumConstant(pa.getAutenticazione(), false);
  330.                         if(auth==null || TipoAutenticazione.DISABILITATO.equals(auth)) {
  331.                             returnAll = true;
  332.                         }
  333.                     }
  334.                     if(returnAll) {
  335.                         return findIdServiziApplicativiByAuthTrasporto(idSoggetto, returnAll, pa.getAutenticazione(), tokenPolicy, pa.getProprietaAutenticazione()); 
  336.                     }
  337.                     else {
  338.                         ltrasporto = findIdServiziApplicativiByAuthTrasporto(idSoggetto, returnAll, pa.getAutenticazione(), tokenPolicy, pa.getProprietaAutenticazione());
  339.                     }
  340.                 }
  341.                 
  342.                 // find by token
  343.                 List<IDServizioApplicativoDB> ltoken = null;
  344.                 if(authToken &&
  345.                     tokenPolicy!=null) {
  346.                     ltoken = ((DriverConfigurazioneDB)this.driverConfigurazioneGET).soggettiServizioApplicativoList(idSoggetto,superuser, CredenzialeTipo.TOKEN, 
  347.                             false, CostantiConfigurazione.CLIENT, 
  348.                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  349.                 }

  351.                 List<IDServizioApplicativo> lSA = new ArrayList<>();
  352.                 List<String> nomi = new ArrayList<>();
  353.                 if(ltrasporto!=null && !ltrasporto.isEmpty()) {
  354.                     for (IDServizioApplicativo idSADB : ltrasporto) {
  355.                         lSA.add(idSADB);
  356.                         nomi.add(idSADB.getNome());
  357.                     }
  358.                 }
  359.                 if(ltoken!=null && !ltoken.isEmpty()) {
  360.                     for (IDServizioApplicativoDB idSADB : ltoken) {
  361.                         if(!nomi.contains(idSADB.getNome())) {
  362.                             lSA.add(idSADB);
  363.                             nomi.add(idSADB.getNome());
  364.                         }
  365.                     }
  366.                 }
  367.                 if(lSA.isEmpty()) {
  368.                     throw new RegistryNotFound("Servizi applicativi non trovati");
  369.                 }
  370.                 return lSA;
  371.             }
  372.             else {
  373.                 throw new RegistryException("Unsupported");
  374.             }
  375.         }
  376.         catch (RegistryNotFound notFound) {
  377.             throw notFound;
  378.         }
  379.         catch(Exception e){
  380.             throw new RegistryException(e.getMessage(),e);
  381.         }
  382.     }
  383.     
  384.     @Override
  385.     public List<IDServizioApplicativo> findIdServiziApplicativiByPdAuth(PortaDelegata pd, boolean authToken, boolean authTrasporto) throws RegistryNotFound,RegistryException{
  386.         try{
  387.             if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  388.                 IDSoggetto idSoggetto = new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario());
  389.                 String superuser = null;
  390.                 
  391.                 boolean returnAll = false;
  392.                 
  393.                 boolean bothSslAndToken = false;
  394.                 String tokenPolicy = null;
  395.                 boolean tokenPolicyOR = false;
  396.                 if(pd.getGestioneToken()!=null && pd.getGestioneToken().getPolicy()!=null) {
  397.                     tokenPolicy = pd.getGestioneToken().getPolicy();
  398.                 }
  399.                 
  400.                 // find by credenziali trasporto        
  401.                 List<IDServizioApplicativo> ltrasporto = null;
  402.                 if(authTrasporto) {
  403.                     if(pd.getAutenticazione()!=null && StringUtils.isNotEmpty(pd.getAutenticazione())) {
  404.                         TipoAutenticazione auth = TipoAutenticazione.toEnumConstant(pd.getAutenticazione(), false);
  405.                         if(auth==null || TipoAutenticazione.DISABILITATO.equals(auth)) {
  406.                             returnAll = true;
  407.                         }
  408.                     }
  409.                     if(returnAll) {
  410.                         return findIdServiziApplicativiByAuthTrasporto(idSoggetto, returnAll, pd.getAutenticazione(), tokenPolicy, pd.getProprietaAutenticazione()); 
  411.                     }
  412.                     else {
  413.                         ltrasporto = findIdServiziApplicativiByAuthTrasporto(idSoggetto, returnAll, pd.getAutenticazione(), tokenPolicy, pd.getProprietaAutenticazione());
  414.                     }
  415.                 }
  416.                 
  417.                 // find by token
  418.                 List<IDServizioApplicativoDB> ltoken = null;
  419.                 if(authToken &&
  420.                     tokenPolicy!=null) {
  421.                     ltoken = ((DriverConfigurazioneDB)this.driverConfigurazioneGET).soggettiServizioApplicativoList(idSoggetto,superuser, CredenzialeTipo.TOKEN, 
  422.                             false, CostantiConfigurazione.CLIENT, 
  423.                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  424.                 }

  426.                 List<IDServizioApplicativo> lSA = new ArrayList<>();
  427.                 List<String> nomi = new ArrayList<>();
  428.                 if(ltrasporto!=null && !ltrasporto.isEmpty()) {
  429.                     for (IDServizioApplicativo idSADB : ltrasporto) {
  430.                         lSA.add(idSADB);
  431.                         nomi.add(idSADB.getNome());
  432.                     }
  433.                 }
  434.                 if(ltoken!=null && !ltoken.isEmpty()) {
  435.                     for (IDServizioApplicativoDB idSADB : ltoken) {
  436.                         if(!nomi.contains(idSADB.getNome())) {
  437.                             lSA.add(idSADB);
  438.                             nomi.add(idSADB.getNome());
  439.                         }
  440.                     }
  441.                 }
  442.                 if(lSA.isEmpty()) {
  443.                     throw new RegistryNotFound("Servizi applicativi non trovati");
  444.                 }
  445.                 return lSA;
  446.             }
  447.             else {
  448.                 throw new RegistryException("Unsupported");
  449.             }
  450.         }
  451.         catch (RegistryNotFound notFound) {
  452.             throw notFound;
  453.         }
  454.         catch(Exception e){
  455.             throw new RegistryException(e.getMessage(),e);
  456.         }
  457.     }
  458.     private List<IDServizioApplicativo> findIdServiziApplicativiByAuthTrasporto(IDSoggetto idSoggetto, boolean returnAll, String autenticazione, String tokenPolicy, List<Proprieta> listProprietaAutenticazione) throws RegistryNotFound, RegistryException, DriverConfigurazioneException{
  459.         // find by credenziali trasporto
  460.         if(returnAll) {
  461.             ProtocolFiltroRicercaServiziApplicativi f = new ProtocolFiltroRicercaServiziApplicativi();
  462.             f.setTipoSoggetto(idSoggetto.getTipo());
  463.             f.setNomeSoggetto(idSoggetto.getNome());
  464.             f.setTipo(CostantiConfigurazione.CLIENT);
  465.             return this.findIdServiziApplicativi(f);
  466.         }
  467.         else {
  468.             Boolean appId = null;
  469.             CredenzialeTipo tipoAutenticazione = CredenzialeTipo.toEnumConstant(autenticazione);
  470.             if(CredenzialeTipo.APIKEY.equals(tipoAutenticazione) && listProprietaAutenticazione!=null && !listProprietaAutenticazione.isEmpty()) {
  471.                 for (Proprieta proprieta : listProprietaAutenticazione) {
  472.                     if("appId".equals(proprieta.getNome())) {
  473.                         appId = "true".equals(proprieta.getValore());
  474.                         break;
  475.                     }
  476.                 }
  477.             }
  478.             boolean bothSslAndToken = false;
  479.             boolean tokenPolicyOR = false;
  480.             List<IDServizioApplicativoDB> ltrasporto = ((DriverConfigurazioneDB)this.driverConfigurazioneGET).soggettiServizioApplicativoList(idSoggetto,null,tipoAutenticazione, 
  481.                     appId, CostantiConfigurazione.CLIENT, 
  482.                     bothSslAndToken, tokenPolicy, tokenPolicyOR);
  483.             List<IDServizioApplicativo> lSA = new ArrayList<>();
  484.             for (IDServizioApplicativoDB idSADB : ltrasporto) {
  485.                 lSA.add(idSADB);
  486.             }
  487.             return lSA;
  488.         }
  489.         
  490.     }
  491.     
  492.     @Override
  493.     public boolean inUso(IDServizioApplicativo idServizioApplicativo, boolean verificaRuoli) throws RegistryException{
  494.         return this.inUsoDriver.inUso(idServizioApplicativo, verificaRuoli);
  495.     }
  496.     
  497.     @Override
  498.     public String getDettagliInUso(IDServizioApplicativo idServizioApplicativo, boolean verificaRuoli) throws RegistryException{
  499.         return this.inUsoDriver.getDettagliInUso(idServizioApplicativo, verificaRuoli);
  500.     }
  501.     
  502.     
  503.     
  504.     
  505.     // PORTA DELEGATA
  506.     
  507.     @Override
  508.     public IDPortaDelegata getIdPortaDelegata(String nome, IProtocolFactory<?> protocolFactory) throws RegistryNotFound,RegistryException{
  509.         
  510.         try{
  511.             return this.driverConfigurazioneGET.getIDPortaDelegata(nome);
  512.         } catch (DriverConfigurazioneNotFound de) {
  513.             throw new RegistryNotFound(de.getMessage(),de);
  514.         }catch(Exception e){
  515.             throw new RegistryException(e.getMessage(),e);
  516.         }

  518.     }
  519.     
  520.     @Override
  521.     public boolean existsPortaDelegata(IDPortaDelegata idPortaDelegata){
  522.         try{
  523.             if(this.driverConfigurazioneCRUD!=null){
  524.                 return this.driverConfigurazioneCRUD.existsPortaDelegata(idPortaDelegata);
  525.             }
  526.             else{
  527.                 return this.driverConfigurazioneGET.getPortaDelegata(idPortaDelegata)!=null;
  528.             }
  529.         }catch(Exception e){
  530.             return false;
  531.         }   
  532.     }
  533.     
  534.     @Override
  535.     public PortaDelegata getPortaDelegata(IDPortaDelegata idPortaDelegata) throws RegistryNotFound,RegistryException{
  536.         try{
  537.             return this.driverConfigurazioneGET.getPortaDelegata(idPortaDelegata);
  538.         } catch (DriverConfigurazioneNotFound de) {
  539.             throw new RegistryNotFound(de.getMessage(),de);
  540.         }catch(Exception e){
  541.             throw new RegistryException(e.getMessage(),e);
  542.         }
  543.     }
  544.     
  545.     @Override
  546.     public List<IDPortaDelegata> findIdPorteDelegate(ProtocolFiltroRicercaPorteDelegate filtroRicerca) throws RegistryNotFound,RegistryException{
  547.         try{
  548.             return this.driverConfigurazioneGET.getAllIdPorteDelegate(filtroRicerca);
  549.         } catch (DriverConfigurazioneNotFound de) {
  550.             throw new RegistryNotFound(de.getMessage(),de);
  551.         }catch(Exception e){
  552.             throw new RegistryException(e.getMessage(),e);
  553.         }
  554.     }
  555.     
  556.     @Override
  557.     public List<AttivazionePolicy> getRateLimitingPolicy(IDPortaDelegata idPortaDelegata) throws RegistryNotFound,RegistryException{
  558.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  559.             
  560.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  561.             Connection con = null;
  562.             try {
  563.                 con = driver.getConnection("getRateLimitingPolicy(portaDelegata)");
  564.                 
  565.                 org.openspcoop2.core.commons.Search search = new Search(true);
  566.                 return ControlloTrafficoDriverUtils.configurazioneControlloTrafficoAttivazionePolicyList(search, RuoloPolicy.DELEGATA, idPortaDelegata.getNome(),
  567.                         con, this.log, driver.getTipoDB());
  568.                 
  569.             }
  570.             catch(Exception e) {
  571.                 throw new RegistryException(e.getMessage(),e);
  572.             }
  573.             finally {
  574.                 try {
  575.                     if(con!=null) {
  576.                         driver.releaseConnection(con);
  577.                     }
  578.                 }catch(Exception eClose) {
  579.                     // close
  580.                 }
  581.             }
  582.             
  583.         }
  584.         else {
  585.             throw new RegistryException(NOT_IMPLEMENTED);
  586.         }
  587.     }
  588.     
  589.     @Override
  590.     public List<Allarme> getAllarmi(IDPortaDelegata idPortaDelegata) throws RegistryNotFound,RegistryException{
  591.         if(!CostantiDB.isAllarmiEnabled()) {
  592.             return new ArrayList<>();
  593.         }
  594.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  595.             
  596.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  597.             Connection con = null;
  598.             try {
  599.                 con = driver.getConnection("getAllarmi(portaDelegata)");
  600.                 
  601.                 org.openspcoop2.core.commons.Search search = new Search(true);
  602.                 return AllarmiDriverUtils.allarmiList(search, RuoloPorta.DELEGATA, idPortaDelegata.getNome(),
  603.                         con, this.log, driver.getTipoDB());
  604.                 
  605.             }
  606.             catch(Exception e) {
  607.                 throw new RegistryException(e.getMessage(),e);
  608.             }
  609.             finally {
  610.                 try {
  611.                     if(con!=null) {
  612.                         driver.releaseConnection(con);
  613.                     }
  614.                 }catch(Exception eClose) {
  615.                     // close
  616.                 }
  617.             }
  618.             
  619.         }
  620.         else {
  621.             throw new RegistryException(NOT_IMPLEMENTED);
  622.         }
  623.     }
  624.     
  625.     @Override
  626.     public List<MappingFruizionePortaDelegata> getMappingFruizionePortaDelegataList(IDSoggetto idFruitore, IDServizio idServizio) throws RegistryException{
  627.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  628.             
  629.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  630.             Connection con = null;
  631.             try {
  632.                 con = driver.getConnection("getMappingFruizionePortaDelegataList");
  633.                 
  634.                 return DBMappingUtils.mappingFruizionePortaDelegataList(con, driver.getTipoDB(), idFruitore, idServizio, false);
  635.                 
  636.             }
  637.             catch(Exception e) {
  638.                 throw new RegistryException(e.getMessage(),e);
  639.             }
  640.             finally {
  641.                 try {
  642.                     if(con!=null) {
  643.                         driver.releaseConnection(con);
  644.                     }
  645.                 }catch(Exception eClose) {
  646.                     // close
  647.                 }
  648.             }
  649.             
  650.         }
  651.         else {
  652.             throw new RegistryException(NOT_IMPLEMENTED);
  653.         }
  654.     }
  655.         
  656.     
  657.     
  658.     
  659.     
  660.         
  661.     // PORTA APPLICATIVA
  662.         
  663.     @Override
  664.     public IDPortaApplicativa getIdPortaApplicativa(String nome, IProtocolFactory<?> protocolFactory) throws RegistryNotFound,RegistryException{
  665.         
  666.         try{
  667.             return this.driverConfigurazioneGET.getIDPortaApplicativa(nome);
  668.         } catch (DriverConfigurazioneNotFound de) {
  669.             throw new RegistryNotFound(de.getMessage(),de);
  670.         }catch(Exception e){
  671.             throw new RegistryException(e.getMessage(),e);
  672.         }

  674.     }
  675.         
  676.     @Override
  677.     public boolean existsPortaApplicativa(IDPortaApplicativa idPortaApplicativa){
  678.         try{
  679.             if(this.driverConfigurazioneCRUD!=null){
  680.                 return this.driverConfigurazioneCRUD.existsPortaApplicativa(idPortaApplicativa);
  681.             }
  682.             else{
  683.                 return this.driverConfigurazioneGET.getPortaApplicativa(idPortaApplicativa)!=null;
  684.             }
  685.         }catch(Exception e){
  686.             return false;
  687.         }   
  688.     }
  689.     
  690.     @Override
  691.     public PortaApplicativa getPortaApplicativa(IDPortaApplicativa idPortaApplicativa) throws RegistryNotFound,RegistryException{
  692.         try{
  693.             return this.driverConfigurazioneGET.getPortaApplicativa(idPortaApplicativa);
  694.         } catch (DriverConfigurazioneNotFound de) {
  695.             throw new RegistryNotFound(de.getMessage(),de);
  696.         }catch(Exception e){
  697.             throw new RegistryException(e.getMessage(),e);
  698.         }
  699.     }
  700.     
  701.     @Override
  702.     public List<IDPortaApplicativa> findIdPorteApplicative(ProtocolFiltroRicercaPorteApplicative filtroRicerca) throws RegistryNotFound,RegistryException{
  703.         try{
  704.             return this.driverConfigurazioneGET.getAllIdPorteApplicative(filtroRicerca);
  705.         } catch (DriverConfigurazioneNotFound de) {
  706.             throw new RegistryNotFound(de.getMessage(),de);
  707.         }catch(Exception e){
  708.             throw new RegistryException(e.getMessage(),e);
  709.         }
  710.     }
  711.     
  712.     
  713.     @Override
  714.     public List<AttivazionePolicy> getRateLimitingPolicy(IDPortaApplicativa idPortaApplicativa) throws RegistryNotFound,RegistryException{
  715.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  716.             
  717.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  718.             Connection con = null;
  719.             try {
  720.                 con = driver.getConnection("getRateLimitingPolicy(portaApplicativa)");
  721.                 
  722.                 org.openspcoop2.core.commons.Search search = new Search(true);
  723.                 return ControlloTrafficoDriverUtils.configurazioneControlloTrafficoAttivazionePolicyList(search, RuoloPolicy.APPLICATIVA, idPortaApplicativa.getNome(),
  724.                         con, this.log, driver.getTipoDB());
  725.                 
  726.             }
  727.             catch(Exception e) {
  728.                 throw new RegistryException(e.getMessage(),e);
  729.             }
  730.             finally {
  731.                 try {
  732.                     if(con!=null) {
  733.                         driver.releaseConnection(con);
  734.                     }
  735.                 }catch(Exception eClose) {
  736.                     // close
  737.                 }
  738.             }
  739.             
  740.         }
  741.         else {
  742.             throw new RegistryException(NOT_IMPLEMENTED);
  743.         }
  744.     }
  745.     
  746.     @Override
  747.     public List<Allarme> getAllarmi(IDPortaApplicativa idPortaApplicativa) throws RegistryNotFound,RegistryException{
  748.         if(!CostantiDB.isAllarmiEnabled()) {
  749.             return new ArrayList<>();
  750.         }
  751.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  752.             
  753.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  754.             Connection con = null;
  755.             try {
  756.                 con = driver.getConnection("getAllarmi(portaApplicativa)");
  757.                 
  758.                 org.openspcoop2.core.commons.Search search = new Search(true);
  759.                 return AllarmiDriverUtils.allarmiList(search, RuoloPorta.APPLICATIVA, idPortaApplicativa.getNome(),
  760.                         con, this.log, driver.getTipoDB());
  761.                 
  762.             }
  763.             catch(Exception e) {
  764.                 throw new RegistryException(e.getMessage(),e);
  765.             }
  766.             finally {
  767.                 try {
  768.                     if(con!=null) {
  769.                         driver.releaseConnection(con);
  770.                     }
  771.                 }catch(Exception eClose) {
  772.                     // close
  773.                 }
  774.             }
  775.             
  776.         }
  777.         else {
  778.             throw new RegistryException(NOT_IMPLEMENTED);
  779.         }
  780.     }
  781.     
  782.     @Override
  783.     public List<MappingErogazionePortaApplicativa> getMappingErogazionePortaApplicativaList(IDServizio idServizio) throws RegistryException{
  784.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  785.             
  786.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  787.             Connection con = null;
  788.             try {
  789.                 con = driver.getConnection("getMappingErogazionePortaApplicativaList");
  790.                 
  791.                 return DBMappingUtils.mappingErogazionePortaApplicativaList(con, driver.getTipoDB(), idServizio, false);
  792.                 
  793.             }
  794.             catch(Exception e) {
  795.                 throw new RegistryException(e.getMessage(),e);
  796.             }
  797.             finally {
  798.                 try {
  799.                     if(con!=null) {
  800.                         driver.releaseConnection(con);
  801.                     }
  802.                 }catch(Exception eClose) {
  803.                     // close
  804.                 }
  805.             }
  806.             
  807.         }
  808.         else {
  809.             throw new RegistryException(NOT_IMPLEMENTED);
  810.         }
  811.     }
  812.     
  813.     

  815.     // CONFIGURAZIONE
  816.     
  817.     @Override
  818.     public ConfigurazioneMultitenant getConfigurazioneMultitenant() throws RegistryNotFound,RegistryException{
  819.         try{
  820.             ConfigurazioneMultitenant conf = this.driverConfigurazioneGET.getConfigurazioneGenerale().getMultitenant();
  821.             if(conf==null) {
  822.                 return new ConfigurazioneMultitenant();
  823.             }
  824.             return conf;
  825.         } catch (DriverConfigurazioneNotFound de) {
  826.             throw new RegistryNotFound(de.getMessage(),de);
  827.         }catch(Exception e){
  828.             throw new RegistryException(e.getMessage(),e);
  829.         }
  830.     }
  831.     
  832.     @Override
  833.     public CanaliConfigurazione getCanaliConfigurazione() throws RegistryNotFound,RegistryException{
  834.         try{
  835.             return this.driverConfigurazioneGET.getCanaliConfigurazione();
  836.         } catch (DriverConfigurazioneNotFound de) {
  837.             throw new RegistryNotFound(de.getMessage(),de);
  838.         }catch(Exception e){
  839.             throw new RegistryException(e.getMessage(),e);
  840.         }
  841.     }
  842.     
  843.     @Override
  844.     public List<AttivazionePolicy> getRateLimitingPolicyGlobali() throws RegistryNotFound,RegistryException{
  845.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  846.             
  847.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  848.             Connection con = null;
  849.             try {
  850.                 con = driver.getConnection("getRateLimitingPolicyGlobali");
  851.                 
  852.                 org.openspcoop2.core.commons.Search search = new Search(true);
  853.                 return ControlloTrafficoDriverUtils.configurazioneControlloTrafficoAttivazionePolicyList(search, null, null,
  854.                         con, this.log, driver.getTipoDB());
  855.                 
  856.             }
  857.             catch(Exception e) {
  858.                 throw new RegistryException(e.getMessage(),e);
  859.             }
  860.             finally {
  861.                 try {
  862.                     if(con!=null) {
  863.                         driver.releaseConnection(con);
  864.                     }
  865.                 }catch(Exception eClose) {
  866.                     // close
  867.                 }
  868.             }
  869.             
  870.         }
  871.         else {
  872.             throw new RegistryException(NOT_IMPLEMENTED);
  873.         }
  874.     }
  875.     
  876.     @Override
  877.     public String getNextPolicyInstanceSerialId(String policyId) throws RegistryException{
  878.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  879.             
  880.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  881.             Connection con = null;
  882.             try {
  883.                 con = driver.getConnection("getNextPolicyInstanceSerialId");
  884.                 
  885.                 return ControlloTrafficoDriverUtils.getNextPolicyInstanceSerialId(policyId,
  886.                         con, this.log, driver.getTipoDB());
  887.                 
  888.             }
  889.             catch(Exception e) {
  890.                 throw new RegistryException(e.getMessage(),e);
  891.             }
  892.             finally {
  893.                 try {
  894.                     if(con!=null) {
  895.                         driver.releaseConnection(con);
  896.                     }
  897.                 }catch(Exception eClose) {
  898.                     // close
  899.                 }
  900.             }
  901.             
  902.         }
  903.         else {
  904.             throw new RegistryException(NOT_IMPLEMENTED);
  905.         }
  906.     }

  908.     @Override
  909.     public List<Allarme> getAllarmiGlobali() throws RegistryNotFound,RegistryException{
  910.         if(!CostantiDB.isAllarmiEnabled()) {
  911.             return new ArrayList<>();
  912.         }
  913.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  914.             
  915.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  916.             Connection con = null;
  917.             try {
  918.                 con = driver.getConnection("getAllarmiGlobali");
  919.                 
  920.                 org.openspcoop2.core.commons.Search search = new Search(true);
  921.                 return AllarmiDriverUtils.allarmiList(search, null, null,
  922.                         con, this.log, driver.getTipoDB());
  923.                 
  924.             }
  925.             catch(Exception e) {
  926.                 throw new RegistryException(e.getMessage(),e);
  927.             }
  928.             finally {
  929.                 try {
  930.                     if(con!=null) {
  931.                         driver.releaseConnection(con);
  932.                     }
  933.                 }catch(Exception eClose) {
  934.                     // close
  935.                 }
  936.             }
  937.             
  938.         }
  939.         else {
  940.             throw new RegistryException(NOT_IMPLEMENTED);
  941.         }
  942.     }
  943.     
  944.     @Override
  945.     public String getNextAlarmInstanceSerialId(String tipoPlugin) throws RegistryException{
  946.         if(!CostantiDB.isAllarmiEnabled()) {
  947.             throw new RegistryException("Alarm not supported");
  948.         }
  949.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  950.             
  951.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  952.             Connection con = null;
  953.             try {
  954.                 con = driver.getConnection("getNextAlarmInstanceSerialId");
  955.                 
  956.                 return AllarmiDriverUtils.getNextAlarmInstanceSerialId(tipoPlugin,
  957.                         con, this.log, driver.getTipoDB());
  958.                 
  959.             }
  960.             catch(Exception e) {
  961.                 throw new RegistryException(e.getMessage(),e);
  962.             }
  963.             finally {
  964.                 try {
  965.                     if(con!=null) {
  966.                         driver.releaseConnection(con);
  967.                     }
  968.                 }catch(Exception eClose) {
  969.                     // close
  970.                 }
  971.             }
  972.             
  973.         }
  974.         else {
  975.             throw new RegistryException(NOT_IMPLEMENTED);
  976.         }
  977.     }
  978.     
  979.     @Override
  980.     public List<GenericProperties> getTokenPolicyValidazione() throws RegistryException{
  981.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  982.             
  983.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  984.             try {
  985.                 org.openspcoop2.core.commons.Search search = new Search(true);
  986.                 List<String> tipologiaList = new ArrayList<>();
  987.                 tipologiaList.add(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION);
  988.                 return driver.getGenericProperties(tipologiaList, Liste.CONFIGURAZIONE_GESTIONE_POLICY_TOKEN, search,false);
  989.             }
  990.             catch(Exception e) {
  991.                 throw new RegistryException(e.getMessage(),e);
  992.             }
  993.             
  994.         }
  995.         else {
  996.             throw new RegistryException(NOT_IMPLEMENTED);
  997.         }
  998.     }
  999.     @Override
  1000.     public GenericProperties getTokenPolicyValidazione(String nome) throws RegistryNotFound,RegistryException{
  1001.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  1002.             
  1003.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  1004.             try {
  1005.                 GenericProperties gp = driver.getGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION, nome);
  1006.                 if(gp==null) {
  1007.                     throw new DriverConfigurazioneNotFound();
  1008.                 }
  1009.                 return gp;
  1010.             } catch (DriverConfigurazioneNotFound de) {
  1011.                 throw new RegistryNotFound(de.getMessage(),de);
  1012.             }
  1013.             catch(Exception e) {
  1014.                 throw new RegistryException(e.getMessage(),e);
  1015.             }
  1016.             
  1017.         }
  1018.         else {
  1019.             throw new RegistryException(NOT_IMPLEMENTED);
  1020.         }
  1021.     }
  1022.     
  1023.     @Override
  1024.     public List<GenericProperties> getTokenPolicyNegoziazione() throws RegistryException{
  1025.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  1026.             
  1027.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  1028.             try {
  1029.                 org.openspcoop2.core.commons.Search search = new Search(true);
  1030.                 List<String> tipologiaList = new ArrayList<>();
  1031.                 tipologiaList.add(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE);
  1032.                 return driver.getGenericProperties(tipologiaList, Liste.CONFIGURAZIONE_GESTIONE_POLICY_TOKEN, search,false);
  1033.             }
  1034.             catch(Exception e) {
  1035.                 throw new RegistryException(e.getMessage(),e);
  1036.             }
  1037.             
  1038.         }
  1039.         else {
  1040.             throw new RegistryException(NOT_IMPLEMENTED);
  1041.         }
  1042.     }
  1043.     @Override
  1044.     public GenericProperties getTokenPolicyNegoziazione(String nome) throws RegistryNotFound,RegistryException{
  1045.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  1046.             
  1047.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  1048.             try {
  1049.                 GenericProperties gp = driver.getGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE, nome);
  1050.                 if(gp==null) {
  1051.                     throw new DriverConfigurazioneNotFound();
  1052.                 }
  1053.                 return gp;
  1054.             } catch (DriverConfigurazioneNotFound de) {
  1055.                 throw new RegistryNotFound(de.getMessage(),de);
  1056.             }
  1057.             catch(Exception e) {
  1058.                 throw new RegistryException(e.getMessage(),e);
  1059.             }
  1060.             
  1061.         }
  1062.         else {
  1063.             throw new RegistryException(NOT_IMPLEMENTED);
  1064.         }
  1065.     }
  1066.     
  1067.     @Override
  1068.     public List<GenericProperties> getAttributeAuthority() throws RegistryException{
  1069.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  1070.             
  1071.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  1072.             try {
  1073.                 org.openspcoop2.core.commons.Search search = new Search(true);
  1074.                 List<String> tipologiaList = new ArrayList<>();
  1075.                 tipologiaList.add(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY);
  1076.                 return driver.getGenericProperties(tipologiaList, Liste.CONFIGURAZIONE_GESTIONE_ATTRIBUTE_AUTHORITY, search,false);
  1077.             }
  1078.             catch(Exception e) {
  1079.                 throw new RegistryException(e.getMessage(),e);
  1080.             }
  1081.             
  1082.         }
  1083.         else {
  1084.             throw new RegistryException(NOT_IMPLEMENTED);
  1085.         }
  1086.     }
  1087.     @Override
  1088.     public GenericProperties getAttributeAuthority(String nome) throws RegistryNotFound,RegistryException{
  1089.         if(this.driverConfigurazioneGET instanceof DriverConfigurazioneDB) {
  1090.             
  1091.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.driverConfigurazioneGET;
  1092.             try {
  1093.                 GenericProperties gp = driver.getGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY, nome);
  1094.                 if(gp==null) {
  1095.                     throw new DriverConfigurazioneNotFound();
  1096.                 }
  1097.                 return gp;
  1098.             } catch (DriverConfigurazioneNotFound de) {
  1099.                 throw new RegistryNotFound(de.getMessage(),de);
  1100.             }
  1101.             catch(Exception e) {
  1102.                 throw new RegistryException(e.getMessage(),e);
  1103.             }
  1104.             
  1105.         }
  1106.         else {
  1107.             throw new RegistryException(NOT_IMPLEMENTED);
  1108.         }
  1109.     }

  1111. }
Created with JaCoCo 0.8.8.202204050719