AbstractArchiveEngine.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.engine.archive;

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

  28. import org.apache.commons.lang.StringUtils;
  29. import org.openspcoop2.core.allarmi.Allarme;
  30. import org.openspcoop2.core.allarmi.IdAllarme;
  31. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  32. import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
  33. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  34. import org.openspcoop2.core.config.Configurazione;
  35. import org.openspcoop2.core.config.ConfigurazioneGestioneErrore;
  36. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  37. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  38. import org.openspcoop2.core.config.GenericProperties;
  39. import org.openspcoop2.core.config.GestioneErrore;
  40. import org.openspcoop2.core.config.PortaApplicativa;
  41. import org.openspcoop2.core.config.PortaDelegata;
  42. import org.openspcoop2.core.config.RegistroPlugin;
  43. import org.openspcoop2.core.config.RegistroPluginArchivio;
  44. import org.openspcoop2.core.config.RegistroPlugins;
  45. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  46. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  47. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  48. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  49. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  50. import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
  51. import org.openspcoop2.core.config.driver.FiltroRicercaSoggetti;
  52. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  53. import org.openspcoop2.core.config.utils.ConfigurazionePdDUtils;
  54. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  55. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  56. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  57. import org.openspcoop2.core.controllo_traffico.IdActivePolicy;
  58. import org.openspcoop2.core.controllo_traffico.IdPolicy;
  59. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  60. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  61. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  62. import org.openspcoop2.core.id.IDAccordo;
  63. import org.openspcoop2.core.id.IDAccordoCooperazione;
  64. import org.openspcoop2.core.id.IDGenericProperties;
  65. import org.openspcoop2.core.id.IDGruppo;
  66. import org.openspcoop2.core.id.IDPortaApplicativa;
  67. import org.openspcoop2.core.id.IDPortaDelegata;
  68. import org.openspcoop2.core.id.IDRuolo;
  69. import org.openspcoop2.core.id.IDScope;
  70. import org.openspcoop2.core.id.IDServizio;
  71. import org.openspcoop2.core.id.IDServizioApplicativo;
  72. import org.openspcoop2.core.id.IDSoggetto;
  73. import org.openspcoop2.core.mapping.DBMappingUtils;
  74. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  75. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  76. import org.openspcoop2.core.plugins.IdPlugin;
  77. import org.openspcoop2.core.plugins.Plugin;
  78. import org.openspcoop2.core.registry.AccordoCooperazione;
  79. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  80. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  81. import org.openspcoop2.core.registry.Fruitore;
  82. import org.openspcoop2.core.registry.Gruppo;
  83. import org.openspcoop2.core.registry.PortaDominio;
  84. import org.openspcoop2.core.registry.Ruolo;
  85. import org.openspcoop2.core.registry.Scope;
  86. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  87. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  88. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  89. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  90. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  91. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  92. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  93. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  94. import org.openspcoop2.core.registry.driver.ValidazioneStatoPackageException;
  95. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  96. import org.openspcoop2.generic_project.exception.NotFoundException;
  97. import org.openspcoop2.generic_project.expression.IExpression;
  98. import org.openspcoop2.generic_project.expression.IPaginatedExpression;
  99. import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
  100. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  101. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  102. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  103. import org.openspcoop2.protocol.sdk.archive.Archive;
  104. import org.openspcoop2.protocol.sdk.registry.RegistryException;
  105. import org.openspcoop2.utils.certificate.ArchiveLoader;
  106. import org.openspcoop2.utils.certificate.Certificate;
  107. import org.openspcoop2.utils.date.DateManager;
  108. import org.slf4j.Logger;

  110. /**
  111.  *  AbstractArchiveEngine
  112.  *
  113.  * @author Poli Andrea (apoli@link.it)
  114.  * @author $Author$
  115.  * @version $Rev$, $Date$
  116.  */
  117. public abstract class AbstractArchiveEngine {

  119.     private DriverRegistroServiziDB driverRegistroServizi;
  120.     public DriverRegistroServiziDB getDriverRegistroServizi() {
  121.         return this.driverRegistroServizi;
  122.     }

  124.     private DriverConfigurazioneDB driverConfigurazione;
  125.     public DriverConfigurazioneDB getDriverConfigurazione() {
  126.         return this.driverConfigurazione;
  127.     }

  129.     private org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager serviceManagerPlugins;
  130.     public org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager getServiceManagerPlugins() {
  131.         return this.serviceManagerPlugins;
  132.     }
  133.     
  134.     private org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager serviceManagerControlloTraffico;
  135.     public org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager getServiceManagerControlloTraffico() {
  136.         return this.serviceManagerControlloTraffico;
  137.     }
  138.     
  139.     private org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager serviceManagerAllarmi;
  140.     public org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager getServiceManagerAllarmi() {
  141.         return this.serviceManagerAllarmi;
  142.     }

  144.     public AbstractArchiveEngine(DriverRegistroServiziDB driverRegistroServizi,DriverConfigurazioneDB driverConfigurazione,
  145.             org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager serviceManagerPlugins,
  146.             org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager serviceManagerControlloTraffico, 
  147.             org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager serviceManagerAllarmi){
  148.         this.driverRegistroServizi = driverRegistroServizi;
  149.         this.driverConfigurazione = driverConfigurazione;
  150.         this.serviceManagerPlugins = serviceManagerPlugins;
  151.         this.serviceManagerControlloTraffico = serviceManagerControlloTraffico;
  152.         this.serviceManagerAllarmi = serviceManagerAllarmi;
  153.     }
  154.     

  156.     public void finalizeImport(Archive archive) throws DriverConfigurazioneException{
  157.         
  158.     }
  159.     public void finalizeDelete(Archive archive) throws DriverConfigurazioneException{
  160.         
  161.     }
  162.     
  163.     
  164.     // --- Users ---
  165.     
  166.     public abstract boolean isVisioneOggettiGlobale(String userLogin);
  167.     
  168.     
  169.     // --- PDD ---
  170.     
  171.     public List<String> getAllIdPorteDominio(FiltroRicerca filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  172.         return this.driverRegistroServizi.getAllIdPorteDominio(filtroRicerca);
  173.     }
  174.     
  175.     public PortaDominio getPortaDominio(String nomePortaDominio) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  176.         return this.driverRegistroServizi.getPortaDominio(nomePortaDominio);
  177.     }
  178.     
  179.     public String getTipoPortaDominio(String nomePortaDominio) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  180.         return this.driverRegistroServizi.getTipoPortaDominio(nomePortaDominio);
  181.     }
  182.     
  183.     public boolean existsPortaDominio(String nomePortaDominio) throws DriverRegistroServiziException {
  184.         return this.driverRegistroServizi.existsPortaDominio(nomePortaDominio);
  185.     }
  186.     
  187.     public void createPortaDominio(PortaDominio pdd) throws DriverRegistroServiziException {
  188.         this.driverRegistroServizi.createPortaDominio(pdd);
  189.     }
  190.     
  191.     public void updatePortaDominio(PortaDominio pdd) throws DriverRegistroServiziException {
  192.         this.driverRegistroServizi.updatePortaDominio(pdd);
  193.     }
  194.     
  195.     public void deletePortaDominio(PortaDominio pdd) throws DriverRegistroServiziException {
  196.         this.driverRegistroServizi.deletePortaDominio(pdd);
  197.     }
  198.     
  199.     public boolean isPddInUso(String nomePortaDominio, List<String> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  200.         Connection con = null;
  201.         try{
  202.             con = this.driverRegistroServizi.getConnection("archive.isPddInUso");
  203.             return DBOggettiInUsoUtils.isPddInUso(con, this.driverRegistroServizi.getTipoDB(), nomePortaDominio, whereIsInUso, normalizeObjectIds);
  204.         }
  205.         catch(Exception e){
  206.             throw new DriverRegistroServiziException(e.getMessage(),e);
  207.         }
  208.         finally{
  209.             try{
  210.                 this.driverRegistroServizi.releaseConnection(con);
  211.             }catch(Exception eClose){
  212.                 // close
  213.             }
  214.         }
  215.     }
  216.     
  217.     
  218.     
  219.     
  220.     
  221.     
  222.     
  223.     
  224.     // --- GRUPPI ---
  225.     
  226.     public List<IDGruppo> getAllIdGruppi(FiltroRicercaGruppi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  227.         return this.driverRegistroServizi.getAllIdGruppi(filtroRicerca);
  228.     }
  229.     
  230.     public Gruppo getGruppo(IDGruppo idGruppo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  231.         return this.driverRegistroServizi.getGruppo(idGruppo);
  232.     }
  233.     
  234.     public boolean existsGruppo(IDGruppo idGruppo) throws DriverRegistroServiziException {
  235.         return this.driverRegistroServizi.existsGruppo(idGruppo);
  236.     }
  237.     
  238.     public void createGruppo(Gruppo gruppo) throws DriverRegistroServiziException {
  239.         this.driverRegistroServizi.createGruppo(gruppo);
  240.     }
  241.     
  242.     public void updateGruppo(Gruppo gruppo) throws DriverRegistroServiziException {
  243.         this.driverRegistroServizi.updateGruppo(gruppo);
  244.     }
  245.     
  246.     public void deleteGruppo(Gruppo gruppo) throws DriverRegistroServiziException {
  247.         this.driverRegistroServizi.deleteGruppo(gruppo);
  248.     }
  249.     
  250.     public boolean isGruppoInUso(IDGruppo idGruppo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  251.         Connection con = null;
  252.         try{
  253.             con = this.driverRegistroServizi.getConnection("archive.isGruppoInUso");
  254.             return DBOggettiInUsoUtils.isGruppoInUso(con, this.driverRegistroServizi.getTipoDB(), idGruppo, whereIsInUso, normalizeObjectIds);
  255.         }
  256.         catch(Exception e){
  257.             throw new DriverRegistroServiziException(e.getMessage(),e);
  258.         }
  259.         finally{
  260.             try{
  261.                 this.driverRegistroServizi.releaseConnection(con);
  262.             }catch(Exception eClose){
  263.                 // close
  264.             }
  265.         }
  266.     }
  267.     
  268.     
  269.     
  270.     
  271.     
  272.     
  273.     
  274.     
  275.     
  276.     // --- RUOLI ---
  277.     
  278.     public List<IDRuolo> getAllIdRuoli(FiltroRicercaRuoli filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  279.         return this.driverRegistroServizi.getAllIdRuoli(filtroRicerca);
  280.     }
  281.     
  282.     public Ruolo getRuolo(IDRuolo idRuolo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  283.         return this.driverRegistroServizi.getRuolo(idRuolo);
  284.     }
  285.     
  286.     public boolean existsRuolo(IDRuolo idRuolo) throws DriverRegistroServiziException {
  287.         return this.driverRegistroServizi.existsRuolo(idRuolo);
  288.     }
  289.     
  290.     public void createRuolo(Ruolo ruolo) throws DriverRegistroServiziException {
  291.         this.driverRegistroServizi.createRuolo(ruolo);
  292.     }
  293.     
  294.     public void updateRuolo(Ruolo ruolo) throws DriverRegistroServiziException {
  295.         this.driverRegistroServizi.updateRuolo(ruolo);
  296.     }
  297.     
  298.     public void deleteRuolo(Ruolo ruolo) throws DriverRegistroServiziException {
  299.         this.driverRegistroServizi.deleteRuolo(ruolo);
  300.     }
  301.     
  302.     public boolean isRuoloInUso(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  303.         Connection con = null;
  304.         try{
  305.             con = this.driverRegistroServizi.getConnection("archive.isRuoloInUso");
  306.             return DBOggettiInUsoUtils.isRuoloInUso(con, this.driverRegistroServizi.getTipoDB(), idRuolo, whereIsInUso, normalizeObjectIds);
  307.         }
  308.         catch(Exception e){
  309.             throw new DriverRegistroServiziException(e.getMessage(),e);
  310.         }
  311.         finally{
  312.             try{
  313.                 this.driverRegistroServizi.releaseConnection(con);
  314.             }catch(Exception eClose){
  315.                 // close
  316.             }
  317.         }
  318.     }
  319.     
  320.     
  321.     
  322.     
  323.     
  324.     
  325.     // --- SCOPE ---
  326.     
  327.     public List<IDScope> getAllIdScope(FiltroRicercaScope filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  328.         return this.driverRegistroServizi.getAllIdScope(filtroRicerca);
  329.     }
  330.     
  331.     public Scope getScope(IDScope idScope) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  332.         return this.driverRegistroServizi.getScope(idScope);
  333.     }
  334.     
  335.     public boolean existsScope(IDScope idScope) throws DriverRegistroServiziException {
  336.         return this.driverRegistroServizi.existsScope(idScope);
  337.     }
  338.     
  339.     public void createScope(Scope scope) throws DriverRegistroServiziException {
  340.         this.driverRegistroServizi.createScope(scope);
  341.     }
  342.     
  343.     public void updateScope(Scope scope) throws DriverRegistroServiziException {
  344.         this.driverRegistroServizi.updateScope(scope);
  345.     }
  346.     
  347.     public void deleteScope(Scope scope) throws DriverRegistroServiziException {
  348.         this.driverRegistroServizi.deleteScope(scope);
  349.     }
  350.     
  351.     public boolean isScopeInUso(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  352.         Connection con = null;
  353.         try{
  354.             con = this.driverRegistroServizi.getConnection("archive.isScopeInUso");
  355.             return DBOggettiInUsoUtils.isScopeInUso(con, this.driverRegistroServizi.getTipoDB(), idScope, whereIsInUso, normalizeObjectIds);
  356.         }
  357.         catch(Exception e){
  358.             throw new DriverRegistroServiziException(e.getMessage(),e);
  359.         }
  360.         finally{
  361.             try{
  362.                 this.driverRegistroServizi.releaseConnection(con);
  363.             }catch(Exception eClose){
  364.                 // close
  365.             }
  366.         }
  367.     }

  369.     
  370.         
  371.     
  372.     
  373.     // --- Soggetti Registro ---
  374.     
  375.     public List<IDSoggetto> getAllIdSoggettiRegistro(org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  376.         return this.driverRegistroServizi.getAllIdSoggetti(filtroRicerca);
  377.     }
  378.     
  379.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistro(IDSoggetto idSoggetto) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  380.         return this.driverRegistroServizi.getSoggetto(idSoggetto);
  381.     }
  382.     
  383.     public boolean existsSoggettoRegistro(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  384.         return this.driverRegistroServizi.existsSoggetto(idSoggetto);
  385.     }
  386.     
  387.     public void createSoggettoRegistro(org.openspcoop2.core.registry.Soggetto soggetto) throws DriverRegistroServiziException {
  388.         this.driverRegistroServizi.createSoggetto(soggetto);
  389.     }
  390.     
  391.     public void updateSoggettoRegistro(org.openspcoop2.core.registry.Soggetto soggetto) throws DriverRegistroServiziException {
  392.         this.driverRegistroServizi.updateSoggetto(soggetto);
  393.     }
  394.     
  395.     public void deleteSoggettoRegistro(org.openspcoop2.core.registry.Soggetto soggetto) throws DriverRegistroServiziException {
  396.         this.driverRegistroServizi.deleteSoggetto(soggetto);
  397.     }
  398.     
  399.     public boolean isSoggettoRegistroInUso(IDSoggetto idSoggetto, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds, boolean verificaRuoli) throws DriverRegistroServiziException {
  400.         Connection con = null;
  401.         try{
  402.             con = this.driverRegistroServizi.getConnection("archive.isSoggettoRegistroInUso");
  403.             return DBOggettiInUsoUtils.isSoggettoRegistryInUso(con, this.driverRegistroServizi.getTipoDB(), idSoggetto, true, whereIsInUso, normalizeObjectIds, verificaRuoli);
  404.         }
  405.         catch(Exception e){
  406.             throw new DriverRegistroServiziException(e.getMessage(),e);
  407.         }
  408.         finally{
  409.             try{
  410.                 this.driverRegistroServizi.releaseConnection(con);
  411.             }catch(Exception eClose){
  412.                 // close
  413.             }
  414.         }
  415.     }
  416.     
  417.     public IDSoggetto getSoggettoDefault(String protocollo) throws DriverRegistroServiziException{
  418.         try {
  419.             List<IDSoggetto> soggettiDefault = this.driverRegistroServizi.getSoggettiDefault();
  420.             if(soggettiDefault!=null && !soggettiDefault.isEmpty()) {
  421.                 ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  422.                 for (IDSoggetto idSoggetto : soggettiDefault) {
  423.                     if(idSoggetto!=null && idSoggetto.getTipo()!=null) {
  424.                         String protCheck = protocolFactoryManager.getProtocolByOrganizationType(idSoggetto.getTipo());
  425.                         if(protCheck.equals(protocollo)) {
  426.                             return idSoggetto;
  427.                         }
  428.                     }
  429.                 }
  430.             }
  431.             return null;
  432.         }catch(Exception e) {
  433.             throw new DriverRegistroServiziException(e.getMessage(),e);
  434.         }
  435.     }
  436.     
  437.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroCredenzialiBasic(String utente) throws DriverRegistroServiziException{
  438.         return this.driverRegistroServizi.soggettoWithCredenzialiBasic(utente, null, false);
  439.     }
  440.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroCredenzialiApiKey(String utente, boolean appId) throws DriverRegistroServiziException{
  441.         return this.driverRegistroServizi.soggettoWithCredenzialiApiKey(utente, appId);
  442.     }
  443.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroCredenzialiSsl(String subject, String issuer) throws DriverRegistroServiziException{
  444.         try {
  445.             return this.driverRegistroServizi.getSoggettoByCredenzialiSsl(subject, issuer);
  446.         }catch(DriverRegistroServiziNotFound notFound) {
  447.             return null;
  448.         }
  449.     }
  450.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroCredenzialiSsl(byte[]archivio, boolean strictVerifier) throws DriverRegistroServiziException{
  451.         Certificate cSelezionato = null;
  452.         try {
  453.             cSelezionato = ArchiveLoader.load(archivio);
  454.         }catch(Exception e) {
  455.             throw new DriverRegistroServiziException(e.getMessage(),e);
  456.         }
  457.         try {
  458.             return this.driverRegistroServizi.getSoggettoByCredenzialiSsl(cSelezionato.getCertificate(), strictVerifier);
  459.         }catch(DriverRegistroServiziNotFound notFound) {
  460.             return null;
  461.         }
  462.     }
  463.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroCredenzialiPrincipal(String principal) throws DriverRegistroServiziException{
  464.         try {
  465.             return this.driverRegistroServizi.getSoggettoByCredenzialiPrincipal(principal);
  466.         }catch(DriverRegistroServiziNotFound notFound) {
  467.             return null;
  468.         }
  469.     }
  470.     
  471.     
  472.     
  473.     // --- Soggetti Configurazione ---
  474.         
  475.     public List<IDSoggetto> getAllIdSoggettiConfigurazione(FiltroRicercaSoggetti filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  476.         return this.driverConfigurazione.getAllIdSoggetti(filtroRicerca);
  477.     }
  478.     
  479.     public org.openspcoop2.core.config.Soggetto getSoggettoConfigurazione(IDSoggetto idSoggetto) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  480.         return this.driverConfigurazione.getSoggetto(idSoggetto);
  481.     }
  482.     
  483.     public boolean existsSoggettoConfigurazione(IDSoggetto idSoggetto) throws DriverConfigurazioneException {
  484.         return this.driverConfigurazione.existsSoggetto(idSoggetto);
  485.     }
  486.     
  487.     public void createSoggettoConfigurazione(org.openspcoop2.core.config.Soggetto soggetto) throws DriverConfigurazioneException {
  488.         this.driverConfigurazione.createSoggetto(soggetto);
  489.     }
  490.     
  491.     public void updateSoggettoConfigurazione(org.openspcoop2.core.config.Soggetto soggetto) throws DriverConfigurazioneException {
  492.         this.driverConfigurazione.updateSoggetto(soggetto);
  493.     }
  494.     
  495.     public void deleteSoggettoConfigurazione(org.openspcoop2.core.config.Soggetto soggetto) throws DriverConfigurazioneException {
  496.         this.driverConfigurazione.deleteSoggetto(soggetto);
  497.     }
  498.     
  499.     public boolean isSoggettoConfigurazioneInUso(IDSoggetto idSoggetto, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds, boolean verificaRuoli) throws DriverConfigurazioneException {
  500.         Connection con = null;
  501.         try{
  502.             con = this.driverConfigurazione.getConnection("archive.isSoggettoConfigurazioneInUso");
  503.             return DBOggettiInUsoUtils.isSoggettoConfigInUso(con, this.driverConfigurazione.getTipoDB(), idSoggetto, true, whereIsInUso, normalizeObjectIds, verificaRuoli);
  504.         }
  505.         catch(Exception e){
  506.             throw new DriverConfigurazioneException(e.getMessage(),e);
  507.         }
  508.         finally{
  509.             try{
  510.                 this.driverConfigurazione.releaseConnection(con);
  511.             }catch(Exception eClose){
  512.                 // close
  513.             }
  514.         }
  515.     }
  516.     
  517.     
  518.     
  519.     // --- Servizi Applicativi ---
  520.     
  521.     public List<IDServizioApplicativo> getAllIdServiziApplicativi(FiltroRicercaServiziApplicativi filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  522.         return this.driverConfigurazione.getAllIdServiziApplicativi(filtroRicerca);
  523.     }
  524.     
  525.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  526.         return this.driverConfigurazione.getServizioApplicativo(idServizioApplicativo);
  527.     }
  528.     
  529.     public boolean existsServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException {
  530.         return this.driverConfigurazione.existsServizioApplicativo(idServizioApplicativo);
  531.     }
  532.     
  533.     public void createServizioApplicativo(org.openspcoop2.core.config.ServizioApplicativo servizioApplicativo) throws DriverConfigurazioneException {
  534.         this.driverConfigurazione.createServizioApplicativo(servizioApplicativo);
  535.     }
  536.     
  537.     public void updateServizioApplicativo(org.openspcoop2.core.config.ServizioApplicativo servizioApplicativo) throws DriverConfigurazioneException {
  538.         this.driverConfigurazione.updateServizioApplicativo(servizioApplicativo);
  539.     }
  540.     
  541.     public void deleteServizioApplicativo(org.openspcoop2.core.config.ServizioApplicativo servizioApplicativo) throws DriverConfigurazioneException {
  542.         this.driverConfigurazione.deleteServizioApplicativo(servizioApplicativo);
  543.     }
  544.     
  545.     public boolean isServizioApplicativoInUso(IDServizioApplicativo idServizioApplicativo, 
  546.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds, boolean verificaRuoli) throws DriverConfigurazioneException {
  547.         Connection con = null;
  548.         try{
  549.             con = this.driverConfigurazione.getConnection("archive.isServizioApplicativoInUso");
  550.             return DBOggettiInUsoUtils.isServizioApplicativoInUso(con, this.driverConfigurazione.getTipoDB(), idServizioApplicativo, whereIsInUso, true, normalizeObjectIds, verificaRuoli);
  551.         }
  552.         catch(Exception e){
  553.             throw new DriverConfigurazioneException(e.getMessage(),e);
  554.         }
  555.         finally{
  556.             try{
  557.                 this.driverConfigurazione.releaseConnection(con);
  558.             }catch(Exception eClose){
  559.                 // close
  560.             }
  561.         }
  562.     }
  563.     
  564.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativoCredenzialiBasic(String utente) throws DriverConfigurazioneException{
  565.         List<org.openspcoop2.core.config.ServizioApplicativo> l = this.driverConfigurazione.servizioApplicativoWithCredenzialiBasicList(utente, null, false);
  566.         if(l!=null && !l.isEmpty()) {
  567.             return l.get(0);
  568.         }
  569.         return null;
  570.     }
  571.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativoCredenzialiApiKey(String utente, boolean appId) throws DriverConfigurazioneException{
  572.         List<org.openspcoop2.core.config.ServizioApplicativo> l = this.driverConfigurazione.servizioApplicativoWithCredenzialiApiKeyList(utente, appId);
  573.         if(l!=null && !l.isEmpty()) {
  574.             return l.get(0);
  575.         }
  576.         return null;
  577.     }
  578.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativoCredenzialiSsl(String subject, String issuer,
  579.             ConfigurazioneFiltroServiziApplicativi filtro) throws DriverConfigurazioneException{
  580.         List<org.openspcoop2.core.config.ServizioApplicativo> l = this.driverConfigurazione.servizioApplicativoWithCredenzialiSslList(subject, issuer,
  581.                 filtro.getTipiSoggetti(), 
  582.                 filtro.isIncludiApplicativiNonModI(), filtro.isIncludiApplicativiModIEsterni(), filtro.isIncludiApplicativiModIInterni());
  583.         if(l!=null && !l.isEmpty()) {
  584.             return l.get(0);
  585.         }
  586.         return null;
  587.     }
  588.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativoCredenzialiSsl(byte[]archivio, boolean strictVerifier,
  589.             ConfigurazioneFiltroServiziApplicativi filtro) throws DriverConfigurazioneException{
  590.         Certificate cSelezionato = null;
  591.         try {
  592.             cSelezionato = ArchiveLoader.load(archivio);
  593.         }catch(Exception e) {
  594.             throw new DriverConfigurazioneException(e.getMessage(),e);
  595.         }
  596.         List<org.openspcoop2.core.config.ServizioApplicativo> l = this.driverConfigurazione.servizioApplicativoWithCredenzialiSslList(cSelezionato.getCertificate(), strictVerifier,
  597.                 filtro.getTipiSoggetti(), 
  598.                 filtro.isIncludiApplicativiNonModI(), filtro.isIncludiApplicativiModIEsterni(), filtro.isIncludiApplicativiModIInterni());
  599.         if(l!=null && !l.isEmpty()) {
  600.             return l.get(0);
  601.         }
  602.         return null;
  603.     }
  604.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativoCredenzialiPrincipal(String principal) throws DriverConfigurazioneException{
  605.         List<org.openspcoop2.core.config.ServizioApplicativo> l = this.driverConfigurazione.servizioApplicativoWithCredenzialiPrincipalList(principal);
  606.         if(l!=null && !l.isEmpty()) {
  607.             return l.get(0);
  608.         }
  609.         return null;
  610.     }
  611.     public org.openspcoop2.core.config.ServizioApplicativo getServizioApplicativoCredenzialiToken(String tokenPolicy, String tokenClientId) throws DriverConfigurazioneException{
  612.         
  613.         boolean tokenWithHttpsEnabled = false;
  614.         try {
  615.             // basta un protocollo che lo supporta per doverli cercare anche con la funzionalita' abilitata
  616.             for(IProtocolFactory<?> protocolFactory: ProtocolFactoryManager.getInstance().getProtocolFactories().values()) {
  617.                 if(protocolFactory.createProtocolConfiguration().isSupportatoAutenticazioneApplicativiHttpsConToken()) {
  618.                     tokenWithHttpsEnabled = true;
  619.                     break;
  620.                 }
  621.             }
  622.         }catch(Exception e) {
  623.             throw new DriverConfigurazioneException(e.getMessage(),e);
  624.         }
  625.         
  626.         List<org.openspcoop2.core.config.ServizioApplicativo> l = this.driverConfigurazione.servizioApplicativoWithCredenzialiTokenList(tokenPolicy, tokenClientId, tokenWithHttpsEnabled);
  627.         if(l!=null && !l.isEmpty()) {
  628.             return l.get(0);
  629.         }
  630.         return null;
  631.     }
  632.     
  633.     
  634.     
  635.     // --- Accordi di Cooperazione ---
  636.     
  637.     public List<IDAccordoCooperazione> getAllIdAccordiCooperazione(FiltroRicercaAccordi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  638.         return this.driverRegistroServizi.getAllIdAccordiCooperazione(filtroRicerca);
  639.     }
  640.     
  641.     public AccordoCooperazione getAccordoCooperazione(IDAccordoCooperazione idAccordoCooperazione) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  642.         return this.driverRegistroServizi.getAccordoCooperazione(idAccordoCooperazione);
  643.     }
  644.     
  645.     public AccordoCooperazione getAccordoCooperazione(IDAccordoCooperazione idAccordoCooperazione, boolean readContenutoAllegati) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  646.         return this.driverRegistroServizi.getAccordoCooperazione(idAccordoCooperazione,readContenutoAllegati);
  647.     }
  648.     
  649.     public boolean existsAccordoCooperazione(IDAccordoCooperazione idAccordoCooperazione) throws DriverRegistroServiziException {
  650.         return this.driverRegistroServizi.existsAccordoCooperazione(idAccordoCooperazione);
  651.     }
  652.     
  653.     public void createAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException {
  654.         this.driverRegistroServizi.createAccordoCooperazione(accordoCooperazione);
  655.     }
  656.     
  657.     public void updateAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException {
  658.         this.driverRegistroServizi.updateAccordoCooperazione(accordoCooperazione);
  659.     }
  660.     
  661.     public void deleteAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException {
  662.         this.driverRegistroServizi.deleteAccordoCooperazione(accordoCooperazione);
  663.     }
  664.     
  665.     public void validaStatoAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws ValidazioneStatoPackageException {
  666.         this.driverRegistroServizi.validaStatoAccordoCooperazione(accordoCooperazione);
  667.     }
  668.     
  669.     public boolean isAccordoCooperazioneInUso(IDAccordoCooperazione idAccordo, 
  670.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  671.         Connection con = null;
  672.         try{
  673.             con = this.driverRegistroServizi.getConnection("archive.isAccordoCooperazioneInUso");
  674.             return DBOggettiInUsoUtils.isAccordoCooperazioneInUso(con, this.driverRegistroServizi.getTipoDB(), idAccordo, whereIsInUso, normalizeObjectIds);
  675.         }
  676.         catch(Exception e){
  677.             throw new DriverRegistroServiziException(e.getMessage(),e);
  678.         }
  679.         finally{
  680.             try{
  681.                 this.driverRegistroServizi.releaseConnection(con);
  682.             }catch(Exception eClose){
  683.                 // close
  684.             }
  685.         }
  686.     }
  687.     
  688.     
  689.     // --- Accordi di Servizio Parte Comune ---
  690.     
  691.     public List<IDAccordo> getAllIdAccordiServizioParteComune(FiltroRicercaAccordi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  692.         return this.driverRegistroServizi.getAllIdAccordiServizioParteComune(filtroRicerca);
  693.     }
  694.     
  695.     public AccordoServizioParteComune getAccordoServizioParteComune(IDAccordo idAccordoServizioParteComune) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  696.         return this.driverRegistroServizi.getAccordoServizioParteComune(idAccordoServizioParteComune);
  697.     }
  698.     
  699.     public AccordoServizioParteComune getAccordoServizioParteComune(IDAccordo idAccordoServizioParteComune, boolean readContenutoAllegati,boolean readDatiRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  700.         return this.driverRegistroServizi.getAccordoServizioParteComune(idAccordoServizioParteComune, readContenutoAllegati, readDatiRegistro);
  701.     }
  702.     
  703.     public boolean existsAccordoServizioParteComune(IDAccordo idAccordoServizioParteComune) throws DriverRegistroServiziException {
  704.         return this.driverRegistroServizi.existsAccordoServizioParteComune(idAccordoServizioParteComune);
  705.     }
  706.     
  707.     public void createAccordoServizioParteComune(AccordoServizioParteComune accordoServizioParteComune) throws DriverRegistroServiziException {
  708.         this.driverRegistroServizi.createAccordoServizioParteComune(accordoServizioParteComune);
  709.     }
  710.     
  711.     public void updateAccordoServizioParteComune(AccordoServizioParteComune accordoServizioParteComune) throws DriverRegistroServiziException {
  712.         this.driverRegistroServizi.updateAccordoServizioParteComune(accordoServizioParteComune);
  713.     }
  714.     
  715.     public void deleteAccordoServizioParteComune(AccordoServizioParteComune accordoServizioParteComune) throws DriverRegistroServiziException {
  716.         this.driverRegistroServizi.deleteAccordoServizioParteComune(accordoServizioParteComune);
  717.     }
  718.     
  719.     public void validaStatoAccordoServizioParteComune(AccordoServizioParteComune accordoServizioParteComune,boolean utilizzoAzioniDiretteInAccordoAbilitato) throws ValidazioneStatoPackageException {
  720.         this.driverRegistroServizi.validaStatoAccordoServizio(accordoServizioParteComune,utilizzoAzioniDiretteInAccordoAbilitato);
  721.     }
  722.     
  723.     public boolean isAccordoServizioParteComuneInUso(IDAccordo idAccordo, 
  724.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  725.         Connection con = null;
  726.         try{
  727.             con = this.driverRegistroServizi.getConnection("archive.isAccordoServizioParteComuneInUso");
  728.             return DBOggettiInUsoUtils.isAccordoServizioParteComuneInUso(con, this.driverRegistroServizi.getTipoDB(), idAccordo, whereIsInUso, normalizeObjectIds);
  729.         }
  730.         catch(Exception e){
  731.             throw new DriverRegistroServiziException(e.getMessage(),e);
  732.         }
  733.         finally{
  734.             try{
  735.                 this.driverRegistroServizi.releaseConnection(con);
  736.             }catch(Exception eClose){
  737.                 // close
  738.             }
  739.         }
  740.     }
  741.     
  742.     
  743.     // --- Accordi di Servizio Parte Specifica ---
  744.     
  745.     public List<IDServizio> getAllIdAccordiServizioParteSpecifica(FiltroRicercaServizi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  746.         return this.driverRegistroServizi.getAllIdServizi(filtroRicerca);
  747.     }
  748.     
  749.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  750.         return this.driverRegistroServizi.getAccordoServizioParteSpecifica(idServizio);
  751.     }
  752.     
  753.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio, boolean readContenutoAllegati) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  754.         return this.driverRegistroServizi.getAccordoServizioParteSpecifica(idServizio,readContenutoAllegati);
  755.     }
  756.     
  757.     public boolean existsAccordoServizioParteSpecifica(IDServizio idServizio) throws DriverRegistroServiziException {
  758.         return this.driverRegistroServizi.existsAccordoServizioParteSpecifica(idServizio);
  759.     }
  760.     
  761.     public boolean existsFruzioneAccordoServizioParteSpecifica(IDServizio idServizio, IDSoggetto fruitore) throws DriverRegistroServiziException {
  762.         if( this.driverRegistroServizi.existsAccordoServizioParteSpecifica(idServizio) ) {
  763.             try {
  764.                 AccordoServizioParteSpecifica asps = this.getAccordoServizioParteSpecifica(idServizio, false);
  765.                 if(asps.sizeFruitoreList()>0) {
  766.                     for (Fruitore fr : asps.getFruitoreList()) {
  767.                         if(fr.getTipo().equals(fruitore.getTipo()) && fr.getNome().equals(fruitore.getNome())) {
  768.                             return true;
  769.                         }
  770.                     }
  771.                 }
  772.             }catch(Exception e) {
  773.                 return false;
  774.             }           
  775.         }
  776.         return false;
  777.     }
  778.     
  779.     public void createAccordoServizioParteSpecifica(AccordoServizioParteSpecifica accordoServizioParteSpecifica) throws DriverRegistroServiziException {
  780.         this.driverRegistroServizi.createAccordoServizioParteSpecifica(accordoServizioParteSpecifica);
  781.     }
  782.     
  783.     public void updateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica accordoServizioParteSpecifica) throws DriverRegistroServiziException {
  784.         this.driverRegistroServizi.updateAccordoServizioParteSpecifica(accordoServizioParteSpecifica);
  785.     }
  786.     
  787.     public void deleteAccordoServizioParteSpecifica(AccordoServizioParteSpecifica accordoServizioParteSpecifica) throws DriverRegistroServiziException {
  788.         this.driverRegistroServizi.deleteAccordoServizioParteSpecifica(accordoServizioParteSpecifica);
  789.     }
  790.     
  791.     public void validaStatoAccordoServizioParteSpecifica(AccordoServizioParteSpecifica accordoServizioParteSpecifica, boolean gestioneWsdlImplementativo, boolean checkConnettore) throws ValidazioneStatoPackageException {
  792.         this.driverRegistroServizi.validaStatoAccordoServizioParteSpecifica(accordoServizioParteSpecifica, gestioneWsdlImplementativo, checkConnettore);
  793.     }
  794.     
  795.     public void validaStatoFruitoreServizio(Fruitore fruitore, AccordoServizioParteSpecifica accordoServizioParteSpecifica) throws ValidazioneStatoPackageException {
  796.         this.driverRegistroServizi.validaStatoFruitoreServizio(fruitore, accordoServizioParteSpecifica);
  797.     }
  798.     
  799.     public void controlloUnicitaImplementazioneAccordoPerSoggetto(String portType,
  800.             IDSoggetto idSoggettoErogatore, long idSoggettoErogatoreLong, 
  801.             IDAccordo idAccordoServizioParteComune, long idAccordoServizioParteComuneLong,
  802.             IDServizio idAccordoServizioParteSpecifica, long idAccordoServizioParteSpecificaLong,
  803.             boolean isUpdate,boolean isServizioCorrelato,
  804.             boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  805.             boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto) throws DriverRegistroServiziException{
  806.         this.driverRegistroServizi.controlloUnicitaImplementazioneAccordoPerSoggetto(portType, idSoggettoErogatore, idSoggettoErogatoreLong, 
  807.                 idAccordoServizioParteComune, idAccordoServizioParteComuneLong, 
  808.                 idAccordoServizioParteSpecifica, idAccordoServizioParteSpecificaLong, 
  809.                 isUpdate, isServizioCorrelato, 
  810.                 isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto, 
  811.                 isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto);
  812.     }
  813.     
  814.     public boolean isAccordoServizioParteSpecificaInUso(IDServizio idServizio, 
  815.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  816.         Connection con = null;
  817.         try{
  818.             con = this.driverRegistroServizi.getConnection("archive.isAccordoServizioParteSpecificaInUso");
  819.             return DBOggettiInUsoUtils.isAccordoServizioParteSpecificaInUso(con, this.driverRegistroServizi.getTipoDB(), idServizio, whereIsInUso, null, null, normalizeObjectIds);
  820.         }
  821.         catch(Exception e){
  822.             throw new DriverRegistroServiziException(e.getMessage(),e);
  823.         }
  824.         finally{
  825.             try{
  826.                 this.driverRegistroServizi.releaseConnection(con);
  827.             }catch(Exception eClose){
  828.                 // close
  829.             }
  830.         }
  831.     }
  832.     
  833.     
  834.     
  835.     
  836.     // --- Mapping Erogazione ---
  837.     
  838.     public void createMappingErogazione(String nome, String descrizione, boolean isDefault, IDServizio idServizio, IDPortaApplicativa idPortaApplicativaByNome) throws DriverRegistroServiziException {
  839.         Connection con = null;
  840.         try{
  841.             con = this.driverRegistroServizi.getConnection("createMappingErogazione");
  842.             DBMappingUtils.createMappingErogazione(nome, descrizione, isDefault, idServizio, idPortaApplicativaByNome, con, this.driverRegistroServizi.getTipoDB());
  843.         }
  844.         catch(Exception e){
  845.             throw new DriverRegistroServiziException(e.getMessage(),e);
  846.         }
  847.         finally{
  848.             try{
  849.                 this.driverRegistroServizi.releaseConnection(con);
  850.             }catch(Exception eClose){
  851.                 // close
  852.             }
  853.         }
  854.     }
  855.     
  856.     public IDPortaApplicativa getIDPortaApplicativaDefaultAssociataErogazione(IDServizio idServizio) throws DriverRegistroServiziException{
  857.         Connection con = null;
  858.         try{
  859.             con = this.driverRegistroServizi.getConnection("getIDPortaApplicativaDefaultAssociataErogazione");
  860.             return DBMappingUtils.getIDPortaApplicativaAssociataDefault(idServizio, con, this.driverRegistroServizi.getTipoDB());
  861.         }
  862.         catch(Exception e){
  863.             throw new DriverRegistroServiziException(e.getMessage(),e);
  864.         }
  865.         finally{
  866.             try{
  867.                 this.driverRegistroServizi.releaseConnection(con);
  868.             }catch(Exception eClose){
  869.                 // close
  870.             }
  871.         }
  872.     }
  873.     
  874.     public IDPortaApplicativa getIDPortaApplicativaPerAzioneAssociataErogazione(IDServizio idServizio) throws DriverRegistroServiziException{
  875.         Connection con = null;
  876.         try{
  877.             con = this.driverRegistroServizi.getConnection("getIDPortaApplicativaPerAzioneAssociataErogazione");
  878.             return DBMappingUtils.getIDPortaApplicativaAssociataAzione(idServizio, con, this.driverRegistroServizi.getTipoDB());
  879.         }
  880.         catch(Exception e){
  881.             throw new DriverRegistroServiziException(e.getMessage(),e);
  882.         }
  883.         finally{
  884.             try{
  885.                 this.driverRegistroServizi.releaseConnection(con);
  886.             }catch(Exception eClose){
  887.                 // close
  888.             }
  889.         }
  890.     }
  891.     
  892.     public List<IDPortaApplicativa> getIDPorteApplicativeAssociateErogazione(IDServizio idServizio) throws DriverRegistroServiziException{
  893.         Connection con = null;
  894.         try{
  895.             con = this.driverRegistroServizi.getConnection("getIDPorteApplicativeAssociateErogazione");
  896.             return DBMappingUtils.getIDPorteApplicativeAssociate(idServizio, con, this.driverRegistroServizi.getTipoDB());
  897.         }
  898.         catch(Exception e){
  899.             throw new DriverRegistroServiziException(e.getMessage(),e);
  900.         }
  901.         finally{
  902.             try{
  903.                 this.driverRegistroServizi.releaseConnection(con);
  904.             }catch(Exception eClose){
  905.                 // close
  906.             }
  907.         }
  908.     }
  909.     
  910.     public void deleteMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativaByNome) throws DriverRegistroServiziException {
  911.         Connection con = null;
  912.         try{
  913.             con = this.driverRegistroServizi.getConnection("deleteMappingErogazione");
  914.             DBMappingUtils.deleteMappingErogazione(idServizio, idPortaApplicativaByNome, con, this.driverRegistroServizi.getTipoDB());
  915.         }
  916.         catch(Exception e){
  917.             throw new DriverRegistroServiziException(e.getMessage(),e);
  918.         }
  919.         finally{
  920.             try{
  921.                 this.driverRegistroServizi.releaseConnection(con);
  922.             }catch(Exception eClose){
  923.                 // close
  924.             }
  925.         }
  926.     }
  927.     
  928.     public void deleteMappingErogazione(IDServizio idServizio) throws DriverRegistroServiziException {
  929.         Connection con = null;
  930.         try{
  931.             con = this.driverRegistroServizi.getConnection("deleteMappingErogazione");
  932.             DBMappingUtils.deleteMappingErogazione(idServizio, null, con, this.driverRegistroServizi.getTipoDB());
  933.         }
  934.         catch(Exception e){
  935.             throw new DriverRegistroServiziException(e.getMessage(),e);
  936.         }
  937.         finally{
  938.             try{
  939.                 this.driverRegistroServizi.releaseConnection(con);
  940.             }catch(Exception eClose){
  941.                 // close
  942.             }
  943.         }
  944.     }
  945.     
  946.     public boolean existsIDPortaApplicativaDefaultAssociataErogazione(IDServizio idServizio) throws DriverRegistroServiziException {
  947.         Connection con = null;
  948.         try{
  949.             con = this.driverRegistroServizi.getConnection("existsIDPortaApplicativaDefaultAssociataErogazione");
  950.             return DBMappingUtils.existsIDPortaApplicativaAssociataDefault(idServizio, con, this.driverRegistroServizi.getTipoDB());
  951.         }
  952.         catch(Exception e){
  953.             throw new DriverRegistroServiziException(e.getMessage(),e);
  954.         }
  955.         finally{
  956.             try{
  957.                 this.driverRegistroServizi.releaseConnection(con);
  958.             }catch(Exception eClose){
  959.                 // close
  960.             }
  961.         }
  962.     }
  963.     
  964.     public boolean existsIDPortaApplicativaPerAzioneAssociataErogazione(IDServizio idServizio) throws DriverRegistroServiziException {
  965.         Connection con = null;
  966.         try{
  967.             con = this.driverRegistroServizi.getConnection("existsIDPortaApplicativaPerAzioneAssociataErogazione");
  968.             return DBMappingUtils.existsIDPortaApplicativaAssociataAzione(idServizio, con, this.driverRegistroServizi.getTipoDB());
  969.         }
  970.         catch(Exception e){
  971.             throw new DriverRegistroServiziException(e.getMessage(),e);
  972.         }
  973.         finally{
  974.             try{
  975.                 this.driverRegistroServizi.releaseConnection(con);
  976.             }catch(Exception eClose){
  977.                 // close
  978.             }
  979.         }
  980.     }
  981.     
  982.     public boolean existsIDPorteApplicativeAssociateErogazione(IDServizio idServizio) throws DriverRegistroServiziException {
  983.         Connection con = null;
  984.         try{
  985.             con = this.driverRegistroServizi.getConnection("existsIDPorteApplicativeAssociateErogazione");
  986.             return DBMappingUtils.existsIDPorteApplicativeAssociate(idServizio, con, this.driverRegistroServizi.getTipoDB());
  987.         }
  988.         catch(Exception e){
  989.             throw new DriverRegistroServiziException(e.getMessage(),e);
  990.         }
  991.         finally{
  992.             try{
  993.                 this.driverRegistroServizi.releaseConnection(con);
  994.             }catch(Exception eClose){
  995.                 // close
  996.             }
  997.         }
  998.     }
  999.     
  1000.     public boolean existsMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa) throws DriverRegistroServiziException {
  1001.         Connection con = null;
  1002.         try{
  1003.             con = this.driverRegistroServizi.getConnection("existsMappingErogazione");
  1004.             return DBMappingUtils.existsMappingErogazione(idServizio, idPortaApplicativa, con, this.driverRegistroServizi.getTipoDB());
  1005.         }
  1006.         catch(Exception e){
  1007.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1008.         }
  1009.         finally{
  1010.             try{
  1011.                 this.driverRegistroServizi.releaseConnection(con);
  1012.             }catch(Exception eClose){
  1013.                 // close
  1014.             }
  1015.         }
  1016.     }
  1017.     
  1018.     public MappingErogazionePortaApplicativa getMappingErogazionePortaApplicativa(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa) throws DriverRegistroServiziException {
  1019.         Connection con = null;
  1020.         try{
  1021.             con = this.driverRegistroServizi.getConnection("getMappingErogazionePortaApplicativa");
  1022.             return DBMappingUtils.getMappingErogazione(idServizio, idPortaApplicativa, con, this.driverRegistroServizi.getTipoDB());
  1023.         }
  1024.         catch(Exception e){
  1025.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1026.         }
  1027.         finally{
  1028.             try{
  1029.                 this.driverRegistroServizi.releaseConnection(con);
  1030.             }catch(Exception eClose){
  1031.                 // close
  1032.             }
  1033.         }
  1034.     }
  1035.     
  1036.     // Inefficiente
  1037.     @Deprecated 
  1038.     public void initMappingErogazione(Logger log) throws DriverRegistroServiziException {
  1039.         try{
  1040.             UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(this.driverConfigurazione, this.driverRegistroServizi, log);
  1041.             utilities.initMappingErogazione();
  1042.         }
  1043.         catch(Exception e){
  1044.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1045.         }
  1046.     }
  1047.     public void initMappingErogazioneById(Logger log, List<IDPortaApplicativa> listPA) throws DriverRegistroServiziException {
  1048.         try{
  1049.             UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(this.driverConfigurazione, this.driverRegistroServizi, log);
  1050.             utilities.gestioneMappingErogazionePAbyId(listPA);
  1051.         }
  1052.         catch(Exception e){
  1053.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1054.         }
  1055.     }
  1056.     public void initMappingErogazione(Logger log, List<PortaApplicativa> listPA) throws DriverRegistroServiziException {
  1057.         try{
  1058.             UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(this.driverConfigurazione, this.driverRegistroServizi, log);
  1059.             utilities.gestioneMappingErogazionePA(listPA);
  1060.         }
  1061.         catch(Exception e){
  1062.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1063.         }
  1064.     }
  1065.     
  1066.     
  1067.     
  1068.     
  1069.     
  1070.     // --- Mapping Fruizione ---
  1071.     
  1072.     public void createMappingFruizione(String nome, String descrizione, boolean isDefault, IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata) throws DriverRegistroServiziException {
  1073.         Connection con = null;
  1074.         try{
  1075.             con = this.driverRegistroServizi.getConnection("createMappingFruizione");
  1076.             DBMappingUtils.createMappingFruizione(nome, descrizione, isDefault, idServizio, idFruitore, idPortaDelegata, con, this.driverRegistroServizi.getTipoDB());
  1077.         }
  1078.         catch(Exception e){
  1079.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1080.         }
  1081.         finally{
  1082.             try{
  1083.                 this.driverRegistroServizi.releaseConnection(con);
  1084.             }catch(Exception eClose){
  1085.                 // close
  1086.             }
  1087.         }
  1088.     }
  1089.     
  1090.     public IDPortaDelegata getIDPortaDelegataDefaultAssociataFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException{
  1091.         Connection con = null;
  1092.         try{
  1093.             con = this.driverRegistroServizi.getConnection("getIDPortaDelegataDefaultAssociataFruizione");
  1094.             return DBMappingUtils.getIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, this.driverRegistroServizi.getTipoDB());
  1095.         }
  1096.         catch(Exception e){
  1097.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1098.         }
  1099.         finally{
  1100.             try{
  1101.                 this.driverRegistroServizi.releaseConnection(con);
  1102.             }catch(Exception eClose){
  1103.                 // close
  1104.             }
  1105.         }
  1106.     }
  1107.     
  1108.     public IDPortaDelegata getIDPortaDelegataPerAzioneAssociataFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException{
  1109.         Connection con = null;
  1110.         try{
  1111.             con = this.driverRegistroServizi.getConnection("getIDPortaDelegataPerAzioneAssociataFruizione");
  1112.             return DBMappingUtils.getIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, this.driverRegistroServizi.getTipoDB());
  1113.         }
  1114.         catch(Exception e){
  1115.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1116.         }
  1117.         finally{
  1118.             try{
  1119.                 this.driverRegistroServizi.releaseConnection(con);
  1120.             }catch(Exception eClose){
  1121.                 // close
  1122.             }
  1123.         }
  1124.     }
  1125.     
  1126.     public List<IDPortaDelegata> getIDPorteDelegateAssociateFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException{
  1127.         Connection con = null;
  1128.         try{
  1129.             con = this.driverRegistroServizi.getConnection("getIDPorteDelegateAssociateFruizione");
  1130.             return DBMappingUtils.getIDPorteDelegateAssociate(idServizio, idFruitore, con, this.driverRegistroServizi.getTipoDB());
  1131.         }
  1132.         catch(Exception e){
  1133.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1134.         }
  1135.         finally{
  1136.             try{
  1137.                 this.driverRegistroServizi.releaseConnection(con);
  1138.             }catch(Exception eClose){
  1139.                 // close
  1140.             }
  1141.         }
  1142.     }
  1143.     
  1144.     public void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata) throws DriverRegistroServiziException {
  1145.         Connection con = null;
  1146.         try{
  1147.             con = this.driverRegistroServizi.getConnection("deleteMappingFruizione");
  1148.             DBMappingUtils.deleteMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, this.driverRegistroServizi.getTipoDB());
  1149.         }
  1150.         catch(Exception e){
  1151.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1152.         }
  1153.         finally{
  1154.             try{
  1155.                 this.driverRegistroServizi.releaseConnection(con);
  1156.             }catch(Exception eClose){
  1157.                 // close
  1158.             }
  1159.         }
  1160.     }
  1161.     
  1162.     public void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException {
  1163.         Connection con = null;
  1164.         try{
  1165.             con = this.driverRegistroServizi.getConnection("deleteMappingFruizione");
  1166.             DBMappingUtils.deleteMappingFruizione(idServizio, idFruitore, null, con, this.driverRegistroServizi.getTipoDB());
  1167.         }
  1168.         catch(Exception e){
  1169.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1170.         }
  1171.         finally{
  1172.             try{
  1173.                 this.driverRegistroServizi.releaseConnection(con);
  1174.             }catch(Exception eClose){
  1175.                 // close
  1176.             }
  1177.         }
  1178.     }
  1179.     
  1180.     public boolean existsIDPortaDelegataDefaultAssociataFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException {
  1181.         Connection con = null;
  1182.         try{
  1183.             con = this.driverRegistroServizi.getConnection("existsIDPortaDelegataDefaultAssociataFruizione");
  1184.             return DBMappingUtils.existsIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, this.driverRegistroServizi.getTipoDB());
  1185.         }
  1186.         catch(Exception e){
  1187.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1188.         }
  1189.         finally{
  1190.             try{
  1191.                 this.driverRegistroServizi.releaseConnection(con);
  1192.             }catch(Exception eClose){
  1193.                 // close
  1194.             }
  1195.         }
  1196.     }
  1197.     
  1198.     public boolean existsIDPortaDelegataPerAzioneAssociataFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException {
  1199.         Connection con = null;
  1200.         try{
  1201.             con = this.driverRegistroServizi.getConnection("existsIDPortaDelegataPerAzioneAssociataFruizione");
  1202.             return DBMappingUtils.existsIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, this.driverRegistroServizi.getTipoDB());
  1203.         }
  1204.         catch(Exception e){
  1205.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1206.         }
  1207.         finally{
  1208.             try{
  1209.                 this.driverRegistroServizi.releaseConnection(con);
  1210.             }catch(Exception eClose){
  1211.                 // close
  1212.             }
  1213.         }
  1214.     }
  1215.     
  1216.     public boolean existsIDPorteDelegateAssociateFruizione(IDServizio idServizio, IDSoggetto idFruitore) throws DriverRegistroServiziException {
  1217.         Connection con = null;
  1218.         try{
  1219.             con = this.driverRegistroServizi.getConnection("existsIDPorteDelegateAssociateFruizione");
  1220.             return DBMappingUtils.existsIDPorteDelegateAssociate(idServizio, idFruitore, con, this.driverRegistroServizi.getTipoDB());
  1221.         }
  1222.         catch(Exception e){
  1223.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1224.         }
  1225.         finally{
  1226.             try{
  1227.                 this.driverRegistroServizi.releaseConnection(con);
  1228.             }catch(Exception eClose){
  1229.                 // close
  1230.             }
  1231.         }
  1232.     }
  1233.     
  1234.     public boolean existsMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata) throws DriverRegistroServiziException {
  1235.         Connection con = null;
  1236.         try{
  1237.             con = this.driverRegistroServizi.getConnection("existsMappingFruizione");
  1238.             return DBMappingUtils.existsMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, this.driverRegistroServizi.getTipoDB());
  1239.         }
  1240.         catch(Exception e){
  1241.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1242.         }
  1243.         finally{
  1244.             try{
  1245.                 this.driverRegistroServizi.releaseConnection(con);
  1246.             }catch(Exception eClose){
  1247.                 // close
  1248.             }
  1249.         }
  1250.     }
  1251.     
  1252.     public MappingFruizionePortaDelegata getMappingFruizionePortaDelegata(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata) throws DriverRegistroServiziException {
  1253.         Connection con = null;
  1254.         try{
  1255.             con = this.driverRegistroServizi.getConnection("getMappingFruizionePortaDelegata");
  1256.             return DBMappingUtils.getMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, this.driverRegistroServizi.getTipoDB());
  1257.         }
  1258.         catch(Exception e){
  1259.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1260.         }
  1261.         finally{
  1262.             try{
  1263.                 this.driverRegistroServizi.releaseConnection(con);
  1264.             }catch(Exception eClose){
  1265.                 // close
  1266.             }
  1267.         }
  1268.     }
  1269.     
  1270.     // Inefficiente
  1271.     @Deprecated 
  1272.     public void initMappingFruizione(Logger log) throws DriverRegistroServiziException {
  1273.         try{
  1274.             UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(this.driverConfigurazione, this.driverRegistroServizi, log);
  1275.             utilities.initMappingFruizione();
  1276.         }
  1277.         catch(Exception e){
  1278.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1279.         }
  1280.     }
  1281.     public void initMappingFruizioneById(Logger log, List<IDPortaDelegata> listPD) throws DriverRegistroServiziException {
  1282.         try{
  1283.             UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(this.driverConfigurazione, this.driverRegistroServizi, log);
  1284.             utilities.gestioneMappingFruizionePDbyId(listPD);
  1285.         }
  1286.         catch(Exception e){
  1287.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1288.         }
  1289.     }
  1290.     public void initMappingFruizione(Logger log, List<PortaDelegata> listPD) throws DriverRegistroServiziException {
  1291.         try{
  1292.             UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(this.driverConfigurazione, this.driverRegistroServizi, log);
  1293.             utilities.gestioneMappingFruizionePD(listPD);
  1294.         }
  1295.         catch(Exception e){
  1296.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1297.         }
  1298.     }
  1299.         
  1300.     
  1301.     
  1302.     // --- Porte Delegate ---
  1303.     
  1304.     public List<IDPortaDelegata> getAllIdPorteDelegate(FiltroRicercaPorteDelegate filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1305.         return this.driverConfigurazione.getAllIdPorteDelegate(filtroRicerca);
  1306.     }
  1307.     
  1308.     public org.openspcoop2.core.config.PortaDelegata getPortaDelegata(IDPortaDelegata idPortaDelegata) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1309.         return this.driverConfigurazione.getPortaDelegata(idPortaDelegata);
  1310.     }
  1311.     
  1312.     public boolean existsPortaDelegata(IDPortaDelegata idPortaDelegata) throws DriverConfigurazioneException {
  1313.         return this.driverConfigurazione.existsPortaDelegata(idPortaDelegata);
  1314.     }
  1315.     
  1316.     public void createPortaDelegata(org.openspcoop2.core.config.PortaDelegata portaDelegata) throws DriverConfigurazioneException {
  1317.         this.driverConfigurazione.createPortaDelegata(portaDelegata);
  1318.     }
  1319.     
  1320.     public void deletePortaDelegata(org.openspcoop2.core.config.PortaDelegata portaDelegata) throws DriverConfigurazioneException {
  1321.         this.driverConfigurazione.deletePortaDelegata(portaDelegata);
  1322.     }
  1323.     
  1324.     public void updatePortaDelegata(org.openspcoop2.core.config.PortaDelegata portaDelegata) throws DriverConfigurazioneException {
  1325.         this.driverConfigurazione.updatePortaDelegata(portaDelegata);
  1326.     }
  1327.     
  1328.     
  1329.     
  1330.     
  1331.     // --- Porte Applicative ---
  1332.     
  1333.     public List<IDPortaApplicativa> getAllIdPorteApplicative(FiltroRicercaPorteApplicative filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1334.         return this.driverConfigurazione.getAllIdPorteApplicative(filtroRicerca);
  1335.     }
  1336.     
  1337.     public org.openspcoop2.core.config.PortaApplicativa getPortaApplicativa(IDPortaApplicativa idPortaApplicativa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1338.         return this.driverConfigurazione.getPortaApplicativa(idPortaApplicativa);
  1339.     }
  1340.     
  1341.     public boolean existsPortaApplicativa(IDPortaApplicativa idPortaApplicativa) throws DriverConfigurazioneException {
  1342.         return this.driverConfigurazione.existsPortaApplicativa(idPortaApplicativa);
  1343.     }
  1344.     
  1345.     public void createPortaApplicativa(org.openspcoop2.core.config.PortaApplicativa portaApplicativa) throws DriverConfigurazioneException {
  1346.         this.driverConfigurazione.createPortaApplicativa(portaApplicativa);
  1347.     }
  1348.     
  1349.     public void deletePortaApplicativa(org.openspcoop2.core.config.PortaApplicativa portaApplicativa) throws DriverConfigurazioneException {
  1350.         this.driverConfigurazione.deletePortaApplicativa(portaApplicativa);
  1351.     }
  1352.     
  1353.     public void updatePortaApplicativa(org.openspcoop2.core.config.PortaApplicativa portaApplicativa) throws DriverConfigurazioneException {
  1354.         this.driverConfigurazione.updatePortaApplicativa(portaApplicativa);
  1355.     }
  1356.     
  1357.     
  1358.     
  1359.     
  1360.     // --- Controllo Traffico (Configurazione) ---
  1361.     
  1362.     public void updateControlloTraffico_configurazione(ConfigurazioneGenerale configurazione) throws DriverConfigurazioneException{
  1363.         try {
  1364.             this.serviceManagerControlloTraffico.getConfigurazioneGeneraleService().update(configurazione);
  1365.         }catch(Exception e) {
  1366.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1367.         }
  1368.     }
  1369.     
  1370.     public void deleteControlloTraffico_Configurazione(ConfigurazioneGenerale configurazione) throws DriverConfigurazioneException{
  1371.         try {
  1372.             this.serviceManagerControlloTraffico.getConfigurazioneGeneraleService().delete(configurazione);
  1373.         }catch(Exception e) {
  1374.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1375.         }
  1376.     }
  1377.     
  1378.     public ConfigurazioneGenerale getControlloTraffico_Configurazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1379.         try {
  1380.             return this.serviceManagerControlloTraffico.getConfigurazioneGeneraleService().get();
  1381.         }catch(NotFoundException e) {
  1382.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1383.         }catch(Exception e) {
  1384.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1385.         }
  1386.     }
  1387.     
  1388.     
  1389.     // --- Controllo Traffico (ConfigurazionePolicy) ---
  1390.     
  1391.     public List<IdPolicy> getAllIdControlloTraffico_configurationPolicies() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1392.         try {
  1393.             IPaginatedExpression pagExpr = this.serviceManagerControlloTraffico.getConfigurazionePolicyServiceSearch().newPaginatedExpression();
  1394.             List<IdPolicy> l = this.serviceManagerControlloTraffico.getConfigurazionePolicyServiceSearch().findAllIds(pagExpr);
  1395.             if(l==null || l.size()<=0) {
  1396.                 throw new NotFoundException("Non esistono policy");
  1397.             }
  1398.             return l;
  1399.         }catch(NotFoundException e) {
  1400.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1401.         }catch(Exception e) {
  1402.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1403.         }
  1404.     }
  1405.     
  1406.     public ConfigurazionePolicy getControlloTraffico_configurationPolicy(String idPolicy) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1407.         IdPolicy idPolicyObject = new IdPolicy();
  1408.         idPolicyObject.setNome(idPolicy);
  1409.         return this.getControlloTraffico_configurationPolicy(idPolicyObject);
  1410.     }
  1411.     public ConfigurazionePolicy getControlloTraffico_configurationPolicy(IdPolicy idPolicy) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1412.         try {
  1413.             return this.serviceManagerControlloTraffico.getConfigurazionePolicyServiceSearch().get(idPolicy);
  1414.         }catch(NotFoundException e) {
  1415.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1416.         }catch(Exception e) {
  1417.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1418.         }
  1419.     }
  1420.     
  1421.     public boolean existsControlloTraffico_configurationPolicy(String idPolicy) throws DriverConfigurazioneException {
  1422.         IdPolicy idPolicyObject = new IdPolicy();
  1423.         idPolicyObject.setNome(idPolicy);
  1424.         return this.existsControlloTraffico_configurationPolicy(idPolicyObject);
  1425.     }
  1426.     public boolean existsControlloTraffico_configurationPolicy(IdPolicy idPolicy) throws DriverConfigurazioneException {
  1427.         try {
  1428.             return this.serviceManagerControlloTraffico.getConfigurazionePolicyServiceSearch().exists(idPolicy);
  1429.         }catch(Exception e) {
  1430.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1431.         }
  1432.     }
  1433.     
  1434.     public void createControlloTraffico_configurationPolicy(ConfigurazionePolicy policy) throws DriverConfigurazioneException {
  1435.         try {
  1436.             this.serviceManagerControlloTraffico.getConfigurazionePolicyService().create(policy);
  1437.         }catch(Exception e) {
  1438.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1439.         }
  1440.     }
  1441.     
  1442.     public void updateControlloTraffico_configurationPolicy(ConfigurazionePolicy policy) throws DriverConfigurazioneException {
  1443.         try {
  1444.             IdPolicy oldId = new IdPolicy();
  1445.             oldId.setNome(policy.getIdPolicy());
  1446.             if(policy.getOldIdPolicy()!=null && policy.getOldIdPolicy().getNome()!=null) {
  1447.                 oldId.setNome(policy.getOldIdPolicy().getNome());
  1448.             }
  1449.             this.serviceManagerControlloTraffico.getConfigurazionePolicyService().update(oldId, policy);
  1450.         }catch(Exception e) {
  1451.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1452.         }
  1453.     }
  1454.     
  1455.     public void deleteControlloTraffico_configurationPolicy(ConfigurazionePolicy policy) throws DriverConfigurazioneException {
  1456.         try {
  1457.             this.serviceManagerControlloTraffico.getConfigurazionePolicyService().delete(policy);
  1458.         }catch(Exception e) {
  1459.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1460.         }
  1461.     }
  1462.     
  1463.     public boolean isControlloTraffico_configurationPolicyInUso(String idPolicy, List<String> whereIsInUso) throws DriverConfigurazioneException {
  1464.         IdPolicy idPolicyObject = new IdPolicy();
  1465.         idPolicyObject.setNome(idPolicy);
  1466.         return this.isControlloTraffico_configurationPolicyInUso(idPolicyObject,whereIsInUso);
  1467.     }
  1468.     public boolean isControlloTraffico_configurationPolicyInUso(IdPolicy idPolicy, List<String> whereIsInUso) throws DriverConfigurazioneException {
  1469.         try {
  1470.             IPaginatedExpression pagExpr = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().newPaginatedExpression();
  1471.             pagExpr.equals(AttivazionePolicy.model().ID_POLICY, idPolicy.getNome());
  1472.             List<IdActivePolicy> l = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().findAllIds(pagExpr);
  1473.             if(l==null || l.size()<=0) {
  1474.                 return false;
  1475.             }
  1476.             else {
  1477.                 for (IdActivePolicy idActivePolicy : l) {
  1478.                     whereIsInUso.add(idActivePolicy.getNome());
  1479.                 }
  1480.                 return true;    
  1481.             }
  1482.         }catch(Exception e) {
  1483.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1484.         }
  1485.     }
  1486.     
  1487.     
  1488.     // --- Controllo Traffico (AttivazionePolicy) ---
  1489.     
  1490.     public List<IdActivePolicy> getAllIdControlloTraffico_activePolicies_globali(String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1491.         return _getAllIdControlloTraffico_activePolicies(true, tag);
  1492.     }
  1493.     public List<IdActivePolicy> getAllIdControlloTraffico_activePolicies_erogazioniFruizioni(String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1494.         return _getAllIdControlloTraffico_activePolicies(false, tag);
  1495.     }
  1496.     public List<IdActivePolicy> getAllIdControlloTraffico_activePolicies_all(String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1497.         return _getAllIdControlloTraffico_activePolicies(null, tag);
  1498.     }
  1499.     private List<IdActivePolicy> _getAllIdControlloTraffico_activePolicies(Boolean globali, String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1500.         try {
  1501.             IPaginatedExpression pagExpr = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().newPaginatedExpression();
  1502.             pagExpr.and();
  1503.             if(globali!=null) {
  1504.                 if(globali) {
  1505.                     pagExpr.isNull(org.openspcoop2.core.controllo_traffico.AttivazionePolicy.model().FILTRO.NOME_PORTA);
  1506.                 }else {
  1507.                     pagExpr.isNotNull(org.openspcoop2.core.controllo_traffico.AttivazionePolicy.model().FILTRO.NOME_PORTA);
  1508.                 }
  1509.             }
  1510.             if(StringUtils.isNotEmpty(tag)) {
  1511.                 pagExpr.equals(org.openspcoop2.core.controllo_traffico.AttivazionePolicy.model().FILTRO.TAG, tag);
  1512.             }
  1513.             List<IdActivePolicy> l = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().findAllIds(pagExpr);
  1514.             if(l==null || l.size()<=0) {
  1515.                 throw new NotFoundException("Non esistono policy");
  1516.             }
  1517.             return l;
  1518.         }catch(NotFoundException e) {
  1519.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1520.         }catch(Exception e) {
  1521.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1522.         }
  1523.     }
  1524.     
  1525.     public List<IdActivePolicy> getAllIdControlloTraffico_activePolicies_fruizione(String nomePorta) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1526.         return _getAllIdControlloTraffico_activePolicies_porta(RuoloPolicy.DELEGATA, nomePorta);
  1527.     }
  1528.     public List<IdActivePolicy> getAllIdControlloTraffico_activePolicies_erogazione(String nomePorta) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{   
  1529.         return _getAllIdControlloTraffico_activePolicies_porta(RuoloPolicy.APPLICATIVA, nomePorta);
  1530.     }
  1531.     private List<IdActivePolicy> _getAllIdControlloTraffico_activePolicies_porta(RuoloPolicy ruoloPorta, String nomePorta) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1532.         try {
  1533.             IPaginatedExpression pagExpr = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().newPaginatedExpression();
  1534.             pagExpr.equals(org.openspcoop2.core.controllo_traffico.AttivazionePolicy.model().FILTRO.RUOLO_PORTA,ruoloPorta.getValue());
  1535.             pagExpr.and();
  1536.             pagExpr.equals(org.openspcoop2.core.controllo_traffico.AttivazionePolicy.model().FILTRO.NOME_PORTA,nomePorta);
  1537.             List<IdActivePolicy> l = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().findAllIds(pagExpr);
  1538.             if(l==null || l.size()<=0) {
  1539.                 throw new NotFoundException("Non esistono policy");
  1540.             }
  1541.             return l;
  1542.         }catch(NotFoundException e) {
  1543.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1544.         }catch(Exception e) {
  1545.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1546.         }
  1547.     }
  1548.     
  1549.     // Pericoloso: l'id è dinamico e dipende dal sistema dove viene usato.
  1550. //  public AttivazionePolicy getControlloTraffico_activePolicy(String IdActivePolicy) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1551. //      IdActivePolicy IdActivePolicyObject = new IdActivePolicy();
  1552. //      IdActivePolicyObject.setNome(IdActivePolicy);
  1553. //      return this.getControlloTraffico_activePolicy(IdActivePolicyObject);
  1554. //  }
  1555. //  public AttivazionePolicy getControlloTraffico_activePolicy(IdActivePolicy IdActivePolicy) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1556. //      try {
  1557. //          return this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().get(IdActivePolicy);
  1558. //      }catch(NotFoundException e) {
  1559. //          throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1560. //      }catch(Exception e) {
  1561. //          throw new DriverConfigurazioneException(e.getMessage(),e);
  1562. //      }
  1563. //  }
  1564.     public AttivazionePolicy getControlloTraffico_activePolicy(RuoloPolicy ruoloPorta, String nomePorta, String alias) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1565.         try {
  1566.             IExpression expr = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().newExpression();
  1567.             
  1568.             expr.and();
  1569.             
  1570.             if(ruoloPorta!=null && nomePorta!=null) {
  1571.                 expr.equals(AttivazionePolicy.model().FILTRO.RUOLO_PORTA, ruoloPorta);
  1572.                 expr.equals(AttivazionePolicy.model().FILTRO.NOME_PORTA, nomePorta);
  1573.             }
  1574.             else {
  1575.                 expr.isNull(AttivazionePolicy.model().FILTRO.NOME_PORTA);
  1576.             }
  1577.             
  1578.             expr.equals(AttivazionePolicy.model().ALIAS, alias);
  1579.             
  1580.             AttivazionePolicy att = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().find(expr);
  1581.             return att;
  1582.         }
  1583.         catch(NotFoundException e) {
  1584.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1585.         }
  1586.         catch(Exception e) {
  1587.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1588.         }
  1589.     }
  1590.     
  1591.     // Pericoloso: l'id è dinamico e dipende dal sistema dove viene usato.
  1592. //  public boolean existsControlloTraffico_activePolicy(String IdActivePolicy) throws DriverConfigurazioneException {
  1593. //      IdActivePolicy IdActivePolicyObject = new IdActivePolicy();
  1594. //      IdActivePolicyObject.setNome(IdActivePolicy);
  1595. //      return this.existsControlloTraffico_activePolicy(IdActivePolicyObject);
  1596. //  }
  1597. //  public boolean existsControlloTraffico_activePolicy(IdActivePolicy IdActivePolicy) throws DriverConfigurazioneException {
  1598. //      try {
  1599. //          return this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().exists(IdActivePolicy);
  1600. //      }catch(Exception e) {
  1601. //          throw new DriverConfigurazioneException(e.getMessage(),e);
  1602. //      }
  1603. //  }
  1604.     public boolean existsControlloTraffico_activePolicy(RuoloPolicy ruoloPorta, String nomePorta, String alias) throws DriverConfigurazioneException {
  1605.         try {
  1606.             IExpression expr = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().newExpression();
  1607.             
  1608.             expr.and();
  1609.             
  1610.             if(ruoloPorta!=null && nomePorta!=null) {
  1611.                 expr.equals(AttivazionePolicy.model().FILTRO.RUOLO_PORTA, ruoloPorta);
  1612.                 expr.equals(AttivazionePolicy.model().FILTRO.NOME_PORTA, nomePorta);
  1613.             }
  1614.             else {
  1615.                 expr.isNull(AttivazionePolicy.model().FILTRO.NOME_PORTA);
  1616.             }
  1617.             
  1618.             expr.equals(AttivazionePolicy.model().ALIAS, alias);
  1619.             
  1620.             AttivazionePolicy att = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().find(expr);
  1621.             return att!=null;
  1622.         }
  1623.         catch(NotFoundException notFound) {
  1624.             return false;
  1625.         }
  1626.         catch(Exception e) {
  1627.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1628.         }
  1629.     }
  1630.     public String getNextPolicyInstanceSerialId(String policyId, Logger log) throws RegistryException{
  1631.             
  1632.         Connection con = null;
  1633.         try {
  1634.             con = this.driverConfigurazione.getConnection("getNextPolicyInstanceSerialId");
  1635.             
  1636.             return ControlloTrafficoDriverUtils.getNextPolicyInstanceSerialId(policyId,
  1637.                     con, log, this.driverConfigurazione.getTipoDB());
  1638.             
  1639.         }
  1640.         catch(Exception e) {
  1641.             throw new RegistryException(e.getMessage(),e);
  1642.         }
  1643.         finally {
  1644.             try {
  1645.                 if(con!=null) {
  1646.                     this.driverConfigurazione.releaseConnection(con);
  1647.                 }
  1648.             }catch(Exception eClose) {
  1649.                 // close
  1650.             }
  1651.         }
  1652.         
  1653.     }
  1654.     
  1655.     protected void updatePosizioneBeforeCreate(AttivazionePolicy policy, Logger log) throws DriverConfigurazioneException{
  1656.         Connection con = null;
  1657.         try {
  1658.             con = this.driverConfigurazione.getConnection("updatePosizioneAttivazionePolicy");
  1659.             
  1660.             RuoloPolicy ruoloPorta=null;
  1661.             String nomePorta=null;
  1662.             if(policy.getFiltro()!=null) {
  1663.                 ruoloPorta = policy.getFiltro().getRuoloPorta();
  1664.                 nomePorta = policy.getFiltro().getNomePorta();
  1665.             }
  1666.         
  1667.             List<InfoPolicy> lst = ControlloTrafficoDriverUtils.getInfoPolicyList(null, policy.getIdPolicy(),
  1668.                     con, log, this.driverConfigurazione.getTipoDB()); 
  1669.             InfoPolicy infoPolicy = (lst != null && lst.size() > 0) ? lst.get(0) : null;
  1670.             if(infoPolicy==null) {
  1671.                 throw new Exception("Policy '"+policy.getIdPolicy()+"' non trovata");
  1672.             }
  1673.             ControlloTrafficoDriverUtils.updatePosizioneAttivazionePolicy(infoPolicy, policy,
  1674.                     ruoloPorta, nomePorta, 
  1675.                     con, log, this.driverConfigurazione.getTipoDB());           
  1676.         }
  1677.         catch(Exception e) {
  1678.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1679.         }
  1680.         finally {
  1681.             try {
  1682.                 if(con!=null) {
  1683.                     this.driverConfigurazione.releaseConnection(con);
  1684.                 }
  1685.             }catch(Exception eClose) {
  1686.                 // close
  1687.             }
  1688.         }
  1689.     }
  1690.     public void createControlloTraffico_activePolicy(AttivazionePolicy policy, Logger log) throws DriverConfigurazioneException {
  1691.         updatePosizioneBeforeCreate(policy, log);       
  1692.         try {
  1693.             this.serviceManagerControlloTraffico.getAttivazionePolicyService().create(policy);
  1694.         }catch(Exception e) {
  1695.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1696.         }
  1697.     }
  1698.     
  1699.     public void updateControlloTraffico_activePolicy(AttivazionePolicy policy) throws DriverConfigurazioneException {
  1700.         try {
  1701.             IdActivePolicy oldId = new IdActivePolicy();
  1702.             oldId.setNome(policy.getIdActivePolicy());
  1703.             if(policy.getOldIdActivePolicy()!=null && policy.getOldIdActivePolicy().getNome()!=null) {
  1704.                 oldId.setNome(policy.getOldIdActivePolicy().getNome());
  1705.             }
  1706.             this.serviceManagerControlloTraffico.getAttivazionePolicyService().update(oldId, policy);
  1707.         }catch(Exception e) {
  1708.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1709.         }
  1710.     }
  1711.     
  1712.     public void deleteControlloTraffico_activePolicy(AttivazionePolicy policy) throws DriverConfigurazioneException {
  1713.         try {
  1714.             // Il file importato potrebbe avere un identificativo diverso da quello effettivamente salvato
  1715.             if(policy.getAlias()==null) {
  1716.                 this.serviceManagerControlloTraffico.getAttivazionePolicyService().delete(policy);
  1717.             }
  1718.             else {
  1719.                 IExpression expr = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().newExpression();
  1720.                 
  1721.                 expr.and();
  1722.                 
  1723.                 if(policy.getFiltro()!=null && policy.getFiltro().getRuoloPorta()!=null && policy.getFiltro().getNomePorta()!=null) {
  1724.                     expr.equals(AttivazionePolicy.model().FILTRO.RUOLO_PORTA, policy.getFiltro().getRuoloPorta());
  1725.                     expr.equals(AttivazionePolicy.model().FILTRO.NOME_PORTA, policy.getFiltro().getNomePorta());
  1726.                 }
  1727.                 else {
  1728.                     expr.isNull(AttivazionePolicy.model().FILTRO.NOME_PORTA);
  1729.                 }
  1730.                 
  1731.                 expr.equals(AttivazionePolicy.model().ALIAS, policy.getAlias());
  1732.                 
  1733.                 try {
  1734.                     AttivazionePolicy att = this.serviceManagerControlloTraffico.getAttivazionePolicyServiceSearch().find(expr);
  1735.                     this.serviceManagerControlloTraffico.getAttivazionePolicyService().delete(att);
  1736.                 }catch(NotFoundException notFound) {}
  1737.             }
  1738.         }catch(Exception e) {
  1739.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1740.         }
  1741.     }
  1742.     
  1743.     public boolean isControlloTraffico_activePolicyInUso(RuoloPolicy ruoloPorta, String nomePorta, String alias, List<String> whereIsInUso) throws DriverRegistroServiziException {
  1744.         return false;
  1745.     }
  1746.     
  1747.     
  1748.     
  1749.     
  1750.     
  1751.     
  1752.     
  1753.     // --- Allarmi ---
  1754.     
  1755.     public List<IdAllarme> getAllIdAllarmi_globali(String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1756.         return _getAllIdAllarmi(true, tag);
  1757.     }
  1758.     public List<IdAllarme> getAllIdAllarmi_erogazioniFruizioni(String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1759.         return _getAllIdAllarmi(false, tag);
  1760.     }
  1761.     public List<IdAllarme> getAllIdAllarmi_all(String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1762.         return _getAllIdAllarmi(null, tag);
  1763.     }
  1764.     private List<IdAllarme> _getAllIdAllarmi(Boolean globali, String tag) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1765.         try {
  1766.             IPaginatedExpression pagExpr = this.serviceManagerAllarmi.getAllarmeServiceSearch().newPaginatedExpression();
  1767.             pagExpr.and();
  1768.             if(globali!=null) {
  1769.                 if(globali) {
  1770.                     pagExpr.isNull(org.openspcoop2.core.allarmi.Allarme.model().FILTRO.NOME_PORTA);
  1771.                 }else {
  1772.                     pagExpr.isNotNull(org.openspcoop2.core.allarmi.Allarme.model().FILTRO.NOME_PORTA);
  1773.                 }
  1774.             }
  1775.             if(StringUtils.isNotEmpty(tag)) {
  1776.                 pagExpr.equals(org.openspcoop2.core.allarmi.Allarme.model().FILTRO.TAG, tag);
  1777.             }
  1778.             List<IdAllarme> l = this.serviceManagerAllarmi.getAllarmeServiceSearch().findAllIds(pagExpr);
  1779.             if(l==null || l.size()<=0) {
  1780.                 throw new NotFoundException("Non esistono allarmi");
  1781.             }
  1782.             return l;
  1783.         }catch(NotFoundException e) {
  1784.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1785.         }catch(Exception e) {
  1786.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1787.         }
  1788.     }
  1789.     
  1790.     public List<IdAllarme> getAllIdAllarmi_fruizione(String nomePorta) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1791.         return _getAllIdAllarmi_porta(RuoloPorta.DELEGATA, nomePorta);
  1792.     }
  1793.     public List<IdAllarme> getAllIdAllarmi_erogazione(String nomePorta) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{ 
  1794.         return _getAllIdAllarmi_porta(RuoloPorta.APPLICATIVA, nomePorta);
  1795.     }
  1796.     private List<IdAllarme> _getAllIdAllarmi_porta(RuoloPorta ruoloPorta, String nomePorta) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1797.         try {
  1798.             IPaginatedExpression pagExpr = this.serviceManagerAllarmi.getAllarmeServiceSearch().newPaginatedExpression();
  1799.             pagExpr.equals(org.openspcoop2.core.allarmi.Allarme.model().FILTRO.RUOLO_PORTA,ruoloPorta.getValue());
  1800.             pagExpr.and();
  1801.             pagExpr.equals(org.openspcoop2.core.allarmi.Allarme.model().FILTRO.NOME_PORTA,nomePorta);
  1802.             List<IdAllarme> l = this.serviceManagerAllarmi.getAllarmeServiceSearch().findAllIds(pagExpr);
  1803.             if(l==null || l.size()<=0) {
  1804.                 throw new NotFoundException("Non esistono allarmi");
  1805.             }
  1806.             return l;
  1807.         }catch(NotFoundException e) {
  1808.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1809.         }catch(Exception e) {
  1810.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1811.         }
  1812.     }
  1813.     
  1814.     // Pericoloso: l'id è dinamico e dipende dal sistema dove viene usato.
  1815. //  public Allarme getAllarme(String IdAllarme) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1816. //      IdAllarme IdAllarmeObject = new IdAllarme();
  1817. //      IdAllarmeObject.setNome(IdAllarme);
  1818. //      return this.getAllarme(IdAllarmeObject);
  1819. //  }
  1820. //  public Allarme getAllarme(IdAllarme IdAllarme) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1821. //      try {
  1822. //          return this.serviceManagerAllarmi.getAllarmeServiceSearch().get(IdAllarme);
  1823. //      }catch(NotFoundException e) {
  1824. //          throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1825. //      }catch(Exception e) {
  1826. //          throw new DriverConfigurazioneException(e.getMessage(),e);
  1827. //      }
  1828. //  }
  1829.     public Allarme getAllarme(RuoloPorta ruoloPorta, String nomePorta, String alias) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1830.         try {
  1831.             IExpression expr = this.serviceManagerAllarmi.getAllarmeServiceSearch().newExpression();
  1832.             
  1833.             expr.and();
  1834.             
  1835.             if(ruoloPorta!=null && nomePorta!=null) {
  1836.                 expr.equals(Allarme.model().FILTRO.RUOLO_PORTA, ruoloPorta);
  1837.                 expr.equals(Allarme.model().FILTRO.NOME_PORTA, nomePorta);
  1838.             }
  1839.             else {
  1840.                 expr.isNull(Allarme.model().FILTRO.NOME_PORTA);
  1841.             }
  1842.             
  1843.             expr.equals(Allarme.model().ALIAS, alias);
  1844.             
  1845.             Allarme att = this.serviceManagerAllarmi.getAllarmeServiceSearch().find(expr);
  1846.             return att;
  1847.         }
  1848.         catch(NotFoundException e) {
  1849.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  1850.         }
  1851.         catch(Exception e) {
  1852.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1853.         }
  1854.     }
  1855.     
  1856.     // Pericoloso: l'id è dinamico e dipende dal sistema dove viene usato.
  1857. //  public boolean existsAllarme(String IdAllarme) throws DriverConfigurazioneException {
  1858. //      IdAllarme IdAllarmeObject = new IdAllarme();
  1859. //      IdAllarmeObject.setNome(IdAllarme);
  1860. //      return this.existsAllarme(IdAllarmeObject);
  1861. //  }
  1862. //  public boolean existsAllarme(IdAllarme IdAllarme) throws DriverConfigurazioneException {
  1863. //      try {
  1864. //          return this.serviceManagerAllarmi.getAllarmeServiceSearch().exists(IdAllarme);
  1865. //      }catch(Exception e) {
  1866. //          throw new DriverConfigurazioneException(e.getMessage(),e);
  1867. //      }
  1868. //  }
  1869.     public boolean existsAllarme(RuoloPorta ruoloPorta, String nomePorta, String alias) throws DriverConfigurazioneException {
  1870.         try {
  1871.             IExpression expr = this.serviceManagerAllarmi.getAllarmeServiceSearch().newExpression();
  1872.             
  1873.             expr.and();
  1874.             
  1875.             if(ruoloPorta!=null && nomePorta!=null) {
  1876.                 expr.equals(Allarme.model().FILTRO.RUOLO_PORTA, ruoloPorta);
  1877.                 expr.equals(Allarme.model().FILTRO.NOME_PORTA, nomePorta);
  1878.             }
  1879.             else {
  1880.                 expr.isNull(Allarme.model().FILTRO.NOME_PORTA);
  1881.             }
  1882.             
  1883.             expr.equals(Allarme.model().ALIAS, alias);
  1884.             
  1885.             Allarme att = this.serviceManagerAllarmi.getAllarmeServiceSearch().find(expr);
  1886.             return att!=null;
  1887.         }
  1888.         catch(NotFoundException notFound) {
  1889.             return false;
  1890.         }
  1891.         catch(Exception e) {
  1892.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1893.         }
  1894.     }
  1895.     public String getNextAlarmInstanceSerialId(String policyId, Logger log) throws RegistryException{
  1896.             
  1897.         Connection con = null;
  1898.         try {
  1899.             con = this.driverConfigurazione.getConnection("getNextAlarmInstanceSerialId");
  1900.             
  1901.             return AllarmiDriverUtils.getNextAlarmInstanceSerialId(policyId,
  1902.                     con, log, this.driverConfigurazione.getTipoDB());
  1903.             
  1904.         }
  1905.         catch(Exception e) {
  1906.             throw new RegistryException(e.getMessage(),e);
  1907.         }
  1908.         finally {
  1909.             try {
  1910.                 if(con!=null) {
  1911.                     this.driverConfigurazione.releaseConnection(con);
  1912.                 }
  1913.             }catch(Exception eClose) {
  1914.                 // close
  1915.             }
  1916.         }
  1917.         
  1918.     }
  1919.     
  1920.     
  1921.     public void createAllarme(Allarme allarme, Logger log) throws DriverConfigurazioneException {
  1922.         try {
  1923.             this.serviceManagerAllarmi.getAllarmeService().create(allarme);
  1924.         }catch(Exception e) {
  1925.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1926.         }
  1927.     }
  1928.     
  1929.     public void updateAllarme(Allarme allarme, Logger log) throws DriverConfigurazioneException {
  1930.         try {
  1931.             IdAllarme oldId = new IdAllarme();
  1932.             oldId.setNome(allarme.getNome());
  1933. //          if(allarme.get!=null && allarme.getOldIdAllarme().getNome()!=null) {
  1934. //              oldId.setNome(allarme.getOldIdAllarme().getNome());
  1935. //          }
  1936.             this.serviceManagerAllarmi.getAllarmeService().update(oldId, allarme);
  1937.         }catch(Exception e) {
  1938.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1939.         }
  1940.     }
  1941.     
  1942.     public void deleteAllarme(Allarme policy, Logger log) throws DriverConfigurazioneException {
  1943.         try {
  1944.             // Il file importato potrebbe avere un identificativo diverso da quello effettivamente salvato
  1945.             if(policy.getAlias()==null) {
  1946.                 this.serviceManagerAllarmi.getAllarmeService().delete(policy);
  1947.             }
  1948.             else {
  1949.                 IExpression expr = this.serviceManagerAllarmi.getAllarmeService().newExpression();
  1950.                 
  1951.                 expr.and();
  1952.                 
  1953.                 if(policy.getFiltro()!=null && policy.getFiltro().getRuoloPorta()!=null && policy.getFiltro().getNomePorta()!=null) {
  1954.                     expr.equals(AttivazionePolicy.model().FILTRO.RUOLO_PORTA, policy.getFiltro().getRuoloPorta());
  1955.                     expr.equals(AttivazionePolicy.model().FILTRO.NOME_PORTA, policy.getFiltro().getNomePorta());
  1956.                 }
  1957.                 else {
  1958.                     expr.isNull(AttivazionePolicy.model().FILTRO.NOME_PORTA);
  1959.                 }
  1960.                 
  1961.                 expr.equals(AttivazionePolicy.model().ALIAS, policy.getAlias());
  1962.                 
  1963.                 try {
  1964.                     Allarme all = this.serviceManagerAllarmi.getAllarmeService().find(expr);
  1965.                     this.serviceManagerAllarmi.getAllarmeService().delete(all);
  1966.                 }catch(NotFoundException notFound) {}
  1967.             }
  1968.         }catch(Exception e) {
  1969.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1970.         }
  1971.     }
  1972.     
  1973.     public boolean isAllarmeInUso(RuoloPorta ruoloPorta, String nomePorta, String alias, List<String> whereIsInUso) throws DriverRegistroServiziException {
  1974.         return false;
  1975.     }
  1976.     
  1977.     
  1978.     
  1979.     
  1980.     
  1981.     
  1982.     
  1983.     
  1984.     
  1985.     // --- Token Policy ---
  1986.     
  1987.     public List<IDGenericProperties> getAllIdGenericProperties(String tipologia) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1988.         return _getAllIdGenericProperties(tipologia);
  1989.     }
  1990.     public List<IDGenericProperties> getAllIdGenericProperties_validation() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1991.         return _getAllIdGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION);
  1992.     }
  1993.     public List<IDGenericProperties> getAllIdGenericProperties_retrieve() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1994.         return _getAllIdGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE);
  1995.     }
  1996.     public List<IDGenericProperties> getAllIdGenericProperties_attributeAuthorities() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1997.         return _getAllIdGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY);
  1998.     }
  1999.     private List<IDGenericProperties> _getAllIdGenericProperties(String tipologia) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2000.         try {
  2001.             List<GenericProperties> l = this.driverConfigurazione.getGenericProperties(tipologia);
  2002.             if(l==null || l.isEmpty()) {
  2003.                 throw new DriverConfigurazioneNotFound();
  2004.             }
  2005.             List<IDGenericProperties> lNew = new ArrayList<IDGenericProperties>();
  2006.             for (GenericProperties genericProperties : l) {
  2007.                 
  2008.                 if(!tipologia.equals(genericProperties.getTipologia())) {
  2009.                     continue;
  2010.                 }
  2011.                 
  2012.                 IDGenericProperties id = new IDGenericProperties();
  2013.                 id.setNome(genericProperties.getNome());
  2014.                 id.setTipologia(tipologia);
  2015.                 lNew.add(id);
  2016.             }
  2017.             return lNew;
  2018.         }catch(DriverConfigurazioneNotFound e) {
  2019.             throw e;
  2020.         }catch(Exception e) {
  2021.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2022.         }
  2023.     }
  2024.     
  2025.     public GenericProperties getGenericProperties(String tipologia, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2026.         return _getGenericProperties(tipologia, nome);
  2027.     }
  2028.     public GenericProperties getGenericProperties(IDGenericProperties idGP) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2029.         return _getGenericProperties(idGP.getTipologia(), idGP.getNome());
  2030.     }
  2031.     public GenericProperties getGenericProperties_validation(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2032.         return _getGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION, nome);
  2033.     }
  2034.     public GenericProperties getGenericProperties_retrieve(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2035.         return _getGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE, nome);
  2036.     }
  2037.     public GenericProperties getGenericProperties_attributeAuthority(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2038.         return _getGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY, nome);
  2039.     }
  2040.     private GenericProperties _getGenericProperties(String tipologia, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2041.         try {
  2042.             GenericProperties gp = this.driverConfigurazione.getGenericProperties(tipologia, nome);
  2043.             if(gp==null) {
  2044.                 throw new DriverConfigurazioneNotFound();
  2045.             }
  2046.             return gp;
  2047.         }catch(DriverConfigurazioneNotFound e) {
  2048.             throw e;
  2049.         }catch(Exception e) {
  2050.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2051.         }
  2052.     }
  2053.     
  2054.     public boolean existsGenericProperties(String tipologia, String nome) throws DriverConfigurazioneException {
  2055.         return _existsGenericProperties(tipologia, nome);
  2056.     }
  2057.     public boolean existsGenericProperties(IDGenericProperties idGP) throws DriverConfigurazioneException {
  2058.         return _existsGenericProperties(idGP.getTipologia(), idGP.getNome());
  2059.     }
  2060.     public boolean existsGenericProperties_validation(String nome) throws DriverConfigurazioneException{
  2061.         return _existsGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION, nome);
  2062.     }
  2063.     public boolean existsGenericProperties_retrieve(String nome) throws DriverConfigurazioneException{
  2064.         return _existsGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE, nome);
  2065.     }
  2066.     public boolean existsGenericProperties_attributeAuthority(String nome) throws DriverConfigurazioneException{
  2067.         return _existsGenericProperties(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY, nome);
  2068.     }
  2069.     private boolean _existsGenericProperties(String tipologia, String nome) throws DriverConfigurazioneException{
  2070.         try {
  2071.             GenericProperties gp = this.driverConfigurazione.getGenericProperties(tipologia, nome);
  2072.             return gp!=null;
  2073.         }catch(DriverConfigurazioneNotFound e) {
  2074.             return false;
  2075.         }catch(Exception e) {
  2076.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2077.         }
  2078.     }

  2080.     public void createGenericProperties(GenericProperties gp) throws DriverConfigurazioneException{
  2081.         try {
  2082.             this.driverConfigurazione.createGenericProperties(gp);
  2083.         }catch(Exception e) {
  2084.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2085.         }
  2086.     }
  2087.     public void updateGenericProperties(GenericProperties gp) throws DriverConfigurazioneException{
  2088.         try {
  2089.             this.driverConfigurazione.updateGenericProperties(gp);
  2090.         }catch(Exception e) {
  2091.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2092.         }
  2093.     }
  2094.     public void deleteGenericProperties(GenericProperties gp) throws DriverConfigurazioneException{
  2095.         try {
  2096.             this.driverConfigurazione.deleteGenericProperties(gp);
  2097.         }catch(Exception e) {
  2098.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2099.         }
  2100.     }
  2101.     
  2102.     public boolean isGenericPropertiesInUso(String tipologia, String nome, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  2103.         IDGenericProperties idGP = new IDGenericProperties();
  2104.         idGP.setTipologia(tipologia);
  2105.         idGP.setNome(nome);
  2106.         return this.isGenericPropertiesInUso(idGP,whereIsInUso, normalizeObjectIds);
  2107.     }
  2108.     public boolean isGenericPropertiesInUso(IDGenericProperties idGP, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  2109.         Connection con = null;
  2110.         try{
  2111.             con = this.driverRegistroServizi.getConnection("archive.isGenericPropertiesInUso");
  2112.             return DBOggettiInUsoUtils.isGenericPropertiesInUso(con, this.driverRegistroServizi.getTipoDB(), idGP, whereIsInUso, normalizeObjectIds);
  2113.         }
  2114.         catch(Exception e){
  2115.             throw new DriverRegistroServiziException(e.getMessage(),e);
  2116.         }
  2117.         finally{
  2118.             try{
  2119.                 this.driverRegistroServizi.releaseConnection(con);
  2120.             }catch(Exception eClose){
  2121.                 // close
  2122.             }
  2123.         }
  2124.     }
  2125.     
  2126.     
  2127.     
  2128.     
  2129.     
  2130.     
  2131.     // Plugin Classe
  2132.     
  2133.     public List<IdPlugin> getAllIdPluginClasse() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2134.         return _getAllIdPluginClasse(null);
  2135.     }
  2136.     private List<IdPlugin> _getAllIdPluginClasse(String tipoPlugin) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2137.         try {
  2138.             IPaginatedExpression pagExpr = this.serviceManagerPlugins.getPluginServiceSearch().newPaginatedExpression();
  2139.             if(tipoPlugin!=null) {
  2140.                 pagExpr.equals(org.openspcoop2.core.plugins.Plugin.model().TIPO_PLUGIN, tipoPlugin);
  2141.             }
  2142.             List<IdPlugin> l = this.serviceManagerPlugins.getPluginServiceSearch().findAllIds(pagExpr);
  2143.             if(l==null || l.size()<=0) {
  2144.                 throw new NotFoundException("Non esistono plugins");
  2145.             }
  2146.             return l;
  2147.         }catch(NotFoundException e) {
  2148.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  2149.         }catch(Exception e) {
  2150.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2151.         }
  2152.     }
  2153.     
  2154.     public Plugin getPluginClasse(String tipoPlugin, String tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2155.         IdPlugin idPluginObject = new IdPlugin();
  2156.         idPluginObject.setTipoPlugin(tipoPlugin);
  2157.         idPluginObject.setTipo(tipo);
  2158.         return this.getPluginClasse(idPluginObject);
  2159.     }
  2160.     public Plugin getPluginClasse(IdPlugin idPlugin) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2161.         try {
  2162.             return this.serviceManagerPlugins.getPluginServiceSearch().get(idPlugin);
  2163.         }catch(NotFoundException e) {
  2164.             throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  2165.         }catch(Exception e) {
  2166.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2167.         }
  2168. //      try {
  2169. //          IExpression expr = this.serviceManagerPlugins.getPluginServiceSearch().newExpression();
  2170. //          expr.equals(org.openspcoop2.core.plugins.Plugin.model().TIPO_PLUGIN, idPlugin.getTipoPlugin());
  2171. //          expr.equals(org.openspcoop2.core.plugins.Plugin.model().TIPO, idPlugin.getTipo());
  2172. //          return this.serviceManagerPlugins.getPluginServiceSearch().find(expr);
  2173. //      }catch(NotFoundException e) {
  2174. //          throw new DriverConfigurazioneNotFound(e.getMessage(),e);
  2175. //      }catch(Exception e) {
  2176. //          throw new DriverConfigurazioneException(e.getMessage(),e);
  2177. //      }
  2178.     }
  2179.     
  2180.     public boolean existsPluginClasse(String tipoPlugin, String tipo) throws DriverConfigurazioneException {
  2181.         IdPlugin idPluginObject = new IdPlugin();
  2182.         idPluginObject.setTipoPlugin(tipoPlugin);
  2183.         idPluginObject.setTipo(tipo);
  2184.         return this.existsPluginClasse(idPluginObject);
  2185.     }
  2186.     public boolean existsPluginClasse(IdPlugin idPlugin) throws DriverConfigurazioneException {
  2187.         try {
  2188.             return this.serviceManagerPlugins.getPluginServiceSearch().exists(idPlugin);
  2189.         }catch(Exception e) {
  2190.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2191.         }
  2192. //      try {
  2193. //          IExpression expr = this.serviceManagerPlugins.getPluginServiceSearch().newExpression();
  2194. //          expr.equals(org.openspcoop2.core.plugins.Plugin.model().TIPO_PLUGIN, idPlugin.getTipoPlugin());
  2195. //          expr.equals(org.openspcoop2.core.plugins.Plugin.model().TIPO, idPlugin.getTipo());
  2196. //          NonNegativeNumber nn = this.serviceManagerPlugins.getPluginServiceSearch().count(expr);
  2197. //          if(nn!=null) {
  2198. //              if(nn.longValue()>1) {
  2199. //                  throw new MultipleResultException("Trovate "+nn.longValue()+" occorrenze");
  2200. //              }
  2201. //              else if(nn.longValue()==1) {
  2202. //                  return true;
  2203. //              }
  2204. //          }
  2205. //          return false;
  2206. //      }catch(Exception e) {
  2207. //          throw new DriverConfigurazioneException(e.getMessage(),e);
  2208. //      }
  2209.     }
  2210.     
  2211.     
  2212.     public void createPluginClasse(Plugin plugin) throws DriverConfigurazioneException {
  2213.         try {
  2214.             this.serviceManagerPlugins.getPluginService().create(plugin);
  2215.         }catch(Exception e) {
  2216.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2217.         }
  2218.     }
  2219.     
  2220.     public void updatePluginClasse(Plugin plugin) throws DriverConfigurazioneException {
  2221.         try {
  2222.             IdPlugin oldId = new IdPlugin();
  2223.             oldId.setTipoPlugin(plugin.getTipoPlugin());
  2224.             oldId.setTipo(plugin.getTipo());
  2225.             if(plugin.getOldIdPlugin()!=null && plugin.getOldIdPlugin().getTipoPlugin()!=null) {
  2226.                 oldId.setTipoPlugin(plugin.getOldIdPlugin().getTipoPlugin());
  2227.             }
  2228.             if(plugin.getOldIdPlugin()!=null && plugin.getOldIdPlugin().getTipo()!=null) {
  2229.                 oldId.setTipo(plugin.getOldIdPlugin().getTipo());
  2230.             }
  2231.             this.serviceManagerPlugins.getPluginService().update(oldId, plugin);
  2232.         }catch(Exception e) {
  2233.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2234.         }
  2235.     }
  2236.     
  2237.     public void deletePluginClasse(Plugin plugin) throws DriverConfigurazioneException {
  2238.         try {
  2239.             this.serviceManagerPlugins.getPluginService().delete(plugin);
  2240.         }catch(Exception e) {
  2241.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2242.         }
  2243.     }
  2244.     
  2245.     public boolean isPluginClasseInUso(IdPlugin idPlugin, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  2246.         Connection con = null;
  2247.         try{
  2248.             con = this.driverConfigurazione.getConnection("archive.isPluginClasseInUso");
  2249.             return DBOggettiInUsoUtils.isPluginInUso(con, this.driverRegistroServizi.getTipoDB(), 
  2250.                     idPlugin.getClassName(), idPlugin.getLabel(), idPlugin.getTipoPlugin(), idPlugin.getTipo(), 
  2251.                     whereIsInUso, normalizeObjectIds);
  2252.         }
  2253.         catch(Exception e){
  2254.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2255.         }
  2256.         finally{
  2257.             try{
  2258.                 this.driverConfigurazione.releaseConnection(con);
  2259.             }catch(Exception eClose){
  2260.                 // close
  2261.             }
  2262.         }
  2263.     }
  2264.     
  2265.     
  2266.     
  2267.     
  2268.     
  2269.     
  2270.     
  2271.     
  2272.     
  2273.     // --- Plugin Archivio ---
  2274.     
  2275.     public List<String> getAllIdPluginArchivio() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2276.         try {
  2277.             RegistroPlugins registroPlugins = this.driverConfigurazione.getRegistroPlugins();
  2278.             List<String> l = new ArrayList<>();
  2279.             if(registroPlugins!=null && registroPlugins.sizePluginList()>0) {
  2280.                 for (RegistroPlugin registroPlugin : registroPlugins.getPluginList()) {
  2281.                     l.add(registroPlugin.getNome());
  2282.                 }
  2283.             }
  2284.             if(l==null || l.isEmpty()) {
  2285.                 throw new DriverConfigurazioneNotFound();
  2286.             }
  2287.             return l;
  2288.         }catch(DriverConfigurazioneNotFound e) {
  2289.             throw e;
  2290.         }catch(Exception e) {
  2291.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2292.         }
  2293.     }
  2294.     
  2295.     public RegistroPlugin getPluginArchivio(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2296.         try {
  2297.             RegistroPlugins registroPlugins = this.driverConfigurazione.getRegistroPlugins();
  2298.             RegistroPlugin rp = null;
  2299.             if(registroPlugins!=null && registroPlugins.sizePluginList()>0) {
  2300.                 for (RegistroPlugin registroPlugin : registroPlugins.getPluginList()) {
  2301.                     if(nome.equals(registroPlugin.getNome())) {
  2302.                         rp = registroPlugin;
  2303.                         break;
  2304.                     }
  2305.                 }
  2306.             }
  2307.             if(rp==null) {
  2308.                 throw new DriverConfigurazioneNotFound();
  2309.             }
  2310.             return rp;
  2311.         }catch(DriverConfigurazioneNotFound e) {
  2312.             throw e;
  2313.         }catch(Exception e) {
  2314.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2315.         }
  2316.     }
  2317.     
  2318.     public boolean existsPluginArchivio(String nome) throws DriverConfigurazioneException {
  2319.         try {
  2320.             RegistroPlugin rp = getPluginArchivio(nome);
  2321.             return rp!=null;
  2322.         }catch(DriverConfigurazioneNotFound e) {
  2323.             return false;
  2324.         }catch(Exception e) {
  2325.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2326.         }
  2327.     }

  2329.     protected void updatePosizioneBeforeCreate(RegistroPlugin rp) throws DriverConfigurazioneException{
  2330.         try {
  2331.             // calcolo prossima posizione
  2332.             int posizione = this.driverConfigurazione.getMaxPosizioneRegistroPlugin() + 1;
  2333.             rp.setPosizione(posizione);
  2334.         }catch(Exception e) {
  2335.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2336.         }
  2337.     }
  2338.     protected void updateDate(RegistroPlugin rp) throws DriverConfigurazioneException{
  2339.         try {
  2340.             // aggiorno tutte le date
  2341.             rp.setData(DateManager.getDate());
  2342.             if(rp.sizeArchivioList()>0) {
  2343.                 for (RegistroPluginArchivio rpa : rp.getArchivioList()) {
  2344.                     rpa.setData(DateManager.getDate());
  2345.                 }
  2346.             }
  2347.         }catch(Exception e) {
  2348.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2349.         }
  2350.     }
  2351.     public void createPluginArchivio(RegistroPlugin rp) throws DriverConfigurazioneException{
  2352.         updatePosizioneBeforeCreate(rp);
  2353.         updateDate(rp);
  2354.         try {
  2355.             this.driverConfigurazione.createRegistroPlugin(rp);
  2356.         }catch(Exception e) {
  2357.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2358.         }
  2359.     }
  2360.     public void updatePluginArchivio(RegistroPlugin rp) throws DriverConfigurazioneException{
  2361.         updateDate(rp);
  2362.         try {
  2363.             this.driverConfigurazione.updateRegistroPlugin(rp);
  2364.         }catch(Exception e) {
  2365.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2366.         }
  2367.     }
  2368.     public void deletePluginArchivio(RegistroPlugin rp) throws DriverConfigurazioneException{
  2369.         try {
  2370.             this.driverConfigurazione.deleteRegistroPlugin(rp);
  2371.         }catch(Exception e) {
  2372.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2373.         }
  2374.     }
  2375.     
  2376.     public boolean isPluginArchivioInUso(String nome, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  2377.         return false;
  2378.     }
  2379.     
  2380.     
  2381.     
  2382.     
  2383.     
  2384.     
  2385.     // --- Url Invocazione Regole ---
  2386.     
  2387.     public List<String> getAllIdUrlInvocazioneRegola() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2388.         try {
  2389.             ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = this.driverConfigurazione.getConfigurazioneGenerale().getUrlInvocazione();
  2390.             List<String> l = new ArrayList<>();
  2391.             if(configurazioneUrlInvocazione!=null && configurazioneUrlInvocazione.sizeRegolaList()>0) {
  2392.                 for (ConfigurazioneUrlInvocazioneRegola regola : configurazioneUrlInvocazione.getRegolaList()) {
  2393.                     l.add(regola.getNome());
  2394.                 }
  2395.             }
  2396.             if(l==null || l.isEmpty()) {
  2397.                 throw new DriverConfigurazioneNotFound();
  2398.             }
  2399.             return l;
  2400.         }catch(DriverConfigurazioneNotFound e) {
  2401.             throw e;
  2402.         }catch(Exception e) {
  2403.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2404.         }
  2405.     }
  2406.     
  2407.     public ConfigurazioneUrlInvocazioneRegola getUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2408.         try {
  2409.             return this.driverConfigurazione.getUrlInvocazioneRegola(nome);
  2410.         }catch(DriverConfigurazioneNotFound e) {
  2411.             throw e;
  2412.         }catch(Exception e) {
  2413.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2414.         }
  2415.     }
  2416.     
  2417.     public boolean existsUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException {
  2418.         try {
  2419.             return this.driverConfigurazione.existsUrlInvocazioneRegola(nome);
  2420.         }catch(DriverConfigurazioneNotFound e) {
  2421.             return false;
  2422.         }catch(Exception e) {
  2423.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2424.         }
  2425.     }

  2427.     protected void updatePosizioneBeforeCreate(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  2428.         try {
  2429.             // calcolo prossima posizione
  2430.             int posizione = ConfigurazionePdDUtils.getProssimaPosizioneUrlInvocazioneRegola(this.driverConfigurazione.getConfigurazioneGenerale());
  2431.             regola.setPosizione(posizione);
  2432.         }catch(Exception e) {
  2433.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2434.         }
  2435.     }
  2436.     public void createUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  2437.         updatePosizioneBeforeCreate(regola);
  2438.         try {
  2439.             this.driverConfigurazione.createUrlInvocazioneRegola(regola);
  2440.         }catch(Exception e) {
  2441.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2442.         }
  2443.     }
  2444.     public void updateUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  2445.         try {
  2446.             this.driverConfigurazione.updateUrlInvocazioneRegola(regola);
  2447.         }catch(Exception e) {
  2448.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2449.         }
  2450.     }
  2451.     public void deleteUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  2452.         try {
  2453.             this.driverConfigurazione.deleteUrlInvocazioneRegola(regola);
  2454.         }catch(Exception e) {
  2455.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2456.         }
  2457.     }
  2458.     
  2459.     public boolean isUrlInvocazioneRegolaInUso(String nome, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  2460.         return false;
  2461.     }
  2462.     
  2463.     
  2464.     
  2465.     
  2466.     
  2467.     // --- Configurazione (Url Invocazione) ---
  2468.     
  2469.     public void updateConfigurazione_UrlInvocazione(ConfigurazioneUrlInvocazione configurazione) throws DriverConfigurazioneException{
  2470.         try {
  2471.             Configurazione config = this.driverConfigurazione.getConfigurazioneGenerale();
  2472.             if(config.getUrlInvocazione()==null) {
  2473.                 config.setUrlInvocazione(configurazione);
  2474.             }
  2475.             else {
  2476.                 config.getUrlInvocazione().setBaseUrl(configurazione.getBaseUrl());
  2477.                 config.getUrlInvocazione().setBaseUrlFruizione(configurazione.getBaseUrlFruizione());
  2478.             }
  2479.             this.driverConfigurazione.updateConfigurazione(config);
  2480.         }catch(Exception e) {
  2481.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2482.         }
  2483.     }
  2484.     
  2485.     
  2486.     
  2487.     
  2488.     
  2489.     
  2490.     // --- ConfigurazionePdD ---
  2491.     
  2492.     public void updateConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException{
  2493.         if(configurazione.getRoutingTable()!=null){
  2494.             this.driverConfigurazione.updateRoutingTable(configurazione.getRoutingTable());
  2495.         }
  2496.         if(configurazione.getAccessoRegistro()!=null){
  2497.             this.driverConfigurazione.updateAccessoRegistro(configurazione.getAccessoRegistro());
  2498.         }
  2499.         if(configurazione.getGestioneErrore()!=null){
  2500.             if(configurazione.getGestioneErrore().getComponenteCooperazione()!=null){
  2501.                 this.driverConfigurazione.updateGestioneErroreComponenteCooperazione(configurazione.getGestioneErrore().getComponenteCooperazione());
  2502.             }
  2503.             if(configurazione.getGestioneErrore().getComponenteIntegrazione()!=null){
  2504.                 this.driverConfigurazione.updateGestioneErroreComponenteIntegrazione(configurazione.getGestioneErrore().getComponenteIntegrazione());
  2505.             }
  2506.         }
  2507.         if(configurazione.getStatoServiziPdd()!=null){
  2508.             this.driverConfigurazione.updateStatoServiziPdD(configurazione.getStatoServiziPdd());
  2509.         }
  2510.         if(configurazione.getSystemProperties()!=null){
  2511.             this.driverConfigurazione.updateSystemPropertiesPdD(configurazione.getSystemProperties());
  2512.         }
  2513.         this.driverConfigurazione.updateConfigurazione(configurazione);
  2514.     }
  2515.     public void deleteConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException{
  2516.         this.driverConfigurazione.deleteConfigurazione(configurazione);
  2517.     }

  2519.     public Configurazione getConfigurazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2520.         Configurazione configurazione = this.driverConfigurazione.getConfigurazioneGenerale();
  2521.         configurazione.setRoutingTable(this.driverConfigurazione.getRoutingTable());
  2522.         configurazione.setAccessoRegistro(this.driverConfigurazione.getAccessoRegistro());
  2523.         try{
  2524.             configurazione.setAccessoConfigurazione(this.driverConfigurazione.getAccessoConfigurazione());
  2525.         }catch(DriverConfigurazioneNotFound notFound){}
  2526.         try{
  2527.             configurazione.setAccessoDatiAutorizzazione(this.driverConfigurazione.getAccessoDatiAutorizzazione());
  2528.         }catch(DriverConfigurazioneNotFound notFound){}
  2529.         GestioneErrore gestioneErroreCooperazione = null;
  2530.         GestioneErrore gestioneErroreIntegrazione = null;
  2531.         try{
  2532.             gestioneErroreCooperazione = this.driverConfigurazione.getGestioneErroreComponenteCooperazione();
  2533.         }catch(DriverConfigurazioneNotFound notFound){}
  2534.         try{
  2535.             gestioneErroreIntegrazione = this.driverConfigurazione.getGestioneErroreComponenteIntegrazione();
  2536.         }catch(DriverConfigurazioneNotFound notFound){}
  2537.         if(gestioneErroreCooperazione!=null || gestioneErroreIntegrazione!=null){
  2538.             if(configurazione.getGestioneErrore()==null){
  2539.                 configurazione.setGestioneErrore(new ConfigurazioneGestioneErrore());
  2540.             }
  2541.             if(gestioneErroreCooperazione!=null){
  2542.                 configurazione.getGestioneErrore().setComponenteCooperazione(gestioneErroreCooperazione);
  2543.             }
  2544.             if(gestioneErroreIntegrazione!=null){
  2545.                 configurazione.getGestioneErrore().setComponenteIntegrazione(gestioneErroreIntegrazione);
  2546.             }
  2547.         }
  2548.         try{
  2549.             configurazione.setStatoServiziPdd(this.driverConfigurazione.getStatoServiziPdD());
  2550.         }catch(DriverConfigurazioneNotFound notFound){}
  2551.         try{
  2552.             configurazione.setSystemProperties(this.driverConfigurazione.getSystemPropertiesPdD());
  2553.         }catch(DriverConfigurazioneNotFound notFound){}
  2554.         try{
  2555.             configurazione.setGenericPropertiesList(this.driverConfigurazione.getGenericProperties());
  2556.         }catch(DriverConfigurazioneNotFound notFound){}
  2557.         
  2558.         return configurazione;
  2559.     }
  2560. }
Created with JaCoCo 0.8.8.202204050719