AccordiServizioParteSpecificaCore.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.web.ctrlstat.servlet.aps;

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

  27. import javax.servlet.http.HttpServletRequest;
  28. import javax.servlet.http.HttpSession;

  30. import org.openspcoop2.core.commons.DBUtils;
  31. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  32. import org.openspcoop2.core.commons.ISearch;
  33. import org.openspcoop2.core.config.PortaApplicativa;
  34. import org.openspcoop2.core.config.PortaDelegata;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  36. import org.openspcoop2.core.id.IDAccordo;
  37. import org.openspcoop2.core.id.IDFruizione;
  38. import org.openspcoop2.core.id.IDPortType;
  39. import org.openspcoop2.core.id.IDPortaApplicativa;
  40. import org.openspcoop2.core.id.IDPortaDelegata;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.core.mapping.DBMappingUtils;
  44. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  45. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  46. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  47. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  48. import org.openspcoop2.core.registry.Documento;
  49. import org.openspcoop2.core.registry.Fruitore;
  50. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  51. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  52. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  53. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  54. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  55. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  56. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  57. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  58. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  59. import org.openspcoop2.core.registry.driver.ValidazioneStatoPackageException;
  60. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  61. import org.openspcoop2.message.constants.ServiceBinding;
  62. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  63. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  64. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  65. import org.openspcoop2.protocol.sdk.ProtocolException;
  66. import org.openspcoop2.protocol.sdk.validator.ValidazioneResult;
  67. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  68. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  69. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  70. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  71. import org.openspcoop2.web.ctrlstat.registro.GestoreRegistroServiziRemoto;
  72. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  73. import org.openspcoop2.web.lib.mvc.ServletUtils;
  74. import org.openspcoop2.web.lib.mvc.TipoOperazione;

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

  85.     public AccordiServizioParteSpecificaCore() throws DriverControlStationException {
  86.         super();
  87.     }
  88.     public AccordiServizioParteSpecificaCore(ControlStationCore core) throws DriverControlStationException {
  89.         super(core);
  90.     }

  92.     
  93.     public boolean isConnettoreStatic(String protocollo) throws ProtocolException   {
  94.         
  95.         return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolVersionManager(null).isStaticRoute();
  96.     }
  97.     
  98.     
  99.     public boolean isSupportatoVersionamentoAccordiServizioParteSpecifica(String protocollo) throws DriverRegistroServiziException {
  100.         String nomeMetodo = "isSupportatoVersionamentoAccordiServizioParteSpecifica";
  101.         try{
  102.             
  103.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoVersionamentoAccordiParteSpecifica();
  104.             
  105.         }catch (Exception e) {
  106.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  107.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  108.         }
  109.     }
  110.     
  111.     
  112.     public List<String> getTipiServiziGestitiProtocollo(String protocollo,ServiceBinding serviceBinding) throws DriverRegistroServiziException {
  113.         String nomeMetodo = "getTipiServiziGestitiProtocollo";
  114.         try{
  115.             
  116.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().getTipiServizi(serviceBinding);
  117.             
  118.         }catch (Exception e) {
  119.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  120.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  121.         }
  122.     }
  123.     
  124.     public String getTipoServizioDefaultProtocollo(String protocollo,ServiceBinding serviceBinding) throws  DriverRegistroServiziException {
  125.         String getTipoServizioDefault = "getTipoServizioDefaultProtocollo";
  126.         try{
  127.             
  128.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().getTipoServizioDefault(serviceBinding); 
  129.             
  130.         }catch (Exception e) {
  131.             String error = getPrefixError(getTipoServizioDefault, e);
  132.             ControlStationCore.logError(error, e);
  133.             throw new DriverRegistroServiziException(error,e);
  134.         }
  135.     }

  137.     public String getProtocolloAssociatoTipoServizio(String tipoServizio) throws DriverRegistroServiziException {
  138.         String nomeMetodo = "getProtocolloAssociatoTipoServizio";
  139.         try{
  140.             
  141.             return this.protocolFactoryManager.getProtocolByServiceType(tipoServizio);
  142.             
  143.         }catch (Exception e) {
  144.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  145.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  146.         }
  147.     }
  148.     
  149.     
  150.     public void controlloUnicitaImplementazioneAccordoPerSoggetto(String portType,
  151.             IDSoggetto idSoggettoErogatore, long idSoggettoErogatoreLong, 
  152.             IDAccordo idAccordoServizioParteComune, long idAccordoServizioParteComuneLong,
  153.             IDServizio idAccordoServizioParteSpecifica, long idAccordoServizioParteSpecificaLong,
  154.             TipoOperazione tipoOperazione,boolean servizioCorrelato) throws DriverRegistroServiziException{
  155.         
  156.         
  157.         Connection con = null;
  158.         String nomeMetodo = "controlloUnicitaImplementazioneAccordoPerSoggetto";
  159.         try {
  160.             // prendo una connessione
  161.             con = ControlStationCore.dbM.getConnection();
  162.             // istanzio il driver
  163.             DriverRegistroServiziDB driver = new DriverRegistroServiziDB(con, ControlStationCore.log, this.tipoDB);

  165.             driver.controlloUnicitaImplementazioneAccordoPerSoggetto(portType, idSoggettoErogatore, idSoggettoErogatoreLong, 
  166.                     idAccordoServizioParteComune, idAccordoServizioParteComuneLong, 
  167.                     idAccordoServizioParteSpecifica, idAccordoServizioParteSpecificaLong, 
  168.                     TipoOperazione.CHANGE.equals(tipoOperazione), servizioCorrelato, 
  169.                     this.isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto(),
  170.                     this.isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto());
  171.             
  172.         } catch (Exception e) {
  173.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  174.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  175.         } finally {
  176.             ControlStationCore.dbM.releaseConnection(con);
  177.         }
  178.         
  179.         
  180.         
  181.         
  182.         /*
  183.          * Controllo che non esistano 2 servizi con stesso soggetto erogatore e accordo di servizio 
  184.          * che siano entrambi correlati o non correlati. 
  185.          * Al massimo possono esistere 2 servizi di uno stesso accordo erogati da uno stesso soggetto, 
  186.          * purche' siano uno correlato e uno no. 
  187.          * Se tipoOp = change, devo fare attenzione a non escludere il servizio selezionato che sto
  188.          * cambiando 
  189.          */

  191.         String tmpServCorr = CostantiRegistroServizi.DISABILITATO.toString();
  192.         if(servizioCorrelato){
  193.             tmpServCorr = CostantiRegistroServizi.ABILITATO.toString();
  194.         }
  195.         String s = "servizio";
  196.         if (servizioCorrelato) {
  197.             s = "servizio correlato";
  198.         }
  199.         
  200.         // se il servizio non definisce port type effettuo controllo che non
  201.         // esistano 2 servizi con stesso soggetto,
  202.         // accordo e servizio correlato
  203.         if (portType == null || "-".equals(portType)) {
  204.             
  205.             if(this.isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto()){
  206.             
  207.                 // Controllo che non esistano 2 servizi con stesso soggetto,
  208.                 // accordo e servizio correlato
  209.                 // Se tipoOp = change, devo fare attenzione a non escludere il servizio selezionato

  211.                 long idAccordoServizioParteSpecificaAlreadyExists = 
  212.                         this.getServizioWithSoggettoAccordoServCorr(idSoggettoErogatoreLong, idAccordoServizioParteComuneLong, 
  213.                                 tmpServCorr);

  215.                 boolean addError = (tipoOperazione.equals(TipoOperazione.ADD) && (idAccordoServizioParteSpecificaAlreadyExists > 0));
  216.                 boolean changeError = false;
  217.                 if (tipoOperazione.equals(TipoOperazione.CHANGE) && (idAccordoServizioParteSpecificaAlreadyExists > 0)) {
  218.                     changeError = (idAccordoServizioParteSpecificaLong != idAccordoServizioParteSpecificaAlreadyExists);
  219.                 }
  220.                 
  221.                 if (addError || changeError) {
  222.                     throw new DriverRegistroServiziException("Esiste gi&agrave; un " + s + " del Soggetto "+idSoggettoErogatore+
  223.                             " che implementa l'accordo selezionato ["+IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordoServizioParteComune)+"]");
  224.                 }
  225.                 
  226.             }
  227.                 
  228.         } else {
  229.             
  230.             if(this.isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto()){
  231.             
  232.                 // Controllo che non esistano 2 servizi con stesso soggetto,
  233.                 // accordo e servizio correlato e port-type

  235.                 long idAccordoServizioParteSpecificaAlreadyExists =  
  236.                         this.getServizioWithSoggettoAccordoServCorrPt(idSoggettoErogatoreLong, idAccordoServizioParteComuneLong, 
  237.                                 tmpServCorr, portType);

  239.                 boolean addError = (tipoOperazione.equals(TipoOperazione.ADD) && (idAccordoServizioParteSpecificaAlreadyExists > 0));
  240.                 boolean changeError = false;
  241.                 if (tipoOperazione.equals(TipoOperazione.CHANGE) && (idAccordoServizioParteSpecificaAlreadyExists > 0)) {
  242.                     changeError = (idAccordoServizioParteSpecificaLong != idAccordoServizioParteSpecificaAlreadyExists);
  243.                 }
  244.                 
  245.                 if (addError || changeError) {
  246.                     throw new DriverRegistroServiziException("Esiste gi&agrave; un " + s + " del Soggetto "+idSoggettoErogatore+
  247.                             " che implementa il servizio "+portType+" dell'accordo selezionato ["+IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordoServizioParteComune)+"]");
  248.                 }
  249.                 
  250.             }
  251.         }
  252.     }
  253.     
  254.     
  255.     
  256.     public long getIdAccordoServizioParteSpecifica(IDServizio idAccordo) throws DriverRegistroServiziException {
  257.         Connection con = null;
  258.         String nomeMetodo = "getIdAccordoServizioParteSpecifica(id)";
  259.         try {
  260.             // prendo una connessione
  261.             con = ControlStationCore.dbM.getConnection();
  262.             return DBUtils.getIdServizio(idAccordo.getNome(), idAccordo.getTipo(), idAccordo.getVersione(),
  263.                     idAccordo.getSoggettoErogatore().getNome(), idAccordo.getSoggettoErogatore().getTipo(),
  264.                     con, this.tipoDB);
  265.         } catch (Exception e) {
  266.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  267.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  268.         } finally {
  269.             ControlStationCore.dbM.releaseConnection(con);
  270.         }
  271.     }
  272.     public long getIdAccordoServizioParteSpecifica(Connection con, IDServizio idAccordo) throws DriverRegistroServiziException {
  273.         String nomeMetodo = "getIdAccordoServizioParteSpecifica(con,id)";
  274.         try {
  275.             // prendo una connessione
  276.             return DBUtils.getIdServizio(idAccordo.getNome(), idAccordo.getTipo(), idAccordo.getVersione(),
  277.                     idAccordo.getSoggettoErogatore().getNome(), idAccordo.getSoggettoErogatore().getTipo(),
  278.                     con, this.tipoDB);
  279.         } catch (Exception e) {
  280.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  281.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  282.         }
  283.     }
  284.     
  285.     public long getIdFruizioneAccordoServizioParteSpecifica(IDSoggetto idFruitore, IDServizio idAccordo) throws DriverRegistroServiziException {
  286.         Connection con = null;
  287.         String nomeMetodo = "getIdFruizioneAccordoServizioParteSpecifica";
  288.         try {
  289.             // prendo una connessione
  290.             con = ControlStationCore.dbM.getConnection();
  291.             return DBUtils.getIdFruizioneServizio(idAccordo, idFruitore, con, this.tipoDB);
  292.         } catch (Exception e) {
  293.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  294.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  295.         } finally {
  296.             ControlStationCore.dbM.releaseConnection(con);
  297.         }
  298.     }
  299.     
  300.     
  301.     public List<AccordoServizioParteComune> findAccordiParteComuneBySoggettoAndNome(String nomeAccordoParteComune,IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  302.         String nomeMetodo = "findAccordiParteComuneBySoggettoAndNome(" + nomeAccordoParteComune + ", "+idSoggetto.toString()+")";
  303.         Connection con = null;
  304.         DriverControlStationDB driver = null;
  305.         try {
  306.             // prendo una connessione
  307.             con = ControlStationCore.dbM.getConnection();
  308.             // istanzio il driver
  309.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  311.             IDriverRegistroServiziGet driverRegistro = null;
  312.             if(this.isRegistroServiziLocale()){
  313.                 driverRegistro = driver.getDriverRegistroServiziDB();
  314.             }
  315.             else{
  316.                 driverRegistro = GestoreRegistroServiziRemoto.getDriverRegistroServizi(ControlStationCore.log);
  317.             }

  319.             FiltroRicercaAccordi filtroRicerca = new FiltroRicercaAccordi();
  320.             filtroRicerca.setNomeAccordo(nomeAccordoParteComune);
  321.             filtroRicerca.setTipoSoggettoReferente(idSoggetto.getTipo());
  322.             filtroRicerca.setNomeSoggettoReferente(idSoggetto.getNome());
  323.             
  324.             List<IDAccordo> idAccordi = null;
  325.             List<AccordoServizioParteComune> accordi = new ArrayList<>();
  326.             try{
  327.                 idAccordi = driverRegistro.getAllIdAccordiServizioParteComune(filtroRicerca);
  328.             }catch(DriverRegistroServiziNotFound dnf){
  329.                 // ignore
  330.             }
  331.             if(idAccordi!=null && !idAccordi.isEmpty()){
  332.                 // se long
  333.                 for (IDAccordo idAccordo : idAccordi) {
  334.                     accordi.add(driverRegistro.getAccordoServizioParteComune(idAccordo));
  335.                 }
  336.             }

  338.             return accordi;

  340.         }  catch (Exception e) {
  341.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  342.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  343.         } finally {
  344.             ControlStationCore.dbM.releaseConnection(con);
  345.         }
  346.     }
  347.     
  348.     
  349.     public List<AccordoServizioParteSpecifica> serviziByAccordoFilterList(IDAccordo idAccordo) throws DriverRegistroServiziException {
  350.         String nomeMetodo = "serviziByAccordoFilterList(" + idAccordo + ")";
  351.         Connection con = null;
  352.         DriverControlStationDB driver = null;
  353.         try {
  354.             // prendo una connessione
  355.             con = ControlStationCore.dbM.getConnection();
  356.             // istanzio il driver
  357.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  359.             DriverRegistroServiziDB driverRegistro = driver.getDriverRegistroServiziDB();

  361.             FiltroRicercaServizi filtroRicerca = new FiltroRicercaServizi();
  362.             filtroRicerca.setIdAccordoServizioParteComune(idAccordo);
  363.                         
  364.             List<IDServizio> idServizi = null;
  365.             try{
  366.                 idServizi = driverRegistro.getAllIdServizi(filtroRicerca);
  367.             }catch(DriverRegistroServiziNotFound dnf){
  368.                 // ignore
  369.             }
  370.             List<AccordoServizioParteSpecifica> lista = new ArrayList<>();
  371.             if(idServizi!=null && !idServizi.isEmpty()){
  372.                 for(int i=0; i<idServizi.size(); i++){
  373.                     lista.add(driverRegistro.getAccordoServizioParteSpecifica(idServizi.get(i)));
  374.                 }
  375.             }
  376.             return lista;

  378.         }  catch (Exception e) {
  379.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  380.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  381.         } finally {
  382.             ControlStationCore.dbM.releaseConnection(con);
  383.         }
  384.     }

  386.     
  387.         
  388.     public boolean isAccordoServizioParteSpecificaInUso(AccordoServizioParteSpecifica as, Map<ErrorsHandlerCostant, List<String>> whereIsInUso,
  389.             List<IDPortaDelegata> nomePDGenerateAutomaticamente, List<IDPortaApplicativa> nomePAGenerateAutomaticamente, boolean normalizeObjectIds) throws DriverRegistroServiziException {
  390.         Connection con = null;
  391.         String nomeMetodo = "isAccordoServizioPArteSpecificaInUso";
  392.         try {
  393.             // prendo una connessione
  394.             con = ControlStationCore.dbM.getConnection();
  395.             
  396.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(as);
  397.             return DBOggettiInUsoUtils.isAccordoServizioParteSpecificaInUso(con, this.tipoDB, idServizio, whereIsInUso, nomePDGenerateAutomaticamente, nomePAGenerateAutomaticamente, normalizeObjectIds);          
  398.         } catch (Exception e) {
  399.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  400.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  401.         } finally {
  402.             ControlStationCore.dbM.releaseConnection(con);
  403.         }
  404.     }
  405.     
  406.     
  407.     public void validaStatoAccordoServizioParteSpecifica(AccordoServizioParteSpecifica serv, boolean gestioneWsdlImplementativo, boolean checkConnettore) throws DriverRegistroServiziException,ValidazioneStatoPackageException{
  408.         Connection con = null;
  409.         String nomeMetodo = "validaStatoAccordoServizioParteSpecifica";
  410.         DriverRegistroServiziDB driver = null;

  412.         try {
  413.             // prendo una connessione
  414.             con = ControlStationCore.dbM.getConnection();
  415.             // istanzio il driver
  416.             driver = new DriverRegistroServiziDB(con, ControlStationCore.log, this.tipoDB);

  418.             driver.validaStatoAccordoServizioParteSpecifica(serv, gestioneWsdlImplementativo, checkConnettore);
  419.             
  420.         } catch (ValidazioneStatoPackageException e) {
  421.             ControlStationCore.logError("[ControlStationCore::" + nomeMetodo + "] ValidazioneStatoPackageException :" + e.getMessage(), e);
  422.             throw e;
  423.         }  catch (DriverRegistroServiziException e) {
  424.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  425.             throw e;
  426.         } catch (Exception e) {
  427.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  428.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  429.         } finally {
  430.             ControlStationCore.dbM.releaseConnection(con);
  431.         }
  432.     }
  433.     
  434.     public void validaStatoFruitoreAccordoServizioParteSpecifica(Fruitore fruitore,AccordoServizioParteSpecifica serv) throws DriverRegistroServiziException,ValidazioneStatoPackageException{
  435.         Connection con = null;
  436.         String nomeMetodo = "validaStatoFruitoreAccordoServizioParteSpecifica";
  437.         DriverRegistroServiziDB driver = null;

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

  445.             driver.validaStatoFruitoreServizio(fruitore,serv);
  446.             
  447.         } catch (ValidazioneStatoPackageException e) {
  448.             ControlStationCore.logError("[ControlStationCore::" + nomeMetodo + "] validaStatoFruitoreAccordoServizioParteSpecifica :" + e.getMessage(), e);
  449.             throw e;
  450.         }  catch (DriverRegistroServiziException e) {
  451.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  452.             throw e;
  453.         } catch (Exception e) {
  454.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  455.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  456.         } finally {
  457.             ControlStationCore.dbM.releaseConnection(con);
  458.         }
  459.     }
  460.     
  461.     public List<IDServizio> getAllIdServizi(FiltroRicercaServizi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  462.         Connection con = null;
  463.         String nomeMetodo = "getAllIdServizi";
  464.         DriverControlStationDB driver = null;

  466.         try {
  467.             if(this.isRegistroServiziLocale()){
  468.                 // prendo una connessione
  469.                 con = ControlStationCore.dbM.getConnection();
  470.                 // istanzio il driver
  471.                 driver = new DriverControlStationDB(con, null, this.tipoDB);
  472.     
  473.                 return driver.getDriverRegistroServiziDB().getAllIdServizi(filtroRicerca);
  474.             }
  475.             else{
  476.                 return GestoreRegistroServiziRemoto.getDriverRegistroServizi(ControlStationCore.log).getAllIdServizi(filtroRicerca);
  477.             }

  479.         } catch (DriverRegistroServiziNotFound de) {
  480.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  481.             throw de;
  482.         } catch (Exception e) {
  483.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  484.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  485.         } finally {
  486.             ControlStationCore.dbM.releaseConnection(con);
  487.         }
  488.     }

  490.     public List<AccordoServizioParteSpecifica> servizioWithSoggettoFruitore(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  491.         Connection con = null;
  492.         String nomeMetodo = "servizioWithSoggettoFruitore";
  493.         DriverRegistroServiziDB driver = null;

  495.         try {
  496.             // prendo una connessione
  497.             con = ControlStationCore.dbM.getConnection();
  498.             // istanzio il driver
  499.             driver = new DriverRegistroServiziDB(con, ControlStationCore.log, this.tipoDB);

  501.             return driver.servizioWithSoggettoFruitore(idSoggetto);
  502.         } catch (DriverRegistroServiziException e) {
  503.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  504.             throw e;
  505.         } catch (Exception e) {
  506.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  507.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  508.         } finally {
  509.             ControlStationCore.dbM.releaseConnection(con);
  510.         }
  511.     }
  512.     
  513.     public List<AccordoServizioParteSpecifica> serviziWithIdAccordoList(long idAccordo) throws DriverRegistroServiziException {
  514.         Connection con = null;
  515.         String nomeMetodo = "serviziWithIdAccordoList";
  516.         DriverControlStationDB driver = null;

  518.         try {
  519.             // prendo una connessione
  520.             con = ControlStationCore.dbM.getConnection();
  521.             // istanzio il driver
  522.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  524.             return driver.getDriverRegistroServiziDB().serviziWithIdAccordoList(idAccordo);

  526.         } catch (Exception e) {
  527.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  528.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  529.         } finally {
  530.             ControlStationCore.dbM.releaseConnection(con);
  531.         }
  532.     }

  534.     public List<Fruitore> getSoggettiWithServizioNotFruitori(long idServizio, boolean escludiSoggettiEsterni, CredenzialeTipo credenzialeTipo) throws DriverRegistroServiziException {
  535.         Connection con = null;
  536.         String nomeMetodo = "getSoggettiWithServizioNotFruitori";
  537.         DriverControlStationDB driver = null;

  539.         try {
  540.             // prendo una connessione
  541.             con = ControlStationCore.dbM.getConnection();
  542.             // istanzio il driver
  543.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  545.             return driver.getDriverRegistroServiziDB().getSoggettiWithServizioNotFruitori(idServizio, escludiSoggettiEsterni, credenzialeTipo);

  547.         } catch (Exception e) {
  548.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  549.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  550.         } finally {
  551.             ControlStationCore.dbM.releaseConnection(con);
  552.         }
  553.     }
  554.     
  555.     public Fruitore getErogatoreFruitore(long id) throws DriverRegistroServiziException {
  556.         Connection con = null;
  557.         String nomeMetodo = "getErogatoreFruitore";
  558.         DriverControlStationDB driver = null;

  560.         try {
  561.             // prendo una connessione
  562.             con = ControlStationCore.dbM.getConnection();
  563.             // istanzio il driver
  564.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  566.             return driver.getDriverRegistroServiziDB().getErogatoreFruitore(id);

  568.         } catch (Exception e) {
  569.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  570.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  571.         } finally {
  572.             ControlStationCore.dbM.releaseConnection(con);
  573.         }
  574.     }
  575.     
  576.     public long getServizioWithSoggettoAccordoServCorr(long idSoggetto, long idAccordo, String servizioCorrelato) throws DriverRegistroServiziException {
  577.         Connection con = null;
  578.         String nomeMetodo = "getServizioWithSoggettoAccordoServCorr";
  579.         DriverControlStationDB driver = null;

  581.         try {
  582.             // prendo una connessione
  583.             con = ControlStationCore.dbM.getConnection();
  584.             // istanzio il driver
  585.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  587.             return driver.getDriverRegistroServiziDB().getServizioWithSoggettoAccordoServCorr(idSoggetto, idAccordo, servizioCorrelato);

  589.         } catch (Exception e) {
  590.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  591.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  592.         } finally {
  593.             ControlStationCore.dbM.releaseConnection(con);
  594.         }
  595.     }

  597.     public long getServizioWithSoggettoAccordoServCorrPt(long idSoggetto, long idAccordo, String servizioCorrelato, String portType) throws DriverRegistroServiziException {
  598.         Connection con = null;
  599.         String nomeMetodo = "getServizioWithSoggettoAccordoServCorrPt";
  600.         DriverControlStationDB driver = null;

  602.         try {
  603.             // prendo una connessione
  604.             con = ControlStationCore.dbM.getConnection();
  605.             // istanzio il driver
  606.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  608.             return driver.getDriverRegistroServiziDB().getServizioWithSoggettoAccordoServCorrPt(idSoggetto, idAccordo, servizioCorrelato, portType);

  610.         } catch (Exception e) {
  611.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  612.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  613.         } finally {
  614.             ControlStationCore.dbM.releaseConnection(con);
  615.         }
  616.     }

  618.     public Fruitore getServizioFruitore(long idServFru) throws DriverRegistroServiziException {
  619.         Connection con = null;
  620.         String nomeMetodo = "getServizioFruitore";
  621.         DriverControlStationDB driver = null;

  623.         try {
  624.             // prendo una connessione
  625.             con = ControlStationCore.dbM.getConnection();
  626.             // istanzio il driver
  627.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  629.             return driver.getDriverRegistroServiziDB().getServizioFruitore(idServFru);

  631.         } catch (Exception e) {
  632.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  633.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  634.         } finally {
  635.             ControlStationCore.dbM.releaseConnection(con);
  636.         }
  637.     }

  639.     public long getServizioFruitore(IDServizio idServizio, long idSogg) throws DriverRegistroServiziException {
  640.         Connection con = null;
  641.         String nomeMetodo = "getServizioFruitore";
  642.         DriverControlStationDB driver = null;

  644.         try {
  645.             // prendo una connessione
  646.             con = ControlStationCore.dbM.getConnection();
  647.             // istanzio il driver
  648.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  650.             return driver.getDriverRegistroServiziDB().getServizioFruitore(idServizio, idSogg);

  652.         } catch (Exception e) {
  653.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  654.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  655.         } finally {
  656.             ControlStationCore.dbM.releaseConnection(con);
  657.         }
  658.     }

  660.     public long getServizioFruitoreSoggettoFruitoreID(long idServFru) throws DriverRegistroServiziException {
  661.         Connection con = null;
  662.         String nomeMetodo = "getServizioFruitoreSoggettoFruitoreID";
  663.         DriverControlStationDB driver = null;

  665.         try {
  666.             // prendo una connessione
  667.             con = ControlStationCore.dbM.getConnection();
  668.             // istanzio il driver
  669.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  671.             return driver.getDriverRegistroServiziDB().getServizioFruitoreSoggettoFruitoreID(idServFru);

  673.         } catch (Exception e) {
  674.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  675.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  676.         } finally {
  677.             ControlStationCore.dbM.releaseConnection(con);
  678.         }
  679.     }

  681.     public long getServizioFruitoreServizioID(long idServFru) throws DriverRegistroServiziException {
  682.         Connection con = null;
  683.         String nomeMetodo = "getServizioFruitoreServizioID";
  684.         DriverControlStationDB driver = null;

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

  692.             return driver.getDriverRegistroServiziDB().getServizioFruitoreServizioID(idServFru);

  694.         } catch (Exception e) {
  695.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  696.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  697.         } finally {
  698.             ControlStationCore.dbM.releaseConnection(con);
  699.         }
  700.     }
  701.     
  702.     public boolean existsServizio(long idServizio) throws DriverRegistroServiziException {
  703.         Connection con = null;
  704.         String nomeMetodo = "existsServizio";
  705.         DriverControlStationDB driver = null;

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

  713.             return driver.getDriverRegistroServiziDB().existsAccordoServizioParteSpecifica(idServizio);

  715.         } catch (Exception e) {
  716.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  717.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  718.         } finally {
  719.             ControlStationCore.dbM.releaseConnection(con);
  720.         }
  721.     }

  723.     
  724.     public boolean existsServizio(IDServizio idSE) throws DriverRegistroServiziException {
  725.         Connection con = null;
  726.         String nomeMetodo = "existsServizio";
  727.         DriverControlStationDB driver = null;

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

  735.             return driver.getDriverRegistroServiziDB().existsAccordoServizioParteSpecifica(idSE);

  737.         } catch (Exception e) {
  738.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  739.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  740.         } finally {
  741.             ControlStationCore.dbM.releaseConnection(con);
  742.         }
  743.     }


  746.     public boolean existsAccordoServizioParteSpecifica(IDServizio idAccordo) throws DriverRegistroServiziException {
  747.         Connection con = null;
  748.         String nomeMetodo = "existsAccordoServizioParteSpecifica";
  749.         DriverControlStationDB driver = null;

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

  757.             return driver.getDriverRegistroServiziDB().existsAccordoServizioParteSpecifica(idAccordo);

  759.         } catch (Exception e) {
  760.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  761.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  762.         } finally {
  763.             ControlStationCore.dbM.releaseConnection(con);
  764.         }
  765.     }
  766.     
  767.     public AccordoServizioParteSpecifica getServizio(IDServizio idService) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  768.         Connection con = null;
  769.         String nomeMetodo = "getServizio";
  770.         DriverControlStationDB driver = null;

  772.         try {
  773.             if(this.isRegistroServiziLocale()){
  774.                 // prendo una connessione
  775.                 con = ControlStationCore.dbM.getConnection();
  776.                 // istanzio il driver
  777.                 driver = new DriverControlStationDB(con, null, this.tipoDB);
  778.     
  779.                 return driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica(idService);
  780.                 
  781.             }else{
  782.                 return GestoreRegistroServiziRemoto.getDriverRegistroServizi(ControlStationCore.log).getAccordoServizioParteSpecifica(idService);
  783.             }

  785.         } catch (DriverRegistroServiziNotFound de) {
  786.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  787.             throw de;
  788.         } catch (Exception e) {
  789.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  790.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  791.         } finally {
  792.             ControlStationCore.dbM.releaseConnection(con);
  793.         }

  795.     }

  797.     public AccordoServizioParteSpecifica getServizio(IDServizio idService,boolean deepRead) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  798.         Connection con = null;
  799.         String nomeMetodo = "getServizio";
  800.         DriverControlStationDB driver = null;

  802.         try {
  803.             // prendo una connessione
  804.             con = ControlStationCore.dbM.getConnection();
  805.             // istanzio il driver
  806.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  808.             return driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica(idService,deepRead);
  809.         } catch (DriverRegistroServiziNotFound e) {
  810.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  e), e);
  811.             throw e;
  812.         } catch (DriverRegistroServiziException e) {
  813.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  814.             throw e;
  815.         } catch (Exception e) {
  816.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  817.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  818.         } finally {
  819.             ControlStationCore.dbM.releaseConnection(con);
  820.         }
  821.     }

  823.     

  825.     public AccordoServizioParteSpecifica getServizioCorrelato(IDSoggetto idSoggetto, IDAccordo idAccordo) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  826.         Connection con = null;
  827.         String nomeMetodo = "getServizioCorrelato";
  828.         DriverControlStationDB driver = null;

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

  836.             return driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica_ServizioCorrelato(idSoggetto, idAccordo);

  838.         } catch (DriverRegistroServiziNotFound de) {
  839.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  840.             throw de;
  841.         } catch (Exception e) {
  842.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  843.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  844.         } finally {
  845.             ControlStationCore.dbM.releaseConnection(con);
  846.         }

  848.     }


  851.     
  852.     
  853.     public List<AccordoServizioParteSpecifica> soggettiServizioList(String superuser, ISearch ricerca,boolean [] permessiUtente, HttpSession session, HttpServletRequest request) throws DriverRegistroServiziException {
  854.         boolean gestioneFruitori = false;
  855.         boolean gestioneErogatori = false;
  856.         String tipologia = ServletUtils.getObjectFromSession(request, session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  857.         if(tipologia!=null) {
  858.             if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  859.                 gestioneFruitori = true;
  860.             }
  861.             else if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE.equals(tipologia)) {
  862.                 gestioneErogatori = true;
  863.             }
  864.         }
  865.         return soggettiServizioList(superuser, ricerca, permessiUtente, gestioneFruitori, gestioneErogatori);

  867.     }
  868.     public List<AccordoServizioParteSpecifica> soggettiServizioList(String superuser, ISearch ricerca,boolean [] permessiUtente, 
  869.             boolean gestioneFruitori, boolean gestioneErogatori) throws DriverRegistroServiziException {
  870.         Connection con = null;
  871.         String nomeMetodo = "soggettiServizioList";
  872.         DriverControlStationDB driver = null;

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

  880.             return driver.getDriverRegistroServiziDB().soggettiServizioList(superuser, ricerca,permessiUtente, 
  881.                     gestioneFruitori, gestioneErogatori);

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

  890.     }

  892.     

  894.     public List<IDServizio> getIdServiziWithPortType(IDPortType idPT) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  895.         Connection con = null;
  896.         String nomeMetodo = "getIdServiziWithPortType";
  897.         DriverControlStationDB driver = null;

  899.         try {
  900.             // prendo una connessione
  901.             con = ControlStationCore.dbM.getConnection();
  902.             // istanzio il driver
  903.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  904.             return driver.getDriverRegistroServiziDB().getIdServiziWithPortType(idPT);
  905.         } catch (DriverRegistroServiziNotFound e) {
  906.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  e), e);
  907.             throw e;
  908.         } catch (Exception e) {
  909.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  910.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  911.         } finally {
  912.             ControlStationCore.dbM.releaseConnection(con);
  913.         }
  914.     }
  915.     
  916.     public List<IDServizio> getIdServiziWithAccordo(IDAccordo idAccordo,boolean checkPTisNull) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  917.         Connection con = null;
  918.         String nomeMetodo = "getIdServiziWithAccordo";
  919.         DriverControlStationDB driver = null;

  921.         try {
  922.             // prendo una connessione
  923.             con = ControlStationCore.dbM.getConnection();
  924.             // istanzio il driver
  925.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  926.             return driver.getDriverRegistroServiziDB().getIdServiziWithAccordo(idAccordo,checkPTisNull);
  927.         } catch (DriverRegistroServiziNotFound e) {
  928.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  e), e);
  929.             throw e;
  930.         } catch (Exception e) {
  931.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  932.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  933.         } finally {
  934.             ControlStationCore.dbM.releaseConnection(con);
  935.         }
  936.     }
  937.     
  938.     
  939.     public List<AccordoServizioParteSpecifica> serviziList(ISearch ricerca) throws DriverRegistroServiziException {
  940.         Connection con = null;
  941.         String nomeMetodo = "serviziList";
  942.         DriverControlStationDB driver = null;

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

  950.             return driver.getDriverRegistroServiziDB().serviziList(null,ricerca);

  952.         } catch (Exception e) {
  953.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  954.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  955.         } finally {
  956.             ControlStationCore.dbM.releaseConnection(con);
  957.         }

  959.     }
  960.     
  961.     public List<AccordoServizioParteSpecifica> serviziList(String superUser,ISearch ricerca) throws DriverRegistroServiziException {
  962.         Connection con = null;
  963.         String nomeMetodo = "serviziList";
  964.         DriverControlStationDB driver = null;

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

  972.             return driver.getDriverRegistroServiziDB().serviziList(superUser,ricerca);

  974.         } catch (Exception e) {
  975.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  976.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  977.         } finally {
  978.             ControlStationCore.dbM.releaseConnection(con);
  979.         }

  981.     }
  982.     

  984.     public long existServizio(String nomeServizio, String tipoServizio, int versioneServizio, long idSoggettoErogatore) throws DriverControlStationException {
  985.         Connection con = null;
  986.         String nomeMetodo = "existServizio(nome,tipo,versione,idErogatore)";
  987.         DriverControlStationDB driver = null;

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

  995.             return driver.existServizio(nomeServizio, tipoServizio, versioneServizio, idSoggettoErogatore);

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

  1005.     public ValidazioneResult validazione(AccordoServizioParteSpecifica as,SoggettiCore soggettiCore) throws DriverRegistroServiziException {
  1006.         String nomeMetodo = "validazione";
  1007.         try {
  1008.             String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(as.getTipoSoggettoErogatore());
  1009.             IProtocolFactory<?> protocol = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1010.             return protocol.createValidazioneAccordi().valida(as);
  1011.         }catch (Exception e) {
  1012.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1013.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  1014.         }
  1015.     }

  1017.     public ValidazioneResult validaInterfacciaWsdlParteSpecifica(AccordoServizioParteSpecifica as,AccordoServizioParteComune apc,SoggettiCore soggettiCore) throws DriverRegistroServiziException {
  1018.         String nomeMetodo = "validaInterfacciaWsdlParteSpecifica";
  1019.         try {
  1020.             String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(as.getTipoSoggettoErogatore());
  1021.             IProtocolFactory<?> protocol = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1022.             return protocol.createValidazioneDocumenti().validaSpecificaInterfaccia(as,apc);
  1023.         }catch (Exception e) {
  1024.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1025.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  1026.         }
  1027.     }
  1028.     
  1029.     public ValidazioneResult validaInterfacciaWsdlParteSpecifica(Fruitore fruitore,AccordoServizioParteSpecifica as,AccordoServizioParteComune apc,SoggettiCore soggettiCore) throws DriverRegistroServiziException {
  1030.         String nomeMetodo = "validaInterfacciaWsdlParteSpecifica_Fruitore";
  1031.         try {
  1032.             String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(as.getTipoSoggettoErogatore());
  1033.             IProtocolFactory<?> protocol = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1034.             return protocol.createValidazioneDocumenti().validaSpecificaInterfaccia(fruitore, as, apc);
  1035.         }catch (Exception e) {
  1036.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1037.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  1038.         }
  1039.     }

  1041.     public  long getIdAccordoServizioParteSpecifica(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeProprietario,String tipoProprietario) throws DriverRegistroServiziException{
  1042.         Connection con = null;
  1043.         String nomeMetodo = "getIdAccordoServizioParteSpecifica";

  1045.         long idServizio=-1;
  1046.         try
  1047.         {
  1048.             // prendo una connessione
  1049.             con = ControlStationCore.dbM.getConnection();

  1051.             idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeProprietario, tipoProprietario, con, this.tipoDB);


  1054.         } catch (Exception e) {
  1055.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1056.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  1057.         }finally
  1058.         {
  1059.             ControlStationCore.dbM.releaseConnection(con);
  1060.         }
  1061.         return idServizio;
  1062.     }

  1064.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(long idServizio) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  1065.         Connection con = null;
  1066.         String nomeMetodo = "getAccordoServizioParteSpecifica";
  1067.         DriverControlStationDB driver = null;

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

  1075.             return driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica(idServizio);

  1077.         } catch (DriverRegistroServiziNotFound de) {
  1078.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  1079.             throw de;
  1080.         } catch (Exception e) {
  1081.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1082.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  1083.         } finally {
  1084.             ControlStationCore.dbM.releaseConnection(con);
  1085.         }
  1086.     }
  1087.     
  1088.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  1089.         Connection con = null;
  1090.         String nomeMetodo = "getAccordoServizioParteSpecifica(IDServizio)";
  1091.         DriverControlStationDB driver = null;

  1093.         try {
  1094.             // prendo una connessione
  1095.             con = ControlStationCore.dbM.getConnection();
  1096.             // istanzio il driver
  1097.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1099.             return driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica(idServizio);

  1101.         } catch (DriverRegistroServiziNotFound de) {
  1102.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  1103.             throw de;
  1104.         } catch (Exception e) {
  1105.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1106.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  1107.         } finally {
  1108.             ControlStationCore.dbM.releaseConnection(con);
  1109.         }
  1110.     }

  1112.     public List<PortaApplicativa> serviziPorteAppList(String tipoServizio,String nomeServizio, Integer versioneServizio,
  1113.             long idServizio, long idSoggettoErogatore, ISearch ricerca) throws DriverConfigurazioneException {
  1114.         Connection con = null;
  1115.         String nomeMetodo = "serviziPorteAppList";
  1116.         DriverControlStationDB driver = null;

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

  1124.             return driver.getDriverConfigurazioneDB().serviziPorteAppList(tipoServizio,nomeServizio,versioneServizio,idServizio, idSoggettoErogatore, ricerca);

  1126.         } catch (Exception e) {
  1127.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1128.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1129.         } finally {
  1130.             ControlStationCore.dbM.releaseConnection(con);
  1131.         }
  1132.     }
  1133.     
  1134.     public List<MappingErogazionePortaApplicativa> mappingServiziPorteAppList(IDServizio idAccordoServizioParteSpecifica, ISearch ricerca) throws DriverConfigurazioneException, DriverRegistroServiziException {
  1135.         return mappingServiziPorteAppListEngine(idAccordoServizioParteSpecifica, this.getIdAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica), ricerca);
  1136.     }
  1137.     
  1138.     public List<MappingErogazionePortaApplicativa> mappingServiziPorteAppList(IDServizio idAccordoServizioParteSpecifica, Long idServizio, ISearch ricerca) throws DriverConfigurazioneException {
  1139.         return mappingServiziPorteAppListEngine(idAccordoServizioParteSpecifica, idServizio, ricerca);
  1140.     }
  1141.     
  1142.     private List<MappingErogazionePortaApplicativa> mappingServiziPorteAppListEngine(IDServizio idAccordoServizioParteSpecifica, Long idServizio, ISearch ricerca) throws DriverConfigurazioneException {
  1143.         Connection con = null;
  1144.         String nomeMetodo = "mappingServiziPorteAppList";

  1146.         try {
  1147.             // prendo una connessione
  1148.             con = ControlStationCore.dbM.getConnection();
  1149.             boolean orderByDescrizione = true;
  1150.             boolean ricercaUseOffsetLimit = false; // non esiste paginazione per adesso
  1151.             return DBMappingUtils.mappingErogazionePortaApplicativaList(con,this.tipoDB,idAccordoServizioParteSpecifica,idServizio, ricerca, ricercaUseOffsetLimit, orderByDescrizione);
  1152.         } catch (Exception e) {
  1153.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1154.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1155.         } finally {
  1156.             ControlStationCore.dbM.releaseConnection(con);
  1157.         }
  1158.     }
  1159.     
  1160.     public void deleteMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativaByNome) throws DriverConfigurazioneException {
  1161.         Connection con = null;
  1162.         String nomeMetodo = "deleteMappingErogazione";
  1163.         try{
  1164.             con = ControlStationCore.dbM.getConnection();
  1165.             DBMappingUtils.deleteMappingErogazione(idServizio, idPortaApplicativaByNome, con, this.tipoDB);
  1166.         } catch (Exception e) {
  1167.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1168.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1169.         } finally {
  1170.             ControlStationCore.dbM.releaseConnection(con);
  1171.         }
  1172.     }
  1173.     
  1174.     public boolean isDefaultMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativaByNome) throws DriverConfigurazioneException {
  1175.         Connection con = null;
  1176.         String nomeMetodo = "isDefaultMappingErogazione";
  1177.         try{
  1178.             con = ControlStationCore.dbM.getConnection();
  1179.             return DBMappingUtils.checkMappingErogazione(idServizio, idPortaApplicativaByNome, true, con, this.tipoDB);
  1180.         } catch (Exception e) {
  1181.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1182.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1183.         } finally {
  1184.             ControlStationCore.dbM.releaseConnection(con);
  1185.         }
  1186.     }

  1188.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(long idServizio,boolean readContenutoAllegati) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  1189.         Connection con = null;
  1190.         String nomeMetodo = "getAccordoServizioParteSpecifica";
  1191.         DriverControlStationDB driver = null;

  1193.         try {
  1194.             // prendo una connessione
  1195.             con = ControlStationCore.dbM.getConnection();
  1196.             // istanzio il driver
  1197.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1199.             return driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica(idServizio,readContenutoAllegati);

  1201.         } catch (DriverRegistroServiziNotFound de) {
  1202.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  1203.             throw de;
  1204.         } catch (Exception e) {
  1205.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1206.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  1207.         } finally {
  1208.             ControlStationCore.dbM.releaseConnection(con);
  1209.         }
  1210.     }

  1212.     public List<Fruitore> serviziFruitoriList(long idServizi, ISearch ricerca) throws DriverRegistroServiziException {
  1213.         Connection con = null;
  1214.         String nomeMetodo = "serviziFruitoriList";
  1215.         DriverControlStationDB driver = null;

  1217.         try {
  1218.             // prendo una connessione
  1219.             con = ControlStationCore.dbM.getConnection();
  1220.             // istanzio il driver
  1221.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1223.             return driver.getDriverRegistroServiziDB().serviziFruitoriList(idServizi, ricerca);
  1224.         } catch (Exception e) {
  1225.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1226.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  1227.         } finally {
  1228.             ControlStationCore.dbM.releaseConnection(con);
  1229.         }
  1230.     }
  1231.     public List<Fruitore> serviziFruitoriList(Connection con, long idServizi, ISearch ricerca) throws DriverRegistroServiziException {
  1232.         String nomeMetodo = "serviziFruitoriList";
  1233.         DriverControlStationDB driver = null;

  1235.         try {
  1236.             // istanzio il driver
  1237.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1238.             return driver.getDriverRegistroServiziDB().serviziFruitoriList(idServizi, ricerca);
  1239.         } catch (Exception e) {
  1240.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1241.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  1242.         }
  1243.     }


  1246.     public IDServizio getIdAccordoServizioParteSpecifica(long idAccordo) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  1247.         Connection con = null;
  1248.         String nomeMetodo = "getIdAccordoServizioParteSpecifica";
  1249.         DriverControlStationDB driver = null;

  1251.         try {
  1252.             // prendo una connessione
  1253.             con = ControlStationCore.dbM.getConnection();
  1254.             // istanzio il driver
  1255.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1257.             return IDServizioFactory.getInstance().getIDServizioFromAccordo(driver.getDriverRegistroServiziDB().getAccordoServizioParteSpecifica(idAccordo,con));

  1259.         } catch (DriverRegistroServiziNotFound de) {
  1260.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  1261.             throw de;
  1262.         } catch (Exception e) {
  1263.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1264.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  1265.         } finally {
  1266.             ControlStationCore.dbM.releaseConnection(con);
  1267.         }

  1269.     }
  1270.     


  1273.     public List<Fruitore> getServiziFruitoriWithServizio(long idServizio) throws DriverRegistroServiziException {
  1274.         Connection con = null;
  1275.         String nomeMetodo = "getServiziFruitoriWithServizio";
  1276.         DriverControlStationDB driver = null;

  1278.         try {
  1279.             // prendo una connessione
  1280.             con = ControlStationCore.dbM.getConnection();
  1281.             // istanzio il driver
  1282.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1284.             return driver.getDriverRegistroServiziDB().getServiziFruitoriWithServizio(idServizio);
  1285.         } catch (Exception e) {
  1286.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1287.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  1288.         } finally {
  1289.             ControlStationCore.dbM.releaseConnection(con);
  1290.         }
  1291.     }

  1293.     public List<Documento> serviziAllegatiList(long idServizio, ISearch ricerca) throws DriverRegistroServiziException {
  1294.         Connection con = null;
  1295.         String nomeMetodo = "serviziAllegatiList";
  1296.         DriverControlStationDB driver = null;

  1298.         try {
  1299.             // prendo una connessione
  1300.             con = ControlStationCore.dbM.getConnection();
  1301.             // istanzio il driver
  1302.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1304.             return driver.getDriverRegistroServiziDB().serviziAllegatiList(idServizio, ricerca);
  1305.         } catch (Exception e) {
  1306.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1307.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  1308.         } finally {
  1309.             ControlStationCore.dbM.releaseConnection(con);
  1310.         }
  1311.     }

  1313.     
  1314.     public List<PortaDelegata> serviziFruitoriPorteDelegateList(Long idSoggetto, 
  1315.             String tipoServizio, String nomeServizio, Long idServizio, 
  1316.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, Long idSoggettoErogatore, 
  1317.             ISearch ricerca) throws DriverConfigurazioneException {
  1318.         Connection con = null;
  1319.         String nomeMetodo = "serviziPorteAppList";
  1320.         DriverControlStationDB driver = null;

  1322.         try {
  1323.             // prendo una connessione
  1324.             con = ControlStationCore.dbM.getConnection();
  1325.             // istanzio il driver
  1326.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1328.             return driver.getDriverConfigurazioneDB().serviziFruitoriPorteDelegateList(idSoggetto, 
  1329.                     tipoServizio, nomeServizio, idServizio, 
  1330.                     tipoSoggettoErogatore, nomeSoggettoErogatore, idSoggettoErogatore, 
  1331.                     ricerca);

  1333.         } catch (Exception e) {
  1334.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1335.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1336.         } finally {
  1337.             ControlStationCore.dbM.releaseConnection(con);
  1338.         }
  1339.     }
  1340.     
  1341.     public List<MappingFruizionePortaDelegata> serviziFruitoriMappingList(Long idFru, IDSoggetto idSoggettoFruitore,
  1342.             IDServizio idAccordoServizio,
  1343.             ISearch ricerca) throws DriverConfigurazioneException {
  1344.         Connection con = null;
  1345.         String nomeMetodo = "serviziFruitoriMappingList";

  1347.         try {
  1348.             // prendo una connessione
  1349.             con = ControlStationCore.dbM.getConnection();
  1350.             boolean orderByDescrizione = true;
  1351.             boolean ricercaUseOffsetLimit = false; // non esiste paginazione per adesso
  1352.             return DBMappingUtils.mappingFruizionePortaDelegataList(con,this.tipoDB,idFru,idSoggettoFruitore,  
  1353.                     idAccordoServizio, 
  1354.                     ricerca, ricercaUseOffsetLimit,
  1355.                     orderByDescrizione);

  1357.         } catch (Exception e) {
  1358.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1359.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1360.         } finally {
  1361.             ControlStationCore.dbM.releaseConnection(con);
  1362.         }
  1363.     }
  1364.     public List<MappingFruizionePortaDelegata> serviziFruitoriMappingList(IDSoggetto idSoggettoFruitore,
  1365.             IDServizio idAccordoServizio,
  1366.             ISearch ricerca) throws DriverConfigurazioneException {
  1367.         Connection con = null;
  1368.         String nomeMetodo = "serviziFruitoriMappingList";

  1370.         try {
  1371.             // prendo una connessione
  1372.             con = ControlStationCore.dbM.getConnection();
  1373.             boolean orderByDescrizione = true;
  1374.             boolean ricercaUseOffsetLimit = false; // non esiste paginazione per adesso
  1375.             return DBMappingUtils.mappingFruizionePortaDelegataList(con,this.tipoDB,idSoggettoFruitore,  
  1376.                     idAccordoServizio, 
  1377.                     ricerca, ricercaUseOffsetLimit,
  1378.                     orderByDescrizione);

  1380.         } catch (Exception e) {
  1381.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1382.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1383.         } finally {
  1384.             ControlStationCore.dbM.releaseConnection(con);
  1385.         }
  1386.     }
  1387.     
  1388.     public void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata) throws DriverConfigurazioneException {
  1389.         Connection con = null;
  1390.         String nomeMetodo = "deleteMappingFruizione";
  1391.         try{
  1392.             con = ControlStationCore.dbM.getConnection();
  1393.             DBMappingUtils.deleteMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, this.tipoDB);
  1394.         } catch (Exception e) {
  1395.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1396.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1397.         } finally {
  1398.             ControlStationCore.dbM.releaseConnection(con);
  1399.         }
  1400.     }
  1401.     
  1402.     public boolean isDefaultMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata) throws DriverConfigurazioneException {
  1403.         Connection con = null;
  1404.         String nomeMetodo = "isDefaultMappingFruizione";
  1405.         try{
  1406.             con = ControlStationCore.dbM.getConnection();
  1407.             return DBMappingUtils.checkMappingFruizione(idServizio, idFruitore, idPortaDelegata, true, con, this.tipoDB);
  1408.         } catch (Exception e) {
  1409.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1410.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1411.         } finally {
  1412.             ControlStationCore.dbM.releaseConnection(con);
  1413.         }
  1414.     }
  1415.     
  1416.     public boolean existFruizioniServizioWithoutConnettore(long idServizio, boolean escludiSoggettiEsterni) throws DriverControlStationException {
  1417.         Connection con = null;
  1418.         String nomeMetodo = "existServizio";
  1419.         DriverControlStationDB driver = null;

  1421.         try {
  1422.             // prendo una connessione
  1423.             con = ControlStationCore.dbM.getConnection();
  1424.             // istanzio il driver
  1425.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1427.             return driver.getDriverRegistroServiziDB().existFruizioniServizioWithoutConnettore(idServizio,escludiSoggettiEsterni);

  1429.         } catch (Exception e) {
  1430.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1431.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1432.         } finally {
  1433.             ControlStationCore.dbM.releaseConnection(con);
  1434.         }
  1435.     }
  1436.     
  1437.     public boolean filterFruitoriRispettoAutenticazione(AccordoServizioParteSpecifica asps) throws DriverConfigurazioneException{
  1438.         List<PortaApplicativa> lista = this.serviziPorteAppList(asps.getTipo(),asps.getNome(),asps.getVersione(),
  1439.                 asps.getId().intValue(), asps.getIdSoggetto(), new ConsoleSearch(true));
  1440.         return lista.size()==1;
  1441.     }
  1442.     public boolean filterFruitoriRispettoAutenticazione(IDServizio idSE) throws DriverConfigurazioneException, DriverRegistroServiziNotFound, DriverRegistroServiziException{
  1443.         AccordoServizioParteSpecifica asps = this.getServizio(idSE);
  1444.         return filterFruitoriRispettoAutenticazione(asps);
  1445.     }
  1446.     
  1447.     
  1448.     public List<IDServizio> getErogazioni(List<String> protocolli, 
  1449.             String gruppo,
  1450.             String tipoSoggetto, String nomeSoggetto) throws DriverControlStationException {
  1451.         String nomeMetodo = "getErogazioni";
  1452.         Connection con = null;
  1453.         DriverControlStationDB driver = null;
  1454.         try {
  1455.             // prendo una connessione
  1456.             con = ControlStationCore.dbM.getConnection();
  1457.             
  1458.             // istanzio il driver
  1459.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1460.             
  1461.             return driver.getErogazioni(protocolli, gruppo, tipoSoggetto, nomeSoggetto);
  1462.         } catch (Exception e) {
  1463.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1464.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1465.         }finally{
  1466.             ControlStationCore.dbM.releaseConnection(con);
  1467.         }
  1468.     }
  1469.     public List<IDServizio> getErogazioni(List<String> protocolli, 
  1470.             String gruppo,
  1471.             String tipoSoggetto, String nomeSoggetto, 
  1472.             String tipoServizio ,String nomeServizio, Integer versioneServizio, 
  1473.             String nomeAzione) throws DriverControlStationException {
  1474.         String nomeMetodo = "getErogazioni";
  1475.         Connection con = null;
  1476.         DriverControlStationDB driver = null;
  1477.         try {
  1478.             // prendo una connessione
  1479.             con = ControlStationCore.dbM.getConnection();
  1480.             
  1481.             // istanzio il driver
  1482.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1483.             
  1484.             return driver.getErogazioni(protocolli, gruppo, tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, nomeAzione);
  1485.         } catch (Exception e) {
  1486.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1487.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1488.         }finally{
  1489.             ControlStationCore.dbM.releaseConnection(con);
  1490.         }
  1491.     }
  1492.     
  1493.     
  1494.     public List<IDFruizione> getFruizioni(List<String> protocolli, 
  1495.             String gruppo,
  1496.             String tipoSoggetto, String nomeSoggetto) throws DriverControlStationException {
  1497.         String nomeMetodo = "getFruizioni";
  1498.         Connection con = null;
  1499.         DriverControlStationDB driver = null;
  1500.         try {
  1501.             // prendo una connessione
  1502.             con = ControlStationCore.dbM.getConnection();
  1503.             
  1504.             // istanzio il driver
  1505.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1506.             
  1507.             return driver.getFruizioni(protocolli, gruppo, tipoSoggetto, nomeSoggetto);
  1508.         } catch (Exception e) {
  1509.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1510.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1511.         }finally{
  1512.             ControlStationCore.dbM.releaseConnection(con);
  1513.         }
  1514.     }
  1515.     public List<IDFruizione> getFruizioni(List<String> protocolli, 
  1516.             String gruppo,
  1517.             String tipoSoggetto, String nomeSoggetto, 
  1518.             String tipoErogatore, String nomeErogatore,
  1519.             String tipoServizio ,String nomeServizio, Integer versioneServizio, 
  1520.             String nomeAzione) throws DriverControlStationException {
  1521.         String nomeMetodo = "getFruizioni";
  1522.         Connection con = null;
  1523.         DriverControlStationDB driver = null;
  1524.         try {
  1525.             // prendo una connessione
  1526.             con = ControlStationCore.dbM.getConnection();
  1527.             
  1528.             // istanzio il driver
  1529.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1530.             
  1531.             return driver.getFruizioni(protocolli, gruppo, tipoSoggetto, nomeSoggetto, tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, nomeAzione);
  1532.         } catch (Exception e) {
  1533.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1534.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1535.         }finally{
  1536.             ControlStationCore.dbM.releaseConnection(con);
  1537.         }
  1538.     }
  1539.     
  1540. }
Created with JaCoCo 0.8.8.202204050719