SoggettiCore.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.soggetti;

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

  29. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  30. import org.openspcoop2.core.commons.ISearch;
  31. import org.openspcoop2.core.config.Soggetto;
  32. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  33. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  34. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.core.registry.Proprieta;
  37. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  38. import org.openspcoop2.core.registry.constants.PddTipologia;
  39. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  40. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  41. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  42. import org.openspcoop2.core.registry.driver.db.IDSoggettoDB;
  43. import org.openspcoop2.pdd.core.autenticazione.ApiKey;
  44. import org.openspcoop2.pdd.core.autenticazione.ApiKeyUtilities;
  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.utils.resources.MapReader;
  49. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  50. import org.openspcoop2.web.ctrlstat.dao.SoggettoCtrlStat;
  51. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  52. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  53. import org.openspcoop2.web.ctrlstat.registro.GestoreRegistroServiziRemoto;
  54. import org.openspcoop2.web.lib.users.DriverUsersDBException;

  56. /**
  57.  * SoggettiCore
  58.  *
  59.  * @author Poli Andrea (apoli@link.it)
  60.  * @author $Author$
  61.  * @version $Rev$, $Date$
  62.  */
  63. public class SoggettiCore extends ControlStationCore {

  65.     public SoggettiCore() throws DriverControlStationException {
  66.         super();
  67.     }
  68.     public SoggettiCore(ControlStationCore core) throws DriverControlStationException {
  69.         super(core);
  70.     }
  71.         
  72.     public List<IDSoggetto> getAllIdSoggettiRegistro(FiltroRicercaSoggetti filtroRicerca) throws DriverRegistroServiziException {
  73.         Connection con = null;
  74.         String nomeMetodo = "getAllIdSoggettiRegistro";
  75.         DriverControlStationDB driver = null;

  77.         try {
  78.             if(this.isRegistroServiziLocale()){
  79.                 // prendo una connessione
  80.                 con = ControlStationCore.dbM.getConnection();
  81.                 // istanzio il driver
  82.                 driver = new DriverControlStationDB(con, null, this.tipoDB);
  83.     
  84.                 return driver.getDriverRegistroServiziDB().getAllIdSoggetti(filtroRicerca);
  85.             }
  86.             else{
  87.                 return GestoreRegistroServiziRemoto.getDriverRegistroServizi(ControlStationCore.log).getAllIdSoggetti(filtroRicerca);
  88.             }

  90.         } catch (DriverRegistroServiziNotFound de) {
  91.             ControlStationCore.logInfo(getPrefixError(nomeMetodo,  de));
  92.             return new ArrayList<>();
  93.         } catch (Exception e) {
  94.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  95.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  96.         } finally {
  97.             ControlStationCore.dbM.releaseConnection(con);
  98.         }
  99.     }

  101.     public boolean existsSoggetto(long idSoggetto) throws DriverRegistroServiziException {
  102.         Connection con = null;
  103.         String nomeMetodo = "existsSoggetto(long)";
  104.         DriverControlStationDB driver = null;

  106.         try {
  107.             // prendo una connessione
  108.             con = ControlStationCore.dbM.getConnection();
  109.             // istanzio il driver
  110.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  112.             return driver.getDriverRegistroServiziDB().existsSoggetto(idSoggetto);

  114.         } catch (Exception e) {
  115.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  116.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  117.         } finally {
  118.             ControlStationCore.dbM.releaseConnection(con);
  119.         }
  120.     }

  122.     public boolean existsSoggetto(IDSoggetto idSoggetto) throws DriverConfigurazioneException {
  123.         Connection con = null;
  124.         String nomeMetodo = "existsSoggetto";
  125.         DriverControlStationDB driver = null;

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

  133.             return driver.getDriverConfigurazioneDB().existsSoggetto(idSoggetto);

  135.         } catch (Exception e) {
  136.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  137.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  138.         } finally {
  139.             ControlStationCore.dbM.releaseConnection(con);
  140.         }
  141.     }
  142.     
  143.     public boolean existsSoggetto(String codiceIPA) throws DriverConfigurazioneException {
  144.         Connection con = null;
  145.         String nomeMetodo = "existsSoggetto";
  146.         DriverControlStationDB driver = null;

  148.         try {
  149.             // prendo una connessione
  150.             con = ControlStationCore.dbM.getConnection();
  151.             // istanzio il driver
  152.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  154.             return driver.getDriverRegistroServiziDB().existsSoggetto(codiceIPA);

  156.         } catch (Exception e) {
  157.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  158.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  159.         } finally {
  160.             ControlStationCore.dbM.releaseConnection(con);
  161.         }
  162.     }
  163.     
  164.     public org.openspcoop2.core.registry.Soggetto getSoggettoByCodiceIPA(String codiceIPA) throws DriverConfigurazioneException,DriverRegistroServiziNotFound {
  165.         Connection con = null;
  166.         String nomeMetodo = "getSoggettoByCodiceIPA";
  167.         DriverControlStationDB driver = null;

  169.         try {
  170.             // prendo una connessione
  171.             con = ControlStationCore.dbM.getConnection();
  172.             // istanzio il driver
  173.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  175.             return driver.getDriverRegistroServiziDB().getSoggetto(codiceIPA);

  177.         } catch (DriverRegistroServiziNotFound de) {
  178.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  179.             throw de;
  180.         }catch (Exception e) {
  181.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  182.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  183.         } finally {
  184.             ControlStationCore.dbM.releaseConnection(con);
  185.         }
  186.     }
  187.     
  188.     public String getCodiceIPA(IDSoggetto idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  189.         Connection con = null;
  190.         String nomeMetodo = "getCodiceIPA";
  191.         DriverControlStationDB driver = null;

  193.         try {
  194.             // prendo una connessione
  195.             con = ControlStationCore.dbM.getConnection();
  196.             // istanzio il driver
  197.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  199.             return driver.getDriverRegistroServiziDB().getCodiceIPA(idSoggetto);

  201.         } catch (DriverRegistroServiziNotFound de) {
  202.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  203.             throw de;
  204.         }catch (Exception e) {
  205.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  206.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  207.         } finally {
  208.             ControlStationCore.dbM.releaseConnection(con);
  209.         }
  210.     }
  211.     
  212.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistro(IDSoggetto idSoggetto) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  213.         Connection con = null;
  214.         String nomeMetodo = "getSoggettoRegistro";
  215.         DriverControlStationDB driver = null;

  217.         try {
  218.             if(this.isRegistroServiziLocale()){
  219.                 // prendo una connessione
  220.                 con = ControlStationCore.dbM.getConnection();
  221.                 // istanzio il driver
  222.                 driver = new DriverControlStationDB(con, null, this.tipoDB);
  223.     
  224.                 return driver.getDriverRegistroServiziDB().getSoggetto(idSoggetto);
  225.             }
  226.             else{
  227.                 return GestoreRegistroServiziRemoto.getDriverRegistroServizi(ControlStationCore.log).getSoggetto(idSoggetto);
  228.             }

  230.         } catch (DriverRegistroServiziNotFound de) {
  231.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  232.             throw de;
  233.         } catch (Exception e) {
  234.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  235.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  236.         } finally {
  237.             ControlStationCore.dbM.releaseConnection(con);
  238.         }

  240.     }
  241.     
  242.     public IDSoggetto getIdSoggettoRegistro(long idErogatore) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  243.         Connection con = null;
  244.         String nomeMetodo = "getIdSoggettoRegistro";
  245.         DriverControlStationDB driver = null;

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

  253.             return driver.getDriverRegistroServiziDB().getIdSoggetto(idErogatore);

  255.         } catch (DriverRegistroServiziNotFound de) {
  256.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  257.             throw de;
  258.         } catch (Exception e) {
  259.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  260.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  261.         } finally {
  262.             ControlStationCore.dbM.releaseConnection(con);
  263.         }
  264.     }
  265.     
  266.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistro(long idErogatore) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  267.         Connection con = null;
  268.         String nomeMetodo = "getSoggettoRegistro";
  269.         DriverControlStationDB driver = null;

  271.         try {
  272.             // prendo una connessione
  273.             con = ControlStationCore.dbM.getConnection();
  274.             // istanzio il driver
  275.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  277.             return driver.getDriverRegistroServiziDB().getSoggetto(idErogatore);

  279.         } catch (DriverRegistroServiziNotFound de) {
  280.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  281.             throw de;
  282.         } catch (Exception e) {
  283.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  284.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  285.         } finally {
  286.             ControlStationCore.dbM.releaseConnection(con);
  287.         }
  288.     }

  290.     public boolean existsSoggettoServiziWithoutConnettore(long idSoggetto) throws DriverRegistroServiziException {
  291.         Connection con = null;
  292.         String nomeMetodo = "existsSoggettoServiziWithoutConnettore";
  293.         DriverControlStationDB driver = null;

  295.         try {
  296.             // prendo una connessione
  297.             con = ControlStationCore.dbM.getConnection();
  298.             // istanzio il driver
  299.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  301.             return driver.getDriverRegistroServiziDB().existsSoggettoServiziWithoutConnettore(idSoggetto);

  303.         } catch (Exception e) {
  304.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  305.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  306.         } finally {
  307.             ControlStationCore.dbM.releaseConnection(con);
  308.         }
  309.     }
  310.     
  311.     public boolean existFruizioniServiziSoggettoWithoutConnettore(long idSoggetto, boolean escludiSoggettiEsterni) throws DriverRegistroServiziException {
  312.         Connection con = null;
  313.         String nomeMetodo = "existFruizioniServiziSoggettoWithoutConnettore";
  314.         DriverControlStationDB driver = null;

  316.         try {
  317.             // prendo una connessione
  318.             con = ControlStationCore.dbM.getConnection();
  319.             // istanzio il driver
  320.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  322.             return driver.getDriverRegistroServiziDB().existFruizioniServiziSoggettoWithoutConnettore(idSoggetto,escludiSoggettiEsterni);

  324.         } catch (Exception e) {
  325.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  326.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  327.         } finally {
  328.             ControlStationCore.dbM.releaseConnection(con);
  329.         }
  330.     }
  331.     
  332.     public Soggetto getRouter() throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  333.         Connection con = null;
  334.         String nomeMetodo = "getRouter";
  335.         DriverControlStationDB driver = null;

  337.         try {
  338.             // prendo una connessione
  339.             con = ControlStationCore.dbM.getConnection();
  340.             // istanzio il driver
  341.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  343.             return driver.getDriverConfigurazioneDB().getRouter();

  345.         } catch (DriverConfigurazioneNotFound de) {
  346.             ControlStationCore.logInfo(getPrefixError(nomeMetodo,  de));
  347.             throw de;
  348.         } catch (Exception e) {
  349.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  350.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  351.         } finally {
  352.             ControlStationCore.dbM.releaseConnection(con);
  353.         }

  355.     }

  357.     /**
  358.      * Ritorna il {@link Soggetto} utilizzando il driver
  359.      * {@link DriverConfigurazioneDB} che soddisfa i parametri passati come
  360.      * input
  361.      */
  362.     public Soggetto getSoggetto(IDSoggetto soggetto) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  363.         Connection con = null;
  364.         String nomeMetodo = "getSoggetto";
  365.         DriverControlStationDB driver = null;

  367.         try {
  368.             // prendo una connessione
  369.             con = ControlStationCore.dbM.getConnection();
  370.             // istanzio il driver
  371.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  373.             return driver.getDriverConfigurazioneDB().getSoggetto(soggetto);

  375.         } catch (DriverControlStationException e) {
  376.             ControlStationCore.logError(e.getMessage(),e);
  377.             throw new DriverConfigurazioneException(e);
  378.         } catch (DriverConfigurazioneNotFound de) {
  379.             ControlStationCore.logInfo(getPrefixError(nomeMetodo,  de));
  380.             throw de;
  381.         } catch (DriverConfigurazioneException e) {
  382.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  383.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  384.         } finally {
  385.             ControlStationCore.dbM.releaseConnection(con);
  386.         }

  388.     }

  390.     public Soggetto getSoggetto(long idSoggetto) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  391.         Connection con = null;
  392.         String nomeMetodo = "getSoggetto";
  393.         DriverControlStationDB driver = null;

  395.         try {
  396.             // prendo una connessione
  397.             con = ControlStationCore.dbM.getConnection();
  398.             // istanzio il driver
  399.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  401.             return driver.getDriverConfigurazioneDB().getSoggetto(idSoggetto);

  403.         } catch (DriverConfigurazioneNotFound de) {
  404.             ControlStationCore.logInfo(getPrefixError(nomeMetodo,  de));
  405.             throw de;
  406.         } catch (Exception e) {
  407.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  408.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  409.         } finally {
  410.             ControlStationCore.dbM.releaseConnection(con);
  411.         }

  413.     }

  415.     public SoggettoCtrlStat getSoggettoCtrlStat(long idSoggetto) throws DriverConfigurazioneNotFound, DriverRegistroServiziNotFound, DriverControlStationException {
  416.         Connection con = null;
  417.         String nomeMetodo = "getSoggettoCtrlStat";
  418.         DriverControlStationDB driver = null;

  420.         try {
  421.             // prendo una connessione
  422.             con = ControlStationCore.dbM.getConnection();
  423.             // istanzio il driver
  424.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  426.             Soggetto soggConf = driver.getDriverConfigurazioneDB().getSoggetto(idSoggetto);
  427.             org.openspcoop2.core.registry.Soggetto soggReg = null;
  428.             if(this.isRegistroServiziLocale()){
  429.                 soggReg = driver.getDriverRegistroServiziDB().getSoggetto(idSoggetto);
  430.             }

  432.             return new SoggettoCtrlStat(soggReg, soggConf);

  434.         } catch (DriverConfigurazioneNotFound de) {
  435.             ControlStationCore.logInfo(getPrefixError(nomeMetodo,  de));
  436.             throw de;
  437.         } catch (DriverRegistroServiziNotFound de) {
  438.             ControlStationCore.logDebug(getPrefixError(nomeMetodo,  de),de);
  439.             throw de;
  440.         } catch (Exception e) {
  441.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  442.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  443.         } finally {
  444.             ControlStationCore.dbM.releaseConnection(con);
  445.         }
  446.     }
  447.     
  448.     public long getIdSoggetto(String nomeSoggetto, String tipoSoggetto) throws DriverConfigurazioneException
  449.     {
  450.         Connection con = null;
  451.         String nomeMetodo = "getIdSoggetto";
  452.         DriverControlStationDB driver = null;
  453.  
  454.         long idSoggetto=-1;
  455.         try
  456.         {
  457.             // prendo una connessione
  458.             con = ControlStationCore.dbM.getConnection();
  459.             // istanzio il driver
  460.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  461.             
  462.             IDSoggetto aSoggetto = new IDSoggetto(tipoSoggetto, nomeSoggetto);
  463.             
  464.             idSoggetto = driver.getDriverConfigurazioneDB().getSoggetto(aSoggetto).getId();

  466.         } catch (DriverConfigurazioneNotFound e) {
  467.             // Lasciare DEBUG, usato anche in servizio API RS
  468.             ControlStationCore.logDebug(getPrefixNotFound(nomeMetodo,  e), e);
  469.             throw new DriverConfigurazioneException(getPrefixNotFound(nomeMetodo,  e),e);
  470.         } catch (Exception e) {
  471.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  472.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  473.         }finally
  474.         {
  475.             ControlStationCore.dbM.releaseConnection(con);
  476.         }
  477.         return idSoggetto;
  478.     }
  479.     
  480.     public List<Soggetto> soggettiList(String superuser, ISearch ricerca) throws DriverConfigurazioneException {
  481.         Connection con = null;
  482.         String nomeMetodo = "soggettiList";
  483.         DriverControlStationDB driver = null;

  485.         try {
  486.             // prendo una connessione
  487.             con = ControlStationCore.dbM.getConnection();
  488.             // istanzio il driver
  489.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  491.             return driver.getDriverConfigurazioneDB().soggettiList(superuser, ricerca);

  493.         } catch (Exception e) {
  494.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  495.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  496.         } finally {
  497.             ControlStationCore.dbM.releaseConnection(con);
  498.         }

  500.     }

  502.     public List<Soggetto> soggettiWithServiziList(String superuser,ISearch ricerca) throws DriverConfigurazioneException {
  503.         Connection con = null;
  504.         String nomeMetodo = "soggettiWithServiziList";
  505.         DriverControlStationDB driver = null;

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

  513.             return driver.getDriverConfigurazioneDB().soggettiWithServiziList(superuser,ricerca);

  515.         } catch (Exception e) {
  516.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  517.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  518.         } finally {
  519.             ControlStationCore.dbM.releaseConnection(con);
  520.         }

  522.     }
  523.     
  524.     
  525.     public boolean isSoggettoInUso(org.openspcoop2.core.registry.Soggetto soggetto, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, 
  526.             boolean normalizeObjectIds, boolean verificaRuoli) throws DriverControlStationException {

  528.         Connection con = null;
  529.         String nomeMetodo = "isSoggettoInUso(Registro)";
  530.         DriverControlStationDB driver = null;

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

  538.             return driver.isSoggettoInUso(soggetto, whereIsInUso, normalizeObjectIds, verificaRuoli);

  540.         } catch (Exception e) {
  541.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  542.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e), e);
  543.         } finally {
  544.             ControlStationCore.dbM.releaseConnection(con);
  545.         }

  547.     }
  548.     
  549.     public boolean isSoggettoInUso(org.openspcoop2.core.config.Soggetto soggetto, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, 
  550.             boolean normalizeObjectIds, boolean verificaRuoli) throws DriverControlStationException {

  552.         Connection con = null;
  553.         String nomeMetodo = "isSoggettoInUso(Config)";
  554.         DriverControlStationDB driver = null;

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

  562.             return driver.isSoggettoInUso(soggetto, whereIsInUso, normalizeObjectIds, verificaRuoli);

  564.         } catch (Exception e) {
  565.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  566.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e), e);
  567.         } finally {
  568.             ControlStationCore.dbM.releaseConnection(con);
  569.         }

  571.     }
  572.     
  573.     public boolean isSoggettoInUsoInPackageFinali(org.openspcoop2.core.registry.Soggetto soggetto, Map<ErrorsHandlerCostant,String> whereIsInUso) throws DriverControlStationException {

  575.         Connection con = null;
  576.         String nomeMetodo = "isSoggettoInUsoInPackageFinali";
  577.         DriverControlStationDB driver = null;

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

  585.             return driver.getDriverRegistroServiziDB().isSoggettoInUsoInPackageFinali(soggetto, whereIsInUso);

  587.         } catch (Exception e) {
  588.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  589.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  590.         } finally {
  591.             ControlStationCore.dbM.releaseConnection(con);
  592.         }

  594.     }
  595.     
  596.     public boolean isSoggettoInUsoInPackagePubblici(org.openspcoop2.core.registry.Soggetto soggetto, Map<ErrorsHandlerCostant,String> whereIsInUso) throws DriverControlStationException {

  598.         Connection con = null;
  599.         String nomeMetodo = "isSoggettoInUsoInPackagePubblici";
  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().isSoggettoInUsoInPackagePubblici(soggetto, whereIsInUso);

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

  617.     }

  619.     public List<IDSoggetto> getSoggettiWithSuperuser(String user) throws DriverUsersDBException {
  620.         Connection con = null;
  621.         String nomeMetodo = "getSoggettiWithSuperuser";
  622.         DriverControlStationDB driver = null;

  624.         try {
  625.             // prendo una connessione
  626.             con = ControlStationCore.dbM.getConnection();
  627.             // istanzio il driver
  628.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  629.             return driver.getDriverConfigurazioneDB().getSoggettiWithSuperuser(user);
  630.         } catch (Exception e) {
  631.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  632.             throw new DriverUsersDBException(getPrefixError(nomeMetodo,  e),e);
  633.         } finally {
  634.             ControlStationCore.dbM.releaseConnection(con);
  635.         }
  636.     }
  637.     
  638.     
  639.         
  640.     public List<String> getTipiSoggettiGestiti() throws DriverRegistroServiziException {
  641.         String nomeMetodo = "getTipiSoggettiGestiti";
  642.         try{
  643.             
  644.             List<String> tipi = new ArrayList<>();
  645.             
  646.             MapReader<String, IProtocolFactory<?>> protocolFactories = this.protocolFactoryManager.getProtocolFactories();
  647.             Enumeration<String> protocolli = protocolFactories.keys();
  648.             while (protocolli.hasMoreElements()) {
  649.                 
  650.                 String protocollo = protocolli.nextElement();
  651.                 IProtocolFactory<?> protocolFactory = protocolFactories.get(protocollo);
  652.                 for (String tipo : protocolFactory.createProtocolConfiguration().getTipiSoggetti()){
  653.                     if(!tipi.contains(tipo)){
  654.                         tipi.add(tipo);
  655.                     }
  656.                 }
  657.             }
  658.             
  659.             return tipi;
  660.             
  661.         }catch (Exception e) {
  662.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  663.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  664.         }
  665.     }
  666.     public String getTipoSoggettoDefaultProtocollo(String protocollo) throws  DriverRegistroServiziException {
  667.         String getTipoServizioDefault = "getTipoSoggettoDefaultProtocollo";
  668.         try{
  669.             
  670.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().getTipoSoggettoDefault();
  671.             
  672.         }catch (Exception e) {
  673.             String msgError = getPrefixError(getTipoServizioDefault, e);
  674.             ControlStationCore.logError(msgError, e);
  675.             throw new DriverRegistroServiziException(msgError,e);
  676.         }
  677.     }

  679.     public List<String> getTipiSoggettiGestitiProtocollo(String protocollo) throws DriverRegistroServiziException {
  680.         String nomeMetodo = "getTipiSoggettiGestitiProtocollo";
  681.         try{
  682.             
  683.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().getTipiSoggetti();
  684.             
  685.         }catch (Exception e) {
  686.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  687.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  688.         }
  689.     }
  690.     public String getProtocolloAssociatoTipoSoggetto(String tipoSoggetto) throws DriverRegistroServiziException {
  691.         String nomeMetodo = "getProtocolloAssociatoTipoSoggetto";
  692.         try{
  693.             
  694.             return this.protocolFactoryManager.getProtocolByOrganizationType(tipoSoggetto);
  695.             
  696.         }catch (Exception e) {
  697.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  698.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  699.         }
  700.     }
  701.     
  702.     public String getWebContextProtocolAssociatoTipoSoggetto(String tipoSoggetto) throws DriverRegistroServiziException {
  703.         String nomeMetodo = "getWebContextProtocolAssociatoTipoSoggetto";
  704.         try{
  705.             
  706.             String protocollo = this.getProtocolloAssociatoTipoSoggetto(tipoSoggetto);
  707.             IProtocolFactory<?> pf = this.protocolFactoryManager.getProtocolFactoryByName(protocollo);
  708.             if(pf.getManifest().getWeb().getEmptyContext()!=null && pf.getManifest().getWeb().getEmptyContext().isEnabled()){
  709.                 return "";
  710.             }
  711.             else{
  712.                 return pf.getManifest().getWeb().getContext(0).getName();
  713.             }
  714.             
  715.         }catch (Exception e) {
  716.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  717.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  718.         }
  719.     }
  720.     
  721.     public String getIdentificativoPortaDefault(String protocollo,IDSoggetto soggetto) throws DriverRegistroServiziException {
  722.         String nomeMetodo = "getIdentificativoPortaDefault";
  723.         try{
  724.             
  725.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createTraduttore().getIdentificativoPortaDefault(soggetto);
  726.             
  727.         }catch (Exception e) {
  728.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  729.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  730.         }
  731.     }

  733.     public boolean isSupportatoIdentificativoPorta(String protocollo) throws DriverRegistroServiziException {
  734.         String nomeMetodo = "isSupportatoIdentificativoPorta";
  735.         try{
  736.             
  737.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoIdentificativoPortaSoggetto();
  738.             
  739.         }catch (Exception e) {
  740.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  741.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  742.         }
  743.     }
  744.     
  745.     public boolean isSupportatoCodiceIPA(String protocollo) throws DriverRegistroServiziException {
  746.         String nomeMetodo = "isSupportatoCodiceIPA";
  747.         try{
  748.             
  749.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoCodiceIPA();
  750.             
  751.         }catch (Exception e) {
  752.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  753.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  754.         }
  755.     }
  756.     
  757.     public boolean isSupportatoTrattinoNomeSoggetto(String protocollo) throws DriverRegistroServiziException {
  758.         String nomeMetodo = "isSupportatoTrattinoNomeSoggetto";
  759.         try{
  760.             
  761.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoSoggettoUtilizzoTrattino();
  762.             
  763.         }catch (Exception e) {
  764.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  765.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  766.         }
  767.     }
  768.     
  769.     public boolean isSupportatoAutenticazioneSoggetti(String protocollo) throws DriverRegistroServiziException {
  770.         String nomeMetodo = "isSupportatoAutenticazioneSoggetti";
  771.         try{
  772.             
  773.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoAutenticazioneSoggetti();
  774.             
  775.         }catch (Exception e) {
  776.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  777.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  778.         }
  779.     }
  780.     
  781.     public boolean isSupportatoAutenticazioneApplicativiErogazione(String protocollo) throws DriverRegistroServiziException {
  782.         String nomeMetodo = "isSupportatoAutenticazioneApplicativiErogazione";
  783.         try{
  784.             
  785.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportoAutenticazioneApplicativiErogazioni();
  786.             
  787.         }catch (Exception e) {
  788.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  789.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  790.         }
  791.     }
  792.     
  793.     public boolean isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazione(String protocollo) throws DriverRegistroServiziException {
  794.         String nomeMetodo = "isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazione";
  795.         try{
  796.             
  797.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazioni();
  798.             
  799.         }catch (Exception e) {
  800.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  801.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  802.         }
  803.     }
  804.     
  805.     public String getCodiceIPADefault(String protocollo,IDSoggetto soggetto,boolean createURI) throws DriverRegistroServiziException {
  806.         String nomeMetodo = "getCodiceIPADefault";
  807.         try{
  808.             
  809.             return this.protocolFactoryManager.getProtocolFactoryByName(protocollo).createTraduttore().getIdentificativoCodiceIPADefault(soggetto,createURI);
  810.             
  811.         }catch (Exception e) {
  812.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  813.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  814.         }
  815.     }
  816.     
  817.     public List<String> soggettiRuoliList(long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
  818.         Connection con = null;
  819.         String nomeMetodo = "soggettiRuoliList";
  820.         DriverControlStationDB driver = null;

  822.         try {
  823.             // prendo una connessione
  824.             con = ControlStationCore.dbM.getConnection();
  825.             // istanzio il driver
  826.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  828.             return driver.getDriverRegistroServiziDB().soggettiRuoliList(idSoggetto, ricerca);

  830.         } catch (Exception e) {
  831.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  832.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  833.         } finally {
  834.             ControlStationCore.dbM.releaseConnection(con);
  835.         }

  837.     }
  838.     
  839.     public org.openspcoop2.core.registry.Soggetto soggettoWithCredenzialiBasic(String user, String password, boolean checkPassword) throws DriverConfigurazioneException {
  840.         Connection con = null;
  841.         String nomeMetodo = "soggettoWithCredenzialiBasic";
  842.         DriverControlStationDB driver = null;

  844.         try {
  845.             // prendo una connessione
  846.             con = ControlStationCore.dbM.getConnection();
  847.             // istanzio il driver
  848.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  850.             return driver.getDriverRegistroServiziDB().soggettoWithCredenzialiBasic(user, password, checkPassword);

  852.         } 
  853.         catch (Exception e) {
  854.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  855.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  856.         } finally {
  857.             ControlStationCore.dbM.releaseConnection(con);
  858.         }

  860.     }
  861.     
  862.     public String toAppId(String protocollo, IDSoggetto idSoggetto,  boolean multipleApiKeys) throws DriverConfigurazioneException {
  863.         
  864.         Connection con = null;
  865.         String nomeMetodo = "toAppId";
  866.         DriverControlStationDB driver = null;

  868.         try {
  869.             // prendo una connessione
  870.             con = ControlStationCore.dbM.getConnection();
  871.             // istanzio il driver
  872.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  874.             return ApiKeyUtilities.toAppId(protocollo, idSoggetto, multipleApiKeys, driver.getDriverRegistroServiziDB());

  876.         } catch (Exception e) {
  877.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  878.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  879.         } finally {
  880.             ControlStationCore.dbM.releaseConnection(con);
  881.         }
  882.         
  883.     }
  884.     
  885.     public ApiKey newApiKey(String protocollo, IDSoggetto idSoggetto) throws DriverConfigurazioneException {
  886.         
  887.         Connection con = null;
  888.         String nomeMetodo = "newApiKey";
  889.         DriverControlStationDB driver = null;

  891.         try {
  892.             // prendo una connessione
  893.             con = ControlStationCore.dbM.getConnection();
  894.             // istanzio il driver
  895.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  897.             return ApiKeyUtilities.newApiKey(protocollo, idSoggetto, this.getSoggettiApiKeyLunghezzaPasswordGenerate(), driver.getDriverRegistroServiziDB());

  899.         } catch (Exception e) {
  900.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  901.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  902.         } finally {
  903.             ControlStationCore.dbM.releaseConnection(con);
  904.         }
  905.         
  906.     }
  907.     
  908.     public ApiKey newMultipleApiKey() throws DriverConfigurazioneException {
  909.         
  910.         String nomeMetodo = "newMultipleApiKey";
  911.         try {
  912.             return ApiKeyUtilities.newMultipleApiKey(this.getSoggettiApiKeyLunghezzaPasswordGenerate());
  913.         } catch (Exception e) {
  914.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  915.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  916.         }
  917.         
  918.     }
  919.     
  920.     public org.openspcoop2.core.registry.Soggetto soggettoWithCredenzialiApiKey(String user, boolean appId) throws DriverConfigurazioneException {
  921.         Connection con = null;
  922.         String nomeMetodo = "soggettoWithCredenzialiApiKey";
  923.         DriverControlStationDB driver = null;

  925.         try {
  926.             // prendo una connessione
  927.             con = ControlStationCore.dbM.getConnection();
  928.             // istanzio il driver
  929.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  931.             return driver.getDriverRegistroServiziDB().soggettoWithCredenzialiApiKey(user, appId);

  933.         } 
  934.         catch (Exception e) {
  935.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  936.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  937.         } finally {
  938.             ControlStationCore.dbM.releaseConnection(con);
  939.         }

  941.     }
  942.     
  943.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroAutenticatoBasic(String user, String password) throws DriverConfigurazioneException {
  944.         Connection con = null;
  945.         String nomeMetodo = "getSoggettoAutenticatoBasic";
  946.         DriverControlStationDB driver = null;

  948.         try {
  949.             // prendo una connessione
  950.             con = ControlStationCore.dbM.getConnection();
  951.             // istanzio il driver
  952.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  954.             return driver.getDriverRegistroServiziDB().getSoggettoByCredenzialiBasic(user, password, this.getSoggettiPasswordEncrypt());

  956.         } 
  957.         catch (DriverRegistroServiziNotFound e) {
  958.             return null;
  959.         }
  960.         catch (Exception e) {
  961.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  962.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  963.         } finally {
  964.             ControlStationCore.dbM.releaseConnection(con);
  965.         }

  967.     }
  968.     
  969.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroAutenticatoSsl(String subject, String issuer) throws DriverConfigurazioneException {
  970.         Connection con = null;
  971.         String nomeMetodo = "getSoggettoRegistroAutenticatoSsl(subject,issuer)";
  972.         DriverControlStationDB driver = null;

  974.         try {
  975.             // prendo una connessione
  976.             con = ControlStationCore.dbM.getConnection();
  977.             // istanzio il driver
  978.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  980.             return driver.getDriverRegistroServiziDB().getSoggettoByCredenzialiSsl(subject, issuer);

  982.         } 
  983.         catch (DriverRegistroServiziNotFound e) {
  984.             return null;
  985.         }
  986.         catch (Exception e) {
  987.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  988.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  989.         } finally {
  990.             ControlStationCore.dbM.releaseConnection(con);
  991.         }

  993.     }
  994.     
  995.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroAutenticatoSsl(CertificateInfo certificate, boolean strictVerifier) throws DriverConfigurazioneException {
  996.         Connection con = null;
  997.         String nomeMetodo = "getSoggettoRegistroAutenticatoSsl(certificate)";
  998.         DriverControlStationDB driver = null;

  1000.         try {
  1001.             // prendo una connessione
  1002.             con = ControlStationCore.dbM.getConnection();
  1003.             // istanzio il driver
  1004.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1006.             return driver.getDriverRegistroServiziDB().getSoggettoByCredenzialiSsl(certificate, strictVerifier);

  1008.         } 
  1009.         catch (DriverRegistroServiziNotFound e) {
  1010.             return null;
  1011.         }
  1012.         catch (Exception e) {
  1013.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1014.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1015.         } finally {
  1016.             ControlStationCore.dbM.releaseConnection(con);
  1017.         }

  1019.     }
  1020.     
  1021.     public List<org.openspcoop2.core.registry.Soggetto> soggettoWithCredenzialiSslList(CertificateInfo certificate, boolean strictVerifier) throws DriverConfigurazioneException {
  1022.         Connection con = null;
  1023.         String nomeMetodo = "getSoggettoRegistroAutenticatoSsl";
  1024.         DriverControlStationDB driver = null;

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

  1032.             return driver.getDriverRegistroServiziDB().soggettoWithCredenzialiSslList(certificate, strictVerifier);

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

  1042.     }
  1043.     
  1044.     public org.openspcoop2.core.registry.Soggetto getSoggettoRegistroAutenticatoPrincipal(String principal) throws DriverConfigurazioneException {
  1045.         Connection con = null;
  1046.         String nomeMetodo = "getSoggettoAutenticatoPrincipal";
  1047.         DriverControlStationDB driver = null;

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

  1055.             return driver.getDriverRegistroServiziDB().getSoggettoByCredenzialiPrincipal(principal);

  1057.         } 
  1058.         catch (DriverRegistroServiziNotFound e) {
  1059.             return null;
  1060.         }
  1061.         catch (Exception e) {
  1062.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1063.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1064.         } finally {
  1065.             ControlStationCore.dbM.releaseConnection(con);
  1066.         }

  1068.     }
  1069.     
  1070.     public List<IDSoggettoDB> getSoggettiFromTipoAutenticazione(List<String> tipiSoggetto, String superuser,CredenzialeTipo credenziale, Boolean appId, PddTipologia pddTipologia) throws DriverConfigurazioneException{
  1071.         Connection con = null;
  1072.         String nomeMetodo = "getSoggettiFromTipoAutenticazione";
  1073.         DriverControlStationDB driver = null;
  1074.         
  1075.         try {
  1076.             // prendo una connessione
  1077.             con = ControlStationCore.dbM.getConnection();
  1078.             // istanzio il driver
  1079.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1081.             return driver.getDriverRegistroServiziDB().getSoggettiFromTipoAutenticazione(tipiSoggetto,superuser,credenziale,appId, pddTipologia);

  1083.         } 
  1084.         catch (Exception e) {
  1085.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1086.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1087.         } finally {
  1088.             ControlStationCore.dbM.releaseConnection(con);
  1089.         }
  1090.     }
  1091.     
  1092.     
  1093.     public String getDettagliSoggettoInUso(org.openspcoop2.core.registry.Soggetto soggetto, boolean verificaRuoli) throws DriverControlStationException {
  1094.         EnumMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new EnumMap<>(ErrorsHandlerCostant.class);
  1095.         boolean normalizeObjectIds = true;
  1096.         boolean saInUso  = this.isSoggettoInUso(soggetto, whereIsInUso, normalizeObjectIds, verificaRuoli );
  1097.         
  1098.         StringBuilder inUsoMessage = new StringBuilder();
  1099.         if(saInUso) {
  1100.             
  1101.             IDSoggetto idSoggetto = new IDSoggetto();
  1102.             idSoggetto.setTipo(soggetto.getTipo());
  1103.             idSoggetto.setNome(soggetto.getNome());
  1104.             idSoggetto.setCodicePorta(soggetto.getIdentificativoPorta());
  1105.             
  1106.             String s = DBOggettiInUsoUtils.toString(idSoggetto , whereIsInUso, false, "\n", normalizeObjectIds);
  1107.             if(s!=null && s.startsWith("\n") && s.length()>1) {
  1108.                 s = s.substring(1);
  1109.             }
  1110.             inUsoMessage.append(s);
  1111.             inUsoMessage.append("\n");
  1112.         } else {
  1113.             inUsoMessage.append(SoggettiCostanti.LABEL_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  1114.         }
  1115.         
  1116.         return inUsoMessage.toString();
  1117.     }
  1118.     public List<Proprieta> soggettiProprietaList(long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
  1119.         Connection con = null;
  1120.         String nomeMetodo = "soggettiProprietaList";
  1121.         DriverControlStationDB driver = null;

  1123.         try {
  1124.             // prendo una connessione
  1125.             con = ControlStationCore.dbM.getConnection();
  1126.             // istanzio il driver
  1127.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1129.             return driver.getDriverRegistroServiziDB().soggettiProprietaList(idSoggetto, ricerca);

  1131.         } catch (Exception e) {
  1132.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1133.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1134.         } finally {
  1135.             ControlStationCore.dbM.releaseConnection(con);
  1136.         }
  1137.     }
  1138.     
  1139.     public List<String> nomiProprietaSoggetti(List<String> tipoSoggettiProtocollo) throws DriverConfigurazioneException {
  1140.         Connection con = null;
  1141.         String nomeMetodo = "nomiProprietaSoggetti";
  1142.         DriverControlStationDB driver = null;

  1144.         try {
  1145.             // prendo una connessione
  1146.             con = ControlStationCore.dbM.getConnection();
  1147.             // istanzio il driver
  1148.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1150.             return driver.getDriverRegistroServiziDB().nomiProprietaSoggetti(tipoSoggettiProtocollo);

  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. }
Created with JaCoCo 0.8.8.202204050719