GestoreAutorizzazione.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.autorizzazione;

  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.openspcoop2.core.config.AutorizzazioneScope;
  31. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  32. import org.openspcoop2.core.config.PortaDelegata;
  33. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  34. import org.openspcoop2.core.config.Scope;
  35. import org.openspcoop2.core.config.ServizioApplicativo;
  36. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  37. import org.openspcoop2.core.config.constants.RuoloTipologia;
  38. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  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.IDServizio;
  43. import org.openspcoop2.core.id.IDServizioApplicativo;
  44. import org.openspcoop2.core.id.IDSoggetto;
  45. import org.openspcoop2.message.OpenSPCoop2Message;
  46. import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
  47. import org.openspcoop2.message.utils.WWWAuthenticateGenerator;
  48. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  49. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  50. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  51. import org.openspcoop2.pdd.core.AbstractCore;
  52. import org.openspcoop2.pdd.core.CostantiPdD;
  53. import org.openspcoop2.pdd.core.PdDContext;
  54. import org.openspcoop2.pdd.core.autorizzazione.pa.DatiInvocazionePortaApplicativa;
  55. import org.openspcoop2.pdd.core.autorizzazione.pa.EsitoAutorizzazionePortaApplicativa;
  56. import org.openspcoop2.pdd.core.autorizzazione.pa.IAutorizzazioneContenutoPortaApplicativa;
  57. import org.openspcoop2.pdd.core.autorizzazione.pa.IAutorizzazionePortaApplicativa;
  58. import org.openspcoop2.pdd.core.autorizzazione.pd.DatiInvocazionePortaDelegata;
  59. import org.openspcoop2.pdd.core.autorizzazione.pd.EsitoAutorizzazionePortaDelegata;
  60. import org.openspcoop2.pdd.core.autorizzazione.pd.IAutorizzazioneContenutoPortaDelegata;
  61. import org.openspcoop2.pdd.core.autorizzazione.pd.IAutorizzazionePortaDelegata;
  62. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  63. import org.openspcoop2.pdd.core.token.InformazioniToken;
  64. import org.openspcoop2.pdd.core.token.TokenUtilities;
  65. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  66. import org.openspcoop2.protocol.engine.constants.Costanti;
  67. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  68. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  69. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  70. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  71. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  72. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  73. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  74. import org.openspcoop2.utils.SemaphoreLock;
  75. import org.openspcoop2.utils.SortedMap;
  76. import org.openspcoop2.utils.UtilsException;
  77. import org.openspcoop2.utils.cache.Cache;
  78. import org.openspcoop2.utils.cache.CacheAlgorithm;
  79. import org.openspcoop2.utils.cache.CacheResponse;
  80. import org.openspcoop2.utils.cache.CacheType;
  81. import org.openspcoop2.utils.properties.PropertiesUtilities;
  82. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  83. import org.slf4j.Logger;

  85. /**
  86.  * Classe utilizzata per la gestione del processo di autorizzazione Buste
  87.  *
  88.  * @author Poli Andrea (apoli@link.it)
  89.  * @author $Author$
  90.  * @version $Rev$, $Date$
  91.  */
  92. public class GestoreAutorizzazione {

  94.     
  95.     /** Chiave della cache per l'autorizzazione Buste  */
  96.     private static final String AUTORIZZAZIONE_CACHE_NAME = "autorizzazione";
  97.     /** Cache */
  98.     private static Cache cacheAutorizzazione = null;
  99.     //private static final Boolean semaphoreAutorizzazionePD = true;
  100.     //private static final Boolean semaphoreAutorizzazionePA = true;
  101.     //private static final Boolean semaphoreAutorizzazioneContenutiPD = true;
  102.     //private static final Boolean semaphoreAutorizzazioneContenutiPA = true;
  103.     
  104.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAutorizzazionePD = new HashMap<>(); 
  105.     private static synchronized org.openspcoop2.utils.Semaphore initLockAutorizzazionePD(String tipoAutorizzazione){
  106.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazionePD.get(tipoAutorizzazione);
  107.         if(s==null) {
  108.             Integer permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneLockPermits(tipoAutorizzazione);
  109.             if(permits==null) {
  110.                 permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneLockPermits();
  111.             }
  112.             if(permits!=null && permits.intValue()>1) {
  113.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneFruizioni_"+tipoAutorizzazione, permits);
  114.             }
  115.             else {
  116.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneFruizioni_"+tipoAutorizzazione);
  117.             }
  118.             _lockAutorizzazionePD.put(tipoAutorizzazione, s);
  119.         }
  120.         return s;
  121.     }
  122.     private static org.openspcoop2.utils.Semaphore getLockAutorizzazionePD(String tipoAutorizzazione){
  123.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazionePD.get(tipoAutorizzazione);
  124.         if(s==null) {
  125.             s = initLockAutorizzazionePD(tipoAutorizzazione);
  126.         }
  127.         return s;
  128.     }
  129.     
  130.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAutorizzazionePA = new HashMap<>(); 
  131.     private static synchronized org.openspcoop2.utils.Semaphore initLockAutorizzazionePA(String tipoAutorizzazione){
  132.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazionePA.get(tipoAutorizzazione);
  133.         if(s==null) {
  134.             Integer permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneLockPermits(tipoAutorizzazione);
  135.             if(permits==null) {
  136.                 permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneLockPermits();
  137.             }
  138.             if(permits!=null && permits.intValue()>1) {
  139.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneErogazioni_"+tipoAutorizzazione, permits);
  140.             }
  141.             else {
  142.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneErogazioni_"+tipoAutorizzazione);
  143.             }
  144.             _lockAutorizzazionePA.put(tipoAutorizzazione, s);
  145.         }
  146.         return s;
  147.     }
  148.     private static org.openspcoop2.utils.Semaphore getLockAutorizzazionePA(String tipoAutorizzazione){
  149.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazionePA.get(tipoAutorizzazione);
  150.         if(s==null) {
  151.             s = initLockAutorizzazionePA(tipoAutorizzazione);
  152.         }
  153.         return s;
  154.     }
  155.     
  156.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAutorizzazioneContenutiPD = new HashMap<>(); 
  157.     private static synchronized org.openspcoop2.utils.Semaphore initLockAutorizzazioneContenutiPD(String tipoAutorizzazioneContenuti){
  158.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazioneContenutiPD.get(tipoAutorizzazioneContenuti);
  159.         if(s==null) {
  160.             Integer permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneContenutiLockPermits(tipoAutorizzazioneContenuti);
  161.             if(permits==null) {
  162.                 permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneContenutiLockPermits();
  163.             }
  164.             if(permits!=null && permits.intValue()>1) {
  165.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneContenutiFruizioni_"+tipoAutorizzazioneContenuti, permits);
  166.             }
  167.             else {
  168.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneContenutiFruizioni_"+tipoAutorizzazioneContenuti);
  169.             }
  170.             _lockAutorizzazioneContenutiPD.put(tipoAutorizzazioneContenuti, s);
  171.         }
  172.         return s;
  173.     }
  174.     private static org.openspcoop2.utils.Semaphore getLockAutorizzazioneContenutiPD(String tipoAutorizzazioneContenuti){
  175.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazioneContenutiPD.get(tipoAutorizzazioneContenuti);
  176.         if(s==null) {
  177.             s = initLockAutorizzazioneContenutiPD(tipoAutorizzazioneContenuti);
  178.         }
  179.         return s;
  180.     }
  181.     
  182.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAutorizzazioneContenutiPA = new HashMap<>(); 
  183.     private static synchronized org.openspcoop2.utils.Semaphore initLockAutorizzazioneContenutiPA(String tipoAutorizzazioneContenuti){
  184.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazioneContenutiPA.get(tipoAutorizzazioneContenuti);
  185.         if(s==null) {
  186.             Integer permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneContenutiLockPermits(tipoAutorizzazioneContenuti);
  187.             if(permits==null) {
  188.                 permits = OpenSPCoop2Properties.getInstance().getAutorizzazioneContenutiLockPermits();
  189.             }
  190.             if(permits!=null && permits.intValue()>1) {
  191.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneContenutiErogazioni_"+tipoAutorizzazioneContenuti, permits);
  192.             }
  193.             else {
  194.                 s = new org.openspcoop2.utils.Semaphore("GestoreAutorizzazioneContenutiErogazioni_"+tipoAutorizzazioneContenuti);
  195.             }
  196.             _lockAutorizzazioneContenutiPA.put(tipoAutorizzazioneContenuti, s);
  197.         }
  198.         return s;
  199.     }
  200.     private static org.openspcoop2.utils.Semaphore getLockAutorizzazioneContenutiPA(String tipoAutorizzazioneContenuti){
  201.         org.openspcoop2.utils.Semaphore s = _lockAutorizzazioneContenutiPA.get(tipoAutorizzazioneContenuti);
  202.         if(s==null) {
  203.             s = initLockAutorizzazioneContenutiPA(tipoAutorizzazioneContenuti);
  204.         }
  205.         return s;
  206.     }
  207.     
  208.     /** Logger log */
  209.     private static Logger logger = null;
  210.     private static Logger logConsole = OpenSPCoop2Logger.getLoggerOpenSPCoopConsole();



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


  386.     /*----------------- INIZIALIZZAZIONE --------------------*/
  387.     public static void initialize(Logger log) throws Exception{
  388.         GestoreAutorizzazione.initialize(null, false, -1,null,-1l,-1l, log);
  389.     }
  390.     public static void initialize(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  391.             long idleTime, long itemLifeSecond, Logger log) throws Exception{
  392.         GestoreAutorizzazione.initialize(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  393.     }

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

  398.         // Inizializzo log
  399.         GestoreAutorizzazione.logger = log;
  400.         
  401.         // Inizializzazione Cache
  402.         if(cacheAbilitata){
  403.             GestoreAutorizzazione.initCacheAutorizzazione(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  404.         }

  406.     }


  409.     public static void initCacheAutorizzazione(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  410.             long idleTime, long itemLifeSecond, Logger log) throws Exception {
  411.         
  412.         if(log!=null)
  413.             log.info("Inizializzazione cache Autorizzazione");

  415.         GestoreAutorizzazione.cacheAutorizzazione = new Cache(cacheType, GestoreAutorizzazione.AUTORIZZAZIONE_CACHE_NAME);

  417.         if( (dimensioneCache>0) ||
  418.                 (algoritmoCache != null) ){

  420.             if( dimensioneCache>0 ){
  421.                 try{
  422.                     String msg = "Dimensione della cache (Autorizzazione) impostata al valore: "+dimensioneCache;
  423.                     if(log!=null)
  424.                         log.info(msg);
  425.                     GestoreAutorizzazione.logConsole.info(msg);
  426.                     GestoreAutorizzazione.cacheAutorizzazione.setCacheSize(dimensioneCache);
  427.                 }catch(Exception error){
  428.                     throw new AutorizzazioneException("Parametro errato per la dimensione della cache (Gestore Messaggi): "+error.getMessage(),error);
  429.                 }
  430.             }
  431.             if(algoritmoCache != null ){
  432.                 String msg = "Algoritmo di cache (Autorizzazione) impostato al valore: "+algoritmoCache;
  433.                 if(log!=null)
  434.                     log.info(msg);
  435.                 GestoreAutorizzazione.logConsole.info(msg);
  436.                 if(CostantiConfigurazione.CACHE_MRU.toString().equalsIgnoreCase(algoritmoCache))
  437.                     GestoreAutorizzazione.cacheAutorizzazione.setCacheAlgoritm(CacheAlgorithm.MRU);
  438.                 else
  439.                     GestoreAutorizzazione.cacheAutorizzazione.setCacheAlgoritm(CacheAlgorithm.LRU);
  440.             }

  442.         }

  444.         if( idleTime > 0  ){
  445.             try{
  446.                 String msg = "Attributo 'IdleTime' (Autorizzazione) impostato al valore: "+idleTime;
  447.                 if(log!=null)
  448.                     log.info(msg);
  449.                 GestoreAutorizzazione.logConsole.info(msg);
  450.                 GestoreAutorizzazione.cacheAutorizzazione.setItemIdleTime(idleTime);
  451.             }catch(Exception error){
  452.                 throw new AutorizzazioneException("Parametro errato per l'attributo 'IdleTime' (Gestore Messaggi): "+error.getMessage(),error);
  453.             }
  454.         }
  455.         try{
  456.             String msg = "Attributo 'MaxLifeSecond' (Autorizzazione) impostato al valore: "+itemLifeSecond;
  457.             if(log!=null)
  458.                 log.info(msg);
  459.             GestoreAutorizzazione.logConsole.info(msg);
  460.             GestoreAutorizzazione.cacheAutorizzazione.setItemLifeTime(itemLifeSecond);
  461.         }catch(Exception error){
  462.             throw new AutorizzazioneException("Parametro errato per l'attributo 'MaxLifeSecond' (Gestore Messaggi): "+error.getMessage(),error);
  463.         }
  464.         
  465.         GestoreAutorizzazione.cacheAutorizzazione.build();

  467.     }
  468.     

  470.     @SuppressWarnings("deprecation")
  471.     @Deprecated
  472.     public static void disableSyncronizedGet() throws UtilsException {
  473.         if(GestoreAutorizzazione.cacheAutorizzazione==null) {
  474.             throw new UtilsException("Cache disabled");
  475.         }
  476.         GestoreAutorizzazione.cacheAutorizzazione.disableSyncronizedGet();
  477.     }
  478.     @SuppressWarnings("deprecation")
  479.     @Deprecated
  480.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  481.         if(GestoreAutorizzazione.cacheAutorizzazione==null) {
  482.             throw new UtilsException("Cache disabled");
  483.         }
  484.         return GestoreAutorizzazione.cacheAutorizzazione.isDisableSyncronizedGet();
  485.     }
  486.     
  487.     
  488.     
  489.     
  490.     
  491.     
  492. /*----------------- CLEANER --------------------*/
  493.     
  494.     public static void removePortaApplicativa(IDPortaApplicativa idPA) throws Exception {
  495.         if(GestoreAutorizzazione.isCacheAbilitata()) {
  496.             List<String> keyForClean = new ArrayList<>();
  497.             List<String> keys = GestoreAutorizzazione.listKeysCache();
  498.             if(keys!=null && !keys.isEmpty()) {
  499.                 String match = IDPortaApplicativa.PORTA_APPLICATIVA_PREFIX+idPA.getNome()+IDPortaApplicativa.PORTA_APPLICATIVA_SUFFIX;
  500.                 for (String key : keys) {
  501.                     if(key!=null && key.contains(match)) {
  502.                         keyForClean.add(key);
  503.                     }
  504.                 }
  505.             }
  506.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  507.                 for (String key : keyForClean) {
  508.                     removeObjectCache(key);
  509.                 }
  510.             }
  511.         }
  512.     }
  513.     
  514.     public static void removePortaDelegata(IDPortaDelegata idPD) throws Exception {
  515.         if(GestoreAutorizzazione.isCacheAbilitata()) {
  516.             List<String> keyForClean = new ArrayList<>();
  517.             List<String> keys = GestoreAutorizzazione.listKeysCache();
  518.             if(keys!=null && !keys.isEmpty()) {
  519.                 String match = IDPortaDelegata.PORTA_DELEGATA_PREFIX+idPD.getNome()+IDPortaDelegata.PORTA_DELEGATA_SUFFIX;
  520.                 for (String key : keys) {
  521.                     if(key!=null && key.contains(match)) {
  522.                         keyForClean.add(key);
  523.                     }
  524.                 }
  525.             }
  526.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  527.                 for (String key : keyForClean) {
  528.                     removeObjectCache(key);
  529.                 }
  530.             }
  531.         }
  532.     }
  533.     
  534.     public static void removeSoggetto(IDSoggetto idSoggetto) throws Exception {
  535.         if(GestoreAutorizzazione.isCacheAbilitata()) {
  536.             List<String> keyForClean = new ArrayList<>();
  537.             List<String> keys = GestoreAutorizzazione.listKeysCache();
  538.             if(keys!=null && !keys.isEmpty()) {
  539.                 String matchSoggettoFruitore = DatiInvocazionePortaApplicativa.SOGGETTO_FRUITORE_PREFIX+idSoggetto.toString()+DatiInvocazionePortaApplicativa.SOGGETTO_FRUITORE_SUFFIX;
  540.                 for (String key : keys) {
  541.                     if(key!=null && key.contains(matchSoggettoFruitore)) {
  542.                         keyForClean.add(key);
  543.                     }
  544.                 }
  545.             }
  546.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  547.                 for (String key : keyForClean) {
  548.                     removeObjectCache(key);
  549.                 }
  550.             }
  551.         }
  552.     }
  553.     
  554.     public static void removeApplicativo(IDServizioApplicativo idApplicativo) throws Exception {
  555.         if(GestoreAutorizzazione.isCacheAbilitata()) {
  556.             List<String> keyForClean = new ArrayList<>();
  557.             List<String> keys = GestoreAutorizzazione.listKeysCache();
  558.             if(keys!=null && !keys.isEmpty()) {
  559.                 String matchApplicativoFruitore = DatiInvocazionePortaApplicativa.APPLICATIVO_FRUITORE_PREFIX+idApplicativo.toString()+DatiInvocazionePortaApplicativa.APPLICATIVO_FRUITORE_SUFFIX;
  560.                 String matchApplicativo = DatiInvocazionePortaDelegata.APPLICATIVO_PREFIX+idApplicativo.toString()+DatiInvocazionePortaDelegata.APPLICATIVO_SUFFIX;
  561.                 for (String key : keys) {
  562.                     if(key!=null && (key.contains(matchApplicativoFruitore) || key.contains(matchApplicativo))) {
  563.                         keyForClean.add(key);
  564.                     }
  565.                 }
  566.             }
  567.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  568.                 for (String key : keyForClean) {
  569.                     removeObjectCache(key);
  570.                 }
  571.             }
  572.         }
  573.     }
  574.     
  575.     
  576.     
  577.     
  578.     
  579.     
  580.     
  581.     /*----------------- AUTORIZZAZIONE --------------------*/
  582.     

  584.     public static EsitoAutorizzazionePortaDelegata verificaAutorizzazionePortaDelegata(String tipoAutorizzazione, DatiInvocazionePortaDelegata datiInvocazione,
  585.               PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg, Logger log) throws Exception{
  586.         
  587.         checkDatiPortaDelegata(datiInvocazione);
  588.         
  589.         EsitoAutorizzazionePortaDelegata esito = _verificaAutorizzazionePortaDelegata(tipoAutorizzazione, datiInvocazione, pddContext, protocolFactory, msg);
  590.         if(esito.isAutorizzato()==false) {
  591.             return esito;
  592.         }
  593.         
  594.         // Verifiche Richieste
  595.         boolean verificaAutorizzazioneRichiedenti = false;
  596.         boolean verificaAutorizzazioneRuoli = false;
  597.         if(datiInvocazione.getPd()!=null) {
  598.             if(datiInvocazione.getPd().getAutorizzazioneToken()!=null) {
  599.                 if(StatoFunzionalita.ABILITATO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getAutorizzazioneApplicativi())){
  600.                     verificaAutorizzazioneRichiedenti=true;
  601.                 }
  602.                 if(StatoFunzionalita.ABILITATO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getAutorizzazioneRuoli())){
  603.                     verificaAutorizzazioneRuoli = true;
  604.                 }
  605.             }
  606.         }
  607.         
  608.         // Verifica Token Richiedenti
  609.         
  610.         IDServizioApplicativo idSAToken = null;
  611.         if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  612.             idSAToken = (IDServizioApplicativo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  613.         }
  614.         
  615.         boolean authRichiedenti = true;
  616.         if(verificaAutorizzazioneRichiedenti){
  617.             authRichiedenti = false;
  618.             if( idSAToken!=null &&
  619.                     datiInvocazione.getPd().getAutorizzazioneToken().getServiziApplicativi()!=null &&
  620.                     datiInvocazione.getPd().getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0){
  621.                 for (PortaDelegataServizioApplicativo sa : datiInvocazione.getPd().getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList()) {
  622.                     if(idSAToken.getNome().equals(sa.getNome())) {
  623.                         authRichiedenti = true;
  624.                         break;
  625.                     }
  626.                 }
  627.             }
  628.         }

  630.         
  631.         // Verifica Token Roles
  632.         
  633.         boolean authRuoli = true;
  634.         StringBuilder detailsBufferRuoli = null;
  635.         if(verificaAutorizzazioneRuoli){
  636.             boolean checkRuoloRegistro = false;
  637.             boolean checkRuoloEsterno = false;
  638.             if( datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli()==null ||
  639.                 RuoloTipologia.QUALSIASI.equals(datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli())){
  640.                 checkRuoloRegistro = true;
  641.                 checkRuoloEsterno = true;
  642.             } 
  643.             else if( RuoloTipologia.INTERNO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli())){
  644.                 checkRuoloRegistro = true;
  645.             }
  646.             else if( RuoloTipologia.ESTERNO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli())){
  647.                 checkRuoloEsterno = true;
  648.             }
  649.             detailsBufferRuoli = new StringBuilder();
  650.             ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  651.             ServizioApplicativo sa = null;
  652.             if(idSAToken!=null) {
  653.                 sa = configurazionePdDManager.getServizioApplicativo(idSAToken, datiInvocazione.getRequestInfo());
  654.             }
  655.             authRuoli = configurazionePdDManager.
  656.                     autorizzazioneTokenRoles(datiInvocazione.getPd(), sa, 
  657.                             datiInvocazione.getInfoConnettoreIngresso(), 
  658.                             pddContext, datiInvocazione.getRequestInfo(),
  659.                             checkRuoloRegistro, checkRuoloEsterno,
  660.                             detailsBufferRuoli);
  661.         }
  662.         
  663.         
  664.         // Esiti Verifiche Richieste
  665.         
  666.         if(verificaAutorizzazioneRichiedenti && verificaAutorizzazioneRuoli) {
  667.             // se una delle due autorizzazione e' andata a buon fine devo autorizzare
  668.             if(!authRichiedenti && !authRuoli) {
  669.                 // uso eccezione per ruolo che e' più completa come messaggistica
  670.                 EsitoAutorizzazionePortaDelegata esitoNew = esito;
  671.                 if(idSAToken!=null){
  672.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_MISSING_ROLE, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  673.                             getErrore404_AutorizzazioneFallitaServizioApplicativo(idSAToken.getNome()));
  674.                 }
  675.                 else{
  676.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_MISSING_ROLE, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA_ANONIMO.
  677.                             getErrore404_AutorizzazioneFallitaServizioApplicativoAnonimo());
  678.                 }
  679.                 esito.setAutorizzato(false);
  680.                 if(detailsBufferRuoli.length()>0) {
  681.                     esito.setDetails(detailsBufferRuoli.toString());
  682.                 }
  683.                 return esitoNew;
  684.             }
  685.         }
  686.         else {
  687.             if(verificaAutorizzazioneRichiedenti && !authRichiedenti) {
  688.                 EsitoAutorizzazionePortaDelegata esitoNew = esito;
  689.                 esitoNew.setAutorizzato(false);
  690.                 esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_DENY, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  691.                         getErrore404_AutorizzazioneFallitaServizioApplicativo(idSAToken!=null ? idSAToken.getNome() : CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO ));
  692.                 return esitoNew;
  693.             }
  694.             if(verificaAutorizzazioneRuoli && !authRuoli) {
  695.                 EsitoAutorizzazionePortaDelegata esitoNew = esito;
  696.                 if(idSAToken!=null){
  697.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_MISSING_ROLE, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  698.                             getErrore404_AutorizzazioneFallitaServizioApplicativo(idSAToken.getNome()));
  699.                 }
  700.                 else{
  701.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_MISSING_ROLE, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA_ANONIMO.
  702.                             getErrore404_AutorizzazioneFallitaServizioApplicativoAnonimo());
  703.                 }
  704.                 esito.setAutorizzato(false);
  705.                 if(detailsBufferRuoli.length()>0) {
  706.                     esito.setDetails(detailsBufferRuoli.toString());
  707.                 }
  708.                 return esitoNew;
  709.             }
  710.         }
  711.         
  712.         
  713.         // Verifica Token Scopes
  714.         
  715.         AutorizzazioneScope authScope = null;
  716.         if(datiInvocazione.getPd()!=null) {
  717.             authScope = datiInvocazione.getPd().getScope();
  718.         }
  719.         if(authScope!=null && authScope.sizeScopeList()>0) {
  720.             EsitoAutorizzazionePortaDelegata esitoNew = (EsitoAutorizzazionePortaDelegata) autorizzazioneScope(authScope, esito, pddContext, datiInvocazione);
  721.             if(esitoNew.isAutorizzato()==false) {
  722.                 esitoNew.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_MISSING_SCOPE, ErroriIntegrazione.ERRORE_445_TOKEN_AUTORIZZAZIONE_FALLITA.getErroreIntegrazione());
  723.                 return esitoNew;
  724.             }
  725.         }
  726.         
  727.         // Verifica Token Options
  728.         
  729.         if(datiInvocazione.getPd()!=null && datiInvocazione.getPd().getGestioneToken()!=null
  730.                 && datiInvocazione.getPd().getGestioneToken().getOptions()!=null) {
  731.             EsitoAutorizzazionePortaDelegata esitoNew = 
  732.                     (EsitoAutorizzazionePortaDelegata) autorizzazioneTokenOptions(datiInvocazione.getPd().getGestioneToken().getOptions(), 
  733.                             esito, pddContext, datiInvocazione,
  734.                             log, msg);
  735.             if(esitoNew.isAutorizzato()==false) {
  736.                 esitoNew.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_TOKEN_DENY, ErroriIntegrazione.ERRORE_445_TOKEN_AUTORIZZAZIONE_FALLITA.getErroreIntegrazione());
  737.                 return esitoNew;
  738.             }
  739.         }
  740.         
  741.         return esito;
  742.         
  743.     }
  744.     
  745.     private static EsitoAutorizzazionePortaDelegata _verificaAutorizzazionePortaDelegata(String tipoAutorizzazione, DatiInvocazionePortaDelegata datiInvocazione,
  746.           PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  747.         
  748.         IAutorizzazionePortaDelegata auth = newInstanceAuthPortaDelegata(tipoAutorizzazione, pddContext, protocolFactory);
  749.         
  750.         try {
  751.             if(GestoreAutorizzazione.cacheAutorizzazione==null || !auth.saveAuthorizationResultInCache()){
  752.                 return auth.process(datiInvocazione);
  753.             }
  754.             else{
  755.                 String keyCache = buildCacheKey(true, tipoAutorizzazione, datiInvocazione.getKeyCache(), auth.getSuffixKeyAuthorizationResultInCache(datiInvocazione) );
  756.     
  757.                 // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  758.                 org.openspcoop2.utils.cache.CacheResponse response = 
  759.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  760.                 if(response != null){
  761.                     if(response.getObject()!=null){
  762.                         GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  763.                         EsitoAutorizzazionePortaDelegata esito = (EsitoAutorizzazionePortaDelegata) response.getObject();
  764.                         esito.setEsitoPresenteInCache(true);
  765.                         return esito;
  766.                     }else if(response.getException()!=null){
  767.                         GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  768.                         throw (Exception) response.getException();
  769.                     }else{
  770.                         GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  771.                     }
  772.                 }
  773.             
  774.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  775.                 //synchronized (GestoreAutorizzazione.semaphoreAutorizzazionePD) {
  776.                 org.openspcoop2.utils.Semaphore lockAutorizzazionePD = getLockAutorizzazionePD(tipoAutorizzazione);
  777.                 SemaphoreLock lock = lockAutorizzazionePD.acquire("verificaAutorizzazionePortaDelegata", idTransazione);
  778.                 try {
  779.                     
  780.                     response = 
  781.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  782.                     if(response != null){
  783.                         if(response.getObject()!=null){
  784.                             GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  785.                             EsitoAutorizzazionePortaDelegata esito = (EsitoAutorizzazionePortaDelegata) response.getObject();
  786.                             esito.setEsitoPresenteInCache(true);
  787.                             return esito;
  788.                         }else if(response.getException()!=null){
  789.                             GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  790.                             throw (Exception) response.getException();
  791.                         }else{
  792.                             GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  793.                         }
  794.                     }
  795.     
  796.                     // Effettuo la query
  797.                     GestoreAutorizzazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) ricerco nella configurazione...");
  798.                     EsitoAutorizzazionePortaDelegata esito = auth.process(datiInvocazione);
  799.     
  800.                     // Aggiungo la risposta in cache (se esiste una cache)  
  801.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  802.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  803.                     // - impostare il noCache a true
  804.                     if(esito!=null){
  805.                         if(!esito.isNoCache()){
  806.                             GestoreAutorizzazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  807.                             try{    
  808.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  809.                                 responseCache.setObject(esito);
  810.                                 GestoreAutorizzazione.cacheAutorizzazione.put(keyCache,responseCache);
  811.                             }catch(UtilsException e){
  812.                                 GestoreAutorizzazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  813.                             }
  814.                         }
  815.                         return esito;
  816.                     }else{
  817.                         throw new AutorizzazioneException("Metodo (GestoreAutorizzazione.autorizzazionePortaDelegata.process) ha ritornato un valore di esito null");
  818.                     }
  819.                 }finally {
  820.                     lockAutorizzazionePD.release(lock, "verificaAutorizzazionePortaDelegata", idTransazione);
  821.                 }
  822.             }
  823.         }finally {
  824.             if(msg!=null) {
  825.                 auth.cleanPostAuth(msg);
  826.             }
  827.         }
  828.     }
  829.     
  830.     public static EsitoAutorizzazionePortaApplicativa verificaAutorizzazionePortaApplicativa(String tipoAutorizzazione, DatiInvocazionePortaApplicativa datiInvocazione,
  831.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg, Logger log) throws Exception{
  832.           
  833.         checkDatiPortaApplicativa(datiInvocazione);
  834.     
  835.         EsitoAutorizzazionePortaApplicativa esito = _verificaAutorizzazionePortaApplicativa(tipoAutorizzazione, datiInvocazione, pddContext, protocolFactory, msg);
  836.         if(esito.isAutorizzato()==false) {
  837.             return esito;
  838.         }
  839.         
  840.                 
  841.         boolean skipProfiloModi = false;
  842.         if(protocolFactory!=null && Costanti.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
  843.             skipProfiloModi=true;
  844.         }
  845.         
  846.         if(!skipProfiloModi) {
  847.         
  848.             // Verifiche Richieste
  849.             
  850.             boolean verificaAutorizzazioneRichiedenti = false;
  851.             boolean verificaAutorizzazioneRuoli = false;
  852.             if(datiInvocazione.getPa()!=null) {
  853.                 if(datiInvocazione.getPa().getAutorizzazioneToken()!=null) {
  854.                     if(StatoFunzionalita.ABILITATO.equals(datiInvocazione.getPa().getAutorizzazioneToken().getAutorizzazioneApplicativi())){
  855.                         verificaAutorizzazioneRichiedenti=true;
  856.                     }
  857.                     if(StatoFunzionalita.ABILITATO.equals(datiInvocazione.getPa().getAutorizzazioneToken().getAutorizzazioneRuoli())){
  858.                         verificaAutorizzazioneRuoli = true;
  859.                     }
  860.                 }
  861.             }
  862.             else if(datiInvocazione.getPd()!=null){
  863.                 if(datiInvocazione.getPd().getAutorizzazioneToken()!=null) {
  864.                     if(StatoFunzionalita.ABILITATO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getAutorizzazioneApplicativi())){
  865.                         verificaAutorizzazioneRichiedenti=true;
  866.                     }
  867.                     if(StatoFunzionalita.ABILITATO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getAutorizzazioneRuoli())){
  868.                         verificaAutorizzazioneRuoli = true;
  869.                     }
  870.                 }
  871.             }
  872.         

  874.             // Verifica Token Richiedenti
  875.         
  876.             IDServizioApplicativo idSAToken = null;
  877.             if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  878.                 idSAToken = (IDServizioApplicativo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  879.             }
  880.             
  881.             boolean authRichiedenti = true;
  882.             if(datiInvocazione.getPa()!=null) {
  883.                 if(verificaAutorizzazioneRichiedenti){
  884.                     authRichiedenti = false;
  885.                     if( idSAToken!=null &&
  886.                             datiInvocazione.getPa().getAutorizzazioneToken().getServiziApplicativi()!=null &&
  887.                             datiInvocazione.getPa().getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0){
  888.                         for (PortaApplicativaAutorizzazioneServizioApplicativo sa : datiInvocazione.getPa().getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList()) {
  889.                             if(idSAToken.getNome().equals(sa.getNome()) &&
  890.                                     idSAToken.getIdSoggettoProprietario().getTipo().equals(sa.getTipoSoggettoProprietario()) &&
  891.                                     idSAToken.getIdSoggettoProprietario().getNome().equals(sa.getNomeSoggettoProprietario())) {
  892.                                 authRichiedenti = true;
  893.                                 break;
  894.                             }
  895.                         }
  896.                     }
  897.                 }
  898.             }
  899.             else if(datiInvocazione.getPd()!=null){
  900.                 if(verificaAutorizzazioneRichiedenti){
  901.                     authRichiedenti = false;
  902.                     if( idSAToken!=null &&
  903.                             datiInvocazione.getPd().getAutorizzazioneToken().getServiziApplicativi()!=null &&
  904.                             datiInvocazione.getPd().getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0){
  905.                         for (PortaDelegataServizioApplicativo sa : datiInvocazione.getPd().getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList()) {
  906.                             if(idSAToken.getNome().equals(sa.getNome())) {
  907.                                 authRichiedenti = true;
  908.                                 break;
  909.                             }
  910.                         }
  911.                     }
  912.                 }
  913.             }
  914.         
  915.         
  916.             // Verifica Token Roles
  917.         
  918.             boolean authRuoli = true;
  919.             StringBuilder detailsBufferRuoli = null;
  920.             if(datiInvocazione.getPa()!=null) {
  921.                 if(verificaAutorizzazioneRuoli){
  922.                     boolean checkRuoloRegistro = false;
  923.                     boolean checkRuoloEsterno = false;
  924.                     if( datiInvocazione.getPa().getAutorizzazioneToken().getTipologiaRuoli()==null ||
  925.                         RuoloTipologia.QUALSIASI.equals(datiInvocazione.getPa().getAutorizzazioneToken().getTipologiaRuoli())){
  926.                         checkRuoloRegistro = true;
  927.                         checkRuoloEsterno = true;
  928.                     } 
  929.                     else if( RuoloTipologia.INTERNO.equals(datiInvocazione.getPa().getAutorizzazioneToken().getTipologiaRuoli())){
  930.                         checkRuoloRegistro = true;
  931.                     }
  932.                     else if( RuoloTipologia.ESTERNO.equals(datiInvocazione.getPa().getAutorizzazioneToken().getTipologiaRuoli())){
  933.                         checkRuoloEsterno = true;
  934.                     }
  935.                     detailsBufferRuoli = new StringBuilder();
  936.                     ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  937.                     ServizioApplicativo sa = null;
  938.                     if(idSAToken!=null) {
  939.                         sa = configurazionePdDManager.getServizioApplicativo(idSAToken, datiInvocazione.getRequestInfo());
  940.                     }
  941.                     authRuoli = configurazionePdDManager.
  942.                             autorizzazioneTokenRoles(datiInvocazione.getPa(), sa, 
  943.                                     datiInvocazione.getInfoConnettoreIngresso(), 
  944.                                     pddContext, datiInvocazione.getRequestInfo(),
  945.                                     checkRuoloRegistro, checkRuoloEsterno,
  946.                                     detailsBufferRuoli);
  947.                 }
  948.             }
  949.             else if(datiInvocazione.getPd()!=null){
  950.                 if(verificaAutorizzazioneRuoli){
  951.                     boolean checkRuoloRegistro = false;
  952.                     boolean checkRuoloEsterno = false;
  953.                     if( datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli()==null ||
  954.                         RuoloTipologia.QUALSIASI.equals(datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli())){
  955.                         checkRuoloRegistro = true;
  956.                         checkRuoloEsterno = true;
  957.                     } 
  958.                     else if( RuoloTipologia.INTERNO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli())){
  959.                         checkRuoloRegistro = true;
  960.                     }
  961.                     else if( RuoloTipologia.ESTERNO.equals(datiInvocazione.getPd().getAutorizzazioneToken().getTipologiaRuoli())){
  962.                         checkRuoloEsterno = true;
  963.                     }
  964.                     detailsBufferRuoli = new StringBuilder();
  965.                     ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  966.                     ServizioApplicativo sa = null;
  967.                     if(idSAToken!=null) {
  968.                         sa = configurazionePdDManager.getServizioApplicativo(idSAToken, datiInvocazione.getRequestInfo());
  969.                     }
  970.                     authRuoli = configurazionePdDManager.
  971.                             autorizzazioneTokenRoles(datiInvocazione.getPd(), sa, 
  972.                                     datiInvocazione.getInfoConnettoreIngresso(), 
  973.                                     pddContext, datiInvocazione.getRequestInfo(),
  974.                                     checkRuoloRegistro, checkRuoloEsterno,
  975.                                     detailsBufferRuoli);
  976.                 }
  977.             }
  978.             
  979.             
  980.             // Esiti Verifiche Richieste
  981.             
  982.             if(verificaAutorizzazioneRichiedenti && verificaAutorizzazioneRuoli) {
  983.                 // se una delle due autorizzazione e' andata a buon fine devo autorizzare
  984.                 if(!authRichiedenti && !authRuoli) {
  985.                     // uso eccezione per ruolo che e' più completa come messaggistica
  986.                     EsitoAutorizzazionePortaApplicativa esitoNew = esito;
  987.                     String errore = "";
  988.                     esitoNew.setErroreCooperazione(IntegrationFunctionError.AUTHORIZATION_MISSING_ROLE, ErroriCooperazione.AUTORIZZAZIONE_FALLITA.getErroreAutorizzazione(errore, CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA));
  989.                     esitoNew.setAutorizzato(false);
  990.                     if(detailsBufferRuoli.length()>0) {
  991.                         esitoNew.setDetails(detailsBufferRuoli.toString());
  992.                     }
  993.                     return esitoNew;
  994.                 }
  995.             }
  996.             else {
  997.                 if(verificaAutorizzazioneRichiedenti && !authRichiedenti) {
  998.                     EsitoAutorizzazionePortaApplicativa esitoNew = esito;
  999.                     esitoNew.setAutorizzato(false);
  1000.                     IDServizio idServizio = datiInvocazione.getIdServizio();
  1001.                     String errore = org.openspcoop2.pdd.core.autorizzazione.pa.AbstractAutorizzazioneBase.getErrorString(idSAToken, null, idServizio);
  1002.                     if(esitoNew.getDetails()!=null){
  1003.                         errore = errore + " ("+esitoNew.getDetails()+")";
  1004.                     }
  1005.                     esitoNew.setErroreCooperazione(IntegrationFunctionError.AUTHORIZATION_DENY, ErroriCooperazione.AUTORIZZAZIONE_FALLITA.getErroreAutorizzazione(errore, CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA));
  1006.                     return esitoNew;
  1007.                 }
  1008.                 if(verificaAutorizzazioneRuoli && !authRuoli) {
  1009.                     EsitoAutorizzazionePortaApplicativa esitoNew = esito;
  1010.                     String errore = "";
  1011.                     esitoNew.setErroreCooperazione(IntegrationFunctionError.AUTHORIZATION_MISSING_ROLE, ErroriCooperazione.AUTORIZZAZIONE_FALLITA.getErroreAutorizzazione(errore, CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA));
  1012.                     esitoNew.setAutorizzato(false);
  1013.                     if(detailsBufferRuoli.length()>0) {
  1014.                         esitoNew.setDetails(detailsBufferRuoli.toString());
  1015.                     }
  1016.                     return esitoNew;
  1017.                 }
  1018.             }
  1019.         }
  1020.         
  1021.         // Verifica Token Scopes
  1022.         
  1023.         AutorizzazioneScope authScope = null;
  1024.         if(datiInvocazione.getPa()!=null) {
  1025.             authScope = datiInvocazione.getPa().getScope();
  1026.         }
  1027.         else if(datiInvocazione.getPd()!=null){
  1028.             authScope = datiInvocazione.getPd().getScope();
  1029.         }
  1030.         if(authScope!=null && authScope.sizeScopeList()>0) {
  1031.             EsitoAutorizzazionePortaApplicativa esitoNew = (EsitoAutorizzazionePortaApplicativa) autorizzazioneScope(authScope, esito, pddContext, datiInvocazione);
  1032.             if(!esitoNew.isAutorizzato()) {
  1033.                 esitoNew.setErroreCooperazione(IntegrationFunctionError.AUTHORIZATION_MISSING_SCOPE, ErroriCooperazione.TOKEN_AUTORIZZAZIONE_FALLITA.getErroreCooperazione());
  1034.                 return esitoNew;
  1035.             }
  1036.         }
  1037.         
  1038.         
  1039.         // Verifica Token Options
  1040.         
  1041.         String tokenOptions = null;
  1042.         if(datiInvocazione.getPa()!=null) {
  1043.             if(datiInvocazione.getPa().getGestioneToken()!=null) {
  1044.                 tokenOptions = datiInvocazione.getPa().getGestioneToken().getOptions();
  1045.             }
  1046.         }
  1047.         else if(datiInvocazione.getPd()!=null){
  1048.             if(datiInvocazione.getPd().getGestioneToken()!=null) {
  1049.                 tokenOptions = datiInvocazione.getPd().getGestioneToken().getOptions();
  1050.             }
  1051.         }
  1052.         
  1053.         if(tokenOptions!=null) {
  1054.             EsitoAutorizzazionePortaApplicativa esitoNew = 
  1055.                     (EsitoAutorizzazionePortaApplicativa) autorizzazioneTokenOptions(tokenOptions, 
  1056.                             esito, pddContext, datiInvocazione,
  1057.                             log, msg);
  1058.             if(!esitoNew.isAutorizzato()) {
  1059.                 esitoNew.setErroreCooperazione(IntegrationFunctionError.AUTHORIZATION_TOKEN_DENY, ErroriCooperazione.TOKEN_AUTORIZZAZIONE_FALLITA.getErroreCooperazione());
  1060.                 return esitoNew;
  1061.             }
  1062.         }
  1063.         
  1064.         return esito;
  1065.         
  1066.     }
  1067.     private static EsitoAutorizzazionePortaApplicativa _verificaAutorizzazionePortaApplicativa(String tipoAutorizzazione, DatiInvocazionePortaApplicativa datiInvocazione,
  1068.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  1069.         
  1070.         IAutorizzazionePortaApplicativa auth = newInstanceAuthPortaApplicativa(tipoAutorizzazione, pddContext, protocolFactory);
  1071.         
  1072.         try {
  1073.             if(GestoreAutorizzazione.cacheAutorizzazione==null || !auth.saveAuthorizationResultInCache()){
  1074.                 return auth.process(datiInvocazione);
  1075.             }
  1076.             else{
  1077.                 String keyCache = buildCacheKey(false, tipoAutorizzazione, datiInvocazione.getKeyCache(), auth.getSuffixKeyAuthorizationResultInCache(datiInvocazione));
  1078.     
  1079.                 // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1080.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1081.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  1082.                 if(response != null){
  1083.                     if(response.getObject()!=null){
  1084.                         GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1085.                         EsitoAutorizzazionePortaApplicativa esito = (EsitoAutorizzazionePortaApplicativa) response.getObject();
  1086.                         esito.setEsitoPresenteInCache(true);
  1087.                         return esito;
  1088.                     }else if(response.getException()!=null){
  1089.                         GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1090.                         throw (Exception) response.getException();
  1091.                     }else{
  1092.                         GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1093.                     }
  1094.                 }
  1095.                 
  1096.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1097.                 //synchronized (GestoreAutorizzazione.semaphoreAutorizzazionePA) {
  1098.                 org.openspcoop2.utils.Semaphore lockAutorizzazionePA = getLockAutorizzazionePA(tipoAutorizzazione);
  1099.                 SemaphoreLock lock = lockAutorizzazionePA.acquire("verificaAutorizzazionePortaApplicativa", idTransazione);
  1100.                 try {
  1101.                     
  1102.                     response = 
  1103.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  1104.                     if(response != null){
  1105.                         if(response.getObject()!=null){
  1106.                             GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1107.                             EsitoAutorizzazionePortaApplicativa esito = (EsitoAutorizzazionePortaApplicativa) response.getObject();
  1108.                             esito.setEsitoPresenteInCache(true);
  1109.                             return esito;
  1110.                         }else if(response.getException()!=null){
  1111.                             GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1112.                             throw (Exception) response.getException();
  1113.                         }else{
  1114.                             GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1115.                         }
  1116.                     }
  1117.     
  1118.                     // Effettuo la query
  1119.                     GestoreAutorizzazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) ricerco nella configurazione...");
  1120.                     EsitoAutorizzazionePortaApplicativa esito = auth.process(datiInvocazione);
  1121.     
  1122.                     // Aggiungo la risposta in cache (se esiste una cache)  
  1123.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1124.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1125.                     // - impostare il noCache a true
  1126.                     if(esito!=null){
  1127.                         if(!esito.isNoCache()){
  1128.                             GestoreAutorizzazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  1129.                             try{    
  1130.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1131.                                 responseCache.setObject(esito);
  1132.                                 GestoreAutorizzazione.cacheAutorizzazione.put(keyCache,responseCache);
  1133.                             }catch(UtilsException e){
  1134.                                 GestoreAutorizzazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  1135.                             }
  1136.                         }
  1137.                         return esito;
  1138.                     }else{
  1139.                         throw new AutorizzazioneException("Metodo (GestoreAutorizzazione.autorizzazionePortaApplicativa.process) ha ritornato un valore di esito null");
  1140.                     }
  1141.                 }finally {
  1142.                     lockAutorizzazionePA.release(lock, "verificaAutorizzazionePortaApplicativa", idTransazione);
  1143.                 }
  1144.             }
  1145.         }finally {
  1146.             if(msg!=null) {
  1147.                 auth.cleanPostAuth(msg);
  1148.             }
  1149.         }
  1150.     }
  1151.     
  1152.     private static void checkDatiPortaDelegata(DatiInvocazionePortaDelegata datiInvocazione) throws AutorizzazioneException{
  1153.         
  1154.         IDServizio idServizio = datiInvocazione.getIdServizio();
  1155.         if(idServizio==null)
  1156.             throw new AutorizzazioneException("(Parametri) IDServizio non definito");
  1157.         if(idServizio.getTipo()==null || idServizio.getNome()==null || idServizio.getVersione()==null)
  1158.             throw new AutorizzazioneException("(Parametri) Servizio non definito");
  1159.         if(idServizio.getSoggettoErogatore()==null || idServizio.getSoggettoErogatore().getTipo()==null || idServizio.getSoggettoErogatore().getNome()==null)
  1160.             throw new AutorizzazioneException("(Parametri) Soggetto erogatore non definito");
  1161.         
  1162.         IDPortaDelegata idPD = datiInvocazione.getIdPD();
  1163.         if(idPD==null)
  1164.             throw new AutorizzazioneException("(Parametri) IDPortaDelegata non definito");
  1165.         if(idPD.getNome()==null)
  1166.             throw new AutorizzazioneException("(Parametri) IDPortaDelegata.nome non definito");
  1167.         
  1168.         PortaDelegata pd = datiInvocazione.getPd();
  1169.         if(pd==null)
  1170.             throw new AutorizzazioneException("(Parametri) PortaDelegata non definito");
  1171.         
  1172.         IDServizioApplicativo idSA = datiInvocazione.getIdServizioApplicativo();
  1173.         if(idSA==null)
  1174.             throw new AutorizzazioneException("(Parametri) IDServizioApplicativo non definito");
  1175.         if(idSA.getNome()==null)
  1176.             throw new AutorizzazioneException("(Parametri) IDServizioApplicativo.nome non definito");
  1177.         IDSoggetto idSoggettoProprietario = idSA.getIdSoggettoProprietario();
  1178.         if(idSoggettoProprietario==null || idSoggettoProprietario.getTipo()==null || idSoggettoProprietario.getNome()==null)
  1179.             throw new AutorizzazioneException("(Parametri) IDServizioApplicativo.Soggetto non definito");
  1180.         
  1181.     }
  1182.     
  1183.     private static void checkDatiPortaApplicativa(DatiInvocazionePortaApplicativa datiInvocazione) throws AutorizzazioneException{
  1184.         
  1185.         IDServizio idServizio = datiInvocazione.getIdServizio();
  1186.         if(idServizio==null)
  1187.             throw new AutorizzazioneException("(Parametri) IDServizio non definito");
  1188.         if(idServizio.getTipo()==null || idServizio.getNome()==null || idServizio.getVersione()==null)
  1189.             throw new AutorizzazioneException("(Parametri) Servizio non definito");
  1190.         if(idServizio.getSoggettoErogatore()==null || idServizio.getSoggettoErogatore().getTipo()==null || idServizio.getSoggettoErogatore().getNome()==null)
  1191.             throw new AutorizzazioneException("(Parametri) Soggetto erogatore non definito");

  1193.         // Dipende dal ruolo della Busta, se c'e' la porta applicativa o delegata
  1194. //      IDPortaApplicativaByNome idPA = datiInvocazione.getIdPA();
  1195. //      if(idPA==null)
  1196. //          throw new AutorizzazioneException("(Parametri) IDPortaApplicativaByNome non definito");
  1197. //      if(idPA.getNome()==null)
  1198. //          throw new AutorizzazioneException("(Parametri) IDPortaApplicativaByNome.nome non definito");
  1199. //      IDSoggetto idSoggettoProprietarioPA = idPA.getSoggetto();
  1200. //      if(idSoggettoProprietarioPA==null || idSoggettoProprietarioPA.getTipo()==null || idSoggettoProprietarioPA.getNome()==null)
  1201. //          throw new AutorizzazioneException("(Parametri) IDPortaApplicativaByNome.Soggetto non definito");
  1202. //      
  1203. //      PortaApplicativa pa = datiInvocazione.getPa();
  1204. //      if(pa==null)
  1205. //          throw new AutorizzazioneException("(Parametri) PortaApplicativa non definito");
  1206.         
  1207.         // In caso di autenticazione dei soggetti abilitata, il parametro soggetto fruitore può non essere definito
  1208. //      IDSoggetto idSoggettoFruitore = datiInvocazione.getIdSoggettoFruitore();
  1209. //      if(idSoggettoFruitore==null || idSoggettoFruitore.getTipo()==null || idSoggettoFruitore.getNome()==null)
  1210. //          throw new AutorizzazioneException("(Parametri) IDSoggettoFruitore non definito");
  1211.         
  1212.         RuoloBusta ruolo = datiInvocazione.getRuoloBusta();
  1213.         if(ruolo==null)
  1214.             throw new AutorizzazioneException("(Parametri) RuoloBusta non definito");
  1215.     }
  1216.     
  1217.     private static String buildCacheKey(boolean portaDelegata, String tipoAutorizzazione, String keyCache, String suffixKeyCache) throws AutorizzazioneException{
  1218.         StringBuilder bf = new StringBuilder();
  1219.         
  1220.         if(portaDelegata)
  1221.             bf.append("PD ");
  1222.         else
  1223.             bf.append("PA ");
  1224.         
  1225.         bf.append(" Auth:").append(tipoAutorizzazione).append(" ");
  1226.         
  1227.         bf.append(keyCache);
  1228.         
  1229.         if(suffixKeyCache!=null && !"".equals(suffixKeyCache)){
  1230.             bf.append(" ");
  1231.             bf.append(suffixKeyCache);
  1232.         }
  1233.         
  1234.         return bf.toString();
  1235.     }
  1236.     
  1237.     private static IAutorizzazionePortaDelegata newInstanceAuthPortaDelegata(String tipoAutorizzazione,PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws AutorizzazioneException{
  1238.         IAutorizzazionePortaDelegata auth = null;
  1239.         try{
  1240.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1241.             auth = (IAutorizzazionePortaDelegata) pluginLoader.newAutorizzazionePortaDelegata(tipoAutorizzazione);
  1242.         }catch(Exception e){
  1243.             throw new AutorizzazioneException(e.getMessage(),e); // descrizione errore già corretta
  1244.         }
  1245.         String classType = null; 
  1246.         try{
  1247.             classType = auth.getClass().getName();
  1248.             AbstractCore.init(auth, pddContext, protocolFactory);
  1249.             return auth;
  1250.         }catch(Exception e){
  1251.             throw new AutorizzazioneException("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  1252.                     "] che definisce l'autorizzazione della fruizione: "+e.getMessage(),e);
  1253.         }
  1254.     }
  1255.     
  1256.     private static IAutorizzazionePortaApplicativa newInstanceAuthPortaApplicativa(String tipoAutorizzazione,PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws AutorizzazioneException{
  1257.         IAutorizzazionePortaApplicativa auth = null;
  1258.         try{
  1259.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1260.             auth = (IAutorizzazionePortaApplicativa) pluginLoader.newAutorizzazionePortaApplicativa(tipoAutorizzazione);
  1261.         }catch(Exception e){
  1262.             throw new AutorizzazioneException(e.getMessage(),e); // descrizione errore già corretta
  1263.         }
  1264.         String classType = null; 
  1265.         try{
  1266.             classType = auth.getClass().getName();
  1267.             AbstractCore.init(auth, pddContext, protocolFactory);
  1268.             return auth;
  1269.         }catch(Exception e){
  1270.             throw new AutorizzazioneException("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  1271.                     "] che definisce l'autorizzazione della erogazione: "+e.getMessage(),e);
  1272.         }
  1273.     }
  1274.     
  1275.     private static EsitoAutorizzazione autorizzazioneScope(AutorizzazioneScope authScope, EsitoAutorizzazione esito, 
  1276.             PdDContext pddContext, AbstractDatiInvocazione datiInvocazione) throws Exception {
  1277.         if(authScope!=null && authScope.sizeScopeList()>0) {
  1278.             
  1279.             InformazioniToken informazioniTokenNormalizzate = null;
  1280.             Object oInformazioniTokenNormalizzate = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  1281.             if(oInformazioniTokenNormalizzate!=null) {
  1282.                 informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  1283.             }
  1284.             boolean autorizzato = true;
  1285.             String errorMessage = null;
  1286.             if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getScopes()==null || informazioniTokenNormalizzate.getScopes().size()<=0) {
  1287.                 errorMessage = "Token without scopes";
  1288.                 autorizzato = false;
  1289.             }
  1290.             else {
  1291.                 boolean foundAlmostOne = false;
  1292.                 for (Scope scope : authScope.getScopeList()) {
  1293.                     org.openspcoop2.core.registry.Scope scopeOp2Registry = RegistroServiziManager.getInstance(datiInvocazione.getState()).getScope(scope.getNome(),null,datiInvocazione.getRequestInfo());
  1294.                     String nomeScope = scopeOp2Registry.getNome();
  1295.                     if(scopeOp2Registry.getNomeEsterno()!=null && !"".equals(scopeOp2Registry.getNomeEsterno())) {
  1296.                         nomeScope = scopeOp2Registry.getNomeEsterno();
  1297.                     }
  1298.                     if(informazioniTokenNormalizzate.getScopes().contains(nomeScope)==false) {
  1299.                         if(ScopeTipoMatch.ALL.equals(authScope.getMatch())) {
  1300.                             autorizzato = false;
  1301.                             errorMessage = "Scope '"+nomeScope+"' not found";
  1302.                             break;
  1303.                         }
  1304.                     }
  1305.                     else {
  1306.                         foundAlmostOne = true;
  1307.                     }
  1308.                 }
  1309.                 if(!foundAlmostOne) {
  1310.                     autorizzato = false;
  1311.                     errorMessage = "Scopes not found";
  1312.                 }
  1313.             }
  1314.             
  1315.             if(!autorizzato) {
  1316.             
  1317.                 String realm = "OpenSPCoop";
  1318.                 Object oRealm = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_REALM);
  1319.                 if(oRealm!=null) {
  1320.                     realm = (String) oRealm;
  1321.                 }
  1322.                 
  1323.                 boolean emptyMessage = false;
  1324.                 Object oEmptyMessage = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_MESSAGE_ERROR_BODY_EMPTY);
  1325.                 if(oEmptyMessage!=null) {
  1326.                     emptyMessage = (Boolean) oEmptyMessage;
  1327.                 }
  1328.                 
  1329.                 boolean genericMessage = false;
  1330.                 Object oGenericMessage = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_MESSAGE_ERROR_GENERIC_MESSAGE);
  1331.                 if(oGenericMessage!=null) {
  1332.                     genericMessage = (Boolean) oGenericMessage;
  1333.                 }
  1334.                 
  1335.                 if(genericMessage) {
  1336.                     esito.setDetails(errorMessage);
  1337.                 }
  1338.                 
  1339.                 String [] scopes = new String[authScope.sizeScopeList()];
  1340.                 for (int i = 0; i < authScope.sizeScopeList(); i++) {
  1341.                     org.openspcoop2.core.registry.Scope scopeOp2Registry = RegistroServiziManager.getInstance(datiInvocazione.getState()).getScope(authScope.getScope(i).getNome(),null,datiInvocazione.getRequestInfo());
  1342.                     String nomeScope = scopeOp2Registry.getNome();
  1343.                     if(scopeOp2Registry.getNomeEsterno()!=null) {
  1344.                         nomeScope = scopeOp2Registry.getNomeEsterno();
  1345.                     }
  1346.                     scopes[i] = nomeScope;
  1347.                 }
  1348.                 
  1349.                 esito.setAutorizzato(false);
  1350.                 if(emptyMessage) {
  1351.                     esito.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.insufficient_scope, realm, genericMessage, errorMessage, scopes));
  1352.                 }
  1353.                 else {
  1354.                     esito.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.insufficient_scope, realm, genericMessage, errorMessage, scopes));
  1355.                 }
  1356.                 
  1357.             }
  1358.             
  1359.             
  1360.         }
  1361.         
  1362.         return esito;
  1363.     }

  1365.     private static final String ATTRIBUTE_AUTHORITY_PREFIX = "aa.";
  1366.     private static final String ATTRIBUTE_PREFIX = "attribute.";
  1367.     private static EsitoAutorizzazione autorizzazioneTokenOptions(String tokenOptions, EsitoAutorizzazione esito, 
  1368.             PdDContext pddContext, AbstractDatiInvocazione datiInvocazione,
  1369.             Logger log, OpenSPCoop2Message message) throws Exception {
  1370.         
  1371.         boolean autorizzato = true;
  1372.         String errorMessage = null;
  1373.         if(tokenOptions!=null) {
  1374.             
  1375.             /**Properties properties = PropertiesUtilities.convertTextToProperties(tokenOptions);*/
  1376.             // Fix per preservare l'ordine di configurazione
  1377.             SortedMap<List<String>> properties = PropertiesUtilities.convertTextToSortedListMap(tokenOptions);
  1378.             if(properties!=null && properties.size()>0) {
  1379.             
  1380.                 InformazioniToken informazioniTokenNormalizzate = null;
  1381.                 Object oInformazioniTokenNormalizzate = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  1382.                 if(oInformazioniTokenNormalizzate!=null) {
  1383.                     informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  1384.                 }
  1385.             
  1386.                 if(informazioniTokenNormalizzate==null || informazioniTokenNormalizzate.getClaims()==null || informazioniTokenNormalizzate.getClaims().size()<=0) {
  1387.                     autorizzato = false;
  1388.                     errorMessage = "Token without claims";
  1389.                 }
  1390.                 else {
  1391.                                         
  1392.                     /* Costruisco dynamic Map */
  1393.                     boolean bufferMessageReadOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  1394.                     Map<String, Object> dynamicMap = DynamicUtils.buildDynamicMap(message, pddContext, datiInvocazione.getBusta(), log, bufferMessageReadOnly);
  1395.                                         
  1396.                     /* Analisi claims di autorizzazione */
  1397.                     
  1398.                     /**System.out.println("\n\n@ ===== AUTH TOKEN CLAIMS =====");*/
  1399.                     
  1400.                     List<String> keys = properties.keys();
  1401.                     for (String key : keys) {
  1402.                         
  1403.                         List<String> expectedValues = properties.get(key);
  1404.                         if(expectedValues!=null && !expectedValues.isEmpty()) {
  1405.                             
  1406.                             for (String expectedValue : expectedValues) {
  1407.                                 
  1408.                                 /**System.out.println("check '"+key+"'='"+expectedValue+"'");*/
  1409.                                 
  1410.                                 String attributeAuthorityName = null;
  1411.                                 String attributeName = null;
  1412.                                 boolean findAttribute = false;
  1413.                                 Object valueAttributeObject = null; 
  1414.                                 
  1415.                                 // verifica presenza claim nel token
  1416.                                 log.debug("Verifico presenza '"+key+"' nel token ...");
  1417.                                 if(!informazioniTokenNormalizzate.getClaims().containsKey(key)) {
  1418.                                     
  1419.                                     if(key.startsWith(ATTRIBUTE_AUTHORITY_PREFIX) && key.length()>ATTRIBUTE_AUTHORITY_PREFIX.length()) {
  1420.                                         String tmp = key.substring(ATTRIBUTE_AUTHORITY_PREFIX.length());
  1421.                                         //System.out.println("DEBUG ["+tmp+"]");
  1422.                                         if(tmp!=null && tmp.contains(".")) {
  1423.                                             int indexOf = tmp.indexOf(".");
  1424.                                             if(indexOf>0 && indexOf<tmp.length()) {
  1425.                                                 attributeAuthorityName = tmp.substring(0, indexOf);
  1426.                                                 tmp = tmp.substring(indexOf);
  1427.                                                 //System.out.println("DEBUG attributeAuthorityName["+attributeAuthorityName+"] tmp["+tmp+"]");
  1428.                                                 if(tmp.startsWith(("."+ATTRIBUTE_PREFIX)) && tmp.length()>("."+ATTRIBUTE_PREFIX).length()) {
  1429.                                                     indexOf = tmp.indexOf(".",1); // ho appurato che iniza con '.'
  1430.                                                     if(indexOf>0 && indexOf<tmp.length()) {
  1431.                                                         attributeName = tmp.substring(indexOf);
  1432.                                                         if(attributeName.startsWith(".") && attributeName.length()>1) {
  1433.                                                             attributeName = attributeName.substring(1);
  1434.                                                         }
  1435.                                                         //System.out.println("DEBUG attributeName["+attributeName+"]");
  1436.                                                     }
  1437.                                                 }
  1438.                                             }
  1439.                                         }
  1440.                                     }
  1441.                                     else if(key.startsWith(ATTRIBUTE_PREFIX) && key.length()>ATTRIBUTE_PREFIX.length()) {
  1442.                                         attributeName = key.substring(ATTRIBUTE_PREFIX.length());
  1443.                                     }
  1444.                                     
  1445.                                     if(attributeAuthorityName!=null && attributeName!=null) {
  1446.                                         if(informazioniTokenNormalizzate.getAa()!=null && 
  1447.                                                 informazioniTokenNormalizzate.getAa().isMultipleAttributeAuthorities()!=null &&
  1448.                                                 informazioniTokenNormalizzate.getAa().isMultipleAttributeAuthorities().getValue()!=null &&
  1449.                                                 informazioniTokenNormalizzate.getAa().isMultipleAttributeAuthorities().getValue().booleanValue() &&
  1450.                                                 informazioniTokenNormalizzate.getAa().getAttributes()!=null && 
  1451.                                                 informazioniTokenNormalizzate.getAa().getAttributes().containsKey(attributeAuthorityName)) {
  1452.                                             Object o = informazioniTokenNormalizzate.getAa().getAttributes().get(attributeAuthorityName);
  1453.                                             if(o instanceof Map) {
  1454.                                                 @SuppressWarnings("unchecked")
  1455.                                                 Map<String, Object> map = (Map<String, Object>) o;
  1456.                                                 if(map.containsKey(attributeName)) {
  1457.                                                     findAttribute = true;
  1458.                                                     valueAttributeObject = map.get(attributeName);
  1459.                                                 }
  1460.                                             }
  1461.                                         }
  1462.                                     }
  1463.                                     else if(attributeName!=null) {
  1464.                                         if(informazioniTokenNormalizzate.getAa()!=null && 
  1465.                                                 (
  1466.                                                         informazioniTokenNormalizzate.getAa().isMultipleAttributeAuthorities()==null || 
  1467.                                                         informazioniTokenNormalizzate.getAa().isMultipleAttributeAuthorities().getValue()==null || 
  1468.                                                         !informazioniTokenNormalizzate.getAa().isMultipleAttributeAuthorities().getValue()
  1469.                                                 ) &&
  1470.                                                 informazioniTokenNormalizzate.getAa().getAttributes()!=null && 
  1471.                                                 informazioniTokenNormalizzate.getAa().getAttributes().containsKey(attributeName)) {
  1472.                                             findAttribute = true;
  1473.                                             valueAttributeObject = informazioniTokenNormalizzate.getAa().getAttributes().get(attributeName);
  1474.                                         }
  1475.                                     }
  1476.                                     
  1477.                                     if(!findAttribute) {
  1478.                                         if(CostantiAutorizzazione.AUTHZ_UNDEFINED.equalsIgnoreCase(expectedValue)) {
  1479.                                             continue;
  1480.                                         }
  1481.                                         autorizzato = false;
  1482.                                         if(attributeName!=null) {
  1483.                                             errorMessage = "Token without attribute '"+key+"'";
  1484.                                         }
  1485.                                         else {
  1486.                                             errorMessage = "Token without claim '"+key+"'";
  1487.                                         }
  1488.                                         break;
  1489.                                     }
  1490.                                 }
  1491.                                 
  1492.                                 List<String> lClaimValues =null;
  1493.                                 if(findAttribute && valueAttributeObject!=null) {
  1494.                                     lClaimValues = TokenUtilities.getClaimValues(valueAttributeObject);
  1495.                                 }
  1496.                                 else {
  1497.                                     Object valueClaimObject = informazioniTokenNormalizzate.getClaims().get(key);
  1498.                                     lClaimValues = TokenUtilities.getClaimValues(valueClaimObject);
  1499.                                 }
  1500.                                 String nomeClaimAttribute = (attributeName!=null) ? attributeName : key;
  1501.                                 if(lClaimValues==null || lClaimValues.isEmpty()) {
  1502.                                     if(CostantiAutorizzazione.AUTHZ_UNDEFINED.equalsIgnoreCase(expectedValue)) {
  1503.                                         continue;
  1504.                                     }
  1505.                                     autorizzato = false;
  1506.                                     if(attributeName!=null) {
  1507.                                         errorMessage = "Token with attribute '"+nomeClaimAttribute+"' without value";
  1508.                                     }
  1509.                                     else {
  1510.                                         errorMessage = "Token with claim '"+nomeClaimAttribute+"' without value";
  1511.                                     }
  1512.                                     break;
  1513.                                 }
  1514.                                 
  1515.                                 // verifica valore atteso per il claim
  1516.                                 String object = (attributeName!=null) ? "Attribute" : "Claim";
  1517.                                 log.debug("Verifico valore '"+expectedValue+"' per "+object.toLowerCase()+" '"+nomeClaimAttribute+"' nel token ...");
  1518.                                 if(expectedValue==null) {
  1519.                                     throw new Exception(object+" '"+nomeClaimAttribute+"' without expected value");
  1520.                                 }
  1521.                                 expectedValue = expectedValue.trim();
  1522.                                 
  1523.                                 if(CostantiAutorizzazione.AUTHZ_ANY_VALUE.equalsIgnoreCase(expectedValue)) {
  1524.                                     
  1525.                                     /** ANY VALUE */
  1526.                                     
  1527.                                     log.debug("Verifico valore "+object.toLowerCase()+" '"+nomeClaimAttribute+"' che non sia null e non sia vuoto ...");
  1528.                                     
  1529.                                     // basta che abbia un valore not null
  1530.                                     boolean ok = false;
  1531.                                     for (String v : lClaimValues) {
  1532.                                         if(v!=null && !"".equals(v)) {
  1533.                                             ok = true;
  1534.                                             break;
  1535.                                         }
  1536.                                     }
  1537.                                     if(!ok) {
  1538.                                         autorizzato = false;
  1539.                                         errorMessage = "Token "+object.toLowerCase()+" '"+nomeClaimAttribute+"' with unexpected empty value";
  1540.                                         break;
  1541.                                     }
  1542.                                 }
  1543.                                 else if(CostantiAutorizzazione.AUTHZ_UNDEFINED.equalsIgnoreCase(expectedValue)) { 
  1544.                                     
  1545.                                     /** NOT PRESENT */
  1546.                                     
  1547.                                     log.debug("Verifico valore "+object.toLowerCase()+" '"+nomeClaimAttribute+"' sia null o sia vuoto ...");
  1548.                                     
  1549.                                     // basta che abbia un valore
  1550.                                     boolean ok = false;
  1551.                                     for (String v : lClaimValues) {
  1552.                                         if(v!=null && !"".equals(v)) {
  1553.                                             ok = true;
  1554.                                             break;
  1555.                                         }
  1556.                                     }
  1557.                                     if(ok) {
  1558.                                         autorizzato = false;
  1559.                                         errorMessage = "Token unexpected "+object.toLowerCase()+" '"+nomeClaimAttribute+"'";
  1560.                                         break;
  1561.                                     }
  1562.                                     
  1563.                                 }
  1564.                                 else if(
  1565.                                         (
  1566.                                                 expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_MATCH_PREFIX.toLowerCase())
  1567.                                                 ||
  1568.                                                 expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_FIND_PREFIX.toLowerCase())
  1569.                                                 ||
  1570.                                                 expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_NOT_MATCH_PREFIX.toLowerCase())
  1571.                                                 ||
  1572.                                                 expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_NOT_FIND_PREFIX.toLowerCase())
  1573.                                         ) 
  1574.                                         &&
  1575.                                         expectedValue.toLowerCase().endsWith(CostantiAutorizzazione.AUTHZ_REGEXP_SUFFIX.toLowerCase())) {
  1576.                                     
  1577.                                     /** REGULAR EXPRESSION MATCH/FIND */
  1578.                                     
  1579.                                     boolean match = expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_MATCH_PREFIX.toLowerCase())
  1580.                                             ||
  1581.                                             expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_NOT_MATCH_PREFIX.toLowerCase());
  1582.                                     boolean not = expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_NOT_MATCH_PREFIX.toLowerCase())
  1583.                                             ||
  1584.                                             expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_NOT_FIND_PREFIX.toLowerCase());
  1585.                                     String regexpPattern = null;
  1586.                                     if(match) {
  1587.                                         int length = -1;
  1588.                                         if(expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_MATCH_PREFIX.toLowerCase())) {
  1589.                                             length = CostantiAutorizzazione.AUTHZ_REGEXP_MATCH_PREFIX.length();
  1590.                                         }
  1591.                                         else {
  1592.                                             length = CostantiAutorizzazione.AUTHZ_REGEXP_NOT_MATCH_PREFIX.length();
  1593.                                         }
  1594.                                         if(expectedValue.length()<= (length+CostantiAutorizzazione.AUTHZ_REGEXP_SUFFIX.length()) ) {
  1595.                                             throw new Exception(object+" '"+nomeClaimAttribute+"' without expected regexp match");
  1596.                                         }
  1597.                                         regexpPattern = expectedValue.substring(length, (expectedValue.length()-CostantiAutorizzazione.AUTHZ_REGEXP_SUFFIX.length()));
  1598.                                     }
  1599.                                     else {
  1600.                                         int length = -1;
  1601.                                         if(expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_REGEXP_FIND_PREFIX.toLowerCase())) {
  1602.                                             length = CostantiAutorizzazione.AUTHZ_REGEXP_FIND_PREFIX.length();
  1603.                                         }
  1604.                                         else {
  1605.                                             length = CostantiAutorizzazione.AUTHZ_REGEXP_NOT_FIND_PREFIX.length();
  1606.                                         }
  1607.                                         if(expectedValue.length()<= (length+CostantiAutorizzazione.AUTHZ_REGEXP_SUFFIX.length()) ) {
  1608.                                             throw new Exception(object+" '"+nomeClaimAttribute+"' without expected regexp find");
  1609.                                         }
  1610.                                         regexpPattern = expectedValue.substring(length, (expectedValue.length()-CostantiAutorizzazione.AUTHZ_REGEXP_SUFFIX.length()));
  1611.                                     }
  1612.                                     regexpPattern = regexpPattern.trim();
  1613.                                     log.debug("Verifico valore del "+object.toLowerCase()+" '"+nomeClaimAttribute+"' tramite espressione regolare (match:"+match+") '"+regexpPattern+"' ...");
  1614.                                     
  1615.                                     // basta che un valore abbia match
  1616.                                     boolean ok = false;
  1617.                                     for (String v : lClaimValues) {
  1618.                                         if( match ? RegularExpressionEngine.isMatch(v, regexpPattern) : RegularExpressionEngine.isFind(v, regexpPattern)) {
  1619.                                             ok = true;
  1620.                                             break;
  1621.                                         }
  1622.                                     }
  1623.                                     if(not) {
  1624.                                         if(ok) {
  1625.                                             autorizzato = false;
  1626.                                             String tipo = match ? "match" : "find";
  1627.                                             errorMessage = "Token "+object.toLowerCase()+" '"+nomeClaimAttribute+"' with unexpected value (regExpr not "+tipo+" failed)";
  1628.                                             break;
  1629.                                         }
  1630.                                     }
  1631.                                     else {
  1632.                                         if(!ok) {
  1633.                                             autorizzato = false;
  1634.                                             String tipo = match ? "match" : "find";
  1635.                                             errorMessage = "Token "+object.toLowerCase()+" '"+nomeClaimAttribute+"' with unexpected value (regExpr "+tipo+" failed)";
  1636.                                             break;
  1637.                                         }
  1638.                                     }
  1639.                                     
  1640.                                 }
  1641.                                 else {
  1642.                                 
  1643.                                     /** VALUE (con PLACEHOLDERS) */
  1644.                                     
  1645.                                     boolean not = false;
  1646.                                     if(
  1647.                                             expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_NOT_PREFIX.toLowerCase())
  1648.                                             &&
  1649.                                             expectedValue.toLowerCase().endsWith(CostantiAutorizzazione.AUTHZ_NOT_SUFFIX.toLowerCase())) {
  1650.                                         not = true;
  1651.                                         if(expectedValue.length()<= (CostantiAutorizzazione.AUTHZ_NOT_PREFIX.length()+CostantiAutorizzazione.AUTHZ_NOT_SUFFIX.length()) ) {
  1652.                                             throw new Exception(object+" '"+nomeClaimAttribute+"' without value in not condition");
  1653.                                         }
  1654.                                         expectedValue = expectedValue.substring(CostantiAutorizzazione.AUTHZ_NOT_PREFIX.length(), (expectedValue.length()-CostantiAutorizzazione.AUTHZ_NOT_SUFFIX.length()));
  1655.                                     }
  1656.                                     
  1657.                                     boolean ignoreCase = false;
  1658.                                     if(
  1659.                                             expectedValue.toLowerCase().startsWith(CostantiAutorizzazione.AUTHZ_IGNORE_CASE_PREFIX.toLowerCase())
  1660.                                             &&
  1661.                                             expectedValue.toLowerCase().endsWith(CostantiAutorizzazione.AUTHZ_IGNORE_CASE_SUFFIX.toLowerCase())) {
  1662.                                         ignoreCase = true;
  1663.                                         if(expectedValue.length()<= (CostantiAutorizzazione.AUTHZ_IGNORE_CASE_PREFIX.length()+CostantiAutorizzazione.AUTHZ_IGNORE_CASE_SUFFIX.length()) ) {
  1664.                                             throw new Exception(object+" '"+nomeClaimAttribute+"' without value in ignore case condition");
  1665.                                         }
  1666.                                         expectedValue = expectedValue.substring(CostantiAutorizzazione.AUTHZ_IGNORE_CASE_PREFIX.length(), (expectedValue.length()-CostantiAutorizzazione.AUTHZ_IGNORE_CASE_SUFFIX.length()));
  1667.                                     }
  1668.                                     
  1669.                                     try {
  1670.                                         expectedValue = DynamicUtils.convertDynamicPropertyValue(key, expectedValue, dynamicMap, pddContext);
  1671.                                     }catch(Exception e) {
  1672.                                         String msg = "Conversione valore per "+object.toLowerCase()+" '"+nomeClaimAttribute+"' non riuscita (valore: "+expectedValue+"): "+e.getMessage();
  1673.                                         //throw new Exception(msg,e);
  1674.                                         log.error(msg, e);
  1675.                                         autorizzato = false;
  1676.                                         errorMessage = "Token "+object.toLowerCase()+" '"+nomeClaimAttribute+"' not verifiable; unprocessable dynamic value '"+expectedValue+"': "+e.getMessage();
  1677.                                         break;
  1678.                                     }
  1679.                                     
  1680.                                     boolean ok = false;
  1681.                                     if(expectedValue.contains(",")) {
  1682.                                         String [] values = expectedValue.split(",");
  1683.                                         ok = false;
  1684.                                         for (int i = 0; i < values.length; i++) {
  1685.                                             String v = values[i].trim();
  1686.                                             if(ignoreCase) {
  1687.                                                 boolean find = false;
  1688.                                                 for (String claim : lClaimValues) {
  1689.                                                     if(claim.equalsIgnoreCase(v)) {
  1690.                                                         find = true;
  1691.                                                         break;
  1692.                                                     }   
  1693.                                                 }
  1694.                                                 if(find) {
  1695.                                                     ok = true;
  1696.                                                     break;
  1697.                                                 }
  1698.                                             }
  1699.                                             else {
  1700.                                                 if(lClaimValues.contains(v)) {
  1701.                                                     ok = true;
  1702.                                                     break;
  1703.                                                 }
  1704.                                             }
  1705.                                         }
  1706.                                     }
  1707.                                     else {
  1708.                                         if(ignoreCase) {
  1709.                                             boolean find = false;
  1710.                                             for (String claim : lClaimValues) {
  1711.                                                 if(claim.equalsIgnoreCase(expectedValue)) {
  1712.                                                     find = true;
  1713.                                                     break;
  1714.                                                 }   
  1715.                                             }
  1716.                                             ok = find;
  1717.                                         }
  1718.                                         else {
  1719.                                             ok = lClaimValues.contains(expectedValue);
  1720.                                         }
  1721.                                     }
  1722.                                     
  1723.                                     if(not) {
  1724.                                         if(ok) {
  1725.                                             autorizzato = false;
  1726.                                             errorMessage = "Token "+object.toLowerCase()+" '"+nomeClaimAttribute+"' with unauthorized value";
  1727.                                             break;
  1728.                                         }
  1729.                                     }
  1730.                                     else {
  1731.                                         if(!ok) {
  1732.                                             autorizzato = false;
  1733.                                             errorMessage = "Token "+object.toLowerCase()+" '"+nomeClaimAttribute+"' with unexpected value";
  1734.                                             break;
  1735.                                         }
  1736.                                     }
  1737.                                 }
  1738.                             }
  1739.                         }
  1740.                     }
  1741.                 }
  1742.             }
  1743.             
  1744.         }
  1745.         
  1746.         if(!autorizzato) {
  1747.             
  1748.             String realm = "GovWay";
  1749.             Object oRealm = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_REALM);
  1750.             if(oRealm!=null) {
  1751.                 realm = (String) oRealm;
  1752.             }
  1753.             
  1754.             boolean emptyMessage = false;
  1755.             Object oEmptyMessage = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_MESSAGE_ERROR_BODY_EMPTY);
  1756.             if(oEmptyMessage!=null) {
  1757.                 emptyMessage = (Boolean) oEmptyMessage;
  1758.             }
  1759.             
  1760.             boolean genericMessage = false;
  1761.             Object oGenericMessage = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_MESSAGE_ERROR_GENERIC_MESSAGE);
  1762.             if(oGenericMessage!=null) {
  1763.                 genericMessage = (Boolean) oGenericMessage;
  1764.             }
  1765.             
  1766.             if(genericMessage) {
  1767.                 esito.setDetails(errorMessage);
  1768.             }
  1769.             
  1770.             esito.setAutorizzato(false);
  1771.             if(emptyMessage) {
  1772.                 esito.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.insufficient_scope, realm, genericMessage, errorMessage));
  1773.             }
  1774.             else {
  1775.                 esito.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.insufficient_scope, realm, genericMessage, errorMessage));
  1776.             }
  1777.         }
  1778.         
  1779.         
  1780.         return esito;
  1781.     }
  1782.     
  1783.     
  1784.     
  1785.     
  1786.     
  1787.     
  1788.     
  1789.     /*----------------- AUTORIZZAZIONE CONTENUTO --------------------*/
  1790.     

  1792.     // NOTA: le chiamate ad autorizzazione per contenuto possono essere cachate solamente se viene definito un suffix, 
  1793.     //       poiche' altrimenti variano sempre i contenuti e non finiscono nella chiave di cache.
  1794.     public static EsitoAutorizzazionePortaDelegata verificaAutorizzazioneContenutoPortaDelegata(String tipoAutorizzazione, DatiInvocazionePortaDelegata datiInvocazione,
  1795.               PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg, Logger log) throws Exception{
  1796.         
  1797.         checkDatiPortaDelegataAuthContenuto(datiInvocazione, msg);
  1798.         
  1799.         EsitoAutorizzazionePortaDelegata esito = _verificaAutorizzazioneContenutoPortaDelegata(tipoAutorizzazione, datiInvocazione, pddContext, protocolFactory, msg);
  1800.         if(esito.isAutorizzato()==false) {
  1801.             return esito;
  1802.         }
  1803.         
  1804.         return esito;
  1805.         
  1806.     }
  1807.     
  1808.     private static EsitoAutorizzazionePortaDelegata _verificaAutorizzazioneContenutoPortaDelegata(String tipoAutorizzazione, DatiInvocazionePortaDelegata datiInvocazione,
  1809.           PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  1810.         
  1811.         IAutorizzazioneContenutoPortaDelegata auth = newInstanceAuthContenutoPortaDelegata(tipoAutorizzazione, pddContext, protocolFactory);
  1812.         
  1813.         try {
  1814.             if(GestoreAutorizzazione.cacheAutorizzazione==null || !auth.saveAuthorizationResultInCache()){
  1815.                 return auth.process(datiInvocazione, msg);
  1816.             }
  1817.             else{
  1818.                 String keyCache = buildCacheKeyContenuto(true, tipoAutorizzazione, datiInvocazione.getKeyCache(), auth.getSuffixKeyAuthorizationResultInCache(datiInvocazione, msg) );
  1819.     
  1820.                 // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1821.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1822.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  1823.                 if(response != null){
  1824.                     if(response.getObject()!=null){
  1825.                         GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  1826.                         EsitoAutorizzazionePortaDelegata esito = (EsitoAutorizzazionePortaDelegata) response.getObject();
  1827.                         esito.setEsitoPresenteInCache(true);
  1828.                         return esito;
  1829.                     }else if(response.getException()!=null){
  1830.                         GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  1831.                         throw (Exception) response.getException();
  1832.                     }else{
  1833.                         GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1834.                     }
  1835.                 }
  1836.                                 
  1837.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1838.                 //synchronized (GestoreAutorizzazione.semaphoreAutorizzazioneContenutiPD) {
  1839.                 org.openspcoop2.utils.Semaphore lockAutorizzazioneContenutiPD = getLockAutorizzazioneContenutiPD(tipoAutorizzazione);
  1840.                 SemaphoreLock lock = lockAutorizzazioneContenutiPD.acquire("verificaAutorizzazioneContenutoPortaDelegata", idTransazione);
  1841.                 try {
  1842.                     
  1843.                     response = 
  1844.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  1845.                     if(response != null){
  1846.                         if(response.getObject()!=null){
  1847.                             GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  1848.                             EsitoAutorizzazionePortaDelegata esito = (EsitoAutorizzazionePortaDelegata) response.getObject();
  1849.                             esito.setEsitoPresenteInCache(true);
  1850.                             return esito;
  1851.                         }else if(response.getException()!=null){
  1852.                             GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) in cache.");
  1853.                             throw (Exception) response.getException();
  1854.                         }else{
  1855.                             GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1856.                         }
  1857.                     }
  1858.     
  1859.                     // Effettuo la query
  1860.                     GestoreAutorizzazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaDelegata) ricerco nella configurazione...");
  1861.                     EsitoAutorizzazionePortaDelegata esito = auth.process(datiInvocazione, msg);
  1862.     
  1863.                     // Aggiungo la risposta in cache (se esiste una cache)  
  1864.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1865.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1866.                     // - impostare il noCache a true
  1867.                     if(esito!=null){
  1868.                         if(!esito.isNoCache()){
  1869.                             GestoreAutorizzazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  1870.                             try{    
  1871.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1872.                                 responseCache.setObject(esito);
  1873.                                 GestoreAutorizzazione.cacheAutorizzazione.put(keyCache,responseCache);
  1874.                             }catch(UtilsException e){
  1875.                                 GestoreAutorizzazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  1876.                             }
  1877.                         }
  1878.                         return esito;
  1879.                     }else{
  1880.                         throw new AutorizzazioneException("Metodo (GestoreAutorizzazione.autorizzazionePortaDelegata.process) ha ritornato un valore di esito null");
  1881.                     }
  1882.                 }finally {
  1883.                     lockAutorizzazioneContenutiPD.release(lock, "verificaAutorizzazioneContenutoPortaDelegata", idTransazione);
  1884.                 }
  1885.             }
  1886.         }finally {
  1887.             if(msg!=null) {
  1888.                 auth.cleanPostAuth(msg);
  1889.             }
  1890.         }
  1891.     }
  1892.     
  1893.     public static EsitoAutorizzazionePortaApplicativa verificaAutorizzazioneContenutoPortaApplicativa(String tipoAutorizzazione, DatiInvocazionePortaApplicativa datiInvocazione,
  1894.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg, Logger log) throws Exception{
  1895.           
  1896.         checkDatiPortaApplicativaAuthContenuto(datiInvocazione, msg);
  1897.     
  1898.         EsitoAutorizzazionePortaApplicativa esito = _verificaAutorizzazioneContenutoPortaApplicativa(tipoAutorizzazione, datiInvocazione, pddContext, protocolFactory, msg);
  1899.         if(esito.isAutorizzato()==false) {
  1900.             return esito;
  1901.         }
  1902.         
  1903.         return esito;
  1904.         
  1905.     }
  1906.     private static EsitoAutorizzazionePortaApplicativa _verificaAutorizzazioneContenutoPortaApplicativa(String tipoAutorizzazione, DatiInvocazionePortaApplicativa datiInvocazione,
  1907.             PdDContext pddContext,IProtocolFactory<?> protocolFactory, OpenSPCoop2Message msg) throws Exception{
  1908.         
  1909.         IAutorizzazioneContenutoPortaApplicativa auth = newInstanceAuthContenutoPortaApplicativa(tipoAutorizzazione, pddContext, protocolFactory);
  1910.         
  1911.         try {
  1912.             if(GestoreAutorizzazione.cacheAutorizzazione==null || !auth.saveAuthorizationResultInCache()){
  1913.                 return auth.process(datiInvocazione, msg);
  1914.             }
  1915.             else{
  1916.                 String keyCache = buildCacheKeyContenuto(false, tipoAutorizzazione, datiInvocazione.getKeyCache(), auth.getSuffixKeyAuthorizationResultInCache(datiInvocazione, msg));
  1917.     
  1918.                 // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1919.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1920.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  1921.                 if(response != null){
  1922.                     if(response.getObject()!=null){
  1923.                         GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1924.                         EsitoAutorizzazionePortaApplicativa esito = (EsitoAutorizzazionePortaApplicativa) response.getObject();
  1925.                         esito.setEsitoPresenteInCache(true);
  1926.                         return esito;
  1927.                     }else if(response.getException()!=null){
  1928.                         GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1929.                         throw (Exception) response.getException();
  1930.                     }else{
  1931.                         GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1932.                     }
  1933.                 }
  1934.                 
  1935.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1936.                 //synchronized (GestoreAutorizzazione.semaphoreAutorizzazioneContenutiPA) {
  1937.                 org.openspcoop2.utils.Semaphore lockAutorizzazioneContenutiPA = getLockAutorizzazioneContenutiPA(tipoAutorizzazione);
  1938.                 SemaphoreLock lock = lockAutorizzazioneContenutiPA.acquire("verificaAutorizzazioneContenutoPortaApplicativa", idTransazione);
  1939.                 try {
  1940.                     
  1941.                     response = 
  1942.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreAutorizzazione.cacheAutorizzazione.get(keyCache);
  1943.                     if(response != null){
  1944.                         if(response.getObject()!=null){
  1945.                             GestoreAutorizzazione.logger.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1946.                             EsitoAutorizzazionePortaApplicativa esito = (EsitoAutorizzazionePortaApplicativa) response.getObject();
  1947.                             esito.setEsitoPresenteInCache(true);
  1948.                             return esito;
  1949.                         }else if(response.getException()!=null){
  1950.                             GestoreAutorizzazione.logger.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) in cache.");
  1951.                             throw (Exception) response.getException();
  1952.                         }else{
  1953.                             GestoreAutorizzazione.logger.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1954.                         }
  1955.                     }
  1956.     
  1957.                     // Effettuo la query
  1958.                     GestoreAutorizzazione.logger.debug("oggetto con chiave ["+keyCache+"] (method:verificaAutorizzazionePortaApplicativa) ricerco nella configurazione...");
  1959.                     EsitoAutorizzazionePortaApplicativa esito = auth.process(datiInvocazione, msg);
  1960.     
  1961.                     // Aggiungo la risposta in cache (se esiste una cache)  
  1962.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1963.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1964.                     // - impostare il noCache a true
  1965.                     if(esito!=null){
  1966.                         if(!esito.isNoCache()){
  1967.                             GestoreAutorizzazione.logger.info("Aggiungo oggetto ["+keyCache+"] in cache");
  1968.                             try{    
  1969.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1970.                                 responseCache.setObject(esito);
  1971.                                 GestoreAutorizzazione.cacheAutorizzazione.put(keyCache,responseCache);
  1972.                             }catch(UtilsException e){
  1973.                                 GestoreAutorizzazione.logger.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  1974.                             }
  1975.                         }
  1976.                         return esito;
  1977.                     }else{
  1978.                         throw new AutorizzazioneException("Metodo (GestoreAutorizzazione.autorizzazionePortaApplicativa.process) ha ritornato un valore di esito null");
  1979.                     }
  1980.                 }finally {
  1981.                     lockAutorizzazioneContenutiPA.release(lock, "verificaAutorizzazioneContenutoPortaApplicativa", idTransazione);
  1982.                 }
  1983.             }
  1984.         }finally {
  1985.             if(msg!=null) {
  1986.                 auth.cleanPostAuth(msg);
  1987.             }
  1988.         }
  1989.     }
  1990.     
  1991.     private static void checkDatiPortaDelegataAuthContenuto(DatiInvocazionePortaDelegata datiInvocazione, OpenSPCoop2Message msg) throws AutorizzazioneException{
  1992.         
  1993.         checkDatiPortaDelegata(datiInvocazione);
  1994.         
  1995.     }
  1996.     
  1997.     private static void checkDatiPortaApplicativaAuthContenuto(DatiInvocazionePortaApplicativa datiInvocazione, OpenSPCoop2Message msg) throws AutorizzazioneException{
  1998.         
  1999.         checkDatiPortaApplicativa(datiInvocazione);
  2000.         
  2001.     }
  2002.     
  2003.     private static String buildCacheKeyContenuto(boolean portaDelegata, String tipoAutorizzazione, String keyCache, String suffixKeyCache) throws AutorizzazioneException{
  2004.         StringBuilder bf = new StringBuilder();
  2005.         
  2006.         if(portaDelegata)
  2007.             bf.append("PD ");
  2008.         else
  2009.             bf.append("PA ");
  2010.         
  2011.         bf.append(" AuthContenuti:").append(tipoAutorizzazione).append(" ");
  2012.         
  2013.         bf.append(keyCache);
  2014.         
  2015.         if(suffixKeyCache!=null && !"".equals(suffixKeyCache)){
  2016.             bf.append(" ");
  2017.             bf.append(suffixKeyCache);
  2018.         }
  2019.         else {
  2020.             throw new AutorizzazioneException("Per salvare in cache l'esito dell'autorizzazione sui contenuti è richiesta la definizione di un suffisso per la chiave");
  2021.         }
  2022.         
  2023.         return bf.toString();
  2024.     }
  2025.     
  2026.     private static IAutorizzazioneContenutoPortaDelegata newInstanceAuthContenutoPortaDelegata(String tipoAutorizzazione,PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws AutorizzazioneException{
  2027.         IAutorizzazioneContenutoPortaDelegata auth = null;
  2028.         try{
  2029.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2030.             auth = (IAutorizzazioneContenutoPortaDelegata) pluginLoader.newAutorizzazioneContenutiPortaDelegata(tipoAutorizzazione);
  2031.         }catch(Exception e){
  2032.             throw new AutorizzazioneException(e.getMessage(),e); // descrizione errore già corretta
  2033.         }
  2034.         String classType = null; 
  2035.         try{
  2036.             classType = auth.getClass().getName();
  2037.             AbstractCore.init(auth, pddContext, protocolFactory);
  2038.             return auth;
  2039.         }catch(Exception e){
  2040.             throw new AutorizzazioneException("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  2041.                     "] che definisce l'autorizzazione dei contenuti della fruizione: "+e.getMessage(),e);
  2042.         }
  2043.     }
  2044.     
  2045.     private static IAutorizzazioneContenutoPortaApplicativa newInstanceAuthContenutoPortaApplicativa(String tipoAutorizzazione,PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws AutorizzazioneException{
  2046.         IAutorizzazioneContenutoPortaApplicativa auth = null;
  2047.         try{
  2048.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2049.             auth = (IAutorizzazioneContenutoPortaApplicativa) pluginLoader.newAutorizzazioneContenutiPortaApplicativa(tipoAutorizzazione);
  2050.         }catch(Exception e){
  2051.             throw new AutorizzazioneException(e.getMessage(),e); // descrizione errore già corretta
  2052.         }
  2053.         String classType = null; 
  2054.         try{
  2055.             classType = auth.getClass().getName();
  2056.             AbstractCore.init(auth, pddContext, protocolFactory);
  2057.             return auth;
  2058.         }catch(Exception e){
  2059.             throw new AutorizzazioneException("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  2060.                     "] che definisce l'autorizzazione dei contenuti della erogazione: "+e.getMessage(),e);
  2061.         }
  2062.     }
  2063. }
Created with JaCoCo 0.8.8.202204050719