ServiziApplicativiCore.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.sa;

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

  28. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  29. import org.openspcoop2.core.commons.ISearch;
  30. import org.openspcoop2.core.config.Proprieta;
  31. import org.openspcoop2.core.config.ProprietaOggetto;
  32. import org.openspcoop2.core.config.ServizioApplicativo;
  33. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  34. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  36. import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
  37. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  38. import org.openspcoop2.core.id.IDServizioApplicativo;
  39. import org.openspcoop2.core.id.IDSoggetto;
  40. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  41. import org.openspcoop2.pdd.core.autenticazione.ApiKey;
  42. import org.openspcoop2.pdd.core.autenticazione.ApiKeyUtilities;
  43. import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
  44. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  45. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  46. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  47. import org.openspcoop2.utils.certificate.CertificateInfo;
  48. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  49. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  50. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;

  52. /**
  53.  * ServiziApplicativiCore
  54.  *
  55.  * @author Poli Andrea (apoli@link.it)
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  */
  59. public class ServiziApplicativiCore extends ControlStationCore {

  61.     public ServiziApplicativiCore() throws DriverControlStationException {
  62.         super();
  63.     }
  64.     public ServiziApplicativiCore(ControlStationCore core) throws DriverControlStationException {
  65.         super(core);
  66.     }
  67.         
  68.     public ServizioApplicativo getServizioApplicativo(long idServizioApplicativo) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  69.         Connection con = null;
  70.         String nomeMetodo = "getServizioApplicativo";
  71.         DriverControlStationDB driver = null;

  73.         try {
  74.             // prendo una connessione
  75.             con = ControlStationCore.dbM.getConnection();
  76.             // istanzio il driver
  77.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  79.             return driver.getDriverConfigurazioneDB().getServizioApplicativo(idServizioApplicativo);

  81.         } catch (DriverConfigurazioneNotFound e) {
  82.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  e),e);
  83.             throw e;
  84.         } catch (Exception e) {
  85.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  86.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  87.         } finally {
  88.             ControlStationCore.dbM.releaseConnection(con);
  89.         }
  90.     }

  92.     public ServizioApplicativo getServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException {
  93.         Connection con = null;
  94.         String nomeMetodo = "getServizioApplicativo(IDServizioApplicativo)";
  95.         DriverControlStationDB driver = null;

  97.         try {
  98.             // prendo una connessione
  99.             con = ControlStationCore.dbM.getConnection();
  100.             // istanzio il driver
  101.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  103.             return driver.getDriverConfigurazioneDB().getServizioApplicativo(idServizioApplicativo);

  105.         } 
  106.         catch (DriverConfigurazioneNotFound  e) {
  107.             // Lasciare DEBUG, usato anche in servizio API RS
  108.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] ExceptionNotFound :" + e.getMessage(), e);
  109.             throw new DriverConfigurazioneException("[ControlStationCore::" + nomeMetodo + "] NotFound :" + e.getMessage(),e);
  110.         }
  111.         catch (Exception e) {
  112.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  113.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  114.         } finally {
  115.             ControlStationCore.dbM.releaseConnection(con);
  116.         }

  118.     }
  119.     
  120.     public ProprietaOggetto getProprietaOggetto(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException {
  121.         Connection con = null;
  122.         String nomeMetodo = "getProprietaOggetto(IDServizioApplicativo)";
  123.         DriverControlStationDB driver = null;

  125.         try {
  126.             // prendo una connessione
  127.             con = ControlStationCore.dbM.getConnection();
  128.             // istanzio il driver
  129.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  131.             return driver.getDriverConfigurazioneDB().getProprietaOggetto(idServizioApplicativo);

  133.         } 
  134.         catch (DriverConfigurazioneNotFound  e) {
  135.             // Lasciare DEBUG, usato anche in servizio API RS
  136.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] ExceptionNotFound :" + e.getMessage(), e);
  137.             throw new DriverConfigurazioneException("[ControlStationCore::" + nomeMetodo + "] NotFound :" + e.getMessage(),e);
  138.         }
  139.         catch (Exception e) {
  140.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  141.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  142.         } finally {
  143.             ControlStationCore.dbM.releaseConnection(con);
  144.         }

  146.     }
  147.     
  148.     
  149.     public boolean isSupportatoAutenticazioneApplicativiErogazione(String protocollo) throws DriverRegistroServiziException {
  150.         String nomeMetodo = "isSupportatoAutenticazioneApplicativiErogazione";
  151.         try{
  152.             
  153.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoAutenticazioneApplicativiErogazioni();
  154.             
  155.         }catch (Exception e) {
  156.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  157.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  158.         }
  159.     }
  160.     
  161.     public boolean isSupportatoAutenticazioneApplicativiEsterniErogazione(String protocollo) throws DriverRegistroServiziException {
  162.         String nomeMetodo = "isSupportatoAutenticazioneApplicativiEsterniErogazione";
  163.         try{
  164.             
  165.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoAutenticazioneApplicativiEsterniErogazioni();
  166.             
  167.         }catch (Exception e) {
  168.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  169.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  170.         }
  171.     }
  172.     
  173.     public long getIdServizioApplicativo(IDSoggetto idSoggetto, String nomeServizioApplicativo) throws DriverConfigurazioneException {
  174.         Connection con = null;
  175.         String nomeMetodo = "getIdServizioApplicativo";
  176.         DriverControlStationDB driver = null;

  178.         try {
  179.             // prendo una connessione
  180.             con = ControlStationCore.dbM.getConnection();
  181.             // istanzio il driver
  182.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  184.             return driver.getDriverConfigurazioneDB().getIdServizioApplicativo(idSoggetto, nomeServizioApplicativo);

  186.         } catch (Exception e) {
  187.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  188.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  189.         } finally {
  190.             ControlStationCore.dbM.releaseConnection(con);
  191.         }

  193.     }

  195.     public List<ServizioApplicativo> servizioApplicativoWithCredenzialiBasicList(String utente, String password, boolean checkPassword) throws DriverConfigurazioneException {
  196.         Connection con = null;
  197.         String nomeMetodo = "servizioApplicativoWithCredenzialiBasicList";
  198.         DriverControlStationDB driver = null;

  200.         try {
  201.             // prendo una connessione
  202.             con = ControlStationCore.dbM.getConnection();
  203.             // istanzio il driver
  204.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  206.             return driver.getDriverConfigurazioneDB().servizioApplicativoWithCredenzialiBasicList(utente, password, checkPassword);

  208.         } catch (Exception e) {
  209.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  210.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  211.         } finally {
  212.             ControlStationCore.dbM.releaseConnection(con);
  213.         }

  215.     }
  216.     
  217.     public String toAppId(String protocollo, IDServizioApplicativo idSA,  boolean multipleApiKeys) throws DriverConfigurazioneException {
  218.         
  219.         Connection con = null;
  220.         String nomeMetodo = "toAppId";
  221.         DriverControlStationDB driver = null;

  223.         try {
  224.             // prendo una connessione
  225.             con = ControlStationCore.dbM.getConnection();
  226.             // istanzio il driver
  227.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  229.             return ApiKeyUtilities.toAppId(protocollo, idSA, multipleApiKeys, driver.getDriverConfigurazioneDB());

  231.         } catch (Exception e) {
  232.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  233.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  234.         } finally {
  235.             ControlStationCore.dbM.releaseConnection(con);
  236.         }
  237.         
  238.     }
  239.     
  240.     public ApiKey newApiKey(String protocollo, IDServizioApplicativo idSA) throws DriverConfigurazioneException {
  241.         
  242.         Connection con = null;
  243.         String nomeMetodo = "newApiKey";
  244.         DriverControlStationDB driver = null;

  246.         try {
  247.             // prendo una connessione
  248.             con = ControlStationCore.dbM.getConnection();
  249.             // istanzio il driver
  250.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  252.             return ApiKeyUtilities.newApiKey(protocollo, idSA, this.getApplicativiApiKeyLunghezzaPasswordGenerate(), driver.getDriverConfigurazioneDB());

  254.         } catch (Exception e) {
  255.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  256.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  257.         } finally {
  258.             ControlStationCore.dbM.releaseConnection(con);
  259.         }
  260.         
  261.     }
  262.     
  263.     public ApiKey newMultipleApiKey() throws DriverConfigurazioneException {
  264.         
  265.         String nomeMetodo = "newMultipleApiKey";
  266.         try {
  267.             return ApiKeyUtilities.newMultipleApiKey(this.getApplicativiApiKeyLunghezzaPasswordGenerate());
  268.         } catch (Exception e) {
  269.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  270.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  271.         }
  272.         
  273.     }
  274.     
  275.     public List<ServizioApplicativo> servizioApplicativoWithCredenzialiApiKeyList(String utente, boolean appId) throws DriverConfigurazioneException {
  276.         Connection con = null;
  277.         String nomeMetodo = "servizioApplicativoWithCredenzialiApiKeyList";
  278.         DriverControlStationDB driver = null;

  280.         try {
  281.             // prendo una connessione
  282.             con = ControlStationCore.dbM.getConnection();
  283.             // istanzio il driver
  284.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  286.             return driver.getDriverConfigurazioneDB().servizioApplicativoWithCredenzialiApiKeyList(utente, appId);

  288.         } catch (Exception e) {
  289.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  290.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  291.         } finally {
  292.             ControlStationCore.dbM.releaseConnection(con);
  293.         }

  295.     }

  297.     public List<ServizioApplicativo> servizioApplicativoWithCredenzialiSslList(String subject, String issuer,
  298.             ConfigurazioneFiltroServiziApplicativi filtro) throws DriverConfigurazioneException {
  299.         Connection con = null;
  300.         String nomeMetodo = "servizioApplicativoWithCredenzialiSslList";
  301.         DriverControlStationDB driver = null;

  303.         try {
  304.             // prendo una connessione
  305.             con = ControlStationCore.dbM.getConnection();
  306.             // istanzio il driver
  307.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  309.             return driver.getDriverConfigurazioneDB().servizioApplicativoWithCredenzialiSslList(subject, issuer,
  310.                     filtro.getTipiSoggetti(), filtro.isIncludiApplicativiNonModI(), filtro.isIncludiApplicativiModIEsterni(), filtro.isIncludiApplicativiModIInterni());

  312.         } catch (Exception e) {
  313.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  314.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  315.         } finally {
  316.             ControlStationCore.dbM.releaseConnection(con);
  317.         }

  319.     }
  320.     public List<ServizioApplicativo> servizioApplicativoWithCredenzialiSslList(CertificateInfo certificate, boolean strictVerifier,
  321.             ConfigurazioneFiltroServiziApplicativi filtro) throws DriverConfigurazioneException {
  322.         Connection con = null;
  323.         String nomeMetodo = "servizioApplicativoWithCredenzialiSslList";
  324.         DriverControlStationDB driver = null;

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

  332.             return driver.getDriverConfigurazioneDB().servizioApplicativoWithCredenzialiSslList(certificate, strictVerifier,
  333.                     filtro.getTipiSoggetti(), filtro.isIncludiApplicativiNonModI(), filtro.isIncludiApplicativiModIEsterni(), filtro.isIncludiApplicativiModIInterni());

  335.         } catch (Exception e) {
  336.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  337.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  338.         } finally {
  339.             ControlStationCore.dbM.releaseConnection(con);
  340.         }

  342.     }
  343.     
  344.     public List<ServizioApplicativo> servizioApplicativoWithCredenzialiPrincipalList(String principal) throws DriverConfigurazioneException {
  345.         Connection con = null;
  346.         String nomeMetodo = "servizioApplicativoWithCredenzialiPrincipalList";
  347.         DriverControlStationDB driver = null;

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

  355.             return driver.getDriverConfigurazioneDB().servizioApplicativoWithCredenzialiPrincipalList(principal);

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

  364.     }
  365.     
  366.     public List<ServizioApplicativo> servizioApplicativoWithCredenzialiTokenList(String tokenPolicy, String tokenClientId) throws DriverConfigurazioneException {
  367.         Connection con = null;
  368.         String nomeMetodo = "servizioApplicativoWithCredenzialiTokenList";
  369.         DriverControlStationDB driver = null;

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

  377.             boolean tokenWithHttpsEnabled = false;
  378.             // basta un protocollo che lo supporta per doverli cercare anche con la funzionalita' abilitata
  379.             for(IProtocolFactory<?> protocolFactory: ProtocolFactoryManager.getInstance().getProtocolFactories().values()) {
  380.                 if(protocolFactory.createProtocolConfiguration().isSupportatoAutenticazioneApplicativiHttpsConToken()) {
  381.                     tokenWithHttpsEnabled = true;
  382.                     break;
  383.                 }
  384.             }
  385.             
  386.             return driver.getDriverConfigurazioneDB().servizioApplicativoWithCredenzialiTokenList(tokenPolicy, tokenClientId, tokenWithHttpsEnabled);

  388.         } catch (Exception e) {
  389.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  390.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  391.         } finally {
  392.             ControlStationCore.dbM.releaseConnection(con);
  393.         }

  395.     }
  396.     
  397.     public List<ServizioApplicativo> servizioApplicativoList(ISearch ricerca) throws DriverConfigurazioneException {
  398.         Connection con = null;
  399.         String nomeMetodo = "servizioApplicativoList";
  400.         DriverControlStationDB driver = null;

  402.         try {
  403.             // prendo una connessione
  404.             con = ControlStationCore.dbM.getConnection();
  405.             // istanzio il driver
  406.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  408.             return driver.getDriverConfigurazioneDB().servizioApplicativoList(ricerca);

  410.         } catch (Exception e) {
  411.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  412.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  413.         } finally {
  414.             ControlStationCore.dbM.releaseConnection(con);
  415.         }

  417.     }
  418.     
  419.     public List<ServizioApplicativo> servizioApplicativoList(IDSoggetto idSoggetto,ISearch ricerca) throws DriverConfigurazioneException {
  420.         Connection con = null;
  421.         String nomeMetodo = "servizioApplicativoList";
  422.         DriverControlStationDB driver = null;

  424.         try {
  425.             // prendo una connessione
  426.             con = ControlStationCore.dbM.getConnection();
  427.             // istanzio il driver
  428.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  430.             return driver.getDriverConfigurazioneDB().servizioApplicativoList(idSoggetto,ricerca);

  432.         } catch (Exception e) {
  433.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  434.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  435.         } finally {
  436.             ControlStationCore.dbM.releaseConnection(con);
  437.         }

  439.     }

  441.     

  443.     public boolean isServizioApplicativoInUsoComeErogatore(ServizioApplicativo sa, Map<ErrorsHandlerCostant, String> whereIsInUso) throws DriverConfigurazioneException {
  444.         Connection con = null;
  445.         String nomeMetodo = "isServizioApplicativoInUso";
  446.         DriverControlStationDB driver = null;

  448.         try {
  449.             // prendo una connessione
  450.             con = ControlStationCore.dbM.getConnection();
  451.             // istanzio il driver
  452.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  454.             return driver.getDriverConfigurazioneDB().isServizioApplicativoInUsoComeErogatore(sa, whereIsInUso);

  456.         } catch (Exception e) {
  457.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  458.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e), e);
  459.         } finally {
  460.             ControlStationCore.dbM.releaseConnection(con);
  461.         }

  463.     }
  464.     
  465.     
  466.     public boolean existsServizioApplicativo(IDServizioApplicativo idSA) throws DriverConfigurazioneException {
  467.         Connection con = null;
  468.         String nomeMetodo = "existsServizioApplicativo";
  469.         DriverControlStationDB driver = null;

  471.         try {
  472.             // prendo una connessione
  473.             con = ControlStationCore.dbM.getConnection();
  474.             // istanzio il driver
  475.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  477.             return driver.getDriverConfigurazioneDB().existsServizioApplicativo(idSA);

  479.         } catch (Exception e) {
  480.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  481.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  482.         } finally {
  483.             ControlStationCore.dbM.releaseConnection(con);
  484.         }
  485.     }
  486.     
  487.     public List<IDServizioApplicativoDB> getIdServiziApplicativiWithIdErogatore(Long idErogatore) throws DriverConfigurazioneException {
  488.         return getIdServiziApplicativiWithIdErogatore(idErogatore, null, false, false);
  489.     }
  490.     public List<IDServizioApplicativoDB> getIdServiziApplicativiWithIdErogatore(Long idErogatore,
  491.             boolean checkIM, boolean checkConnettoreAbilitato) throws DriverConfigurazioneException {
  492.         return getIdServiziApplicativiWithIdErogatore(idErogatore, null, checkIM, checkConnettoreAbilitato);
  493.     }
  494.     public List<IDServizioApplicativoDB> getIdServiziApplicativiWithIdErogatore(Long idErogatore, String tipo, 
  495.             boolean checkIM, boolean checkConnettoreAbilitato) throws DriverConfigurazioneException {
  496.         Connection con = null;
  497.         String nomeMetodo = "getServiziApplicativiWithIdErogatore";
  498.         DriverControlStationDB driver = null;

  500.         try {
  501.             // prendo una connessione
  502.             con = ControlStationCore.dbM.getConnection();
  503.             // istanzio il driver
  504.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  506.             return driver.getDriverConfigurazioneDB().getIdServiziApplicativiWithIdErogatore(idErogatore, tipo, checkIM, checkConnettoreAbilitato);

  508.         } catch (Exception e) {
  509.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  510.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  511.         } finally {
  512.             ControlStationCore.dbM.releaseConnection(con);
  513.         }
  514.     }

  516.     public List<IDServizioApplicativoDB> soggettiServizioApplicativoList(IDSoggetto idSoggetto,String superuser,CredenzialeTipo credenziale, Boolean appId, String tipo, 
  517.             boolean bothSslAndToken, String tokenPolicy) throws DriverConfigurazioneException {
  518.         return soggettiServizioApplicativoList(idSoggetto, superuser, credenziale, appId, tipo, 
  519.                 bothSslAndToken, tokenPolicy, false);
  520.     }
  521.     public List<IDServizioApplicativoDB> soggettiServizioApplicativoList(IDSoggetto idSoggetto,String superuser,CredenzialeTipo credenziale, Boolean appId, String tipo, 
  522.             boolean bothSslAndToken, String tokenPolicy, boolean tokenPolicyOR) throws DriverConfigurazioneException {
  523.         Connection con = null;
  524.         String nomeMetodo = "soggettiServizioApplicativoList(soggetto,user,credenziale,appId,tipo,ssl,token)";
  525.         DriverControlStationDB driver = null;

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

  533.             return driver.getDriverConfigurazioneDB().soggettiServizioApplicativoList(idSoggetto,superuser,credenziale, appId, tipo, 
  534.                     bothSslAndToken, tokenPolicy, tokenPolicyOR);

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

  544.     public List<ServizioApplicativo> soggettiServizioApplicativoList(String superuser, ISearch ricerca) throws DriverConfigurazioneException {
  545.         Connection con = null;
  546.         String nomeMetodo = "soggettiServizioApplicativoList";
  547.         DriverControlStationDB driver = null;

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

  555.             return driver.getDriverConfigurazioneDB().soggettiServizioApplicativoList(superuser, ricerca);

  557.         } catch (Exception e) {
  558.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  559.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  560.         } finally {
  561.             ControlStationCore.dbM.releaseConnection(con);
  562.         }
  563.     }
  564.     
  565.     public List<ServizioApplicativo> soggettiServizioApplicativoList(ISearch ricerca,Long idSoggetto) throws DriverConfigurazioneException {
  566.         Connection con = null;
  567.         String nomeMetodo = "soggettiServizioApplicativoList";
  568.         DriverControlStationDB driver = null;

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

  576.             return driver.getDriverConfigurazioneDB().soggettiServizioApplicativoList(idSoggetto, ricerca);

  578.         } catch (Exception e) {
  579.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  580.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  581.         } finally {
  582.             ControlStationCore.dbM.releaseConnection(con);
  583.         }
  584.     }
  585.     
  586.     public boolean isServizioApplicativoInUso(IDServizioApplicativo idServizioApplicativo,
  587.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean isRegistroServiziLocale, boolean normalizeObjectIds, boolean verificaRuoli) throws DriverConfigurazioneException {
  588.         Connection con = null;
  589.         String nomeMetodo = "isServizioApplicativoInUso";
  590.         
  591.         try {
  592.             // prendo una connessione
  593.             con = ControlStationCore.dbM.getConnection();

  595.             return DBOggettiInUsoUtils.isServizioApplicativoInUso(con, this.tipoDB, idServizioApplicativo, whereIsInUso, isRegistroServiziLocale, normalizeObjectIds, verificaRuoli);

  597.         } catch (Exception e) {
  598.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  599.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  600.         } finally {
  601.             ControlStationCore.dbM.releaseConnection(con);
  602.         }
  603.     }

  605.     
  606.     public List<IDServizioApplicativo> getAllIdServiziApplicativi(FiltroRicercaServiziApplicativi filtroRicerca) throws DriverConfigurazioneException {
  607.         Connection con = null;
  608.         String nomeMetodo = "getAllIdServiziApplicativi";
  609.         DriverControlStationDB driver = null;

  611.         try {
  612.             // prendo una connessione
  613.             con = ControlStationCore.dbM.getConnection();
  614.             // istanzio il driver
  615.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  617.             return driver.getDriverConfigurazioneDB().getAllIdServiziApplicativi(filtroRicerca);

  619.         } catch (DriverConfigurazioneNotFound e) {
  620.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  e),e);
  621.             return new ArrayList<>();
  622.         } catch (Exception e) {
  623.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  624.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  625.         } finally {
  626.             ControlStationCore.dbM.releaseConnection(con);
  627.         }
  628.     }
  629.     
  630.     public List<String> servizioApplicativoRuoliList(long idSA, ISearch ricerca) throws DriverConfigurazioneException {
  631.         Connection con = null;
  632.         String nomeMetodo = "servizioApplicativoRuoliList";
  633.         DriverControlStationDB driver = null;

  635.         try {
  636.             // prendo una connessione
  637.             con = ControlStationCore.dbM.getConnection();
  638.             // istanzio il driver
  639.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  641.             return driver.getDriverConfigurazioneDB().servizioApplicativoRuoliList(idSA, ricerca);

  643.         } catch (Exception e) {
  644.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  645.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  646.         } finally {
  647.             ControlStationCore.dbM.releaseConnection(con);
  648.         }

  650.     }
  651.     
  652.     public long getIdServizioApplicativoByConnettore(long idConnettore) throws DriverConfigurazioneException {
  653.         Connection con = null;
  654.         String nomeMetodo = "getIdServizioApplicativoByConnettore";
  655.         DriverControlStationDB driver = null;

  657.         try {
  658.             // prendo una connessione
  659.             con = ControlStationCore.dbM.getConnection();
  660.             // istanzio il driver
  661.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  663.             return driver.getDriverConfigurazioneDB().getIdServizioApplicativoByConnettore(idConnettore);

  665.         } catch (Exception e) {
  666.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  667.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  668.         } finally {
  669.             ControlStationCore.dbM.releaseConnection(con);
  670.         }
  671.     }
  672.     
  673.     public String getDettagliServizioApplicativoInUso(IDServizioApplicativo idServizioApplicativo, boolean verificaRuoli) throws DriverConfigurazioneException {
  674.         EnumMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new EnumMap<>(ErrorsHandlerCostant.class);
  675.         boolean normalizeObjectIds = true;
  676.         boolean saInUso  = this.isServizioApplicativoInUso(idServizioApplicativo, whereIsInUso, this.isRegistroServiziLocale(), normalizeObjectIds, verificaRuoli );
  677.         
  678.         StringBuilder inUsoMessage = new StringBuilder();
  679.         if(saInUso) {
  680.             String s = DBOggettiInUsoUtils.toString(idServizioApplicativo, whereIsInUso, false, "\n", normalizeObjectIds);
  681.             if(s!=null && s.startsWith("\n") && s.length()>1) {
  682.                 s = s.substring(1);
  683.             }
  684.             inUsoMessage.append(s);
  685.             inUsoMessage.append("\n");
  686.         } else {
  687.             inUsoMessage.append(ServiziApplicativiCostanti.LABEL_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  688.         }
  689.         
  690.         return inUsoMessage.toString();
  691.     }
  692.     public List<Proprieta> serviziApplicativiProprietaList(int idSA, ISearch ricerca) throws DriverConfigurazioneException {
  693.         Connection con = null;
  694.         String nomeMetodo = "serviziApplicativiProprietaList";
  695.         DriverControlStationDB driver = null;

  697.         try {
  698.             // prendo una connessione
  699.             con = ControlStationCore.dbM.getConnection();
  700.             // istanzio il driver
  701.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  703.             return driver.getDriverConfigurazioneDB().serviziApplicativiProprietaList(idSA, ricerca);

  705.         } catch (Exception e) {
  706.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  707.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  708.         } finally {
  709.             ControlStationCore.dbM.releaseConnection(con);
  710.         }
  711.     }
  712.     
  713.     public List<String> nomiProprietaSA(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoSoggettiProtocollo) throws DriverConfigurazioneException {
  714.         Connection con = null;
  715.         String nomeMetodo = "nomiProprietaSA";
  716.         DriverControlStationDB driver = null;

  718.         try {
  719.             // prendo una connessione
  720.             con = ControlStationCore.dbM.getConnection();
  721.             // istanzio il driver
  722.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  724.             return driver.getDriverConfigurazioneDB().nomiProprietaSA(filterSoggettoTipo, filterSoggettoNome, tipoSoggettiProtocollo); 

  726.         } catch (Exception e) {
  727.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  728.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  729.         } finally {
  730.             ControlStationCore.dbM.releaseConnection(con);
  731.         }
  732.     }
  733. }
Created with JaCoCo 0.8.8.202204050719