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



  23. package org.openspcoop2.pdd.core.autenticazione;

  25. import java.security.SecureRandom;
  26. import java.sql.Connection;
  27. import java.util.ArrayList;
  28. import java.util.Date;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.commons.dao.DAOFactory;
  35. import org.openspcoop2.core.commons.dao.DAOFactoryProperties;
  36. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  37. import org.openspcoop2.core.config.PortaDelegata;
  38. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  39. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  40. import org.openspcoop2.core.id.IDPortaApplicativa;
  41. import org.openspcoop2.core.id.IDPortaDelegata;
  42. import org.openspcoop2.core.id.IDServizioApplicativo;
  43. import org.openspcoop2.core.id.IDSoggetto;
  44. import org.openspcoop2.core.transazioni.CredenzialeMittente;
  45. import org.openspcoop2.core.transazioni.IdCredenzialeMittente;
  46. import org.openspcoop2.core.transazioni.dao.ICredenzialeMittenteService;
  47. import org.openspcoop2.core.transazioni.utils.CredenzialiMittente;
  48. import org.openspcoop2.core.transazioni.utils.TipoCredenzialeMittente;
  49. import org.openspcoop2.core.transazioni.utils.credenziali.AbstractCredenziale;
  50. import org.openspcoop2.core.transazioni.utils.credenziali.AbstractSearchCredenziale;
  51. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeApi;
  52. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeClientAddress;
  53. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeEventi;
  54. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeGruppi;
  55. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchApi;
  56. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchClientAddress;
  57. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchEvento;
  58. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchGruppo;
  59. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchToken;
  60. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchTokenClient;
  61. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeSearchTrasporto;
  62. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeToken;
  63. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeTokenClient;
  64. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeTokenPDND;
  65. import org.openspcoop2.core.transazioni.utils.credenziali.CredenzialeTrasporto;
  66. import org.openspcoop2.generic_project.expression.IPaginatedExpression;
  67. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  68. import org.openspcoop2.message.OpenSPCoop2Message;
  69. import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
  70. import org.openspcoop2.message.utils.WWWAuthenticateGenerator;
  71. import org.openspcoop2.pdd.config.DBTransazioniManager;
  72. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  73. import org.openspcoop2.pdd.config.Resource;
  74. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  75. import org.openspcoop2.pdd.core.AbstractCore;
  76. import org.openspcoop2.pdd.core.PdDContext;
  77. import org.openspcoop2.pdd.core.autenticazione.pa.DatiInvocazionePortaApplicativa;
  78. import org.openspcoop2.pdd.core.autenticazione.pa.EsitoAutenticazionePortaApplicativa;
  79. import org.openspcoop2.pdd.core.autenticazione.pa.IAutenticazionePortaApplicativa;
  80. import org.openspcoop2.pdd.core.autenticazione.pd.DatiInvocazionePortaDelegata;
  81. import org.openspcoop2.pdd.core.autenticazione.pd.EsitoAutenticazionePortaDelegata;
  82. import org.openspcoop2.pdd.core.autenticazione.pd.IAutenticazionePortaDelegata;
  83. import org.openspcoop2.pdd.core.connettori.InfoConnettoreIngresso;
  84. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  85. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  86. import org.openspcoop2.pdd.core.token.Costanti;
  87. import org.openspcoop2.pdd.core.token.InformazioniToken;
  88. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  89. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  90. import org.openspcoop2.protocol.sdk.Context;
  91. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  92. import org.openspcoop2.protocol.sdk.PDNDTokenInfo;
  93. import org.openspcoop2.protocol.sdk.SecurityToken;
  94. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  95. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  96. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  97. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  98. import org.openspcoop2.utils.SemaphoreLock;
  99. import org.openspcoop2.utils.Utilities;
  100. import org.openspcoop2.utils.UtilsException;
  101. import org.openspcoop2.utils.cache.Cache;
  102. import org.openspcoop2.utils.cache.CacheAlgorithm;
  103. import org.openspcoop2.utils.cache.CacheType;
  104. import org.openspcoop2.utils.cache.CacheResponse;
  105. import org.openspcoop2.utils.date.DateManager;
  106. import org.slf4j.Logger;

  108. /**
  109.  * Classe utilizzata per la gestione del processo di autenticazione Buste
  110.  *
  111.  * @author Poli Andrea (apoli@link.it)
  112.  * @author $Author$
  113.  * @version $Rev$, $Date$
  114.  */
  115. public class GestoreAutenticazione {

  117.     
  118.     /** Chiave della cache per l'autenticazione Buste  */
  119.     private static final String AUTENTICAZIONE_CACHE_NAME = "autenticazione";
  120.     /** Cache */
  121.     private static Cache cacheAutenticazione = null;
  122.     //private static final Boolean semaphoreAutenticazionePD = true;
  123.     //private static final Boolean semaphoreAutenticazionePA = true;
  124.     //private static final Boolean semaphoreCredenzialiMittente = true;
  125.     
  126.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAutenticazionePD = new HashMap<>(); 
  127.     private static synchronized org.openspcoop2.utils.Semaphore initLockAutenticazionePD(String tipoAutenticazione){
  128.         org.openspcoop2.utils.Semaphore s = _lockAutenticazionePD.get(tipoAutenticazione);
  129.         if(s==null) {
  130.             Integer permits = OpenSPCoop2Properties.getInstance().getAutenticazioneLockPermits(tipoAutenticazione);
  131.             if(permits==null) {
  132.                 permits = OpenSPCoop2Properties.getInstance().getAutenticazioneLockPermits();
  133.             }
  134.             if(permits!=null && permits.intValue()>1) {
  135.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutenticazioneFruizioni_"+tipoAutenticazione, permits);
  136.             }
  137.             else {
  138.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutenticazioneFruizioni_"+tipoAutenticazione);
  139.             }
  140.             _lockAutenticazionePD.put(tipoAutenticazione, s);
  141.         }
  142.         return s;
  143.     }
  144.     private static org.openspcoop2.utils.Semaphore getLockAutenticazionePD(String tipoAutenticazione){
  145.         org.openspcoop2.utils.Semaphore s = _lockAutenticazionePD.get(tipoAutenticazione);
  146.         if(s==null) {
  147.             s = initLockAutenticazionePD(tipoAutenticazione);
  148.         }
  149.         return s;
  150.     }
  151.     
  152.     
  153.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAutenticazionePA = new HashMap<>(); 
  154.     private static synchronized org.openspcoop2.utils.Semaphore initLockAutenticazionePA(String tipoAutenticazione){
  155.         org.openspcoop2.utils.Semaphore s = _lockAutenticazionePA.get(tipoAutenticazione);
  156.         if(s==null) {
  157.             Integer permits = OpenSPCoop2Properties.getInstance().getAutenticazioneLockPermits(tipoAutenticazione);
  158.             if(permits==null) {
  159.                 permits = OpenSPCoop2Properties.getInstance().getAutenticazioneLockPermits();
  160.             }
  161.             if(permits!=null && permits.intValue()>1) {
  162.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutenticazioneErogazioni_"+tipoAutenticazione, permits);
  163.             }
  164.             else {
  165.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutenticazioneErogazioni_"+tipoAutenticazione);
  166.             }
  167.             _lockAutenticazionePA.put(tipoAutenticazione, s);
  168.         }
  169.         return s;
  170.     }
  171.     private static org.openspcoop2.utils.Semaphore getLockAutenticazionePA(String tipoAutenticazione){
  172.         org.openspcoop2.utils.Semaphore s = _lockAutenticazionePA.get(tipoAutenticazione);
  173.         if(s==null) {
  174.             s = initLockAutenticazionePA(tipoAutenticazione);
  175.         }
  176.         return s;
  177.     }
  178.     
  179.     private static final org.openspcoop2.utils.Semaphore lockCredenzialiMittente = new org.openspcoop2.utils.Semaphore("GestoreCredenziali");
  180.     private static final org.openspcoop2.utils.Semaphore lockCredenzialiMittenteCreazione = new org.openspcoop2.utils.Semaphore("GestoreCredenziali-Creazione");
  181.     private static final org.openspcoop2.utils.Semaphore lockCredenzialiMittenteAggiornamento = new org.openspcoop2.utils.Semaphore("GestoreCredenziali-Aggiornamento");
  182.     /** Logger log */
  183.     private static Logger logger = null;
  184.     private static Logger logConsole = OpenSPCoop2Logger.getLoggerOpenSPCoopConsole();

  186.     
  187.     private static java.util.Random _rnd = null;
  188.     private static synchronized void initRandom() {
  189.         if(_rnd==null) {
  190.             _rnd = new SecureRandom();
  191.         }
  192.     }
  193.     public static java.util.Random getRandom() {
  194.         if(_rnd==null) {
  195.             initRandom();
  196.         }
  197.         return _rnd;
  198.     }
  199.     

  201.     /* --------------- Cache --------------------*/
  202.     public static void resetCache() throws AutenticazioneException{
  203.         if(GestoreAutenticazione.cacheAutenticazione!=null){
  204.             try{
  205.                 GestoreAutenticazione.cacheAutenticazione.clear();
  206.             }catch(Exception e){
  207.                 throw new AutenticazioneException(e.getMessage(),e);
  208.             }
  209.         }
  210.     }
  211.     public static String printStatsCache(String separator) throws AutenticazioneException{
  212.         try{
  213.             if(GestoreAutenticazione.cacheAutenticazione!=null){
  214.                 return GestoreAutenticazione.cacheAutenticazione.printStats(separator);
  215.             }
  216.             else{
  217.                 throw new Exception("Cache non abilitata");
  218.             }
  219.         }catch(Exception e){
  220.             throw new AutenticazioneException("Visualizzazione Statistiche riguardante la cache dell'autenticazione non riuscita: "+e.getMessage(),e);
  221.         }
  222.     }
  223.     public static void abilitaCache() throws AutenticazioneException{
  224.         if(GestoreAutenticazione.cacheAutenticazione!=null)
  225.             throw new AutenticazioneException("Cache gia' abilitata");
  226.         else{
  227.             _abilitaCache();
  228.         }
  229.     }
  230.     private static synchronized void _abilitaCache() throws AutenticazioneException{
  231.         if(GestoreAutenticazione.cacheAutenticazione==null) {
  232.             try{
  233.                 GestoreAutenticazione.cacheAutenticazione = new Cache(CacheType.JCS, GestoreAutenticazione.AUTENTICAZIONE_CACHE_NAME); // lascio JCS come default abilitato via jmx
  234.                 GestoreAutenticazione.cacheAutenticazione.build();
  235.             }catch(Exception e){
  236.                 throw new AutenticazioneException(e.getMessage(),e);
  237.             }
  238.         }
  239.     }
  240.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond) throws AutenticazioneException{
  241.         if(GestoreAutenticazione.cacheAutenticazione!=null)
  242.             throw new AutenticazioneException("Cache gia' abilitata");
  243.         else{
  244.             try{
  245.                 int dimensioneCacheInt = -1;
  246.                 if(dimensioneCache!=null){
  247.                     dimensioneCacheInt = dimensioneCache.intValue();
  248.                 }
  249.                 
  250.                 String algoritmoCache = null;
  251.                 if(algoritmoCacheLRU!=null){
  252.                     if(algoritmoCacheLRU)
  253.                          algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  254.                     else
  255.                          algoritmoCache = CostantiConfigurazione.CACHE_MRU.toString();
  256.                 }else{
  257.                     algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  258.                 }
  259.                 
  260.                 long itemIdleTimeLong = -1;
  261.                 if(itemIdleTime!=null){
  262.                     itemIdleTimeLong = itemIdleTime;
  263.                 }
  264.                 
  265.                 long itemLifeSecondLong = -1;
  266.                 if(itemLifeSecond!=null){
  267.                     itemLifeSecondLong = itemLifeSecond;
  268.                 }
  269.                 
  270.                 GestoreAutenticazione.initCacheAutenticazione(CacheType.JCS, dimensioneCacheInt, algoritmoCache, itemIdleTimeLong, itemLifeSecondLong, null); // lascio JCS come default abilitato via jmx
  271.             }catch(Exception e){
  272.                 throw new AutenticazioneException(e.getMessage(),e);
  273.             }
  274.         }
  275.     }
  276.     public static void disabilitaCache() throws AutenticazioneException{
  277.         if(GestoreAutenticazione.cacheAutenticazione==null)
  278.             throw new AutenticazioneException("Cache gia' disabilitata");
  279.         else{
  280.             _disabilitaCache();
  281.         }
  282.     }
  283.     private static synchronized void _disabilitaCache() throws AutenticazioneException{
  284.         if(GestoreAutenticazione.cacheAutenticazione!=null) {
  285.             try{
  286.                 GestoreAutenticazione.cacheAutenticazione.clear();
  287.                 GestoreAutenticazione.cacheAutenticazione = null;
  288.             }catch(Exception e){
  289.                 throw new AutenticazioneException(e.getMessage(),e);
  290.             }
  291.         }
  292.     }
  293.     public static boolean isCacheAbilitata(){
  294.         return GestoreAutenticazione.cacheAutenticazione != null;
  295.     }
  296.     public static String listKeysCache(String separator) throws AutenticazioneException{
  297.         if(GestoreAutenticazione.cacheAutenticazione!=null){
  298.             try{
  299.                 return GestoreAutenticazione.cacheAutenticazione.printKeys(separator);
  300.             }catch(Exception e){
  301.                 throw new AutenticazioneException(e.getMessage(),e);
  302.             }
  303.         }else{
  304.             throw new AutenticazioneException("Cache non abilitata");
  305.         }
  306.     }
  307.     public static List<String> listKeysCache() throws AutenticazioneException{
  308.         if(GestoreAutenticazione.cacheAutenticazione!=null){
  309.             try{
  310.                 return GestoreAutenticazione.cacheAutenticazione.keys();
  311.             }catch(Exception e){
  312.                 throw new AutenticazioneException(e.getMessage(),e);
  313.             }
  314.         }else{
  315.             throw new AutenticazioneException("Cache non abilitata");
  316.         }
  317.     }
  318.     public static String getObjectCache(String key) throws AutenticazioneException{
  319.         if(GestoreAutenticazione.cacheAutenticazione!=null){
  320.             try{
  321.                 Object o = GestoreAutenticazione.cacheAutenticazione.get(key);
  322.                 if(o!=null){
  323.                     return o.toString();
  324.                 }else{
  325.                     return "oggetto con chiave ["+key+"] non presente";
  326.                 }
  327.             }catch(Exception e){
  328.                 throw new AutenticazioneException(e.getMessage(),e);
  329.             }
  330.         }else{
  331.             throw new AutenticazioneException("Cache non abilitata");
  332.         }
  333.     }
  334.     public static Object getRawObjectCache(String key) throws AutenticazioneException{
  335.         if(GestoreAutenticazione.cacheAutenticazione!=null){
  336.             try{
  337.                 Object o = GestoreAutenticazione.cacheAutenticazione.get(key);
  338.                 if(o!=null){
  339.                     if(o instanceof CacheResponse) {
  340.                         CacheResponse cR = (CacheResponse) o;
  341.                         if(cR.getObject()!=null) {
  342.                             o = cR.getObject();
  343.                         }
  344.                         else if(cR.getException()!=null) {
  345.                             o = cR.getException();
  346.                         }
  347.                     }
  348.                     return o;
  349.                 }else{
  350.                     return null;
  351.                 }
  352.             }catch(Exception e){
  353.                 throw new AutenticazioneException(e.getMessage(),e);
  354.             }
  355.         }else{
  356.             throw new AutenticazioneException("Cache non abilitata");
  357.         }
  358.     }
  359.     public static void removeObjectCache(String key) throws AutenticazioneException{
  360.         if(GestoreAutenticazione.cacheAutenticazione!=null){
  361.             try{
  362.                 GestoreAutenticazione.cacheAutenticazione.remove(key);
  363.             }catch(Exception e){
  364.                 throw new AutenticazioneException(e.getMessage(),e);
  365.             }
  366.         }else{
  367.             throw new AutenticazioneException("Cache non abilitata");
  368.         }
  369.     }
  370.     


  373.     /*----------------- INIZIALIZZAZIONE --------------------*/
  374.     public static void initialize(Logger log) throws Exception{
  375.         GestoreAutenticazione.initialize(null, false, -1,null,-1l,-1l, log);
  376.     }
  377.     public static void initialize(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  378.             long idleTime, long itemLifeSecond, Logger log) throws Exception{
  379.         GestoreAutenticazione.initialize(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  380.     }

  382.     private static void initialize(CacheType cacheType, boolean cacheAbilitata,int dimensioneCache,String algoritmoCache,
  383.             long idleTime, long itemLifeSecond, Logger log) throws Exception{

  385.         // Inizializzo log
  386.         GestoreAutenticazione.logger = log;
  387.         
  388.         // Inizializzazione Cache
  389.         if(cacheAbilitata){
  390.             GestoreAutenticazione.initCacheAutenticazione(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  391.         }

  393.     }


  396.     public static void initCacheAutenticazione(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  397.             long idleTime, long itemLifeSecond, Logger log) throws Exception {
  398.         
  399.         if(log!=null)
  400.             log.info("Inizializzazione cache Autenticazione");

  402.         GestoreAutenticazione.cacheAutenticazione = new Cache(cacheType, GestoreAutenticazione.AUTENTICAZIONE_CACHE_NAME);

  404.         if( (dimensioneCache>0) ||
  405.                 (algoritmoCache != null) ){

  407.             if( dimensioneCache>0 ){
  408.                 try{
  409.                     String msg = "Dimensione della cache (Autenticazione) impostata al valore: "+dimensioneCache;
  410.                     if(log!=null)
  411.                         log.info(msg);
  412.                     GestoreAutenticazione.logConsole.info(msg);
  413.                     GestoreAutenticazione.cacheAutenticazione.setCacheSize(dimensioneCache);
  414.                 }catch(Exception error){
  415.                     throw new AutenticazioneException("Parametro errato per la dimensione della cache (Gestore Messaggi): "+error.getMessage(),error);
  416.                 }
  417.             }
  418.             if(algoritmoCache != null ){
  419.                 String msg = "Algoritmo di cache (Autenticazione) impostato al valore: "+algoritmoCache;
  420.                 if(log!=null)
  421.                     log.info(msg);
  422.                 GestoreAutenticazione.logConsole.info(msg);
  423.                 if(CostantiConfigurazione.CACHE_MRU.toString().equalsIgnoreCase(algoritmoCache))
  424.                     GestoreAutenticazione.cacheAutenticazione.setCacheAlgoritm(CacheAlgorithm.MRU);
  425.                 else
  426.                     GestoreAutenticazione.cacheAutenticazione.setCacheAlgoritm(CacheAlgorithm.LRU);
  427.             }

  429.         }

  431.         if( idleTime > 0  ){
  432.             try{
  433.                 String msg = "Attributo 'IdleTime' (Autenticazione) impostato al valore: "+idleTime;
  434.                 if(log!=null)
  435.                     log.info(msg);
  436.                 GestoreAutenticazione.logConsole.info(msg);
  437.                 GestoreAutenticazione.cacheAutenticazione.setItemIdleTime(idleTime);
  438.             }catch(Exception error){
  439.                 throw new AutenticazioneException("Parametro errato per l'attributo 'IdleTime' (Gestore Messaggi): "+error.getMessage(),error);
  440.             }
  441.         }

  443.         try{
  444.             String msg = "Attributo 'MaxLifeSecond' (Autenticazione) impostato al valore: "+itemLifeSecond;
  445.             if(log!=null)
  446.                 log.info(msg);
  447.             GestoreAutenticazione.logConsole.info(msg);
  448.             GestoreAutenticazione.cacheAutenticazione.setItemLifeTime(itemLifeSecond);
  449.         }catch(Exception error){
  450.             throw new AutenticazioneException("Parametro errato per l'attributo 'MaxLifeSecond' (Gestore Messaggi): "+error.getMessage(),error);
  451.         }

  453.         GestoreAutenticazione.cacheAutenticazione.build();
  454.     }
  455.     
  456.     @SuppressWarnings("deprecation")
  457.     @Deprecated
  458.     public static void disableSyncronizedGet() throws UtilsException {
  459.         if(GestoreAutenticazione.cacheAutenticazione==null) {
  460.             throw new UtilsException("Cache disabled");
  461.         }
  462.         GestoreAutenticazione.cacheAutenticazione.disableSyncronizedGet();
  463.     }
  464.     @SuppressWarnings("deprecation")
  465.     @Deprecated
  466.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  467.         if(GestoreAutenticazione.cacheAutenticazione==null) {
  468.             throw new UtilsException("Cache disabled");
  469.         }
  470.         return GestoreAutenticazione.cacheAutenticazione.isDisableSyncronizedGet();
  471.     }
  472.     

  474.     
  475.     
  476.     
  477.     /*----------------- CLEANER --------------------*/
  478.     
  479.     public static void removePortaApplicativa(IDPortaApplicativa idPA) throws Exception {
  480.         if(GestoreAutenticazione.isCacheAbilitata()) {
  481.             List<String> keyForClean = new ArrayList<>();
  482.             List<String> keys = GestoreAutenticazione.listKeysCache();
  483.             if(keys!=null && !keys.isEmpty()) {
  484.                 String match = IDPortaApplicativa.PORTA_APPLICATIVA_PREFIX+idPA.getNome()+IDPortaApplicativa.PORTA_APPLICATIVA_SUFFIX;
  485.                 for (String key : keys) {
  486.                     if(key!=null && key.contains(match)) {
  487.                         keyForClean.add(key);
  488.                     }
  489.                 }
  490.             }
  491.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  492.                 for (String key : keyForClean) {
  493.                     removeObjectCache(key);
  494.                 }
  495.             }
  496.         }
  497.     }
  498.     
  499.     public static void removePortaDelegata(IDPortaDelegata idPD) throws Exception {
  500.         if(GestoreAutenticazione.isCacheAbilitata()) {
  501.             List<String> keyForClean = new ArrayList<>();
  502.             List<String> keys = GestoreAutenticazione.listKeysCache();
  503.             if(keys!=null && !keys.isEmpty()) {
  504.                 String match = IDPortaDelegata.PORTA_DELEGATA_PREFIX+idPD.getNome()+IDPortaDelegata.PORTA_DELEGATA_SUFFIX;
  505.                 for (String key : keys) {
  506.                     if(key!=null && key.contains(match)) {
  507.                         keyForClean.add(key);
  508.                     }
  509.                 }
  510.             }
  511.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  512.                 for (String key : keyForClean) {
  513.                     removeObjectCache(key);
  514.                 }
  515.             }
  516.         }
  517.     }
  518.     
  519.     public static void removeSoggetto(IDSoggetto idSoggetto) throws Exception {
  520.         if(GestoreAutenticazione.isCacheAbilitata()) {
  521.             List<String> keyForClean = new ArrayList<>();
  522.             List<String> keys = GestoreAutenticazione.listKeysCache();
  523.             if(keys!=null && !keys.isEmpty()) {
  524.                 for (String key : keys) {
  525.                     if(key!=null) {
  526.                         Object o = GestoreAutenticazione.getRawObjectCache(key);
  527.                         if(o!=null) {
  528.                             if(o instanceof EsitoAutenticazionePortaApplicativa) {
  529.                                 EsitoAutenticazionePortaApplicativa esito = (EsitoAutenticazionePortaApplicativa) o;
  530.                                 if(esito.getIdSoggetto()!=null && esito.getIdSoggetto().equals(idSoggetto)) {
  531.                                     keyForClean.add(key);
  532.                                 }
  533.                             }
  534.                         }
  535.                     }
  536.                 }
  537.             }
  538.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  539.                 for (String key : keyForClean) {
  540.                     removeObjectCache(key);
  541.                 }
  542.             }
  543.         }
  544.     }
  545.     
  546.     public static void removeApplicativo(IDServizioApplicativo idApplicativo) throws Exception {
  547.         if(GestoreAutenticazione.isCacheAbilitata()) {
  548.             List<String> keyForClean = new ArrayList<>();
  549.             List<String> keys = GestoreAutenticazione.listKeysCache();
  550.             if(keys!=null && !keys.isEmpty()) {
  551.                 for (String key : keys) {
  552.                     if(key!=null) {
  553.                         Object o = GestoreAutenticazione.getRawObjectCache(key);
  554.                         if(o!=null) {
  555.                             if(o instanceof EsitoAutenticazionePortaDelegata) {
  556.                                 EsitoAutenticazionePortaDelegata esito = (EsitoAutenticazionePortaDelegata) o;
  557.                                 if(esito.getIdServizioApplicativo()!=null && esito.getIdServizioApplicativo().equals(idApplicativo)) {
  558.                                     keyForClean.add(key);
  559.                                 }
  560.                             }
  561.                             else if(o instanceof EsitoAutenticazionePortaApplicativa) {
  562.                                 EsitoAutenticazionePortaApplicativa esito = (EsitoAutenticazionePortaApplicativa) o;
  563.                                 if(esito.getIdServizioApplicativo()!=null && esito.getIdServizioApplicativo().equals(idApplicativo)) {
  564.                                     keyForClean.add(key);
  565.                                 }
  566.                             }
  567.                         }
  568.                     }
  569.                 }
  570.             }
  571.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  572.                 for (String key : keyForClean) {
  573.                     removeObjectCache(key);
  574.                 }
  575.             }
  576.         }
  577.     }
  578.     
  579.     
  580.     
  581.     
  582.     
  583.     /*----------------- AUTENTICAZIONE --------------------*/
  584.     
  585.     public static EsitoAutenticazionePortaDelegata verificaAutenticazionePortaDelegata(String tipoAutenticazione, 
  586.             DatiInvocazionePortaDelegata datiInvocazione, ParametriAutenticazione parametriAutenticazione,
  587.           PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  588.         return _verificaAutenticazionePortaDelegata(false, tipoAutenticazione, 
  589.                 datiInvocazione, parametriAutenticazione, 
  590.                 pddContext, protocolFactory, msg);
  591.     }
  592.     public static EsitoAutenticazionePortaDelegata verificaAutenticazioneMessageBox(String tipoAutenticazione, 
  593.             DatiInvocazionePortaDelegata datiInvocazione, ParametriAutenticazione parametriAutenticazione,
  594.           PdDContext pddContext,IProtocolFactory<?> protocolFactory) throws Exception{
  595.         return _verificaAutenticazionePortaDelegata(true, tipoAutenticazione, 
  596.                 datiInvocazione, parametriAutenticazione, 
  597.                 pddContext, protocolFactory, null);
  598.     }
  599.     
  600.     private static EsitoAutenticazionePortaDelegata _verificaAutenticazionePortaDelegata(boolean messageBox, String tipoAutenticazione, 
  601.             DatiInvocazionePortaDelegata datiInvocazione, ParametriAutenticazione parametriAutenticazione,
  602.           PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  603.         
  604.         checkDatiPortaDelegata(messageBox,datiInvocazione);
  605.         
  606.         IAutenticazionePortaDelegata auth = newInstanceAuthPortaDelegata(tipoAutenticazione, pddContext, protocolFactory);
  607.         auth.initParametri(parametriAutenticazione);
  608.         if(messageBox) {
  609.             auth.setLogError(false);
  610.         }
  611.         
  612.         try {
  613.             if(GestoreAutenticazione.cacheAutenticazione==null || !auth.saveAuthenticationResultInCache()){
  614.                 return auth.process(datiInvocazione);
  615.             }
  616.             else{
  617.                 String keyCache = buildCacheKey(messageBox, true, tipoAutenticazione, datiInvocazione.getKeyCache(), auth.getSuffixKeyAuthenticationResultInCache(datiInvocazione));
  618.     
  619.                 // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  620.                 org.openspcoop2.utils.cache.CacheResponse response = 
  621.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutenticazione.cacheAutenticazione.get(keyCache);
  622.                 if(response != null){
  623.                     if(response.getObject()!=null){
  624.                         GestoreAutenticazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaDelegata) in cache.");
  625.                         EsitoAutenticazionePortaDelegata esito = (EsitoAutenticazionePortaDelegata) response.getObject();
  626.                         esito.setEsitoPresenteInCache(true);
  627.                         return esito;
  628.                     }else if(response.getException()!=null){
  629.                         GestoreAutenticazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaDelegata) in cache.");
  630.                         throw (Exception) response.getException();
  631.                     }else{
  632.                         GestoreAutenticazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  633.                     }
  634.                 }
  635.                 
  636.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  637.                 //synchronized (GestoreAutenticazione.semaphoreAutenticazionePD) {
  638.                 org.openspcoop2.utils.Semaphore lockAutenticazionePD = getLockAutenticazionePD(tipoAutenticazione);
  639.                 SemaphoreLock lock = lockAutenticazionePD.acquire("verificaAutenticazionePortaDelegata", idTransazione);
  640.                 try {
  641.                     
  642.                     response = 
  643.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutenticazione.cacheAutenticazione.get(keyCache);
  644.                     if(response != null){
  645.                         if(response.getObject()!=null){
  646.                             GestoreAutenticazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaDelegata) in cache.");
  647.                             EsitoAutenticazionePortaDelegata esito = (EsitoAutenticazionePortaDelegata) response.getObject();
  648.                             esito.setEsitoPresenteInCache(true);
  649.                             return esito;
  650.                         }else if(response.getException()!=null){
  651.                             GestoreAutenticazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaDelegata) in cache.");
  652.                             throw (Exception) response.getException();
  653.                         }else{
  654.                             GestoreAutenticazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  655.                         }
  656.                     }
  657.     
  658.                     // Effettuo la query
  659.                     GestoreAutenticazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:verificaAutenticazionePortaDelegata) ricerco nella configurazione...");
  660.                     EsitoAutenticazionePortaDelegata esito = auth.process(datiInvocazione);
  661.     
  662.                     // Aggiungo la risposta in cache (se esiste una cache)  
  663.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  664.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  665.                     // - impostare il noCache a true
  666.                     if(esito!=null){
  667.                         if(!esito.isNoCache()){
  668.                             GestoreAutenticazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  669.                             try{    
  670.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  671.                                 responseCache.setObject(esito);
  672.                                 GestoreAutenticazione.cacheAutenticazione.put(keyCache,responseCache);
  673.                             }catch(UtilsException e){
  674.                                 GestoreAutenticazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  675.                             }
  676.                         }
  677.                         return esito;
  678.                     }else{
  679.                         throw new AutenticazioneException("Metodo (GestoreAutenticazione.autenticazionePortaDelegata.process) ha ritornato un valore di esito null");
  680.                     }
  681.                 }finally{
  682.                     lockAutenticazionePD.release(lock, "verificaAutenticazionePortaDelegata", idTransazione);
  683.                 }
  684.             }
  685.         }finally {
  686.             if(msg!=null) {
  687.                 auth.cleanPostAuth(msg);
  688.             }
  689.         }
  690.     }
  691.     
  692.     public static EsitoAutenticazionePortaApplicativa verificaAutenticazionePortaApplicativa(String tipoAutenticazione, 
  693.             DatiInvocazionePortaApplicativa datiInvocazione, ParametriAutenticazione parametriAutenticazione,
  694.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  695.           
  696.         checkDatiPortaApplicativa(datiInvocazione);
  697.         
  698.         IAutenticazionePortaApplicativa auth = newInstanceAuthPortaApplicativa(tipoAutenticazione, pddContext, protocolFactory);
  699.         auth.initParametri(parametriAutenticazione);
  700.         
  701.         try {
  702.             if(GestoreAutenticazione.cacheAutenticazione==null || !auth.saveAuthenticationResultInCache()){
  703.                 return auth.process(datiInvocazione);
  704.             }
  705.             else{
  706.                 String keyCache = buildCacheKey(false, false, tipoAutenticazione, datiInvocazione.getKeyCache(), auth.getSuffixKeyAuthenticationResultInCache(datiInvocazione));
  707.     
  708.                 // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  709.                 org.openspcoop2.utils.cache.CacheResponse response = 
  710.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutenticazione.cacheAutenticazione.get(keyCache);
  711.                 if(response != null){
  712.                     if(response.getObject()!=null){
  713.                         GestoreAutenticazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaApplicativa) in cache.");
  714.                         EsitoAutenticazionePortaApplicativa esito = (EsitoAutenticazionePortaApplicativa) response.getObject();
  715.                         esito.setEsitoPresenteInCache(true);
  716.                         return esito;
  717.                     }else if(response.getException()!=null){
  718.                         GestoreAutenticazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaApplicativa) in cache.");
  719.                         throw (Exception) response.getException();
  720.                     }else{
  721.                         GestoreAutenticazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  722.                     }
  723.                 }
  724.                 
  725.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  726.                 //synchronized (GestoreAutenticazione.semaphoreAutenticazionePA) {
  727.                 org.openspcoop2.utils.Semaphore lockAutenticazionePA = getLockAutenticazionePA(tipoAutenticazione);
  728.                 SemaphoreLock lock = lockAutenticazionePA.acquire("verificaAutenticazionePortaApplicativa", idTransazione);
  729.                 try {
  730.                     
  731.                     response = 
  732.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutenticazione.cacheAutenticazione.get(keyCache);
  733.                     if(response != null){
  734.                         if(response.getObject()!=null){
  735.                             GestoreAutenticazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaApplicativa) in cache.");
  736.                             EsitoAutenticazionePortaApplicativa esito = (EsitoAutenticazionePortaApplicativa) response.getObject();
  737.                             esito.setEsitoPresenteInCache(true);
  738.                             return esito;
  739.                         }else if(response.getException()!=null){
  740.                             GestoreAutenticazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutenticazionePortaApplicativa) in cache.");
  741.                             throw (Exception) response.getException();
  742.                         }else{
  743.                             GestoreAutenticazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  744.                         }
  745.                     }
  746.     
  747.                     // Effettuo la query
  748.                     GestoreAutenticazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:verificaAutenticazionePortaApplicativa) ricerco nella configurazione...");
  749.                     EsitoAutenticazionePortaApplicativa esito = auth.process(datiInvocazione);
  750.     
  751.                     // Aggiungo la risposta in cache (se esiste una cache)  
  752.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  753.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  754.                     // - impostare il noCache a true
  755.                     if(esito!=null){
  756.                         if(!esito.isNoCache()){
  757.                             GestoreAutenticazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  758.                             try{    
  759.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  760.                                 responseCache.setObject(esito);
  761.                                 GestoreAutenticazione.cacheAutenticazione.put(keyCache,responseCache);
  762.                             }catch(UtilsException e){
  763.                                 GestoreAutenticazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  764.                             }
  765.                         }
  766.                         return esito;
  767.                     }else{
  768.                         throw new AutenticazioneException("Metodo (GestoreAutenticazione.autenticazionePortaApplicativa.process) ha ritornato un valore di esito null");
  769.                     }
  770.                 }finally {
  771.                     lockAutenticazionePA.release(lock, "verificaAutenticazionePortaApplicativa", idTransazione);
  772.                 }
  773.             }
  774.         }finally {
  775.             if(msg!=null) {
  776.                 auth.cleanPostAuth(msg);
  777.             }
  778.         }
  779.     }
  780.         
  781.     private static void checkDatiPortaDelegata(boolean messageBox, DatiInvocazionePortaDelegata datiInvocazione) throws AutenticazioneException{
  782.         
  783.         InfoConnettoreIngresso infoConnettoreIngresso = datiInvocazione.getInfoConnettoreIngresso();
  784.         if(infoConnettoreIngresso==null)
  785.             throw new AutenticazioneException("(Parametri) InfoConnettoreIngresso non definito");
  786.         if(infoConnettoreIngresso.getCredenziali()==null)
  787.             throw new AutenticazioneException("(Parametri) InfoConnettoreIngresso.credenziali non definito");
  788.         
  789.         if(messageBox==false){
  790.             IDPortaDelegata idPD = datiInvocazione.getIdPD();
  791.             if(idPD==null)
  792.                 throw new AutenticazioneException("(Parametri) IDPortaDelegata non definito");
  793.             if(idPD.getNome()==null)
  794.                 throw new AutenticazioneException("(Parametri) IDPortaDelegata.nome non definito");
  795.             
  796.             PortaDelegata pd = datiInvocazione.getPd();
  797.             if(pd==null)
  798.                 throw new AutenticazioneException("(Parametri) PortaDelegata non definito");
  799.         }
  800.         
  801.     }
  802.     
  803.     private static void checkDatiPortaApplicativa(DatiInvocazionePortaApplicativa datiInvocazione) throws AutenticazioneException{
  804.         
  805.         InfoConnettoreIngresso infoConnettoreIngresso = datiInvocazione.getInfoConnettoreIngresso();
  806.         if(infoConnettoreIngresso==null)
  807.             throw new AutenticazioneException("(Parametri) InfoConnettoreIngresso non definito");
  808.         if(infoConnettoreIngresso.getCredenziali()==null)
  809.             throw new AutenticazioneException("(Parametri) InfoConnettoreIngresso.credenziali non definito");

  811.         // Dipende dal ruolo della Busta, se c'e' la porta applicativa o delegata
  812. //      IDPortaApplicativaByNome idPA = datiInvocazione.getIdPA();
  813. //      if(idPA==null)
  814. //          throw new AutenticazioneException("(Parametri) IDPortaApplicativaByNome non definito");
  815. //      if(idPA.getNome()==null)
  816. //          throw new AutenticazioneException("(Parametri) IDPortaApplicativaByNome.nome non definito");
  817. //      IDSoggetto idSoggettoProprietarioPA = idPA.getSoggetto();
  818. //      if(idSoggettoProprietarioPA==null || idSoggettoProprietarioPA.getTipo()==null || idSoggettoProprietarioPA.getNome()==null)
  819. //          throw new AutenticazioneException("(Parametri) IDPortaApplicativaByNome.Soggetto non definito");
  820. //      
  821. //      PortaApplicativa pa = datiInvocazione.getPa();
  822. //      if(pa==null)
  823. //          throw new AutenticazioneException("(Parametri) PortaApplicativa non definito");
  824.         
  825.     }
  826.     
  827.     private static String buildCacheKey(boolean messageBox, boolean portaDelegata, String tipoAutenticazione, String keyCache, String suffixKeyCache) throws AutenticazioneException{
  828.         StringBuilder bf = new StringBuilder();
  829.         
  830.         if(portaDelegata){
  831.             if(messageBox){
  832.                 bf.append("MessageBox ");
  833.             }
  834.             else{
  835.                 bf.append("PD ");
  836.             }
  837.         }else{
  838.             bf.append("PA ");
  839.         }
  840.         
  841.         bf.append(" Auth:").append(tipoAutenticazione).append(" ");
  842.         
  843.         bf.append(keyCache);
  844.         
  845.         if(suffixKeyCache!=null && !"".equals(suffixKeyCache)){
  846.             bf.append(" ");
  847.             bf.append(suffixKeyCache);
  848.         }
  849.         
  850.         return bf.toString();
  851.     }
  852.     
  853.     private static IAutenticazionePortaDelegata newInstanceAuthPortaDelegata(String tipoAutenticazione,PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws AutenticazioneException{
  854.         IAutenticazionePortaDelegata auth = null;
  855.         try{
  856.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  857.             auth = (IAutenticazionePortaDelegata) pluginLoader.newAutenticazionePortaDelegata(tipoAutenticazione);
  858.         }catch(Exception e){
  859.             throw new AutenticazioneException(e.getMessage(),e); // descrizione errore già corretta
  860.         }
  861.         String classType = null; 
  862.         try{
  863.             classType = auth.getClass().getName();
  864.             AbstractCore.init(auth, pddContext, protocolFactory);
  865.             return auth;
  866.         }catch(Exception e){
  867.             throw new AutenticazioneException("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  868.                     "] che definisce l'autenticazione della fruizione: "+e.getMessage(),e);
  869.         }
  870.     }
  871.     
  872.     private static IAutenticazionePortaApplicativa newInstanceAuthPortaApplicativa(String tipoAutenticazione,PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws AutenticazioneException{
  873.         IAutenticazionePortaApplicativa auth = null;
  874.         try{
  875.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  876.             auth = (IAutenticazionePortaApplicativa) pluginLoader.newAutenticazionePortaApplicativa(tipoAutenticazione);
  877.         }catch(Exception e){
  878.             throw new AutenticazioneException(e.getMessage(),e); // descrizione errore già corretta
  879.         }
  880.         String classType = null; 
  881.         try{
  882.             classType = auth.getClass().getName();
  883.             AbstractCore.init(auth, pddContext, protocolFactory);
  884.             return auth;
  885.         }catch(Exception e){
  886.             throw new AutenticazioneException("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  887.                     "] che definisce l'autenticazione della erogazione: "+e.getMessage(),e);
  888.         }
  889.     }
  890.     
  891.     public static boolean isAutenticazioneTokenEnabled(GestioneTokenAutenticazione gestioneTokenAutenticazione) {
  892.         return
  893.                 StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getIssuer()) ||
  894.                 StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getClientId()) ||
  895.                 StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getSubject()) ||
  896.                 StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getUsername()) ||
  897.                 StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getEmail());
  898.     }
  899.     
  900.     public static String getLabel(GestioneTokenAutenticazione gestioneTokenAutenticazione) {
  901.         return _getActions(gestioneTokenAutenticazione);
  902.     }
  903.     public static String getActions(GestioneTokenAutenticazione gestioneTokenAutenticazione) {
  904.         return _getActions(gestioneTokenAutenticazione);
  905.     }
  906.     private static String _getActions(GestioneTokenAutenticazione gestioneTokenAutenticazione) {
  907.         StringBuilder bf = new StringBuilder();
  908.         if(StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getIssuer())) {
  909.             if(bf.length()>0) {
  910.                 bf.append(",");
  911.             }
  912.             bf.append(Costanti.GESTIONE_TOKEN_AUTENTICAZIONE_ISSUER);
  913.         }
  914.         if(StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getClientId())) {
  915.             if(bf.length()>0) {
  916.                 bf.append(",");
  917.             }
  918.             bf.append(Costanti.GESTIONE_TOKEN_AUTENTICAZIONE_CLIENT_ID);
  919.         }
  920.         if(StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getSubject())) {
  921.             if(bf.length()>0) {
  922.                 bf.append(",");
  923.             }
  924.             bf.append(Costanti.GESTIONE_TOKEN_AUTENTICAZIONE_SUBJECT);
  925.         }
  926.         if(StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getUsername())) {
  927.             if(bf.length()>0) {
  928.                 bf.append(",");
  929.             }
  930.             bf.append(Costanti.GESTIONE_TOKEN_AUTENTICAZIONE_USERNAME);
  931.         }
  932.         if(StatoFunzionalita.ABILITATO.equals(gestioneTokenAutenticazione.getEmail())) {
  933.             if(bf.length()>0) {
  934.                 bf.append(",");
  935.             }
  936.             bf.append(Costanti.GESTIONE_TOKEN_AUTENTICAZIONE_EMAIL);
  937.         }
  938.         return bf.toString();
  939.     }
  940.     
  941.     public static EsitoAutenticazionePortaDelegata verificaAutenticazioneTokenPortaDelegata(GestioneTokenAutenticazione tipoAutenticazione, DatiInvocazionePortaDelegata datiInvocazione,
  942.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  943.         
  944.         EsitoAutenticazionePortaDelegata esito = new EsitoAutenticazionePortaDelegata();
  945.         esito.setClientAuthenticated(true);
  946.         
  947.         esito = (EsitoAutenticazionePortaDelegata) autenticazioneToken(tipoAutenticazione, esito, pddContext, datiInvocazione);
  948.         if(esito.isClientAuthenticated()==false) {
  949.             esito.setErroreIntegrazione(IntegrationFunctionError.TOKEN_REQUIRED_CLAIMS_NOT_FOUND, ErroriIntegrazione.ERRORE_445_TOKEN_AUTORIZZAZIONE_FALLITA.getErroreIntegrazione());
  950.         }
  951.         return esito;
  952.     }
  953.     
  954.     public static EsitoAutenticazionePortaApplicativa verificaAutenticazioneTokenPortaApplicativa(GestioneTokenAutenticazione tipoAutenticazione, DatiInvocazionePortaApplicativa datiInvocazione,
  955.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  956.         
  957.         EsitoAutenticazionePortaApplicativa esito = new EsitoAutenticazionePortaApplicativa();
  958.         esito.setClientAuthenticated(true);
  959.         
  960.         esito = (EsitoAutenticazionePortaApplicativa) autenticazioneToken(tipoAutenticazione, esito, pddContext, datiInvocazione);
  961.         if(esito.isClientAuthenticated()==false) {
  962.             esito.setErroreCooperazione(IntegrationFunctionError.TOKEN_REQUIRED_CLAIMS_NOT_FOUND, ErroriCooperazione.TOKEN_AUTORIZZAZIONE_FALLITA.getErroreCooperazione());
  963.         }
  964.         return esito;
  965.         
  966.     }
  967.     
  968.     private static EsitoAutenticazione autenticazioneToken(GestioneTokenAutenticazione tipoAutenticazione, EsitoAutenticazione esito, 
  969.             PdDContext pddContext, AbstractDatiInvocazione datiInvocazione) throws Exception {
  970.         
  971.         boolean autenticato = true;
  972.         String errorMessage = null;
  973.         if(tipoAutenticazione!=null) {
  974.             
  975.             boolean issuer = StatoFunzionalita.ABILITATO.equals(tipoAutenticazione.getIssuer());
  976.             boolean clientId = StatoFunzionalita.ABILITATO.equals(tipoAutenticazione.getClientId());
  977.             boolean subject = StatoFunzionalita.ABILITATO.equals(tipoAutenticazione.getSubject());
  978.             boolean username = StatoFunzionalita.ABILITATO.equals(tipoAutenticazione.getUsername());
  979.             boolean email = StatoFunzionalita.ABILITATO.equals(tipoAutenticazione.getEmail());
  980.             
  981.             if(issuer || clientId || subject || username ||email ) {
  982.                     
  983.                 InformazioniToken informazioniTokenNormalizzate = null;
  984.                 Object oInformazioniTokenNormalizzate = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  985.                 if(oInformazioniTokenNormalizzate!=null) {
  986.                     informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  987.                 }
  988.             
  989.                 if(issuer) {
  990.                     if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getIss()==null || "".equals(informazioniTokenNormalizzate.getIss())) {
  991.                         autenticato = false;
  992.                         errorMessage = "Token without issuer claim";
  993.                     }
  994.                 }
  995.                 
  996.                 if(clientId) {
  997.                     if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getClientId()==null || "".equals(informazioniTokenNormalizzate.getClientId())) {
  998.                         autenticato = false;
  999.                         errorMessage = "Token without clientId claim";
  1000.                     }
  1001.                 }
  1002.                 
  1003.                 if(subject) {
  1004.                     if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getSub()==null || "".equals(informazioniTokenNormalizzate.getSub())) {
  1005.                         autenticato = false;
  1006.                         errorMessage = "Token without subject claim";
  1007.                     }
  1008.                 }
  1009.                 
  1010.                 if(username) {
  1011.                     if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getUsername()==null || "".equals(informazioniTokenNormalizzate.getUsername())) {
  1012.                         autenticato = false;
  1013.                         errorMessage = "Token without username claim";
  1014.                     }
  1015.                 }
  1016.                 
  1017.                 if(email) {
  1018.                     if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getUserInfo()==null || 
  1019.                             informazioniTokenNormalizzate.getUserInfo().getEMail()==null || 
  1020.                             "".equals(informazioniTokenNormalizzate.getUserInfo().getEMail())) {
  1021.                         autenticato = false;
  1022.                         errorMessage = "Token without email claim";
  1023.                     }
  1024.                 }
  1025.             }
  1026.             
  1027.         }
  1028.         
  1029.         if(!autenticato) {
  1030.             
  1031.             esito.setDetails(errorMessage);
  1032.             
  1033.             String realm = "OpenSPCoop";
  1034.             Object oRealm = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_REALM);
  1035.             if(oRealm!=null) {
  1036.                 realm = (String) oRealm;
  1037.             }
  1038.             
  1039.             boolean emptyMessage = false;
  1040.             Object oEmptyMessage = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_MESSAGE_ERROR_BODY_EMPTY);
  1041.             if(oEmptyMessage!=null) {
  1042.                 emptyMessage = (Boolean) oEmptyMessage;
  1043.             }
  1044.             
  1045.             boolean genericMessage = false;
  1046.             Object oGenericMessage = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_MESSAGE_ERROR_GENERIC_MESSAGE);
  1047.             if(oGenericMessage!=null) {
  1048.                 genericMessage = (Boolean) oGenericMessage;
  1049.             }
  1050.             
  1051.             esito.setClientAuthenticated(false);
  1052.             if(emptyMessage) {
  1053.                 esito.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.insufficient_scope, realm, genericMessage, errorMessage));
  1054.             }
  1055.             else {
  1056.                 esito.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.insufficient_scope, realm, genericMessage, errorMessage));
  1057.             }
  1058.         }
  1059.         
  1060.         
  1061.         return esito;
  1062.     }
  1063.     
  1064.     
  1065.     public static void updateCredenzialiTrasporto(IDSoggetto dominio, String modulo, String idTransazione, 
  1066.             String tipoAutenticazione, String credential, CredenzialiMittente credenzialiMittente,
  1067.             IOpenSPCoopState openspcoopState, String identitaChiamante, RequestInfo requestInfo) throws Exception{
  1068.         
  1069.         CredenzialeSearchTrasporto trasportoSearch = new CredenzialeSearchTrasporto(tipoAutenticazione);
  1070.         trasportoSearch.disableConvertToDBValue();
  1071.         CredenzialeTrasporto trasporto = new CredenzialeTrasporto(tipoAutenticazione, credential);
  1072.         credenzialiMittente.setTrasporto(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1073.                 trasportoSearch, trasporto, openspcoopState, identitaChiamante,
  1074.                 null, requestInfo));
  1075.         
  1076.     }
  1077.     
  1078.     public static void updateCredenzialiToken(IDSoggetto dominio, String modulo, String idTransazione, 
  1079.             InformazioniToken informazioniTokenNormalizzate, IDServizioApplicativo idApplicativoToken, CredenzialiMittente credenzialiMittente, 
  1080.             IOpenSPCoopState openspcoopState, String identitaChiamante, RequestInfo requestInfo,
  1081.             Context context) throws Exception{
  1082.         
  1083.         if(informazioniTokenNormalizzate.getIss()!=null) {
  1084.             CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.TOKEN_ISSUER);
  1085.             tokenSearch.disableConvertToDBValue();
  1086.             CredenzialeToken token = new CredenzialeToken(TipoCredenzialeMittente.TOKEN_ISSUER, informazioniTokenNormalizzate.getIss());
  1087.             credenzialiMittente.setTokenIssuer(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1088.                     tokenSearch, token, openspcoopState, identitaChiamante,
  1089.                     null, requestInfo));
  1090.         }
  1091.         if(informazioniTokenNormalizzate.getClientId()!=null) {
  1092.             if(idApplicativoToken==null) {
  1093.                 CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.TOKEN_CLIENT_ID);
  1094.                 tokenSearch.disableConvertToDBValue();
  1095.                 CredenzialeToken token = new CredenzialeToken(TipoCredenzialeMittente.TOKEN_CLIENT_ID, informazioniTokenNormalizzate.getClientId());
  1096.                 credenzialiMittente.setTokenClientId(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1097.                         tokenSearch, token, openspcoopState, identitaChiamante,
  1098.                         null, requestInfo));
  1099.             }
  1100.             else {
  1101.                 CredenzialeSearchTokenClient tokenSearch = new CredenzialeSearchTokenClient(true, true, true);
  1102.                 tokenSearch.disableConvertToDBValue();
  1103.                 CredenzialeTokenClient token = new CredenzialeTokenClient(informazioniTokenNormalizzate.getClientId(), idApplicativoToken);
  1104.                 credenzialiMittente.setTokenClientId(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1105.                         tokenSearch, token, openspcoopState, identitaChiamante,
  1106.                         null, requestInfo));
  1107.             }
  1108.         }

  1110.         if(informazioniTokenNormalizzate.getSub()!=null) {
  1111.             CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.TOKEN_SUBJECT);
  1112.             tokenSearch.disableConvertToDBValue();
  1113.             CredenzialeToken token = new CredenzialeToken(TipoCredenzialeMittente.TOKEN_SUBJECT, informazioniTokenNormalizzate.getSub());
  1114.             credenzialiMittente.setTokenSubject(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1115.                     tokenSearch, token, openspcoopState, identitaChiamante,
  1116.                     null, requestInfo));
  1117.         }
  1118.         if(informazioniTokenNormalizzate.getUsername()!=null) {
  1119.             CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.TOKEN_USERNAME);
  1120.             tokenSearch.disableConvertToDBValue();
  1121.             CredenzialeToken token = new CredenzialeToken(TipoCredenzialeMittente.TOKEN_USERNAME, informazioniTokenNormalizzate.getUsername());
  1122.             credenzialiMittente.setTokenUsername(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1123.                     tokenSearch, token, openspcoopState, identitaChiamante,
  1124.                     null, requestInfo));
  1125.         }
  1126.         if(informazioniTokenNormalizzate.getUserInfo()!=null && informazioniTokenNormalizzate.getUserInfo().getEMail()!=null) {
  1127.             CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.TOKEN_EMAIL);
  1128.             tokenSearch.disableConvertToDBValue();
  1129.             CredenzialeToken token = new CredenzialeToken(TipoCredenzialeMittente.TOKEN_EMAIL, informazioniTokenNormalizzate.getUserInfo().getEMail());
  1130.             credenzialiMittente.setTokenEMail(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1131.                     tokenSearch, token, openspcoopState, identitaChiamante,
  1132.                     null, requestInfo));
  1133.         }
  1134.         
  1135.         updateCredenzialiTokenPDND(dominio, modulo, idTransazione, 
  1136.                 informazioniTokenNormalizzate, credenzialiMittente, 
  1137.                 openspcoopState, identitaChiamante, requestInfo,
  1138.                 context);
  1139.         
  1140.     }
  1141.     
  1142.     public static void updateCredenzialiTokenPDND(IDSoggetto dominio, String modulo, String idTransazione, 
  1143.             InformazioniToken informazioniTokenNormalizzate, CredenzialiMittente credenzialiMittente, 
  1144.             IOpenSPCoopState openspcoopState, String identitaChiamante, RequestInfo requestInfo,
  1145.             Context context) throws Exception{
  1146.                 
  1147.         SecurityToken securityTokenForContext = SecurityTokenUtilities.readSecurityToken(context);
  1148.         
  1149.         Long refClientIdCredenzialieMittente = null;
  1150.         if(credenzialiMittente!=null && credenzialiMittente.getTokenClientId()!=null && credenzialiMittente.getTokenClientId().getId()!=null &&
  1151.                 credenzialiMittente.getTokenClientId().getId()>0) {
  1152.             refClientIdCredenzialieMittente = credenzialiMittente.getTokenClientId().getId();
  1153.         }
  1154.         if(refClientIdCredenzialieMittente==null) {
  1155.             return;
  1156.         }
  1157.         
  1158.         if(
  1159.                 (securityTokenForContext!=null && securityTokenForContext.getPdnd()!=null)
  1160.                 ||
  1161.                 (informazioniTokenNormalizzate.getPdnd()!=null && !informazioniTokenNormalizzate.getPdnd().isEmpty())
  1162.             ) {
  1163.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  1164.                         
  1165.             if(credenzialiMittente.getTokenPdndClientJson()==null &&
  1166.                     properties.isGestoreChiaviPDNDclientsTraceJsonResponse() &&
  1167.                     (securityTokenForContext!=null && securityTokenForContext.getPdnd()!=null)) {
  1168.                 String clientJson = securityTokenForContext.getPdnd().getClientJson();
  1169.                 if(clientJson!=null && StringUtils.isNotEmpty(clientJson)) {
  1170.                     CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.PDND_CLIENT_JSON);
  1171.                     tokenSearch.disableConvertToDBValue();
  1172.                     CredenzialeTokenPDND token = new CredenzialeTokenPDND(TipoCredenzialeMittente.PDND_CLIENT_JSON, clientJson, refClientIdCredenzialieMittente);
  1173.                     credenzialiMittente.setTokenPdndClientJson(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1174.                             tokenSearch, token, openspcoopState, identitaChiamante,
  1175.                             null, requestInfo));
  1176.                     /**System.out.println("["+idTransazione+"] PDND_CLIENT_JSON ref["+refClientIdCredenzialieMittente+"] ("+clientJson+") ID CREDENZIALE: "+credenzialiMittente.getTokenPdndClientJson().getId()+
  1177.                             " REFDB: "+credenzialiMittente.getTokenPdndClientJson().getRefCredenziale());*/
  1178.                 }
  1179.             }
  1180.                 
  1181.             if(credenzialiMittente.getTokenPdndOrganizationJson()==null &&
  1182.                     properties.isGestoreChiaviPDNDorganizationsTraceJsonResponse() &&
  1183.                     (securityTokenForContext!=null && securityTokenForContext.getPdnd()!=null)) {
  1184.                 String organizationJson = securityTokenForContext.getPdnd().getOrganizationJson();
  1185.                 if(organizationJson!=null && StringUtils.isNotEmpty(organizationJson)) {
  1186.                     CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.PDND_ORGANIZATION_JSON);
  1187.                     tokenSearch.disableConvertToDBValue();
  1188.                     CredenzialeTokenPDND token = new CredenzialeTokenPDND(TipoCredenzialeMittente.PDND_ORGANIZATION_JSON, organizationJson, refClientIdCredenzialieMittente);
  1189.                     credenzialiMittente.setTokenPdndOrganizationJson(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1190.                             tokenSearch, token, openspcoopState, identitaChiamante,
  1191.                             null, requestInfo));
  1192.                     /**System.out.println("["+idTransazione+"] PDND_ORGANIZATION_JSON ref["+refClientIdCredenzialieMittente+"] ("+organizationJson+") ID CREDENZIALE: "+credenzialiMittente.getTokenPdndOrganizationJson().getId()+
  1193.                             " REFDB: "+credenzialiMittente.getTokenPdndOrganizationJson().getRefCredenziale());*/
  1194.                 }
  1195.             }
  1196.             
  1197.             if(credenzialiMittente.getTokenPdndOrganizationName()==null &&
  1198.                     properties.isGestoreChiaviPDNDorganizationsTraceName()) {
  1199.                 
  1200.                 String organizationName = null;
  1201.                 if(securityTokenForContext!=null && securityTokenForContext.getPdnd()!=null){
  1202.                     try {
  1203.                         organizationName = securityTokenForContext.getPdnd().getOrganizationName(logger);
  1204.                     }catch(Exception e) {
  1205.                         // ignore (nel caso non è presente un organizationJson non è possibile recuperarlo)
  1206.                     }
  1207.                 }
  1208.                 if(organizationName==null && informazioniTokenNormalizzate.getPdnd()!=null) {
  1209.                     organizationName = PDNDTokenInfo.readOrganizationNameFromPDNDMap(informazioniTokenNormalizzate.getPdnd());
  1210.                 }
  1211.                 if(organizationName!=null && StringUtils.isNotEmpty(organizationName)) {
  1212.                     CredenzialeSearchToken tokenSearch = new CredenzialeSearchToken(TipoCredenzialeMittente.PDND_ORGANIZATION_NAME);
  1213.                     tokenSearch.disableConvertToDBValue();
  1214.                     CredenzialeTokenPDND token = new CredenzialeTokenPDND(TipoCredenzialeMittente.PDND_ORGANIZATION_NAME, organizationName, refClientIdCredenzialieMittente);
  1215.                     credenzialiMittente.setTokenPdndOrganizationName(getCredenzialeMittente(dominio, modulo, idTransazione, 
  1216.                             tokenSearch, token, openspcoopState, identitaChiamante,
  1217.                             null, requestInfo));
  1218.                     /**System.out.println("["+idTransazione+"] PDND_ORGANIZATION_NAME ref["+refClientIdCredenzialieMittente+"] ("+organizationName+") ID CREDENZIALE: "+credenzialiMittente.getTokenPdndOrganizationName().getId()+
  1219.                             " REFDB: "+credenzialiMittente.getTokenPdndOrganizationName().getRefCredenziale());*/
  1220.                 }
  1221.             }
  1222.         }
  1223.         
  1224.     }
  1225.     
  1226.     public static CredenzialeMittente convertGruppiToCredenzialiMittenti(IDSoggetto dominio, String modulo, String idTransazione,
  1227.             List<String> gruppiList, IOpenSPCoopState openspcoopState, String identitaChiamante,
  1228.             StringBuilder sbConflict, RequestInfo requestInfo) throws Exception{
  1229.         if(gruppiList!=null && !gruppiList.isEmpty()) {
  1230.             CredenzialeSearchGruppo gruppiSearch = new CredenzialeSearchGruppo();
  1231.             gruppiSearch.disableConvertToDBValue();
  1232.             CredenzialeGruppi gruppi = new CredenzialeGruppi(gruppiList);
  1233.             return getCredenzialeMittente(dominio, modulo, idTransazione, 
  1234.                     gruppiSearch, gruppi, openspcoopState, identitaChiamante,
  1235.                     sbConflict, requestInfo);
  1236.         }
  1237.         return null;
  1238.     }
  1239.     
  1240.     public static CredenzialeMittente convertAPIToCredenzialiMittenti(IDSoggetto dominio, String modulo, String idTransazione,
  1241.             String uriAccordoServizio, IOpenSPCoopState openspcoopState, String identitaChiamante,
  1242.             StringBuilder sbConflict, RequestInfo requestInfo) throws Exception{
  1243.         if(uriAccordoServizio!=null && !"".equals(uriAccordoServizio)) {
  1244.             CredenzialeSearchApi apiSearch = new CredenzialeSearchApi();
  1245.             apiSearch.disableConvertToDBValue();
  1246.             CredenzialeApi api = new CredenzialeApi(uriAccordoServizio);
  1247.             return getCredenzialeMittente(dominio, modulo, idTransazione, 
  1248.                     apiSearch, api, openspcoopState, identitaChiamante,
  1249.                     sbConflict, requestInfo);
  1250.         }
  1251.         return null;
  1252.     }
  1253.     
  1254.     public static CredenzialeMittente convertEventiToCredenzialiMittenti(IDSoggetto dominio, String modulo, String idTransazione,
  1255.             List<String> eventiList, IOpenSPCoopState openspcoopState, String identitaChiamante,
  1256.             StringBuilder sbConflict, RequestInfo requestInfo) throws Exception{
  1257.         if(eventiList!=null && !eventiList.isEmpty()) {
  1258.             CredenzialeSearchEvento eventiSearch = new CredenzialeSearchEvento();
  1259.             eventiSearch.disableConvertToDBValue();
  1260.             CredenzialeEventi eventi = new CredenzialeEventi(eventiList);
  1261.             return getCredenzialeMittente(dominio, modulo, idTransazione, 
  1262.                     eventiSearch, eventi, openspcoopState, identitaChiamante,
  1263.                     sbConflict, requestInfo);
  1264.         }
  1265.         return null;
  1266.     }
  1267.     
  1268.     public static CredenzialeMittente convertClientCredentialToCredenzialiMittenti(IDSoggetto dominio, String modulo, String idTransazione,
  1269.             String socketAddress, String transportAddress, 
  1270.             IOpenSPCoopState openspcoopState, String identitaChiamante,
  1271.             StringBuilder sbConflict, RequestInfo requestInfo) throws Exception{
  1272.         boolean socketAddressDefined = socketAddress!=null && !"".equals(socketAddress);
  1273.         boolean transportAddressDefined = transportAddress!=null && !"".equals(transportAddress);
  1274.         if(socketAddressDefined || transportAddressDefined) {
  1275.             CredenzialeSearchClientAddress clientAddressSearch = new CredenzialeSearchClientAddress(socketAddressDefined, transportAddressDefined, true);
  1276.             clientAddressSearch.disableConvertToDBValue();
  1277.             CredenzialeClientAddress clientAddress = new CredenzialeClientAddress(socketAddress, transportAddress);
  1278.             return getCredenzialeMittente(dominio, modulo, idTransazione, 
  1279.                     clientAddressSearch, clientAddress, openspcoopState, identitaChiamante,
  1280.                     sbConflict, requestInfo);
  1281.         }
  1282.         return null;
  1283.     }
  1284.     
  1285.     private static CredenzialeMittente getCredenzialeMittente(IDSoggetto dominio, String modulo, String idTransazione, 
  1286.             AbstractSearchCredenziale searchCredential, AbstractCredenziale credentialParam,
  1287.             IOpenSPCoopState openspcoopState, String identitaChiamante,
  1288.             StringBuilder sbConflict, RequestInfo requestInfo) throws Exception{
  1289.         
  1290.         if(dominio==null)
  1291.             throw new AutenticazioneException("(Parametri) dominio non definito");
  1292.         if(modulo==null)
  1293.             throw new AutenticazioneException("(Parametri) modulo non definito");
  1294.         if(idTransazione==null)
  1295.             throw new AutenticazioneException("(Parametri) idTransazione non definito");
  1296.         if(searchCredential==null)
  1297.             throw new AutenticazioneException("(Parametri) searchCredential non definito");
  1298.         if(credentialParam==null)
  1299.             throw new AutenticazioneException("(Parametri) credenziali non definite");
  1300.                 
  1301.         String credential = credentialParam.getCredenziale();
  1302.         int maxLengthCredenziali = OpenSPCoop2Properties.getInstance().getTransazioniCredenzialiMittenteMaxLength();
  1303.         if(credential.length()>maxLengthCredenziali) {
  1304.             logger.error("Attenzione: credenziale '"+searchCredential.getTipo()+"' ricevuta supera la dimensione massima consentita '"+maxLengthCredenziali+"'. Verrà salvata troncata a tale dimensione. Credenziale: '"+credential+"'");
  1305.             credential = credential.substring(0,maxLengthCredenziali);
  1306.             try {
  1307.                 credentialParam.updateCredenziale(credential);
  1308.             }catch(Exception e) {
  1309.                 logger.error("Non è possibile troncare la credenziale di tipo '"+searchCredential.getTipo()+"', l'informazione non verrà salvata");
  1310.             }
  1311.         }
  1312.         
  1313.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null;
  1314.         String keyCache = buildCacheKey(searchCredential, credential);
  1315.         
  1316.         int maxLifeSeconds = OpenSPCoop2Properties.getInstance().getTransazioniCredenzialiMittenteLifeSeconds();
  1317.         Date scadenzaEntry = new Date(DateManager.getTimeMillis()-(maxLifeSeconds*1000));
  1318.         
  1319.         if(useRequestInfo) {
  1320.             CredenzialeMittente c = requestInfo.getRequestConfig().getCredenzialeMittente(searchCredential.getTipoCredenzialeMittente(), keyCache);
  1321.             if(c!=null && c.getOraRegistrazione().after(scadenzaEntry)) {
  1322.                 return c; // informazione in cache valida
  1323.             }
  1324.         }
  1325.         
  1326.         CredenzialeMittente c = _getCredenzialeMittente(dominio, modulo, idTransazione, 
  1327.                 searchCredential, credentialParam,
  1328.                 openspcoopState, identitaChiamante,
  1329.                 sbConflict, requestInfo,
  1330.                 keyCache, scadenzaEntry);
  1331.         
  1332.         if(useRequestInfo) {
  1333.             requestInfo.getRequestConfig().addCredenzialeMittente(searchCredential.getTipoCredenzialeMittente(), keyCache, c, idTransazione, scadenzaEntry);
  1334.         }
  1335.         
  1336.         return c;
  1337.     }
  1338.     
  1339.     private static CredenzialeMittente _getCredenzialeMittente(IDSoggetto dominio, String modulo, String idTransazione, 
  1340.             AbstractSearchCredenziale searchCredential, AbstractCredenziale credentialParam,
  1341.             IOpenSPCoopState openspcoopState, String identitaChiamante,
  1342.             StringBuilder sbConflict, RequestInfo requestInfo,
  1343.             String keyCache, Date scadenzaEntry) throws Exception{
  1344.                 
  1345.         if(GestoreAutenticazione.cacheAutenticazione==null){
  1346.             return _getCredenzialeMittente(dominio, modulo, idTransazione, scadenzaEntry, searchCredential, credentialParam, openspcoopState, identitaChiamante, sbConflict);
  1347.         }
  1348.         else{
  1349.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1350.             org.openspcoop2.utils.cache.CacheResponse response = 
  1351.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreAutenticazione.cacheAutenticazione.get(keyCache);
  1352.             if(response != null){
  1353.                 if(response.getObject()!=null){
  1354.                     GestoreAutenticazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:getCredenzialeMittente) in cache.");
  1355.                     CredenzialeMittente credenziale = (CredenzialeMittente) response.getObject();
  1356.                     if(credenziale.getOraRegistrazione().after(scadenzaEntry)) {
  1357.                         return credenziale; // informazione in cache valida
  1358.                     }
  1359.                 }else if(response.getException()!=null){
  1360.                     GestoreAutenticazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:getCredenzialeMittente) in cache.");
  1361.                     throw (Exception) response.getException();
  1362.                 }else{
  1363.                     GestoreAutenticazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1364.                 }
  1365.             }
  1366.             
  1367.             //synchronized (GestoreAutenticazione.semaphoreCredenzialiMittente) {
  1368.             SemaphoreLock lock = GestoreAutenticazione.lockCredenzialiMittente.acquire("getCredenzialeMittente", idTransazione);
  1369.             try {
  1370.                 response = 
  1371.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreAutenticazione.cacheAutenticazione.get(keyCache);
  1372.                 if(response != null){
  1373.                     if(response.getObject()!=null){
  1374.                         GestoreAutenticazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:getCredenzialeMittente) in cache.");
  1375.                         CredenzialeMittente credenziale = (CredenzialeMittente) response.getObject();
  1376.                         if(credenziale.getOraRegistrazione().after(scadenzaEntry)) {
  1377.                             return credenziale; // informazione in cache valida
  1378.                         }
  1379.                     }else if(response.getException()!=null){
  1380.                         GestoreAutenticazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:getCredenzialeMittente) in cache.");
  1381.                         throw (Exception) response.getException();
  1382.                     }else{
  1383.                         GestoreAutenticazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1384.                     }
  1385.                 }

  1387.                 // Effettuo la query
  1388.                 GestoreAutenticazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:getCredenzialeMittente) ricerco nella configurazione...");
  1389.                 CredenzialeMittente credenziale = _getCredenzialeMittente(dominio, modulo, idTransazione, scadenzaEntry, searchCredential, credentialParam, openspcoopState, identitaChiamante, sbConflict);

  1391.                 // Aggiungo la risposta in cache (se esiste una cache)  
  1392.                 // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1393.                 // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1394.                 // - impostare il noCache a true
  1395.                 if(credenziale!=null){
  1396.                     GestoreAutenticazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  1397.                     try{
  1398.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1399.                         responseCache.setObject(credenziale);
  1400.                         GestoreAutenticazione.cacheAutenticazione.put(keyCache,responseCache);
  1401.                     }catch(UtilsException e){
  1402.                         GestoreAutenticazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  1403.                     }
  1404.                     return credenziale;
  1405.                 }else{
  1406.                     throw new AutenticazioneException("Metodo (GestoreAutenticazione.getCredenzialeMittente) ha ritornato un valore di esito null");
  1407.                 }
  1408.             }finally {
  1409.                 GestoreAutenticazione.lockCredenzialiMittente.release(lock, "getCredenzialeMittente", idTransazione);
  1410.             }
  1411.         }
  1412.     }
  1413.     
  1414.     private static String buildCacheKey(AbstractSearchCredenziale searchCredential, String credential) throws AutenticazioneException{
  1415.         StringBuilder bf = new StringBuilder();

  1417.         bf.append(searchCredential.getTipo()).append(" ");
  1418.         
  1419.         bf.append(credential);
  1420.         
  1421.         return bf.toString();
  1422.     }
  1423.     
  1424.     private static CredenzialeMittente _getCredenzialeMittente(IDSoggetto dominio, String modulo, String idTransazione, 
  1425.             Date scadenzaEntry,
  1426.             AbstractSearchCredenziale searchCredential, AbstractCredenziale credential,
  1427.             IOpenSPCoopState openspcoopState, String identitaChiamante,
  1428.             StringBuilder sbConflict) throws Exception {
  1429.         DBTransazioniManager dbManager = null;
  1430.         Resource r = null;
  1431.         boolean useConnectionRuntime = false;
  1432.         try{
  1433.             Connection con = null;
  1434.             
  1435.             OpenSPCoop2Properties openspcoopProperties = OpenSPCoop2Properties.getInstance();
  1436.             if(openspcoopProperties.isTransazioniUsePddRuntimeDatasource()) {
  1437.                 if(openspcoopState!=null) {
  1438.                     if(openspcoopState instanceof OpenSPCoopState) {
  1439.                         OpenSPCoopState s = (OpenSPCoopState) openspcoopState;
  1440.                         if(s.getConnectionDB()!=null && !s.getConnectionDB().isClosed()) {
  1441.                             con = s.getConnectionDB();
  1442.                             useConnectionRuntime = true;
  1443.                         }
  1444.                     }
  1445.                 }
  1446.             }
  1447.             
  1448.             //boolean isNull = (openspcoopState==null);
  1449.             //System.out.println("GET CREDENZIALI MITTENTE useConnectionRuntime["+useConnectionRuntime+"] (isNull:"+isNull+") (identitaChiamante: "+identitaChiamante+") ("+idTransazione+") ...");
  1450.             
  1451.             if(useConnectionRuntime==false){
  1452.                 dbManager = DBTransazioniManager.getInstance();
  1453.                 r = dbManager.getResource(dominio, modulo+".credenzialeMittente", idTransazione);
  1454.                 if(r==null){
  1455.                     throw new Exception("Risorsa al database non disponibile");
  1456.                 }
  1457.                 con = (Connection) r.getResource();
  1458.             }
  1459.             
  1460.             if(con == null)
  1461.                 throw new Exception("Connessione non disponibile"); 
  1462.             //System.out.println("GET CREDENZIALI MITTENTE useConnectionRuntime["+useConnectionRuntime+"] (isNull:"+isNull+") (identitaChiamante: "+identitaChiamante+") ("+idTransazione+") OK");
  1463.             boolean debug = OpenSPCoop2Properties.getInstance().isTransazioniDebug();
  1464.             Logger logSql =  OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSql(debug);
  1465.             DAOFactory daoFactory = DAOFactory.getInstance(logSql);
  1466.             DAOFactoryProperties daoFactoryProperties = DAOFactoryProperties.getInstance(logSql);
  1467.             ServiceManagerProperties daoFactoryServiceManagerPropertiesTransazioni = daoFactoryProperties.getServiceManagerProperties(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance());
  1468.             daoFactoryServiceManagerPropertiesTransazioni.setShowSql(debug);
  1469.             daoFactoryServiceManagerPropertiesTransazioni.setDatabaseType(DBTransazioniManager.getInstance().getTipoDatabase());
  1470.             
  1471.             org.openspcoop2.core.transazioni.dao.IServiceManager transazioniSM = 
  1472.                     (org.openspcoop2.core.transazioni.dao.IServiceManager) 
  1473.                         daoFactory.getServiceManager(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance(), con, daoFactoryServiceManagerPropertiesTransazioni, logSql); 

  1475.             ICredenzialeMittenteService credenzialiMittenteService = transazioniSM.getCredenzialeMittenteService();
  1476.             boolean ricercaEsatta = true;
  1477.             boolean caseSensitive = true;
  1478.             IPaginatedExpression pagExpression = searchCredential.createExpression(credenzialiMittenteService, credential.getCredenziale(), ricercaEsatta, caseSensitive);
  1479.             List<CredenzialeMittente> list = credenzialiMittenteService.findAll(pagExpression);
  1480.             if(list!=null && !list.isEmpty() && credential instanceof CredenzialeTrasporto) {
  1481.                 CredenzialeTrasporto cTrasporto = (CredenzialeTrasporto) credential;
  1482.                 if(cTrasporto.isSsl()) {
  1483.                     list = CredenzialeSearchTrasporto.filterList(list, credential.getCredenziale(), logSql);
  1484.                 }
  1485.             }

  1487.             if(list==null || list.size()<=0) {
  1488.                 // not exists
  1489.                 return createCredenzialeMittente(credenzialiMittenteService, scadenzaEntry, searchCredential, credential, logSql);
  1490.             }
  1491.             else if(list.size()>1) {
  1492.                 throw new Exception("Trovata più di un'occorrenza di credenziale di tipo '"+searchCredential.getTipo()+"'; credenziale: ["+credential.getCredenziale()+"]");
  1493.             }
  1494.             else {
  1495.                 CredenzialeMittente credenziale = list.get(0);
  1496.                 if(credenziale.getOraRegistrazione().after(scadenzaEntry)) {
  1497.                     return credenziale; // informazione in cache valida
  1498.                 }
  1499.                 else {
  1500.                     return updateDataCredenzialeMittente(credenzialiMittenteService, scadenzaEntry, credenziale, sbConflict);
  1501.                 }
  1502.             }
  1503.             
  1504.         }finally{
  1505.             if(useConnectionRuntime==false) {
  1506.                 try{
  1507.                     if(r!=null)
  1508.                         dbManager.releaseResource(dominio, modulo, r);
  1509.                 }catch(Exception eClose){
  1510.                     // close
  1511.                 }
  1512.             }
  1513.         }
  1514.     }
  1515.     
  1516.     private static CredenzialeMittente createCredenzialeMittente(ICredenzialeMittenteService credenzialeMittentiService,
  1517.             Date scadenzaEntry,
  1518.             AbstractSearchCredenziale searchCredential, AbstractCredenziale credential,
  1519.             Logger log) throws Exception {
  1520.         SemaphoreLock lock = GestoreAutenticazione.lockCredenzialiMittenteCreazione.acquire("createCredenzialeMittente");
  1521.         try {
  1522.             return  GestoreAutenticazione._createCredenzialeMittente(credenzialeMittentiService,
  1523.                     scadenzaEntry,
  1524.                     searchCredential, credential,
  1525.                     log);
  1526.         }finally {
  1527.             GestoreAutenticazione.lockCredenzialiMittenteCreazione.release(lock, "createCredenzialeMittente");
  1528.         }
  1529.     }
  1530. //    private static synchronized CredenzialeMittente createCredenzialeMittente(ICredenzialeMittenteService credenzialeMittentiService,
  1531. //          Date scadenzaEntry,
  1532. //          AbstractSearchCredenziale searchCredential, AbstractCredenziale credential,
  1533. //          Logger log) throws Exception {
  1534.     private static CredenzialeMittente _createCredenzialeMittente(ICredenzialeMittenteService credenzialeMittentiService,
  1535.             Date scadenzaEntry,
  1536.             AbstractSearchCredenziale searchCredential, AbstractCredenziale credential,
  1537.             Logger log) throws Exception {
  1538.         boolean ricercaEsatta = true;
  1539.         boolean caseSensitive = true;
  1540.         IPaginatedExpression pagEpression = searchCredential.createExpression(credenzialeMittentiService, credential.getCredenziale(), ricercaEsatta, caseSensitive); 
  1541.         List<CredenzialeMittente> list = credenzialeMittentiService.findAll(pagEpression);
  1542.         if(list!=null && !list.isEmpty() && credential instanceof CredenzialeTrasporto) {
  1543.             CredenzialeTrasporto cTrasporto = (CredenzialeTrasporto) credential;
  1544.             if(cTrasporto.isSsl()) {
  1545.                 list = CredenzialeSearchTrasporto.filterList(list, credential.getCredenziale(), log);
  1546.             }
  1547.         }
  1548.         if(list==null || list.size()<=0) {

  1550.             // not exists
  1551.             CredenzialeMittente credenzialeMittente = new CredenzialeMittente();
  1552.             credenzialeMittente.setTipo(credential.getTipo());
  1553.             credenzialeMittente.setRefCredenziale(credential.getReferenceId());
  1554.             credenzialeMittente.setOraRegistrazione(DateManager.getDate());
  1555.             credenzialeMittente.setCredenziale(credential.getCredenziale());
  1556.             try{
  1557.                 credenzialeMittentiService.create(credenzialeMittente);
  1558.             }catch(Throwable t){
  1559.                 // L'errore potrebbe essere dovuto al fatto che un thread su un altro nodo (dove non può agire la sincronizzazione del metodo) ha già creata la stessa entry
  1560.                 // Si avrebbe un errore simile al seguente: "org.openspcoop2.generic_project.exception.ServiceException: Create not completed: insertAndReturnGeneratedKey failed: ORA-00001: unique constraint (GOVWAY_ENTERPRISE.UNIQUE_CREDENZIALE_MITTENTE_1) violated"
  1561.                 // Provo a vedere se adesso le credenziali esistono
  1562.                 
  1563.                 list = credenzialeMittentiService.findAll(pagEpression);
  1564.                 if(list!=null && !list.isEmpty() && credential instanceof CredenzialeTrasporto) {
  1565.                     CredenzialeTrasporto cTrasporto = (CredenzialeTrasporto) credential;
  1566.                     if(cTrasporto.isSsl()) {
  1567.                         list = CredenzialeSearchTrasporto.filterList(list, credential.getCredenziale(), log);
  1568.                     }
  1569.                 }

  1571.                 if(list==null || list.size()<=0) {
  1572.                     // not exists, rilancio eccezione originale
  1573.                     throw new Exception(t.getMessage(),t);
  1574.                 }
  1575.                 else if(list.size()>1) {
  1576.                     throw new Exception("Trovata più di un'occorrenza di credenziale di tipo '"+searchCredential.getTipo()+"'; credenziale: ["+credential.getCredenziale()+"]");
  1577.                 }
  1578.                 else {
  1579.                     CredenzialeMittente credenziale = list.get(0);
  1580.                     return credenziale; // appena creata dall'altro nodo.
  1581.                 }
  1582.             }
  1583.             return credenzialeMittente;
  1584.         }
  1585.         else if(list.size()>1) {
  1586.             throw new Exception("Trovata più di un'occorrenza di credenziale di tipo '"+searchCredential.getTipo()+"'; credenziale: ["+credential.getCredenziale()+"]");
  1587.         }
  1588.         else {
  1589.             CredenzialeMittente credenziale = list.get(0);
  1590.             if(credenziale.getOraRegistrazione().after(scadenzaEntry)) {
  1591.                 return credenziale; // informazione in cache valida
  1592.             }
  1593.             //else {
  1594.                 //return updateDataCredenzialeMittente(credenzialeMittentiService, scadenzaEntry, credenziale);
  1595.                 // ritorno la credenziale trovata sul database, che comunque è sicuramente stata "appena" creata da un altro nodo run. Altrimenti non arriverei a questo else
  1596.                 // il metodo di updateDataCredenzialeMittente imposta un ulteriore lock che non si desidera "pagare"
  1597.                 return credenziale;
  1598.             //}
  1599.         }
  1600.     }
  1601.     
  1602.     private static CredenzialeMittente updateDataCredenzialeMittente(ICredenzialeMittenteService credenzialeMittentiService,
  1603.             Date scadenzaEntry, CredenzialeMittente credenziale,
  1604.             StringBuilder sbConflict) throws Exception {
  1605.         
  1606.         // Il semaforo utilizzato prima di effettuare l'update non basta, la modifica potrebbe essere effettuata da più nodi.
  1607.         
  1608.         long gestioneSerializableDB_AttesaAttiva = OpenSPCoop2Properties.getInstance().getGestioneSerializableDBAttesaAttiva();
  1609.         int gestioneSerializableDB_CheckInterval = OpenSPCoop2Properties.getInstance().getGestioneSerializableDBCheckInterval();
  1610.         
  1611.         long scadenzaWhile = DateManager.getTimeMillis() + gestioneSerializableDB_AttesaAttiva;
  1612.         
  1613.         Throwable lastT = null;
  1614.         while(DateManager.getTimeMillis() < scadenzaWhile){
  1615.         
  1616.             int conflict = 0;
  1617.             try{
  1618.                 
  1619.                 SemaphoreLock lock = GestoreAutenticazione.lockCredenzialiMittenteAggiornamento.acquire("updateDataCredenzialeMittente");
  1620.                 try {
  1621.                     CredenzialeMittente c = GestoreAutenticazione._updateDataCredenzialeMittente(credenzialeMittentiService,
  1622.                             scadenzaEntry, credenziale);
  1623.                     if(sbConflict!=null) {
  1624.                         sbConflict.append(conflict);
  1625.                     }
  1626.                     return c;
  1627.                 
  1628.                 }finally {
  1629.                     GestoreAutenticazione.lockCredenzialiMittenteAggiornamento.release(lock, "updateDataCredenzialeMittente");
  1630.                 }
  1631.                     
  1632.             } catch(Throwable e) {
  1633.                 lastT = e;
  1634.                 //System.out.println("Serializable error:"+e.getMessage());
  1635.                 //e.printStackTrace(System.out);
  1636.                 conflict++;
  1637.             }
  1638.             
  1639.             // Per aiutare ad evitare conflitti
  1640.             try{
  1641.                 Utilities.sleep((getRandom()).nextInt(gestioneSerializableDB_CheckInterval)); // random da 0ms a checkIntervalms
  1642.             }catch(Exception eRandom){
  1643.                 // ignore
  1644.             }
  1645.         }
  1646.         
  1647.         if(lastT!=null) {
  1648.             throw new Exception("Aggiornamento credenziali non riuscito: "+lastT.getMessage(),lastT);
  1649.         }
  1650.         else {
  1651.             throw new Exception("Aggiornamento credenziali non riuscito");
  1652.         }
  1653.         
  1654.     }
  1655. //    private static synchronized CredenzialeMittente updateDataCredenzialeMittente(ICredenzialeMittenteService credenzialeMittentiService,
  1656. //          Date scadenzaEntry, CredenzialeMittente credenziale) throws Exception {
  1657.     private static CredenzialeMittente _updateDataCredenzialeMittente(ICredenzialeMittenteService credenzialeMittentiService,
  1658.             Date scadenzaEntry, CredenzialeMittente credenziale) throws Exception {
  1659.         
  1660.         IdCredenzialeMittente id = credenzialeMittentiService.convertToId(credenziale);
  1661.         CredenzialeMittente credenzialeCheck = credenzialeMittentiService.get(id);
  1662.         if(credenziale.getOraRegistrazione().after(scadenzaEntry)) {
  1663.             return credenzialeCheck; // informazione in cache già aggiornata da una chiamata concorrente
  1664.         }
  1665.         else {
  1666.             //System.out.println("Update Credenziale '"+id.getTipo()+"'");
  1667.             credenzialeCheck.setOraRegistrazione(DateManager.getDate()); // update
  1668.             credenzialeMittentiService.update(id, credenzialeCheck);
  1669.             return credenzialeCheck;
  1670.         }
  1671.         
  1672.     }
  1673.     
  1674. }
Created with JaCoCo 0.8.8.202204050719